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