Don't make assumptions on what the path looks like.
[openssl.git] / doc / openssl.txt
1
2 This is some preliminary documentation for OpenSSL.
3
4 ==============================================================================
5                             BUFFER Library
6 ==============================================================================
7
8 The buffer library handles simple character arrays. Buffers are used for
9 various purposes in the library, most notably memory BIOs.
10
11 The library uses the BUF_MEM structure defined in buffer.h:
12
13 typedef struct buf_mem_st
14 {
15         int length;     /* current number of bytes */
16         char *data;
17         int max;        /* size of buffer */
18 } BUF_MEM;
19
20 'length' is the current size of the buffer in bytes, 'max' is the amount of
21 memory allocated to the buffer. There are three functions which handle these
22 and one "miscellaneous" function.
23
24 BUF_MEM *BUF_MEM_new()
25
26 This allocates a new buffer of zero size. Returns the buffer or NULL on error.
27
28 void BUF_MEM_free(BUF_MEM *a)
29
30 This frees up an already existing buffer. The data is zeroed before freeing
31 up in case the buffer contains sensitive data.
32
33 int BUF_MEM_grow(BUF_MEM *str, int len)
34
35 This changes the size of an already existing buffer. It returns zero on error
36 or the new size (i.e. 'len'). Any data already in the buffer is preserved if
37 it increases in size.
38
39 char * BUF_strdup(char *str)
40
41 This is the previously mentioned strdup function: like the standard library
42 strdup() it copies a null terminated string into a block of allocated memory
43 and returns a pointer to the allocated block.
44
45 Unlike the standard C library strdup() this function uses Malloc() and so
46 should be used in preference to the standard library strdup() because it can
47 be used for memory leak checking or replacing the malloc() function.
48
49 The memory allocated from BUF_strdup() should be freed up using the Free()
50 function.
51
52 ==============================================================================
53                OpenSSL X509V3 extension configuration
54 ==============================================================================
55
56 OpenSSL X509V3 extension configuration: preliminary documentation.
57
58 INTRODUCTION.
59
60 For OpenSSL 0.9.2 the extension code has be considerably enhanced. It is now
61 possible to add and print out common X509 V3 certificate and CRL extensions.
62
63 BEGINNERS NOTE
64
65 For most simple applications you don't need to know too much about extensions:
66 the default openssl.cnf values will usually do sensible things.
67
68 If you want to know more you can initially quickly look through the sections
69 describing how the standard OpenSSL utilities display and add extensions and
70 then the list of supported extensions.
71
72 For more technical information about the meaning of extensions see:
73
74 http://www.imc.org/ietf-pkix/
75 http://home.netscape.com/eng/security/certs.html
76
77 PRINTING EXTENSIONS.
78
79 Extension values are automatically printed out for supported extensions.
80
81 openssl x509 -in cert.pem -text
82 openssl crl -in crl.pem -text
83
84 will give information in the extension printout, for example:
85
86         X509v3 extensions:
87             X509v3 Basic Constraints: 
88                 CA:TRUE
89             X509v3 Subject Key Identifier: 
90                 73:FE:F7:59:A7:E1:26:84:44:D6:44:36:EE:79:1A:95:7C:B1:4B:15
91             X509v3 Authority Key Identifier: 
92                 keyid:73:FE:F7:59:A7:E1:26:84:44:D6:44:36:EE:79:1A:95:7C:B1:4B:15, DirName:/C=AU/ST=Some-State/O=Internet Widgits Pty Ltd/Email=email@1.address/Email=email@2.address, serial:00
93             X509v3 Key Usage: 
94                 Certificate Sign, CRL Sign
95             X509v3 Subject Alternative Name: 
96                 email:email@1.address, email:email@2.address
97
98 CONFIGURATION FILES.
99
100 The OpenSSL utilities 'ca' and 'req' can now have extension sections listing
101 which certificate extensions to include. In each case a line:
102
103 x509_extensions = extension_section
104
105 indicates which section contains the extensions. In the case of 'req' the
106 extension section is used when the -x509 option is present to create a
107 self signed root certificate.
108
109 The 'x509' utility also supports extensions when it signs a certificate.
110 The -extfile option is used to set the configuration file containing the
111 extensions. In this case a line with:
112
113 extensions = extension_section
114
115 in the nameless (default) section is used. If no such line is included then
116 it uses the default section.
117
118 You can also add extensions to CRLs: a line
119
120 crl_extensions = crl_extension_section
121
122 will include extensions when the -gencrl option is used with the 'ca' utility.
123 You can add any extension to a CRL but of the supported extensions only
124 issuerAltName and authorityKeyIdentifier make any real sense. Note: these are
125 CRL extensions NOT CRL *entry* extensions which cannot currently be generated.
126 CRL entry extensions can be displayed.
127
128 NB. At this time Netscape Communicator rejects V2 CRLs: to get an old V1 CRL
129 you should not include a crl_extensions line in the configuration file.
130
131 As with all configuration files you can use the inbuilt environment expansion
132 to allow the values to be passed in the environment. Therefore if you have
133 several extension sections used for different purposes you can have a line:
134
135 x509_extensions = $ENV::ENV_EXT
136
137 and set the ENV_EXT environment variable before calling the relevant utility.
138
139 EXTENSION SYNTAX.
140
141 Extensions have the basic form:
142
143 extension_name=[critical,] extension_options
144
145 the use of the critical option makes the extension critical. Extreme caution
146 should be made when using the critical flag. If an extension is marked
147 as critical then any client that does not understand the extension should
148 reject it as invalid. Some broken software will reject certificates which
149 have *any* critical extensions (these violates PKIX but we have to live
150 with it).
151
152 There are three main types of extension: string extensions, multi-valued
153 extensions, and raw extensions.
154
155 String extensions simply have a string which contains either the value itself
156 or how it is obtained.
157
158 For example:
159
160 nsComment="This is a Comment"
161
162 Multi-valued extensions have a short form and a long form. The short form
163 is a list of names and values:
164
165 basicConstraints=critical,CA:true,pathlen:1
166
167 The long form allows the values to be placed in a separate section:
168
169 basicConstraints=critical,@bs_section
170
171 [bs_section]
172
173 CA=true
174 pathlen=1
175
176 Both forms are equivalent. However it should be noted that in some cases the
177 same name can appear multiple times, for example,
178
179 subjectAltName=email:steve@here,email:steve@there
180
181 in this case an equivalent long form is:
182
183 subjectAltName=@alt_section
184
185 [alt_section]
186
187 email.1=steve@here
188 email.2=steve@there
189
190 This is because the configuration file code cannot handle the same name
191 occurring twice in the same extension.
192
193 The syntax of raw extensions is governed by the extension code: it can
194 for example contain data in multiple sections. The correct syntax to
195 use is defined by the extension code itself: check out the certificate
196 policies extension for an example.
197
198 In addition it is also possible to use the word DER to include arbitrary
199 data in any extension.
200
201 1.2.3.4=critical,DER:01:02:03:04
202 1.2.3.4=DER:01020304
203
204 The value following DER is a hex dump of the DER encoding of the extension
205 Any extension can be placed in this form to override the default behaviour.
206 For example:
207
208 basicConstraints=critical,DER:00:01:02:03
209
210 WARNING: DER should be used with caution. It is possible to create totally
211 invalid extensions unless care is taken.
212
213 CURRENTLY SUPPORTED EXTENSIONS.
214
215 If you aren't sure about extensions then they can be largely ignored: its only
216 when you want to do things like restrict certificate usage when you need to
217 worry about them. 
218
219 The only extension that a beginner might want to look at is Basic Constraints.
220 If in addition you want to try Netscape object signing the you should also
221 look at Netscape Certificate Type.
222
223 Literal String extensions.
224
225 In each case the 'value' of the extension is placed directly in the
226 extension. Currently supported extensions in this category are: nsBaseUrl,
227 nsRevocationUrl, nsCaRevocationUrl, nsRenewalUrl, nsCaPolicyUrl,
228 nsSslServerName and nsComment.
229
230 For example:
231
232 nsComment="This is a test comment"
233
234 Bit Strings.
235
236 Bit string extensions just consist of a list of supported bits, currently
237 two extensions are in this category: PKIX keyUsage and the Netscape specific
238 nsCertType.
239
240 nsCertType (netscape certificate type) takes the flags: client, server, email,
241 objsign, reserved, sslCA, emailCA, objCA.
242
243 keyUsage (PKIX key usage) takes the flags: digitalSignature, nonRepudiation,
244 keyEncipherment, dataEncipherment, keyAgreement, keyCertSign, cRLSign,
245 encipherOnly, decipherOnly.
246
247 For example:
248
249 nsCertType=server
250
251 keyUsage=digitalSignature, nonRepudiation
252
253 Hints on Netscape Certificate Type.
254
255 Other than Basic Constraints this is the only extension a beginner might
256 want to use, if you want to try Netscape object signing, otherwise it can
257 be ignored.
258
259 If you want a certificate that can be used just for object signing then:
260
261 nsCertType=objsign
262
263 will do the job. If you want to use it as a normal end user and server
264 certificate as well then
265
266 nsCertType=objsign,email,server
267
268 is more appropriate. You cannot use a self signed certificate for object
269 signing (well Netscape signtool can but it cheats!) so you need to create
270 a CA certificate and sign an end user certificate with it.
271
272 Side note: If you want to conform to the Netscape specifications then you
273 should really also set:
274
275 nsCertType=objCA
276
277 in the *CA* certificate for just an object signing CA and
278
279 nsCertType=objCA,emailCA,sslCA
280
281 for everything. Current Netscape software doesn't enforce this so it can
282 be omitted.
283
284 Basic Constraints.
285
286 This is generally the only extension you need to worry about for simple
287 applications. If you want your certificate to be usable as a CA certificate
288 (in addition to an end user certificate) then you set this to:
289
290 basicConstraints=CA:TRUE
291
292 if you want to be certain the certificate cannot be used as a CA then do:
293
294 basicConstraints=CA:FALSE
295
296 The rest of this section describes more advanced usage.
297
298 Basic constraints is a multi-valued extension that supports a CA and an
299 optional pathlen option. The CA option takes the values true and false and
300 pathlen takes an integer. Note if the CA option is false the pathlen option
301 should be omitted. 
302
303 The pathlen parameter indicates the maximum number of CAs that can appear
304 below this one in a chain. So if you have a CA with a pathlen of zero it can
305 only be used to sign end user certificates and not further CAs. This all
306 assumes that the software correctly interprets this extension of course.
307
308 Examples:
309
310 basicConstraints=CA:TRUE
311 basicConstraints=critical,CA:TRUE, pathlen:0
312
313 NOTE: for a CA to be considered valid it must have the CA option set to
314 TRUE. An end user certificate MUST NOT have the CA value set to true.
315 According to PKIX recommendations it should exclude the extension entirely,
316 however some software may require CA set to FALSE for end entity certificates.
317
318 Subject Key Identifier.
319
320 This is really a string extension and can take two possible values. Either
321 a hex string giving details of the extension value to include or the word
322 'hash' which then automatically follow PKIX guidelines in selecting and
323 appropriate key identifier. The use of the hex string is strongly discouraged.
324
325 Example: subjectKeyIdentifier=hash
326
327 Authority Key Identifier.
328
329 The authority key identifier extension permits two options. keyid and issuer:
330 both can take the optional value "always".
331
332 If the keyid option is present an attempt is made to copy the subject key
333 identifier from the parent certificate. If the value "always" is present
334 then an error is returned if the option fails.
335
336 The issuer option copies the issuer and serial number from the issuer
337 certificate. Normally this will only be done if the keyid option fails or
338 is not included: the "always" flag will always include the value.
339
340 Subject Alternative Name.
341
342 The subject alternative name extension allows various literal values to be
343 included in the configuration file. These include "email" (an email address)
344 "URI" a uniform resource indicator, "DNS" (a DNS domain name), RID (a
345 registered ID: OBJECT IDENTIFIER) and IP (and IP address).
346
347 Also the email option include a special 'copy' value. This will automatically
348 include and email addresses contained in the certificate subject name in
349 the extension.
350
351 Examples:
352
353 subjectAltName=email:copy,email:my@other.address,URL:http://my.url.here/
354 subjectAltName=email:my@other.address,RID:1.2.3.4
355
356 Issuer Alternative Name.
357
358 The issuer alternative name option supports all the literal options of
359 subject alternative name. It does *not* support the email:copy option because
360 that would not make sense. It does support an additional issuer:copy option
361 that will copy all the subject alternative name values from the issuer 
362 certificate (if possible).
363
364 CRL distribution points.
365
366 This is a multi-valued extension that supports all the literal options of
367 subject alternative name. Of the few software packages that currently interpret
368 this extension most only interpret the URI option.
369
370 Currently each option will set a new DistributionPoint with the fullName
371 field set to the given value.
372
373 Other fields like cRLissuer and reasons cannot currently be set or displayed:
374 at this time no examples were available that used these fields.
375
376 If you see this extension with <UNSUPPORTED> when you attempt to print it out
377 or it doesn't appear to display correctly then let me know, including the
378 certificate (mail me at steve@openssl.org) .
379
380 Examples:
381
382 crlDistributionPoints=URI:http://www.myhost.com/myca.crl
383 crlDistributionPoints=URI:http://www.my.com/my.crl,URI:http://www.oth.com/my.crl
384
385 Certificate Policies.
386
387 This is a RAW extension. It attempts to display the contents of this extension:
388 unfortunately this extension is often improperly encoded.
389
390 The certificate policies extension will rarely be used in practice: few
391 software packages interpret it correctly or at all. IE5 does partially
392 support this extension: but it needs the 'ia5org' option because it will
393 only correctly support a broken encoding. Of the options below only the
394 policy OID, explicitText and CPS options are displayed with IE5.
395
396 All the fields of this extension can be set by using the appropriate syntax.
397
398 If you follow the PKIX recommendations of not including any qualifiers and just
399 using only one OID then you just include the value of that OID. Multiple OIDs
400 can be set separated by commas, for example:
401
402 certificatePolicies= 1.2.4.5, 1.1.3.4
403
404 If you wish to include qualifiers then the policy OID and qualifiers need to
405 be specified in a separate section: this is done by using the @section syntax
406 instead of a literal OID value.
407
408 The section referred to must include the policy OID using the name
409 policyIdentifier, cPSuri qualifiers can be included using the syntax:
410
411 CPS.nnn=value
412
413 userNotice qualifiers can be set using the syntax:
414
415 userNotice.nnn=@notice
416
417 The value of the userNotice qualifier is specified in the relevant section.
418 This section can include explicitText, organization and noticeNumbers
419 options. explicitText and organization are text strings, noticeNumbers is a
420 comma separated list of numbers. The organization and noticeNumbers options
421 (if included) must BOTH be present. If you use the userNotice option with IE5
422 then you need the 'ia5org' option at the top level to modify the encoding:
423 otherwise it will not be interpreted properly.
424
425 Example:
426
427 certificatePolicies=ia5org,1.2.3.4,1.5.6.7.8,@polsect
428
429 [polsect]
430
431 policyIdentifier = 1.3.5.8
432 CPS.1="http://my.host.name/"
433 CPS.2="http://my.your.name/"
434 userNotice.1=@notice
435
436 [notice]
437
438 explicitText="Explicit Text Here"
439 organization="Organisation Name"
440 noticeNumbers=1,2,3,4
441
442 TECHNICAL NOTE: the ia5org option changes the type of the 'organization' field,
443 according to PKIX it should be of type DisplayText but Verisign uses an 
444 IA5STRING and IE5 needs this too.
445
446 Display only extensions.
447
448 Some extensions are only partially supported and currently are only displayed
449 but cannot be set. These include private key usage period, CRL number, and
450 CRL reason.
451
452 ==============================================================================
453                             PKCS#12 Library
454 ==============================================================================
455
456 This section describes the internal PKCS#12 support. There are very few
457 differences between the old external library and the new internal code at
458 present. This may well change because the external library will not be updated
459 much in future.
460
461 This version now includes a couple of high level PKCS#12 functions which
462 generally "do the right thing" and should make it much easier to handle PKCS#12
463 structures.
464
465 HIGH LEVEL FUNCTIONS.
466
467 For most applications you only need concern yourself with the high level
468 functions. They can parse and generate simple PKCS#12 files as produced by
469 Netscape and MSIE or indeed any compliant PKCS#12 file containing a single
470 private key and certificate pair.
471
472 1. Initialisation and cleanup.
473
474 No special initialisation is needed for the internal PKCS#12 library: the 
475 standard SSLeay_add_all_algorithms() is sufficient. If you do not wish to
476 add all algorithms (you should at least add SHA1 though) then you can manually
477 initialise the PKCS#12 library with:
478
479 PKCS12_PBE_add();
480
481 The memory allocated by the PKCS#12 library is freed up when EVP_cleanup() is
482 called or it can be directly freed with:
483
484 EVP_PBE_cleanup();
485
486 after this call (or EVP_cleanup() ) no more PKCS#12 library functions should
487 be called.
488
489 2. I/O functions.
490
491 i2d_PKCS12_bio(bp, p12)
492
493 This writes out a PKCS12 structure to a BIO.
494
495 i2d_PKCS12_fp(fp, p12)
496
497 This is the same but for a FILE pointer.
498
499 d2i_PKCS12_bio(bp, p12)
500
501 This reads in a PKCS12 structure from a BIO.
502
503 d2i_PKCS12_fp(fp, p12)
504
505 This is the same but for a FILE pointer.
506
507 3. Parsing and creation functions.
508
509 3.1 Parsing with PKCS12_parse().
510
511 int PKCS12_parse(PKCS12 *p12, char *pass, EVP_PKEY **pkey, X509 **cert,
512                                                                  STACK **ca);
513
514 This function takes a PKCS12 structure and a password (ASCII, null terminated)
515 and returns the private key, the corresponding certificate and any CA
516 certificates. If any of these is not required it can be passed as a NULL.
517 The 'ca' parameter should be either NULL, a pointer to NULL or a valid STACK
518 structure. Typically to read in a PKCS#12 file you might do:
519
520 p12 = d2i_PKCS12_fp(fp, NULL);
521 PKCS12_parse(p12, password, &pkey, &cert, NULL);        /* CAs not wanted */
522 PKCS12_free(p12);
523
524 3.2 PKCS#12 creation with PKCS12_create().
525
526 PKCS12 *PKCS12_create(char *pass, char *name, EVP_PKEY *pkey, X509 *cert,
527                         STACK *ca, int nid_key, int nid_cert, int iter,
528                                                  int mac_iter, int keytype);
529
530 This function will create a PKCS12 structure from a given password, name,
531 private key, certificate and optional STACK of CA certificates. The remaining
532 5 parameters can be set to 0 and sensible defaults will be used.
533
534 The parameters nid_key and nid_cert are the key and certificate encryption
535 algorithms, iter is the encryption iteration count, mac_iter is the MAC
536 iteration count and keytype is the type of private key. If you really want
537 to know what these last 5 parameters do then read the low level section.
538
539 Typically to create a PKCS#12 file the following could be used:
540
541 p12 = PKCS12_create(pass, "My Certificate", pkey, cert, NULL, 0,0,0,0,0);
542 i2d_PKCS12_fp(fp, p12);
543 PKCS12_free(p12);
544
545 LOW LEVEL FUNCTIONS.
546
547 In some cases the high level functions do not provide the necessary
548 functionality. For example if you want to generate or parse more complex
549 PKCS#12 files. The sample pkcs12 application uses the low level functions
550 to display details about the internal structure of a PKCS#12 file.
551
552 Introduction.
553
554 This is a brief description of how a PKCS#12 file is represented internally:
555 some knowledge of PKCS#12 is assumed.
556
557 A PKCS#12 object contains several levels.
558
559 At the lowest level is a PKCS12_SAFEBAG. This can contain a certificate, a
560 CRL, a private key, encrypted or unencrypted, a set of safebags (so the
561 structure can be nested) or other secrets (not documented at present). 
562 A safebag can optionally have attributes, currently these are: a unicode
563 friendlyName (a Unicode string) or a localKeyID (a string of bytes).
564
565 At the next level is an authSafe which is a set of safebags collected into
566 a PKCS#7 ContentInfo. This can be just plain data, or encrypted itself.
567
568 At the top level is the PKCS12 structure itself which contains a set of
569 authSafes in an embedded PKCS#7 Contentinfo of type data. In addition it
570 contains a MAC which is a kind of password protected digest to preserve
571 integrity (so any unencrypted stuff below can't be tampered with).
572
573 The reason for these levels is so various objects can be encrypted in various
574 ways. For example you might want to encrypt a set of private keys with
575 triple-DES and then include the related certificates either unencrypted or
576 with lower encryption. Yes it's the dreaded crypto laws at work again which
577 allow strong encryption on private keys and only weak encryption on other
578 stuff.
579
580 To build one of these things you turn all certificates and keys into safebags
581 (with optional attributes). You collect the safebags into (one or more) STACKS
582 and convert these into authsafes (encrypted or unencrypted).  The authsafes
583 are collected into a STACK and added to a PKCS12 structure.  Finally a MAC
584 inserted.
585
586 Pulling one apart is basically the reverse process. The MAC is verified against
587 the given password. The authsafes are extracted and each authsafe split into
588 a set of safebags (possibly involving decryption). Finally the safebags are
589 decomposed into the original keys and certificates and the attributes used to
590 match up private key and certificate pairs.
591
592 Anyway here are the functions that do the dirty work.
593
594 1. Construction functions.
595
596 1.1 Safebag functions.
597
598 M_PKCS12_x5092certbag(x509)
599
600 This macro takes an X509 structure and returns a certificate bag. The
601 X509 structure can be freed up after calling this function.
602
603 M_PKCS12_x509crl2certbag(crl)
604
605 As above but for a CRL.
606
607 PKCS8_PRIV_KEY_INFO *PKEY2PKCS8(EVP_PKEY *pkey)
608
609 Take a private key and convert it into a PKCS#8 PrivateKeyInfo structure.
610 Works for both RSA and DSA private keys. NB since the PKCS#8 PrivateKeyInfo
611 structure contains a private key data in plain text form it should be free'd
612 up as soon as it has been encrypted for security reasons (freeing up the
613 structure zeros out the sensitive data). This can be done with
614 PKCS8_PRIV_KEY_INFO_free().
615
616 PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage)
617
618 This sets the key type when a key is imported into MSIE or Outlook 98. Two
619 values are currently supported: KEY_EX and KEY_SIG. KEY_EX is an exchange type
620 key that can also be used for signing but its size is limited in the export
621 versions of MS software to 512 bits, it is also the default. KEY_SIG is a
622 signing only key but the keysize is unlimited (well 16K is supposed to work).
623 If you are using the domestic version of MSIE then you can ignore this because
624 KEY_EX is not limited and can be used for both.
625
626 PKCS12_SAFEBAG *PKCS12_MAKE_KEYBAG(PKCS8_PRIV_KEY_INFO *p8)
627
628 Convert a PKCS8 private key structure into a keybag. This routine embeds the
629 p8 structure in the keybag so p8 should not be freed up or used after it is
630 called.  The p8 structure will be freed up when the safebag is freed.
631
632 PKCS12_SAFEBAG *PKCS12_MAKE_SHKEYBAG(int pbe_nid, unsigned char *pass, int passlen, unsigned char *salt, int saltlen, int iter, PKCS8_PRIV_KEY_INFO *p8)
633
634 Convert a PKCS#8 structure into a shrouded key bag (encrypted). p8 is not
635 embedded and can be freed up after use.
636
637 int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name, int namelen)
638 int PKCS12_add_friendlyname(PKCS12_SAFEBAG *bag, unsigned char *name, int namelen)
639
640 Add a local key id or a friendlyname to a safebag.
641
642 1.2 Authsafe functions.
643
644 PKCS7 *PKCS12_pack_p7data(STACK *sk)
645 Take a stack of safebags and convert them into an unencrypted authsafe. The
646 stack of safebags can be freed up after calling this function.
647
648 PKCS7 *PKCS12_pack_p7encdata(int pbe_nid, unsigned char *pass, int passlen, unsigned char *salt, int saltlen, int iter, STACK *bags);
649
650 As above but encrypted.
651
652 1.3 PKCS12 functions.
653
654 PKCS12 *PKCS12_init(int mode)
655
656 Initialise a PKCS12 structure (currently mode should be NID_pkcs7_data).
657
658 M_PKCS12_pack_authsafes(p12, safes)
659
660 This macro takes a STACK of authsafes and adds them to a PKCS#12 structure.
661
662 int PKCS12_set_mac(PKCS12 *p12, unsigned char *pass, int passlen, unsigned char *salt, int saltlen, int iter, EVP_MD *md_type);
663
664 Add a MAC to a PKCS12 structure. If EVP_MD is NULL use SHA-1, the spec suggests
665 that SHA-1 should be used.
666
667 2. Extraction Functions.
668
669 2.1 Safebags.
670
671 M_PKCS12_bag_type(bag)
672
673 Return the type of "bag". Returns one of the following
674
675 NID_keyBag
676 NID_pkcs8ShroudedKeyBag                 7
677 NID_certBag                             8
678 NID_crlBag                              9
679 NID_secretBag                           10
680 NID_safeContentsBag                     11
681
682 M_PKCS12_cert_bag_type(bag)
683
684 Returns type of certificate bag, following are understood.
685
686 NID_x509Certificate                     14
687 NID_sdsiCertificate                     15
688
689 M_PKCS12_crl_bag_type(bag)
690
691 Returns crl bag type, currently only NID_crlBag is recognised.
692
693 M_PKCS12_certbag2x509(bag)
694
695 This macro extracts an X509 certificate from a certificate bag.
696
697 M_PKCS12_certbag2x509crl(bag)
698
699 As above but for a CRL.
700
701 EVP_PKEY * PKCS82PKEY(PKCS8_PRIV_KEY_INFO *p8)
702
703 Extract a private key from a PKCS8 private key info structure.
704
705 M_PKCS12_decrypt_skey(bag, pass, passlen) 
706
707 Decrypt a shrouded key bag and return a PKCS8 private key info structure.
708 Works with both RSA and DSA keys
709
710 char *PKCS12_get_friendlyname(bag)
711
712 Returns the friendlyName of a bag if present or NULL if none. The returned
713 string is a null terminated ASCII string allocated with Malloc(). It should 
714 thus be freed up with Free() after use.
715
716 2.2 AuthSafe functions.
717
718 M_PKCS12_unpack_p7data(p7)
719
720 Extract a STACK of safe bags from a PKCS#7 data ContentInfo.
721
722 #define M_PKCS12_unpack_p7encdata(p7, pass, passlen)
723
724 As above but for an encrypted content info.
725
726 2.3 PKCS12 functions.
727
728 M_PKCS12_unpack_authsafes(p12)
729
730 Extract a STACK of authsafes from a PKCS12 structure.
731
732 M_PKCS12_mac_present(p12)
733
734 Check to see if a MAC is present.
735
736 int PKCS12_verify_mac(PKCS12 *p12, unsigned char *pass, int passlen)
737
738 Verify a MAC on a PKCS12 structure. Returns an error if MAC not present.
739
740
741 Notes.
742
743 1. All the function return 0 or NULL on error.
744 2. Encryption based functions take a common set of parameters. These are
745 described below.
746
747 pass, passlen
748 ASCII password and length. The password on the MAC is called the "integrity
749 password" the encryption password is called the "privacy password" in the
750 PKCS#12 documentation. The passwords do not have to be the same. If -1 is
751 passed for the length it is worked out by the function itself (currently
752 this is sometimes done whatever is passed as the length but that may change).
753
754 salt, saltlen
755 A 'salt' if salt is NULL a random salt is used. If saltlen is also zero a
756 default length is used.
757
758 iter
759 Iteration count. This is a measure of how many times an internal function is
760 called to encrypt the data. The larger this value is the longer it takes, it
761 makes dictionary attacks on passwords harder. NOTE: Some implementations do
762 not support an iteration count on the MAC. If the password for the MAC and
763 encryption is the same then there is no point in having a high iteration
764 count for encryption if the MAC has no count. The MAC could be attacked
765 and the password used for the main decryption.
766
767 pbe_nid
768 This is the NID of the password based encryption method used. The following are
769 supported.
770 NID_pbe_WithSHA1And128BitRC4
771 NID_pbe_WithSHA1And40BitRC4
772 NID_pbe_WithSHA1And3_Key_TripleDES_CBC
773 NID_pbe_WithSHA1And2_Key_TripleDES_CBC
774 NID_pbe_WithSHA1And128BitRC2_CBC
775 NID_pbe_WithSHA1And40BitRC2_CBC
776
777 Which you use depends on the implementation you are exporting to. "Export
778 grade" (i.e. cryptographically challenged) products cannot support all
779 algorithms. Typically you may be able to use any encryption on shrouded key
780 bags but they must then be placed in an unencrypted authsafe. Other authsafes
781 may only support 40bit encryption. Of course if you are using SSLeay
782 throughout you can strongly encrypt everything and have high iteration counts
783 on everything.
784
785 3. For decryption routines only the password and length are needed.
786
787 4. Unlike the external version the nid's of objects are the values of the
788 constants: that is NID_certBag is the real nid, therefore there is no 
789 PKCS12_obj_offset() function.  Note the object constants are not the same as
790 those of the external version. If you use these constants then you will need
791 to recompile your code.
792
793 5. With the exception of PKCS12_MAKE_KEYBAG(), after calling any function or 
794 macro of the form PKCS12_MAKE_SOMETHING(other) the "other" structure can be
795 reused or freed up safely.
796