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

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

CA认证

开发平台：

WINDOWS

crmfcont.c：源码内容
  1. /* -*- Mode: C; tab-width: 8 -*-*/
  2. /*
  3.  * The contents of this file are subject to the Mozilla Public
  4.  * License Version 1.1 (the "License"); you may not use this file
  5.  * except in compliance with the License. You may obtain a copy of
  6.  * the License at http://www.mozilla.org/MPL/
  7.  * 
  8.  * Software distributed under the License is distributed on an "AS
  9.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  10.  * implied. See the License for the specific language governing
  11.  * rights and limitations under the License.
  12.  * 
  13.  * The Original Code is the Netscape security libraries.
  14.  * 
  15.  * The Initial Developer of the Original Code is Netscape
  16.  * Communications Corporation.  Portions created by Netscape are 
  17.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  18.  * Rights Reserved.
  19.  * 
  20.  * Contributor(s):
  21.  * 
  22.  * Alternatively, the contents of this file may be used under the
  23.  * terms of the GNU General Public License Version 2 or later (the
  24.  * "GPL"), in which case the provisions of the GPL are applicable 
  25.  * instead of those above.  If you wish to allow use of your 
  26.  * version of this file only under the terms of the GPL and not to
  27.  * allow others to use your version of this file under the MPL,
  28.  * indicate your decision by deleting the provisions above and
  29.  * replace them with the notice and other provisions required by
  30.  * the GPL.  If you do not delete the provisions above, a recipient
  31.  * may use your version of this file under either the MPL or the
  32.  * GPL.
  33.  */
  35. #include "crmf.h"
  36. #include "crmfi.h"
  37. #include "pk11func.h"
  38. #include "keyhi.h"
  39. #include "secoid.h"
  41. static SECStatus
  42. crmf_modify_control_array (CRMFCertRequest *inCertReq, int count)
  43. {
  44.     if (count > 0) {
  45.         void *dummy = PORT_Realloc(inCertReq->controls, 
  46.    sizeof(CRMFControl*)*(count+2));
  47. if (dummy == NULL) {
  48.     return SECFailure;
  49. }
  50. inCertReq->controls = dummy;
  51.     } else {
  52.         inCertReq->controls = PORT_ZNewArray(CRMFControl*, 2);
  53.     }
  54.     return (inCertReq->controls == NULL) ? SECFailure : SECSuccess ;
  55. }
  57. static SECStatus
  58. crmf_add_new_control(CRMFCertRequest *inCertReq,SECOidTag inTag,
  59.      CRMFControl **destControl)
  60. {
  61.     SECOidData  *oidData;
  62.     SECStatus    rv;
  63.     PRArenaPool *poolp;
  64.     int          numControls = 0;
  65.     CRMFControl *newControl;
  66.     CRMFControl **controls;
  67.     void        *mark;
  69.     poolp = inCertReq->poolp;
  70.     if (poolp == NULL) {
  71.         return SECFailure;
  72.     }
  73.     mark = PORT_ArenaMark(poolp);
  74.     if (inCertReq->controls != NULL) {
  75.         while (inCertReq->controls[numControls] != NULL)
  76.     numControls++;
  77.     }
  78.     rv = crmf_modify_control_array(inCertReq, numControls);
  79.     if (rv != SECSuccess) {
  80.         goto loser;
  81.     }
  82.     controls = inCertReq->controls;
  83.     oidData = SECOID_FindOIDByTag(inTag);
  84.     newControl = *destControl = PORT_ArenaZNew(poolp,CRMFControl);
  85.     if (newControl == NULL) {
  86.         goto loser;
  87.     }
  88.     rv = SECITEM_CopyItem(poolp, &newControl->derTag, &oidData->oid);
  89.     if (rv != SECSuccess) {
  90.         goto loser;
  91.     }
  92.     newControl->tag = inTag;
  93.     controls[numControls] = newControl;
  94.     controls[numControls+1] = NULL;
  95.     PORT_ArenaUnmark(poolp, mark);
  96.     return SECSuccess;
  98.  loser:
  99.     PORT_ArenaRelease(poolp, mark);
  100.     *destControl = NULL;
  101.     return SECFailure;
  102.   
  103. }
  105. SECStatus
  106. crmf_add_secitem_control(CRMFCertRequest *inCertReq, SECItem *value,
  107.  SECOidTag inTag)
  108. {
  109.     SECStatus    rv;
  110.     CRMFControl *newControl;
  111.     void        *mark;
  113.     rv = crmf_add_new_control(inCertReq, inTag, &newControl);
  114.     if (rv != SECSuccess) {
  115.         return rv;
  116.     }
  117.     mark = PORT_ArenaMark(inCertReq->poolp);
  118.     rv = SECITEM_CopyItem(inCertReq->poolp, &newControl->derValue, value);
  119.     if (rv != SECSuccess) {
  120.         PORT_ArenaRelease(inCertReq->poolp, mark);
  121. return rv;
  122.     }
  123.     PORT_ArenaUnmark(inCertReq->poolp, mark);
  124.     return SECSuccess;
  125. }
  127. SECStatus
  128. CRMF_CertRequestSetRegTokenControl(CRMFCertRequest *inCertReq, SECItem *value)
  129. {
  130.     return crmf_add_secitem_control(inCertReq, value, 
  131.     SEC_OID_PKIX_REGCTRL_REGTOKEN);
  132. }
  134. SECStatus
  135. CRMF_CertRequestSetAuthenticatorControl (CRMFCertRequest *inCertReq, 
  136.  SECItem         *value)
  137. {
  138.     return crmf_add_secitem_control(inCertReq, value, 
  139.     SEC_OID_PKIX_REGCTRL_AUTHENTICATOR);
  140. }
  142. SECStatus
  143. crmf_destroy_encrypted_value(CRMFEncryptedValue *inEncrValue, PRBool freeit)
  144. {
  145.     if (inEncrValue != NULL) {
  146.         if (inEncrValue->intendedAlg) {
  147.     SECOID_DestroyAlgorithmID(inEncrValue->intendedAlg, PR_TRUE);
  148. }
  149. if (inEncrValue->symmAlg) {
  150.     SECOID_DestroyAlgorithmID(inEncrValue->symmAlg, PR_TRUE);
  151. }
  152.         if (inEncrValue->encSymmKey.data) {
  153.     PORT_Free(inEncrValue->encSymmKey.data);
  154. }
  155. if (inEncrValue->keyAlg) {
  156.     SECOID_DestroyAlgorithmID(inEncrValue->keyAlg, PR_TRUE);
  157. }
  158. if (inEncrValue->valueHint.data) {
  159.     PORT_Free(inEncrValue->valueHint.data);
  160. }
  161.         if (inEncrValue->encValue.data) {
  162.     PORT_Free(inEncrValue->encValue.data);
  163. }
  164. if (freeit) {
  165.     PORT_Free(inEncrValue);
  166. }
  167.     }
  168.     return SECSuccess;
  169. }
  171. SECStatus
  172. CRMF_DestroyEncryptedValue(CRMFEncryptedValue *inEncrValue)
  173. {
  174.     return crmf_destroy_encrypted_value(inEncrValue, PR_TRUE);
  175. }
  177. SECStatus
  178. crmf_copy_encryptedvalue_secalg(PRArenaPool     *poolp,
  179. SECAlgorithmID  *srcAlgId,
  180. SECAlgorithmID **destAlgId)
  181. {
  182.     SECAlgorithmID *newAlgId;
  184.     *destAlgId = newAlgId = (poolp != NULL) ?
  185.                             PORT_ArenaZNew(poolp, SECAlgorithmID) :
  186.                             PORT_ZNew(SECAlgorithmID);
  187.     if (newAlgId == NULL) {
  188.         return SECFailure;
  189.     }
  190.     
  191.     return SECOID_CopyAlgorithmID(poolp, newAlgId, srcAlgId);
  192. }
  194. SECStatus
  195. crmf_copy_encryptedvalue(PRArenaPool        *poolp,
  196.  CRMFEncryptedValue *srcValue,
  197.  CRMFEncryptedValue *destValue)
  198. {
  199.     SECStatus           rv;
  201.     if (srcValue->intendedAlg != NULL) {
  202.         rv = crmf_copy_encryptedvalue_secalg(poolp,
  203.      srcValue->intendedAlg,
  204.      &destValue->intendedAlg);
  205. if (rv != SECSuccess) {
  206.     goto loser;
  207. }
  208.     }
  209.     if (srcValue->symmAlg != NULL) {
  210.         rv = crmf_copy_encryptedvalue_secalg(poolp, 
  211.      srcValue->symmAlg,
  212.      &destValue->symmAlg);
  213. if (rv != SECSuccess) {
  214.     goto loser;
  215. }
  216.     }
  217.     if (srcValue->encSymmKey.data != NULL) {
  218.         rv = crmf_make_bitstring_copy(poolp, 
  219.       &destValue->encSymmKey,
  220.       &srcValue->encSymmKey);
  221. if (rv != SECSuccess) {
  222.     goto loser;
  223. }
  224.     }
  225.     if (srcValue->keyAlg != NULL) {
  226.         rv = crmf_copy_encryptedvalue_secalg(poolp,
  227.      srcValue->keyAlg,
  228.      &destValue->keyAlg);
  229. if (rv != SECSuccess) {
  230.     goto loser;
  231. }
  232.     }
  233.     if (srcValue->valueHint.data != NULL) {
  234.         rv = SECITEM_CopyItem(poolp, 
  235.       &destValue->valueHint,
  236.       &srcValue->valueHint);
  237. if (rv != SECSuccess) {
  238.     goto loser;
  239. }
  240.     }
  241.     if (srcValue->encValue.data != NULL) {
  242.         rv = crmf_make_bitstring_copy(poolp,
  243.       &destValue->encValue,
  244.       &srcValue->encValue);
  245. if (rv != SECSuccess) {
  246.     goto loser;
  247. }
  248.     }
  249.     return SECSuccess;
  250.  loser:
  251.     if (poolp == NULL && destValue != NULL) {
  252.         crmf_destroy_encrypted_value(destValue, PR_TRUE);
  253.     }
  254.     return SECFailure;
  255. }
  257. SECStatus 
  258. crmf_copy_encryptedkey(PRArenaPool       *poolp,
  259.        CRMFEncryptedKey  *srcEncrKey,
  260.        CRMFEncryptedKey  *destEncrKey)
  261. {
  262.     SECStatus          rv;
  263.     void              *mark;
  265.     if (poolp != NULL) {
  266.         mark = PORT_ArenaMark(poolp);
  267.     }
  269.     switch (srcEncrKey->encKeyChoice) {
  270.     case crmfEncryptedValueChoice:
  271.         rv = crmf_copy_encryptedvalue(poolp, 
  272.       &srcEncrKey->value.encryptedValue,
  273.       &destEncrKey->value.encryptedValue);
  274. break;
  275.     case crmfEnvelopedDataChoice:
  276.         destEncrKey->value.envelopedData = 
  277.     SEC_PKCS7CopyContentInfo(srcEncrKey->value.envelopedData);
  278.         rv = (destEncrKey->value.envelopedData != NULL) ? SECSuccess:
  279.                                                   SECFailure;
  280.         break;
  281.     default:
  282.         rv = SECFailure;
  283.     }
  284.     if (rv != SECSuccess) {
  285.         goto loser;
  286.     }
  287.     destEncrKey->encKeyChoice = srcEncrKey->encKeyChoice;
  288.     if (poolp != NULL) {
  289.      PORT_ArenaUnmark(poolp, mark);
  290.     }
  291.     return SECSuccess;
  293.  loser:
  294.     if (poolp != NULL) {
  295.         PORT_ArenaRelease(poolp, mark);
  296.     }
  297.     return SECFailure;
  298. }
  300. CRMFPKIArchiveOptions*
  301. crmf_create_encr_pivkey_option(CRMFEncryptedKey *inEncryptedKey)
  302. {
  303.     CRMFPKIArchiveOptions *newArchOpt;
  304.     SECStatus              rv;
  306.     newArchOpt = PORT_ZNew(CRMFPKIArchiveOptions);
  307.     if (newArchOpt == NULL) {
  308.         goto loser;
  309.     }
  311.     rv = crmf_copy_encryptedkey(NULL, inEncryptedKey,
  312. &newArchOpt->option.encryptedKey);
  313.     
  314.     if (rv != SECSuccess) {
  315.       goto loser;
  316.     }
  317.     newArchOpt->archOption = crmfEncryptedPrivateKey;
  318.     return newArchOpt;
  319.  loser:
  320.     if (newArchOpt != NULL) {
  321.         CRMF_DestroyPKIArchiveOptions(newArchOpt);
  322.     }
  323.     return NULL;
  324. }
  326. static CRMFPKIArchiveOptions*
  327. crmf_create_keygen_param_option(SECItem *inKeyGenParams)
  328. {
  329.     CRMFPKIArchiveOptions *newArchOptions;
  330.     SECStatus              rv;
  332.     newArchOptions = PORT_ZNew(CRMFPKIArchiveOptions);
  333.     if (newArchOptions == NULL) {
  334.         goto loser;
  335.     }
  336.     newArchOptions->archOption = crmfKeyGenParameters;
  337.     rv = SECITEM_CopyItem(NULL, &newArchOptions->option.keyGenParameters,
  338.   inKeyGenParams);
  339.     if (rv != SECSuccess) {
  340.         goto loser;
  341.     }
  342.     return newArchOptions;
  343.  loser:
  344.     if (newArchOptions != NULL) {
  345.         CRMF_DestroyPKIArchiveOptions(newArchOptions);
  346.     }
  347.     return NULL;
  348. }
  350. static CRMFPKIArchiveOptions*
  351. crmf_create_arch_rem_gen_privkey(PRBool archiveRemGenPrivKey)
  352. {
  353.     unsigned char          value;
  354.     SECItem               *dummy;
  355.     CRMFPKIArchiveOptions *newArchOptions;
  357.     value = (archiveRemGenPrivKey) ? hexTrue : hexFalse;
  358.     newArchOptions = PORT_ZNew(CRMFPKIArchiveOptions);
  359.     if (newArchOptions == NULL) {
  360.         goto loser;
  361.     }
  362.     dummy = SEC_ASN1EncodeItem(NULL, 
  363.        &newArchOptions->option.archiveRemGenPrivKey,
  364.        &value, SEC_BooleanTemplate);
  365.     PORT_Assert (dummy == &newArchOptions->option.archiveRemGenPrivKey);
  366.     if (dummy != &newArchOptions->option.archiveRemGenPrivKey) {
  367.         SECITEM_FreeItem (dummy, PR_TRUE);
  368. goto loser;
  369.     }
  370.     newArchOptions->archOption = crmfArchiveRemGenPrivKey;
  371.     return newArchOptions;
  372.  loser:
  373.     if (newArchOptions != NULL) {
  374.         CRMF_DestroyPKIArchiveOptions(newArchOptions);
  375.     }
  376.     return NULL;
  377. }
  379. CRMFPKIArchiveOptions*
  380. CRMF_CreatePKIArchiveOptions(CRMFPKIArchiveOptionsType inType, void *data)
  381. {
  382.     CRMFPKIArchiveOptions* retOptions;
  384.     PORT_Assert(data != NULL);
  385.     if (data == NULL) {
  386.         return NULL;
  387.     }
  388.     switch(inType) {
  389.     case crmfEncryptedPrivateKey:
  390.         retOptions = crmf_create_encr_pivkey_option((CRMFEncryptedKey*)data);
  391. break;
  392.     case crmfKeyGenParameters:
  393.         retOptions = crmf_create_keygen_param_option((SECItem*)data);
  394. break;
  395.     case crmfArchiveRemGenPrivKey:
  396.         retOptions = crmf_create_arch_rem_gen_privkey(*(PRBool*)data);
  397. break;
  398.     default:
  399.         retOptions = NULL;
  400.     }
  401.     return retOptions;
  402. }
  404. static SECStatus
  405. crmf_destroy_encrypted_key(CRMFEncryptedKey *inEncrKey, PRBool freeit)
  406. { 
  407.     PORT_Assert(inEncrKey != NULL);
  408.     if (inEncrKey != NULL) {
  409.         switch (inEncrKey->encKeyChoice){
  410. case crmfEncryptedValueChoice:
  411.             crmf_destroy_encrypted_value(&inEncrKey->value.encryptedValue, 
  412.  PR_FALSE);
  413.     break;
  414. case crmfEnvelopedDataChoice:
  415.     SEC_PKCS7DestroyContentInfo(inEncrKey->value.envelopedData);
  416.             break;
  417.         default:
  418.             break;
  419.         }
  420.         if (freeit) {
  421.             PORT_Free(inEncrKey);
  422.         }
  423.     }
  424.     return SECSuccess;
  425. }
  427. SECStatus 
  428. crmf_destroy_pkiarchiveoptions(CRMFPKIArchiveOptions *inArchOptions, 
  429.        PRBool                 freeit)
  430. {
  431.     PORT_Assert(inArchOptions != NULL);
  432.     if (inArchOptions != NULL) {
  433.         switch (inArchOptions->archOption) {
  434. case crmfEncryptedPrivateKey:
  435.     crmf_destroy_encrypted_key(&inArchOptions->option.encryptedKey,
  436.        PR_FALSE);
  437.     break;
  438. case crmfKeyGenParameters:
  439. case crmfArchiveRemGenPrivKey:
  440.     /* This is a union, so having a pointer to one is like
  441.      * having a pointer to both.  
  442.      */
  443.     SECITEM_FreeItem(&inArchOptions->option.keyGenParameters, 
  444.      PR_FALSE);
  445.     break;
  446.         case crmfNoArchiveOptions:
  447.             break;
  448. }
  449. if (freeit) {
  450.     PORT_Free(inArchOptions);
  451. }
  452.     }
  453.     return SECSuccess;
  454. }
  456. SECStatus
  457. CRMF_DestroyPKIArchiveOptions(CRMFPKIArchiveOptions *inArchOptions) 
  458. {
  459.     return crmf_destroy_pkiarchiveoptions(inArchOptions, PR_TRUE);
  460. }
  462. static CK_MECHANISM_TYPE
  463. crmf_get_non_pad_mechanism(CK_MECHANISM_TYPE type)
  464. {
  465.     switch (type) {
  466.     case CKM_DES3_CBC_PAD:
  467.         return CKM_DES3_CBC;
  468.     case CKM_CAST5_CBC_PAD:
  469.         return CKM_CAST5_CBC;
  470.     case CKM_DES_CBC_PAD:
  471.         return CKM_DES_CBC;
  472.     case CKM_IDEA_CBC_PAD:
  473.         return CKM_IDEA_CBC;
  474.     case CKM_CAST3_CBC_PAD:
  475.         return CKM_CAST3_CBC;
  476.     case CKM_CAST_CBC_PAD:
  477.         return CKM_CAST_CBC;
  478.     case CKM_RC5_CBC_PAD:
  479.         return CKM_RC5_CBC;
  480.     case CKM_RC2_CBC_PAD:
  481.         return CKM_RC2_CBC;
  482.     case CKM_CDMF_CBC_PAD:
  483.         return CKM_CDMF_CBC;
  484.     }
  485.     return type;
  486. }
  488. static CK_MECHANISM_TYPE
  489. crmf_get_pad_mech_from_tag(SECOidTag oidTag)
  490. {
  491.     CK_MECHANISM_TYPE  mechType;
  492.     SECOidData        *oidData;
  494.     oidData = SECOID_FindOIDByTag(oidTag);
  495.     mechType = (CK_MECHANISM_TYPE)oidData->mechanism;
  496.     return PK11_GetPadMechanism(mechType);
  497. }
  499. static CK_MECHANISM_TYPE
  500. crmf_get_best_privkey_wrap_mechanism(PK11SlotInfo *slot) 
  501. {
  502.     CK_MECHANISM_TYPE privKeyPadMechs[] = { CKM_DES3_CBC_PAD,
  503.     CKM_CAST5_CBC_PAD,
  504.     CKM_DES_CBC_PAD,
  505.     CKM_IDEA_CBC_PAD,
  506.     CKM_CAST3_CBC_PAD,
  507.     CKM_CAST_CBC_PAD,
  508.     CKM_RC5_CBC_PAD,
  509.     CKM_RC2_CBC_PAD,
  510.     CKM_CDMF_CBC_PAD };
  511.     int mechCount = sizeof(privKeyPadMechs)/sizeof(privKeyPadMechs[0]);
  512.     int i;
  514.     for (i=0; i < mechCount; i++) {
  515.         if (PK11_DoesMechanism(slot, privKeyPadMechs[i])) {
  516.     return privKeyPadMechs[i];
  517. }
  518.     }
  519.     return CKM_INVALID_MECHANISM;
  520. }
  522. CK_MECHANISM_TYPE
  523. CRMF_GetBestWrapPadMechanism(PK11SlotInfo *slot)
  524. {
  525.     return crmf_get_best_privkey_wrap_mechanism(slot);
  526. }
  528. static SECItem*
  529. crmf_get_iv(CK_MECHANISM_TYPE mechType)
  530. {
  531.     int        iv_size = PK11_GetIVLength(mechType);
  532.     SECItem   *iv;
  533.     SECStatus  rv; 
  535.     iv = PORT_ZNew(SECItem);
  536.     if (iv == NULL) {
  537.         return NULL;
  538.     }
  539.     if (iv_size == 0) {
  540.         iv->data = NULL;
  541. iv->len  = 0;
  542. return iv;
  543.     }
  544.     iv->data = PORT_NewArray(unsigned char, iv_size);
  545.     if (iv->data == NULL) {
  546.         iv->len = 0;
  547. return iv;
  548.     }
  549.     iv->len = iv_size;
  550.     rv = PK11_GenerateRandom(iv->data, iv->len);
  551.     if (rv != SECSuccess) {
  552.         PORT_Free(iv->data);
  553. iv->data = NULL;
  554. iv->len  = 0;
  555.     }
  556.     return iv;
  557. }
  559. SECItem*
  560. CRMF_GetIVFromMechanism(CK_MECHANISM_TYPE mechType)
  561. {
  562.     return crmf_get_iv(mechType);
  563. }
  565. CK_MECHANISM_TYPE
  566. crmf_get_mechanism_from_public_key(SECKEYPublicKey *inPubKey)
  567. {
  568.     CERTSubjectPublicKeyInfo *spki = NULL;
  569.     SECOidTag                 tag;
  570.     
  572.     spki = SECKEY_CreateSubjectPublicKeyInfo(inPubKey);
  573.     if (spki == NULL) {
  574.         return CKM_INVALID_MECHANISM;
  575.     }
  576.     tag = SECOID_FindOIDTag(&spki->algorithm.algorithm);
  577.     SECKEY_DestroySubjectPublicKeyInfo(spki);
  578.     spki = NULL;
  579.     return PK11_AlgtagToMechanism(tag);
  580. }
  582. SECItem*
  583. crmf_get_public_value(SECKEYPublicKey *pubKey, SECItem *dest)
  584. {
  585.     SECItem *pubValue;
  587.     if (dest != NULL) {
  588.         pubValue = dest;
  589.     } else {
  590.         pubValue = PORT_ZNew(SECItem);
  591.     }
  592.     switch(pubKey->keyType) {
  593.         case dsaKey:
  594.     SECITEM_CopyItem(NULL, pubValue, &pubKey->u.dsa.publicValue);
  595.             break;
  596.         case rsaKey:
  597.     SECITEM_CopyItem(NULL, pubValue, &pubKey->u.rsa.modulus);
  598.             break;
  599.         case dhKey:
  600.     SECITEM_CopyItem(NULL, pubValue, &pubKey->u.dh.publicValue);
  601.     break;
  602.         default:
  603.     if (dest == NULL) {
  604.         PORT_Free(pubValue);
  605.     }
  606.             pubValue = NULL;
  607.     break;
  608.     }
  609.     return pubValue;
  610. }
  612. static SECItem*
  613. crmf_decode_params(SECItem *inParams)
  614. {
  615.     SECItem   *params;
  616.     SECStatus  rv;
  617.     
  618.     params = PORT_ZNew(SECItem);
  619.     rv = SEC_ASN1DecodeItem(NULL, params, SEC_OctetStringTemplate,
  620.     inParams);
  621.     if (rv != SECSuccess) {
  622.         SECITEM_FreeItem(params, PR_TRUE);
  623. return NULL;
  624.     }
  625.     return params;
  626. }
  628. int
  629. crmf_get_key_size_from_mech(CK_MECHANISM_TYPE mechType)
  630. {
  631.     CK_MECHANISM_TYPE keyGen = PK11_GetKeyGen(mechType);
  633.     switch (keyGen) {
  634.     case CKM_CDMF_KEY_GEN:
  635.     case CKM_DES_KEY_GEN:
  636.         return 8;
  637.     case CKM_DES2_KEY_GEN:
  638. return 16;
  639.     case CKM_DES3_KEY_GEN:
  640. return 24;
  641.     }
  642.     return 0;
  643. }
  645. SECStatus
  646. crmf_encrypted_value_unwrap_priv_key(PRArenaPool        *poolp,
  647.      CRMFEncryptedValue *encValue,
  648.      SECKEYPrivateKey   *privKey,
  649.      SECKEYPublicKey    *newPubKey,
  650.      SECItem            *nickname,
  651.      PK11SlotInfo       *slot,
  652.      unsigned char       keyUsage,
  653.      SECKEYPrivateKey  **unWrappedKey,
  654.      void               *wincx)
  655. {
  656.     PK11SymKey        *wrappingKey = NULL;
  657.     CK_MECHANISM_TYPE  wrapMechType;
  658.     SECOidTag          oidTag;
  659.     SECItem           *params = NULL, *publicValue = NULL;
  660.     int                keySize, origLen;
  661.     CK_KEY_TYPE        keyType;
  662.     CK_ATTRIBUTE_TYPE *usage;
  663.     CK_ATTRIBUTE_TYPE rsaUsage[] = {
  664.       CKA_UNWRAP, CKA_DECRYPT, CKA_SIGN, CKA_SIGN_RECOVER };
  665.     CK_ATTRIBUTE_TYPE dsaUsage[] = { CKA_SIGN };
  666.     CK_ATTRIBUTE_TYPE dhUsage[] = { CKA_DERIVE };
  667.     int usageCount;
  669.     oidTag = SECOID_GetAlgorithmTag(encValue->symmAlg);
  670.     wrapMechType = crmf_get_pad_mech_from_tag(oidTag);
  671.     keySize = crmf_get_key_size_from_mech(wrapMechType);
  672.     wrappingKey = PK11_PubUnwrapSymKey(privKey, &encValue->encSymmKey, 
  673.        wrapMechType, CKA_UNWRAP, keySize);
  674.     if (wrappingKey == NULL) {
  675.         goto loser;
  676.     }/* Make the length a byte length instead of bit length*/
  677.     params = (encValue->symmAlg != NULL) ? 
  678.               crmf_decode_params(&encValue->symmAlg->parameters) : NULL;
  679.     origLen = encValue->encValue.len;
  680.     encValue->encValue.len = CRMF_BITS_TO_BYTES(origLen);
  681.     publicValue = crmf_get_public_value(newPubKey, NULL);
  682.     switch(newPubKey->keyType) {
  683.     default:
  684.     case rsaKey:
  685.         keyType = CKK_RSA;
  686.         switch  (keyUsage & (KU_KEY_ENCIPHERMENT|KU_DIGITAL_SIGNATURE)) {
  687.         case KU_KEY_ENCIPHERMENT:
  688.             usage = rsaUsage;
  689.             usageCount = 2;
  690.             break;
  691.         case KU_DIGITAL_SIGNATURE:
  692.             usage = &rsaUsage[2];
  693.             usageCount = 2;
  694.             break;
  695.         case KU_KEY_ENCIPHERMENT|KU_DIGITAL_SIGNATURE:
  696.         case 0: /* default to everything */
  697.             usage = rsaUsage;
  698.             usageCount = 4;
  699.             break;
  700.         }
  701. break;
  702.     case dhKey:
  703.         keyType = CKK_DH;
  704.         usage = dhUsage;
  705.         usageCount = sizeof(dhUsage)/sizeof(dhUsage[0]);
  706.         break;
  707.     case dsaKey:
  708.         keyType = CKK_DSA;
  709.         usage = dsaUsage;
  710.         usageCount = sizeof(dsaUsage)/sizeof(dsaUsage[0]);
  711.         break;
  712.     }
  713.     *unWrappedKey = PK11_UnwrapPrivKey(slot, wrappingKey, wrapMechType, params,
  714.        &encValue->encValue, nickname,
  715.        publicValue, PR_TRUE,PR_TRUE, 
  716.        keyType, usage, usageCount, wincx);
  717.     encValue->encValue.len = origLen;
  718.     if (*unWrappedKey == NULL) {
  719.         goto loser;
  720.     }
  721.     SECITEM_FreeItem (publicValue, PR_TRUE);
  722.     if (params!= NULL) {
  723.         SECITEM_FreeItem(params, PR_TRUE);
  724.     } 
  725.     PK11_FreeSymKey(wrappingKey);
  726.     return SECSuccess;
  727.  loser:
  728.     *unWrappedKey = NULL;
  729.     return SECFailure;
  730. }
  732. CRMFEncryptedValue *
  733. crmf_create_encrypted_value_wrapped_privkey(SECKEYPrivateKey   *inPrivKey,
  734.     SECKEYPublicKey    *inCAKey,
  735.     CRMFEncryptedValue *destValue)
  736. {
  737.     SECItem                   wrappedPrivKey, wrappedSymKey;
  738.     SECItem                   encodedParam, *dummy;
  739.     SECStatus                 rv;
  740.     CK_MECHANISM_TYPE         pubMechType, symKeyType;
  741.     unsigned char            *wrappedSymKeyBits;
  742.     unsigned char            *wrappedPrivKeyBits;
  743.     SECItem                  *iv = NULL;
  744.     SECOidTag                 tag;
  745.     PK11SymKey               *symKey;
  746.     PK11SlotInfo             *slot;
  747.     SECAlgorithmID           *symmAlg;
  748.     CRMFEncryptedValue       *myEncrValue = NULL;
  750.     encodedParam.data = NULL;
  751.     wrappedSymKeyBits  = PORT_NewArray(unsigned char, MAX_WRAPPED_KEY_LEN);
  752.     wrappedPrivKeyBits = PORT_NewArray(unsigned char, MAX_WRAPPED_KEY_LEN);
  753.     if (wrappedSymKeyBits == NULL || wrappedPrivKeyBits == NULL) {
  754.         goto loser;
  755.     }
  756.     if (destValue == NULL) {
  757.         myEncrValue = destValue = PORT_ZNew(CRMFEncryptedValue);
  758. if (destValue == NULL) {
  759.     goto loser;
  760. }
  761.     }
  763.     pubMechType = crmf_get_mechanism_from_public_key(inCAKey);
  764.     if (pubMechType == CKM_INVALID_MECHANISM) {
  765.         /* XXX I should probably do something here for non-RSA 
  766.  *     keys that are in certs. (ie DSA)
  767.  */
  768.         goto loser;
  769.     }
  770.     slot = inPrivKey->pkcs11Slot; 
  771.     PORT_Assert(slot != NULL);
  772.     symKeyType = crmf_get_best_privkey_wrap_mechanism(slot);
  773.     symKey = PK11_KeyGen(slot, symKeyType, NULL, 0, NULL);
  774.     if (symKey == NULL) {
  775.         goto loser;
  776.     }
  778.     wrappedSymKey.data = wrappedSymKeyBits;
  779.     wrappedSymKey.len  = MAX_WRAPPED_KEY_LEN;
  780.     rv = PK11_PubWrapSymKey(pubMechType, inCAKey, symKey, &wrappedSymKey);
  781.     if (rv != SECSuccess) {
  782.         goto loser;
  783.     }
  784.     /* Make the length of the result a Bit String length. */
  785.     wrappedSymKey.len <<= 3;
  787.     wrappedPrivKey.data = wrappedPrivKeyBits;
  788.     wrappedPrivKey.len  = MAX_WRAPPED_KEY_LEN;
  789.     iv = crmf_get_iv(symKeyType);
  790.     rv = PK11_WrapPrivKey(slot, symKey, inPrivKey, symKeyType, iv, 
  791.   &wrappedPrivKey, NULL);
  792.     PK11_FreeSymKey(symKey);
  793.     if (rv != SECSuccess) {
  794.         goto loser;
  795.     }
  796.     /* Make the length of the result a Bit String length. */
  797.     wrappedPrivKey.len <<= 3;
  798.     rv = crmf_make_bitstring_copy(NULL, 
  799.   &destValue->encValue, 
  800.   &wrappedPrivKey);
  801.     if (rv != SECSuccess) {
  802.         goto loser;
  803.     }
  805.     rv = crmf_make_bitstring_copy(NULL,
  806.   &destValue->encSymmKey, 
  807.   &wrappedSymKey);
  808.     if (rv != SECSuccess) {
  809.         goto loser;
  810.     }
  811.     destValue->symmAlg = symmAlg = PORT_ZNew(SECAlgorithmID);
  812.     if (symmAlg == NULL) {
  813.         goto loser;
  814.     }
  816.     dummy = SEC_ASN1EncodeItem(NULL, &encodedParam, iv, 
  817.        SEC_OctetStringTemplate);
  818.     if (dummy != &encodedParam) {
  819.         SECITEM_FreeItem(dummy, PR_TRUE);
  820. goto loser;
  821.     }
  823.     symKeyType = crmf_get_non_pad_mechanism(symKeyType);
  824.     tag = PK11_MechanismToAlgtag(symKeyType);
  825.     rv = SECOID_SetAlgorithmID(NULL, symmAlg, tag, &encodedParam);
  826.     if (rv != SECSuccess) {
  827.         goto loser;
  828.     }
  829.     PORT_Free(encodedParam.data);
  830.     PORT_Free(wrappedPrivKeyBits);
  831.     PORT_Free(wrappedSymKeyBits);
  832.     if (iv->data != NULL) {
  833.         PORT_Free(iv->data);
  834.     }
  835.     PORT_Free(iv);
  836.     return destValue;
  837.  loser:
  838.     if (iv != NULL) {
  839.         if (iv->data) {
  840.     PORT_Free(iv->data);
  841. }
  842.         PORT_Free(iv);
  843.     }
  844.     if (myEncrValue != NULL) {
  845.         crmf_destroy_encrypted_value(myEncrValue, PR_TRUE);
  846.     }
  847.     if (wrappedSymKeyBits != NULL) {
  848.         PORT_Free(wrappedSymKeyBits);
  849.     }
  850.     if (wrappedPrivKeyBits != NULL) {
  851.         PORT_Free(wrappedPrivKeyBits);
  852.     }
  853.     if (encodedParam.data != NULL) {
  854.         PORT_Free(encodedParam.data);
  855.     }
  856.     return NULL;
  857. }
  859. CRMFEncryptedKey*
  860. CRMF_CreateEncryptedKeyWithEncryptedValue (SECKEYPrivateKey *inPrivKey,
  861.    CERTCertificate  *inCACert)
  862. {
  863.     SECKEYPublicKey          *caPubKey = NULL;
  864.     CRMFEncryptedKey         *encKey = NULL;
  865.     CRMFEncryptedValue       *dummy;
  867.     PORT_Assert(inPrivKey != NULL && inCACert != NULL);
  868.     if (inPrivKey == NULL || inCACert == NULL) {
  869.         return NULL;
  870.     }
  872.     caPubKey = CERT_ExtractPublicKey(inCACert);
  873.     if (caPubKey == NULL) {
  874.         goto loser;
  875.     }
  877.     encKey = PORT_ZNew(CRMFEncryptedKey);
  878.     if (encKey == NULL) {
  879.         goto loser;
  880.     }
  881.     dummy = crmf_create_encrypted_value_wrapped_privkey(inPrivKey,
  882. caPubKey,
  883.        &encKey->value.encryptedValue);
  884.     PORT_Assert(dummy == &encKey->value.encryptedValue);
  885.     /* We won't add the der value here, but rather when it 
  886.      * becomes part of a certificate request.
  887.      */
  888.     SECKEY_DestroyPublicKey(caPubKey);
  889.     encKey->encKeyChoice = crmfEncryptedValueChoice;
  890.     return encKey;
  891.  loser:
  892.     if (encKey != NULL) {
  893.         CRMF_DestroyEncryptedKey(encKey);
  894.     }
  895.     if (caPubKey != NULL) {
  896.         SECKEY_DestroyPublicKey(caPubKey);
  897.     }
  898.     return NULL;
  899. }
  901. SECStatus
  902. CRMF_DestroyEncryptedKey(CRMFEncryptedKey *inEncrKey)
  903. {
  904.     return crmf_destroy_encrypted_key(inEncrKey, PR_TRUE);
  905. }
  907. SECStatus
  908. crmf_copy_pkiarchiveoptions(PRArenaPool           *poolp,
  909.     CRMFPKIArchiveOptions *destOpt,
  910.     CRMFPKIArchiveOptions *srcOpt)
  911. {
  912.     SECStatus rv;
  913.     destOpt->archOption = srcOpt->archOption;
  914.     switch (srcOpt->archOption) {
  915.     case crmfEncryptedPrivateKey:
  916.         rv = crmf_copy_encryptedkey(poolp,
  917.     &srcOpt->option.encryptedKey,
  918.     &destOpt->option.encryptedKey);
  919.         break;
  920.     case crmfKeyGenParameters:
  921.     case crmfArchiveRemGenPrivKey:
  922.         /* We've got a union, so having a pointer to one is just
  923.  * like having a pointer to the other one.
  924.  */
  925.         rv = SECITEM_CopyItem(poolp, 
  926.       &destOpt->option.keyGenParameters,
  927.       &srcOpt->option.keyGenParameters);
  928. break;
  929.     default:
  930.         rv = SECFailure;
  931.     }
  932.     return rv;
  933. }
  935. static SECStatus
  936. crmf_check_and_adjust_archoption(CRMFControl *inControl)
  937. {
  938.     CRMFPKIArchiveOptions *options;
  940.     options = &inControl->value.archiveOptions;
  941.     if (options->archOption == crmfNoArchiveOptions) {
  942.         /* It hasn't been set, so figure it out from the 
  943.  * der.
  944.  */
  945.         switch (inControl->derValue.data[0] & 0x0f) {
  946. case 0:
  947.     options->archOption = crmfEncryptedPrivateKey;
  948.     break;
  949. case 1:
  950.     options->archOption = crmfKeyGenParameters;
  951.     break;
  952. case 2:
  953.     options->archOption = crmfArchiveRemGenPrivKey;
  954.     break;
  955. default:
  956.     /* We've got bad DER.  Return an error. */
  957.     return SECFailure;
  958. }
  959.     }
  960.     return SECSuccess;
  961. }
  963. static const SEC_ASN1Template *
  964. crmf_get_pkiarchive_subtemplate(CRMFControl *inControl)
  965. {
  966.     const SEC_ASN1Template *retTemplate;
  967.     SECStatus               rv;
  968.     /*
  969.      * We could be in the process of decoding, in which case the
  970.      * archOption field will not be set.  Let's check it and set 
  971.      * it accordingly.
  972.      */
  974.     rv = crmf_check_and_adjust_archoption(inControl);
  975.     if (rv != SECSuccess) {
  976.         return NULL;
  977.     }
  979.     switch (inControl->value.archiveOptions.archOption) {
  980.     case crmfEncryptedPrivateKey:
  981.         retTemplate = CRMFEncryptedKeyWithEncryptedValueTemplate;
  982. inControl->value.archiveOptions.option.encryptedKey.encKeyChoice =
  983.   crmfEncryptedValueChoice;
  984. break;
  985.     default:
  986.         retTemplate = NULL;
  987.     }
  988.     return retTemplate;
  989. }
  991. const SEC_ASN1Template*
  992. crmf_get_pkiarchiveoptions_subtemplate(CRMFControl *inControl)
  993. {
  994.     const SEC_ASN1Template *retTemplate;
  996.     switch (inControl->tag) {
  997.     case SEC_OID_PKIX_REGCTRL_REGTOKEN:
  998.     case SEC_OID_PKIX_REGCTRL_AUTHENTICATOR:
  999.         retTemplate = SEC_UTF8StringTemplate;
  1000. break;
  1001.     case SEC_OID_PKIX_REGCTRL_PKI_ARCH_OPTIONS:
  1002.         retTemplate = crmf_get_pkiarchive_subtemplate(inControl);
  1003. break;
  1004.     case SEC_OID_PKIX_REGCTRL_PKIPUBINFO:
  1005.     case SEC_OID_PKIX_REGCTRL_OLD_CERT_ID:
  1006.     case SEC_OID_PKIX_REGCTRL_PROTOCOL_ENC_KEY:
  1007.         /* We don't support these controls, so we fail for now.*/
  1008.         retTemplate = NULL;
  1009. break;
  1010.     default:
  1011.         retTemplate = NULL;
  1012.     }
  1013.     return retTemplate;
  1014. }
  1016. static SECStatus
  1017. crmf_encode_pkiarchiveoptions(PRArenaPool *poolp, CRMFControl *inControl)
  1018. {
  1019.     const SEC_ASN1Template *asn1Template;
  1020.     SECStatus               rv;
  1022.     asn1Template = crmf_get_pkiarchiveoptions_subtemplate(inControl);
  1023.     /* We've got a union, so passing a pointer to one element of the 
  1024.      * union, is the same as passing a pointer to any of the other
  1025.      * members of the union.
  1026.      */
  1027.     SEC_ASN1EncodeItem(poolp, &inControl->derValue,
  1028.                        &inControl->value.archiveOptions, asn1Template);
  1030.     if (inControl->derValue.data == NULL) {
  1031.         goto loser;
  1032.     }
  1033.     return SECSuccess;
  1034.  loser:
  1035.     return SECFailure;
  1036. }
  1038. SECStatus
  1039. CRMF_CertRequestSetPKIArchiveOptions(CRMFCertRequest       *inCertReq,
  1040.      CRMFPKIArchiveOptions *inOptions)
  1041. {
  1042.     CRMFControl *newControl;
  1043.     PRArenaPool *poolp;
  1044.     SECStatus    rv;
  1045.     void        *mark;
  1046.     
  1047.     PORT_Assert(inCertReq != NULL && inOptions != NULL);
  1048.     if (inCertReq == NULL || inOptions == NULL) {
  1049.         return SECFailure;
  1050.     }
  1051.     poolp = inCertReq->poolp;
  1052.     mark = PORT_ArenaMark(poolp);
  1053.     rv = crmf_add_new_control(inCertReq, 
  1054.       SEC_OID_PKIX_REGCTRL_PKI_ARCH_OPTIONS,
  1055.       &newControl);
  1056.     if (rv != SECSuccess) {
  1057.         goto loser;
  1058.     }
  1060.     rv = crmf_copy_pkiarchiveoptions(poolp, 
  1061.      &newControl->value.archiveOptions,
  1062.      inOptions);
  1063.     if (rv != SECSuccess) {
  1064.         goto loser;
  1065.     }
  1067.     rv = crmf_encode_pkiarchiveoptions(poolp, newControl); 
  1068.     if (rv != SECSuccess) {
  1069.         goto loser;
  1070.     }
  1071.     PORT_ArenaUnmark(poolp, mark);
  1072.     return SECSuccess;
  1073.  loser:
  1074.     PORT_ArenaRelease(poolp, mark);
  1075.     return SECFailure;
  1076. }
  1078. SECStatus
  1079. crmf_destroy_control(CRMFControl *inControl, PRBool freeit)
  1080. {
  1081.     PORT_Assert(inControl != NULL);
  1082.     if (inControl != NULL) {
  1083.         SECITEM_FreeItem(&inControl->derTag, PR_FALSE);
  1084.         SECITEM_FreeItem(&inControl->derValue, PR_FALSE);
  1085. /* None of the other tags require special processing at 
  1086.  * the moment when freeing because they are not supported,
  1087.  * but if/when they are, add the necessary routines here.  
  1088.  * If all controls are supported, then every member of the 
  1089.  * union inControl->value will have a case that deals with 
  1090.  * it in the following switch statement.
  1091.  */
  1092. switch (inControl->tag) {
  1093. case SEC_OID_PKIX_REGCTRL_PKI_ARCH_OPTIONS:
  1094.     crmf_destroy_pkiarchiveoptions(&inControl->value.archiveOptions,
  1095.    PR_FALSE);
  1096.     break;
  1097.         default:
  1098.            /* Put this here to get rid of all those annoying warnings.*/
  1099.            break;
  1100. }
  1101. if (freeit) {
  1102.     PORT_Free(inControl);
  1103. }
  1104.     }
  1105.     return SECSuccess;
  1106. }
  1108. SECStatus
  1109. CRMF_DestroyControl(CRMFControl *inControl)
  1110. {
  1111.     return crmf_destroy_control(inControl, PR_TRUE);
  1112. }
  1114. static SECOidTag
  1115. crmf_controltype_to_tag(CRMFControlType inControlType)
  1116. {
  1117.     SECOidTag retVal;
  1119.     switch(inControlType) {
  1120.     case crmfRegTokenControl:
  1121.       retVal = SEC_OID_PKIX_REGCTRL_REGTOKEN; 
  1122.       break;
  1123.     case crmfAuthenticatorControl:
  1124.       retVal = SEC_OID_PKIX_REGCTRL_AUTHENTICATOR;
  1125.       break;
  1126.     case crmfPKIPublicationInfoControl:
  1127.       retVal = SEC_OID_PKIX_REGCTRL_PKIPUBINFO;
  1128.       break;
  1129.     case crmfPKIArchiveOptionsControl:
  1130.       retVal = SEC_OID_PKIX_REGCTRL_PKI_ARCH_OPTIONS;
  1131.       break;
  1132.     case crmfOldCertIDControl:
  1133.       retVal = SEC_OID_PKIX_REGCTRL_OLD_CERT_ID;
  1134.       break;
  1135.     case crmfProtocolEncrKeyControl:
  1136.       retVal = SEC_OID_PKIX_REGCTRL_PROTOCOL_ENC_KEY;
  1137.       break;
  1138.     default:
  1139.       retVal = SEC_OID_UNKNOWN;
  1140.       break;
  1141.     }
  1142.     return retVal;
  1143. }
  1145. PRBool
  1146. CRMF_CertRequestIsControlPresent(CRMFCertRequest *inCertReq,
  1147.  CRMFControlType  inControlType)
  1148. {
  1149.     SECOidTag controlTag;
  1150.     int       i;
  1152.     PORT_Assert(inCertReq != NULL);
  1153.     if (inCertReq == NULL || inCertReq->controls == NULL) {
  1154.         return PR_FALSE;
  1155.     }
  1156.     controlTag = crmf_controltype_to_tag(inControlType);
  1157.     for (i=0; inCertReq->controls[i] != NULL; i++) {
  1158.         if (inCertReq->controls[i]->tag == controlTag) {
  1159.     return PR_TRUE;
  1160. }
  1161.     }
  1162.     return PR_FALSE;
  1163. }