=pod

=head1 NAME

pkcs7 - PKCS#7 utility

=head1 SYNOPSIS

B<openssl> B<pkcs7>
[B<-inform PEM|DER>]
[B<-outform PEM|DER>]
[B<-in filename>]
[B<-out filename>]
[B<-print_certs>]
[B<-text>]
[B<-noout>]
[B<-engine id>]

=head1 DESCRIPTION

The B<pkcs7> command processes PKCS#7 files in DER or PEM format.

=head1 COMMAND OPTIONS

=over 4

=item B<-inform DER|PEM>

This specifies the input format. B<DER> format is DER encoded PKCS#7
v1.5 structure.B<PEM> (the default) is a base64 encoded version of
the DER form with header and footer lines.

=item B<-outform DER|PEM>

This specifies the output format, the options have the same meaning as the 
B<-inform> option.

=item B<-in filename>

This specifies the input filename to read from or standard input if this
option is not specified.

=item B<-out filename>

specifies the output filename to write to or standard output by
default.

=item B<-print_certs>

prints out any certificates or CRLs contained in the file. They are
preceded by their subject and issuer names in one line format.

=item B<-text>

prints out certificates details in full rather than just subject and
issuer names.

=item B<-noout>

don't output the encoded version of the PKCS#7 structure (or certificates
is B<-print_certs> is set).

=item B<-engine id>

specifying an engine (by it's unique B<id> string) will cause B<req>
to attempt to obtain a functional reference to the specified engine,
thus initialising it if needed. The engine will then be set as the default
for all available algorithms.

=back

=head1 EXAMPLES

Convert a PKCS#7 file from PEM to DER:

 openssl pkcs7 -in file.pem -outform DER -out file.der

Output all certificates in a file:

 openssl pkcs7 -in file.pem -print_certs -out certs.pem

=head1 NOTES

The PEM PKCS#7 format uses the header and footer lines:

 -----BEGIN PKCS7-----
 -----END PKCS7-----

For compatibility with some CAs it will also accept:

 -----BEGIN CERTIFICATE-----
 -----END CERTIFICATE-----

=head1 RESTRICTIONS

There is no option to print out all the fields of a PKCS#7 file.

This PKCS#7 routines only understand PKCS#7 v 1.5 as specified in RFC2315 they 
cannot currently parse, for example, the new CMS as described in RFC2630.

=head1 SEE ALSO

L<crl2pkcs7(1)|crl2pkcs7(1)>

=cut
