开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
secpkcs5.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：46k
源码类别：

CA认证

开发平台：

WINDOWS

secpkcs5.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. #include "plarena.h"
  36. #include "seccomon.h"
  37. #include "secitem.h"
  38. #include "secport.h"
  39. #include "hasht.h"
  40. #include "pkcs11t.h"
  41. #include "blapi.h"
  42. #include "sechash.h"
  43. #include "secasn1.h"
  44. #include "secder.h"
  45. #include "secpkcs5.h"
  46. #include "secoid.h"
  47. #include "alghmac.h"
  48. #include "softoken.h"
  49. #include "secerr.h"
  51. #define DES_IV_LENGTH 8
  52. #define RC2_IV_LENGTH 8
  53. #define MD2_LENGTH 16
  54. #define MD5_LENGTH 16
  55. #define SHA1_LENGTH 20
  56. #define SEED_LENGTH  16
  57. #define SALT_LENGTH 8
  58. #define PBE_SALT_LENGTH 16
  60. /* template for PKCS 5 PBE Parameter.  This template has been expanded
  61.  * based upon the additions in PKCS 12.  This should eventually be moved
  62.  * if RSA updates PKCS 5.
  63.  */
  64. const SEC_ASN1Template SEC_PKCS5PBEParameterTemplate[] =
  65. {
  66.     { SEC_ASN1_SEQUENCE, 
  67. 0, NULL, sizeof(SEC_PKCS5PBEParameter) },
  68.     { SEC_ASN1_OCTET_STRING, 
  69. offsetof(SEC_PKCS5PBEParameter, salt) },
  70.     { SEC_ASN1_INTEGER,
  71. offsetof(SEC_PKCS5PBEParameter, iteration) },
  72.     { 0 }
  73. };
  75. const SEC_ASN1Template SEC_V2PKCS12PBEParameterTemplate[] =
  76. {   
  77.     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(SEC_PKCS5PBEParameter) },
  78.     { SEC_ASN1_OCTET_STRING, offsetof(SEC_PKCS5PBEParameter, salt) },
  79.     { SEC_ASN1_INTEGER, offsetof(SEC_PKCS5PBEParameter, iteration) },
  80.     { 0 }
  81. };
  83. pbeBitGenParameters pbeHashAlgorithmParams[] = {
  84.     {   0,   0, SEC_OID_UNKNOWN },
  85.     { 128, 512, SEC_OID_MD2 },
  86.     { 128, 512, SEC_OID_MD5 },
  87.     { 160, 512, SEC_OID_SHA1 },
  88. };
  90. /* generate some random bytes.  this is used to generate the 
  91.  * salt if it is not specified.
  92.  */
  93. static SECStatus 
  94. sec_pkcs5_generate_random_bytes(PRArenaPool *poolp, 
  95. SECItem *dest, int len)
  96. {
  97.     SECStatus rv = SECFailure;
  99.     if(dest != NULL)
  100.     {
  101. void *mark = PORT_ArenaMark(poolp);
  102. dest->data = (unsigned char *)PORT_ArenaZAlloc(poolp, len);
  103. if(dest->data != NULL)
  104. {
  105.     dest->len = len;
  106.     RNG_GenerateGlobalRandomBytes(dest->data, dest->len);
  107.     PORT_ArenaUnmark(poolp, mark);
  108.     rv = SECSuccess;
  109. } else
  110.     PORT_ArenaRelease(poolp, mark);
  111.     }
  113.     return rv;
  114. }
  116. /* maps hash algorithm from PBE algorithm.
  117.  */
  118. static SECOidTag 
  119. sec_pkcs5_hash_algorithm(SECOidTag algorithm)
  120. {
  121.     switch(algorithm)
  122.     {
  123. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_TRIPLE_DES_CBC:
  124. case SEC_OID_PKCS5_PBE_WITH_SHA1_AND_DES_CBC:
  125. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  126. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  127. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC4:
  128. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC4:
  129. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC4:
  130. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC4:
  131. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC:
  132. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_2KEY_TRIPLE_DES_CBC:
  133. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  134. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  135.     return SEC_OID_SHA1;
  136. case SEC_OID_PKCS5_PBE_WITH_MD5_AND_DES_CBC:
  137.     return SEC_OID_MD5;
  138. case SEC_OID_PKCS5_PBE_WITH_MD2_AND_DES_CBC:
  139.     return SEC_OID_MD2;
  140. default:
  141.     break;
  142.     }
  143.     return SEC_OID_UNKNOWN;
  144. }
  146. /* get the iv length needed for the PBE algorithm 
  147.  */
  148. static int 
  149. sec_pkcs5_iv_length(SECOidTag algorithm)
  150. {
  151.     switch(algorithm)
  152.     {
  153. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_TRIPLE_DES_CBC:
  154. case SEC_OID_PKCS5_PBE_WITH_MD2_AND_DES_CBC:
  155. case SEC_OID_PKCS5_PBE_WITH_SHA1_AND_DES_CBC:
  156. case SEC_OID_PKCS5_PBE_WITH_MD5_AND_DES_CBC:
  157. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC:
  158. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_2KEY_TRIPLE_DES_CBC:
  159.     return DES_IV_LENGTH;
  160. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  161. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  162. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  163. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  164.     return RC2_IV_LENGTH;
  165. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC4:
  166. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC4:
  167. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC4:
  168. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC4:
  169.     return 0;
  170. default:
  171.     break;
  172.     }
  173.     return -1;
  174. }
  176. /* get the key length needed for the PBE algorithm
  177.  */
  178. static int 
  179. sec_pkcs5_key_length(SECOidTag algorithm)
  180. {
  181.     switch(algorithm)
  182.     {
  183. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC:
  184. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_TRIPLE_DES_CBC:
  185. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_2KEY_TRIPLE_DES_CBC:
  186.     return 24;
  187. case SEC_OID_PKCS5_PBE_WITH_MD2_AND_DES_CBC:
  188. case SEC_OID_PKCS5_PBE_WITH_SHA1_AND_DES_CBC:
  189. case SEC_OID_PKCS5_PBE_WITH_MD5_AND_DES_CBC:
  190.     return 8;
  191. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  192. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC4:
  193. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC4:
  194. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  195.     return 5;
  196. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  197. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC4:
  198. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  199. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC4:
  200.     return 16;
  201. default:
  202.     break;
  203.     }
  204.     return -1;
  205. }
  207. /* the V2 algorithms only encode the salt, there is no iteration
  208.  * count so we need a check for V2 algorithm parameters.
  209.  */
  210. static PRBool
  211. sec_pkcs5_is_algorithm_v2_pkcs12_algorithm(SECOidTag algorithm)
  212. {
  213.     switch(algorithm) 
  214.     {
  215. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC4:
  216. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC4:
  217. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC:
  218. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_2KEY_TRIPLE_DES_CBC:
  219. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  220. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  221.     return PR_TRUE;
  222. default:
  223.     break;
  224.     }
  226.     return PR_FALSE;
  227. }
  229. /* creates a PBE parameter based on the PBE algorithm.  the only required
  230.  * parameters are algorithm and interation.  the return is a PBE parameter
  231.  * which conforms to PKCS 5 parameter unless an extended parameter is needed.
  232.  * this is primarily if keyLen and a variable key length algorithm are
  233.  * specified.
  234.  *   salt -  if null, a salt will be generated from random bytes.
  235.  *   iteration - number of iterations to perform hashing.
  236.  *   keyLen - only used in variable key length algorithms
  237.  *   iv - if null, the IV will be generated based on PKCS 5 when needed.
  238.  *   params - optional, currently unsupported additional parameters.
  239.  * once a parameter is allocated, it should be destroyed calling 
  240.  * sec_pkcs5_destroy_pbe_parameter or SEC_PKCS5DestroyPBEParameter.
  241.  */
  242. static SEC_PKCS5PBEParameter *
  243. sec_pkcs5_create_pbe_parameter(SECOidTag algorithm, 
  244. SECItem *salt, 
  245. int iteration)
  246. {
  247.     PRArenaPool *poolp = NULL;
  248.     SEC_PKCS5PBEParameter *pbe_param = NULL;
  249.     SECStatus rv; 
  250.     void *dummy = NULL;
  252.     if(iteration < 0) {
  253. return NULL;
  254.     }
  256.     poolp = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
  257.     if(poolp == NULL)
  258. return NULL;
  260.     pbe_param = (SEC_PKCS5PBEParameter *)PORT_ArenaZAlloc(poolp,
  261. sizeof(SEC_PKCS5PBEParameter));
  262.     if(!pbe_param) {
  263. PORT_FreeArena(poolp, PR_TRUE);
  264. return NULL;
  265.     }
  267.     pbe_param->poolp = poolp;
  268.     pbe_param->algorithm = algorithm;
  270.     /* should we generate the salt? */
  271.     if(!salt || !salt->data) {
  272. rv = sec_pkcs5_generate_random_bytes(poolp, &pbe_param->salt, 
  273. SALT_LENGTH);
  274.     } else {
  275. rv = SECITEM_CopyItem(poolp, &pbe_param->salt, salt);
  276.     }
  278.     if(rv != SECSuccess) {
  279. PORT_FreeArena(poolp, PR_TRUE);
  280. return NULL;
  281.     }
  283.     /* encode the integer */
  284.     dummy = SEC_ASN1EncodeInteger(poolp, &pbe_param->iteration, 
  285. iteration);
  286.     rv = (dummy) ? SECSuccess : SECFailure;
  288.     if(rv != SECSuccess) {
  289. PORT_FreeArena(poolp, PR_FALSE);
  290. return NULL;
  291.     }
  293.     return pbe_param;
  294. }
  296. /* generate bits for key and iv using MD5 hashing 
  297.  */
  298. static SECItem *
  299. sec_pkcs5_compute_md5_hash(SECItem *salt, SECItem *pwd, int iter,
  300.    PRBool dummy)
  301. {
  302.     SECItem *hash = NULL, *pre_hash = NULL;
  303.     SECStatus rv = SECFailure;
  305.     if((salt == NULL) || (pwd == NULL) || (iter < 0)) {
  306. return NULL;
  307.     }
  309.     hash = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  310.     pre_hash = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  311.     if((hash != NULL) && (pre_hash != NULL)) {
  312. unsigned int i, ph_len;
  314. ph_len = MD5_LENGTH;
  315. if(ph_len < (salt->len + pwd->len)) {
  316.     ph_len = salt->len + pwd->len;
  317. }
  319. rv = SECFailure;
  320. hash->data = (unsigned char *)PORT_ZAlloc(MD5_LENGTH);
  321. hash->len = MD5_LENGTH;
  322. pre_hash->data = (unsigned char *)PORT_ZAlloc(ph_len);
  323. pre_hash->len = salt->len + pwd->len;
  325. if((hash->data != NULL) && (pre_hash->data != NULL)) {
  326.     rv = SECSuccess;
  327.     /* handle 0 length password */
  328.     if(pwd->len > 0) {
  329. PORT_Memcpy(pre_hash->data, pwd->data, pwd->len);
  330.     }
  331.     if(salt->len > 0) {
  332.   PORT_Memcpy((pre_hash->data+pwd->len), salt->data, salt->len);
  333.     }
  334.     for(i = 0; ((i < (unsigned int)iter) && (rv == SECSuccess)); i++) {
  335. rv = MD5_HashBuf(hash->data, pre_hash->data, pre_hash->len);
  336. if(rv != SECFailure) {
  337.     PORT_Memcpy(pre_hash->data, hash->data, MD5_LENGTH);
  338.     pre_hash->len = MD5_LENGTH;
  339. }
  340.     }
  341. }
  342.     }
  344.     if(pre_hash != NULL)
  345. SECITEM_FreeItem(pre_hash, PR_TRUE);
  347.     if((rv == SECFailure) && (hash)) {
  348. SECITEM_FreeItem(hash, PR_TRUE);
  349. hash = NULL;
  350.     }
  352.     return hash;
  353. }
  355. /* generate bits for key and iv using MD2 hashing 
  356.  */
  357. static SECItem *
  358. sec_pkcs5_compute_md2_hash(SECItem *salt, SECItem *pwd, int iter,
  359.    PRBool dummy)
  360. {
  361.     SECItem *hash = NULL, *pre_hash = NULL;
  362.     SECStatus rv = SECFailure;
  364.     if((salt == NULL) || (pwd == NULL) || (iter < 0))
  365. return NULL;
  367.     hash = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  368.     pre_hash = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  369.     if((hash != NULL) && (pre_hash != NULL))
  370.     {
  371. int i, ph_len;
  373. ph_len = MD2_LENGTH;
  374. if((salt->len + pwd->len) > MD2_LENGTH)
  375.     ph_len = salt->len+pwd->len;
  377. rv = SECFailure;
  378. hash->data = (unsigned char *)PORT_ZAlloc(MD2_LENGTH);
  379. hash->len = MD2_LENGTH;
  380. pre_hash->data = (unsigned char *)PORT_ZAlloc(ph_len);
  381. pre_hash->len = salt->len + pwd->len;
  383. if((hash->data != NULL) && (pre_hash->data != NULL))
  384. {
  385.     MD2Context *ctxt;
  387.     rv = SECSuccess;
  388.     if(pwd->len > 0) {
  389. PORT_Memcpy(pre_hash->data, pwd->data, pwd->len);
  390.     }
  391.     if(salt->len > 0) {
  392. PORT_Memcpy((pre_hash->data+pwd->len), salt->data, salt->len);
  393.     }
  395.     for(i = 0; ((i < iter) && (rv == SECSuccess)); i++)
  396.     {
  397. ctxt = MD2_NewContext();
  398. if(ctxt == NULL)
  399.     rv = SECFailure;
  400. else
  401. {
  402.     MD2_Update(ctxt, pre_hash->data, pre_hash->len);
  403.     MD2_End(ctxt, hash->data, &hash->len, hash->len);
  404.     PORT_Memcpy(pre_hash->data, hash->data, MD2_LENGTH);
  405.     pre_hash->len = MD2_LENGTH;
  406.     MD2_DestroyContext(ctxt, PR_TRUE);
  407. }
  408.     }
  409. }
  410.     }
  412.     if(pre_hash != NULL)
  413. SECITEM_FreeItem(pre_hash, PR_TRUE);
  415.     if(rv != SECSuccess)
  416. if(hash != NULL)
  417. {
  418.     SECITEM_FreeItem(hash, PR_TRUE);
  419.     hash = NULL;
  420. }
  422.     return hash;
  423. }
  425. /* generate bits using SHA1 hash 
  426.  */
  427. static SECItem *
  428. sec_pkcs5_compute_sha1_hash(SECItem *salt, SECItem *pwd, int iter, 
  429.     PRBool faulty3DES) 
  430. {
  431.     SECItem *hash = NULL, *pre_hash = NULL;
  432.     SECStatus rv = SECFailure;
  434.     if((salt == NULL) || (pwd == NULL) || (iter < 0)) {
  435. return NULL;
  436.     }
  438.     hash = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  439.     pre_hash = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  441.     if((hash != NULL) && (pre_hash != NULL)) {
  442. int i, ph_len;
  444. ph_len = SHA1_LENGTH;
  445. if((salt->len + pwd->len) > SHA1_LENGTH) {
  446.     ph_len = salt->len + pwd->len;
  447. }
  449. rv = SECFailure;
  451. /* allocate buffers */
  452. hash->data = (unsigned char *)PORT_ZAlloc(SHA1_LENGTH);
  453. hash->len = SHA1_LENGTH;
  454. pre_hash->data = (unsigned char *)PORT_ZAlloc(ph_len);
  456. /* in pbeSHA1TripleDESCBC there was an allocation error that made
  457.  * it into the caller.  We do not want to propagate those errors
  458.  * further, so we are doing it correctly, but reading the old method.
  459.  */
  460. if(faulty3DES) {
  461.     pre_hash->len = ph_len;
  462. } else {
  463.     pre_hash->len = salt->len + pwd->len;
  464. }
  466. /* preform hash */
  467. if((hash->data != NULL) && (pre_hash->data != NULL)) {
  468.     rv = SECSuccess;
  469.     /* check for 0 length password */
  470.     if(pwd->len > 0) {
  471. PORT_Memcpy(pre_hash->data, pwd->data, pwd->len);
  472.     }
  473.     if(salt->len > 0) {
  474. PORT_Memcpy((pre_hash->data+pwd->len), salt->data, salt->len);
  475.     }
  476.     for(i = 0; ((i < iter) && (rv == SECSuccess)); i++) {
  477. rv = SHA1_HashBuf(hash->data, pre_hash->data, pre_hash->len);
  478. if(rv != SECFailure) {
  479.     pre_hash->len = SHA1_LENGTH;
  480.     PORT_Memcpy(pre_hash->data, hash->data, SHA1_LENGTH);
  481. }
  482.     }
  483. }
  484.     }
  486.     if(pre_hash != NULL) {
  487. SECITEM_FreeItem(pre_hash, PR_TRUE);
  488.     }
  490.     if((rv != SECSuccess) && (hash != NULL)) {
  491. SECITEM_FreeItem(hash, PR_TRUE);
  492. hash = NULL;
  493.     }
  495.     return hash;
  496. }
  498. /* bit generation/key and iv generation routines. */
  499. typedef SECItem *(* sec_pkcs5_hash_func)(SECItem *s, SECItem *p, 
  500.  int iter, PRBool faulty3DES);
  502. /* generates bits needed for the key and iv based on PKCS 5,
  503.  * be concatenating the password and salt and using the appropriate
  504.  * hash algorithm.  This function serves as a front end to the 
  505.  * specific hash functions above.  a return of NULL indicates an
  506.  * error.
  507.  */
  508. static SECItem *
  509. sec_pkcs5_compute_hash(SEC_PKCS5PBEParameter *pbe_param, SECItem *pwitem,
  510.        PRBool faulty3DES)
  511. {
  512.     sec_pkcs5_hash_func hash_func;
  513.     SECOidTag hash_alg;
  514.     SECItem *hash = NULL;
  515.     SECItem *salt = NULL;
  517.     hash_alg = sec_pkcs5_hash_algorithm(pbe_param->algorithm);
  518.     salt = &(pbe_param->salt);
  519.     switch(hash_alg)
  520.     {
  521. case SEC_OID_SHA1:
  522.     hash_func = sec_pkcs5_compute_sha1_hash;
  523.     break;
  524. case SEC_OID_MD2:
  525.     hash_func = sec_pkcs5_compute_md2_hash;
  526.     break;
  527. case SEC_OID_MD5:
  528.     hash_func = sec_pkcs5_compute_md5_hash;
  529.     break;
  530. default:
  531.     hash_func = NULL;
  532.     }
  534.     if(hash_func) {
  535. hash = (* hash_func)(salt, pwitem, pbe_param->iter, faulty3DES);
  536.     }
  538.     return hash;
  539. }
  541. /* determines the number of bits needed for key and iv generation
  542.  * based upon the algorithm identifier.  if a number of
  543.  * bits greater than the hash algorithm can produce are needed,
  544.  * the bits will be generated based upon the extended PKCS 5 
  545.  * described in PKCS 12.
  546.  *
  547.  * a return of -1 indicates an error.
  548.  */
  549. static int 
  550. sec_pkcs5_bits_needed(SEC_PKCS5PBEParameter *pbe_param)
  551. {
  552.     int iv_bits;
  553.     int key_bits;
  554.     
  555.     if(pbe_param == NULL) {
  556. return -1;
  557.     }
  559.     iv_bits = sec_pkcs5_iv_length(pbe_param->algorithm) * 8;
  560.     key_bits = sec_pkcs5_key_length(pbe_param->algorithm) * 8;
  562.     if(key_bits != 0) {
  563. return iv_bits + key_bits;
  564.     }
  566.     return -1;
  567. }
  569. /* determines the number of bits generated by each hash algorithm.
  570.  * in case of an error, -1 is returned. 
  571.  */
  572. static int
  573. sec_pkcs5_hash_bits_generated(SEC_PKCS5PBEParameter *pbe_param)
  574. {
  575.     if(pbe_param == NULL) {
  576. return -1;
  577.     }
  579.     switch(sec_pkcs5_hash_algorithm(pbe_param->algorithm)) {
  580. case SEC_OID_SHA1:
  581.     return SHA1_LENGTH * 8;
  582. case SEC_OID_MD2:
  583.     return MD2_LENGTH * 8;
  584. case SEC_OID_MD5:
  585.     return MD5_LENGTH * 8;
  586. default:
  587.     break;
  588.     }
  590.     return -1;
  591. }
  593. /* this bit generation routine is described in PKCS 12 and the proposed
  594.  * extensions to PKCS 5.  an initial hash is generated following the
  595.  * instructions laid out in PKCS 5.  If the number of bits generated is
  596.  * insufficient, then the method discussed in the proposed extensions to
  597.  * PKCS 5 in PKCS 12 are used.  This extension makes use of the HMAC
  598.  * function.  And the P_Hash function from the TLS standard.
  599.  */
  600. static SECItem *
  601. sec_pkcs5_bit_generator(SEC_PKCS5PBEParameter *pbe_param,
  602. SECItem *init_hash, 
  603. unsigned int bits_needed)
  604. {
  605.     SECItem *ret_bits = NULL;
  606.     int hash_size = 0;
  607.     unsigned int i;
  608.     unsigned int hash_iter;
  609.     unsigned int dig_len;
  610.     SECStatus rv = SECFailure;
  611.     unsigned char *state = NULL;
  612.     unsigned int state_len;
  613.     HMACContext *cx = NULL;
  615.     hash_size = sec_pkcs5_hash_bits_generated(pbe_param);
  616.     if(hash_size == -1)
  617. return NULL;
  619.     hash_iter = (bits_needed + (unsigned int)hash_size - 1) / hash_size;
  620.     hash_size /= 8;
  622.     /* allocate return buffer */
  623.     ret_bits = (SECItem  *)PORT_ZAlloc(sizeof(SECItem));
  624.     if(ret_bits == NULL)
  625. return NULL;
  626.     ret_bits->data = (unsigned char *)PORT_ZAlloc((hash_iter * hash_size) + 1);
  627.     ret_bits->len = (hash_iter * hash_size);
  628.     if(ret_bits->data == NULL) {
  629. PORT_Free(ret_bits);
  630. return NULL;
  631.     }
  633.     /* allocate intermediate hash buffer.  8 is for the 8 bytes of
  634.      * data which are added based on iteration number 
  635.      */
  637.     if ((unsigned int)hash_size > pbe_param->salt.len) {
  638. state_len = hash_size;
  639.     } else {
  640. state_len = pbe_param->salt.len;
  641.     }
  642.     state = (unsigned char *)PORT_ZAlloc(state_len);
  643.     if(state == NULL) {
  644. rv = SECFailure;
  645. goto loser;
  646.     }
  647.     if(pbe_param->salt.len > 0) {
  648. PORT_Memcpy(state, pbe_param->salt.data, pbe_param->salt.len);
  649.     }
  651.     cx = HMAC_Create(sec_pkcs5_hash_algorithm(pbe_param->algorithm),
  652.      init_hash->data, init_hash->len);
  653.     if (cx == NULL) {
  654. rv = SECFailure;
  655. goto loser;
  656.     }
  658.     for(i = 0; i < hash_iter; i++) { 
  660. /* generate output bits */
  661. HMAC_Begin(cx);
  662. HMAC_Update(cx, state, state_len);
  663. HMAC_Update(cx, pbe_param->salt.data, pbe_param->salt.len);
  664. rv = HMAC_Finish(cx, ret_bits->data + (i * hash_size),
  665.  &dig_len, hash_size);
  666. if (rv != SECSuccess)
  667.     goto loser;
  668. PORT_Assert((unsigned int)hash_size == dig_len);
  670. /* generate new state */
  671. HMAC_Begin(cx);
  672. HMAC_Update(cx, state, state_len);
  673. rv = HMAC_Finish(cx, state, &state_len, state_len);
  674. if (rv != SECSuccess)
  675.     goto loser;
  676. PORT_Assert(state_len == dig_len);
  677.     }
  679. loser:
  680.     if (state != NULL)
  681. PORT_ZFree(state, state_len);
  682.     HMAC_Destroy(cx);
  684.     if(rv != SECSuccess) {
  685. SECITEM_ZfreeItem(ret_bits, PR_TRUE);
  686. ret_bits = NULL;
  687.     }
  689.     return ret_bits;
  690. }
  692. /* generate bits for the key and iv determination.  if enough bits
  693.  * are not generated using PKCS 5, then we need to generate more bits
  694.  * based on the extension proposed in PKCS 12
  695.  */
  696. static SECItem *
  697. sec_pkcs5_generate_bits(SEC_PKCS5PBEParameter *pbe_param, SECItem *pwitem, 
  698. PRBool faulty3DES)
  699. {
  700.     SECItem * hash  = NULL;
  701.     SECItem * newHash  = NULL;
  702.     int       bits_needed;
  703.     int       bits_available;
  704.     
  705.     bits_needed = sec_pkcs5_bits_needed(pbe_param);
  706.     bits_available = sec_pkcs5_hash_bits_generated(pbe_param);
  708.     if((bits_needed == -1) || (bits_available == -1)) {
  709. return NULL;
  710.     }
  712.     hash = sec_pkcs5_compute_hash(pbe_param, pwitem, faulty3DES);
  713.     if(hash == NULL) {
  714. return NULL;
  715.     }
  717.     if(bits_needed <= bits_available) {
  718. return hash;
  719.     } 
  721.     newHash = sec_pkcs5_bit_generator(pbe_param, hash, bits_needed);
  722.     if (hash != newHash)
  723. SECITEM_FreeItem(hash, PR_TRUE);
  724.     return newHash;
  725. }
  727. /* compute the IV as per PKCS 5
  728.  */
  729. static SECItem *
  730. sec_pkcs5_compute_iv(SEC_PKCS5PBEParameter *pbe_param, SECItem *pwitem,
  731.      PRBool faulty3DES)
  732. {
  733.     SECItem *hash = NULL, *iv = NULL;
  735.     if((pbe_param == NULL) || (pwitem == NULL)) {
  736. return NULL;
  737.     }
  739.     /* generate iv */
  740.     iv = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  741.     if(!iv) {
  742. return NULL;
  743.     }
  745.     iv->len = sec_pkcs5_iv_length(pbe_param->algorithm);
  746.     if(iv->len == -1) {
  747. PORT_Free(iv);
  748. return NULL;
  749.     }
  751.     iv->data = (unsigned char *)PORT_ZAlloc(iv->len);
  752.     if(iv->data == NULL) {
  753. PORT_Free(iv);
  754. return NULL;
  755.     }
  757.     if(sec_pkcs5_is_algorithm_v2_pkcs12_algorithm(pbe_param->algorithm)) {
  758. SECOidTag hashAlg;
  759. PBEBitGenContext *ctxt;
  760. hashAlg = sec_pkcs5_hash_algorithm(pbe_param->algorithm);
  761. ctxt = PBE_CreateContext(hashAlg, pbeBitGenCipherIV,
  762.  pwitem, &pbe_param->salt,
  763.  iv->len * 8, pbe_param->iter);
  764. if(!ctxt) {
  765.     SECITEM_FreeItem(iv, PR_TRUE);
  766.     return NULL;
  767. }
  769. hash = PBE_GenerateBits(ctxt);
  770. PBE_DestroyContext(ctxt);
  771.     } else {
  772. hash = sec_pkcs5_generate_bits(pbe_param, pwitem, faulty3DES);
  773.     }
  775.     if(!hash) {
  776. SECITEM_FreeItem(iv, PR_TRUE);
  777. return NULL;
  778.     }
  780.     PORT_Memcpy(iv->data, (hash->data+(hash->len - iv->len)), iv->len);
  781.     SECITEM_FreeItem(hash, PR_TRUE);
  783.     return iv;
  784. }
  786. /* generate key as per PKCS 5
  787.  */
  788. static SECItem *
  789. sec_pkcs5_compute_key(SEC_PKCS5PBEParameter *pbe_param, SECItem *pwitem,
  790.       PRBool faulty3DES)
  791. {
  792.     SECItem *hash = NULL, *key = NULL;
  794.     if((pbe_param == NULL) || (pwitem == NULL)) {
  795. return NULL;
  796.     }
  798.     key = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  799.     if(!key) {
  800. return NULL;
  801.     }
  803.     key->len = sec_pkcs5_key_length(pbe_param->algorithm);
  804.     if(key->len == -1) {
  805. PORT_Free(key);
  806. return NULL;
  807.     }
  809.     key->data = (unsigned char *)PORT_ZAlloc(sizeof(unsigned char) *
  810.      key->len);
  811.     if(!key->data) {
  812. PORT_Free(key);
  813. return NULL;
  814.     }
  817.     if(sec_pkcs5_is_algorithm_v2_pkcs12_algorithm(pbe_param->algorithm)) {
  818. SECOidTag hashAlg;
  819. PBEBitGenContext *ctxt;
  820. hashAlg = sec_pkcs5_hash_algorithm(pbe_param->algorithm);
  821. ctxt = PBE_CreateContext(hashAlg, pbeBitGenCipherKey,
  822.  pwitem, &pbe_param->salt,
  823.  key->len * 8, pbe_param->iter);
  824. if(!ctxt) {
  825.     SECITEM_FreeItem(key, PR_TRUE);
  826.     return NULL;
  827. }
  829. hash = PBE_GenerateBits(ctxt);
  830. PBE_DestroyContext(ctxt);
  831.     } else {
  832. hash = sec_pkcs5_generate_bits(pbe_param, pwitem, faulty3DES);
  833.     }
  834.    
  835.     if(!hash) {
  836. SECITEM_FreeItem(key, PR_TRUE);
  837. return NULL;
  838.     }
  840.     if(pbe_param->algorithm ==
  841.    SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_2KEY_TRIPLE_DES_CBC) {
  842. PORT_Memcpy(key->data, hash->data, (key->len * 2) / 3);
  843. PORT_Memcpy(&(key->data[(key->len  * 2) / 3]), key->data,
  844.     key->len / 3);
  845.     } else {
  846. PORT_Memcpy(key->data, hash->data, key->len);
  847.     }
  849.     SECITEM_FreeItem(hash, PR_TRUE);
  850.     return key;
  851. }
  853. /* decode the algid and generate a PKCS 5 parameter from it
  854.  */
  855. static SEC_PKCS5PBEParameter *
  856. sec_pkcs5_convert_algid(SECAlgorithmID *algid)
  857. {
  858.     PRArenaPool *poolp;
  859.     SEC_PKCS5PBEParameter *pbe_param = NULL;
  860.     SECOidTag algorithm;
  861.     SECStatus rv = SECFailure;
  863.     if(algid == NULL)
  864. return NULL;
  866.     algorithm = SECOID_GetAlgorithmTag(algid);
  867.    
  868.     if(sec_pkcs5_hash_algorithm(algorithm) == SEC_OID_UNKNOWN)
  869. return NULL;
  871.     poolp = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
  872.     if(poolp == NULL)
  873. return NULL;
  875.     /* allocate memory for the parameter */
  876.     pbe_param = (SEC_PKCS5PBEParameter *)PORT_ArenaZAlloc(poolp, 
  877. sizeof(SEC_PKCS5PBEParameter));
  879.     /* decode parameter */
  880.     if(pbe_param && !sec_pkcs5_is_algorithm_v2_pkcs12_algorithm(algorithm)) {
  881. pbe_param->poolp = poolp;
  882. rv = SEC_ASN1DecodeItem(poolp, pbe_param, 
  883.     SEC_PKCS5PBEParameterTemplate, &algid->parameters);
  884. if(rv != SECSuccess) {
  885.     goto loser;
  886. }
  887. pbe_param->algorithm = algorithm;
  888. pbe_param->iter = DER_GetInteger(&pbe_param->iteration);
  889.     } else if(sec_pkcs5_is_algorithm_v2_pkcs12_algorithm(algorithm)) {
  890. pbe_param->algorithm = algorithm;
  891. pbe_param->poolp = poolp;
  892. rv = SEC_ASN1DecodeItem(poolp, pbe_param, SEC_V2PKCS12PBEParameterTemplate,
  893. &algid->parameters);
  894. if(rv != SECSuccess) {
  895.     goto loser;
  896. }
  897. pbe_param->iter = DER_GetInteger(&pbe_param->iteration);
  898.     }
  900. loser:
  901.     if((pbe_param == NULL) || (rv != SECSuccess)) {
  902. PORT_FreeArena(poolp, PR_TRUE);
  903. pbe_param = NULL;
  904.     }
  906.     return pbe_param;
  907. }
  909. /* destroy a pbe parameter.  it assumes that the parameter was 
  910.  * generated using the appropriate create function and therefor
  911.  * contains an arena pool.
  912.  */
  913. static void 
  914. sec_pkcs5_destroy_pbe_param(SEC_PKCS5PBEParameter *pbe_param)
  915. {
  916.     if(pbe_param != NULL)
  917. PORT_FreeArena(pbe_param->poolp, PR_TRUE);
  918. }
  921. /* crypto routines */
  923. /* function pointer template for crypto functions */
  924. typedef SECItem *(* pkcs5_crypto_func)(SECItem *key, SECItem *iv, 
  925.  SECItem *src, PRBool op1, PRBool op2);
  927. /* map PBE algorithm to crypto algorithm */
  928. static SECOidTag 
  929. sec_pkcs5_encryption_algorithm(SECOidTag algorithm)
  930. {
  931.     switch(algorithm)
  932.     {
  933. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC:
  934. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_2KEY_TRIPLE_DES_CBC:
  935. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_TRIPLE_DES_CBC:
  936.     return SEC_OID_DES_EDE3_CBC;
  937. case SEC_OID_PKCS5_PBE_WITH_MD2_AND_DES_CBC:
  938. case SEC_OID_PKCS5_PBE_WITH_SHA1_AND_DES_CBC:
  939. case SEC_OID_PKCS5_PBE_WITH_MD5_AND_DES_CBC:
  940.     return SEC_OID_DES_CBC;
  941. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  942. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  943. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  944. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  945.     return SEC_OID_RC2_CBC;
  946. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC4:
  947. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC4:
  948. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC4:
  949. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC4:
  950.     return SEC_OID_RC4;
  951. default:
  952.     break;
  953.     }
  954.     return SEC_OID_UNKNOWN;
  955. }
  957. /* perform DES encryption and decryption.  these routines are called
  958.  * by SEC_PKCS5CipherData.  In the case of an error, NULL is returned.
  959.  */
  960. static SECItem *
  961. sec_pkcs5_des(SECItem *key, 
  962.       SECItem *iv, 
  963.       SECItem *src,
  964.       PRBool triple_des, 
  965.       PRBool encrypt)
  966. {
  967.     SECItem *dest;
  968.     SECItem *dup_src;
  969.     SECStatus rv = SECFailure;
  970.     int pad;
  972.     if((src == NULL) || (key == NULL) || (iv == NULL))
  973. return NULL;
  975.     dup_src = SECITEM_DupItem(src);
  976.     if(dup_src == NULL) {
  977. return NULL;
  978.     }
  980.     if(encrypt != PR_FALSE) {
  981. void *dummy;
  983. dummy = DES_PadBuffer(NULL, dup_src->data, 
  984.     dup_src->len, &dup_src->len);
  985. if(dummy == NULL) {
  986.     SECITEM_FreeItem(dup_src, PR_TRUE);
  987.     return NULL;
  988. }
  989. dup_src->data = (unsigned char*)dummy;
  990.     }
  992.     dest = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  993.     if(dest != NULL) {
  994. /* allocate with over flow */
  995. dest->data = (unsigned char *)PORT_ZAlloc(dup_src->len + 64);
  996. if(dest->data != NULL) {
  997.     DESContext *ctxt;
  998.     ctxt = DES_CreateContext(key->data, iv->data, 
  999. (triple_des ? NSS_DES_EDE3_CBC : NSS_DES_CBC), 
  1000. encrypt);
  1002.     if(ctxt != NULL) {
  1003. rv = ((encrypt != PR_TRUE) ? DES_Decrypt : DES_Encrypt)(
  1004. ctxt, dest->data, &dest->len,
  1005. dup_src->len + 64, dup_src->data, dup_src->len);
  1007. /* remove padding -- assumes 64 bit blocks */
  1008. if((encrypt == PR_FALSE) && (rv == SECSuccess)) {
  1009.     pad = dest->data[dest->len-1];
  1010.     if((pad > 0) && (pad <= 8)) {
  1011. if(dest->data[dest->len-pad] != pad) {
  1012.     rv = SECFailure;
  1013.     PORT_SetError(SEC_ERROR_BAD_PASSWORD);
  1014. } else {
  1015.     dest->len -= pad;
  1016. }
  1017.     } else {
  1018. rv = SECFailure;
  1019. PORT_SetError(SEC_ERROR_BAD_PASSWORD);
  1020.     }
  1021. }
  1022. DES_DestroyContext(ctxt, PR_TRUE);
  1023.     }
  1024. }
  1025.     }
  1027.     if(rv == SECFailure) {
  1028. if(dest != NULL) {
  1029.     SECITEM_FreeItem(dest, PR_TRUE);
  1030. }
  1031. dest = NULL;
  1032.     }
  1034.     if(dup_src != NULL) {
  1035. SECITEM_FreeItem(dup_src, PR_TRUE);
  1036.     }
  1038.     return dest;
  1039. }
  1041. /* perform rc2 encryption/decryption if an error occurs, NULL is returned
  1042.  */
  1043. static SECItem *
  1044. sec_pkcs5_rc2(SECItem *key, 
  1045.       SECItem *iv, 
  1046.       SECItem *src,
  1047.       PRBool cbc_mode, 
  1048.       PRBool encrypt)
  1049. {
  1050.     SECItem *dest;
  1051.     SECItem *dup_src;
  1052.     SECStatus rv = SECFailure;
  1053.     int pad;
  1055.     if((src == NULL) || (key == NULL) || (iv == NULL)) {
  1056. return NULL;
  1057.     }
  1059.     dup_src = SECITEM_DupItem(src);
  1060.     if(dup_src == NULL) {
  1061. return NULL;
  1062.     }
  1064.     if(encrypt != PR_FALSE) {
  1065. void *dummy;
  1067. dummy = DES_PadBuffer(NULL, dup_src->data, 
  1068.       dup_src->len, &dup_src->len);
  1069. if(dummy == NULL) {
  1070.     SECITEM_FreeItem(dup_src, PR_TRUE);
  1071.     return NULL;
  1072. }
  1073. dup_src->data = (unsigned char*)dummy;
  1074.     }
  1076.     dest = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  1077.     if(dest != NULL) {
  1078. dest->data = (unsigned char *)PORT_ZAlloc(dup_src->len + 64);
  1079. if(dest->data != NULL) {
  1080.     RC2Context *ctxt;
  1082.     ctxt = RC2_CreateContext(key->data, key->len, iv->data, 
  1083. ((cbc_mode != PR_TRUE) ? NSS_RC2 : NSS_RC2_CBC), 
  1084. key->len);
  1086.     if(ctxt != NULL) {
  1087. rv = ((encrypt != PR_TRUE) ? RC2_Decrypt : RC2_Encrypt)(
  1088. ctxt, dest->data, &dest->len,
  1089. dup_src->len + 64, dup_src->data, dup_src->len);
  1091. /* assumes 8 byte blocks  -- remove padding */
  1092. if((rv == SECSuccess) && (encrypt != PR_TRUE) && 
  1093. (cbc_mode == PR_TRUE)) {
  1094.     pad = dest->data[dest->len-1];
  1095.     if((pad > 0) && (pad <= 8)) {
  1096. if(dest->data[dest->len-pad] != pad) {
  1097.     PORT_SetError(SEC_ERROR_BAD_PASSWORD);
  1098.     rv = SECFailure;
  1099. } else {
  1100.     dest->len -= pad;
  1101. }
  1102.     } else {
  1103. PORT_SetError(SEC_ERROR_BAD_PASSWORD);
  1104. rv = SECFailure;
  1105.     }
  1106. }
  1108.     }
  1109. }
  1110.     }
  1112.     if((rv != SECSuccess) && (dest != NULL)) {
  1113. SECITEM_FreeItem(dest, PR_TRUE);
  1114. dest = NULL;
  1115.     }
  1117.     if(dup_src != NULL) {
  1118. SECITEM_FreeItem(dup_src, PR_TRUE);
  1119.     }
  1121.     return dest;
  1122. }
  1124. /* perform rc4 encryption and decryption */
  1125. static SECItem *
  1126. sec_pkcs5_rc4(SECItem *key, 
  1127.       SECItem *iv, 
  1128.       SECItem *src, 
  1129.       PRBool dummy_op,
  1130.       PRBool encrypt)
  1131. {
  1132.     SECItem *dest;
  1133.     SECStatus rv = SECFailure;
  1135.     if((src == NULL) || (key == NULL) || (iv == NULL)) {
  1136. return NULL;
  1137.     }
  1139.     dest = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  1140.     if(dest != NULL) {
  1141. dest->data = (unsigned char *)PORT_ZAlloc(sizeof(unsigned char) *
  1142.     (src->len + 64));
  1143. if(dest->data != NULL) {
  1144.     RC4Context *ctxt;
  1146.     ctxt = RC4_CreateContext(key->data, key->len);
  1147.     if(ctxt) { 
  1148. rv = ((encrypt != PR_FALSE) ? RC4_Decrypt : RC4_Encrypt)(
  1149. ctxt, dest->data, &dest->len,
  1150. src->len + 64, src->data, src->len);
  1151. RC4_DestroyContext(ctxt, PR_TRUE);
  1152.     }
  1153. }
  1154.     }
  1156.     if((rv != SECSuccess) && (dest)) {
  1157. SECITEM_FreeItem(dest, PR_TRUE);
  1158. dest = NULL;
  1159.     }
  1161.     return dest;
  1162. }
  1164. /* performs the cipher operation on the src and returns the result.
  1165.  * if an error occurs, NULL is returned. 
  1166.  *
  1167.  * a null length password is allowed.  this corresponds to encrypting
  1168.  * the data with ust the salt.
  1169.  */
  1170. /* change this to use PKCS 11? */
  1171. SECItem *
  1172. SEC_PKCS5CipherData(SECAlgorithmID *algid, 
  1173.     SECItem *pwitem,
  1174.     SECItem *src, 
  1175.     PRBool encrypt, PRBool *update)
  1176. {
  1177.     SEC_PKCS5PBEParameter *pbe_param;
  1178.     SECOidTag enc_alg;
  1179.     SECItem *key = NULL, *iv = NULL;
  1180.     SECItem *dest = NULL;
  1181.     int iv_len;
  1183.     if (update) { 
  1184.         *update = PR_FALSE;
  1185.     }
  1187.     if((algid == NULL) || (pwitem == NULL) || (src == NULL)) {
  1188. return NULL;
  1189.     }
  1191.     /* convert algid to pbe parameter */
  1192.     pbe_param = sec_pkcs5_convert_algid(algid);
  1193.     if(pbe_param == NULL) {
  1194. return NULL;
  1195.     }
  1197.     /* get algorithm, key, and iv */
  1198.     enc_alg = sec_pkcs5_encryption_algorithm(pbe_param->algorithm);
  1199.     key = sec_pkcs5_compute_key(pbe_param, pwitem, PR_FALSE);
  1200.     if(key != NULL) {
  1201. iv_len = sec_pkcs5_iv_length(pbe_param->algorithm);
  1202.      iv = sec_pkcs5_compute_iv(pbe_param, pwitem, PR_FALSE);
  1204. if((iv != NULL) || (iv_len == 0)) {
  1205.     /*perform encryption / decryption */
  1206.     PRBool op1 = PR_TRUE;
  1207.     pkcs5_crypto_func cryptof;
  1209.     switch(enc_alg) {
  1210. case SEC_OID_DES_EDE3_CBC:
  1211.     cryptof = sec_pkcs5_des;
  1212.     break;
  1213. case SEC_OID_DES_CBC:
  1214.     cryptof = sec_pkcs5_des;
  1215.     op1 = PR_FALSE;
  1216.     break;
  1217. case SEC_OID_RC2_CBC:
  1218.     cryptof = sec_pkcs5_rc2;
  1219.     break;
  1220. case SEC_OID_RC4:
  1221.     cryptof = sec_pkcs5_rc4;
  1222.     break;
  1223. default:
  1224.     cryptof = NULL;
  1225.     break;
  1226.     }
  1228.     if(cryptof) {
  1229. dest = (*cryptof)(key, iv, src, op1, encrypt);
  1230. /* 
  1231.  * it's possible for some keys and keydb's to claim to
  1232.  * be triple des when they're really des. In this case
  1233.  * we simply try des. If des works we set the update flag
  1234.  * so the key db knows it needs to update all it's entries.
  1235.  *  The case can only happen on decrypted of a 
  1236.  *  SEC_OID_DES_EDE3_CBD.
  1237.  */
  1238. if ((dest == NULL) && (encrypt == PR_FALSE) && 
  1239. (enc_alg == SEC_OID_DES_EDE3_CBC)) {
  1240.     dest = (*cryptof)(key, iv, src, PR_FALSE, encrypt);
  1241.     if (update && (dest != NULL)) *update = PR_TRUE;
  1242. }
  1243.     }
  1244. }
  1245.     }
  1247.     sec_pkcs5_destroy_pbe_param(pbe_param);
  1249.     if(key != NULL) {
  1250. SECITEM_ZfreeItem(key, PR_TRUE);
  1251.     }
  1252.     if(iv != NULL) {
  1253. SECITEM_ZfreeItem(iv, PR_TRUE);
  1254.     }
  1256.     return dest;
  1257. }
  1259. /* creates a algorithm ID containing the PBE algorithm and appropriate
  1260.  * parameters.  the required parameter is the algorithm.  if salt is
  1261.  * not specified, it is generated randomly.  if IV is specified, it overrides
  1262.  * the PKCS 5 generation of the IV.  
  1263.  *
  1264.  * the returned SECAlgorithmID should be destroyed using 
  1265.  * SECOID_DestroyAlgorithmID
  1266.  */
  1267. SECAlgorithmID *
  1268. SEC_PKCS5CreateAlgorithmID(SECOidTag algorithm, 
  1269.    SECItem *salt, 
  1270.    int iteration)
  1271. {
  1272.     PRArenaPool *poolp = NULL;
  1273.     SECAlgorithmID *algid, *ret_algid;
  1274.     SECItem der_param;
  1275.     SECStatus rv = SECFailure;
  1276.     SEC_PKCS5PBEParameter *pbe_param;
  1278.     if(sec_pkcs5_hash_algorithm(algorithm) == SEC_OID_UNKNOWN)
  1279. return NULL;
  1281.     if(iteration <= 0) {
  1282. return NULL;
  1283.     }
  1285.     der_param.data = NULL;
  1286.     der_param.len = 0;
  1288.     /* generate the parameter */
  1289.     pbe_param = sec_pkcs5_create_pbe_parameter(algorithm, salt, iteration);
  1290.     if(!pbe_param) {
  1291. return NULL;
  1292.     }
  1294.     poolp = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
  1295.     if(!poolp) {
  1296. sec_pkcs5_destroy_pbe_param(pbe_param);
  1297. return NULL;
  1298.     }
  1300.     /* generate the algorithm id */
  1301.     algid = (SECAlgorithmID *)PORT_ArenaZAlloc(poolp, sizeof(SECAlgorithmID));
  1302.     if(algid != NULL) {
  1303. void *dummy;
  1304. if(!sec_pkcs5_is_algorithm_v2_pkcs12_algorithm(algorithm)) {
  1305.     dummy = SEC_ASN1EncodeItem(poolp, &der_param, pbe_param,
  1306. SEC_PKCS5PBEParameterTemplate);
  1307. } else {
  1308.     dummy = SEC_ASN1EncodeItem(poolp, &der_param, pbe_param,
  1309.      SEC_V2PKCS12PBEParameterTemplate);
  1310. }
  1312. if(dummy) {
  1313.     rv = SECOID_SetAlgorithmID(poolp, algid, algorithm, &der_param);
  1314. }
  1315.     }
  1317.     ret_algid = NULL;
  1318.     if(algid != NULL) {
  1319. ret_algid = (SECAlgorithmID *)PORT_ZAlloc(sizeof(SECAlgorithmID));
  1320. if(ret_algid != NULL) {
  1321.     rv = SECOID_CopyAlgorithmID(NULL, ret_algid, algid);
  1322.     if(rv != SECSuccess) {
  1323. SECOID_DestroyAlgorithmID(ret_algid, PR_TRUE);
  1324. ret_algid = NULL;
  1325.     }
  1326. }
  1327.     }
  1329.     if(poolp != NULL) {
  1330. PORT_FreeArena(poolp, PR_TRUE);
  1331. algid = NULL;
  1332.     }
  1334.     sec_pkcs5_destroy_pbe_param(pbe_param);
  1336.     return ret_algid;
  1337. }
  1339. /* wrapper for converting the algid to a pbe parameter. 
  1340.  */
  1341. SEC_PKCS5PBEParameter *
  1342. SEC_PKCS5GetPBEParameter(SECAlgorithmID *algid)
  1343. {
  1344.     if(algid) {
  1345. return sec_pkcs5_convert_algid(algid);
  1346.     }
  1348.     return NULL;
  1349. }
  1351. /* destroy a pbe parameter */
  1352. void
  1353. SEC_PKCS5DestroyPBEParameter(SEC_PKCS5PBEParameter *pbe_param)
  1354. {
  1355.     sec_pkcs5_destroy_pbe_param(pbe_param);
  1356. }
  1358. /* return the initialization vector either the preset one if it 
  1359.  * exists or generated based on pkcs 5.
  1360.  *
  1361.  * a null length password is allowed...but not a null password
  1362.  * secitem.
  1363.  */
  1364. SECItem *
  1365. SEC_PKCS5GetIV(SECAlgorithmID *algid, SECItem *pwitem, PRBool faulty3DES)
  1366. {
  1367.     SECItem *iv;
  1368.     SEC_PKCS5PBEParameter *pbe_param;
  1370.     if((algid == NULL) || (pwitem == NULL)) {
  1371. return NULL;
  1372.     }
  1374.     pbe_param = sec_pkcs5_convert_algid(algid);
  1375.     if(!pbe_param) {
  1376. return NULL;
  1377.     }
  1379.     iv = sec_pkcs5_compute_iv(pbe_param, pwitem, faulty3DES);
  1381.     sec_pkcs5_destroy_pbe_param(pbe_param);
  1383.     return iv;
  1384. }
  1386. /* generate the key 
  1387.  * a 0 length password is allowed.  corresponds to a key generated
  1388.  * from just the salt.
  1389.  */
  1390. SECItem *
  1391. SEC_PKCS5GetKey(SECAlgorithmID *algid, SECItem *pwitem, PRBool faulty3DES)
  1392. {
  1393.     SECItem *key;
  1394.     SEC_PKCS5PBEParameter *pbe_param;
  1396.     if((algid == NULL) || (pwitem == NULL)) {
  1397. return NULL;
  1398.     }
  1400.     pbe_param = sec_pkcs5_convert_algid(algid);
  1401.     if(pbe_param == NULL) {
  1402. return NULL;
  1403.     }
  1405.     key = sec_pkcs5_compute_key(pbe_param, pwitem, faulty3DES);
  1407.     sec_pkcs5_destroy_pbe_param(pbe_param);
  1409.     return key;
  1410. }
  1412. /* retrieve the salt */
  1413. SECItem *
  1414. SEC_PKCS5GetSalt(SECAlgorithmID *algid)
  1415. {
  1416.     SECItem *salt;
  1417.     SEC_PKCS5PBEParameter *pbe_param;
  1419.     if(algid == NULL)
  1420. return NULL;
  1422.     pbe_param = sec_pkcs5_convert_algid(algid);
  1423.     if(pbe_param == NULL)
  1424. return NULL;
  1426.     if(pbe_param->salt.data) {
  1427. salt = SECITEM_DupItem(&pbe_param->salt);
  1428.     } else {
  1429. salt = NULL;
  1430.     }
  1432.     sec_pkcs5_destroy_pbe_param(pbe_param);
  1434.     return salt;
  1435. }
  1437. /* check to see if an oid is a pbe algorithm
  1438.  */ 
  1439. PRBool 
  1440. SEC_PKCS5IsAlgorithmPBEAlg(SECAlgorithmID *algid)
  1441. {
  1442.     SECOidTag algorithm;
  1444.     algorithm = SECOID_GetAlgorithmTag(algid);
  1445.     if(sec_pkcs5_hash_algorithm(algorithm) == SEC_OID_UNKNOWN) {
  1446. return PR_FALSE;
  1447.     }
  1449.     return PR_TRUE;
  1450. }
  1452. int 
  1453. SEC_PKCS5GetKeyLength(SECAlgorithmID *algid)
  1454. {
  1455.     SEC_PKCS5PBEParameter *pbe_param;
  1456.     int keyLen = -1;
  1458.     if(algid == NULL)
  1459. return -1;
  1461.     pbe_param = sec_pkcs5_convert_algid(algid);
  1462.     if(pbe_param == NULL)
  1463. return -1;
  1465.     keyLen = sec_pkcs5_key_length(pbe_param->algorithm);
  1467.     sec_pkcs5_destroy_pbe_param(pbe_param);
  1469.     return keyLen;
  1470. }
  1472. /* maps crypto algorithm from PBE algorithm.
  1473.  */
  1474. SECOidTag 
  1475. SEC_PKCS5GetCryptoAlgorithm(SECAlgorithmID *algid)
  1476. {
  1477.     SEC_PKCS5PBEParameter *pbe_param;
  1479.     if(algid == NULL)
  1480. return SEC_OID_UNKNOWN;
  1482.     pbe_param = sec_pkcs5_convert_algid(algid);
  1483.     if(pbe_param == NULL)
  1484. return SEC_OID_UNKNOWN;
  1486.     switch(pbe_param->algorithm)
  1487.     {
  1488. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC:
  1489. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_2KEY_TRIPLE_DES_CBC:
  1490. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_TRIPLE_DES_CBC:
  1491.     return SEC_OID_DES_EDE3_CBC;
  1492. case SEC_OID_PKCS5_PBE_WITH_SHA1_AND_DES_CBC:
  1493. case SEC_OID_PKCS5_PBE_WITH_MD5_AND_DES_CBC:
  1494. case SEC_OID_PKCS5_PBE_WITH_MD2_AND_DES_CBC:
  1495.     return SEC_OID_DES_CBC;
  1496. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  1497. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  1498. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC:
  1499. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC:
  1500.     return SEC_OID_RC2_CBC;
  1501. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC4:
  1502. case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC4:
  1503. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC4:
  1504. case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC4:
  1505.     return SEC_OID_RC4;
  1506. default:
  1507.     break;
  1508.     }
  1510.     sec_pkcs5_destroy_pbe_param(pbe_param);
  1512.     return SEC_OID_UNKNOWN;
  1513. }
  1515. /* maps PBE algorithm from crypto algorithm, assumes SHA1 hashing.
  1516.  */
  1517. SECOidTag 
  1518. SEC_PKCS5GetPBEAlgorithm(SECOidTag algTag, int keyLen)
  1519. {
  1520.     switch(algTag)
  1521.     {
  1522. case SEC_OID_DES_EDE3_CBC:
  1523.     switch(keyLen) {
  1524. case 168:
  1525. case 192:
  1526.     return SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC;
  1527. case 128:
  1528. case 92:
  1529.     return SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_2KEY_TRIPLE_DES_CBC;
  1530. default:
  1531.     break;
  1532.     }
  1533.     break;
  1534. case SEC_OID_DES_CBC:
  1535.     return SEC_OID_PKCS5_PBE_WITH_SHA1_AND_DES_CBC;
  1536. case SEC_OID_RC2_CBC:
  1537.     switch(keyLen) {
  1538. case 40:
  1539.     return SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC;
  1540. case 128:
  1541.     return SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC;
  1542. default:
  1543.     break;
  1544.     }
  1545.     break;
  1546. case SEC_OID_RC4:
  1547.     switch(keyLen) {
  1548. case 40:
  1549.     return SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC4;
  1550. case 128:
  1551.     return SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC4;
  1552. default:
  1553.     break;
  1554.     }
  1555.     break;
  1556. default:
  1557.     break;
  1558.     }
  1560.     return SEC_OID_UNKNOWN;
  1561. }
  1563. /* zero length password and salts are allowed.  however, the items
  1564.  * containing the salt and password must be non-null.
  1565.  */
  1566. PBEBitGenContext *
  1567. PBE_CreateContext(SECOidTag hashAlgorithm, PBEBitGenID bitGenPurpose,
  1568.   SECItem *pwitem, SECItem *salt, unsigned int bitsNeeded,
  1569.   unsigned int iterations)
  1570. {
  1571.     PRArenaPool *arena = NULL;
  1572.     PBEBitGenContext *pbeCtxt = NULL;
  1573.     HASH_HashType pbeHash;
  1574.     int vbytes, ubytes;
  1575.     
  1576.     unsigned int c;
  1578.     if(!pwitem || !salt) {
  1579. return NULL;
  1580.     }
  1582.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1583.     if(!arena) {
  1584. return NULL;
  1585.     }
  1587.     pbeCtxt = (PBEBitGenContext*)PORT_ArenaZAlloc(arena, sizeof(PBEBitGenContext));
  1588.     if(!pbeCtxt) {
  1589. goto loser;
  1590.     }
  1592.     switch(hashAlgorithm) {
  1593. case SEC_OID_MD2:
  1594.     pbeHash = HASH_AlgMD2;
  1595.     break;
  1596. case SEC_OID_MD5:
  1597.     pbeHash = HASH_AlgMD5;
  1598.     break;
  1599. case SEC_OID_SHA1:
  1600.     pbeHash = HASH_AlgSHA1;
  1601.     break;
  1602. default:
  1603.     goto loser;
  1604.     }
  1606.     pbeCtxt->hashObject = &SECRawHashObjects[pbeHash]; 
  1607.     PORT_Memcpy(&pbeCtxt->pbeParams, &pbeHashAlgorithmParams[pbeHash], 
  1608.      sizeof(pbeBitGenParameters));
  1609.     PORT_Assert(pbeCtxt->pbeParams.hashAlgorithm == hashAlgorithm);
  1611.     vbytes = pbeCtxt->pbeParams.v / 8;
  1612.     ubytes = pbeCtxt->pbeParams.u / 8;
  1614.     c = (bitsNeeded / pbeCtxt->pbeParams.u);
  1615.     c += ((bitsNeeded - (pbeCtxt->pbeParams.u * c)) > 0) ? 1 : 0;
  1616.     pbeCtxt->c = c;
  1617.     pbeCtxt->n = bitsNeeded;
  1618.     pbeCtxt->iterations = iterations;
  1620.     /* allocate buffers */
  1621.     pbeCtxt->D.len = vbytes;
  1622.     pbeCtxt->S.len = (((salt->len * 8) / pbeCtxt->pbeParams.v) + 
  1623.            ((((salt->len * 8) % pbeCtxt->pbeParams.v) > 0) ? 1 : 0)) *
  1624.            vbytes;
  1625.     pbeCtxt->P.len = (((pwitem->len * 8) / pbeCtxt->pbeParams.v) + 
  1626.            ((((pwitem->len * 8) % pbeCtxt->pbeParams.v) > 0) ? 1 : 0)) *
  1627.       vbytes;
  1628.     pbeCtxt->I.len = pbeCtxt->S.len + pbeCtxt->P.len;
  1629.     pbeCtxt->A.len = c * ubytes;
  1630.     pbeCtxt->B.len = pbeCtxt->D.len;
  1632.     pbeCtxt->D.data = (unsigned char*)PORT_ArenaZAlloc(arena, pbeCtxt->D.len);
  1633.     if(pbeCtxt->S.len) {
  1634. pbeCtxt->S.data = (unsigned char*)PORT_ArenaZAlloc(arena, pbeCtxt->S.len);
  1635.     }
  1636.     if(pbeCtxt->P.len) {
  1637. pbeCtxt->P.data = (unsigned char*)PORT_ArenaZAlloc(arena, pbeCtxt->P.len);
  1638.     }
  1639.     if(pbeCtxt->I.len) {
  1640. pbeCtxt->I.data = (unsigned char*)PORT_ArenaZAlloc(arena, pbeCtxt->I.len);
  1641.     }
  1642.     pbeCtxt->A.data = (unsigned char*)PORT_ArenaZAlloc(arena, pbeCtxt->A.len);
  1643.     pbeCtxt->B.data = (unsigned char*)PORT_ArenaZAlloc(arena, pbeCtxt->B.len);
  1645.     if(!pbeCtxt->D.data || !pbeCtxt->A.data || !pbeCtxt->B.data ||
  1646.        (!pbeCtxt->S.data && pbeCtxt->S.len) || 
  1647.        (!pbeCtxt->P.data && pbeCtxt->P.len) ||
  1648.        (!pbeCtxt->I.data && pbeCtxt->I.len)) {
  1649. goto loser;
  1650.     }
  1652.     PORT_Memset(pbeCtxt->D.data, (char)bitGenPurpose, pbeCtxt->D.len);
  1653.     if(pbeCtxt->P.len) {
  1654. unsigned int z = 0;
  1655. while(z < pbeCtxt->P.len) {
  1656.     PORT_Memcpy(&(pbeCtxt->P.data[z]), pwitem->data,  
  1657.      ((z + pwitem->len > pbeCtxt->P.len) ? (pbeCtxt->P.len - z) :
  1658.            (pwitem->len)));
  1659.     z += pwitem->len;
  1660. }
  1661.     } 
  1662.     if(pbeCtxt->S.len) {
  1663. unsigned int z = 0;
  1664. while(z < pbeCtxt->S.len) {
  1665.     PORT_Memcpy(&(pbeCtxt->S.data[z]), salt->data,  
  1666.      ((z + salt->len > pbeCtxt->S.len) ? (pbeCtxt->S.len - z) :
  1667.          (salt->len)));
  1668.     z += salt->len;
  1669. }
  1670.     } 
  1671.     if(pbeCtxt->I.len) {
  1672. if(pbeCtxt->S.len) {
  1673.     PORT_Memcpy(pbeCtxt->I.data, pbeCtxt->S.data, pbeCtxt->S.len);
  1674. }
  1675. if(pbeCtxt->P.len) {
  1676.     PORT_Memcpy(&(pbeCtxt->I.data[pbeCtxt->S.len]), pbeCtxt->P.data, 
  1677.      pbeCtxt->P.len);
  1678. }
  1679.     }
  1681.     pbeCtxt->arena = arena;
  1683.     return pbeCtxt;
  1685. loser:
  1686.     if(arena) {
  1687. PORT_FreeArena(arena, PR_TRUE);
  1688.     }
  1690.     return NULL;
  1691. }
  1693. SECItem *
  1694. PBE_GenerateBits(PBEBitGenContext *pbeCtxt)
  1695. {
  1696.     unsigned int i;
  1697.     SECItem *A, *D, *I, *B, *S, *P;
  1698.     unsigned int u, v, c, z, hashLen, n, iter;
  1699.     unsigned int vbyte, ubyte;
  1700.     unsigned char *iterBuf;
  1701.     void *hash = NULL;
  1703.     if(!pbeCtxt) {
  1704. return NULL;
  1705.     }
  1707.     A = &pbeCtxt->A;
  1708.     B = &pbeCtxt->B;
  1709.     I = &pbeCtxt->I;
  1710.     D = &pbeCtxt->D;
  1711.     S = &pbeCtxt->S;
  1712.     P = &pbeCtxt->P;
  1713.     u = pbeCtxt->pbeParams.u;
  1714.     v = pbeCtxt->pbeParams.v;
  1715.     vbyte = v / 8;
  1716.     ubyte = u / 8;
  1717.     c = pbeCtxt->c;
  1718.     n = pbeCtxt->n;
  1719.     z = 0;
  1721.     iterBuf = (unsigned char*)PORT_Alloc(ubyte);
  1722.     if(!iterBuf) {
  1723. goto loser;
  1724.     }
  1726.     for(i = 1; i <= c; i++) {
  1727. unsigned int Bidx;
  1728. unsigned int k, j;
  1731. for(iter = 1; iter <= pbeCtxt->iterations; iter++) {
  1732.     hash = pbeCtxt->hashObject->create();
  1733.     if(!hash) {
  1734. goto loser;
  1735.     }
  1737.     pbeCtxt->hashObject->begin(hash);
  1739.     if(iter == 1) {
  1740. pbeCtxt->hashObject->update(hash, D->data, D->len);
  1741. pbeCtxt->hashObject->update(hash, I->data, I->len); 
  1742.     } else {
  1743. pbeCtxt->hashObject->update(hash, iterBuf, hashLen);
  1744.     }
  1746.     pbeCtxt->hashObject->end(hash, iterBuf, &hashLen, (ubyte));
  1747.     pbeCtxt->hashObject->destroy(hash, PR_TRUE);
  1748.     if(hashLen != (ubyte)) {
  1749. goto loser;
  1750.     }
  1751. }
  1753. PORT_Memcpy(&(A->data[z]), iterBuf, (ubyte));
  1755. Bidx = 0;
  1756. while(Bidx < B->len) {
  1757.     PORT_Memcpy(&(B->data[Bidx]), &(A->data[z]), 
  1758. (((Bidx + (ubyte)) > B->len) ? (B->len - Bidx) : 
  1759.        (ubyte)));
  1760.     Bidx += (ubyte);
  1761. }
  1763. k = (S->len / (vbyte)) + (P->len / (vbyte));
  1764. for(j = 0; j < k; j++) {
  1765.     unsigned int byteIdx = (vbyte);
  1766.     unsigned int q, carryBit = 0;
  1768.     while(byteIdx > 0) {
  1769. q = (unsigned int)I->data[(j * (vbyte)) + byteIdx - 1];
  1770. q += (unsigned int)B->data[byteIdx - 1];
  1771. q += carryBit;
  1772. if(byteIdx == (vbyte)) {
  1773.     q += 1;
  1774. }
  1776. carryBit = ((q > 255) ? 1 : 0);
  1778. I->data[(j * (vbyte)) + byteIdx - 1] = (unsigned char)(q & 255);
  1780. byteIdx--;
  1781.     }
  1782. }
  1784. z += (ubyte);
  1785.     }
  1787.     A->len = (n / 8);
  1788.     
  1789.     return SECITEM_DupItem(A);
  1791. loser:
  1792.     return NULL;
  1793. } 
  1795. void
  1796. PBE_DestroyContext(PBEBitGenContext *pbeCtxt) {
  1797.     if(pbeCtxt) {
  1798. PORT_FreeArena(pbeCtxt->arena, PR_TRUE);
  1799.     }
  1800. }
  1802. SECStatus
  1803. PBE_PK11ParamToAlgid(SECOidTag algTag, SECItem *param, PRArenaPool *arena, 
  1804.      SECAlgorithmID *algId)
  1805. {
  1806.     CK_PBE_PARAMS *pbe_param;
  1807.     SECItem pbeSalt;
  1808.     SECAlgorithmID *pbeAlgID = NULL;
  1809.     SECStatus rv;
  1811.     if(!param || !algId) {
  1812. return SECFailure;
  1813.     }
  1815.     pbe_param = (CK_PBE_PARAMS *)param->data;
  1816.     pbeSalt.data = (unsigned char *)pbe_param->pSalt;
  1817.     pbeSalt.len = pbe_param->ulSaltLen;
  1818.     pbeAlgID = SEC_PKCS5CreateAlgorithmID(algTag, &pbeSalt, 
  1819.   (int)pbe_param->ulIteration);
  1820.     if(!pbeAlgID) {
  1821. return SECFailure;
  1822.     }
  1824.     rv = SECOID_CopyAlgorithmID(arena, algId, pbeAlgID);
  1825.     SECOID_DestroyAlgorithmID(pbeAlgID, PR_TRUE);
  1826.     return rv;
  1827. }