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

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

CA认证

开发平台：

WINDOWS

secname.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. #include "cert.h"
  35. #include "secoid.h"
  36. #include "secder.h" /* XXX remove this when remove the DERTemplates */
  37. #include "secasn1.h"
  38. #include "secitem.h"
  39. #include <stdarg.h>
  40. #include "secerr.h"
  42. static const SEC_ASN1Template cert_AVATemplate[] = {
  43.     { SEC_ASN1_SEQUENCE,
  44.   0, NULL, sizeof(CERTAVA) },
  45.     { SEC_ASN1_OBJECT_ID,
  46.   offsetof(CERTAVA,type), },
  47.     { SEC_ASN1_ANY,
  48.   offsetof(CERTAVA,value), },
  49.     { 0, }
  50. };
  52. const SEC_ASN1Template CERT_RDNTemplate[] = {
  53.     { SEC_ASN1_SET_OF,
  54.   offsetof(CERTRDN,avas), cert_AVATemplate, sizeof(CERTRDN) }
  55. };
  58. static int
  59. CountArray(void **array)
  60. {
  61.     int count = 0;
  62.     if (array) {
  63. while (*array++) {
  64.     count++;
  65. }
  66.     }
  67.     return count;
  68. }
  70. static void
  71. **AddToArray(PRArenaPool *arena, void **array, void *element)
  72. {
  73.     unsigned count;
  74.     void **ap;
  76.     /* Count up number of slots already in use in the array */
  77.     count = 0;
  78.     ap = array;
  79.     if (ap) {
  80. while (*ap++) {
  81.     count++;
  82. }
  83.     }
  85.     if (array) {
  86. array = (void**) PORT_ArenaGrow(arena, array,
  87. (count + 1) * sizeof(void *),
  88. (count + 2) * sizeof(void *));
  89.     } else {
  90. array = (void**) PORT_ArenaAlloc(arena, (count + 2) * sizeof(void *));
  91.     }
  92.     if (array) {
  93. array[count] = element;
  94. array[count+1] = 0;
  95.     }
  96.     return array;
  97. }
  99. #if 0
  100. static void
  101. **RemoveFromArray(void **array, void *element)
  102. {
  103.     unsigned count;
  104.     void **ap;
  105.     int slot;
  107.     /* Look for element */
  108.     ap = array;
  109.     if (ap) {
  110. count = 1; /* count the null at the end */
  111. slot = -1;
  112. for (; *ap; ap++, count++) {
  113.     if (*ap == element) {
  114. /* Found it */
  115. slot = ap - array;
  116.     }
  117. }
  118. if (slot >= 0) {
  119.     /* Found it. Squish array down */
  120.     PORT_Memmove((void*) (array + slot), (void*) (array + slot + 1),
  121.        (count - slot - 1) * sizeof(void*));
  122.     /* Don't bother reallocing the memory */
  123. }
  124.     }
  125.     return array;
  126. }
  127. #endif /* 0 */
  129. SECOidTag
  130. CERT_GetAVATag(CERTAVA *ava)
  131. {
  132.     SECOidData *oid;
  133.     if (!ava->type.data) return (SECOidTag)-1;
  135.     oid = SECOID_FindOID(&ava->type);
  136.     
  137.     if ( oid ) {
  138. return(oid->offset);
  139.     }
  140.     return (SECOidTag)-1;
  141. }
  143. static SECStatus
  144. SetupAVAType(PRArenaPool *arena, SECOidTag type, SECItem *it, unsigned *maxLenp)
  145. {
  146.     unsigned char *oid;
  147.     unsigned oidLen;
  148.     unsigned char *cp;
  149.     unsigned maxLen;
  150.     SECOidData *oidrec;
  152.     oidrec = SECOID_FindOIDByTag(type);
  153.     if (oidrec == NULL)
  154. return SECFailure;
  156.     oid = oidrec->oid.data;
  157.     oidLen = oidrec->oid.len;
  159.     switch (type) {
  160.       case SEC_OID_AVA_COUNTRY_NAME:
  161. maxLen = 2;
  162. break;
  163.       case SEC_OID_AVA_ORGANIZATION_NAME:
  164. maxLen = 64;
  165. break;
  166.       case SEC_OID_AVA_COMMON_NAME:
  167. maxLen = 64;
  168. break;
  169.       case SEC_OID_AVA_LOCALITY:
  170. maxLen = 128;
  171. break;
  172.       case SEC_OID_AVA_STATE_OR_PROVINCE:
  173. maxLen = 128;
  174. break;
  175.       case SEC_OID_AVA_ORGANIZATIONAL_UNIT_NAME:
  176. maxLen = 64;
  177. break;
  178.       case SEC_OID_AVA_DC:
  179. maxLen = 128;
  180. break;
  181.       case SEC_OID_AVA_DN_QUALIFIER:
  182. maxLen = 0x7fff;
  183. break;
  184.       case SEC_OID_PKCS9_EMAIL_ADDRESS:
  185. maxLen = 128;
  186. break;
  187.       case SEC_OID_RFC1274_UID:
  188. maxLen = 256;  /* RFC 1274 specifies 256 */
  189. break;
  190.       case SEC_OID_RFC1274_MAIL:
  191. maxLen = 256;  /* RFC 1274 specifies 256 */
  192. break; 
  193.       default:
  194. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  195. return SECFailure;
  196.     }
  198.     it->data = cp = (unsigned char*) PORT_ArenaAlloc(arena, oidLen);
  199.     if (cp == NULL) {
  200. return SECFailure;
  201.     }
  202.     it->len = oidLen;
  203.     PORT_Memcpy(cp, oid, oidLen);
  204.     *maxLenp = maxLen;
  205.     return SECSuccess;
  206. }
  208. static SECStatus
  209. SetupAVAValue(PRArenaPool *arena, int valueType, char *value, SECItem *it,
  210.       unsigned maxLen)
  211. {
  212.     unsigned valueLen, valueLenLen, total;
  213.     unsigned ucs4Len = 0, ucs4MaxLen;
  214.     unsigned char *cp, *ucs4Val;
  216.     switch (valueType) {
  217.       case SEC_ASN1_PRINTABLE_STRING:
  218.       case SEC_ASN1_IA5_STRING:
  219.       case SEC_ASN1_T61_STRING:
  220. valueLen = PORT_Strlen(value);
  221. break;
  222.       case SEC_ASN1_UNIVERSAL_STRING:
  223. valueLen = PORT_Strlen(value);
  224. ucs4Val = (unsigned char *)PORT_ArenaZAlloc(arena, 
  225.     PORT_Strlen(value) * 6);
  226. ucs4MaxLen = PORT_Strlen(value) * 6;
  227. if(!ucs4Val || !PORT_UCS4_UTF8Conversion(PR_TRUE, (unsigned char *)value, valueLen,
  228. ucs4Val, ucs4MaxLen, &ucs4Len)) {
  229.     PORT_SetError(SEC_ERROR_INVALID_ARGS);
  230.     return SECFailure;
  231. }
  232. value = (char *)ucs4Val;
  233. valueLen = ucs4Len;
  234. break;
  235.       default:
  236. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  237. return SECFailure;
  238.     }
  240.     if (((valueType != SEC_ASN1_UNIVERSAL_STRING) && (valueLen > maxLen)) ||
  241. (valueType == SEC_ASN1_UNIVERSAL_STRING) && (valueLen > (maxLen * 4))) {
  242. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  243. return SECFailure;
  244.     } 
  246.     valueLenLen = DER_LengthLength(valueLen);
  247.     total = 1 + valueLenLen + valueLen;
  248.     it->data = cp = (unsigned char*) PORT_ArenaAlloc(arena, total);
  249.     if (!cp) {
  250. return SECFailure;
  251.     }
  252.     it->len = total;
  253.     cp = (unsigned char*) DER_StoreHeader(cp, valueType, valueLen);
  254.     PORT_Memcpy(cp, value, valueLen);
  255.     return SECSuccess;
  256. }
  258. CERTAVA *
  259. CERT_CreateAVA(PRArenaPool *arena, SECOidTag kind, int valueType, char *value)
  260. {
  261.     CERTAVA *ava;
  262.     int rv;
  263.     unsigned maxLen;
  265.     ava = (CERTAVA*) PORT_ArenaZAlloc(arena, sizeof(CERTAVA));
  266.     if (ava) {
  267. rv = SetupAVAType(arena, kind, &ava->type, &maxLen);
  268. if (rv) {
  269.     /* Illegal AVA type */
  270.     return 0;
  271. }
  272. rv = SetupAVAValue(arena, valueType, value, &ava->value, maxLen);
  273. if (rv) {
  274.     /* Illegal value type */
  275.     return 0;
  276. }
  277.     }
  278.     return ava;
  279. }
  281. CERTAVA *
  282. CERT_CopyAVA(PRArenaPool *arena, CERTAVA *from)
  283. {
  284.     CERTAVA *ava;
  285.     int rv;
  287.     ava = (CERTAVA*) PORT_ArenaZAlloc(arena, sizeof(CERTAVA));
  288.     if (ava) {
  289. rv = SECITEM_CopyItem(arena, &ava->type, &from->type);
  290. if (rv) goto loser;
  291. rv = SECITEM_CopyItem(arena, &ava->value, &from->value);
  292. if (rv) goto loser;
  293.     }
  294.     return ava;
  296.   loser:
  297.     return 0;
  298. }
  300. /************************************************************************/
  301. /* XXX This template needs to go away in favor of the new SEC_ASN1 version. */
  302. static const SEC_ASN1Template cert_RDNTemplate[] = {
  303.     { SEC_ASN1_SET_OF,
  304.   offsetof(CERTRDN,avas), cert_AVATemplate, sizeof(CERTRDN) }
  305. };
  308. CERTRDN *
  309. CERT_CreateRDN(PRArenaPool *arena, CERTAVA *ava0, ...)
  310. {
  311.     CERTAVA *ava;
  312.     CERTRDN *rdn;
  313.     va_list ap;
  314.     unsigned count;
  315.     CERTAVA **avap;
  317.     rdn = (CERTRDN*) PORT_ArenaAlloc(arena, sizeof(CERTRDN));
  318.     if (rdn) {
  319. /* Count number of avas going into the rdn */
  320. count = 1;
  321. va_start(ap, ava0);
  322. while ((ava = va_arg(ap, CERTAVA*)) != 0) {
  323.     count++;
  324. }
  325. va_end(ap);
  327. /* Now fill in the pointers */
  328. rdn->avas = avap =
  329.     (CERTAVA**) PORT_ArenaAlloc( arena, (count + 1)*sizeof(CERTAVA*));
  330. if (!avap) {
  331.     return 0;
  332. }
  333. *avap++ = ava0;
  334. va_start(ap, ava0);
  335. while ((ava = va_arg(ap, CERTAVA*)) != 0) {
  336.     *avap++ = ava;
  337. }
  338. va_end(ap);
  339. *avap++ = 0;
  340.     }
  341.     return rdn;
  342. }
  344. SECStatus
  345. CERT_AddAVA(PRArenaPool *arena, CERTRDN *rdn, CERTAVA *ava)
  346. {
  347.     rdn->avas = (CERTAVA**) AddToArray(arena, (void**) rdn->avas, ava);
  348.     return rdn->avas ? SECSuccess : SECFailure;
  349. }
  351. SECStatus
  352. CERT_CopyRDN(PRArenaPool *arena, CERTRDN *to, CERTRDN *from)
  353. {
  354.     CERTAVA **avas, *fava, *tava;
  355.     SECStatus rv;
  357.     /* Copy each ava from from */
  358.     avas = from->avas;
  359.     while ((fava = *avas++) != 0) {
  360. tava = CERT_CopyAVA(arena, fava);
  361. if (!tava) return SECFailure;
  362. rv = CERT_AddAVA(arena, to, tava);
  363. if (rv) return rv;
  364.     }
  365.     return SECSuccess;
  366. }
  368. /************************************************************************/
  370. const SEC_ASN1Template CERT_NameTemplate[] = {
  371.     { SEC_ASN1_SEQUENCE_OF,
  372.   offsetof(CERTName,rdns), CERT_RDNTemplate, sizeof(CERTName) }
  373. };
  375. CERTName *
  376. CERT_CreateName(CERTRDN *rdn0, ...)
  377. {
  378.     CERTRDN *rdn;
  379.     CERTName *name;
  380.     va_list ap;
  381.     unsigned count;
  382.     CERTRDN **rdnp;
  383.     PRArenaPool *arena;
  384.     
  385.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  386.     if ( !arena ) {
  387. return(0);
  388.     }
  389.     
  390.     name = (CERTName*) PORT_ArenaAlloc(arena, sizeof(CERTName));
  391.     if (name) {
  392. name->arena = arena;
  394. /* Count number of RDNs going into the Name */
  395. if (!rdn0) {
  396.     count = 0;
  397. } else {
  398.     count = 1;
  399.     va_start(ap, rdn0);
  400.     while ((rdn = va_arg(ap, CERTRDN*)) != 0) {
  401. count++;
  402.     }
  403.     va_end(ap);
  404. }
  406. /* Allocate space (including space for terminal null ptr) */
  407. name->rdns = rdnp =
  408.     (CERTRDN**) PORT_ArenaAlloc(arena, (count + 1) * sizeof(CERTRDN*));
  409. if (!name->rdns) {
  410.     goto loser;
  411. }
  413. /* Now fill in the pointers */
  414. if (count > 0) {
  415.     *rdnp++ = rdn0;
  416.     va_start(ap, rdn0);
  417.     while ((rdn = va_arg(ap, CERTRDN*)) != 0) {
  418. *rdnp++ = rdn;
  419.     }
  420.     va_end(ap);
  421. }
  423. /* null terminate the list */
  424. *rdnp++ = 0;
  425.     }
  426.     return name;
  428. loser:
  429.     PORT_FreeArena(arena, PR_FALSE);
  430.     return(0);
  431. }
  433. void
  434. CERT_DestroyName(CERTName *name)
  435. {
  436.     if (name)
  437.     {
  438.         PRArenaPool *arena = name->arena;
  439.         name->rdns = NULL;
  440. name->arena = NULL;
  441. if (arena) PORT_FreeArena(arena, PR_FALSE);
  442.     }
  443. }
  445. SECStatus
  446. CERT_AddRDN(CERTName *name, CERTRDN *rdn)
  447. {
  448.     name->rdns = (CERTRDN**) AddToArray(name->arena, (void**) name->rdns, rdn);
  449.     return name->rdns ? SECSuccess : SECFailure;
  450. }
  452. SECStatus
  453. CERT_CopyName(PRArenaPool *arena, CERTName *to, CERTName *from)
  454. {
  455.     CERTRDN **rdns, *frdn, *trdn;
  456.     SECStatus rv;
  458.     CERT_DestroyName(to);
  459.     to->arena = arena;
  461.     /* Copy each rdn from from */
  462.     rdns = from->rdns;
  463.     while ((frdn = *rdns++) != 0) {
  464. trdn = CERT_CreateRDN(arena, 0);
  465. if ( trdn == NULL ) {
  466.     return(SECFailure);
  467. }
  468. rv = CERT_CopyRDN(arena, trdn, frdn);
  469. if (rv) return rv;
  470. rv = CERT_AddRDN(to, trdn);
  471. if (rv) return rv;
  472.     }
  473.     return SECSuccess;
  474. }
  476. /************************************************************************/
  478. SECComparison
  479. CERT_CompareAVA(CERTAVA *a, CERTAVA *b)
  480. {
  481.     SECComparison rv;
  483.     rv = SECITEM_CompareItem(&a->type, &b->type);
  484.     if (rv) {
  485. /*
  486. ** XXX for now we are going to just assume that a bitwise
  487. ** comparison of the value codes will do the trick.
  488. */
  489.     }
  490.     rv = SECITEM_CompareItem(&a->value, &b->value);
  491.     return rv;
  492. }
  494. SECComparison
  495. CERT_CompareRDN(CERTRDN *a, CERTRDN *b)
  496. {
  497.     CERTAVA **aavas, *aava;
  498.     CERTAVA **bavas, *bava;
  499.     int ac, bc;
  500.     SECComparison rv = SECEqual;
  502.     aavas = a->avas;
  503.     bavas = b->avas;
  505.     /*
  506.     ** Make sure array of ava's are the same length. If not, then we are
  507.     ** not equal
  508.     */
  509.     ac = CountArray((void**) aavas);
  510.     bc = CountArray((void**) bavas);
  511.     if (ac < bc) return SECLessThan;
  512.     if (ac > bc) return SECGreaterThan;
  514.     for (;;) {
  515. aava = *aavas++;
  516. bava = *bavas++;
  517. if (!aava) {
  518.     break;
  519. }
  520. rv = CERT_CompareAVA(aava, bava);
  521. if (rv) return rv;
  522.     }
  523.     return rv;
  524. }
  526. SECComparison
  527. CERT_CompareName(CERTName *a, CERTName *b)
  528. {
  529.     CERTRDN **ardns, *ardn;
  530.     CERTRDN **brdns, *brdn;
  531.     int ac, bc;
  532.     SECComparison rv = SECEqual;
  534.     ardns = a->rdns;
  535.     brdns = b->rdns;
  537.     /*
  538.     ** Make sure array of rdn's are the same length. If not, then we are
  539.     ** not equal
  540.     */
  541.     ac = CountArray((void**) ardns);
  542.     bc = CountArray((void**) brdns);
  543.     if (ac < bc) return SECLessThan;
  544.     if (ac > bc) return SECGreaterThan;
  546.     for (;;) {
  547. ardn = *ardns++;
  548. brdn = *brdns++;
  549. if (!ardn) {
  550.     break;
  551. }
  552. rv = CERT_CompareRDN(ardn, brdn);
  553. if (rv) return rv;
  554.     }
  555.     return rv;
  556. }
  558. /* Moved from certhtml.c */
  559. SECItem *
  560. CERT_DecodeAVAValue(SECItem *derAVAValue)
  561. {
  562.           SECItem          *retItem; 
  563.     const SEC_ASN1Template *theTemplate       = NULL;
  564.           PRBool            convertUCS4toUTF8 = PR_FALSE;
  565.           PRBool            convertUCS2toUTF8 = PR_FALSE;
  566.           SECItem           avaValue          = {siBuffer, 0}; 
  568.     if(!derAVAValue) {
  569. return NULL;
  570.     }
  572.     switch(derAVAValue->data[0]) {
  573. case SEC_ASN1_UNIVERSAL_STRING:
  574.     convertUCS4toUTF8 = PR_TRUE;
  575.     theTemplate = SEC_UniversalStringTemplate;
  576.     break;
  577. case SEC_ASN1_IA5_STRING:
  578.     theTemplate = SEC_IA5StringTemplate;
  579.     break;
  580. case SEC_ASN1_PRINTABLE_STRING:
  581.     theTemplate = SEC_PrintableStringTemplate;
  582.     break;
  583. case SEC_ASN1_T61_STRING:
  584.     theTemplate = SEC_T61StringTemplate;
  585.     break;
  586. case SEC_ASN1_BMP_STRING:
  587.     convertUCS2toUTF8 = PR_TRUE;
  588.     theTemplate = SEC_BMPStringTemplate;
  589.     break;
  590. case SEC_ASN1_UTF8_STRING:
  591.     /* No conversion needed ! */
  592.     theTemplate = SEC_UTF8StringTemplate;
  593.     break;
  594. default:
  595.     return NULL;
  596.     }
  598.     PORT_Memset(&avaValue, 0, sizeof(SECItem));
  599.     if(SEC_ASN1DecodeItem(NULL, &avaValue, theTemplate, derAVAValue) 
  600. != SECSuccess) {
  601. return NULL;
  602.     }
  604.     if (convertUCS4toUTF8) {
  605. unsigned int   utf8ValLen = avaValue.len * 3;
  606. unsigned char *utf8Val    = (unsigned char*)PORT_ZAlloc(utf8ValLen);
  608. if(!PORT_UCS4_UTF8Conversion(PR_FALSE, avaValue.data, avaValue.len,
  609.      utf8Val, utf8ValLen, &utf8ValLen)) {
  610.     PORT_Free(utf8Val);
  611.     PORT_Free(avaValue.data);
  612.     return NULL;
  613. }
  615. PORT_Free(avaValue.data);
  616. avaValue.data = utf8Val;
  617. avaValue.len = utf8ValLen;
  619.     } else if (convertUCS2toUTF8) {
  621. unsigned int   utf8ValLen = avaValue.len * 3;
  622. unsigned char *utf8Val    = (unsigned char*)PORT_ZAlloc(utf8ValLen);
  624. if(!PORT_UCS2_UTF8Conversion(PR_FALSE, avaValue.data, avaValue.len,
  625.      utf8Val, utf8ValLen, &utf8ValLen)) {
  626.     PORT_Free(utf8Val);
  627.     PORT_Free(avaValue.data);
  628.     return NULL;
  629. }
  631. PORT_Free(avaValue.data);
  632. avaValue.data = utf8Val;
  633. avaValue.len = utf8ValLen;
  634.     }
  636.     retItem = SECITEM_DupItem(&avaValue);
  637.     PORT_Free(avaValue.data);
  638.     return retItem;
  639. }