Release history of Convert-PEM
Switch branches/tags
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
lib/Convert
t
xt
.gitignore
Changes
MANIFEST
MANIFEST.SKIP
Makefile.PL
README

README

NAME
    Convert::PEM - Read/write encrypted ASN.1 PEM files

SYNOPSIS
        use Convert::PEM;
        my $pem = Convert::PEM->new(
                       Name => "DSA PRIVATE KEY",
                       ASN => qq(
                           DSAPrivateKey SEQUENCE {
                               version INTEGER,
                               p INTEGER,
                               q INTEGER,
                               g INTEGER,
                               pub_key INTEGER,
                               priv_key INTEGER
                           }
                      ));

        my $keyfile = 'private-key.pem';
        my $pwd = 'foobar';

        my $pkey = $pem->read(
                       Filename => $keyfile,
                       Password => $pwd
                 );

        $pem->write(
                       Content  => $pkey,
                       Password => $pwd,
                       Filename => $keyfile
                 );

DESCRIPTION
    *Convert::PEM* reads and writes PEM files containing ASN.1-encoded
    objects. The files can optionally be encrypted using a symmetric cipher
    algorithm, such as 3DES. An unencrypted PEM file might look something
    like this:

        -----BEGIN DH PARAMETERS-----
        MB4CGQDUoLoCULb9LsYm5+/WN992xxbiLQlEuIsCAQM=
        -----END DH PARAMETERS-----

    The string beginning "MB4C..." is the Base64-encoded, ASN.1-encoded
    "object."

    An encrypted file would have headers describing the type of encryption
    used, and the initialization vector:

        -----BEGIN DH PARAMETERS-----
        Proc-Type: 4,ENCRYPTED
        DEK-Info: DES-EDE3-CBC,C814158661DC1449

        AFAZFbnQNrGjZJ/ZemdVSoZa3HWujxZuvBHzHNoesxeyqqidFvnydA==
        -----END DH PARAMETERS-----

    The two headers ("Proc-Type" and "DEK-Info") indicate information about
    the type of encryption used, and the string starting with "AFAZ..." is
    the Base64-encoded, encrypted, ASN.1-encoded contents of this "object."

    The initialization vector ("C814158661DC1449") is chosen randomly.

USAGE
  $pem = Convert::PEM->new( %arg )
    Constructs a new *Convert::PEM* object designed to read/write an object
    of a specific type (given in *%arg*, see below). Returns the new object
    on success, "undef" on failure (see *ERROR HANDLING* for details).

    *%arg* can contain:

    *   Name

        The name of the object; when decoding a PEM-encoded stream, the name
        in the encoding will be checked against the value of *Name*.
        Similarly, when encoding an object, the value of *Name* will be used
        as the name of the object in the PEM-encoded content. For example,
        given the string "FOO BAR", the output from *encode* will start with
        a header like:

            -----BEGIN FOO BAR-----

        *Name* is a required argument.

    *   ASN

        An ASN.1 description of the content to be either encoded or decoded.

        *ASN* is a required argument.

    *   Macro

        If your ASN.1 description (in the *ASN* parameter) includes more
        than one ASN.1 macro definition, you will want to use the *Macro*
        parameter to specify which definition to use when encoding/decoding
        objects. For example, if your ASN.1 description looks like this:

            Foo ::= SEQUENCE {
                x INTEGER,
                bar Bar
            }

            Bar ::= INTEGER

        If you want to encode/decode a "Foo" object, you will need to tell
        *Convert::PEM* to use the "Foo" macro definition by using the
        *Macro* parameter and setting the value to "Foo".

        *Macro* is an optional argument.

  $obj = $pem->decode(%args)
    Decodes, and, optionally, decrypts a PEM file, returning the object as
    decoded by *Convert::ASN1*. The difference between this method and
    *read* is that *read* reads the contents of a PEM file on disk; this
    method expects you to pass the PEM contents as an argument.

    If an error occurs while reading the file or decrypting/decoding the
    contents, the function returns *undef*, and you should check the error
    message using the *errstr* method (below).

    *%args* can contain:

    *   Content

        The PEM contents.

    *   Password

        The password with which the file contents were encrypted.

        If the file is encrypted, this is a mandatory argument (well, it's
        not strictly mandatory, but decryption isn't going to work without
        it). Otherwise it's not necessary.

  $blob = $pem->encode(%args)
    Constructs the contents for the PEM file from an object: ASN.1-encodes
    the object, optionally encrypts those contents.

    Returns *undef* on failure (encryption failure, file-writing failure,
    etc.); in this case you should check the error message using the
    *errstr* method (below). On success returns the constructed PEM string.

    *%args* can contain:

    *   Content

        A hash reference that will be passed to *Convert::ASN1::encode*, and
        which should correspond to the ASN.1 description you gave to the
        *new* method. The hash reference should have the exact same format
        as that returned from the *read* method.

        This argument is mandatory.

    *   Password

        A password used to encrypt the contents of the PEM file. This is an
        optional argument; if not provided the contents will be unencrypted.

  $obj = $pem->read(%args)
    Reads, decodes, and, optionally, decrypts a PEM file, returning the
    object as decoded by *Convert::ASN1*. This is implemented as a wrapper
    around *decode*, with the bonus of reading the PEM file from disk for
    you.

    If an error occurs while reading the file or decrypting/decoding the
    contents, the function returns *undef*, and you should check the error
    message using the *errstr* method (below).

    In addition to the arguments that can be passed to the *decode* method
    (minus the *Content* method), *%args* can contain:

    *   Filename

        The location of the PEM file that you wish to read.

  $pem->write(%args)
    Constructs the contents for the PEM file from an object: ASN.1-encodes
    the object, optionally encrypts those contents; then writes the file to
    disk. This is implemented as a wrapper around *encode*, with the bonus
    of writing the file to disk for you.

    Returns *undef* on failure (encryption failure, file-writing failure,
    etc.); in this case you should check the error message using the
    *errstr* method (below). On success returns the constructed PEM string.

    In addition to the arguments for *encode*, *%args* can contain:

    *   Filename

        The location on disk where you'd like the PEM file written.

  $pem->errstr
    Returns the value of the last error that occurred. This should only be
    considered meaningful when you've received *undef* from one of the
    functions above; in all other cases its relevance is undefined.

  $pem->asn
    Returns the *Convert::ASN1* object used internally to decode and encode
    ASN.1 representations. This is useful when you wish to interact directly
    with that object; for example, if you need to call *configure* on that
    object to set the type of big-integer class to be used when
    decoding/encoding big integers:

        $pem->asn->configure( decode => { bigint => 'Math::Pari' },
                              encode => { bigint => 'Math::Pari' } );

ERROR HANDLING
    If an error occurs in any of the above methods, the method will return
    "undef". You should then call the method *errstr* to determine the
    source of the error:

        $pem->errstr

    In the case that you do not yet have a *Convert::PEM* object (that is,
    if an error occurs while creating a *Convert::PEM* object), the error
    can be obtained as a class method:

        Convert::PEM->errstr

    For example, if you try to decode an encrypted object, and you do not
    give a passphrase to decrypt the object:

        my $obj = $pem->read( Filename => "encrypted.pem" )
            or die "Decryption failed: ", $pem->errstr;

LICENSE
    Convert::PEM is free software; you may redistribute it and/or modify it
    under the same terms as Perl itself.

AUTHOR & COPYRIGHTS
    Except where otherwise noted, Convert::PEM is Copyright Benjamin Trott,
    cpan@stupidfool.org. All rights reserved.