e8c0cd7ea6579a0f5320c3ecb8b6574d5eebfd5d
[openssl.git] / doc / openssl.txt
1
2 This is some preliminary documentation for OpenSSL.
3
4 Contents:
5
6  OpenSSL X509V3 extension configuration
7  X509V3 Extension code: programmers guide
8  PKCS#12 Library
9
10
11 ==============================================================================
12                OpenSSL X509V3 extension configuration
13 ==============================================================================
14
15 OpenSSL X509V3 extension configuration: preliminary documentation.
16
17 INTRODUCTION.
18
19 For OpenSSL 0.9.2 the extension code has be considerably enhanced. It is now
20 possible to add and print out common X509 V3 certificate and CRL extensions.
21
22 BEGINNERS NOTE
23
24 For most simple applications you don't need to know too much about extensions:
25 the default openssl.cnf values will usually do sensible things.
26
27 If you want to know more you can initially quickly look through the sections
28 describing how the standard OpenSSL utilities display and add extensions and
29 then the list of supported extensions.
30
31 For more technical information about the meaning of extensions see:
32
33 http://www.imc.org/ietf-pkix/
34 http://home.netscape.com/eng/security/certs.html
35
36 PRINTING EXTENSIONS.
37
38 Extension values are automatically printed out for supported extensions.
39
40 openssl x509 -in cert.pem -text
41 openssl crl -in crl.pem -text
42
43 will give information in the extension printout, for example:
44
45         X509v3 extensions:
46             X509v3 Basic Constraints: 
47                 CA:TRUE
48             X509v3 Subject Key Identifier: 
49                 73:FE:F7:59:A7:E1:26:84:44:D6:44:36:EE:79:1A:95:7C:B1:4B:15
50             X509v3 Authority Key Identifier: 
51                 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
52             X509v3 Key Usage: 
53                 Certificate Sign, CRL Sign
54             X509v3 Subject Alternative Name: 
55                 email:email@1.address, email:email@2.address
56
57 CONFIGURATION FILES.
58
59 The OpenSSL utilities 'ca' and 'req' can now have extension sections listing
60 which certificate extensions to include. In each case a line:
61
62 x509_extensions = extension_section
63
64 indicates which section contains the extensions. In the case of 'req' the
65 extension section is used when the -x509 option is present to create a
66 self signed root certificate.
67
68 The 'x509' utility also supports extensions when it signs a certificate.
69 The -extfile option is used to set the configuration file containing the
70 extensions. In this case a line with:
71
72 extensions = extension_section
73
74 in the nameless (default) section is used. If no such line is included then
75 it uses the default section.
76
77 You can also add extensions to CRLs: a line
78
79 crl_extensions = crl_extension_section
80
81 will include extensions when the -gencrl option is used with the 'ca' utility.
82 You can add any extension to a CRL but of the supported extensions only
83 issuerAltName and authorityKeyIdentifier make any real sense. Note: these are
84 CRL extensions NOT CRL *entry* extensions which cannot currently be generated.
85 CRL entry extensions can be displayed.
86
87 NB. At this time Netscape Communicator rejects V2 CRLs: to get an old V1 CRL
88 you should not include a crl_extensions line in the configuration file.
89
90 As with all configuration files you can use the inbuilt environment expansion
91 to allow the values to be passed in the environment. Therefore if you have
92 several extension sections used for different purposes you can have a line:
93
94 x509_extensions = $ENV::ENV_EXT
95
96 and set the ENV_EXT environment variable before calling the relevant utility.
97
98 EXTENSION SYNTAX.
99
100 Extensions have the basic form:
101
102 extension_name=[critical,] extension_options
103
104 the use of the critical option makes the extension critical. Extreme caution
105 should be made when using the critical flag. If an extension is marked
106 as critical then any client that does not understand the extension should
107 reject it as invalid. Some broken software will reject certificates which
108 have *any* critical extensions (these violates PKIX but we have to live
109 with it).
110
111 There are three main types of extension: string extensions, multi-valued
112 extensions, and raw extensions.
113
114 String extensions simply have a string which contains either the value itself
115 or how it is obtained.
116
117 For example:
118
119 nsComment="This is a Comment"
120
121 Multi-valued extensions have a short form and a long form. The short form
122 is a list of names and values:
123
124 basicConstraints=critical,CA:true,pathlen:1
125
126 The long form allows the values to be placed in a separate section:
127
128 basicConstraints=critical,@bs_section
129
130 [bs_section]
131
132 CA=true
133 pathlen=1
134
135 Both forms are equivalent. However it should be noted that in some cases the
136 same name can appear multiple times, for example,
137
138 subjectAltName=email:steve@here,email:steve@there
139
140 in this case an equivalent long form is:
141
142 subjectAltName=@alt_section
143
144 [alt_section]
145
146 email.1=steve@here
147 email.2=steve@there
148
149 This is because the configuration file code cannot handle the same name
150 occurring twice in the same section.
151
152 The syntax of raw extensions is governed by the extension code: it can
153 for example contain data in multiple sections. The correct syntax to
154 use is defined by the extension code itself: check out the certificate
155 policies extension for an example.
156
157 In addition it is also possible to use the word DER to include arbitrary
158 data in any extension.
159
160 1.2.3.4=critical,DER:01:02:03:04
161 1.2.3.4=DER:01020304
162
163 The value following DER is a hex dump of the DER encoding of the extension
164 Any extension can be placed in this form to override the default behaviour.
165 For example:
166
167 basicConstraints=critical,DER:00:01:02:03
168
169 WARNING: DER should be used with caution. It is possible to create totally
170 invalid extensions unless care is taken.
171
172 CURRENTLY SUPPORTED EXTENSIONS.
173
174 If you aren't sure about extensions then they can be largely ignored: its only
175 when you want to do things like restrict certificate usage when you need to
176 worry about them. 
177
178 The only extension that a beginner might want to look at is Basic Constraints.
179 If in addition you want to try Netscape object signing the you should also
180 look at Netscape Certificate Type.
181
182 Literal String extensions.
183
184 In each case the 'value' of the extension is placed directly in the
185 extension. Currently supported extensions in this category are: nsBaseUrl,
186 nsRevocationUrl, nsCaRevocationUrl, nsRenewalUrl, nsCaPolicyUrl,
187 nsSslServerName and nsComment.
188
189 For example:
190
191 nsComment="This is a test comment"
192
193 Bit Strings.
194
195 Bit string extensions just consist of a list of supported bits, currently
196 two extensions are in this category: PKIX keyUsage and the Netscape specific
197 nsCertType.
198
199 nsCertType (netscape certificate type) takes the flags: client, server, email,
200 objsign, reserved, sslCA, emailCA, objCA.
201
202 keyUsage (PKIX key usage) takes the flags: digitalSignature, nonRepudiation,
203 keyEncipherment, dataEncipherment, keyAgreement, keyCertSign, cRLSign,
204 encipherOnly, decipherOnly.
205
206 For example:
207
208 nsCertType=server
209
210 keyUsage=digitalSignature, nonRepudiation
211
212 Hints on Netscape Certificate Type.
213
214 Other than Basic Constraints this is the only extension a beginner might
215 want to use, if you want to try Netscape object signing, otherwise it can
216 be ignored.
217
218 If you want a certificate that can be used just for object signing then:
219
220 nsCertType=objsign
221
222 will do the job. If you want to use it as a normal end user and server
223 certificate as well then
224
225 nsCertType=objsign,email,server
226
227 is more appropriate. You cannot use a self signed certificate for object
228 signing (well Netscape signtool can but it cheats!) so you need to create
229 a CA certificate and sign an end user certificate with it.
230
231 Side note: If you want to conform to the Netscape specifications then you
232 should really also set:
233
234 nsCertType=objCA
235
236 in the *CA* certificate for just an object signing CA and
237
238 nsCertType=objCA,emailCA,sslCA
239
240 for everything. Current Netscape software doesn't enforce this so it can
241 be omitted.
242
243 Basic Constraints.
244
245 This is generally the only extension you need to worry about for simple
246 applications. If you want your certificate to be usable as a CA certificate
247 (in addition to an end user certificate) then you set this to:
248
249 basicConstraints=CA:TRUE
250
251 if you want to be certain the certificate cannot be used as a CA then do:
252
253 basicConstraints=CA:FALSE
254
255 The rest of this section describes more advanced usage.
256
257 Basic constraints is a multi-valued extension that supports a CA and an
258 optional pathlen option. The CA option takes the values true and false and
259 pathlen takes an integer. Note if the CA option is false the pathlen option
260 should be omitted. 
261
262 The pathlen parameter indicates the maximum number of CAs that can appear
263 below this one in a chain. So if you have a CA with a pathlen of zero it can
264 only be used to sign end user certificates and not further CAs. This all
265 assumes that the software correctly interprets this extension of course.
266
267 Examples:
268
269 basicConstraints=CA:TRUE
270 basicConstraints=critical,CA:TRUE, pathlen:0
271
272 NOTE: for a CA to be considered valid it must have the CA option set to
273 TRUE. An end user certificate MUST NOT have the CA value set to true.
274 According to PKIX recommendations it should exclude the extension entirely,
275 however some software may require CA set to FALSE for end entity certificates.
276
277 Extended Key Usage.
278
279 This extensions consists of a list of usages.
280
281 These can either be object short names of the dotted numerical form of OIDs.
282 While any OID can be used only certain values make sense. In particular the
283 following PKIX, NS and MS values are meaningful:
284
285 Value                   Meaning
286 -----                   -------
287 serverAuth              SSL/TLS Web Server Authentication.
288 clientAuth              SSL/TLS Web Client Authentication.
289 codeSigning             Code signing.
290 emailProtection         E-mail Protection (S/MIME).
291 timeStamping            Trusted Timestamping
292 msCodeInd               Microsoft Individual Code Signing (authenticode)
293 msCodeCom               Microsoft Commercial Code Signing (authenticode)
294 msCTLSign               Microsoft Trust List Signing
295 msSGC                   Microsoft Server Gated Crypto
296 msEFS                   Microsoft Encrypted File System
297 nsSGC                   Netscape Server Gated Crypto
298
299 For example, under IE5 a CA can be used for any purpose: by including a list
300 of the above usages the CA can be restricted to only authorised uses.
301
302 Note: software packages may place additional interpretations on certificate 
303 use, in particular some usages may only work for selected CAs. Don't for example
304 expect just including msSGC or nsSGC will automatically mean that a certificate
305 can be used for SGC ("step up" encryption) otherwise anyone could use it.
306
307 Examples:
308
309 extendedKeyUsage=critical,codeSigning,1.2.3.4
310 extendedKeyUsage=nsSGC,msSGC
311
312 Subject Key Identifier.
313
314 This is really a string extension and can take two possible values. Either
315 a hex string giving details of the extension value to include or the word
316 'hash' which then automatically follow PKIX guidelines in selecting and
317 appropriate key identifier. The use of the hex string is strongly discouraged.
318
319 Example: subjectKeyIdentifier=hash
320
321 Authority Key Identifier.
322
323 The authority key identifier extension permits two options. keyid and issuer:
324 both can take the optional value "always".
325
326 If the keyid option is present an attempt is made to copy the subject key
327 identifier from the parent certificate. If the value "always" is present
328 then an error is returned if the option fails.
329
330 The issuer option copies the issuer and serial number from the issuer
331 certificate. Normally this will only be done if the keyid option fails or
332 is not included: the "always" flag will always include the value.
333
334 Subject Alternative Name.
335
336 The subject alternative name extension allows various literal values to be
337 included in the configuration file. These include "email" (an email address)
338 "URI" a uniform resource indicator, "DNS" (a DNS domain name), RID (a
339 registered ID: OBJECT IDENTIFIER) and IP (and IP address).
340
341 Also the email option include a special 'copy' value. This will automatically
342 include and email addresses contained in the certificate subject name in
343 the extension.
344
345 Examples:
346
347 subjectAltName=email:copy,email:my@other.address,URL:http://my.url.here/
348 subjectAltName=email:my@other.address,RID:1.2.3.4
349
350 Issuer Alternative Name.
351
352 The issuer alternative name option supports all the literal options of
353 subject alternative name. It does *not* support the email:copy option because
354 that would not make sense. It does support an additional issuer:copy option
355 that will copy all the subject alternative name values from the issuer 
356 certificate (if possible).
357
358 Example:
359
360 issuserAltName = issuer:copy
361
362 Authority Info Access.
363
364 The authority information access extension gives details about how to access
365 certain information relating to the CA. Its syntax is accessOID;location
366 where 'location' has the same syntax as subject alternative name (except
367 that email:copy is not supported). accessOID can be any valid OID but only
368 certain values are meaningful for example OCSP and caIssuers. OCSP gives the
369 location of an OCSP responder: this is used by Netscape PSM and other software.
370
371 Example:
372
373 authorityInfoAccess = OCSP;URI:http://ocsp.my.host/
374 authorityInfoAccess = caIssuers;URI:http://my.ca/ca.html
375
376 CRL distribution points.
377
378 This is a multi-valued extension that supports all the literal options of
379 subject alternative name. Of the few software packages that currently interpret
380 this extension most only interpret the URI option.
381
382 Currently each option will set a new DistributionPoint with the fullName
383 field set to the given value.
384
385 Other fields like cRLissuer and reasons cannot currently be set or displayed:
386 at this time no examples were available that used these fields.
387
388 If you see this extension with <UNSUPPORTED> when you attempt to print it out
389 or it doesn't appear to display correctly then let me know, including the
390 certificate (mail me at steve@openssl.org) .
391
392 Examples:
393
394 crlDistributionPoints=URI:http://www.myhost.com/myca.crl
395 crlDistributionPoints=URI:http://www.my.com/my.crl,URI:http://www.oth.com/my.crl
396
397 Certificate Policies.
398
399 This is a RAW extension. It attempts to display the contents of this extension:
400 unfortunately this extension is often improperly encoded.
401
402 The certificate policies extension will rarely be used in practice: few
403 software packages interpret it correctly or at all. IE5 does partially
404 support this extension: but it needs the 'ia5org' option because it will
405 only correctly support a broken encoding. Of the options below only the
406 policy OID, explicitText and CPS options are displayed with IE5.
407
408 All the fields of this extension can be set by using the appropriate syntax.
409
410 If you follow the PKIX recommendations of not including any qualifiers and just
411 using only one OID then you just include the value of that OID. Multiple OIDs
412 can be set separated by commas, for example:
413
414 certificatePolicies= 1.2.4.5, 1.1.3.4
415
416 If you wish to include qualifiers then the policy OID and qualifiers need to
417 be specified in a separate section: this is done by using the @section syntax
418 instead of a literal OID value.
419
420 The section referred to must include the policy OID using the name
421 policyIdentifier, cPSuri qualifiers can be included using the syntax:
422
423 CPS.nnn=value
424
425 userNotice qualifiers can be set using the syntax:
426
427 userNotice.nnn=@notice
428
429 The value of the userNotice qualifier is specified in the relevant section.
430 This section can include explicitText, organization and noticeNumbers
431 options. explicitText and organization are text strings, noticeNumbers is a
432 comma separated list of numbers. The organization and noticeNumbers options
433 (if included) must BOTH be present. If you use the userNotice option with IE5
434 then you need the 'ia5org' option at the top level to modify the encoding:
435 otherwise it will not be interpreted properly.
436
437 Example:
438
439 certificatePolicies=ia5org,1.2.3.4,1.5.6.7.8,@polsect
440
441 [polsect]
442
443 policyIdentifier = 1.3.5.8
444 CPS.1="http://my.host.name/"
445 CPS.2="http://my.your.name/"
446 userNotice.1=@notice
447
448 [notice]
449
450 explicitText="Explicit Text Here"
451 organization="Organisation Name"
452 noticeNumbers=1,2,3,4
453
454 TECHNICAL NOTE: the ia5org option changes the type of the 'organization' field,
455 according to PKIX it should be of type DisplayText but Verisign uses an 
456 IA5STRING and IE5 needs this too.
457
458 Display only extensions.
459
460 Some extensions are only partially supported and currently are only displayed
461 but cannot be set. These include private key usage period, CRL number, and
462 CRL reason.
463
464 ==============================================================================
465                 X509V3 Extension code: programmers guide
466 ==============================================================================
467
468 The purpose of the extension code is twofold. It allows an extension to be
469 created from a string or structure describing its contents and it prints out an
470 extension in a human or machine readable form.
471
472 1. Initialisation and cleanup.
473
474 No special initialisation is needed before calling the extension functions.
475 You used to have to call X509V3_add_standard_extensions(); but this is no longer
476 required and this function no longer does anything.
477
478 void X509V3_EXT_cleanup(void);
479
480 This function should be called to cleanup the extension code if any custom
481 extensions have been added. If no custom extensions have been added then this
482 call does nothing. After this call all custom extension code is freed up but
483 you can still use the standard extensions.
484
485 2. Printing and parsing extensions.
486
487 The simplest way to print out extensions is via the standard X509 printing
488 routines: if you use the standard X509_print() function, the supported
489 extensions will be printed out automatically.
490
491 The following functions allow finer control over extension display:
492
493 int X509V3_EXT_print(BIO *out, X509_EXTENSION *ext, int flag, int indent);
494 int X509V3_EXT_print_fp(FILE *out, X509_EXTENSION *ext, int flag, int indent);
495
496 These two functions print out an individual extension to a BIO or FILE pointer.
497 Currently the flag argument is unused and should be set to 0. The 'indent'
498 argument is the number of spaces to indent each line.
499
500 void *X509V3_EXT_d2i(X509_EXTENSION *ext);
501
502 This function parses an extension and returns its internal structure. The
503 precise structure you get back depends on the extension being parsed. If the
504 extension if basicConstraints you will get back a pointer to a
505 BASIC_CONSTRAINTS structure. Check out the source in crypto/x509v3 for more
506 details about the structures returned. The returned structure should be freed
507 after use using the relevant free function, BASIC_CONSTRAINTS_free() for 
508 example.
509
510 3. Generating extensions.
511
512 An extension will typically be generated from a configuration file, or some
513 other kind of configuration database.
514
515 int X509V3_EXT_add_conf(LHASH *conf, X509V3_CTX *ctx, char *section,
516                                                                  X509 *cert);
517 int X509V3_EXT_CRL_add_conf(LHASH *conf, X509V3_CTX *ctx, char *section,
518                                                                  X509_CRL *crl);
519
520 These functions add all the extensions in the given section to the given
521 certificate or CRL. They will normally be called just before the certificate
522 or CRL is due to be signed. Both return 0 on error on non zero for success.
523
524 In each case 'conf' is the LHASH pointer of the configuration file to use
525 and 'section' is the section containing the extension details.
526
527 See the 'context functions' section for a description of the ctx parameter.
528
529
530 X509_EXTENSION *X509V3_EXT_conf(LHASH *conf, X509V3_CTX *ctx, char *name,
531                                                                  char *value);
532
533 This function returns an extension based on a name and value pair, if the
534 pair will not need to access other sections in a config file (or there is no
535 config file) then the 'conf' parameter can be set to NULL.
536
537 X509_EXTENSION *X509V3_EXT_conf_nid(char *conf, X509V3_CTX *ctx, int nid,
538                                                                  char *value);
539
540 This function creates an extension in the same way as X509V3_EXT_conf() but
541 takes the NID of the extension rather than its name.
542
543 For example to produce basicConstraints with the CA flag and a path length of
544 10:
545
546 x = X509V3_EXT_conf_nid(NULL, NULL, NID_basic_constraints,"CA:TRUE,pathlen:10");
547
548
549 X509_EXTENSION *X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc);
550
551 This function sets up an extension from its internal structure. The ext_nid
552 parameter is the NID of the extension and 'crit' is the critical flag.
553
554 4. Context functions.
555
556 The following functions set and manipulate an extension context structure.
557 The purpose of the extension context is to allow the extension code to
558 access various structures relating to the "environment" of the certificate:
559 for example the issuers certificate or the certificate request.
560
561 void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subject,
562                                  X509_REQ *req, X509_CRL *crl, int flags);
563
564 This function sets up an X509V3_CTX structure with details of the certificate
565 environment: specifically the issuers certificate, the subject certificate,
566 the certificate request and the CRL: if these are not relevant or not
567 available then they can be set to NULL. The 'flags' parameter should be set
568 to zero.
569
570 X509V3_set_ctx_test(ctx)
571
572 This macro is used to set the 'ctx' structure to a 'test' value: this is to
573 allow the syntax of an extension (or configuration file) to be tested.
574
575 X509V3_set_ctx_nodb(ctx)
576
577 This macro is used when no configuration database is present.
578
579 void X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH *lhash);
580
581 This function is used to set the configuration database when it is an LHASH
582 structure: typically a configuration file.
583
584 The following functions are used to access a configuration database: they
585 should only be used in RAW extensions.
586
587 char * X509V3_get_string(X509V3_CTX *ctx, char *name, char *section);
588
589 This function returns the value of the parameter "name" in "section", or NULL
590 if there has been an error.
591
592 void X509V3_string_free(X509V3_CTX *ctx, char *str);
593
594 This function frees up the string returned by the above function.
595
596 STACK_OF(CONF_VALUE) * X509V3_get_section(X509V3_CTX *ctx, char *section);
597
598 This function returns a whole section as a STACK_OF(CONF_VALUE) .
599
600 void X509V3_section_free( X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section);
601
602 This function frees up the STACK returned by the above function.
603
604 Note: it is possible to use the extension code with a custom configuration
605 database. To do this the "db_meth" element of the X509V3_CTX structure should
606 be set to an X509V3_CTX_METHOD structure. This structure contains the following
607 function pointers:
608
609 char * (*get_string)(void *db, char *section, char *value);
610 STACK_OF(CONF_VALUE) * (*get_section)(void *db, char *section);
611 void (*free_string)(void *db, char * string);
612 void (*free_section)(void *db, STACK_OF(CONF_VALUE) *section);
613
614 these will be called and passed the 'db' element in the X509V3_CTX structure
615 to access the database. If a given function is not implemented or not required
616 it can be set to NULL.
617
618 5. String helper functions.
619
620 There are several "i2s" and "s2i" functions that convert structures to and
621 from ASCII strings. In all the "i2s" cases the returned string should be
622 freed using Free() after use. Since some of these are part of other extension
623 code they may take a 'method' parameter. Unless otherwise stated it can be
624 safely set to NULL.
625
626 char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, ASN1_OCTET_STRING *oct);
627
628 This returns a hex string from an ASN1_OCTET_STRING.
629
630 char * i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, ASN1_INTEGER *aint);
631 char * i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *meth, ASN1_ENUMERATED *aint);
632
633 These return a string decimal representations of an ASN1_INTEGER and an
634 ASN1_ENUMERATED type, respectively.
635
636 ASN1_OCTET_STRING *s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
637                                                    X509V3_CTX *ctx, char *str);
638
639 This converts an ASCII hex string to an ASN1_OCTET_STRING.
640
641 ASN1_INTEGER * s2i_ASN1_INTEGER(X509V3_EXT_METHOD *meth, char *value);
642
643 This converts a decimal ASCII string into an ASN1_INTEGER.
644
645 6. Multi valued extension helper functions.
646
647 The following functions can be used to manipulate STACKs of CONF_VALUE
648 structures, as used by multi valued extensions.
649
650 int X509V3_get_value_bool(CONF_VALUE *value, int *asn1_bool);
651
652 This function expects a boolean value in 'value' and sets 'asn1_bool' to
653 it. That is it sets it to 0 for FALSE or 0xff for TRUE. The following
654 strings are acceptable: "TRUE", "true", "Y", "y", "YES", "yes", "FALSE"
655 "false", "N", "n", "NO" or "no".
656
657 int X509V3_get_value_int(CONF_VALUE *value, ASN1_INTEGER **aint);
658
659 This accepts a decimal integer of arbitrary length and sets an ASN1_INTEGER.
660
661 int X509V3_add_value(const char *name, const char *value,
662                                                 STACK_OF(CONF_VALUE) **extlist);
663
664 This simply adds a string name and value pair.
665
666 int X509V3_add_value_uchar(const char *name, const unsigned char *value,
667                                                 STACK_OF(CONF_VALUE) **extlist);
668
669 The same as above but for an unsigned character value.
670
671 int X509V3_add_value_bool(const char *name, int asn1_bool,
672                                                 STACK_OF(CONF_VALUE) **extlist);
673
674 This adds either "TRUE" or "FALSE" depending on the value of 'asn1_bool'
675
676 int X509V3_add_value_bool_nf(char *name, int asn1_bool,
677                                                 STACK_OF(CONF_VALUE) **extlist);
678
679 This is the same as above except it adds nothing if asn1_bool is FALSE.
680
681 int X509V3_add_value_int(const char *name, ASN1_INTEGER *aint,
682                                                 STACK_OF(CONF_VALUE) **extlist);
683
684 This function adds the value of the ASN1_INTEGER in decimal form.
685
686 7. Other helper functions.
687
688 <to be added>
689
690 ADDING CUSTOM EXTENSIONS.
691
692 Currently there are three types of supported extensions. 
693
694 String extensions are simple strings where the value is placed directly in the
695 extensions, and the string returned is printed out.
696
697 Multi value extensions are passed a STACK_OF(CONF_VALUE) name and value pairs
698 or return a STACK_OF(CONF_VALUE).
699
700 Raw extensions are just passed a BIO or a value and it is the extensions
701 responsibility to handle all the necessary printing.
702
703 There are two ways to add an extension. One is simply as an alias to an already
704 existing extension. An alias is an extension that is identical in ASN1 structure
705 to an existing extension but has a different OBJECT IDENTIFIER. This can be
706 done by calling:
707
708 int X509V3_EXT_add_alias(int nid_to, int nid_from);
709
710 'nid_to' is the new extension NID and 'nid_from' is the already existing
711 extension NID.
712
713 Alternatively an extension can be written from scratch. This involves writing
714 the ASN1 code to encode and decode the extension and functions to print out and
715 generate the extension from strings. The relevant functions are then placed in
716 a X509V3_EXT_METHOD structure and int X509V3_EXT_add(X509V3_EXT_METHOD *ext);
717 called.
718
719 The X509V3_EXT_METHOD structure is described below.
720
721 strut {
722 int ext_nid;
723 int ext_flags;
724 X509V3_EXT_NEW ext_new;
725 X509V3_EXT_FREE ext_free;
726 X509V3_EXT_D2I d2i;
727 X509V3_EXT_I2D i2d;
728 X509V3_EXT_I2S i2s;
729 X509V3_EXT_S2I s2i;
730 X509V3_EXT_I2V i2v;
731 X509V3_EXT_V2I v2i;
732 X509V3_EXT_R2I r2i;
733 X509V3_EXT_I2R i2r;
734
735 void *usr_data;
736 };
737
738 The elements have the following meanings.
739
740 ext_nid         is the NID of the object identifier of the extension.
741
742 ext_flags       is set of flags. Currently the only external flag is
743                 X509V3_EXT_MULTILINE which means a multi valued extensions
744                 should be printed on separate lines.
745
746 usr_data        is an extension specific pointer to any relevant data. This
747                 allows extensions to share identical code but have different
748                 uses. An example of this is the bit string extension which uses
749                 usr_data to contain a list of the bit names.
750
751 All the remaining elements are function pointers.
752
753 ext_new         is a pointer to a function that allocates memory for the
754                 extension ASN1 structure: for example ASN1_OBJECT_new().
755
756 ext_free        is a pointer to a function that free up memory of the extension
757                 ASN1 structure: for example ASN1_OBJECT_free().
758
759 d2i             is the standard ASN1 function that converts a DER buffer into
760                 the internal ASN1 structure: for example d2i_ASN1_IA5STRING().
761
762 i2d             is the standard ASN1 function that converts the internal
763                 structure into the DER representation: for example
764                 i2d_ASN1_IA5STRING().
765
766 The remaining functions are depend on the type of extension. One i2X and
767 one X2i should be set and the rest set to NULL. The types set do not need
768 to match up, for example the extension could be set using the multi valued
769 v2i function and printed out using the raw i2r.
770
771 All functions have the X509V3_EXT_METHOD passed to them in the 'method'
772 parameter and an X509V3_CTX structure. Extension code can then access the
773 parent structure via the 'method' parameter to for example make use of the value
774 of usr_data. If the code needs to use detail relating to the request it can
775 use the 'ctx' parameter.
776
777 A note should be given here about the 'flags' member of the 'ctx' parameter.
778 If it has the value CTX_TEST then the configuration syntax is being checked
779 and no actual certificate or CRL exists. Therefore any attempt in the config
780 file to access such information should silently succeed. If the syntax is OK
781 then it should simply return a (possibly bogus) extension, otherwise it
782 should return NULL.
783
784 char *i2s(struct v3_ext_method *method, void *ext);
785
786 This function takes the internal structure in the ext parameter and returns
787 a Malloc'ed string representing its value.
788
789 void * s2i(struct v3_ext_method *method, struct v3_ext_ctx *ctx, char *str);
790
791 This function takes the string representation in the ext parameter and returns
792 an allocated internal structure: ext_free() will be used on this internal
793 structure after use.
794
795 i2v and v2i handle a STACK_OF(CONF_VALUE):
796
797 typedef struct
798 {
799         char *section;
800         char *name;
801         char *value;
802 } CONF_VALUE;
803
804 Only the name and value members are currently used.
805
806 STACK_OF(CONF_VALUE) * i2v(struct v3_ext_method *method, void *ext);
807
808 This function is passed the internal structure in the ext parameter and
809 returns a STACK of CONF_VALUE structures. The values of name, value,
810 section and the structure itself will be freed up with Free after use.
811 Several helper functions are available to add values to this STACK.
812
813 void * v2i(struct v3_ext_method *method, struct v3_ext_ctx *ctx,
814                                                 STACK_OF(CONF_VALUE) *values);
815
816 This function takes a STACK_OF(CONF_VALUE) structures and should set the
817 values of the external structure. This typically uses the name element to
818 determine which structure element to set and the value element to determine
819 what to set it to. Several helper functions are available for this
820 purpose (see above).
821
822 int i2r(struct v3_ext_method *method, void *ext, BIO *out, int indent);
823
824 This function is passed the internal extension structure in the ext parameter
825 and sends out a human readable version of the extension to out. The 'indent'
826 parameter should be noted to determine the necessary amount of indentation
827 needed on the output.
828
829 void * r2i(struct v3_ext_method *method, struct v3_ext_ctx *ctx, char *str);
830
831 This is just passed the string representation of the extension. It is intended
832 to be used for more elaborate extensions where the standard single and multi
833 valued options are insufficient. They can use the 'ctx' parameter to parse the
834 configuration database themselves. See the context functions section for details
835 of how to do this.
836
837 Note: although this type takes the same parameters as the "r2s" function there
838 is a subtle difference. Whereas an "r2i" function can access a configuration
839 database an "s2i" function MUST NOT. This is so the internal code can safely
840 assume that an "s2i" function will work without a configuration database.
841
842 ==============================================================================
843                             PKCS#12 Library
844 ==============================================================================
845
846 This section describes the internal PKCS#12 support. There are very few
847 differences between the old external library and the new internal code at
848 present. This may well change because the external library will not be updated
849 much in future.
850
851 This version now includes a couple of high level PKCS#12 functions which
852 generally "do the right thing" and should make it much easier to handle PKCS#12
853 structures.
854
855 HIGH LEVEL FUNCTIONS.
856
857 For most applications you only need concern yourself with the high level
858 functions. They can parse and generate simple PKCS#12 files as produced by
859 Netscape and MSIE or indeed any compliant PKCS#12 file containing a single
860 private key and certificate pair.
861
862 1. Initialisation and cleanup.
863
864 No special initialisation is needed for the internal PKCS#12 library: the 
865 standard SSLeay_add_all_algorithms() is sufficient. If you do not wish to
866 add all algorithms (you should at least add SHA1 though) then you can manually
867 initialise the PKCS#12 library with:
868
869 PKCS12_PBE_add();
870
871 The memory allocated by the PKCS#12 library is freed up when EVP_cleanup() is
872 called or it can be directly freed with:
873
874 EVP_PBE_cleanup();
875
876 after this call (or EVP_cleanup() ) no more PKCS#12 library functions should
877 be called.
878
879 2. I/O functions.
880
881 i2d_PKCS12_bio(bp, p12)
882
883 This writes out a PKCS12 structure to a BIO.
884
885 i2d_PKCS12_fp(fp, p12)
886
887 This is the same but for a FILE pointer.
888
889 d2i_PKCS12_bio(bp, p12)
890
891 This reads in a PKCS12 structure from a BIO.
892
893 d2i_PKCS12_fp(fp, p12)
894
895 This is the same but for a FILE pointer.
896
897 3. High level functions.
898
899 3.1 Parsing with PKCS12_parse().
900
901 int PKCS12_parse(PKCS12 *p12, char *pass, EVP_PKEY **pkey, X509 **cert,
902                                                                  STACK **ca);
903
904 This function takes a PKCS12 structure and a password (ASCII, null terminated)
905 and returns the private key, the corresponding certificate and any CA
906 certificates. If any of these is not required it can be passed as a NULL.
907 The 'ca' parameter should be either NULL, a pointer to NULL or a valid STACK
908 structure. Typically to read in a PKCS#12 file you might do:
909
910 p12 = d2i_PKCS12_fp(fp, NULL);
911 PKCS12_parse(p12, password, &pkey, &cert, NULL);        /* CAs not wanted */
912 PKCS12_free(p12);
913
914 3.2 PKCS#12 creation with PKCS12_create().
915
916 PKCS12 *PKCS12_create(char *pass, char *name, EVP_PKEY *pkey, X509 *cert,
917                         STACK *ca, int nid_key, int nid_cert, int iter,
918                                                  int mac_iter, int keytype);
919
920 This function will create a PKCS12 structure from a given password, name,
921 private key, certificate and optional STACK of CA certificates. The remaining
922 5 parameters can be set to 0 and sensible defaults will be used.
923
924 The parameters nid_key and nid_cert are the key and certificate encryption
925 algorithms, iter is the encryption iteration count, mac_iter is the MAC
926 iteration count and keytype is the type of private key. If you really want
927 to know what these last 5 parameters do then read the low level section.
928
929 Typically to create a PKCS#12 file the following could be used:
930
931 p12 = PKCS12_create(pass, "My Certificate", pkey, cert, NULL, 0,0,0,0,0);
932 i2d_PKCS12_fp(fp, p12);
933 PKCS12_free(p12);
934
935 3.3 Changing a PKCS#12 structure password.
936
937 int PKCS12_newpass(PKCS12 *p12, char *oldpass, char *newpass);
938
939 This changes the password of an already existing PKCS#12 structure. oldpass
940 is the old password and newpass is the new one. An error occurs if the old
941 password is incorrect.
942
943 LOW LEVEL FUNCTIONS.
944
945 In some cases the high level functions do not provide the necessary
946 functionality. For example if you want to generate or parse more complex
947 PKCS#12 files. The sample pkcs12 application uses the low level functions
948 to display details about the internal structure of a PKCS#12 file.
949
950 Introduction.
951
952 This is a brief description of how a PKCS#12 file is represented internally:
953 some knowledge of PKCS#12 is assumed.
954
955 A PKCS#12 object contains several levels.
956
957 At the lowest level is a PKCS12_SAFEBAG. This can contain a certificate, a
958 CRL, a private key, encrypted or unencrypted, a set of safebags (so the
959 structure can be nested) or other secrets (not documented at present). 
960 A safebag can optionally have attributes, currently these are: a unicode
961 friendlyName (a Unicode string) or a localKeyID (a string of bytes).
962
963 At the next level is an authSafe which is a set of safebags collected into
964 a PKCS#7 ContentInfo. This can be just plain data, or encrypted itself.
965
966 At the top level is the PKCS12 structure itself which contains a set of
967 authSafes in an embedded PKCS#7 Contentinfo of type data. In addition it
968 contains a MAC which is a kind of password protected digest to preserve
969 integrity (so any unencrypted stuff below can't be tampered with).
970
971 The reason for these levels is so various objects can be encrypted in various
972 ways. For example you might want to encrypt a set of private keys with
973 triple-DES and then include the related certificates either unencrypted or
974 with lower encryption. Yes it's the dreaded crypto laws at work again which
975 allow strong encryption on private keys and only weak encryption on other
976 stuff.
977
978 To build one of these things you turn all certificates and keys into safebags
979 (with optional attributes). You collect the safebags into (one or more) STACKS
980 and convert these into authsafes (encrypted or unencrypted).  The authsafes
981 are collected into a STACK and added to a PKCS12 structure.  Finally a MAC
982 inserted.
983
984 Pulling one apart is basically the reverse process. The MAC is verified against
985 the given password. The authsafes are extracted and each authsafe split into
986 a set of safebags (possibly involving decryption). Finally the safebags are
987 decomposed into the original keys and certificates and the attributes used to
988 match up private key and certificate pairs.
989
990 Anyway here are the functions that do the dirty work.
991
992 1. Construction functions.
993
994 1.1 Safebag functions.
995
996 M_PKCS12_x5092certbag(x509)
997
998 This macro takes an X509 structure and returns a certificate bag. The
999 X509 structure can be freed up after calling this function.
1000
1001 M_PKCS12_x509crl2certbag(crl)
1002
1003 As above but for a CRL.
1004
1005 PKCS8_PRIV_KEY_INFO *PKEY2PKCS8(EVP_PKEY *pkey)
1006
1007 Take a private key and convert it into a PKCS#8 PrivateKeyInfo structure.
1008 Works for both RSA and DSA private keys. NB since the PKCS#8 PrivateKeyInfo
1009 structure contains a private key data in plain text form it should be free'd
1010 up as soon as it has been encrypted for security reasons (freeing up the
1011 structure zeros out the sensitive data). This can be done with
1012 PKCS8_PRIV_KEY_INFO_free().
1013
1014 PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage)
1015
1016 This sets the key type when a key is imported into MSIE or Outlook 98. Two
1017 values are currently supported: KEY_EX and KEY_SIG. KEY_EX is an exchange type
1018 key that can also be used for signing but its size is limited in the export
1019 versions of MS software to 512 bits, it is also the default. KEY_SIG is a
1020 signing only key but the keysize is unlimited (well 16K is supposed to work).
1021 If you are using the domestic version of MSIE then you can ignore this because
1022 KEY_EX is not limited and can be used for both.
1023
1024 PKCS12_SAFEBAG *PKCS12_MAKE_KEYBAG(PKCS8_PRIV_KEY_INFO *p8)
1025
1026 Convert a PKCS8 private key structure into a keybag. This routine embeds the
1027 p8 structure in the keybag so p8 should not be freed up or used after it is
1028 called.  The p8 structure will be freed up when the safebag is freed.
1029
1030 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)
1031
1032 Convert a PKCS#8 structure into a shrouded key bag (encrypted). p8 is not
1033 embedded and can be freed up after use.
1034
1035 int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name, int namelen)
1036 int PKCS12_add_friendlyname(PKCS12_SAFEBAG *bag, unsigned char *name, int namelen)
1037
1038 Add a local key id or a friendlyname to a safebag.
1039
1040 1.2 Authsafe functions.
1041
1042 PKCS7 *PKCS12_pack_p7data(STACK *sk)
1043 Take a stack of safebags and convert them into an unencrypted authsafe. The
1044 stack of safebags can be freed up after calling this function.
1045
1046 PKCS7 *PKCS12_pack_p7encdata(int pbe_nid, unsigned char *pass, int passlen, unsigned char *salt, int saltlen, int iter, STACK *bags);
1047
1048 As above but encrypted.
1049
1050 1.3 PKCS12 functions.
1051
1052 PKCS12 *PKCS12_init(int mode)
1053
1054 Initialise a PKCS12 structure (currently mode should be NID_pkcs7_data).
1055
1056 M_PKCS12_pack_authsafes(p12, safes)
1057
1058 This macro takes a STACK of authsafes and adds them to a PKCS#12 structure.
1059
1060 int PKCS12_set_mac(PKCS12 *p12, unsigned char *pass, int passlen, unsigned char *salt, int saltlen, int iter, EVP_MD *md_type);
1061
1062 Add a MAC to a PKCS12 structure. If EVP_MD is NULL use SHA-1, the spec suggests
1063 that SHA-1 should be used.
1064
1065 2. Extraction Functions.
1066
1067 2.1 Safebags.
1068
1069 M_PKCS12_bag_type(bag)
1070
1071 Return the type of "bag". Returns one of the following
1072
1073 NID_keyBag
1074 NID_pkcs8ShroudedKeyBag                 7
1075 NID_certBag                             8
1076 NID_crlBag                              9
1077 NID_secretBag                           10
1078 NID_safeContentsBag                     11
1079
1080 M_PKCS12_cert_bag_type(bag)
1081
1082 Returns type of certificate bag, following are understood.
1083
1084 NID_x509Certificate                     14
1085 NID_sdsiCertificate                     15
1086
1087 M_PKCS12_crl_bag_type(bag)
1088
1089 Returns crl bag type, currently only NID_crlBag is recognised.
1090
1091 M_PKCS12_certbag2x509(bag)
1092
1093 This macro extracts an X509 certificate from a certificate bag.
1094
1095 M_PKCS12_certbag2x509crl(bag)
1096
1097 As above but for a CRL.
1098
1099 EVP_PKEY * PKCS82PKEY(PKCS8_PRIV_KEY_INFO *p8)
1100
1101 Extract a private key from a PKCS8 private key info structure.
1102
1103 M_PKCS12_decrypt_skey(bag, pass, passlen) 
1104
1105 Decrypt a shrouded key bag and return a PKCS8 private key info structure.
1106 Works with both RSA and DSA keys
1107
1108 char *PKCS12_get_friendlyname(bag)
1109
1110 Returns the friendlyName of a bag if present or NULL if none. The returned
1111 string is a null terminated ASCII string allocated with Malloc(). It should 
1112 thus be freed up with Free() after use.
1113
1114 2.2 AuthSafe functions.
1115
1116 M_PKCS12_unpack_p7data(p7)
1117
1118 Extract a STACK of safe bags from a PKCS#7 data ContentInfo.
1119
1120 #define M_PKCS12_unpack_p7encdata(p7, pass, passlen)
1121
1122 As above but for an encrypted content info.
1123
1124 2.3 PKCS12 functions.
1125
1126 M_PKCS12_unpack_authsafes(p12)
1127
1128 Extract a STACK of authsafes from a PKCS12 structure.
1129
1130 M_PKCS12_mac_present(p12)
1131
1132 Check to see if a MAC is present.
1133
1134 int PKCS12_verify_mac(PKCS12 *p12, unsigned char *pass, int passlen)
1135
1136 Verify a MAC on a PKCS12 structure. Returns an error if MAC not present.
1137
1138
1139 Notes.
1140
1141 1. All the function return 0 or NULL on error.
1142 2. Encryption based functions take a common set of parameters. These are
1143 described below.
1144
1145 pass, passlen
1146 ASCII password and length. The password on the MAC is called the "integrity
1147 password" the encryption password is called the "privacy password" in the
1148 PKCS#12 documentation. The passwords do not have to be the same. If -1 is
1149 passed for the length it is worked out by the function itself (currently
1150 this is sometimes done whatever is passed as the length but that may change).
1151
1152 salt, saltlen
1153 A 'salt' if salt is NULL a random salt is used. If saltlen is also zero a
1154 default length is used.
1155
1156 iter
1157 Iteration count. This is a measure of how many times an internal function is
1158 called to encrypt the data. The larger this value is the longer it takes, it
1159 makes dictionary attacks on passwords harder. NOTE: Some implementations do
1160 not support an iteration count on the MAC. If the password for the MAC and
1161 encryption is the same then there is no point in having a high iteration
1162 count for encryption if the MAC has no count. The MAC could be attacked
1163 and the password used for the main decryption.
1164
1165 pbe_nid
1166 This is the NID of the password based encryption method used. The following are
1167 supported.
1168 NID_pbe_WithSHA1And128BitRC4
1169 NID_pbe_WithSHA1And40BitRC4
1170 NID_pbe_WithSHA1And3_Key_TripleDES_CBC
1171 NID_pbe_WithSHA1And2_Key_TripleDES_CBC
1172 NID_pbe_WithSHA1And128BitRC2_CBC
1173 NID_pbe_WithSHA1And40BitRC2_CBC
1174
1175 Which you use depends on the implementation you are exporting to. "Export
1176 grade" (i.e. cryptographically challenged) products cannot support all
1177 algorithms. Typically you may be able to use any encryption on shrouded key
1178 bags but they must then be placed in an unencrypted authsafe. Other authsafes
1179 may only support 40bit encryption. Of course if you are using SSLeay
1180 throughout you can strongly encrypt everything and have high iteration counts
1181 on everything.
1182
1183 3. For decryption routines only the password and length are needed.
1184
1185 4. Unlike the external version the nid's of objects are the values of the
1186 constants: that is NID_certBag is the real nid, therefore there is no 
1187 PKCS12_obj_offset() function.  Note the object constants are not the same as
1188 those of the external version. If you use these constants then you will need
1189 to recompile your code.
1190
1191 5. With the exception of PKCS12_MAKE_KEYBAG(), after calling any function or 
1192 macro of the form PKCS12_MAKE_SOMETHING(other) the "other" structure can be
1193 reused or freed up safely.
1194