Provided by: libgnupg-interface-perl_1.04-1_all bug

NAME

       GnuPG::Interface - Perl interface to GnuPG

SYNOPSIS

         # A simple example
         use IO::Handle;
         use GnuPG::Interface;

         # setting up the situation
         my $gnupg = GnuPG::Interface->new();
         $gnupg->options->hash_init( armor   => 1,
                                     homedir => '/home/foobar' );

         # Note you can set the recipients even if you aren't encrypting!
         $gnupg->options->push_recipients( 'ftobin@cpan.org' );
         $gnupg->options->meta_interactive( 0 );

         # how we create some handles to interact with GnuPG
         my $input   = IO::Handle->new();
         my $output  = IO::Handle->new();
         my $handles = GnuPG::Handles->new( stdin  => $input,
                                            stdout => $output );

         # Now we'll go about encrypting with the options already set
         my @plaintext = ( 'foobar' );
         my $pid = $gnupg->encrypt( handles => $handles );

         # Now we write to the input of GnuPG
         print $input @plaintext;
         close $input;

         # now we read the output
         my @ciphertext = <$output>;
         close $output;

         waitpid $pid, 0;

DESCRIPTION

       GnuPG::Interface and its associated modules are designed to provide an object-oriented
       method for interacting with GnuPG, being able to perform functions such as but not limited
       to encrypting, signing, decryption, verification, and key-listing parsing.

   How Data Member Accessor Methods are Created
       Each module in the GnuPG::Interface bundle relies on Moo to generate the get/set methods
       used to set the object's data members.  This is very important to realize.  This means
       that any data member which is a list has special methods assigned to it for pushing,
       popping, and clearing the list.

   Understanding Bidirectional Communication
       It is also imperative to realize that this package uses interprocess communication methods
       similar to those used in IPC::Open3 and "Bidirectional Communication with Another Process"
       in perlipc, and that users of this package need to understand how to use this method
       because this package does not abstract these methods for the user greatly.  This package
       is not designed to abstract this away entirely (partly for security purposes), but rather
       to simply help create 'proper', clean calls to GnuPG, and to implement key-listing
       parsing.  Please see "Bidirectional Communication with Another Process" in perlipc to
       learn how to deal with these methods.

       Using this package to do message processing generally invovlves creating a
       GnuPG::Interface object, creating a GnuPG::Handles object, setting some options in its
       options data member, and then calling a method which invokes GnuPG, such as clearsign.
       One then interacts with with the handles appropriately, as described in "Bidirectional
       Communication with Another Process" in perlipc.

GnuPG Versions

       As of this version of GnuPG::Interface, there are three supported versions of GnuPG:
       1.4.x, 2.2.x, and 2.4.x. The GnuPG download page <https://gnupg.org/download/index.html>
       has updated information on the currently supported versions.

       GnuPG released 2.0 and 2.1 versions in the past and some packaging systems may still
       provide these if you install the default "gpg", "gnupg", "gnupg2", etc. packages. 2.0 and
       2.1 versions are not supported, so you may need to find additional package repositories or
       build from source to get the updated version.

OBJECT METHODS

   Initialization Methods
       new( %initialization_args )
           This methods creates a new object.  The optional arguments are initialization of data
           members.

       hash_init( %args ).

   Object Methods which use a GnuPG::Handles Object
       list_public_keys( % )
       list_sigs( % )
       list_secret_keys( % )
       encrypt( % )
       encrypt_symmetrically( % )
       sign( % )
       clearsign( % )
       detach_sign( % )
       sign_and_encrypt( % )
       decrypt( % )
       verify( % )
       import_keys( % )
       export_keys( % )
       recv_keys( % )
       send_keys( % )
       search_keys( % )
           These methods each correspond directly to or are very similar to a GnuPG command
           described in gpg.  Each of these methods takes a hash, which currently must contain a
           key of handles which has the value of a GnuPG::Handles object.  Another optional key
           is command_args which should have the value of an array reference; these arguments
           will be passed to GnuPG as command arguments.  These command arguments are used for
           such things as determining the keys to list in the export_keys method.  Please note
           that GnuPG command arguments are not the same as GnuPG options.  To understand what
           are options and what are command arguments please read "COMMANDS" in gpg and "OPTIONS"
           in gpg.

           Each of these calls returns the PID for the resulting GnuPG process.  One can use this
           PID in a "waitpid" call instead of a "wait" call if more precise process reaping is
           needed.

           These methods will attach the handles specified in the handles object to the running
           GnuPG object, so that bidirectional communication can be established.  That is, the
           optionally-defined stdin, stdout, stderr, status, logger, and passphrase handles will
           be attached to GnuPG's input, output, standard error, the handle created by setting
           status-fd, the handle created by setting logger-fd, and the handle created by setting
           passphrase-fd respectively.  This tying of handles of similar to the process done in
           IPC::Open3.

           If you want the GnuPG process to read or write directly to an already-opened
           filehandle, you cannot do this via the normal IPC::Open3 mechanisms.  In order to
           accomplish this, set the appropriate handles data member to the already-opened
           filehandle, and then set the option direct to be true for that handle, as described in
           "options" in GnuPG::Handles.  For example, to have GnuPG read from the file input.txt
           and write to output.txt, the following snippet may do:

             my $infile  = IO::File->new( 'input.txt' );
             my $outfile = IO::File->new( '>output.txt' );
             my $handles = GnuPG::Handles->new( stdin  => $infile,
                                                stdout => $outfile,
                                              );
             $handles->options( 'stdin'  )->{direct} = 1;
             $handles->options( 'stdout' )->{direct} = 1;

           If any handle in the handles object is not defined, GnuPG's input, output, and
           standard error will be tied to the running program's standard error, standard output,
           or standard error.  If the status or logger handle is not defined, this channel of
           communication is never established with GnuPG, and so this information is not
           generated and does not come into play.

           If the passphrase data member handle of the handles object is not defined, but the the
           passphrase data member handle of GnuPG::Interface object is, GnuPG::Interface will
           handle passing this information into GnuPG for the user as a convenience.  Note that
           this will result in GnuPG::Interface storing the passphrase in memory, instead of
           having it simply 'pass-through' to GnuPG via a handle.

           If neither the passphrase data member of the GnuPG::Interface nor the passphrase data
           member of the handles object is defined, then GnuPG::Interface assumes that access and
           control over the secret key will be handled by the running gpg-agent process.  This
           represents the simplest mode of operation with the GnuPG "stable" suite (version 2.2
           and later).  It is also the preferred mode for tools intended to be user-facing, since
           the user will be prompted directly by gpg-agent for use of the secret key material.
           Note that for programmatic use, this mode requires the gpg-agent and pinentry to
           already be correctly configured.

   Other Methods
       get_public_keys( @search_strings )
       get_secret_keys( @search_strings )
       get_public_keys_with_sigs( @search_strings )
           These methods create and return objects of the type GnuPG::PublicKey or
           GnuPG::SecretKey respectively.  This is done by parsing the output of GnuPG with the
           option with-colons enabled.  The objects created do or do not have signature
           information stored in them, depending if the method ends in _sigs; this separation of
           functionality is there because of performance hits when listing information with
           signatures.

       test_default_key_passphrase()
           This method will return a true or false value, depending on whether GnuPG reports a
           good passphrase was entered while signing a short message using the values of the
           passphrase data member, and the default key specified in the options data member.

       version()
           Returns the version of GnuPG that GnuPG::Interface is running.

Invoking GnuPG with a custom call

       GnuPG::Interface attempts to cover a lot of the commands of GnuPG that one would want to
       perform; however, there may be a lot more calls that GnuPG is and will be capable of, so a
       generic command interface is provided, "wrap_call".

       wrap_call( %args )
           Call GnuPG with a custom command.  The %args hash must contain at least the following
           keys:

           commands
               The value of this key in the hash must be a reference to a a list of commands for
               GnuPG, such as "[ qw( --encrypt --sign ) ]".

           handles
               As with most other GnuPG::Interface methods, handles must be a GnuPG::Handles
               object.

           The following keys are optional.

           command_args
               As with other GnuPG::Interface methods, the value in hash for this key must be a
               reference to a list of arguments to be passed to the GnuPG command, such as which
               keys to list in a key-listing.

OBJECT DATA MEMBERS

       call
           This defines the call made to invoke GnuPG.  Defaults to '/usr/bin/gpg'; this should
           be changed if there is a different name for the binary on your system.

       passphrase
           In order to lessen the burden of using handles by the user of this package, setting
           this option to one's passphrase for a secret key will allow the package to enter the
           passphrase via a handle to GnuPG by itself instead of leaving this to the user.  See
           also "passphrase" in GnuPG::Handles.

       options
           This data member, of the type GnuPG::Options; the setting stored in this data member
           are used to determine the options used when calling GnuPG via any of the object
           methods described in this package.  See GnuPG::Options for more information.

EXAMPLES

       The following setup can be done before any of the following examples:

         use IO::Handle;
         use GnuPG::Interface;

         my @original_plaintext = ( "How do you doo?" );
         my $passphrase = "Three Little Pigs";

         my $gnupg = GnuPG::Interface->new();

         $gnupg->options->hash_init( armor    => 1,
                                     recipients => [ 'ftobin@uiuc.edu',
                                                     '0xABCD1234ABCD1234ABCD1234ABCD1234ABCD1234' ],
                                     meta_interactive => 0 ,
                                   );

          $gnupg->options->debug_level(4);

          $gnupg->options->logger_file("/tmp/gnupg-$$-decrypt-".time().".log");

   Encrypting
         # We'll let the standard error of GnuPG pass through
         # to our own standard error, by not creating
         # a stderr-part of the $handles object.
         my ( $input, $output ) = ( IO::Handle->new(),
                                    IO::Handle->new() );

         my $handles = GnuPG::Handles->new( stdin    => $input,
                                            stdout   => $output );

         # this sets up the communication
         # Note that the recipients were specified earlier
         # in the 'options' data member of the $gnupg object.
         my $pid = $gnupg->encrypt( handles => $handles );

         # this passes in the plaintext
         print $input @original_plaintext;

         # this closes the communication channel,
         # indicating we are done
         close $input;

         my @ciphertext = <$output>;  # reading the output

         waitpid $pid, 0;  # clean up the finished GnuPG process

   Signing
         # This time we'll catch the standard error for our perusing
         my ( $input, $output, $error ) = ( IO::Handle->new(),
                                            IO::Handle->new(),
                                            IO::Handle->new(),
                                          );

         my $handles = GnuPG::Handles->new( stdin    => $input,
                                            stdout   => $output,
                                            stderr   => $error,
                                          );

         # indicate our pasphrase through the
         # convenience method
         $gnupg->passphrase( $passphrase );

         # this sets up the communication
         my $pid = $gnupg->sign( handles => $handles );

         # this passes in the plaintext
         print $input @original_plaintext;

         # this closes the communication channel,
         # indicating we are done
         close $input;

         my @ciphertext   = <$output>;  # reading the output
         my @error_output = <$error>;   # reading the error

         close $output;
         close $error;

         waitpid $pid, 0;  # clean up the finished GnuPG process

   Decryption
         # This time we'll catch the standard error for our perusing
         # as well as passing in the passphrase manually
         # as well as the status information given by GnuPG
         my ( $input, $output, $error, $passphrase_fh, $status_fh )
           = ( IO::Handle->new(),
               IO::Handle->new(),
               IO::Handle->new(),
               IO::Handle->new(),
               IO::Handle->new(),
             );

         my $handles = GnuPG::Handles->new( stdin      => $input,
                                            stdout     => $output,
                                            stderr     => $error,
                                            passphrase => $passphrase_fh,
                                            status     => $status_fh,
                                          );

         # this time we'll also demonstrate decrypting
         # a file written to disk
         # Make sure you "use IO::File" if you use this module!
         my $cipher_file = IO::File->new( 'encrypted.gpg' );

         # this sets up the communication
         my $pid = $gnupg->decrypt( handles => $handles );

         # This passes in the passphrase
         print $passphrase_fh $passphrase;
         close $passphrase_fh;

         # this passes in the plaintext
         print $input $_ while <$cipher_file>;

         # this closes the communication channel,
         # indicating we are done
         close $input;
         close $cipher_file;

         my @plaintext    = <$output>;    # reading the output
         my @error_output = <$error>;     # reading the error
         my @status_info  = <$status_fh>; # read the status info

         # clean up...
         close $output;
         close $error;
         close $status_fh;

         waitpid $pid, 0;  # clean up the finished GnuPG process

   Printing Keys
         # This time we'll just let GnuPG print to our own output
         # and read from our input, because no input is needed!
         my $handles = GnuPG::Handles->new();

         my @ids = ( 'ftobin', '0xABCD1234ABCD1234ABCD1234ABCD1234ABCD1234' );

         # this time we need to specify something for
         # command_args because --list-public-keys takes
         # search ids as arguments
         my $pid = $gnupg->list_public_keys( handles      => $handles,
                                             command_args => [ @ids ] );

          waitpid $pid, 0;

   Creating GnuPG::PublicKey Objects
         my @ids = [ 'ftobin', '0xABCD1234ABCD1234ABCD1234ABCD1234ABCD1234' ];

         my @keys = $gnupg->get_public_keys( @ids );

         # no wait is required this time; it's handled internally
         # since the entire call is encapsulated

   Custom GnuPG call
         # assuming $handles is a GnuPG::Handles object
         my $pid = $gnupg->wrap_call
           ( commands     => [ qw( --list-packets ) ],
             command_args => [ qw( test/key.1.asc ) ],
             handles      => $handles,
           );

           my @out = <$handles->stdout()>;
           waitpid $pid, 0;

FAQ

       How do I get GnuPG::Interface to read/write directly from a filehandle?
           You need to set GnuPG::Handles direct option to be true for the filehandles in
           concern.  See "options" in GnuPG::Handles and "Object Methods which use a
           GnuPG::Handles Object" for more information.

       Why do you make it so difficult to get GnuPG to write/read from a filehandle?  In the
       shell, I can just call GnuPG with the --outfile option!
           There are lots of issues when trying to tell GnuPG to read/write directly from a file,
           such as if the file isn't there, or there is a file, and you want to write over it!
           What do you want to happen then?  Having the user of this module handle these
           questions beforehand by opening up filehandles to GnuPG lets the user know fully what
           is going to happen in these circumstances, and makes the module less error-prone.

       When having GnuPG process a large message, sometimes it just hanges there.
           Your problem may be due to buffering issues; when GnuPG reads/writes to non-direct
           filehandles (those that are sent to filehandles which you read to from into memory,
           not that those access the disk), buffering issues can mess things up.  I recommend
           looking into "options" in GnuPG::Handles.

NOTES

       This package is the successor to PGP::GPG::MessageProcessor, which I found to be too
       inextensible to carry on further.  A total redesign was needed, and this is the resulting
       work.

       After any call to a GnuPG-command method of GnuPG::Interface in which one passes in the
       handles, one should all wait to clean up GnuPG from the process table.

BUGS

   Large Amounts of Data
       Currently there are problems when transmitting large quantities of information over
       handles; I'm guessing this is due to buffering issues.  This bug does not seem specific to
       this package; IPC::Open3 also appears affected.

   OpenPGP v3 Keys
       I don't know yet how well this module handles parsing OpenPGP v3 keys.

   RHEL 7 Test Failures
       Testing with the updates for version 1.00 we saw intermittent test failures on RHEL 7 with
       GnuPG version 2.2.20. In some cases the tests would all pass for several runs, then one
       would fail. We're unable to reliably reproduce this so we would be interested in feedback
       from other users.

SEE ALSO

       GnuPG::Options, GnuPG::Handles, GnuPG::PublicKey, GnuPG::SecretKey, gpg, "Bidirectional
       Communication with Another Process" in perlipc

LICENSE

       This module is free software; you can redistribute it and/or modify it under the same
       terms as Perl itself.

AUTHOR

       GnuPG::Interface is currently maintained by Best Practical Solutions <BPS@cpan.org>.

       Frank J. Tobin, ftobin@cpan.org was the original author of the package.