08e247633f1abd9338a90501fc899d320ac7fbfb
[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 section.
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 Extended Key Usage.
319
320 This extensions consists of a list of usages.
321
322 These can either be object short names of the dotted numerical form of OIDs.
323 While any OID can be used only certain values make sense. In partiular the
324 following PKIX, NS and MS values are meaningful:
325
326 Value                   Meaning
327 -----                   -------
328 serverAuth              SSL/TLS Web Server Authentication.
329 clientAuth              SSL/TLS Web Client Authentication.
330 codeSigning             Code signing.
331 emailProtection         E-mail Protection (S/MIME).
332 timeStamping            Trusted Timestamping
333 msCodeInd               Microsoft Individual Code Signing (authenticode)
334 msCodeCom               Microsoft Commercial Code Signing (authenticode)
335 msCTLSign               Microsoft Trust List Signing
336 msSGC                   Microsoft Server Gated Crypto
337 msEFS                   Microsoft Encrypted File System
338 nsSGC                   Netscape Server Gated Crypto
339
340 For example, under IE5 a CA can be used for any purpose: by including a list
341 of the above usages the CA can be restricted to only authorised uses.
342
343 Note: software packages may place additional interpretations on certificate 
344 use, in particular some usages may only work for selected CAs. Don't for example
345 expect just including msSGC or nsSGC will automatically mean that a certificate
346 can be used for SGC ("step up" encryption) otherwise anyone could use it.
347
348 Examples:
349
350 extendedKeyUsage=critical,codeSigning,1.2.3.4
351 extendedKeyUsage=nsSGC,msSGC
352
353 Subject Key Identifier.
354
355 This is really a string extension and can take two possible values. Either
356 a hex string giving details of the extension value to include or the word
357 'hash' which then automatically follow PKIX guidelines in selecting and
358 appropriate key identifier. The use of the hex string is strongly discouraged.
359
360 Example: subjectKeyIdentifier=hash
361
362 Authority Key Identifier.
363
364 The authority key identifier extension permits two options. keyid and issuer:
365 both can take the optional value "always".
366
367 If the keyid option is present an attempt is made to copy the subject key
368 identifier from the parent certificate. If the value "always" is present
369 then an error is returned if the option fails.
370
371 The issuer option copies the issuer and serial number from the issuer
372 certificate. Normally this will only be done if the keyid option fails or
373 is not included: the "always" flag will always include the value.
374
375 Subject Alternative Name.
376
377 The subject alternative name extension allows various literal values to be
378 included in the configuration file. These include "email" (an email address)
379 "URI" a uniform resource indicator, "DNS" (a DNS domain name), RID (a
380 registered ID: OBJECT IDENTIFIER) and IP (and IP address).
381
382 Also the email option include a special 'copy' value. This will automatically
383 include and email addresses contained in the certificate subject name in
384 the extension.
385
386 Examples:
387
388 subjectAltName=email:copy,email:my@other.address,URL:http://my.url.here/
389 subjectAltName=email:my@other.address,RID:1.2.3.4
390
391 Issuer Alternative Name.
392
393 The issuer alternative name option supports all the literal options of
394 subject alternative name. It does *not* support the email:copy option because
395 that would not make sense. It does support an additional issuer:copy option
396 that will copy all the subject alternative name values from the issuer 
397 certificate (if possible).
398
399 CRL distribution points.
400
401 This is a multi-valued extension that supports all the literal options of
402 subject alternative name. Of the few software packages that currently interpret
403 this extension most only interpret the URI option.
404
405 Currently each option will set a new DistributionPoint with the fullName
406 field set to the given value.
407
408 Other fields like cRLissuer and reasons cannot currently be set or displayed:
409 at this time no examples were available that used these fields.
410
411 If you see this extension with <UNSUPPORTED> when you attempt to print it out
412 or it doesn't appear to display correctly then let me know, including the
413 certificate (mail me at steve@openssl.org) .
414
415 Examples:
416
417 crlDistributionPoints=URI:http://www.myhost.com/myca.crl
418 crlDistributionPoints=URI:http://www.my.com/my.crl,URI:http://www.oth.com/my.crl
419
420 Certificate Policies.
421
422 This is a RAW extension. It attempts to display the contents of this extension:
423 unfortunately this extension is often improperly encoded.
424
425 The certificate policies extension will rarely be used in practice: few
426 software packages interpret it correctly or at all. IE5 does partially
427 support this extension: but it needs the 'ia5org' option because it will
428 only correctly support a broken encoding. Of the options below only the
429 policy OID, explicitText and CPS options are displayed with IE5.
430
431 All the fields of this extension can be set by using the appropriate syntax.
432
433 If you follow the PKIX recommendations of not including any qualifiers and just
434 using only one OID then you just include the value of that OID. Multiple OIDs
435 can be set separated by commas, for example:
436
437 certificatePolicies= 1.2.4.5, 1.1.3.4
438
439 If you wish to include qualifiers then the policy OID and qualifiers need to
440 be specified in a separate section: this is done by using the @section syntax
441 instead of a literal OID value.
442
443 The section referred to must include the policy OID using the name
444 policyIdentifier, cPSuri qualifiers can be included using the syntax:
445
446 CPS.nnn=value
447
448 userNotice qualifiers can be set using the syntax:
449
450 userNotice.nnn=@notice
451
452 The value of the userNotice qualifier is specified in the relevant section.
453 This section can include explicitText, organization and noticeNumbers
454 options. explicitText and organization are text strings, noticeNumbers is a
455 comma separated list of numbers. The organization and noticeNumbers options
456 (if included) must BOTH be present. If you use the userNotice option with IE5
457 then you need the 'ia5org' option at the top level to modify the encoding:
458 otherwise it will not be interpreted properly.
459
460 Example:
461
462 certificatePolicies=ia5org,1.2.3.4,1.5.6.7.8,@polsect
463
464 [polsect]
465
466 policyIdentifier = 1.3.5.8
467 CPS.1="http://my.host.name/"
468 CPS.2="http://my.your.name/"
469 userNotice.1=@notice
470
471 [notice]
472
473 explicitText="Explicit Text Here"
474 organization="Organisation Name"
475 noticeNumbers=1,2,3,4
476
477 TECHNICAL NOTE: the ia5org option changes the type of the 'organization' field,
478 according to PKIX it should be of type DisplayText but Verisign uses an 
479 IA5STRING and IE5 needs this too.
480
481 Display only extensions.
482
483 Some extensions are only partially supported and currently are only displayed
484 but cannot be set. These include private key usage period, CRL number, and
485 CRL reason.
486
487 ==============================================================================
488                 X509V3 Extension code: programmers guide
489 ==============================================================================
490
491 The purpose of the extension code is twofold. It allows an extension to be
492 created from a string or structure describing its contents and it prints out an
493 extension in a human or machine readable form.
494
495 1. Initialisation and cleanup.
496
497 X509V3_add_standard_extensions();
498
499 This function should be called before any other extension code. It adds support
500 for some common PKIX and Netscape extensions. Additional custom extensions can
501 be added as well (see later).
502
503 void X509V3_EXT_cleanup(void);
504
505 This function should be called last to cleanup the extension code. After this
506 call no other extension calls should be made.
507
508 2. Printing and parsing extensions.
509
510 The simplest way to print out extensions is via the standard X509 printing
511 routines: if you use the standard X509_print() function, the supported
512 extensions will be printed out automatically.
513
514 The following functions allow finer control over extension display:
515
516 int X509V3_EXT_print(BIO *out, X509_EXTENSION *ext, int flag, int indent);
517 int X509V3_EXT_print_fp(FILE *out, X509_EXTENSION *ext, int flag, int indent);
518
519 These two functions print out an individual extension to a BIO or FILE pointer.
520 Currently the flag argument is unused and should be set to 0. The 'indent'
521 argument is the number of spaces to indent each line.
522
523 void *X509V3_EXT_d2i(X509_EXTENSION *ext);
524
525 This function parses an extension and returns its internal structure. The
526 precise structure you get back depends on the extension being parsed. If the
527 extension if basicConstraints you will get back a pointer to a
528 BASIC_CONSTRAINTS structure. Check out the source in crypto/x509v3 for more
529 details about the structures returned. The returned structure should be freed
530 after use using the relevant free function, BASIC_CONSTRAINTS_free() for 
531 example.
532
533 3. Generating extensions.
534
535 An extension will typically be generated from a configuration file, or some
536 other kind of configuration database.
537
538 int X509V3_EXT_add_conf(LHASH *conf, X509V3_CTX *ctx, char *section,
539                                                                  X509 *cert);
540 int X509V3_EXT_CRL_add_conf(LHASH *conf, X509V3_CTX *ctx, char *section,
541                                                                  X509_CRL *crl);
542
543 These functions add all the extensions in the given section to the given
544 certificate or CRL. They will normally be called just before the certificate
545 or CRL is due to be signed. Both return 0 on error on non zero for success.
546
547 In each case 'conf' is the LHASH pointer of the configuration file to use
548 and 'section' is the section containing the extension details.
549
550 See the 'context functions' section for a description of the ctx paramater.
551
552
553 X509_EXTENSION *X509V3_EXT_conf(LHASH *conf, X509V3_CTX *ctx, char *name,
554                                                                  char *value);
555
556 This function returns an extension based on a name and value pair, if the
557 pair will not need to access other sections in a config file (or there is no
558 config file) then the 'conf' parameter can be set to NULL.
559
560 X509_EXTENSION *X509V3_EXT_conf_nid(char *conf, X509V3_CTX *ctx, int nid,
561                                                                  char *value);
562
563 This function creates an extension in the same way as X509V3_EXT_conf() but
564 takes the NID of the extension rather than its name.
565
566 For example to produce basicConstraints with the CA flag and a path length of
567 10:
568
569 x = X509V3_EXT_conf_nid(NULL, NULL, NID_basic_constraints,"CA:TRUE,pathlen:10");
570
571
572 X509_EXTENSION *X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc);
573
574 This function sets up an extension from its internal structure. The ext_nid
575 parameter is the NID of the extension and 'crit' is the critical flag.
576
577 4. Context functions.
578
579 The following functions set and manipulate an extension context structure.
580 The purpose of the extension context is to allow the extension code to
581 access various structures relating to the "environment" of the certificate:
582 for example the issuers certificate or the certificate request.
583
584 void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subject,
585                                  X509_REQ *req, X509_CRL *crl, int flags);
586
587 This function sets up an X509V3_CTX structure with details of the certificate
588 environment: specifically the issuers certificate, the subject certificate,
589 the certificate request and the CRL: if these are not relevant or not
590 available then they can be set to NULL. The 'flags' parameter should be set
591 to zero.
592
593 X509V3_set_ctx_test(ctx)
594
595 This macro is used to set the 'ctx' structure to a 'test' value: this is to
596 allow the syntax of an extension (or configuration file) to be tested.
597
598 X509V3_set_ctx_nodb(ctx)
599
600 This macro is used when no configuration database is present.
601
602 void X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH *lhash);
603
604 This function is used to set the configuration database when it is an LHASH
605 structure: typically a configuration file.
606
607 The following functions are used to access a configuration database: they
608 should only be used in RAW extensions.
609
610 char * X509V3_get_string(X509V3_CTX *ctx, char *name, char *section);
611
612 This function returns the value of the parameter "name" in "section", or NULL
613 if there has been an error.
614
615 void X509V3_string_free(X509V3_CTX *ctx, char *str);
616
617 This function frees up the string returned by the above function.
618
619 STACK_OF(CONF_VALUE) * X509V3_get_section(X509V3_CTX *ctx, char *section);
620
621 This function returns a whole section as a STACK_OF(CONF_VALUE) .
622
623 void X509V3_section_free( X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section);
624
625 This function frees up the STACK returned by the above function.
626
627 Note: it is possible to use the extension code with a custom configuration
628 database. To do this the "db_meth" element of the X509V3_CTX structure should
629 be set to an X509V3_CTX_METHOD structure. This structure contains the following
630 function pointers:
631
632 char * (*get_string)(void *db, char *section, char *value);
633 STACK_OF(CONF_VALUE) * (*get_section)(void *db, char *section);
634 void (*free_string)(void *db, char * string);
635 void (*free_section)(void *db, STACK_OF(CONF_VALUE) *section);
636
637 these will be called and passed the 'db' element in the X509V3_CTX structure
638 to access the database. If a given function is not implemented or not required
639 it can be set to NULL.
640
641 5. String helper functions.
642
643 There are several "i2s" and "s2i" functions that convert structures to and
644 from ASCII strings. In all the "i2s" cases the returned string should be
645 freed using Free() after use. Since some of these are part of other extension
646 code they may take a 'method' parameter. Unless otherwise stated it can be
647 safely set to NULL.
648
649 char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, ASN1_OCTET_STRING *oct);
650
651 This returns a hex string from an ASN1_OCTET_STRING.
652
653 char * i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, ASN1_INTEGER *aint);
654 char * i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *meth, ASN1_ENUMERATED *aint);
655
656 These return a string decimal representations of an ASN1_INTEGER and an
657 ASN1_ENUMERATED type, respectively.
658
659 ASN1_OCTET_STRING *s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
660                                                    X509V3_CTX *ctx, char *str);
661
662 This converts an ASCII hex string to an ASN1_OCTET_STRING.
663
664 ASN1_INTEGER * s2i_ASN1_INTEGER(X509V3_EXT_METHOD *meth, char *value);
665
666 This converts a decimal ASCII string into an ASN1_INTEGER.
667
668 6. Multi valued extension helper functions.
669
670 The following functions can be used to manipulate STACKs of CONF_VALUE
671 structures, as used by multi valued extensions.
672
673 int X509V3_get_value_bool(CONF_VALUE *value, int *asn1_bool);
674
675 This function expects a boolean value in 'value' and sets 'asn1_bool' to
676 it. That is it sets it to 0 for FALSE or 0xff for TRUE. The following
677 strings are acceptable: "TRUE", "true", "Y", "y", "YES", "yes", "FALSE"
678 "false", "N", "n", "NO" or "no".
679
680 int X509V3_get_value_int(CONF_VALUE *value, ASN1_INTEGER **aint);
681
682 This accepts a decimal integer of arbitrary length and sets an ASN1_INTEGER.
683
684 int X509V3_add_value(const char *name, const char *value,
685                                                 STACK_OF(CONF_VALUE) **extlist);
686
687 This simply adds a string name and value pair.
688
689 int X509V3_add_value_uchar(const char *name, const unsigned char *value,
690                                                 STACK_OF(CONF_VALUE) **extlist);
691
692 The same as above but for an unsigned character value.
693
694 int X509V3_add_value_bool(const char *name, int asn1_bool,
695                                                 STACK_OF(CONF_VALUE) **extlist);
696
697 This adds either "TRUE" or "FALSE" depending on the value of 'ans1_bool'
698
699 int X509V3_add_value_bool_nf(char *name, int asn1_bool,
700                                                 STACK_OF(CONF_VALUE) **extlist);
701
702 This is the same as above except it adds nothing if asn1_bool is FALSE.
703
704 int X509V3_add_value_int(const char *name, ASN1_INTEGER *aint,
705                                                 STACK_OF(CONF_VALUE) **extlist);
706
707 This function adds the value of the ASN1_INTEGER in decimal form.
708
709 7. Other helper functions.
710
711 <to be added>
712
713 ADDING CUSTOM EXTENSIONS.
714
715 Currently there are three types of supported extensions. 
716
717 String extensions are simple strings where the value is placed directly in the
718 extensions, and the string returned is printed out.
719
720 Multi value extensions are passed a STACK_OF(CONF_VALUE) name and value pairs
721 or return a STACK_OF(CONF_VALUE).
722
723 Raw extensions are just passed a BIO or a value and it is the extensions
724 responsiblity to handle all the necessary printing.
725
726 There are two ways to add an extension. One is simply as an alias to an already
727 existing extension. An alias is an extension that is identical in ASN1 structure
728 to an existing extension but has a different OBJECT IDENTIFIER. This can be
729 done by calling:
730
731 int X509V3_EXT_add_alias(int nid_to, int nid_from);
732
733 'nid_to' is the new extension NID and 'nid_from' is the already existing
734 extension NID.
735
736 Alternatively an extension can be written from scratch. This involves writing
737 the ASN1 code to encode and decode the extension and functions to print out and
738 generate the extension from strings. The relevant functions are then placed in
739 a X509V3_EXT_METHOD structure and int X509V3_EXT_add(X509V3_EXT_METHOD *ext);
740 called.
741
742 The X509V3_EXT_METHOD structure is described below.
743
744 strut {
745 int ext_nid;
746 int ext_flags;
747 X509V3_EXT_NEW ext_new;
748 X509V3_EXT_FREE ext_free;
749 X509V3_EXT_D2I d2i;
750 X509V3_EXT_I2D i2d;
751 X509V3_EXT_I2S i2s;
752 X509V3_EXT_S2I s2i;
753 X509V3_EXT_I2V i2v;
754 X509V3_EXT_V2I v2i;
755 X509V3_EXT_R2I r2i;
756 X509V3_EXT_I2R i2r;
757
758 void *usr_data;
759 };
760
761 The elements have the following meanings.
762
763 ext_nid         is the NID of the object identifier of the extension.
764
765 ext_flags       is set of flags. Currently the only external flag is
766                 X509V3_EXT_MULTILINE which means a multi valued extensions
767                 should be printed on separate lines.
768
769 usr_data        is an extension specific pointer to any relevant data. This
770                 allows extensions to share identical code but have different
771                 uses. An example of this is the bit string extension which uses
772                 usr_data to contain a list of the bit names.
773
774 All the remaining elements are function pointers.
775
776 ext_new         is a pointer to a function that allocates memory for the
777                 extension ASN1 structure: for example ASN1_OBJECT_new().
778
779 ext_free        is a pointer to a function that free up memory of the extension
780                 ASN1 structure: for example ASN1_OBJECT_free().
781
782 d2i             is the standard ASN1 function that converts a DER buffer into
783                 the internal ASN1 structure: for example d2i_ASN1_IA5STRING().
784
785 i2d             is the standard ASN1 function that converts the internal
786                 structure into the DER representation: for example
787                 i2d_ASN1_IA5STRING().
788
789 The remaining functions are depend on the type of extension. One i2X and
790 one X2i should be set and the rest set to NULL. The types set do not need
791 to match up, for example the extension could be set using the multi valued
792 v2i function and printed out using the raw i2r.
793
794 All functions have the X509V3_EXT_METHOD passed to them in the 'method'
795 parameter and an X509V3_CTX structure. Extension code can then access the
796 parent structure via the 'method' parameter to for example make use of the value
797 of usr_data. If the code needs to use detail relating to the request it can
798 use the 'ctx' parameter.
799
800 A note should be given here about the 'flags' member of the 'ctx' parameter.
801 If it has the value CTX_TEST then the configuration syntax is being checked
802 and no actual certificate or CRL exists. Therefore any attempt in the config
803 file to access such information should silently succeed. If the syntax is OK
804 then it should simply return a (possibly bogus) extension, otherwise it
805 should return NULL.
806
807 char *i2s(struct v3_ext_method *method, void *ext);
808
809 This function takes the internal structure in the ext parameter and returns
810 a Malloc'ed string representing its value.
811
812 void * s2i(struct v3_ext_method *method, struct v3_ext_ctx *ctx, char *str);
813
814 This function takes the string representation in the ext parameter and returns
815 an allocated internal structure: ext_free() will be used on this internal
816 structure after use.
817
818 i2v and v2i handle a STACK_OF(CONF_VALUE):
819
820 typedef struct
821 {
822         char *section;
823         char *name;
824         char *value;
825 } CONF_VALUE;
826
827 Only the name and value members are currently used.
828
829 STACK_OF(CONF_VALUE) * i2v(struct v3_ext_method *method, void *ext);
830
831 This function is passed the internal structure in the ext parameter and
832 returns a STACK of CONF_VALUE structures. The values of name, value,
833 section and the structure itself will be freed up with Free after use.
834 Several helper functions are available to add values to this STACK.
835
836 void * v2i(struct v3_ext_method *method, struct v3_ext_ctx *ctx,
837                                                 STACK_OF(CONF_VALUE) *values);
838
839 This function takes a STACK_OF(CONF_VALUE) structures and should set the
840 values of the external structure. This typically uses the name element to
841 determine which structure element to set and the value element to determine
842 what to set it to. Several helper functions are available for this
843 purpose (see above).
844
845 int i2r(struct v3_ext_method *method, void *ext, BIO *out, int indent);
846
847 This function is passed the internal extension structure in the ext parameter
848 and sends out a human readable version of the extension to out. The 'indent'
849 paremeter should be noted to determine the necessary amount of indentation
850 needed on the output.
851
852 void * r2i(struct v3_ext_method *method, struct v3_ext_ctx *ctx, char *str);
853
854 This is just passed the string representation of the extension. It is intended
855 to be used for more elaborate extensions where the standard single and multi
856 valued options are insufficient. They can use the 'ctx' parameter to parse the
857 configuration database themselves. See the context functions section for details
858 of how to do this.
859
860 Note: although this type takes the same parameters as the "r2s" function there
861 is a subtle difference. Whereas an "r2i" function can access a configuration
862 database an "s2i" function MUST NOT. This is so the internal code can safely
863 assume that an "s2i" function will work without a configuration database.
864
865 ==============================================================================
866                             PKCS#12 Library
867 ==============================================================================
868
869 This section describes the internal PKCS#12 support. There are very few
870 differences between the old external library and the new internal code at
871 present. This may well change because the external library will not be updated
872 much in future.
873
874 This version now includes a couple of high level PKCS#12 functions which
875 generally "do the right thing" and should make it much easier to handle PKCS#12
876 structures.
877
878 HIGH LEVEL FUNCTIONS.
879
880 For most applications you only need concern yourself with the high level
881 functions. They can parse and generate simple PKCS#12 files as produced by
882 Netscape and MSIE or indeed any compliant PKCS#12 file containing a single
883 private key and certificate pair.
884
885 1. Initialisation and cleanup.
886
887 No special initialisation is needed for the internal PKCS#12 library: the 
888 standard SSLeay_add_all_algorithms() is sufficient. If you do not wish to
889 add all algorithms (you should at least add SHA1 though) then you can manually
890 initialise the PKCS#12 library with:
891
892 PKCS12_PBE_add();
893
894 The memory allocated by the PKCS#12 library is freed up when EVP_cleanup() is
895 called or it can be directly freed with:
896
897 EVP_PBE_cleanup();
898
899 after this call (or EVP_cleanup() ) no more PKCS#12 library functions should
900 be called.
901
902 2. I/O functions.
903
904 i2d_PKCS12_bio(bp, p12)
905
906 This writes out a PKCS12 structure to a BIO.
907
908 i2d_PKCS12_fp(fp, p12)
909
910 This is the same but for a FILE pointer.
911
912 d2i_PKCS12_bio(bp, p12)
913
914 This reads in a PKCS12 structure from a BIO.
915
916 d2i_PKCS12_fp(fp, p12)
917
918 This is the same but for a FILE pointer.
919
920 3. Parsing and creation functions.
921
922 3.1 Parsing with PKCS12_parse().
923
924 int PKCS12_parse(PKCS12 *p12, char *pass, EVP_PKEY **pkey, X509 **cert,
925                                                                  STACK **ca);
926
927 This function takes a PKCS12 structure and a password (ASCII, null terminated)
928 and returns the private key, the corresponding certificate and any CA
929 certificates. If any of these is not required it can be passed as a NULL.
930 The 'ca' parameter should be either NULL, a pointer to NULL or a valid STACK
931 structure. Typically to read in a PKCS#12 file you might do:
932
933 p12 = d2i_PKCS12_fp(fp, NULL);
934 PKCS12_parse(p12, password, &pkey, &cert, NULL);        /* CAs not wanted */
935 PKCS12_free(p12);
936
937 3.2 PKCS#12 creation with PKCS12_create().
938
939 PKCS12 *PKCS12_create(char *pass, char *name, EVP_PKEY *pkey, X509 *cert,
940                         STACK *ca, int nid_key, int nid_cert, int iter,
941                                                  int mac_iter, int keytype);
942
943 This function will create a PKCS12 structure from a given password, name,
944 private key, certificate and optional STACK of CA certificates. The remaining
945 5 parameters can be set to 0 and sensible defaults will be used.
946
947 The parameters nid_key and nid_cert are the key and certificate encryption
948 algorithms, iter is the encryption iteration count, mac_iter is the MAC
949 iteration count and keytype is the type of private key. If you really want
950 to know what these last 5 parameters do then read the low level section.
951
952 Typically to create a PKCS#12 file the following could be used:
953
954 p12 = PKCS12_create(pass, "My Certificate", pkey, cert, NULL, 0,0,0,0,0);
955 i2d_PKCS12_fp(fp, p12);
956 PKCS12_free(p12);
957
958 LOW LEVEL FUNCTIONS.
959
960 In some cases the high level functions do not provide the necessary
961 functionality. For example if you want to generate or parse more complex
962 PKCS#12 files. The sample pkcs12 application uses the low level functions
963 to display details about the internal structure of a PKCS#12 file.
964
965 Introduction.
966
967 This is a brief description of how a PKCS#12 file is represented internally:
968 some knowledge of PKCS#12 is assumed.
969
970 A PKCS#12 object contains several levels.
971
972 At the lowest level is a PKCS12_SAFEBAG. This can contain a certificate, a
973 CRL, a private key, encrypted or unencrypted, a set of safebags (so the
974 structure can be nested) or other secrets (not documented at present). 
975 A safebag can optionally have attributes, currently these are: a unicode
976 friendlyName (a Unicode string) or a localKeyID (a string of bytes).
977
978 At the next level is an authSafe which is a set of safebags collected into
979 a PKCS#7 ContentInfo. This can be just plain data, or encrypted itself.
980
981 At the top level is the PKCS12 structure itself which contains a set of
982 authSafes in an embedded PKCS#7 Contentinfo of type data. In addition it
983 contains a MAC which is a kind of password protected digest to preserve
984 integrity (so any unencrypted stuff below can't be tampered with).
985
986 The reason for these levels is so various objects can be encrypted in various
987 ways. For example you might want to encrypt a set of private keys with
988 triple-DES and then include the related certificates either unencrypted or
989 with lower encryption. Yes it's the dreaded crypto laws at work again which
990 allow strong encryption on private keys and only weak encryption on other
991 stuff.
992
993 To build one of these things you turn all certificates and keys into safebags
994 (with optional attributes). You collect the safebags into (one or more) STACKS
995 and convert these into authsafes (encrypted or unencrypted).  The authsafes
996 are collected into a STACK and added to a PKCS12 structure.  Finally a MAC
997 inserted.
998
999 Pulling one apart is basically the reverse process. The MAC is verified against
1000 the given password. The authsafes are extracted and each authsafe split into
1001 a set of safebags (possibly involving decryption). Finally the safebags are
1002 decomposed into the original keys and certificates and the attributes used to
1003 match up private key and certificate pairs.
1004
1005 Anyway here are the functions that do the dirty work.
1006
1007 1. Construction functions.
1008
1009 1.1 Safebag functions.
1010
1011 M_PKCS12_x5092certbag(x509)
1012
1013 This macro takes an X509 structure and returns a certificate bag. The
1014 X509 structure can be freed up after calling this function.
1015
1016 M_PKCS12_x509crl2certbag(crl)
1017
1018 As above but for a CRL.
1019
1020 PKCS8_PRIV_KEY_INFO *PKEY2PKCS8(EVP_PKEY *pkey)
1021
1022 Take a private key and convert it into a PKCS#8 PrivateKeyInfo structure.
1023 Works for both RSA and DSA private keys. NB since the PKCS#8 PrivateKeyInfo
1024 structure contains a private key data in plain text form it should be free'd
1025 up as soon as it has been encrypted for security reasons (freeing up the
1026 structure zeros out the sensitive data). This can be done with
1027 PKCS8_PRIV_KEY_INFO_free().
1028
1029 PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage)
1030
1031 This sets the key type when a key is imported into MSIE or Outlook 98. Two
1032 values are currently supported: KEY_EX and KEY_SIG. KEY_EX is an exchange type
1033 key that can also be used for signing but its size is limited in the export
1034 versions of MS software to 512 bits, it is also the default. KEY_SIG is a
1035 signing only key but the keysize is unlimited (well 16K is supposed to work).
1036 If you are using the domestic version of MSIE then you can ignore this because
1037 KEY_EX is not limited and can be used for both.
1038
1039 PKCS12_SAFEBAG *PKCS12_MAKE_KEYBAG(PKCS8_PRIV_KEY_INFO *p8)
1040
1041 Convert a PKCS8 private key structure into a keybag. This routine embeds the
1042 p8 structure in the keybag so p8 should not be freed up or used after it is
1043 called.  The p8 structure will be freed up when the safebag is freed.
1044
1045 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)
1046
1047 Convert a PKCS#8 structure into a shrouded key bag (encrypted). p8 is not
1048 embedded and can be freed up after use.
1049
1050 int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name, int namelen)
1051 int PKCS12_add_friendlyname(PKCS12_SAFEBAG *bag, unsigned char *name, int namelen)
1052
1053 Add a local key id or a friendlyname to a safebag.
1054
1055 1.2 Authsafe functions.
1056
1057 PKCS7 *PKCS12_pack_p7data(STACK *sk)
1058 Take a stack of safebags and convert them into an unencrypted authsafe. The
1059 stack of safebags can be freed up after calling this function.
1060
1061 PKCS7 *PKCS12_pack_p7encdata(int pbe_nid, unsigned char *pass, int passlen, unsigned char *salt, int saltlen, int iter, STACK *bags);
1062
1063 As above but encrypted.
1064
1065 1.3 PKCS12 functions.
1066
1067 PKCS12 *PKCS12_init(int mode)
1068
1069 Initialise a PKCS12 structure (currently mode should be NID_pkcs7_data).
1070
1071 M_PKCS12_pack_authsafes(p12, safes)
1072
1073 This macro takes a STACK of authsafes and adds them to a PKCS#12 structure.
1074
1075 int PKCS12_set_mac(PKCS12 *p12, unsigned char *pass, int passlen, unsigned char *salt, int saltlen, int iter, EVP_MD *md_type);
1076
1077 Add a MAC to a PKCS12 structure. If EVP_MD is NULL use SHA-1, the spec suggests
1078 that SHA-1 should be used.
1079
1080 2. Extraction Functions.
1081
1082 2.1 Safebags.
1083
1084 M_PKCS12_bag_type(bag)
1085
1086 Return the type of "bag". Returns one of the following
1087
1088 NID_keyBag
1089 NID_pkcs8ShroudedKeyBag                 7
1090 NID_certBag                             8
1091 NID_crlBag                              9
1092 NID_secretBag                           10
1093 NID_safeContentsBag                     11
1094
1095 M_PKCS12_cert_bag_type(bag)
1096
1097 Returns type of certificate bag, following are understood.
1098
1099 NID_x509Certificate                     14
1100 NID_sdsiCertificate                     15
1101
1102 M_PKCS12_crl_bag_type(bag)
1103
1104 Returns crl bag type, currently only NID_crlBag is recognised.
1105
1106 M_PKCS12_certbag2x509(bag)
1107
1108 This macro extracts an X509 certificate from a certificate bag.
1109
1110 M_PKCS12_certbag2x509crl(bag)
1111
1112 As above but for a CRL.
1113
1114 EVP_PKEY * PKCS82PKEY(PKCS8_PRIV_KEY_INFO *p8)
1115
1116 Extract a private key from a PKCS8 private key info structure.
1117
1118 M_PKCS12_decrypt_skey(bag, pass, passlen) 
1119
1120 Decrypt a shrouded key bag and return a PKCS8 private key info structure.
1121 Works with both RSA and DSA keys
1122
1123 char *PKCS12_get_friendlyname(bag)
1124
1125 Returns the friendlyName of a bag if present or NULL if none. The returned
1126 string is a null terminated ASCII string allocated with Malloc(). It should 
1127 thus be freed up with Free() after use.
1128
1129 2.2 AuthSafe functions.
1130
1131 M_PKCS12_unpack_p7data(p7)
1132
1133 Extract a STACK of safe bags from a PKCS#7 data ContentInfo.
1134
1135 #define M_PKCS12_unpack_p7encdata(p7, pass, passlen)
1136
1137 As above but for an encrypted content info.
1138
1139 2.3 PKCS12 functions.
1140
1141 M_PKCS12_unpack_authsafes(p12)
1142
1143 Extract a STACK of authsafes from a PKCS12 structure.
1144
1145 M_PKCS12_mac_present(p12)
1146
1147 Check to see if a MAC is present.
1148
1149 int PKCS12_verify_mac(PKCS12 *p12, unsigned char *pass, int passlen)
1150
1151 Verify a MAC on a PKCS12 structure. Returns an error if MAC not present.
1152
1153
1154 Notes.
1155
1156 1. All the function return 0 or NULL on error.
1157 2. Encryption based functions take a common set of parameters. These are
1158 described below.
1159
1160 pass, passlen
1161 ASCII password and length. The password on the MAC is called the "integrity
1162 password" the encryption password is called the "privacy password" in the
1163 PKCS#12 documentation. The passwords do not have to be the same. If -1 is
1164 passed for the length it is worked out by the function itself (currently
1165 this is sometimes done whatever is passed as the length but that may change).
1166
1167 salt, saltlen
1168 A 'salt' if salt is NULL a random salt is used. If saltlen is also zero a
1169 default length is used.
1170
1171 iter
1172 Iteration count. This is a measure of how many times an internal function is
1173 called to encrypt the data. The larger this value is the longer it takes, it
1174 makes dictionary attacks on passwords harder. NOTE: Some implementations do
1175 not support an iteration count on the MAC. If the password for the MAC and
1176 encryption is the same then there is no point in having a high iteration
1177 count for encryption if the MAC has no count. The MAC could be attacked
1178 and the password used for the main decryption.
1179
1180 pbe_nid
1181 This is the NID of the password based encryption method used. The following are
1182 supported.
1183 NID_pbe_WithSHA1And128BitRC4
1184 NID_pbe_WithSHA1And40BitRC4
1185 NID_pbe_WithSHA1And3_Key_TripleDES_CBC
1186 NID_pbe_WithSHA1And2_Key_TripleDES_CBC
1187 NID_pbe_WithSHA1And128BitRC2_CBC
1188 NID_pbe_WithSHA1And40BitRC2_CBC
1189
1190 Which you use depends on the implementation you are exporting to. "Export
1191 grade" (i.e. cryptographically challenged) products cannot support all
1192 algorithms. Typically you may be able to use any encryption on shrouded key
1193 bags but they must then be placed in an unencrypted authsafe. Other authsafes
1194 may only support 40bit encryption. Of course if you are using SSLeay
1195 throughout you can strongly encrypt everything and have high iteration counts
1196 on everything.
1197
1198 3. For decryption routines only the password and length are needed.
1199
1200 4. Unlike the external version the nid's of objects are the values of the
1201 constants: that is NID_certBag is the real nid, therefore there is no 
1202 PKCS12_obj_offset() function.  Note the object constants are not the same as
1203 those of the external version. If you use these constants then you will need
1204 to recompile your code.
1205
1206 5. With the exception of PKCS12_MAKE_KEYBAG(), after calling any function or 
1207 macro of the form PKCS12_MAKE_SOMETHING(other) the "other" structure can be
1208 reused or freed up safely.
1209