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