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

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

CA认证

开发平台：

WINDOWS

seckey.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.  */
  33. #include "cryptohi.h"
  34. #include "keyhi.h"
  35. #include "secrng.h"
  36. #include "secoid.h"
  37. #include "secitem.h"
  38. #include "secder.h"
  39. #include "base64.h"
  40. #include "secasn1.h"
  41. #include "cert.h"
  42. #include "pk11func.h"
  43. #include "secerr.h"
  44. #include "secdig.h"
  45. #include "prtime.h"
  47. const SEC_ASN1Template CERT_SubjectPublicKeyInfoTemplate[] = {
  48.     { SEC_ASN1_SEQUENCE,
  49.   0, NULL, sizeof(CERTSubjectPublicKeyInfo) },
  50.     { SEC_ASN1_INLINE,
  51.   offsetof(CERTSubjectPublicKeyInfo,algorithm),
  52.   SECOID_AlgorithmIDTemplate },
  53.     { SEC_ASN1_BIT_STRING,
  54.   offsetof(CERTSubjectPublicKeyInfo,subjectPublicKey), },
  55.     { 0, }
  56. };
  58. const SEC_ASN1Template CERT_PublicKeyAndChallengeTemplate[] =
  59. {
  60.     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(CERTPublicKeyAndChallenge) },
  61.     { SEC_ASN1_ANY, offsetof(CERTPublicKeyAndChallenge,spki) },
  62.     { SEC_ASN1_IA5_STRING, offsetof(CERTPublicKeyAndChallenge,challenge) },
  63.     { 0 }
  64. };
  66. const SEC_ASN1Template SECKEY_RSAPublicKeyTemplate[] = {
  67.     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(SECKEYPublicKey) },
  68.     { SEC_ASN1_INTEGER, offsetof(SECKEYPublicKey,u.rsa.modulus), },
  69.     { SEC_ASN1_INTEGER, offsetof(SECKEYPublicKey,u.rsa.publicExponent), },
  70.     { 0, }
  71. };
  73. const SEC_ASN1Template SECKEY_DSAPublicKeyTemplate[] = {
  74.     { SEC_ASN1_INTEGER, offsetof(SECKEYPublicKey,u.dsa.publicValue), },
  75.     { 0, }
  76. };
  78. const SEC_ASN1Template SECKEY_PQGParamsTemplate[] = {
  79.     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(PQGParams) },
  80.     { SEC_ASN1_INTEGER, offsetof(PQGParams,prime) },
  81.     { SEC_ASN1_INTEGER, offsetof(PQGParams,subPrime) },
  82.     { SEC_ASN1_INTEGER, offsetof(PQGParams,base) },
  83.     { 0, }
  84. };
  86. const SEC_ASN1Template SECKEY_DHPublicKeyTemplate[] = {
  87.     { SEC_ASN1_INTEGER, offsetof(SECKEYPublicKey,u.dh.publicValue), },
  88.     { 0, }
  89. };
  91. const SEC_ASN1Template SECKEY_DHParamKeyTemplate[] = {
  92.     { SEC_ASN1_SEQUENCE,  0, NULL, sizeof(SECKEYPublicKey) },
  93.     { SEC_ASN1_INTEGER, offsetof(SECKEYPublicKey,u.dh.prime), },
  94.     { SEC_ASN1_INTEGER, offsetof(SECKEYPublicKey,u.dh.base), },
  95.     /* XXX chrisk: this needs to be expanded for decoding of j and validationParms (RFC2459 7.3.2) */
  96.     { SEC_ASN1_SKIP_REST },
  97.     { 0, }
  98. };
  100. const SEC_ASN1Template SECKEY_FortezzaParameterTemplate[] = {
  101.     { SEC_ASN1_SEQUENCE,  0, NULL, sizeof(PQGParams) },
  102.     { SEC_ASN1_OCTET_STRING, offsetof(PQGParams,prime), },
  103.     { SEC_ASN1_OCTET_STRING, offsetof(PQGParams,subPrime), },
  104.     { SEC_ASN1_OCTET_STRING, offsetof(PQGParams,base), },
  105.     { 0 },
  106. };
  107.  
  108. const SEC_ASN1Template SECKEY_FortezzaDiffParameterTemplate[] = {
  109.     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(DiffPQGParams) },
  110.     { SEC_ASN1_INLINE, offsetof(DiffPQGParams,DiffKEAParams), 
  111.                        SECKEY_FortezzaParameterTemplate},
  112.     { SEC_ASN1_INLINE, offsetof(DiffPQGParams,DiffDSAParams), 
  113.                        SECKEY_FortezzaParameterTemplate},
  114.     { 0 },
  115. };
  117. const SEC_ASN1Template SECKEY_FortezzaPreParamTemplate[] = {
  118.     { SEC_ASN1_EXPLICIT | SEC_ASN1_CONSTRUCTED |
  119.       SEC_ASN1_CONTEXT_SPECIFIC | 1, offsetof(PQGDualParams,CommParams),
  120.                 SECKEY_FortezzaParameterTemplate},
  121.     { 0, }
  122. };
  124. const SEC_ASN1Template SECKEY_FortezzaAltPreParamTemplate[] = {
  125.     { SEC_ASN1_EXPLICIT | SEC_ASN1_CONSTRUCTED |
  126.       SEC_ASN1_CONTEXT_SPECIFIC | 0, offsetof(PQGDualParams,DiffParams),
  127.                 SECKEY_FortezzaDiffParameterTemplate},
  128.     { 0, }
  129. };
  131. const SEC_ASN1Template SECKEY_KEAPublicKeyTemplate[] = {
  132.     { SEC_ASN1_INTEGER, offsetof(SECKEYPublicKey,u.kea.publicValue), },
  133.     { 0, }
  134. };
  136. const SEC_ASN1Template SECKEY_KEAParamsTemplate[] = {
  137.     { SEC_ASN1_OCTET_STRING, offsetof(SECKEYPublicKey,u.kea.params.hash), }, 
  138.     { 0, }
  139. };
  142. /*
  143.  * NOTE: This only generates RSA Private Key's. If you need more,
  144.  * We need to pass in some more params...
  145.  */
  146. SECKEYPrivateKey *
  147. SECKEY_CreateRSAPrivateKey(int keySizeInBits,SECKEYPublicKey **pubk, void *cx)
  148. {
  149.     SECKEYPrivateKey *privk;
  150.     PK11SlotInfo *slot = PK11_GetBestSlot(CKM_RSA_PKCS_KEY_PAIR_GEN,cx);
  151.     PK11RSAGenParams param;
  153.     param.keySizeInBits = keySizeInBits;
  154.     param.pe = 65537L;
  155.     
  156.     privk = PK11_GenerateKeyPair(slot,CKM_RSA_PKCS_KEY_PAIR_GEN,&param,pubk,
  157. PR_FALSE, PR_TRUE, cx);
  158.     PK11_FreeSlot(slot);
  159.     return(privk);
  160. }
  162. void
  163. SECKEY_DestroyPrivateKey(SECKEYPrivateKey *privk)
  164. {
  165.     if (privk) {
  166. if (privk->pkcs11Slot) {
  167.     if (privk->pkcs11IsTemp) {
  168.      PK11_DestroyObject(privk->pkcs11Slot,privk->pkcs11ID);
  169.     }
  170.     PK11_FreeSlot(privk->pkcs11Slot);
  172. }
  173.      if (privk->arena) {
  174.     PORT_FreeArena(privk->arena, PR_TRUE);
  175. }
  176.     }
  177. }
  179. void
  180. SECKEY_DestroyPublicKey(SECKEYPublicKey *pubk)
  181. {
  182.     if (pubk) {
  183. if (pubk->pkcs11Slot) {
  184.     PK11_DestroyObject(pubk->pkcs11Slot,pubk->pkcs11ID);
  185.     PK11_FreeSlot(pubk->pkcs11Slot);
  186. }
  187.      if (pubk->arena) {
  188.     PORT_FreeArena(pubk->arena, PR_FALSE);
  189. }
  190.     }
  191. }
  193. SECStatus
  194. SECKEY_CopySubjectPublicKeyInfo(PRArenaPool *arena,
  195.      CERTSubjectPublicKeyInfo *to,
  196.      CERTSubjectPublicKeyInfo *from)
  197. {
  198.     SECStatus rv;
  200.     rv = SECOID_CopyAlgorithmID(arena, &to->algorithm, &from->algorithm);
  201.     if (rv == SECSuccess)
  202. rv = SECITEM_CopyItem(arena, &to->subjectPublicKey, &from->subjectPublicKey);
  204.     return rv;
  205. }
  207. SECStatus
  208. SECKEY_KEASetParams(KEAParams * params, SECKEYPublicKey * pubKey) {
  210.     if (pubKey->keyType == fortezzaKey) {
  211.         /* the key is a fortezza V1 public key  */
  213. /* obtain hash of pubkey->u.fortezza.params.prime.data +
  214.           pubkey->u.fortezza.params.subPrime.data +
  215.   pubkey->u.fortezza.params.base.data  */
  217. /* store hash in params->hash */
  219.     } else if (pubKey->keyType == keaKey) {
  221.         /* the key is a new fortezza KEA public key. */
  222.         SECITEM_CopyItem(pubKey->arena, &params->hash, 
  223.                  &pubKey->u.kea.params.hash );
  225.     } else {
  227. /* the key has no KEA parameters */
  228. return SECFailure;
  229.     }
  231. }
  234. SECStatus
  235. SECKEY_KEAParamCompare(CERTCertificate *cert1,CERTCertificate *cert2) 
  236. {
  238.     SECStatus rv;
  239.     SECOidData *oid=NULL;
  240.     CERTSubjectPublicKeyInfo * subjectSpki=NULL;
  241.     CERTSubjectPublicKeyInfo * issuerSpki=NULL;
  242.     CERTCertificate *issuerCert = NULL;
  244.     SECKEYPublicKey *pubKey1 = 0;
  245.     SECKEYPublicKey *pubKey2 = 0;
  247.     KEAParams params1;
  248.     KEAParams params2;
  251.     rv = SECFailure;
  253.     /* get cert1's public key */
  254.     pubKey1 = CERT_ExtractPublicKey(cert1);
  255.     if ( !pubKey1 ) {
  256. return(SECFailure);
  257.     }
  258.     
  260.     /* get cert2's public key */
  261.     pubKey2 = CERT_ExtractPublicKey(cert2);
  262.     if ( !pubKey2 ) {
  263. return(SECFailure);
  264.     }
  266.     /* handle the case when both public keys are new
  267.      * fortezza KEA public keys.    */
  269.     if ((pubKey1->keyType == keaKey) &&
  270.         (pubKey2->keyType == keaKey) ) {
  272.         rv = (SECStatus)SECITEM_CompareItem(&pubKey1->u.kea.params.hash,
  273.                          &pubKey2->u.kea.params.hash);
  274. goto done;
  275.     }
  277.     /* handle the case when both public keys are old fortezza
  278.      * public keys.              */
  280.     if ((pubKey1->keyType == fortezzaKey) &&
  281.         (pubKey2->keyType == fortezzaKey) ) {
  283.         rv = (SECStatus)SECITEM_CompareItem(&pubKey1->u.fortezza.keaParams.prime,
  284.                          &pubKey2->u.fortezza.keaParams.prime);
  286. if (rv == SECEqual) {
  287.     rv = (SECStatus)SECITEM_CompareItem(&pubKey1->u.fortezza.keaParams.subPrime,
  288.                              &pubKey2->u.fortezza.keaParams.subPrime);
  289. }
  291. if (rv == SECEqual) {
  292.     rv = (SECStatus)SECITEM_CompareItem(&pubKey1->u.fortezza.keaParams.base,
  293.                              &pubKey2->u.fortezza.keaParams.base);
  294. }
  296. goto done;
  297.     }
  300.     /* handle the case when the public keys are a mixture of 
  301.      * old and new.                          */
  303.     rv = SECKEY_KEASetParams(&params1, pubKey1);
  304.     if (rv != SECSuccess) return rv;
  306.     rv = SECKEY_KEASetParams(&params2, pubKey2);
  307.     if (rv != SECSuccess) return rv;
  309.     rv = (SECStatus)SECITEM_CompareItem(&params1.hash, &params2.hash);
  311. done:
  312.     SECKEY_DestroyPublicKey(pubKey1);
  313.     SECKEY_DestroyPublicKey(pubKey2);
  315.     return rv;   /* returns SECEqual if parameters are equal */
  317. }
  320. /* Procedure to update the pqg parameters for a cert's public key.
  321.  * pqg parameters only need to be updated for DSA and fortezza certificates.
  322.  * The procedure uses calls to itself recursively to update a certificate
  323.  * issuer's pqg parameters.  Some important rules are:
  324.  *    - Do nothing if the cert already has PQG parameters.
  325.  *    - If the cert does not have PQG parameters, obtain them from the issuer.
  326.  *    - A valid cert chain cannot have a DSA or Fortezza cert without
  327.  *      pqg parameters that has a parent that is not a DSA or Fortezza cert.
  328.  *    - pqg paramters are stored in two different formats: the standard
  329.  *      DER encoded format and the fortezza-only wrapped format.  The params
  330.  *      should be copied from issuer to subject cert without modifying the
  331.  *      formats.  The public key extraction code will deal with the different
  332.  *      formats at the time of extraction.  */
  334. SECStatus
  335. seckey_UpdateCertPQGChain(CERTCertificate * subjectCert, int count)
  336. {
  337.     SECStatus rv, rvCompare;
  338.     SECOidData *oid=NULL;
  339.     int tag;
  340.     CERTSubjectPublicKeyInfo * subjectSpki=NULL;
  341.     CERTSubjectPublicKeyInfo * issuerSpki=NULL;
  342.     CERTCertificate *issuerCert = NULL;
  344.     rv = SECSuccess;
  346.     /* increment cert chain length counter*/
  347.     count++;
  349.     /* check if cert chain length exceeds the maximum length*/
  350.     if (count > CERT_MAX_CERT_CHAIN) {
  351. return SECFailure;
  352.     }
  354.     oid = SECOID_FindOID(&subjectCert->subjectPublicKeyInfo.algorithm.algorithm);            
  355.     if (oid != NULL) {  
  356.         tag = oid->offset;
  357.              
  358.         /* Check if cert has a DSA or Fortezza public key. If not, return
  359.          * success since no PQG params need to be updated.  */
  361. if ( (tag != SEC_OID_MISSI_KEA_DSS_OLD) &&
  362.      (tag != SEC_OID_MISSI_DSS_OLD) &&
  363.              (tag != SEC_OID_MISSI_KEA_DSS) &&
  364.              (tag != SEC_OID_MISSI_DSS) &&               
  365.              (tag != SEC_OID_ANSIX9_DSA_SIGNATURE) &&
  366.              (tag != SEC_OID_ANSIX9_DSA_SIGNATURE_WITH_SHA1_DIGEST) &&
  367.              (tag != SEC_OID_BOGUS_DSA_SIGNATURE_WITH_SHA1_DIGEST) ) {
  368.             
  369.             return SECSuccess;
  370.         }
  371.     } else {
  372.         return SECFailure;  /* return failure if oid is NULL */  
  373.     }
  375.     /* if cert has PQG parameters, return success */
  377.     subjectSpki=&subjectCert->subjectPublicKeyInfo;
  379.     if (subjectSpki->algorithm.parameters.len != 0) {
  380.         return SECSuccess;
  381.     }
  383.     /* check if the cert is self-signed */
  384.     rvCompare = (SECStatus)SECITEM_CompareItem(&subjectCert->derSubject,
  385.     &subjectCert->derIssuer);
  386. if (rvCompare == SECEqual) {
  387.   /* fail since cert is self-signed and has no pqg params. */
  388.             return SECFailure;     
  389. }
  390.      
  391.     /* get issuer cert */
  392.     issuerCert = CERT_FindCertIssuer(subjectCert, PR_Now(), certUsageAnyCA);
  393. if ( ! issuerCert ) {
  394.             return SECFailure;
  395. }
  397.     /* if parent is not DSA or fortezza, return failure since
  398.        we don't allow this case. */
  400.     oid = SECOID_FindOID(&issuerCert->subjectPublicKeyInfo.algorithm.algorithm);
  401.     if (oid != NULL) {  
  402.         tag = oid->offset;
  403.              
  404.         /* Check if issuer cert has a DSA or Fortezza public key. If not,
  405.          * return failure.   */
  407. if ( (tag != SEC_OID_MISSI_KEA_DSS_OLD) &&
  408.      (tag != SEC_OID_MISSI_DSS_OLD) &&
  409.              (tag != SEC_OID_MISSI_KEA_DSS) &&
  410.              (tag != SEC_OID_MISSI_DSS) &&               
  411.              (tag != SEC_OID_ANSIX9_DSA_SIGNATURE) &&
  412.              (tag != SEC_OID_ANSIX9_DSA_SIGNATURE_WITH_SHA1_DIGEST) &&
  413.              (tag != SEC_OID_BOGUS_DSA_SIGNATURE_WITH_SHA1_DIGEST) ) {
  414.             
  415.             return SECFailure;
  416.         }
  417.     } else {
  418.         return SECFailure;  /* return failure if oid is NULL */  
  419.     }
  422.     /* at this point the subject cert has no pqg parameters and the
  423.      * issuer cert has a DSA or fortezza public key.  Update the issuer's
  424.      * pqg parameters with a recursive call to this same function. */
  426.     rv = seckey_UpdateCertPQGChain(issuerCert, count);
  427.     if (rv != SECSuccess) return rv;
  429.     /* ensure issuer has pqg parameters */
  431.     issuerSpki=&issuerCert->subjectPublicKeyInfo;
  432.     if (issuerSpki->algorithm.parameters.len == 0) {
  433.         rv = SECFailure; 
  434.     }
  436.     /* if update was successful and pqg params present, then copy the
  437.      * parameters to the subject cert's key. */
  439.     if (rv == SECSuccess) {
  440.         rv = SECITEM_CopyItem(subjectCert->arena,
  441.                               &subjectSpki->algorithm.parameters, 
  442.           &issuerSpki->algorithm.parameters);
  443.     }
  445.     return rv;
  447. }
  448.  
  450. SECStatus
  451. SECKEY_UpdateCertPQG(CERTCertificate * subjectCert)
  452. {
  453.     return(seckey_UpdateCertPQGChain(subjectCert,0));
  454. }
  455.    
  457. /* Decode the PQG parameters.  The params could be stored in two
  458.  * possible formats, the old fortezza-only wrapped format or
  459.  * the standard DER encoded format.   Store the decoded parameters in an
  460.  * old fortezza cert data structure */
  461.  
  462. SECStatus
  463. SECKEY_FortezzaDecodePQGtoOld(PRArenaPool *arena, SECKEYPublicKey *pubk,
  464.                               SECItem *params) {
  465.         SECStatus rv;
  466. PQGDualParams dual_params;
  468.     if (params == NULL) return SECFailure; 
  469.     
  470.     if (params->data == NULL) return SECFailure;
  472.     /* Check if params use the standard format.
  473.      * The value 0xa1 will appear in the first byte of the parameter data
  474.      * if the PQG parameters are not using the standard format. This
  475.      * code should be changed to use a better method to detect non-standard
  476.      * parameters.    */
  478.     if ((params->data[0] != 0xa1) &&
  479.         (params->data[0] != 0xa0)) {
  481.             /* PQG params are in the standard format */
  483.     /* Store DSA PQG parameters */
  484.             rv = SEC_ASN1DecodeItem(arena, &pubk->u.fortezza.params,
  485.                               SECKEY_PQGParamsTemplate,
  486.                               params);
  488.     if (rv == SECSuccess) {
  490.         /* Copy the DSA PQG parameters to the KEA PQG parameters. */
  491.         rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.keaParams.prime,
  492.                                       &pubk->u.fortezza.params.prime);
  493.                 if (rv != SECSuccess) return rv;
  494.                 rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.keaParams.subPrime,
  495.                                       &pubk->u.fortezza.params.subPrime);
  496.                 if (rv != SECSuccess) return rv;
  497.                 rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.keaParams.base,
  498.                                       &pubk->u.fortezza.params.base);
  499.                 if (rv != SECSuccess) return rv;
  500.             }
  502.     } else {
  504. dual_params.CommParams.prime.len = 0;
  505.         dual_params.CommParams.subPrime.len = 0;
  506. dual_params.CommParams.base.len = 0;
  507. dual_params.DiffParams.DiffDSAParams.prime.len = 0;
  508.         dual_params.DiffParams.DiffDSAParams.subPrime.len = 0;
  509. dual_params.DiffParams.DiffDSAParams.base.len = 0;
  511.         /* else the old fortezza-only wrapped format is used. */
  513. if (params->data[0] == 0xa1) {
  514.             rv = SEC_ASN1DecodeItem(arena, &dual_params, 
  515. SECKEY_FortezzaPreParamTemplate, params);
  516. } else {
  517.             rv = SEC_ASN1DecodeItem(arena, &dual_params, 
  518.         SECKEY_FortezzaAltPreParamTemplate, params);
  519.         }
  521.         if (rv < 0) return rv;
  523.         if ( (dual_params.CommParams.prime.len > 0) &&
  524.              (dual_params.CommParams.subPrime.len > 0) && 
  525.              (dual_params.CommParams.base.len > 0) ) {
  526.             /* copy in common params */
  527.     
  528.     rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.params.prime,
  529.                                   &dual_params.CommParams.prime);
  530.             if (rv != SECSuccess) return rv;
  531.             rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.params.subPrime,
  532.                                   &dual_params.CommParams.subPrime);
  533.             if (rv != SECSuccess) return rv;
  534.             rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.params.base,
  535.                                   &dual_params.CommParams.base);
  537.     /* Copy the DSA PQG parameters to the KEA PQG parameters. */
  538.     rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.keaParams.prime,
  539.                                   &pubk->u.fortezza.params.prime);
  540.             if (rv != SECSuccess) return rv;
  541.             rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.keaParams.subPrime,
  542.                                   &pubk->u.fortezza.params.subPrime);
  543.             if (rv != SECSuccess) return rv;
  544.             rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.keaParams.base,
  545.                                   &pubk->u.fortezza.params.base);
  546.             if (rv != SECSuccess) return rv;
  548.         } else {
  550.     /* else copy in different params */
  552.     /* copy DSA PQG parameters */
  553.     rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.params.prime,
  554.                                   &dual_params.DiffParams.DiffDSAParams.prime);
  555.             if (rv != SECSuccess) return rv;
  556.             rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.params.subPrime,
  557.                                   &dual_params.DiffParams.DiffDSAParams.subPrime);
  558.             if (rv != SECSuccess) return rv;
  559.             rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.params.base,
  560.                                   &dual_params.DiffParams.DiffDSAParams.base);
  562.     /* copy KEA PQG parameters */
  564.     rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.keaParams.prime,
  565.                                   &dual_params.DiffParams.DiffKEAParams.prime);
  566.             if (rv != SECSuccess) return rv;
  567.             rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.keaParams.subPrime,
  568.                                   &dual_params.DiffParams.DiffKEAParams.subPrime);
  569.             if (rv != SECSuccess) return rv;
  570.             rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.keaParams.base,
  571.                                   &dual_params.DiffParams.DiffKEAParams.base);
  572.         }
  573.        
  574.     }
  575.     return rv;
  576. }
  579. /* Decode the DSA PQG parameters.  The params could be stored in two
  580.  * possible formats, the old fortezza-only wrapped format or
  581.  * the normal standard format.  Store the decoded parameters in
  582.  * a V3 certificate data structure.  */ 
  584. SECStatus
  585. SECKEY_DSADecodePQG(PRArenaPool *arena, SECKEYPublicKey *pubk, SECItem *params) {
  586.         SECStatus rv;
  587. PQGDualParams dual_params;
  589.     if (params == NULL) return SECFailure; 
  590.     
  591.     if (params->data == NULL) return SECFailure;
  593.     /* Check if params use the standard format.
  594.      * The value 0xa1 will appear in the first byte of the parameter data
  595.      * if the PQG parameters are not using the standard format.  This
  596.      * code should be changed to use a better method to detect non-standard
  597.      * parameters.    */
  599.     if ((params->data[0] != 0xa1) &&
  600.         (params->data[0] != 0xa0)) {
  601.     
  602.          /* PQG params are in the standard format */
  603.          rv = SEC_ASN1DecodeItem(arena, &pubk->u.dsa.params,
  604.                              SECKEY_PQGParamsTemplate,
  605.                              params);
  606.     } else {
  608. dual_params.CommParams.prime.len = 0;
  609.         dual_params.CommParams.subPrime.len = 0;
  610. dual_params.CommParams.base.len = 0;
  611. dual_params.DiffParams.DiffDSAParams.prime.len = 0;
  612.         dual_params.DiffParams.DiffDSAParams.subPrime.len = 0;
  613. dual_params.DiffParams.DiffDSAParams.base.len = 0;
  615.         /* else the old fortezza-only wrapped format is used. */
  616.         if (params->data[0] == 0xa1) {
  617.             rv = SEC_ASN1DecodeItem(arena, &dual_params, 
  618. SECKEY_FortezzaPreParamTemplate, params);
  619. } else {
  620.             rv = SEC_ASN1DecodeItem(arena, &dual_params, 
  621.         SECKEY_FortezzaAltPreParamTemplate, params);
  622.         }
  624.         if (rv < 0) return rv;
  626.         if ( (dual_params.CommParams.prime.len > 0) &&
  627.              (dual_params.CommParams.subPrime.len > 0) && 
  628.              (dual_params.CommParams.base.len > 0) ) {
  629.             /* copy in common params */
  630.     
  631.     rv = SECITEM_CopyItem(arena, &pubk->u.dsa.params.prime,
  632.                                   &dual_params.CommParams.prime);
  633.             if (rv != SECSuccess) return rv;
  634.             rv = SECITEM_CopyItem(arena, &pubk->u.dsa.params.subPrime,
  635.                                   &dual_params.CommParams.subPrime);
  636.             if (rv != SECSuccess) return rv;
  637.             rv = SECITEM_CopyItem(arena, &pubk->u.dsa.params.base,
  638.                                   &dual_params.CommParams.base);
  640.         } else {
  642.     /* else copy in different params */
  644.     /* copy DSA PQG parameters */
  645.     rv = SECITEM_CopyItem(arena, &pubk->u.dsa.params.prime,
  646.                                   &dual_params.DiffParams.DiffDSAParams.prime);
  647.             if (rv != SECSuccess) return rv;
  648.             rv = SECITEM_CopyItem(arena, &pubk->u.dsa.params.subPrime,
  649.                                   &dual_params.DiffParams.DiffDSAParams.subPrime);
  650.             if (rv != SECSuccess) return rv;
  651.             rv = SECITEM_CopyItem(arena, &pubk->u.dsa.params.base,
  652.                                   &dual_params.DiffParams.DiffDSAParams.base);
  654.         }
  655.     }
  656.     return rv;
  657. }
  661. /* Decodes the DER encoded fortezza public key and stores the results in a
  662.  * structure of type SECKEYPublicKey. */
  664. SECStatus
  665. SECKEY_FortezzaDecodeCertKey(PRArenaPool *arena, SECKEYPublicKey *pubk,
  666.                              SECItem *rawkey, SECItem *params) {
  668. unsigned char *rawptr = rawkey->data;
  669. unsigned char *end = rawkey->data + rawkey->len;
  670. unsigned char *clearptr;
  672. /* first march down and decode the raw key data */
  674. /* version */
  675. pubk->u.fortezza.KEAversion = *rawptr++;
  676. if (*rawptr++ != 0x01) {
  677. return SECFailure;
  678. }
  680. /* KMID */
  681. PORT_Memcpy(pubk->u.fortezza.KMID,rawptr,
  682. sizeof(pubk->u.fortezza.KMID));
  683. rawptr += sizeof(pubk->u.fortezza.KMID);
  685. /* clearance (the string up to the first byte with the hi-bit on */
  686. clearptr = rawptr;
  687. while ((rawptr < end) && (*rawptr++ & 0x80));
  689. if (rawptr >= end) { return SECFailure; }
  690. pubk->u.fortezza.clearance.len = rawptr - clearptr;
  691. pubk->u.fortezza.clearance.data = 
  692. (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.clearance.len);
  693. if (pubk->u.fortezza.clearance.data == NULL) {
  694. return SECFailure;
  695. }
  696. PORT_Memcpy(pubk->u.fortezza.clearance.data,clearptr,
  697. pubk->u.fortezza.clearance.len);
  699. /* KEAPrivilege (the string up to the first byte with the hi-bit on */
  700. clearptr = rawptr;
  701. while ((rawptr < end) && (*rawptr++ & 0x80));
  702. if (rawptr >= end) { return SECFailure; }
  703. pubk->u.fortezza.KEApriviledge.len = rawptr - clearptr;
  704. pubk->u.fortezza.KEApriviledge.data = 
  705. (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.KEApriviledge.len);
  706. if (pubk->u.fortezza.KEApriviledge.data == NULL) {
  707. return SECFailure;
  708. }
  709. PORT_Memcpy(pubk->u.fortezza.KEApriviledge.data,clearptr,
  710. pubk->u.fortezza.KEApriviledge.len);
  713. /* now copy the key. The next to bytes are the key length, and the
  714.  * key follows */
  715. pubk->u.fortezza.KEAKey.len = (*rawptr << 8) | rawptr[1];
  717. rawptr += 2;
  718. if (rawptr+pubk->u.fortezza.KEAKey.len > end) { return SECFailure; }
  719. pubk->u.fortezza.KEAKey.data = 
  720. (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.KEAKey.len);
  721. if (pubk->u.fortezza.KEAKey.data == NULL) {
  722. return SECFailure;
  723. }
  724. PORT_Memcpy(pubk->u.fortezza.KEAKey.data,rawptr,
  725. pubk->u.fortezza.KEAKey.len);
  726. rawptr += pubk->u.fortezza.KEAKey.len;
  728. /* shared key */
  729. if (rawptr >= end) {
  730.     pubk->u.fortezza.DSSKey.len = pubk->u.fortezza.KEAKey.len;
  731.     /* this depends on the fact that we are going to get freed with an
  732.      * ArenaFree call. We cannot free DSSKey and KEAKey separately */
  733.     pubk->u.fortezza.DSSKey.data=
  734. pubk->u.fortezza.KEAKey.data;
  735.     pubk->u.fortezza.DSSpriviledge.len = 
  736. pubk->u.fortezza.KEApriviledge.len;
  737.     pubk->u.fortezza.DSSpriviledge.data =
  738. pubk->u.fortezza.DSSpriviledge.data;
  739.     goto done;
  740. }
  743. /* DSS Version is next */
  744. pubk->u.fortezza.DSSversion = *rawptr++;
  746. if (*rawptr++ != 2) {
  747. return SECFailure;
  748. }
  750. /* DSSPrivilege (the string up to the first byte with the hi-bit on */
  751. clearptr = rawptr;
  752. while ((rawptr < end) && (*rawptr++ & 0x80));
  753. if (rawptr >= end) { return SECFailure; }
  754. pubk->u.fortezza.DSSpriviledge.len = rawptr - clearptr;
  755. pubk->u.fortezza.DSSpriviledge.data = 
  756. (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.DSSpriviledge.len);
  757. if (pubk->u.fortezza.DSSpriviledge.data == NULL) {
  758. return SECFailure;
  759. }
  760. PORT_Memcpy(pubk->u.fortezza.DSSpriviledge.data,clearptr,
  761. pubk->u.fortezza.DSSpriviledge.len);
  763. /* finally copy the DSS key. The next to bytes are the key length,
  764.  *  and the key follows */
  765. pubk->u.fortezza.DSSKey.len = (*rawptr << 8) | rawptr[1];
  767. rawptr += 2;
  768. if (rawptr+pubk->u.fortezza.DSSKey.len > end){ return SECFailure; }
  769. pubk->u.fortezza.DSSKey.data = 
  770. (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.DSSKey.len);
  771. if (pubk->u.fortezza.DSSKey.data == NULL) {
  772. return SECFailure;
  773. }
  774. PORT_Memcpy(pubk->u.fortezza.DSSKey.data,rawptr,
  775. pubk->u.fortezza.DSSKey.len);
  777. /* ok, now we decode the parameters */
  778. done:
  780.         return SECKEY_FortezzaDecodePQGtoOld(arena, pubk, params);
  781. }
  784. /* Function used to determine what kind of cert we are dealing with. */
  785. KeyType 
  786. CERT_GetCertKeyType (CERTSubjectPublicKeyInfo *spki) {
  787.     int tag;
  788.     KeyType keyType;
  790.     tag = SECOID_GetAlgorithmTag(&spki->algorithm);
  791.     switch (tag) {
  792.       case SEC_OID_X500_RSA_ENCRYPTION:
  793.       case SEC_OID_PKCS1_RSA_ENCRYPTION:
  794. keyType = rsaKey;
  795. break;
  796.       case SEC_OID_ANSIX9_DSA_SIGNATURE:
  797. keyType = dsaKey;
  798. break;
  799.       case SEC_OID_MISSI_KEA_DSS_OLD:
  800.       case SEC_OID_MISSI_KEA_DSS:
  801.       case SEC_OID_MISSI_DSS_OLD:
  802.       case SEC_OID_MISSI_DSS:  
  803. keyType = fortezzaKey;
  804. break;
  805.       case SEC_OID_MISSI_KEA:
  806.       case SEC_OID_MISSI_ALT_KEA:
  807. keyType = keaKey;
  808. break;
  809.       case SEC_OID_X942_DIFFIE_HELMAN_KEY:
  810. keyType = dhKey;
  811.       default:
  812. keyType = nullKey;
  813.     }
  814.     return keyType;
  815. }
  817. static SECKEYPublicKey *
  818. seckey_ExtractPublicKey(CERTSubjectPublicKeyInfo *spki)
  819. {
  820.     SECKEYPublicKey *pubk;
  821.     SECItem os;
  822.     SECStatus rv;
  823.     PRArenaPool *arena;
  824.     SECOidTag tag;
  826.     arena = PORT_NewArena (DER_DEFAULT_CHUNKSIZE);
  827.     if (arena == NULL)
  828. return NULL;
  830.     pubk = (SECKEYPublicKey *) PORT_ArenaZAlloc(arena, sizeof(SECKEYPublicKey));
  831.     if (pubk == NULL) {
  832. PORT_FreeArena (arena, PR_FALSE);
  833. return NULL;
  834.     }
  836.     pubk->arena = arena;
  837.     pubk->pkcs11Slot = 0;
  838.     pubk->pkcs11ID = CK_INVALID_KEY;
  841.     /* Convert bit string length from bits to bytes */
  842.     os = spki->subjectPublicKey;
  843.     DER_ConvertBitString (&os);
  845.     tag = SECOID_GetAlgorithmTag(&spki->algorithm);
  846.     switch ( tag ) {
  847.       case SEC_OID_X500_RSA_ENCRYPTION:
  848.       case SEC_OID_PKCS1_RSA_ENCRYPTION:
  849. pubk->keyType = rsaKey;
  850. rv = SEC_ASN1DecodeItem(arena, pubk, SECKEY_RSAPublicKeyTemplate, &os);
  851. if (rv == SECSuccess)
  852.     return pubk;
  853. break;
  854.       case SEC_OID_ANSIX9_DSA_SIGNATURE:
  855. pubk->keyType = dsaKey;
  856. rv = SEC_ASN1DecodeItem(arena, pubk, SECKEY_DSAPublicKeyTemplate, &os);
  857. if (rv != SECSuccess) break;
  859.         rv = SECKEY_DSADecodePQG(arena, pubk,
  860.                                  &spki->algorithm.parameters); 
  862. if (rv == SECSuccess) return pubk;
  863. break;
  864.       case SEC_OID_X942_DIFFIE_HELMAN_KEY:
  865. pubk->keyType = dhKey;
  866. rv = SEC_ASN1DecodeItem(arena, pubk, SECKEY_DHPublicKeyTemplate, &os);
  867. if (rv != SECSuccess) break;
  869.         rv = SEC_ASN1DecodeItem(arena, pubk, SECKEY_DHParamKeyTemplate,
  870.                                  &spki->algorithm.parameters); 
  872. if (rv == SECSuccess) return pubk;
  873. break;
  874.       case SEC_OID_MISSI_KEA_DSS_OLD:
  875.       case SEC_OID_MISSI_KEA_DSS:
  876.       case SEC_OID_MISSI_DSS_OLD:
  877.       case SEC_OID_MISSI_DSS:
  878. pubk->keyType = fortezzaKey;
  879. rv = SECKEY_FortezzaDecodeCertKey(arena, pubk, &os,
  880.           &spki->algorithm.parameters);
  881. if (rv == SECSuccess)
  882.     return pubk;
  883. break;
  885.       case SEC_OID_MISSI_KEA:
  886. pubk->keyType = keaKey;
  888.         rv = SEC_ASN1DecodeItem(arena, pubk,
  889.                                 SECKEY_KEAPublicKeyTemplate, &os);
  890.         if (rv != SECSuccess) break;
  893.         rv = SEC_ASN1DecodeItem(arena, pubk, SECKEY_KEAParamsTemplate,
  894.                         &spki->algorithm.parameters);
  896. if (rv == SECSuccess)
  897.     return pubk;
  899.       break;
  901.       case SEC_OID_MISSI_ALT_KEA:
  902. pubk->keyType = keaKey;
  904.         rv = SECITEM_CopyItem(arena,&pubk->u.kea.publicValue,&os);
  905.         if (rv != SECSuccess) break;
  906.  
  907.         rv = SEC_ASN1DecodeItem(arena, pubk, SECKEY_KEAParamsTemplate,
  908.                         &spki->algorithm.parameters);
  910. if (rv == SECSuccess)
  911.     return pubk;
  913.       break;
  916.       default:
  917. rv = SECFailure;
  918. break;
  919.     }
  921.     SECKEY_DestroyPublicKey (pubk);
  922.     return NULL;
  923. }
  925. SECKEYPublicKey *
  926. CERT_ExtractPublicKey(CERTCertificate *cert)
  927. {
  928.     SECStatus rv;
  930.     rv = SECKEY_UpdateCertPQG(cert);
  931.     if (rv != SECSuccess) return NULL;
  933.     return seckey_ExtractPublicKey(&cert->subjectPublicKeyInfo);
  934. }
  936. /*
  937.  * Get the public key for the fortezza KMID. NOTE this requires the
  938.  * PQG paramters to be set. We probably should have a fortezza call that 
  939.  * just extracts the kmid for us directly so this function can work
  940.  * without having the whole cert chain
  941.  */
  942. SECKEYPublicKey *
  943. CERT_KMIDPublicKey(CERTCertificate *cert)
  944. {
  945.     return seckey_ExtractPublicKey(&cert->subjectPublicKeyInfo);
  946. }
  948. /* returns key strength in bytes (not bits) */
  949. unsigned
  950. SECKEY_PublicKeyStrength(SECKEYPublicKey *pubk)
  951. {
  952.     unsigned char b0;
  954.     /* interpret modulus length as key strength... in
  955.      * fortezza that's the public key length */
  957.     switch (pubk->keyType) {
  958.     case rsaKey:
  959.      b0 = pubk->u.rsa.modulus.data[0];
  960.      return b0 ? pubk->u.rsa.modulus.len : pubk->u.rsa.modulus.len - 1;
  961.     case dsaKey:
  962.      b0 = pubk->u.dsa.publicValue.data[0];
  963.      return b0 ? pubk->u.dsa.publicValue.len :
  964.     pubk->u.dsa.publicValue.len - 1;
  965.     case dhKey:
  966.      b0 = pubk->u.dh.publicValue.data[0];
  967.      return b0 ? pubk->u.dh.publicValue.len :
  968.     pubk->u.dh.publicValue.len - 1;
  969.     case fortezzaKey:
  970. return PR_MAX(pubk->u.fortezza.KEAKey.len, pubk->u.fortezza.DSSKey.len);
  971.     default:
  972. break;
  973.     }
  974.     return 0;
  975. }
  977. SECKEYPrivateKey *
  978. SECKEY_CopyPrivateKey(SECKEYPrivateKey *privk)
  979. {
  980.     SECKEYPrivateKey *copyk;
  981.     PRArenaPool *arena;
  982.     
  983.     if (privk == NULL) {
  984. return NULL;
  985.     }
  986.     
  987.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  988.     if (arena == NULL) {
  989. PORT_SetError (SEC_ERROR_NO_MEMORY);
  990. return NULL;
  991.     }
  993.     copyk = (SECKEYPrivateKey *) PORT_ArenaZAlloc (arena, sizeof (SECKEYPrivateKey));
  994.     if (copyk) {
  995. copyk->arena = arena;
  996. copyk->keyType = privk->keyType;
  998. /* copy the PKCS #11 parameters */
  999. copyk->pkcs11Slot = PK11_ReferenceSlot(privk->pkcs11Slot);
  1000. /* if the key we're referencing was a temparary key we have just
  1001.  * created, that we want to go away when we're through, we need
  1002.  * to make a copy of it */
  1003. if (privk->pkcs11IsTemp) {
  1004.     copyk->pkcs11ID = 
  1005. PK11_CopyKey(privk->pkcs11Slot,privk->pkcs11ID);
  1006.     if (copyk->pkcs11ID == CK_INVALID_KEY) goto fail;
  1007. } else {
  1008.     copyk->pkcs11ID = privk->pkcs11ID;
  1009. }
  1010. copyk->pkcs11IsTemp = privk->pkcs11IsTemp;
  1011. copyk->wincx = privk->wincx;
  1012. return copyk;
  1013.     } else {
  1014. PORT_SetError (SEC_ERROR_NO_MEMORY);
  1015.     }
  1017. fail:
  1018.     PORT_FreeArena (arena, PR_FALSE);
  1019.     return NULL;
  1020. }
  1022. SECKEYPublicKey *
  1023. SECKEY_CopyPublicKey(SECKEYPublicKey *pubk)
  1024. {
  1025.     SECKEYPublicKey *copyk;
  1026.     PRArenaPool *arena;
  1027.     
  1028.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1029.     if (arena == NULL) {
  1030. PORT_SetError (SEC_ERROR_NO_MEMORY);
  1031. return NULL;
  1032.     }
  1034.     copyk = (SECKEYPublicKey *) PORT_ArenaZAlloc (arena, sizeof (SECKEYPublicKey));
  1035.     if (copyk != NULL) {
  1036. SECStatus rv = SECSuccess;
  1038. copyk->arena = arena;
  1039. copyk->keyType = pubk->keyType;
  1040. copyk->pkcs11Slot = NULL; /* go get own reference */
  1041. copyk->pkcs11ID = CK_INVALID_KEY;
  1042. switch (pubk->keyType) {
  1043.   case rsaKey:
  1044.     rv = SECITEM_CopyItem(arena, &copyk->u.rsa.modulus,
  1045.   &pubk->u.rsa.modulus);
  1046.     if (rv == SECSuccess) {
  1047. rv = SECITEM_CopyItem (arena, &copyk->u.rsa.publicExponent,
  1048.        &pubk->u.rsa.publicExponent);
  1049. if (rv == SECSuccess)
  1050.     return copyk;
  1051.     }
  1052.     break;
  1053.   case dsaKey:
  1054.     rv = SECITEM_CopyItem(arena, &copyk->u.dsa.publicValue,
  1055.   &pubk->u.dsa.publicValue);
  1056.     if (rv != SECSuccess) break;
  1057.     rv = SECITEM_CopyItem(arena, &copyk->u.dsa.params.prime,
  1058.   &pubk->u.dsa.params.prime);
  1059.     if (rv != SECSuccess) break;
  1060.     rv = SECITEM_CopyItem(arena, &copyk->u.dsa.params.subPrime,
  1061.   &pubk->u.dsa.params.subPrime);
  1062.     if (rv != SECSuccess) break;
  1063.     rv = SECITEM_CopyItem(arena, &copyk->u.dsa.params.base,
  1064.   &pubk->u.dsa.params.base);
  1065.     break;
  1066.           case keaKey:
  1067.             rv = SECITEM_CopyItem(arena, &copyk->u.kea.publicValue,
  1068.                                   &pubk->u.kea.publicValue);
  1069.             if (rv != SECSuccess) break;
  1070.             rv = SECITEM_CopyItem(arena, &copyk->u.kea.params.hash,
  1071.                                   &pubk->u.kea.params.hash);
  1072.             break;
  1073.   case fortezzaKey:
  1074.     copyk->u.fortezza.KEAversion = pubk->u.fortezza.KEAversion;
  1075.     copyk->u.fortezza.DSSversion = pubk->u.fortezza.DSSversion;
  1076.     PORT_Memcpy(copyk->u.fortezza.KMID, pubk->u.fortezza.KMID,
  1077. sizeof(pubk->u.fortezza.KMID));
  1078.     rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.clearance, 
  1079.   &pubk->u.fortezza.clearance);
  1080.     if (rv != SECSuccess) break;
  1081.     rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.KEApriviledge, 
  1082. &pubk->u.fortezza.KEApriviledge);
  1083.     if (rv != SECSuccess) break;
  1084.     rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.DSSpriviledge, 
  1085. &pubk->u.fortezza.DSSpriviledge);
  1086.     if (rv != SECSuccess) break;
  1087.     rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.KEAKey, 
  1088. &pubk->u.fortezza.KEAKey);
  1089.     if (rv != SECSuccess) break;
  1090.     rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.DSSKey, 
  1091. &pubk->u.fortezza.DSSKey);
  1092.     if (rv != SECSuccess) break;
  1093.     rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.params.prime, 
  1094.   &pubk->u.fortezza.params.prime);
  1095.     if (rv != SECSuccess) break;
  1096.     rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.params.subPrime, 
  1097. &pubk->u.fortezza.params.subPrime);
  1098.     if (rv != SECSuccess) break;
  1099.     rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.params.base, 
  1100. &pubk->u.fortezza.params.base);
  1101.             if (rv != SECSuccess) break;
  1102.             rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.keaParams.prime, 
  1103.   &pubk->u.fortezza.keaParams.prime);
  1104.     if (rv != SECSuccess) break;
  1105.     rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.keaParams.subPrime, 
  1106. &pubk->u.fortezza.keaParams.subPrime);
  1107.     if (rv != SECSuccess) break;
  1108.     rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.keaParams.base, 
  1109. &pubk->u.fortezza.keaParams.base);
  1110.     break;
  1111.   case dhKey:
  1112.             rv = SECITEM_CopyItem(arena,&copyk->u.dh.prime,&pubk->u.dh.prime);
  1113.     if (rv != SECSuccess) break;
  1114.     rv = SECITEM_CopyItem(arena,&copyk->u.dh.base,&pubk->u.dh.base);
  1115.     if (rv != SECSuccess) break;
  1116.     rv = SECITEM_CopyItem(arena, &copyk->u.dh.publicValue, 
  1117. &pubk->u.dh.publicValue);
  1118.     break;
  1119.   case nullKey:
  1120.     return copyk;
  1121.   default:
  1122.     rv = SECFailure;
  1123.     break;
  1124. }
  1125. if (rv == SECSuccess)
  1126.     return copyk;
  1128. SECKEY_DestroyPublicKey (copyk);
  1129.     } else {
  1130. PORT_SetError (SEC_ERROR_NO_MEMORY);
  1131.     }
  1133.     PORT_FreeArena (arena, PR_FALSE);
  1134.     return NULL;
  1135. }
  1138. SECKEYPublicKey *
  1139. SECKEY_ConvertToPublicKey(SECKEYPrivateKey *privk)
  1140. {
  1141.     SECKEYPublicKey *pubk;
  1142.     PRArenaPool *arena;
  1143.     CERTCertificate *cert;
  1144.     SECStatus rv;
  1146.     /*
  1147.      * First try to look up the cert.
  1148.      */
  1149.     cert = PK11_GetCertFromPrivateKey(privk);
  1150.     if (cert) {
  1151. pubk = CERT_ExtractPublicKey(cert);
  1152. CERT_DestroyCertificate(cert);
  1153. return pubk;
  1154.     }
  1156.     /* couldn't find the cert, build pub key by hand */
  1157.     arena = PORT_NewArena (DER_DEFAULT_CHUNKSIZE);
  1158.     if (arena == NULL) {
  1159. PORT_SetError (SEC_ERROR_NO_MEMORY);
  1160. return NULL;
  1161.     }
  1162.     pubk = (SECKEYPublicKey *)PORT_ArenaZAlloc(arena,
  1163.    sizeof (SECKEYPublicKey));
  1164.     if (pubk == NULL) {
  1165. PORT_FreeArena(arena,PR_FALSE);
  1166. return NULL;
  1167.     }
  1168.     pubk->keyType = privk->keyType;
  1169.     pubk->pkcs11Slot = NULL;
  1170.     pubk->pkcs11ID = CK_INVALID_KEY;
  1171.     pubk->arena = arena;
  1173.     /*
  1174.      * fortezza is at the head of this switch, since we don't want to
  1175.      * allocate an arena... CERT_ExtractPublicKey will to that for us.
  1176.      */
  1177.     switch(privk->keyType) {
  1178.       case fortezzaKey:
  1179.       case nullKey:
  1180.       case dhKey:
  1181.       case dsaKey:
  1182. /* Nothing to query, if the cert isn't there, we're done -- no way
  1183.  * to get the public key */
  1184. break;
  1185.       case rsaKey:
  1186. rv = PK11_ReadAttribute(privk->pkcs11Slot,privk->pkcs11ID,
  1187. CKA_MODULUS,arena,&pubk->u.rsa.modulus);
  1188. if (rv != SECSuccess)  break;
  1189. rv = PK11_ReadAttribute(privk->pkcs11Slot,privk->pkcs11ID,
  1190. CKA_PUBLIC_EXPONENT,arena,&pubk->u.rsa.publicExponent);
  1191. if (rv != SECSuccess)  break;
  1192. return pubk;
  1193. break;
  1194.     default:
  1195. break;
  1196.     }
  1198.     PORT_FreeArena (arena, PR_FALSE);
  1199.     return NULL;
  1200. }
  1202. CERTSubjectPublicKeyInfo *
  1203. SECKEY_CreateSubjectPublicKeyInfo(SECKEYPublicKey *pubk)
  1204. {
  1205.     CERTSubjectPublicKeyInfo *spki;
  1206.     PRArenaPool *arena;
  1207.     SECItem params = { siBuffer, NULL, 0 };
  1209.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1210.     if (arena == NULL) {
  1211. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1212. return NULL;
  1213.     }
  1215.     spki = (CERTSubjectPublicKeyInfo *) PORT_ArenaZAlloc(arena, sizeof (*spki));
  1216.     if (spki != NULL) {
  1217. SECStatus rv;
  1218. SECItem *rv_item;
  1220. spki->arena = arena;
  1221. switch(pubk->keyType) {
  1222.   case rsaKey:
  1223.     rv = SECOID_SetAlgorithmID(arena, &spki->algorithm,
  1224.      SEC_OID_PKCS1_RSA_ENCRYPTION, 0);
  1225.     if (rv == SECSuccess) {
  1226. /*
  1227.  * DER encode the public key into the subjectPublicKeyInfo.
  1228.  */
  1229. rv_item = SEC_ASN1EncodeItem(arena, &spki->subjectPublicKey,
  1230.      pubk, SECKEY_RSAPublicKeyTemplate);
  1231. if (rv_item != NULL) {
  1232.     /*
  1233.      * The stored value is supposed to be a BIT_STRING,
  1234.      * so convert the length.
  1235.      */
  1236.     spki->subjectPublicKey.len <<= 3;
  1237.     /*
  1238.      * We got a good one; return it.
  1239.      */
  1240.     return spki;
  1241. }
  1242.     }
  1243.     break;
  1244.   case dsaKey:
  1245.     /* DER encode the params. */
  1246.     rv_item = SEC_ASN1EncodeItem(arena, &params, &pubk->u.dsa.params,
  1247.  SECKEY_PQGParamsTemplate);
  1248.     if (rv_item != NULL) {
  1249. rv = SECOID_SetAlgorithmID(arena, &spki->algorithm,
  1250.    SEC_OID_ANSIX9_DSA_SIGNATURE,
  1251.    &params);
  1252. if (rv == SECSuccess) {
  1253.     /*
  1254.      * DER encode the public key into the subjectPublicKeyInfo.
  1255.      */
  1256.     rv_item = SEC_ASN1EncodeItem(arena, &spki->subjectPublicKey,
  1257.  pubk,
  1258.  SECKEY_DSAPublicKeyTemplate);
  1259.     if (rv_item != NULL) {
  1260. /*
  1261.  * The stored value is supposed to be a BIT_STRING,
  1262.  * so convert the length.
  1263.  */
  1264. spki->subjectPublicKey.len <<= 3;
  1265. /*
  1266.  * We got a good one; return it.
  1267.  */
  1268. return spki;
  1269.     }
  1270. }
  1271.     }
  1272.     SECITEM_FreeItem(&params, PR_FALSE);
  1273.     break;
  1274.   case keaKey:
  1275.   case dhKey: /* later... */
  1277.   break;  
  1278.   case fortezzaKey:
  1279. #ifdef notdef
  1280.     /* encode the DSS parameters (PQG) */
  1281.     rv = FortezzaBuildParams(&params,pubk);
  1282.     if (rv != SECSuccess) break;
  1284.     /* set the algorithm */
  1285.     rv = SECOID_SetAlgorithmID(arena, &spki->algorithm,
  1286.        SEC_OID_MISSI_KEA_DSS, &params);
  1287.     PORT_Free(params.data);
  1288.     if (rv == SECSuccess) {
  1289. /*
  1290.  * Encode the public key into the subjectPublicKeyInfo.
  1291.  * Fortezza key material is not standard DER
  1292.  */
  1293. rv = FortezzaEncodeCertKey(arena,&spki->subjectPublicKey,pubk);
  1294. if (rv == SECSuccess) {
  1295.     /*
  1296.      * The stored value is supposed to be a BIT_STRING,
  1297.      * so convert the length.
  1298.      */
  1299.     spki->subjectPublicKey.len <<= 3;
  1301.     /*
  1302.      * We got a good one; return it.
  1303.      */
  1304.     return spki;
  1305. }
  1306.     }
  1307. #endif
  1308.     break;
  1309.   default:
  1310.     break;
  1311. }
  1312.     } else {
  1313. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1314.     }
  1316.     PORT_FreeArena(arena, PR_FALSE);
  1317.     return NULL;
  1318. }
  1320. void
  1321. SECKEY_DestroySubjectPublicKeyInfo(CERTSubjectPublicKeyInfo *spki)
  1322. {
  1323.     if (spki && spki->arena) {
  1324. PORT_FreeArena(spki->arena, PR_FALSE);
  1325.     }
  1326. }
  1328. /*
  1329.  * this only works for RSA keys... need to do something
  1330.  * similiar to CERT_ExtractPublicKey for other key times.
  1331.  */
  1332. SECKEYPublicKey *
  1333. SECKEY_DecodeDERPublicKey(SECItem *pubkder)
  1334. {
  1335.     PRArenaPool *arena;
  1336.     SECKEYPublicKey *pubk;
  1337.     SECStatus rv;
  1339.     arena = PORT_NewArena (DER_DEFAULT_CHUNKSIZE);
  1340.     if (arena == NULL) {
  1341. PORT_SetError (SEC_ERROR_NO_MEMORY);
  1342. return NULL;
  1343.     }
  1345.     pubk = (SECKEYPublicKey *) PORT_ArenaZAlloc (arena, sizeof (SECKEYPublicKey));
  1346.     if (pubk != NULL) {
  1347. pubk->arena = arena;
  1348. pubk->pkcs11Slot = NULL;
  1349. pubk->pkcs11ID = 0;
  1350. rv = SEC_ASN1DecodeItem(arena, pubk, SECKEY_RSAPublicKeyTemplate,
  1351. pubkder);
  1352. if (rv == SECSuccess)
  1353.     return pubk;
  1354. SECKEY_DestroyPublicKey (pubk);
  1355.     } else {
  1356. PORT_SetError (SEC_ERROR_NO_MEMORY);
  1357.     }
  1359.     PORT_FreeArena (arena, PR_FALSE);
  1360.     return NULL;
  1361. }
  1363. /*
  1364.  * Decode a base64 ascii encoded DER encoded public key.
  1365.  */
  1366. SECKEYPublicKey *
  1367. SECKEY_ConvertAndDecodePublicKey(char *pubkstr)
  1368. {
  1369.     SECKEYPublicKey *pubk;
  1370.     SECStatus rv;
  1371.     SECItem der;
  1373.     rv = ATOB_ConvertAsciiToItem (&der, pubkstr);
  1374.     if (rv != SECSuccess)
  1375. return NULL;
  1377.     pubk = SECKEY_DecodeDERPublicKey (&der);
  1379.     PORT_Free (der.data);
  1380.     return pubk;
  1381. }
  1383. CERTSubjectPublicKeyInfo *
  1384. SECKEY_DecodeDERSubjectPublicKeyInfo(SECItem *spkider)
  1385. {
  1386.     PRArenaPool *arena;
  1387.     CERTSubjectPublicKeyInfo *spki;
  1388.     SECStatus rv;
  1390.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1391.     if (arena == NULL) {
  1392. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1393. return NULL;
  1394.     }
  1396.     spki = (CERTSubjectPublicKeyInfo *)
  1397. PORT_ArenaZAlloc(arena, sizeof (CERTSubjectPublicKeyInfo));
  1398.     if (spki != NULL) {
  1399. spki->arena = arena;
  1400. rv = SEC_ASN1DecodeItem(arena,spki,
  1401. CERT_SubjectPublicKeyInfoTemplate,spkider);
  1402. if (rv == SECSuccess)
  1403.     return spki;
  1404. SECKEY_DestroySubjectPublicKeyInfo(spki);
  1405.     } else {
  1406. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1407.     }
  1409.     PORT_FreeArena(arena, PR_FALSE);
  1410.     return NULL;
  1411. }
  1413. /*
  1414.  * Decode a base64 ascii encoded DER encoded subject public key info.
  1415.  */
  1416. CERTSubjectPublicKeyInfo *
  1417. SECKEY_ConvertAndDecodeSubjectPublicKeyInfo(char *spkistr)
  1418. {
  1419.     CERTSubjectPublicKeyInfo *spki;
  1420.     SECStatus rv;
  1421.     SECItem der;
  1423.     rv = ATOB_ConvertAsciiToItem(&der, spkistr);
  1424.     if (rv != SECSuccess)
  1425. return NULL;
  1427.     spki = SECKEY_DecodeDERSubjectPublicKeyInfo(&der);
  1429.     PORT_Free(der.data);
  1430.     return spki;
  1431. }
  1433. /*
  1434.  * Decode a base64 ascii encoded DER encoded public key and challenge
  1435.  * Verify digital signature and make sure challenge matches
  1436.  */
  1437. CERTSubjectPublicKeyInfo *
  1438. SECKEY_ConvertAndDecodePublicKeyAndChallenge(char *pkacstr, char *challenge,
  1439. void *wincx)
  1440. {
  1441.     CERTSubjectPublicKeyInfo *spki = NULL;
  1442.     CERTPublicKeyAndChallenge pkac;
  1443.     SECStatus rv;
  1444.     SECItem signedItem;
  1445.     PRArenaPool *arena = NULL;
  1446.     CERTSignedData sd;
  1447.     SECItem sig;
  1448.     SECKEYPublicKey *pubKey = NULL;
  1449.     int len;
  1450.     
  1451.     signedItem.data = NULL;
  1452.     
  1453.     /* convert the base64 encoded data to binary */
  1454.     rv = ATOB_ConvertAsciiToItem(&signedItem, pkacstr);
  1455.     if (rv != SECSuccess) {
  1456. goto loser;
  1457.     }
  1459.     /* create an arena */
  1460.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1461.     if (arena == NULL) {
  1462. goto loser;
  1463.     }
  1465.     /* decode the outer wrapping of signed data */
  1466.     PORT_Memset(&sd, 0, sizeof(CERTSignedData));
  1467.     rv = SEC_ASN1DecodeItem(arena, &sd, CERT_SignedDataTemplate, &signedItem );
  1468.     if ( rv ) {
  1469. goto loser;
  1470.     }
  1472.     /* decode the public key and challenge wrapper */
  1473.     PORT_Memset(&pkac, 0, sizeof(CERTPublicKeyAndChallenge));
  1474.     rv = SEC_ASN1DecodeItem(arena, &pkac, CERT_PublicKeyAndChallengeTemplate, 
  1475.     &sd.data);
  1476.     if ( rv ) {
  1477. goto loser;
  1478.     }
  1480.     /* decode the subject public key info */
  1481.     spki = SECKEY_DecodeDERSubjectPublicKeyInfo(&pkac.spki);
  1482.     if ( spki == NULL ) {
  1483. goto loser;
  1484.     }
  1485.     
  1486.     /* get the public key */
  1487.     pubKey = seckey_ExtractPublicKey(spki);
  1488.     if ( pubKey == NULL ) {
  1489. goto loser;
  1490.     }
  1492.     /* check the signature */
  1493.     sig = sd.signature;
  1494.     DER_ConvertBitString(&sig);
  1495.     rv = VFY_VerifyData(sd.data.data, sd.data.len, pubKey, &sig,
  1496. SECOID_GetAlgorithmTag(&(sd.signatureAlgorithm)), wincx);
  1497.     if ( rv != SECSuccess ) {
  1498. goto loser;
  1499.     }
  1500.     
  1501.     /* check the challenge */
  1502.     if ( challenge ) {
  1503. len = PORT_Strlen(challenge);
  1504. /* length is right */
  1505. if ( len != pkac.challenge.len ) {
  1506.     goto loser;
  1507. }
  1508. /* actual data is right */
  1509. if ( PORT_Memcmp(challenge, pkac.challenge.data, len) != 0 ) {
  1510.     goto loser;
  1511. }
  1512.     }
  1513.     goto done;
  1515. loser:
  1516.     /* make sure that we return null if we got an error */
  1517.     if ( spki ) {
  1518. SECKEY_DestroySubjectPublicKeyInfo(spki);
  1519.     }
  1520.     spki = NULL;
  1521.     
  1522. done:
  1523.     if ( signedItem.data ) {
  1524. PORT_Free(signedItem.data);
  1525.     }
  1526.     if ( arena ) {
  1527. PORT_FreeArena(arena, PR_FALSE);
  1528.     }
  1529.     if ( pubKey ) {
  1530. SECKEY_DestroyPublicKey(pubKey);
  1531.     }
  1532.     
  1533.     return spki;
  1534. }
  1536. void
  1537. SECKEY_DestroyPrivateKeyInfo(SECKEYPrivateKeyInfo *pvk,
  1538.      PRBool freeit)
  1539. {
  1540.     PRArenaPool *poolp;
  1542.     if(pvk != NULL) {
  1543. if(pvk->arena) {
  1544.     poolp = pvk->arena;
  1545.     /* zero structure since PORT_FreeArena does not support
  1546.      * this yet.
  1547.      */
  1548.     PORT_Memset(pvk->privateKey.data, 0, pvk->privateKey.len);
  1549.     PORT_Memset((char *)pvk, 0, sizeof(*pvk));
  1550.     if(freeit == PR_TRUE) {
  1551. PORT_FreeArena(poolp, PR_TRUE);
  1552.     } else {
  1553. pvk->arena = poolp;
  1554.     }
  1555. } else {
  1556.     SECITEM_ZfreeItem(&pvk->version, PR_FALSE);
  1557.     SECITEM_ZfreeItem(&pvk->privateKey, PR_FALSE);
  1558.     SECOID_DestroyAlgorithmID(&pvk->algorithm, PR_FALSE);
  1559.     PORT_Memset((char *)pvk, 0, sizeof(pvk));
  1560.     if(freeit == PR_TRUE) {
  1561. PORT_Free(pvk);
  1562.     }
  1563. }
  1564.     }
  1565. }
  1567. void
  1568. SECKEY_DestroyEncryptedPrivateKeyInfo(SECKEYEncryptedPrivateKeyInfo *epki,
  1569.       PRBool freeit)
  1570. {
  1571.     PRArenaPool *poolp;
  1573.     if(epki != NULL) {
  1574. if(epki->arena) {
  1575.     poolp = epki->arena;
  1576.     /* zero structure since PORT_FreeArena does not support
  1577.      * this yet.
  1578.      */
  1579.     PORT_Memset(epki->encryptedData.data, 0, epki->encryptedData.len);
  1580.     PORT_Memset((char *)epki, 0, sizeof(*epki));
  1581.     if(freeit == PR_TRUE) {
  1582. PORT_FreeArena(poolp, PR_TRUE);
  1583.     } else {
  1584. epki->arena = poolp;
  1585.     }
  1586. } else {
  1587.     SECITEM_ZfreeItem(&epki->encryptedData, PR_FALSE);
  1588.     SECOID_DestroyAlgorithmID(&epki->algorithm, PR_FALSE);
  1589.     PORT_Memset((char *)epki, 0, sizeof(epki));
  1590.     if(freeit == PR_TRUE) {
  1591. PORT_Free(epki);
  1592.     }
  1593. }
  1594.     }
  1595. }
  1597. SECStatus
  1598. SECKEY_CopyPrivateKeyInfo(PRArenaPool *poolp,
  1599.   SECKEYPrivateKeyInfo *to,
  1600.   SECKEYPrivateKeyInfo *from)
  1601. {
  1602.     SECStatus rv = SECFailure;
  1604.     if((to == NULL) || (from == NULL)) {
  1605. return SECFailure;
  1606.     }
  1608.     rv = SECOID_CopyAlgorithmID(poolp, &to->algorithm, &from->algorithm);
  1609.     if(rv != SECSuccess) {
  1610. return SECFailure;
  1611.     }
  1612.     rv = SECITEM_CopyItem(poolp, &to->privateKey, &from->privateKey);
  1613.     if(rv != SECSuccess) {
  1614. return SECFailure;
  1615.     }
  1616.     rv = SECITEM_CopyItem(poolp, &to->version, &from->version);
  1618.     return rv;
  1619. }
  1621. SECStatus
  1622. SECKEY_CopyEncryptedPrivateKeyInfo(PRArenaPool *poolp, 
  1623.    SECKEYEncryptedPrivateKeyInfo *to,
  1624.    SECKEYEncryptedPrivateKeyInfo *from)
  1625. {
  1626.     SECStatus rv = SECFailure;
  1628.     if((to == NULL) || (from == NULL)) {
  1629. return SECFailure;
  1630.     }
  1632.     rv = SECOID_CopyAlgorithmID(poolp, &to->algorithm, &from->algorithm);
  1633.     if(rv != SECSuccess) {
  1634. return SECFailure;
  1635.     }
  1636.     rv = SECITEM_CopyItem(poolp, &to->encryptedData, &from->encryptedData);
  1638.     return rv;
  1639. }
  1641. KeyType
  1642. SECKEY_GetPrivateKeyType(SECKEYPrivateKey *privKey)
  1643. {
  1644.    return privKey->keyType;
  1645. }
  1647. KeyType
  1648. SECKEY_GetPublicKeyType(SECKEYPublicKey *pubKey)
  1649. {
  1650.    return pubKey->keyType;
  1651. }