idnits 2.17.1 draft-moriarty-pkcs5-v2dot1-04.txt: Checking boilerplate required by RFC 5378 and the IETF Trust (see https://trustee.ietf.org/license-info): ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/1id-guidelines.txt: ---------------------------------------------------------------------------- == The page length should not exceed 58 lines per page, but there was 1 longer page, the longest (page 1) being 1836 lines Checking nits according to https://www.ietf.org/id-info/checklist : ---------------------------------------------------------------------------- ** The document seems to lack a both a reference to RFC 2119 and the recommended RFC 2119 boilerplate, even if it appears to use RFC 2119 keywords. RFC 2119 keyword, line 874: '... keyLength INTEGER (1..MAX) OPTIONAL,...' RFC 2119 keyword, line 1205: '... rc2ParameterVersion INTEGER OPTIONAL,...' RFC 2119 keyword, line 1255: '... iv OCTET STRING OPTIONAL }...' RFC 2119 keyword, line 1370: '... {@algorithm}) OPTIONAL...' RFC 2119 keyword, line 1395: '... keyLength INTEGER (1..MAX) OPTIONAL,...' (2 more instances...) Miscellaneous warnings: ---------------------------------------------------------------------------- == The copyright year in the IETF Trust and authors Copyright Line does not match the current year == Line 159 has weird spacing: '... dkLen leng...' == Line 163 has weird spacing: '... Hash und...' == Line 165 has weird spacing: '... hLen len...' == Line 184 has weird spacing: '... psLen leng...' == Line 196 has weird spacing: '... \xor bit...' == (9 more instances...) -- The document date (September 6, 2016) is 2787 days in the past. Is this intentional? -- Found something which looks like a code comment -- if you have code sections in the document, please surround them with '' and '' lines. Checking references for intended status: Informational ---------------------------------------------------------------------------- -- Missing reference section? 'PKCS8' on line 1687 looks like a reference -- Missing reference section? 'RFC5958' on line 1750 looks like a reference -- Missing reference section? 'BELLOV' on line 1609 looks like a reference -- Missing reference section? 'JABLON' on line 1639 looks like a reference -- Missing reference section? 'WU' on line 1778 looks like a reference -- Missing reference section? 'RFC2898' on line 1740 looks like a reference -- Missing reference section? 'MORRIS' on line 1643 looks like a reference -- Missing reference section? 'RFC2279' on line 1735 looks like a reference -- Missing reference section? 'NISTSP63' on line 1669 looks like a reference -- Missing reference section? 'NISTSP132' on line 1674 looks like a reference -- Missing reference section? 'RFC1319' on line 1704 looks like a reference -- Missing reference section? 'RFC1321' on line 1709 looks like a reference -- Missing reference section? 'NIST180' on line 1656 looks like a reference -- Missing reference section? 'NIST46' on line 1648 looks like a reference -- Missing reference section? 'RFC2268' on line 1730 looks like a reference -- Missing reference section? 'NIST81' on line 1652 looks like a reference -- Missing reference section? 'RFC1423' on line 1714 looks like a reference -- Missing reference section? 'RFC6149' on line 1754 looks like a reference -- Missing reference section? 'RFC6151' on line 1759 looks like a reference -- Missing reference section? 'RFC6194' on line 1765 looks like a reference -- Missing reference section? 'ISO8824-1' on line 1622 looks like a reference -- Missing reference section? 'ISO8824-2' on line 1626 looks like a reference -- Missing reference section? 'ISO8824-3' on line 1630 looks like a reference -- Missing reference section? 'ISO8824-4' on line 1634 looks like a reference -- Missing reference section? 'RFC2104' on line 1725 looks like a reference -- Missing reference section? 'WANG' on line 1771 looks like a reference -- Missing reference section? 'COCHRAN' on line 1616 looks like a reference -- Missing reference section? 'NIST198' on line 1664 looks like a reference -- Missing reference section? 'ANSIX952' on line 1604 looks like a reference -- Missing reference section? 'RC5' on line 1699 looks like a reference -- Missing reference section? 'RFC5652' on line 1745 looks like a reference -- Missing reference section? 'RFC2040' on line 1720 looks like a reference -- Missing reference section? 'NIST197' on line 1660 looks like a reference -- Missing reference section? 'RBLOCK1' on line 1691 looks like a reference -- Missing reference section? 'RBLOCK2' on line 1695 looks like a reference Summary: 1 error (**), 0 flaws (~~), 8 warnings (==), 37 comments (--). Run idnits with the --verbose option for more detailed information about the items above. -------------------------------------------------------------------------------- 1 INTERNET-DRAFT K. Moriarty, Ed. 2 Intended Status: Informational EMC 3 Obsoletes: 2898 (once approved) B. Kaliski 4 Expires: March 13, 2017 Verisign 5 A. Rusch 6 RSA 7 September 6, 2016 9 PKCS #5: Password-Based Cryptography Specification 10 Version 2.1 11 draft-moriarty-pkcs5-v2dot1-04 13 Abstract 15 This document provides recommendations for the implementation of 16 password-based cryptography, covering key derivation functions, 17 encryption schemes, message-authentication schemes, and ASN.1 syntax 18 identifying the techniques. 20 The recommendations are intended for general application within 21 computer and communications systems, and as such include a fair 22 amount of flexibility. They are particularly intended for the 23 protection of sensitive information such as private keys, as in PKCS 24 #8. It is expected that application standards and implementation 25 profiles based on these specifications may include additional 26 constraints. 28 Other cryptographic techniques based on passwords, such as password- 29 based key entity authentication and key establishment protocols are 30 outside the scope of this document. Guidelines for the selection of 31 passwords are also outside the scope. 33 This document represents a republication of PKCS #5 v2.1 from RSA 34 Laboratories' Public-Key Cryptography Standards (PKCS) series. By 35 publishing this RFC, change control is transferred to the IETF. 37 This document also obsoletes RFC 2898. 39 Status of this Memo 41 This Internet-Draft is submitted to IETF in full conformance with the 42 provisions of BCP 78 and BCP 79. 44 Internet-Drafts are working documents of the Internet Engineering 45 Task Force (IETF), its areas, and its working groups. Note that 46 other groups may also distribute working documents as Internet- 47 Drafts. 49 Internet-Drafts are draft documents valid for a maximum of six months 50 and may be updated, replaced, or obsoleted by other documents at any 51 time. It is inappropriate to use Internet-Drafts as reference 52 material or to cite them other than as "work in progress." 54 The list of current Internet-Drafts can be accessed at 55 http://www.ietf.org/1id-abstracts.html 57 The list of Internet-Draft Shadow Directories can be accessed at 58 http://www.ietf.org/shadow.html 60 Copyright and License Notice 62 Copyright (c) 2016 IETF Trust and the persons identified as the 63 document authors. All rights reserved. 65 This document is subject to BCP 78 and the IETF Trust's Legal 66 Provisions Relating to IETF Documents 67 (http://trustee.ietf.org/license-info) in effect on the date of 68 publication of this document. Please review these documents 69 carefully, as they describe your rights and restrictions with respect 70 to this document. Code Components extracted from this document must 71 include Simplified BSD License text as described in Section 4.e of 72 the Trust Legal Provisions and are provided without warranty as 73 described in the Simplified BSD License. 75 Table of Contents 77 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 3 78 2. Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 79 3. Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 80 4. Salt and Iteration Count . . . . . . . . . . . . . . . . . . . 6 81 4.1. Salt . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 82 4.2. Iteration Count . . . . . . . . . . . . . . . . . . . . . . 8 83 5. Key Derivation Functions . . . . . . . . . . . . . . . . . . . 8 84 5.1. PBKDF1 . . . . . . . . . . . . . . . . . . . . . . . . . . 9 85 5.2. PBKDF2 . . . . . . . . . . . . . . . . . . . . . . . . . . 10 86 6. Encryption Schemes . . . . . . . . . . . . . . . . . . . . . . 12 87 6.1. PBES1 . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 88 6.1.1. PBES1 Encryption Operation . . . . . . . . . . . . . . 12 89 6.1.2. PBES1 Decryption Operation . . . . . . . . . . . . . . 13 90 6.2. PBES2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 91 6.2.1. PBES2 Encryption Operation . . . . . . . . . . . . . . 14 92 6.2.2. PBES2 Decryption Operation . . . . . . . . . . . . . . 15 93 7. Message Authentication Schemes . . . . . . . . . . . . . . . . 16 94 7.1. PBMAC1 . . . . . . . . . . . . . . . . . . . . . . . . . . 16 95 7.1.1 PBMAC1 Generation Operation . . . . . . . . . . . . . . 16 96 7.1.2. PBMAC1 Verification Operation . . . . . . . . . . . . . 17 97 8. Security Considerations . . . . . . . . . . . . . . . . . . . . 17 98 9. IANA Considerations . . . . . . . . . . . . . . . . . . . . . . 18 99 A. ASN.1 Syntax . . . . . . . . . . . . . . . . . . . . . . . . . 18 100 A.1. PBKDF1 . . . . . . . . . . . . . . . . . . . . . . . . . . 18 101 A.2. PBKDF2 . . . . . . . . . . . . . . . . . . . . . . . . . . 18 102 A.3. PBES1 . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 103 A.4. PBES2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 104 A.5. PBMAC1 . . . . . . . . . . . . . . . . . . . . . . . . . . 21 105 B. Supporting Techniques . . . . . . . . . . . . . . . . . . . . . 22 106 B.1. Pseudorandom functions . . . . . . . . . . . . . . . . . . 22 107 B.1.1. HMAC-SHA-1 . . . . . . . . . . . . . . . . . . . . . . 22 108 B.1.2. HMAC-SHA-2 . . . . . . . . . . . . . . . . . . . . . . 23 109 B.2. Encryption Schemes . . . . . . . . . . . . . . . . . . . . 24 110 B.2.1. DES-CBC-Pad . . . . . . . . . . . . . . . . . . . . . . 24 111 B.2.2. DES-EDE3-CBC-Pad . . . . . . . . . . . . . . . . . . . 25 112 B.2.3. RC2-CBC-Pad . . . . . . . . . . . . . . . . . . . . . . 25 113 B.2.4. RC5-CBC-Pad . . . . . . . . . . . . . . . . . . . . . . 26 114 B.2.5. AES-CBC-Pad . . . . . . . . . . . . . . . . . . . . . . 27 115 B.3. Message Authentication Schemes . . . . . . . . . . . . . . 27 116 B.3.1. HMAC-SHA-1 . . . . . . . . . . . . . . . . . . . . . . 27 117 B.3.2. HMAC-SHA-2 . . . . . . . . . . . . . . . . . . . . . . 28 118 C. ASN.1 Module . . . . . . . . . . . . . . . . . . . . . . . . . 28 119 D. Intellectual Property Considerations . . . . . . . . . . . . . 32 120 E. Revision History . . . . . . . . . . . . . . . . . . . . . . . 32 121 F. References . . . . . . . . . . . . . . . . . . . . . . . . . . 33 122 F.1 Normative References . . . . . . . . . . . . . . . . . . . 34 123 G. About PKCS . . . . . . . . . . . . . . . . . . . . . . . . . . 36 124 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . . 37 126 1. Introduction 128 This document provides recommendations for the implementation of 129 password-based cryptography, covering the following aspects: 131 - key derivation functions 132 - encryption schemes 133 - message-authentication schemes 134 - ASN.1 syntax identifying the techniques 136 The recommendations are intended for general application within 137 computer and communications systems, and as such include a fair 138 amount of flexibility. They are particularly intended for the 139 protection of sensitive information such as private keys as in PKCS 140 #8 [PKCS8][RFC5958]. It is expected that application standards and 141 implementation profiles based on these specifications may include 142 additional constraints. 144 Other cryptographic techniques based on passwords, such as password- 145 based key entity authentication and key establishment protocols 146 [BELLOV][JABLON][WU] are outside the scope of this document. 147 Guidelines for the selection of passwords are also outside the scope. 148 This document supersedes PKCS #5 version 2.0 [RFC2898], but includes 149 compatible techniques. 151 2. Notation 153 C ciphertext, an octet string 155 c iteration count, a positive integer 157 DK derived key, an octet string 159 dkLen length in octets of derived key, a positive integer 161 EM encoded message, an octet string 163 Hash underlying hash function 165 hLen length in octets of pseudorandom function output, a positive 166 integer 168 l length in blocks of derived key, a positive integer 170 IV initialization vector, an octet string 172 K encryption key, an octet string 174 KDF key derivation function 176 M message, an octet string 178 P password, an octet string 180 PRF underlying pseudorandom function 182 PS padding string, an octet string 184 psLen length in octets of padding string, a positive integer 186 S salt, an octet string 188 T message authentication code, an octet string 190 T_1, ..., T_l, U_1, ..., U_c 191 intermediate values, octet strings 193 01, 02, ..., 08 194 octets with value 1, 2, ..., 8 196 \xor bit-wise exclusive-or of two octet strings 198 || || octet length operator 200 || concatenation operator 202 substring extraction operator: extracts octets i through j, 203 0 <= i <= j 205 3. Overview 207 In many applications of public-key cryptography, user security is 208 ultimately dependent on one or more secret text values or passwords. 209 Since a password is not directly applicable as a key to any 210 conventional cryptosystem, however, some processing of the password 211 is required to perform cryptographic operations with it. Moreover, as 212 passwords are often chosen from a relatively small space, special 213 care is required in that processing to defend against search attacks. 215 A general approach to password-based cryptography, as described by 216 Morris and Thompson [MORRIS] for the protection of password tables, 217 is to combine a password with a salt to produce a key. The salt can 218 be viewed as an index into a large set of keys derived from the 219 password, and need not be kept secret. Although it may be possible 220 for an opponent to construct a table of possible passwords (a so- 221 called "dictionary attack"), constructing a table of possible keys 222 will be difficult, since there will be many possible keys for each 223 password. An opponent will thus be limited to searching through 224 passwords separately for each salt. 226 Another approach to password-based cryptography is to construct key 227 derivation techniques that are relatively expensive, thereby 228 increasing the cost of exhaustive search. One way to do this is to 229 include an iteration count in the key derivation technique, 230 indicating how many times to iterate some underlying function by 231 which keys are derived. A modest number of iterations, say 1000, is 232 not likely to be a burden for legitimate parties when computing a 233 key, but will be a significant burden for opponents. 235 Salt and iteration count formed the basis for password-based 236 encryption in PKCS #5 v2.0, and adopted here as well for the various 237 cryptographic operations. Thus, password-based key derivation as 238 defined here is a function of a password, a salt, and an iteration 239 count, where the latter two quantities need not be kept secret. 241 From a password-based key derivation function, it is straightforward 242 to define password-based encryption and message authentication 243 schemes. As in PKCS #5 v2.0, the password-based encryption schemes 244 here are based on an underlying, conventional encryption scheme, 245 where the key for the conventional scheme is derived from the 246 password. Similarly, the password-based message authentication scheme 247 is based on an underlying conventional scheme. This two-layered 248 approach makes the password-based techniques modular in terms of the 249 underlying techniques they can be based on. 251 It is expected that the password-based key derivation functions may 252 find other applications than just the encryption and message 253 authentication schemes defined here. For instance, one might derive a 254 set of keys with a single application of a key derivation function, 255 rather than derive each key with a separate application of the 256 function. The keys in the set would be obtained as substrings of the 257 output of the key derivation function. This approach might be 258 employed as part of key establishment in a session-oriented protocol. 259 Another application is password checking, where the output of the key 260 derivation function is stored (along with the salt and iteration 261 count) for the purposes of subsequent verification of a password. 263 Throughout this document, a password is considered to be an octet 264 string of arbitrary length whose interpretation as a text string is 265 unspecified. In the interest of interoperability, however, it is 266 recommended that applications follow some common text encoding rules. 267 ASCII and UTF-8 [RFC2279] are two possibilities. (ASCII is a subset 268 of UTF-8.) 270 Although the selection of passwords is outside the scope of this 271 document, guidelines have been published [NISTSP63] that may well be 272 taken into account. 274 4. Salt and Iteration Count 276 Inasmuch as salt and iteration count are central to the techniques 277 defined in this document, some further discussion is warranted. 279 4.1. Salt 281 A salt in password-based cryptography has traditionally served the 282 purpose of producing a large set of keys corresponding to a given 283 password, among which one is selected at random according to the 284 salt. An individual key in the set is selected by applying a key 285 derivation function KDF, as 287 DK = KDF (P, S) 289 where DK is the derived key, P is the password, and S is the salt. 290 This has two benefits: 292 1. It is difficult for an opponent to precompute all the keys 293 corresponding to a dictionary of passwords, or even the most 294 likely keys. If the salt is 64 bits long, for instance, there 295 will be as many as 2^64 keys for each password. An opponent is 296 thus limited to searching for passwords after a password-based 297 operation has been performed and the salt is known. 299 2. It is unlikely that the same key will be selected twice. Again, 300 if the salt is 64 bits long, the chance of "collision" between 301 keys does not become significant until about 2^32 keys have 302 been produced, according to the Birthday Paradox. This 303 addresses some of the concerns about interactions between 304 multiple uses of the same key, which may apply for some 305 encryption and authentication techniques. 307 In password-based encryption, the party encrypting a message can gain 308 assurance that these benefits are realized simply by selecting a 309 large and sufficiently random salt when deriving an encryption key 310 from a password. A party generating a message authentication code can 311 gain such assurance in a similar fashion. 313 The party decrypting a message or verifying a message authentication 314 code, however, cannot be sure that a salt supplied by another party 315 has actually been generated at random. It is possible, for instance, 316 that the salt may have been copied from another password-based 317 operation, in an attempt to exploit interactions between multiple 318 uses of the same key. For instance, suppose two legitimate parties 319 exchange a encrypted message, where the encryption key is an 80-bit 320 key derived from a shared password with some salt. An opponent could 321 take the salt from that encryption and provide it to one of the 322 parties as though it were for a 40-bit key. If the party reveals the 323 result of decryption with the 40-bit key, the opponent may be able to 324 solve for the 40-bit key. In the case that 40-bit key is the first 325 half of the 80-bit key, the opponent can then readily solve for the 326 remaining 40 bits of the 80-bit key. 328 To defend against such attacks, either the interaction between 329 multiple uses of the same key should be carefully analyzed, or the 330 salt should contain data that explicitly distinguishes between 331 different operations. For instance, the salt might have an 332 additional, non-random octet that specifies whether the derived key 333 is for encryption, for message authentication, or for some other 334 operation. 336 Based on this, the following is recommended for salt selection: 338 1. If there is no concern about interactions between multiple uses 339 of the same key (or a prefix of that key) with the password- 340 based encryption and authentication techniques supported for a 341 given password, then the salt may be generated at random and 342 need not be checked for a particular format by the party 343 receiving the salt. It should be at least eight octets (64 344 bits) long. 346 2. Otherwise, the salt should contain data that explicitly 347 distinguishes between different operations and different key 348 lengths, in addition to a random part that is at least eight 349 octets long, and this data should be checked or regenerated by 350 the party receiving the salt. For instance, the salt could have 351 an additional non-random octet that specifies the purpose of 352 the derived key. Alternatively, it could be the encoding of a 353 structure that specifies detailed information about the derived 354 key, such as the encryption or authentication technique and a 355 sequence number among the different keys derived from the 356 password. The particular format of the additional data is left 357 to the application. 359 Note. If a random number generator or pseudorandom generator is not 360 available, a deterministic alternative for generating the salt (or 361 the random part of it) is to apply a password-based key derivation 362 function to the password and the message M to be processed. For 363 instance, the salt could be computed with a key derivation function 364 as S = KDF (P, M). This approach is not recommended if the message M 365 is known to belong to a small message space (e.g., "Yes" or "No"), 366 however, since then there will only be a small number of possible 367 salts. 369 4.2. Iteration Count 371 An iteration count has traditionally served the purpose of increasing 372 the cost of producing keys from a password, thereby also increasing 373 the difficulty of attack. Mathematically, an iteration count of c 374 will increase the security strength of a password by log2(c) 375 bits against trial based attacks like brute force or dictionary 376 attacks. 378 Choosing a reasonable value for the iteration count depends on 379 environment and circumstances, and varies from application to 380 application. This document follows the recommendations made in FIPS 381 Special Publication 800-132 [NISTSP132], which says "The iteration 382 count shall be selected as large as possible, as long as the time 383 required to generate the key using the entered password is acceptable 384 for the users. [...] A minimum iteration count of 1,000 is 385 recommended. For especially critical keys, or for very powerful 386 systems or systems where user-perceived performance is not critical, 387 an iteration count of 10,000,000 may be appropriate". 389 5. Key Derivation Functions 391 A key derivation function produces a derived key from a base key and 392 other parameters. In a password-based key derivation function, the 393 base key is a password and the other parameters are a salt value and 394 an iteration count, as outlined in Section 3. 396 The primary application of the password-based key derivation 397 functions defined here is in the encryption schemes in Section 6 and 398 the message authentication scheme in Section 7. Other applications 399 are certainly possible, hence the independent definition of these 400 functions. 402 Two functions are specified in this section: PBKDF1 and PBKDF2. 403 PBKDF2 is recommended for new applications; PBKDF1 is included only 404 for compatibility with existing applications, and is not recommended 405 for new applications. 407 A typical application of the key derivation functions defined here 408 might include the following steps: 410 1. Select a salt S and an iteration count c, as outlined in 411 Section 4. 413 2. Select a length in octets for the derived key, dkLen. 415 3. Apply the key derivation function to the password, the salt, 416 the iteration count and the key length to produce a derived 417 key. 419 4. Output the derived key. 421 Any number of keys may be derived from a password by varying the 422 salt, as described in Section 3. 424 5.1. PBKDF1 426 PBKDF1 applies a hash function, which shall be MD2 [RFC1319], MD5 427 [RFC1321] or SHA-1 [NIST180], to derive keys. The length of the 428 derived key is bounded by the length of the hash function output, 429 which is 16 octets for MD2 and MD5 and 20 octets for SHA-1. PBKDF1 is 430 compatible with the key derivation process in PKCS #5 v1.5 431 [PKCS5_15]. 433 PBKDF1 is recommended only for compatibility with existing 434 applications since the keys it produces may not be large enough for 435 some applications. 437 PBKDF1 (P, S, c, dkLen) 439 Options: Hash underlying hash function 441 Input: P password, an octet string 442 S salt, an octet string 443 c iteration count, a positive integer 444 dkLen intended length in octets of derived key, 445 a positive integer, at most 16 for MD2 or 446 MD5 and 20 for SHA-1 447 Output: DK derived key, a dkLen-octet string 449 Steps: 451 1. If dkLen > 16 for MD2 and MD5, or dkLen > 20 for SHA-1, output 452 "derived key too long" and stop. 454 2. Apply the underlying hash function Hash for c iterations to the 455 concatenation of the password P and the salt S, then extract 456 the first dkLen octets to produce a derived key DK: 458 T_1 = Hash (P || S) , 459 T_2 = Hash (T_1) , 460 ... 461 T_c = Hash (T_{c-1}) , 462 DK = T_c<0..dkLen-1> 464 3. Output the derived key DK. 466 5.2. PBKDF2 468 PBKDF2 applies a pseudorandom function (see Appendix B.1 for an 469 example) to derive keys. The length of the derived key is essentially 470 unbounded. (However, the maximum effective search space for the 471 derived key may be limited by the structure of the underlying 472 pseudorandom function. See Appendix B.1 for further discussion.) 473 PBKDF2 is recommended for new applications. 475 PBKDF2 (P, S, c, dkLen) 477 Options: PRF underlying pseudorandom function (hLen 478 denotes the length in octets of the 479 pseudorandom function output) 481 Input: P password, an octet string 482 S salt, an octet string 483 c iteration count, a positive integer 484 dkLen intended length in octets of the derived 485 key, a positive integer, at most 486 (2^32 - 1) * hLen 488 Output: DK derived key, a dkLen-octet string 490 Steps: 492 1. If dkLen > (2^32 - 1) * hLen, output "derived key too long" and 493 stop. 495 2. Let l be the number of hLen-octet blocks in the derived key, 496 rounding up, and let r be the number of octets in the last 497 block: 499 l = CEIL (dkLen / hLen) , 500 r = dkLen - (l - 1) * hLen . 502 Here, CEIL (x) is the "ceiling" function, i.e. the smallest 503 integer greater than, or equal to, x. 505 3. For each block of the derived key apply the function F defined 506 below to the password P, the salt S, the iteration count c, and 507 the block index to compute the block: 509 T_1 = F (P, S, c, 1) , 510 T_2 = F (P, S, c, 2) , 511 ... 512 T_l = F (P, S, c, l) , 514 where the function F is defined as the exclusive-or sum of the 515 first c iterates of the underlying pseudorandom function PRF 516 applied to the password P and the concatenation of the salt S 517 and the block index i: 519 F (P, S, c, i) = U_1 \xor U_2 \xor ... \xor U_c 521 where 522 U_1 = PRF (P, S || INT (i)) , 523 U_2 = PRF (P, U_1) , 524 ... 525 U_c = PRF (P, U_{c-1}) . 527 Here, INT (i) is a four-octet encoding of the integer i, most 528 significant octet first. 530 4. Concatenate the blocks and extract the first dkLen octets to 531 produce a derived key DK: 533 DK = T_1 || T_2 || ... || T_l<0..r-1> 535 5. Output the derived key DK. 537 Note. The construction of the function F follows a "belt-and- 538 suspenders" approach. The iterates U_i are computed recursively to 539 remove a degree of parallelism from an opponent; they are exclusive- 540 ored together to reduce concerns about the recursion degenerating 541 into a small set of values. 543 6. Encryption Schemes 545 An encryption scheme, in the symmetric setting, consists of an 546 encryption operation and a decryption operation, where the encryption 547 operation produces a ciphertext from a message under a key, and the 548 decryption operation recovers the message from the ciphertext under 549 the same key. In a password-based encryption scheme, the key is a 550 password. 552 A typical application of a password-based encryption scheme is a 553 private-key protection method, where the message contains private-key 554 information, as in PKCS #8. The encryption schemes defined here would 555 be suitable encryption algorithms in that context. 557 Two schemes are specified in this section: PBES1 and PBES2. PBES2 is 558 recommended for new applications; PBES1 is included only for 559 compatibility with existing applications, and is not recommended for 560 new applications. 562 6.1. PBES1 564 PBES1 combines the PBKDF1 function (Section 5.1) with an underlying 565 block cipher, which shall be either DES [NIST46] or RC2(tm) [RFC2268] 566 in CBC mode [NIST81]. PBES1 is compatible with the encryption scheme 567 in PKCS #5 v1.5 [PKCS5_15]. 569 PBES1 is recommended only for compatibility with existing 570 applications, since it supports only two underlying encryption 571 schemes, each of which has a key size (56 or 64 bits) that may not be 572 large enough for some applications. 574 6.1.1. PBES1 Encryption Operation 576 The encryption operation for PBES1 consists of the following steps, 577 which encrypt a message M under a password P to produce a ciphertext 578 C: 580 1. Select an eight-octet salt S and an iteration count c, as 581 outlined in Section 4. 583 2. Apply the PBKDF1 key derivation function (Section 5.1) to the 584 password P, the salt S, and the iteration count c to produce at 585 derived key DK of length 16 octets: 587 DK = PBKDF1 (P, S, c, 16) . 589 3. Separate the derived key DK into an encryption key K consisting 590 of the first eight octets of DK and an initialization vector IV 591 consisting of the next eight octets: 593 K = DK<0..7> , 594 IV = DK<8..15> . 596 4. Concatenate M and a padding string PS to form an encoded 597 message EM: 599 EM = M || PS , 601 where the padding string PS consists of 8-(||M|| mod 8) octets 602 each with value 8-(||M|| mod 8). The padding string PS will 603 satisfy one of the following statements: 605 PS = 01, if ||M|| mod 8 = 7 ; 606 PS = 02 02, if ||M|| mod 8 = 6 ; 607 ... 608 PS = 08 08 08 08 08 08 08 08, if ||M|| mod 8 = 0. 610 The length in octets of the encoded message will be a multiple 611 of eight and it will be possible to recover the message M 612 unambiguously from the encoded message. (This padding rule is 613 taken from RFC 1423 [RFC1423].) 615 5. Encrypt the encoded message EM with the underlying block cipher 616 (DES or RC2) in cipher block chaining mode under the encryption 617 key K with initialization vector IV to produce the ciphertext 618 C. For DES, the key K shall be considered as a 64-bit encoding 619 of a 56-bit DES key with parity bits ignored (see [NIST46]). 620 For RC2, the "effective key bits" shall be 64 bits. 622 6. Output the ciphertext C. 624 The salt S and the iteration count c may be conveyed to the party 625 performing decryption in an AlgorithmIdentifier value (see Appendix 626 A.3). 628 6.1.2. PBES1 Decryption Operation 630 The decryption operation for PBES1 consists of the following steps, 631 which decrypt a ciphertext C under a password P to recover a message 632 M: 634 1. Obtain the eight-octet salt S and the iteration count c. 636 2. Apply the PBKDF1 key derivation function (Section 5.1) to the 637 password P, the salt S, and the iteration count c to produce a 638 derived key DK of length 16 octets: 640 DK = PBKDF1 (P, S, c, 16) 642 3. Separate the derived key DK into an encryption key K consisting 643 of the first eight octets of DK and an initialization vector IV 644 consisting of the next eight octets: 646 K = DK<0..7> , 647 IV = DK<8..15> . 649 4. Decrypt the ciphertext C with the underlying block cipher (DES 650 or RC2) in cipher block chaining mode under the encryption key 651 K with initialization vector IV to recover an encoded message 652 EM. If the length in octets of the ciphertext C is not a 653 multiple of eight, output "decryption error" and stop. 655 5. Separate the encoded message EM into a message M and a padding 656 string PS: 658 EM = M || PS , 660 where the padding string PS consists of some number psLen 661 octets each with value psLen, where psLen is between 1 and 8. 662 If it is not possible to separate the encoded message EM in 663 this manner, output "decryption error" and stop. 665 6. Output the recovered message M. 667 6.2. PBES2 669 PBES2 combines a password-based key derivation function, which shall 670 be PBKDF2 (Section 5.2) for this version of PKCS #5, with an 671 underlying encryption scheme (see Appendix B.2 for examples). The key 672 length and any other parameters for the underlying encryption scheme 673 depend on the scheme. 675 PBES2 is recommended for new applications. 677 6.2.1. PBES2 Encryption Operation 679 The encryption operation for PBES2 consists of the following steps, 680 which encrypt a message M under a password P to produce a ciphertext 681 C, applying a selected key derivation function KDF and a selected 682 underlying encryption scheme: 684 1. Select a salt S and an iteration count c, as outlined in 685 Section 4. 687 2. Select the length in octets, dkLen, for the derived key for the 688 underlying encryption scheme. 690 3. Apply the selected key derivation function to the password P, 691 the salt S, and the iteration count c to produce a derived key 692 DK of length dkLen octets: 694 DK = KDF (P, S, c, dkLen) . 696 4. Encrypt the message M with the underlying encryption scheme 697 under the derived key DK to produce a ciphertext C. (This step 698 may involve selection of parameters such as an initialization 699 vector and padding, depending on the underlying scheme.) 701 5. Output the ciphertext C. 703 The salt S, the iteration count c, the key length dkLen, and 704 identifiers for the key derivation function and the underlying 705 encryption scheme may be conveyed to the party performing decryption 706 in an AlgorithmIdentifier value (see Appendix A.4). 708 6.2.2. PBES2 Decryption Operation 710 The decryption operation for PBES2 consists of the following steps, 711 which decrypt a ciphertext C under a password P to recover a message 712 M: 714 1. Obtain the salt S for the operation. 716 2. Obtain the iteration count c for the key derivation function. 718 3. Obtain the key length in octets, dkLen, for the derived key for 719 the underlying encryption scheme. 721 4. Apply the selected key derivation function to the password P, 722 the salt S, and the iteration count c to produce a derived key 723 DK of length dkLen octets: 725 DK = KDF (P, S, c, dkLen) . 727 5. Decrypt the ciphertext C with the underlying encryption scheme 728 under the derived key DK to recover a message M. If the 729 decryption function outputs "decryption error," then output 730 "decryption error" and stop. 732 6. Output the recovered message M. 734 7. Message Authentication Schemes 736 A message authentication scheme consists of a MAC (message 737 authentication code) generation operation and a MAC verification 738 operation, where the MAC generation operation produces a message 739 authentication code from a message under a key, and the MAC 740 verification operation verifies the message authentication code under 741 the same key. In a password-based message authentication scheme, the 742 key is a password. 744 One scheme is specified in this section: PBMAC1. 746 7.1. PBMAC1 748 PBMAC1 combines a password-based key derivation function, which shall 749 be PBKDF2 (Section 5.2) for this version of PKCS #5, with an 750 underlying message authentication scheme (see Appendix B.3 for an 751 example). The key length and any other parameters for the underlying 752 message authentication scheme depend on the scheme. 754 7.1.1 PBMAC1 Generation Operation 756 The MAC generation operation for PBMAC1 consists of the following 757 steps, which process a message M under a password P to generate a 758 message authentication code T, applying a selected key derivation 759 function KDF and a selected underlying message authentication scheme: 761 1. Select a salt S and an iteration count c, as outlined in 762 Section 4. 764 2. Select a key length in octets, dkLen, for the derived key for 765 the underlying message authentication function. 767 3. Apply the selected key derivation function to the password P, 768 the salt S, and the iteration count c to produce a derived key 769 DK of length dkLen octets: 771 DK = KDF (P, S, c, dkLen) . 773 4. Process the message M with the underlying message 774 authentication scheme under the derived key DK to generate a 775 message authentication code T. 777 5. Output the message authentication code T. 779 The salt S, the iteration count c, the key length dkLen, and 780 identifiers for the key derivation function and underlying message 781 authentication scheme may be conveyed to the party performing 782 verification in an AlgorithmIdentifier value (see Appendix A.5). 784 7.1.2. PBMAC1 Verification Operation 786 The MAC verification operation for PBMAC1 consists of the following 787 steps, which process a message M under a password P to verify a 788 message authentication code T: 790 1. Obtain the salt S and the iteration count c. 792 2. Obtain the key length in octets, dkLen, for the derived key for 793 the underlying message authentication scheme. 795 3. Apply the selected key derivation function to the password P, 796 the salt S, and the iteration count c to produce a derived key 797 DK of length dkLen octets: 799 DK = KDF (P, S, c, dkLen) . 801 4. Process the message M with the underlying message 802 authentication scheme under the derived key DK to verify the 803 message authentication code T. 805 5. If the message authentication code verifies, output "correct"; 806 else output "incorrect." 808 8. Security Considerations 810 Password-based cryptography is generally limited in the security that 811 it can provide, particularly for methods such as those defined in 812 this document where off-line password search is possible. While the 813 use of salt and iteration count can increase the complexity of attack 814 (see Section 4 for recommendations), it is essential that passwords 815 are selected well, and relevant guidelines (e.g., [NISTSP63]) should 816 be taken into account. It is also important that passwords be 817 protected well if stored. 819 In general, different keys should be derived from a password for 820 different uses to minimize the possibility of unintended 821 interactions. For password-based encryption with a single algorithm, 822 a random salt is sufficient to ensure that different keys will be 823 produced. In certain other situations, as outlined in Section 4, a 824 structured salt is necessary. The recommendations in Section 4 should 825 thus be taken into account when selecting the salt value. 827 For information on security considerations for MD2 [RFC1319] see 828 [RFC6149], for MD5 [RFC1321] see [RFC6151], for SHA-1 [NIST180] see 829 [RFC6194]. 831 9. IANA Considerations 833 None. 835 A. ASN.1 Syntax 837 This section defines ASN.1 syntax for the key derivation functions, 838 the encryption schemes, the message authentication scheme, and 839 supporting techniques. The intended application of these definitions 840 includes PKCS #8 and other syntax for key management, encrypted data, 841 and integrity-protected data. (Various aspects of ASN.1 are specified 842 in several ISO/IEC standards [ISO8824-1][ISO8824-2][ISO8824-3] 843 [ISO8824-4].) 845 The object identifier pkcs-5 identifies the arc of the OID tree from 846 which the PKCS #5-specific OIDs in this section are derived: 848 rsadsi OBJECT IDENTIFIER ::= {iso(1) member-body(2) us(840) 113549} 849 pkcs OBJECT IDENTIFIER ::= {rsadsi 1} 850 pkcs-5 OBJECT IDENTIFIER ::= {pkcs 5} 852 A.1. PBKDF1 854 No object identifier is given for PBKDF1, as the object identifiers 855 for PBES1 are sufficient for existing applications and PBKDF2 is 856 recommended for new applications. 858 A.2. PBKDF2 860 The object identifier id-PBKDF2 identifies the PBKDF2 key derivation 861 function (Section 5.2). 863 id-PBKDF2 OBJECT IDENTIFIER ::= {pkcs-5 12} 865 The parameters field associated with this OID in an 866 AlgorithmIdentifier shall have type PBKDF2-params: 868 PBKDF2-params ::= SEQUENCE { 869 salt CHOICE { 870 specified OCTET STRING, 871 otherSource AlgorithmIdentifier {{PBKDF2-SaltSources}} 872 }, 873 iterationCount INTEGER (1..MAX), 874 keyLength INTEGER (1..MAX) OPTIONAL, 875 prf AlgorithmIdentifier {{PBKDF2-PRFs}} DEFAULT 876 algid-hmacWithSHA1 } 878 The fields of type PBKDF2-params have the following meanings: 880 - salt specifies the salt value, or the source of the salt value. 881 It shall either be an octet string or an algorithm ID with an 882 OID in the set PBKDF2-SaltSources, which is reserved for future 883 versions of PKCS #5. 885 The salt-source approach is intended to indicate how the salt 886 value is to be generated as a function of parameters in the 887 algorithm ID, application data, or both. For instance, it may 888 indicate that the salt value is produced from the encoding of a 889 structure that specifies detailed information about the derived 890 key as suggested in Section 4.1. Some of the information may be 891 carried elsewhere, e.g., in the encryption algorithm ID. 892 However, such facilities are deferred to a future version of 893 PKCS #5. 895 In this version, an application may achieve the benefits 896 mentioned in Section 4.1 by choosing a particular 897 interpretation of the salt value in the specified alternative. 899 PBKDF2-SaltSources ALGORITHM-IDENTIFIER ::= { ... } 901 - iterationCount specifies the iteration count. The maximum 902 iteration count allowed depends on the implementation. It is 903 expected that implementation profiles may further constrain the 904 bounds. 906 - keyLength, an optional field, is the length in octets of the 907 derived key. The maximum key length allowed depends on the 908 implementation; it is expected that implementation profiles may 909 further constrain the bounds. The field is provided for 910 convenience only; the key length is not cryptographically 911 protected. If there is concern about interaction between 912 operations with different key lengths for a given salt (see 913 Section 4.1), the salt should distinguish among the different 914 key lengths. 916 - prf identifies the underlying pseudorandom function. It shall 917 be an algorithm ID with an OID in the set PBKDF2-PRFs, which 918 for this version of PKCS #5 shall consist of id-hmacWithSHA1 919 (see Appendix B.1.1) and any other OIDs defined by the 920 application. 922 PBKDF2-PRFs ALGORITHM-IDENTIFIER ::= { 923 {NULL IDENTIFIED BY id-hmacWithSHA1}, 924 {NULL IDENTIFIED BY id-hmacWithSHA224}, 925 {NULL IDENTIFIED BY id-hmacWithSHA256}, 926 {NULL IDENTIFIED BY id-hmacWithSHA384}, 927 {NULL IDENTIFIED BY id-hmacWithSHA512}, 928 {NULL IDENTIFIED BY id-hmacWithSHA512-224}, 929 {NULL IDENTIFIED BY id-hmacWithSHA512-256}, 930 ... 931 } 933 The default pseudorandom function is HMAC-SHA-1: 935 algid-hmacWithSHA1 AlgorithmIdentifier {{PBKDF2-PRFs}} ::= 936 {algorithm id-hmacWithSHA1, parameters NULL : NULL} 938 A.3. PBES1 940 Different object identifiers identify the PBES1 encryption scheme 941 (Section 6.1) according to the underlying hash function in the key 942 derivation function and the underlying block cipher, as summarized in 943 the following table: 945 Hash Function Block Cipher OID 946 MD2 DES pkcs-5.1 947 MD2 RC2 pkcs-5.4 948 MD5 DES pkcs-5.3 949 MD5 RC2 pkcs-5.6 950 SHA-1 DES pkcs-5.10 951 SHA-1 RC2 pkcs-5.11 953 pbeWithMD2AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 1} 954 pbeWithMD2AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 4} 955 pbeWithMD5AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 3} 956 pbeWithMD5AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 6} 957 pbeWithSHA1AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 10} 958 pbeWithSHA1AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 11} 960 For each OID, the parameters field associated with the OID in an 961 AlgorithmIdentifier shall have type PBEParameter: 963 PBEParameter ::= SEQUENCE { 964 salt OCTET STRING (SIZE(8)), 965 iterationCount INTEGER } 967 The fields of type PBEParameter have the following meanings: 969 - salt specifies the salt value, an eight-octet string. 971 - iterationCount specifies the iteration count. 973 A.4. PBES2 975 The object identifier id-PBES2 identifies the PBES2 encryption scheme 976 (Section 6.2). 978 id-PBES2 OBJECT IDENTIFIER ::= {pkcs-5 13} 980 The parameters field associated with this OID in an 981 AlgorithmIdentifier shall have type PBES2-params: 983 PBES2-params ::= SEQUENCE { 984 keyDerivationFunc AlgorithmIdentifier {{PBES2-KDFs}}, 985 encryptionScheme AlgorithmIdentifier {{PBES2-Encs}} } 987 The fields of type PBES2-params have the following meanings: 989 - keyDerivationFunc identifies the underlying key derivation 990 function. It shall be an algorithm ID with an OID in the set 991 PBES2-KDFs, which for this version of PKCS #5 shall consist of 992 id-PBKDF2 (Appendix A.2). 994 PBES2-KDFs ALGORITHM-IDENTIFIER ::= 995 { {PBKDF2-params IDENTIFIED BY id-PBKDF2}, ... } 997 - encryptionScheme identifies the underlying encryption scheme. 998 It shall be an algorithm ID with an OID in the set PBES2-Encs, 999 whose definition is left to the application. Example underlying 1000 encryption schemes are given in Appendix B.2. 1002 PBES2-Encs ALGORITHM-IDENTIFIER ::= { ... } 1004 A.5. PBMAC1 1006 The object identifier id-PBMAC1 identifies the PBMAC1 message 1007 authentication scheme (Section 7.1). 1009 id-PBMAC1 OBJECT IDENTIFIER ::= {pkcs-5 14} 1011 The parameters field associated with this OID in an 1012 AlgorithmIdentifier shall have type PBMAC1-params: 1014 PBMAC1-params ::= SEQUENCE { 1015 keyDerivationFunc AlgorithmIdentifier {{PBMAC1-KDFs}}, 1016 messageAuthScheme AlgorithmIdentifier {{PBMAC1-MACs}} } 1018 The keyDerivationFunc field has the same meaning as the corresponding 1019 field of PBES2-params (Appendix A.4) except that the set of OIDs is 1020 PBMAC1-KDFs. 1022 PBMAC1-KDFs ALGORITHM-IDENTIFIER ::= 1023 { {PBKDF2-params IDENTIFIED BY id-PBKDF2}, ... } 1025 The messageAuthScheme field identifies the underlying message 1026 authentication scheme. It shall be an algorithm ID with an OID in the 1027 set PBMAC1-MACs, whose definition is left to the application. Example 1028 underlying encryption schemes are given in Appendix B.3. 1030 PBMAC1-MACs ALGORITHM-IDENTIFIER ::= { ... } 1032 B. Supporting Techniques 1034 This section gives several examples of underlying functions and 1035 schemes supporting the password-based schemes in Sections 5, 6 and 7. 1037 While these supporting techniques are appropriate for applications to 1038 implement, none of them is required to be implemented. It is 1039 expected, however, that profiles for PKCS #5 will be developed that 1040 specify particular supporting techniques. 1042 This section also gives object identifiers for the supporting 1043 techniques. The object identifiers digestAlgorithm and 1044 encryptionAlgorithm identify the arcs from which certain algorithm 1045 OIDs referenced in this section are derived: 1047 digestAlgorithm OBJECT IDENTIFIER ::= {rsadsi 2} 1048 encryptionAlgorithm OBJECT IDENTIFIER ::= {rsadsi 3} 1050 B.1. Pseudorandom functions 1052 Examples of pseudorandom function for PBKDF2 (Section 5.2) include 1053 HMAC with SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, and 1054 SHA512/256. Applications may employ other schemes as well. 1056 B.1.1. HMAC-SHA-1 1058 HMAC-SHA-1 is the pseudorandom function corresponding to the HMAC 1059 message authentication code [RFC2104] based on the SHA-1 hash 1060 function [NIST180]. The pseudorandom function is the same function 1061 by which the message authentication code is computed, with a full- 1062 length output. (The first argument to the pseudorandom function PRF 1063 serves as HMAC's "key," and the second serves as HMAC's "text." In 1064 the case of PBKDF2, the "key" is thus the password and the "text" is 1065 the salt.) HMAC-SHA-1 has a variable key length and a 20-octet 1066 (160-bit) output value. 1068 Although the length of the key to HMAC-SHA-1 is essentially 1069 unbounded, the effective search space for pseudorandom function 1070 outputs may be limited by the structure of the function. In 1071 particular, when the key is longer than 512 bits, HMAC-SHA-1 will 1072 first hash it to 160 bits. Thus, even if a long derived key 1073 consisting of several pseudorandom function outputs is produced from 1074 a key, the effective search space for the derived key will be at most 1075 160 bits. Although the specific limitation for other key sizes 1076 depends on details of the HMAC construction, one should assume, to be 1077 conservative, that the effective search space is limited to 160 bits 1078 for other key sizes as well. 1080 (The 160-bit limitation should not generally pose a practical 1081 limitation in the case of password-based cryptography, since the 1082 search space for a password is unlikely to be greater than 160 bits.) 1084 The object identifier id-hmacWithSHA1 identifies the HMAC-SHA-1 1085 pseudorandom function: 1087 id-hmacWithSHA1 OBJECT IDENTIFIER ::= {digestAlgorithm 7} 1089 The parameters field associated with this OID in an 1090 AlgorithmIdentifier shall have type NULL. This object identifier is 1091 employed in the object set PBKDF2-PRFs (Appendix A.2). 1093 Note. Although HMAC-SHA-1 was designed as a message authentication 1094 code, its proof of security is readily modified to accommodate 1095 requirements for a pseudorandom function, under stronger assumptions. 1096 A hash function may also meet the requirements of a pseudorandom 1097 function under certain assumptions. For instance, the direct 1098 application of a hash function to to the concatenation of the "key" 1099 and the "text" may be appropriate, provided that "text" has 1100 appropriate structure to prevent certain attacks. HMAC-SHA-1 is 1101 preferable, however, because it treats "key" and "text" as separate 1102 arguments and does not require "text" to have any structure. 1104 During 2004 and 2005 there were a number of attacks on SHA-1 that 1105 reduced its perceived effective strength against collision attacks to 1106 62 bits instead of the expected 80 bits (e.g. Wang et al. [WANG], 1107 confirmed by M. Cochran [COCHRAN]). However, since these attacks 1108 centered on finding collisions between values they are not a direct 1109 security consideration here because the collision-resistant property 1110 is not required by the HMAC authentication scheme. 1112 B.1.2. HMAC-SHA-2 1114 HMAC-SHA-2 refers to the set of pseudo-random functions corresponding 1115 to the HMAC message authentication code (now a FIPS standard 1116 [NIST198]) based on the new SHA-2 functions (FIPS 180-4 [NIST180]). 1117 HMAC-SHA-2 has a variable key length and variable output value 1118 depending on the hash function chosen (SHA-224, SHA-256, SHA-384, 1119 SHA-512, SHA -512/224, or SHA-512/256), that is 28, 32, 48, or 64 1120 octets. 1122 Using the new hash functions extends the search space for the 1123 produced keys. Where SHA-1 limits the search space to 20 octets, 1124 SHA-2 sets new limits of 28, 32, 48 and 64 octets. 1126 Object identifiers for HMAC are defined as follows: 1128 id-hmacWithSHA224 OBJECT IDENTIFIER ::= {digestAlgorithm 8} 1129 id-hmacWithSHA256 OBJECT IDENTIFIER ::= {digestAlgorithm 9} 1130 id-hmacWithSHA384 OBJECT IDENTIFIER ::= {digestAlgorithm 10} 1131 id-hmacWithSHA512 OBJECT IDENTIFIER ::= {digestAlgorithm 11} 1132 id-hmacWithSHA512-224 OBJECT IDENTIFIER ::= {digestAlgorithm 12} 1133 id-hmacWithSHA512-256 OBJECT IDENTIFIER ::= {digestAlgorithm 13} 1135 B.2. Encryption Schemes 1137 An example encryption scheme for PBES2 (Section 6.2) is AES-CBC-Pad. 1138 The schemes defined in PKCS #5 v2.0 [RFC2898], DES-CBC-Pad, DES-EDE3- 1139 CBC-Pad, RC2-CBC-Pad, and RC5-CBC-Pad, are still supported, but 1140 DES-CBC-Pad, DES-EDE3-CBC-Pad, RC2-CBC-Pad are now considered legacy 1141 and should only be used for backwards compatibility reasons. 1143 The object identifiers given in this section are intended to be 1144 employed in the object set PBES2-Encs (Appendix A.4). 1146 B.2.1. DES-CBC-Pad 1148 DES-CBC-Pad is single-key DES [NIST46] in CBC mode [NIST81] with the 1149 RFC 1423 [RFC1423] padding operation (see Section 6.1.1). DES-CBC-Pad 1150 has an eight- octet encryption key and an eight-octet initialization 1151 vector. The key is considered as a 64-bit encoding of a 56-bit DES 1152 key with parity bits ignored. 1154 The object identifier desCBC (defined in the NIST/OSI Implementors' 1155 Workshop agreements) identifies the DES-CBC-Pad encryption scheme: 1157 desCBC OBJECT IDENTIFIER ::= 1158 {iso(1) identified-organization(3) oiw(14) secsig(3) 1159 algorithms(2) 7} 1161 The parameters field associated with this OID in an 1162 AlgorithmIdentifier shall have type OCTET STRING (SIZE(8)), 1163 specifying the initialization vector for CBC mode. 1165 B.2.2. DES-EDE3-CBC-Pad 1167 DES-EDE3-CBC-Pad is three-key triple-DES in CBC mode [ANSIX952] with 1168 the RFC 1423 [RFC1423] padding operation. DES-EDE3-CBC-Pad has a 1169 24-octet encryption key and an eight-octet initialization vector. The 1170 key is considered as the concatenation of three eight-octet keys, 1171 each of which is a 64-bit encoding of a 56-bit DES key with parity 1172 bits ignored. 1174 The object identifier des-EDE3-CBC identifies the DES-EDE3-CBC-Pad 1175 encryption scheme: 1177 des-EDE3-CBC OBJECT IDENTIFIER ::= {encryptionAlgorithm 7} 1179 The parameters field associated with this OID in an 1180 AlgorithmIdentifier shall have type OCTET STRING (SIZE(8)), 1181 specifying the initialization vector for CBC mode. 1183 Note. An OID for DES-EDE3-CBC without padding is given in ANSI X9.52 1184 [ANSIX952]; the one given here is preferred since it specifies 1185 padding. 1187 B.2.3. RC2-CBC-Pad 1189 RC2-CBC-Pad is the RC2(tm) encryption algorithm [RFC2268] in CBC mode 1190 with the RFC 1423 [RFC1423] padding operation. RC2-CBC-Pad has a 1191 variable key length, from one to 128 octets, a separate "effective 1192 key bits" parameter from one to 1024 bits that limits the effective 1193 search space independent of the key length, and an eight-octet 1194 initialization vector. 1196 The object identifier rc2CBC identifies the RC2-CBC-Pad encryption 1197 scheme: 1199 rc2CBC OBJECT IDENTIFIER ::= {encryptionAlgorithm 2} 1201 The parameters field associated with OID in an AlgorithmIdentifier 1202 shall have type RC2-CBC-Parameter: 1204 RC2-CBC-Parameter ::= SEQUENCE { 1205 rc2ParameterVersion INTEGER OPTIONAL, 1206 iv OCTET STRING (SIZE(8)) } 1208 The fields of type RC2-CBCParameter have the following meanings: 1210 - rc2ParameterVersion is a proprietary RSA Security Inc. encoding 1211 of the "effective key bits" for RC2. The following encodings 1212 are defined: 1214 Effective Key Bits Encoding 1215 40 160 1216 64 120 1217 128 58 1218 b >= 256 b 1220 If the rc2ParameterVersion field is omitted, the "effective key bits" 1221 defaults to 32. (This is for backward compatibility with certain very 1222 old implementations.) 1224 - iv is the eight-octet initialization vector. 1226 B.2.4. RC5-CBC-Pad 1228 RC5-CBC-Pad is the RC5(tm) encryption algorithm [RC5] in CBC mode 1229 with RFC 5652 [RFC5652] padding operation, which is a generalization 1230 of the RFC 1423 [RFC1423] padding operation. The scheme is fully 1231 specified in [RFC2040]. RC5-CBC-Pad has a variable key length, from 0 1232 to 256 octets, and supports both a 64-bit block size and a 128-bit 1233 block size. For the former, it has an eight-octet initialization 1234 vector, and for the latter, a 16-octet initialization vector. 1235 RC5-CBC-Pad also has a variable number of "rounds" in the encryption 1236 operation, from 8 to 127. 1238 Note: For RC5 with a 64-bit block size, the padding string is as 1239 defined in RFC 1423 [RFC1423]. For RC5 with a 128-bit block size, the 1240 padding string consists of 16-(||M|| mod 16) octets each with value 1241 16-(||M|| mod 16). 1243 The object identifier rc5-CBC-PAD [RFC2040] identifies RC5-CBC-Pad 1244 encryption scheme: 1246 rc5-CBC-PAD OBJECT IDENTIFIER ::= {encryptionAlgorithm 9} 1248 The parameters field associated with this OID in an 1249 AlgorithmIdentifier shall have type RC5-CBC-Parameters: 1251 RC5-CBC-Parameters ::= SEQUENCE { 1252 version INTEGER {v1-0(16)} (v1-0), 1253 rounds INTEGER (8..127), 1254 blockSizeInBits INTEGER (64 | 128), 1255 iv OCTET STRING OPTIONAL } 1257 The fields of type RC5-CBC-Parameters have the following meanings: 1259 - version is the version of the algorithm, which shall be v1-0. 1261 - rounds is the number of rounds in the encryption operation, 1262 which shall be between 8 and 127. 1264 - blockSizeInBits is the block size in bits, which shall be 64 or 1265 128. 1267 - iv is the initialization vector, an eight-octet string for 1268 64-bit RC5 and a 16-octet string for 128-bit RC5. The default 1269 is a string of the appropriate length consisting of zero 1270 octets. 1272 B.2.5. AES-CBC-Pad 1274 AES-CBC-Pad is the AES encryption algorithm [NIST197] in CBC mode 1275 with RFC 5652 [RFC5652] padding operation. AES-CBC-Pad has a variable 1276 key length of 16, 24, or 32 octets and has a 16-octet block size. It 1277 has a 16-octet initialization vector. 1279 Note: For AES, the padding string consists of 16-(||M|| mod 16) 1280 octets each with value 16-(||M|| mod 16). 1282 For AES, object identifiers are defined depending on key size and 1283 operation mode. For example, the 16-octet (128 bit) key AES 1284 encryption scheme in CBC mode would be aes128-CBC-Pad identifying the 1285 AES-CBC-PAD encryption scheme using a 16-octet key: 1287 aes128-CBC-PAD OBJECT IDENTIFIER ::= {aes 2} 1289 The AES object identifier is defined in Appendix C. 1291 The parameters field associated with this OID in an 1292 AlgorithmIdentifier shall have type OCTET STRING (SIZE(16)), 1293 specifying the initialization vector for CBC mode. 1295 B.3. Message Authentication Schemes 1297 An example message authentication scheme for PBMAC1 (Section 7.1) is 1298 HMAC-SHA-1. 1300 B.3.1. HMAC-SHA-1 1302 HMAC-SHA-1 is the HMAC message authentication scheme [RFC2104] based 1303 on the SHA-1 hash function [NIST180]. HMAC-SHA-1 has a variable key 1304 length and a 20-octet (160-bit) message authentication code. 1306 The object identifier id-hmacWithSHA1 (see Appendix B.1.1) identifies 1307 the HMAC-SHA-1 message authentication scheme. (The object identifier 1308 is the same for both the pseudorandom function and the message 1309 authentication scheme; the distinction is to be understood by 1310 context.) This object identifier is intended to be employed in the 1311 object set PBMAC1-Macs (Appendix A.5). 1313 B.3.2. HMAC-SHA-2 1315 HMAC-SHA-2 refers to the set of HMAC message authentication schemes 1316 [NIST198] based on the SHA-2 functions [NIST180]. HMAC-SHA-2 has a 1317 variable key length and a message authentication code whose length 1318 is based on the hash function chosen (SHA-224, SHA-256, SHA-384, 1319 SHA-512, SHA-512/224, or SHA-512/256giving 28, 32, 48 or 64 octets). 1321 The object identifiers id-hmacWithSHA224, id-hmacWithSHA256, id- 1322 hmacWithSHA384, id-hmacWithSHA512, id-hmacWithSHA512-224,and id- 1323 hmacWithSHA512-256 (see Appendix B.1.2) identify the HMAC-SHA-2 1324 schemes. The object identifiers are the same for both the 1325 pseudo-random functions and the message authentication schemes; the 1326 distinction is to be understood by context. These object identifiers 1327 are intended to be employed in the object set PBMAC1-Macs (Appendix 1328 A.5) 1330 C. ASN.1 Module 1332 For reference purposes, the ASN.1 syntax in the preceding sections is 1333 presented as an ASN.1 module here. 1335 -- PKCS #5 v2.1 ASN.1 Module 1336 -- Revised October 27, 2012 1338 -- This module has been checked for conformance with the 1339 -- ASN.1 standard by the OSS ASN.1 Tools 1341 PKCS5v2-1 { 1342 iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-5(5) 1343 modules(16) pkcs5v2-1(2) 1344 } 1346 DEFINITIONS EXPLICIT TAGS ::= 1348 BEGIN 1350 -- ======================== 1351 -- Basic object identifiers 1352 -- ======================== 1354 nistAlgorithms OBJECT IDENTIFIER ::= {joint-iso-itu-t(2) country(16) 1355 us(840) organization(1) 1356 gov(101) csor(3) 4} 1357 oiw OBJECT IDENTIFIER ::= {iso(1) identified-organization(3) 14} 1358 rsadsi OBJECT IDENTIFIER ::= {iso(1) member-body(2) us(840) 113549} 1359 pkcs OBJECT IDENTIFIER ::= {rsadsi 1} 1360 pkcs-5 OBJECT IDENTIFIER ::= {pkcs 5} 1362 -- ======================= 1363 -- Basic types and classes 1364 -- ======================= 1366 AlgorithmIdentifier { ALGORITHM-IDENTIFIER:InfoObjectSet } ::= 1367 SEQUENCE { 1368 algorithm ALGORITHM-IDENTIFIER.&id({InfoObjectSet}), 1369 parameters ALGORITHM-IDENTIFIER.&Type({InfoObjectSet} 1370 {@algorithm}) OPTIONAL 1371 } 1373 ALGORITHM-IDENTIFIER ::= TYPE-IDENTIFIER 1375 -- ====== 1376 -- PBKDF2 1377 -- ====== 1379 PBKDF2Algorithms ALGORITHM-IDENTIFIER ::= { 1380 {PBKDF2-params IDENTIFIED BY id-PBKDF2}, 1381 ... 1382 } 1384 id-PBKDF2 OBJECT IDENTIFIER ::= {pkcs-5 12} 1386 algid-hmacWithSHA1 AlgorithmIdentifier {{PBKDF2-PRFs}} ::= 1387 {algorithm id-hmacWithSHA1, parameters NULL : NULL} 1389 PBKDF2-params ::= SEQUENCE { 1390 salt CHOICE { 1391 specified OCTET STRING, 1392 otherSource AlgorithmIdentifier {{PBKDF2-SaltSources}} 1393 }, 1394 iterationCount INTEGER (1..MAX), 1395 keyLength INTEGER (1..MAX) OPTIONAL, 1396 prf AlgorithmIdentifier {{PBKDF2-PRFs}} DEFAULT 1397 algid-hmacWithSHA1 1398 } 1400 PBKDF2-SaltSources ALGORITHM-IDENTIFIER ::= { ... } 1402 PBKDF2-PRFs ALGORITHM-IDENTIFIER ::= { 1403 {NULL IDENTIFIED BY id-hmacWithSHA1}, 1404 {NULL IDENTIFIED BY id-hmacWithSHA224}, 1405 {NULL IDENTIFIED BY id-hmacWithSHA256}, 1406 {NULL IDENTIFIED BY id-hmacWithSHA384}, 1407 {NULL IDENTIFIED BY id-hmacWithSHA512}, 1408 {NULL IDENTIFIED BY id-hmacWithSHA512-224}, 1409 {NULL IDENTIFIED BY id-hmacWithSHA512-256}, 1410 ... 1411 } 1413 -- ===== 1414 -- PBES1 1415 -- ===== 1417 PBES1Algorithms ALGORITHM-IDENTIFIER ::= { 1418 {PBEParameter IDENTIFIED BY pbeWithMD2AndDES-CBC} | 1419 {PBEParameter IDENTIFIED BY pbeWithMD2AndRC2-CBC} | 1420 {PBEParameter IDENTIFIED BY pbeWithMD5AndDES-CBC} | 1421 {PBEParameter IDENTIFIED BY pbeWithMD5AndRC2-CBC} | 1422 {PBEParameter IDENTIFIED BY pbeWithSHA1AndDES-CBC} | 1423 {PBEParameter IDENTIFIED BY pbeWithSHA1AndRC2-CBC}, 1424 ... 1425 } 1427 pbeWithMD2AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 1} 1428 pbeWithMD2AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 4} 1429 pbeWithMD5AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 3} 1430 pbeWithMD5AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 6} 1431 pbeWithSHA1AndDES-CBC OBJECT IDENTIFIER ::= {pkcs-5 10} 1432 pbeWithSHA1AndRC2-CBC OBJECT IDENTIFIER ::= {pkcs-5 11} 1434 PBEParameter ::= SEQUENCE { 1435 salt OCTET STRING (SIZE(8)), 1436 iterationCount INTEGER 1437 } 1439 -- ===== 1440 -- PBES2 1441 -- ===== 1443 PBES2Algorithms ALGORITHM-IDENTIFIER ::= { 1444 {PBES2-params IDENTIFIED BY id-PBES2}, 1445 ... 1446 } 1448 id-PBES2 OBJECT IDENTIFIER ::= {pkcs-5 13} 1450 PBES2-params ::= SEQUENCE { 1451 keyDerivationFunc AlgorithmIdentifier {{PBES2-KDFs}}, 1452 encryptionScheme AlgorithmIdentifier {{PBES2-Encs}} 1453 } 1455 PBES2-KDFs ALGORITHM-IDENTIFIER ::= { 1456 {PBKDF2-params IDENTIFIED BY id-PBKDF2}, 1457 ... 1458 } 1460 PBES2-Encs ALGORITHM-IDENTIFIER ::= { ... } 1462 -- ====== 1463 -- PBMAC1 1464 -- ====== 1466 PBMAC1Algorithms ALGORITHM-IDENTIFIER ::= { 1467 {PBMAC1-params IDENTIFIED BY id-PBMAC1}, 1468 ... 1469 } 1471 id-PBMAC1 OBJECT IDENTIFIER ::= {pkcs-5 14} 1473 PBMAC1-params ::= SEQUENCE { 1474 keyDerivationFunc AlgorithmIdentifier {{PBMAC1-KDFs}}, 1475 messageAuthScheme AlgorithmIdentifier {{PBMAC1-MACs}} 1476 } 1478 PBMAC1-KDFs ALGORITHM-IDENTIFIER ::= { 1479 {PBKDF2-params IDENTIFIED BY id-PBKDF2}, 1480 ... 1481 } 1483 PBMAC1-MACs ALGORITHM-IDENTIFIER ::= { ... } 1485 -- ===================== 1486 -- Supporting techniques 1487 -- ===================== 1489 digestAlgorithm OBJECT IDENTIFIER ::= {rsadsi 2} 1490 encryptionAlgorithm OBJECT IDENTIFIER ::= {rsadsi 3} 1492 SupportingAlgorithms ALGORITHM-IDENTIFIER ::= { 1493 {NULL IDENTIFIED BY id-hmacWithSHA1} | 1494 {OCTET STRING (SIZE(8)) IDENTIFIED BY desCBC} | 1495 {OCTET STRING (SIZE(8)) IDENTIFIED BY des-EDE3-CBC} | 1496 {RC2-CBC-Parameter IDENTIFIED BY rc2CBC} | 1497 {RC5-CBC-Parameters IDENTIFIED BY rc5-CBC-PAD}, | 1498 {OCTET STRING (SIZE(16)) IDENTIFIED BY aes128-CBC-PAD} | 1499 {OCTET STRING (SIZE(16)) IDENTIFIED BY aes192-CBC-PAD} | 1500 {OCTET STRING (SIZE(16)) IDENTIFIED BY aes256-CBC-PAD}, 1501 ... 1502 } 1504 id-hmacWithSHA1 OBJECT IDENTIFIER ::= {digestAlgorithm 7} 1505 id-hmacWithSHA224 OBJECT IDENTIFIER ::= {digestAlgorithm 8} 1506 id-hmacWithSHA256 OBJECT IDENTIFIER ::= {digestAlgorithm 9} 1507 id-hmacWithSHA384 OBJECT IDENTIFIER ::= {digestAlgorithm 10} 1508 id-hmacWithSHA512 OBJECT IDENTIFIER ::= {digestAlgorithm 11} 1509 id-hmacWithSHA512-224 OBJECT IDENTIFIER ::= {digestAlgorithm 12} 1510 id-hmacWithSHA512-256 OBJECT IDENTIFIER ::= {digestAlgorithm 13} 1512 desCBC OBJECT IDENTIFIER ::= {oiw secsig(3) algorithms(2) 7} 1514 des-EDE3-CBC OBJECT IDENTIFIER ::= {encryptionAlgorithm 7} 1516 rc2CBC OBJECT IDENTIFIER ::= {encryptionAlgorithm 2} 1518 RC2-CBC-Parameter ::= SEQUENCE { 1519 rc2ParameterVersion INTEGER OPTIONAL, 1520 iv OCTET STRING (SIZE(8)) 1521 } 1523 rc5-CBC-PAD OBJECT IDENTIFIER ::= {encryptionAlgorithm 9} 1525 RC5-CBC-Parameters ::= SEQUENCE { 1526 version INTEGER {v1-0(16)} (v1-0), 1527 rounds INTEGER (8..127), 1528 blockSizeInBits INTEGER (64 | 128), 1529 iv OCTET STRING OPTIONAL 1530 } 1532 aes OBJECT IDENTIFIER ::= { nistAlgorithms 1 } 1533 aes128-CBC-PAD OBJECT IDENTIFIER ::= { aes 2 } 1534 aes192-CBC-PAD OBJECT IDENTIFIER ::= { aes 22 } 1535 aes256-CBC-PAD OBJECT IDENTIFIER ::= { aes 42 } 1537 END 1539 D. Intellectual Property Considerations 1541 EMC Corporation makes no patent claims on the general constructions 1542 described in this document, although specific underlying techniques 1543 may be covered. Among the underlying techniques, the RC5 encryption 1544 algorithm (Appendix B.2.4) is protected by U.S. Patents 5,724,428 1545 [RBLOCK1] and 5,835,600 [RBLOCK2]. 1547 RC2 and RC5 are trademarks of EMC Corporation. 1549 EMC Corporation makes no representation regarding intellectual 1550 property claims by other parties. Such determination is the 1551 responsibility of the user. 1553 E. Revision History 1555 Versions 1.0-1.3 1557 Versions 1.0-1.3 were distributed to participants in RSA Data 1558 Security Inc.'s Public-Key Cryptography Standards meetings in 1559 February and March 1991. 1561 Version 1.4 1563 Version 1.4 was part of the June 3, 1991 initial public release of 1564 PKCS. Version 1.4 was published as NIST/OSI Implementors' Workshop 1565 document SEC-SIG-91-20. 1567 Version 1.5 1569 Version 1.5 incorporated several editorial changes, including 1570 updates to the references and the addition of a revision history. 1572 Version 2.0 1574 Version 2.0 incorporates major editorial changes in terms of the 1575 document structure, and introduces the PBES2 encryption scheme, 1576 the PBMAC1 message authentication scheme, and independent 1577 password-based key derivation functions. This version continues to 1578 support the encryption process in version 1.5. 1580 Version 2.1 1582 This document transfers PKCS #5 into the IETF and includes some 1583 minor changes from the authors for this submission. 1585 o Introduces AES/CBC as an encryption scheme for PBES2 and HMAC 1586 with the hash functions SHA-224, SHA-256, SHA-384, SHA-512, 1587 SHA-512/224, and SHA512/256 as pseudo-random functions for PBKDF2 1588 and message authentication schemes for PBMAC1. 1590 o Replacement of RSA with EMC in the "Intellectual Property 1591 Considerations". 1593 o Changes references to PKCS #5 and PKCS #8 to RSA 2898 and RFC 1594 5208/5898. 1596 o Incorporates two editorial errata reported on PKCS #5 [RFC2898]. 1598 o Added security considerations for MD2, MD5, and SHA-1. 1600 F. References 1602 F.1 Normative References 1604 [ANSIX952] 1605 American National Standard X9.52 - 1998, Triple Data Encryption 1606 Algorithm Modes of Operation. Working draft, Accredited 1607 Standards Committee X9, July 27, 1998. 1609 [BELLOV] 1610 S.M. Bellovin and M. Merritt. Encrypted key exchange: Password- 1611 based protocols secure against dictionary attacks. In 1612 Proceedings of the 1992 IEEE Computer Society Conference on 1613 Research in Security and Privacy, pages 72-84, IEEE Computer 1614 Society, 1992. 1616 [COCHRAN] 1617 M. Cochran. Notes on the Wang et al. 2^63 SHA-1 Differential 1618 Path. International Association for Cryptologic Research, ePrint 1619 Archive. August 2008. Available from 1620 1622 [ISO8824-1] 1623 ISO/IEC 8824-1: 2008: Information technology - Abstract Syntax 1624 Notation One (ASN.1) - Specification of basic notation. 2008. 1626 [ISO8824-2] 1627 ISO/IEC 8824-2: 2008: Information technology - Abstract Syntax 1628 Notation One (ASN.1) - Information object specification. 2008. 1630 [ISO8824-3] 1631 ISO/IEC 8824-3: 2008: Information technology - Abstract Syntax 1632 Notation One (ASN.1) - Constraint specification. 2008. 1634 [ISO8824-4] 1635 ISO/IEC 8824-4: 2008: Information technology - Abstract Syntax 1636 Notation One (ASN.1) - Parameterization of ASN.1 specifications. 1637 2008. 1639 [JABLON] 1640 D. Jablon. Strong password-only authenticated key exchange. ACM 1641 Computer Communications Review, October 1996. 1643 [MORRIS] 1644 Robert Morris and Ken Thompson. Password security: A case 1645 history. Communications of the ACM, 22(11):594-597, November 1646 1979. 1648 [NIST46] 1649 National Institute of Standards and Technology (NIST). FIPS PUB 1650 46-3: Data Encryption Standard. October 1999. 1652 [NIST81] 1653 National Institute of Standards and Technology (NIST). FIPS PUB 1654 81: DES Modes of Operation. December 2, 1980. 1656 [NIST180] 1657 National Institute of Standards and Technology (NIST). FIPS PUB 1658 180-4: Secure Hash Standard. March 2012. 1660 [NIST197] 1661 National Institute of Standards and Technology (NIST). FIPS PUB 1662 197: Advance Encryption Standard (AES). November 2001. 1664 [NIST198] 1665 National Institute of Standards and Technology (NIST). FIPS 1666 Publication 198-1: The Keyed - Hash Message Authentication Code 1667 (HMAC). July 2008. 1669 [NISTSP63] 1670 National Institute of Standards and Technology (NIST). Special 1671 Publication 800-63-2: Electronic Authentication Guideline, 1672 Appendix A. August 2013. 1674 [NISTSP132] 1675 National Institute of Standards and Technology (NIST). Special 1676 Publication 800-132: Recommendation for Password - Based Key 1677 Derivation, Part 1: Storage Applications. December 2010. 1679 [PKCS5_15] 1680 RSA Laboratories. PKCS #5: Password-Based Encryption Standard 1681 Version 1.5, November 1993. 1683 [PKCS5_21] 1684 RSA Laboratories. PKCS #5: Password-Based Encryption Standard 1685 Version 2.1, October 2012. 1687 [PKCS8] 1688 RSA Laboratories. "PKCS #8: Private-Key Information Syntax 1689 Standard Version 1.2", RFC 5208, May 2008. 1691 [RBLOCK1] 1692 R.L. Rivest. Block-Encryption Algorithm with Data-Dependent 1693 Rotations. U.S. Patent No. 5,724,428, March 3, 1998. 1695 [RBLOCK2] 1696 R.L. Rivest. Block Encryption Algorithm with Data-Dependent 1697 Rotations. U.S. Patent No. 5,835,600, November 10, 1998. 1699 [RC5] 1700 R.L. Rivest. The RC5 encryption algorithm. In Proceedings of the 1701 Second International Workshop on Fast Software Encryption, pages 1702 86-96, Springer-Verlag, 1994. 1704 [RFC1319] 1705 Kaliski, B., "The MD2 Message-Digest Algorithm", RFC 1319, April 1706 1992, 1707 . 1709 [RFC1321] 1710 Rivest, R., "The MD5 Message-Digest Algorithm", RFC 1321, April 1711 1992, 1712 . 1714 [RFC1423] 1715 Balenson, D., "Privacy Enhancement for Internet Electronic Mail: 1716 Part III: Algorithms, Modes, and Identifiers", RFC 1423, 1717 February 1993, 1718 . 1720 [RFC2040] 1721 Baldwin, R. and R. Rivest, "The RC5, RC5-CBC, RC5-CBC-Pad, and 1722 RC5-CTS Algorithms", RFC 2040, October 1996, 1723 . 1725 [RFC2104] 1726 Krawczyk, H., Bellare, M. and R. Canetti, "HMAC: Keyed-Hashing 1727 for Message Authentication", RFC 2104, February 1997, 1728 . 1730 [RFC2268] 1731 Rivest, R., "A Description of the RC2(r) Encryption Algorithm", 1732 RFC 2268, March 1998, 1733 . 1735 [RFC2279] 1736 Yergeau, F., "UTF-8, a transformation format of ISO 10646", RFC 1737 2279, January 1998, 1738 . 1740 [RFC2898] 1741 B. Kaliski., "PKCS #5: Password-Based Encryption Standard 1742 Version 2.0", RFC 2898, September 2000, 1743 . 1745 [RFC5652] 1746 R. Housley. RFC 5652: Cryptographic Message Syntax. IETF, 1747 September 2009, 1748 . 1750 [RFC5958] 1751 Turner, S., "Asymmetric Key Packages", RFC 5958, August 2010, 1752 . 1754 [RFC6149] 1755 Turner, S. and L. Chen, "MD2 to Historic Status", RFC 6149, 1756 March 2011, 1757 . 1759 [RFC6151] 1760 Turner, S. and L. Chen, "Updated Security Considerations for the 1761 MD5 Message-Digest and the HMAC-MD5 Algorithms", RFC 6151, March 1762 2011, 1763 . 1765 [RFC6194] 1766 Polk, T., Chen, L., Turner, S., and P. Hoffman, "Security 1767 Considerations for the SHA-0 and SHA-1 Message-Digest 1768 Algorithms", RFC 6194, March 2011, 1769 . 1771 [WANG] 1772 X. Wang, A.C. Yao, and F. Yao. Cryptanalysis on SHA-1. 1773 Presented by Adi Shamir at the rump session of CRYPTO 2005. 1774 Slides may be found currently at 1775 1778 [WU] 1779 T. Wu. The Secure Remote Password protocol. In Proceedings of 1780 the 1998 Internet Society Network and Distributed System 1781 Security Symposium, pages 97-111, Internet Society, 1998. 1783 G. About PKCS 1785 The Public-Key Cryptography Standards are specifications produced by 1786 RSA Laboratories in cooperation with secure systems developers 1787 worldwide for the purpose of accelerating the deployment of public- 1788 key cryptography. First published in 1991 as a result of meetings 1789 with a small group of early adopters of public-key technology, the 1790 PKCS documents have become widely referenced and implemented. 1791 Contributions from the PKCS series have become part of many formal 1792 and de facto standards, including ANSI X9 documents, PKIX, SET, 1793 S/MIME, and SSL. 1795 Further development of most PKCS documents occurs through the IETF. 1796 Suggestions for improvement are welcome. 1798 H. Acknowledgements 1800 This document is based on a contribution of RSA Laboratories, the 1801 research center of RSA Security Inc. 1803 Authors' Addresses 1805 Kathleen M. Moriarty (editor) 1806 EMC Corporation 1807 176 South Street 1808 Hopkinton, MA 01748 1809 US 1811 Email: kathleen.moriarty@emc.com 1813 Burt Kaliski 1814 Verisign 1815 12061 Bluemont Way 1816 Reston, VA 20190 1817 US 1819 Email: bkaliski@verisign.com 1820 URI: http://verisignlabs.com 1822 Andreas Rusch 1823 RSA 1824 345 Queen Street 1825 Brisbane, QLD 4000 1826 AU 1828 Email: andreas.rusch@rsa.com