Crypt::DSA::Key - phpMan

NAME
    Crypt::DSA::Key - DSA key

SYNOPSIS
        use Crypt::DSA::Key;
        my $key = Crypt::DSA::Key->new;

        $key->p($p);

DESCRIPTION
    *Crypt::DSA::Key* contains a DSA key, both the public and private
    portions. Subclasses of *Crypt::DSA::Key* implement *read* and *write*
    methods, such that you can store DSA keys on disk, and read them back
    into your application.

USAGE
    Any of the key attributes can be accessed through combination get/set
    methods. The key attributes are: *p*, *q*, *g*, *priv_key*, and
    *pub_key*. For example:

        $key->p($p);
        my $p2 = $key->p;

  $key = Crypt::DSA::Key->new(%arg)
    Creates a new (empty) key object. All of the attributes are initialized
    to 0.

    Alternately, if you provide the *Filename* parameter (see below), the
    key will be read in from disk. If you provide the *Type* parameter
    (mandatory if *Filename* is provided), be aware that your key will
    actually be blessed into a subclass of *Crypt::DSA::Key*. Specifically,
    it will be the class implementing the specific read functionality for
    that type, eg. *Crypt::DSA::Key::PEM*.

    Returns the key on success, "undef" otherwise. (See *Password* for one
    reason why *new* might return "undef").

    *%arg* can contain:

    *   Type

        The type of file where the key is stored. Currently the only option
        is *PEM*, which indicates a PEM file (optionally encrypted,
        ASN.1-encoded object). Support for reading/writing PEM files comes
        from *Convert::PEM*; if you don't have this module installed, the
        *new* method will die.

        This argument is mandatory, *if* you're either reading the file from
        disk (ie. you provide a *Filename* argument) or you've specified the
        *Content* argument.

    *   Filename

        The location of the file from which you'd like to read the key.
        Requires a *Type* argument so the decoder knows what type of file it
        is. You can't specify *Content* and *Filename* at the same time.

    *   Content

        The serialized version of the key. Requires a *Type* argument so the
        decoder knows how to decode it. You can't specify *Content* and
        *Filename* at the same time.

    *   Password

        If your key file is encrypted, you'll need to supply a passphrase to
        decrypt it. You can do that here.

        If your passphrase is incorrect, *new* will return "undef".

  $key->write(%arg)
    Writes a key (optionally) to disk, using a format that you define with
    the *Type* parameter.

    If your *$key* object has a defined *priv_key* (private key portion),
    the key will be written as a DSA private key object; otherwise, it will
    be written out as a public key. Note that not all serialization
    mechanisms can produce public keys in this version--currently, only PEM
    public keys are supported.

    *%arg* can include:

    *   Type

        The type of file format that you wish to write. *PEM* is one example
        (in fact, currently, it's the only example).

        This argument is mandatory, *unless* your *$key* object is already
        blessed into a subclass (eg. *Crypt::DSA::Key::PEM*), and you wish
        to write the file using the same subclass.

    *   Filename

        The location of the file on disk where you want the key file to be
        written.

    *   Password

        If you want the key file to be encrypted, provide this argument, and
        the ASN.1-encoded string will be encrypted using the passphrase as a
        key.

  $key->size
    Returns the size of the key, in bits. This is actually the number of
    bits in the large prime *p*.

AUTHOR & COPYRIGHTS
    Please see the Crypt::DSA manpage for author, copyright, and license
    information.