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

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

CA认证

开发平台：

WINDOWS

pkcs11u.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. /*
  34.  * Internal PKCS #11 functions. Should only be called by pkcs11.c
  35.  */
  36. #include "pkcs11.h"
  37. #include "pkcs11i.h"
  38. #include "key.h"
  39. #include "certdb.h"
  42. /* declare the internal pkcs11 slot structures:
  43.  *  There are threee:
  44.  * slot 0 is the generic crypto service token.
  45.  * slot 1 is the Database service token.
  46.  * slot 2 is the FIPS token (both generic and database).
  47.  */
  48. static PK11Slot pk11_slot[3];
  50. /*
  51.  * ******************** Attribute Utilities *******************************
  52.  */
  54. /*
  55.  * create a new attribute with type, value, and length. Space is allocated
  56.  * to hold value.
  57.  */
  58. static PK11Attribute *
  59. pk11_NewAttribute(PK11Object *object,
  60. CK_ATTRIBUTE_TYPE type, CK_VOID_PTR value, CK_ULONG len)
  61. {
  62.     PK11Attribute *attribute;
  64. #ifdef NO_ARENA
  65.     int index;
  66.     /* 
  67.      * NO_ARENA attempts to keep down contention on Malloc and Arena locks
  68.      * by limiting the number of these calls on high traversed paths. this
  69.      * is done for attributes by 'allocating' them from a pool already allocated
  70.      * by the parent object.
  71.      */
  72.     PK11_USE_THREADS(PR_Lock(object->attributeLock);)
  73.     index = object->nextAttr++;
  74.     PK11_USE_THREADS(PR_Unlock(object->attributeLock);)
  75.     PORT_Assert(index < MAX_OBJS_ATTRS);
  76.     if (index >= MAX_OBJS_ATTRS) return NULL;
  78.     attribute = &object->attrList[index];
  79.     attribute->attrib.type = type;
  80.     if (value) {
  81.         if (len <= ATTR_SPACE) {
  82.     attribute->attrib.pValue = attribute->space;
  83. } else {
  84.     attribute->attrib.pValue = PORT_Alloc(len);
  85. }
  86. if (attribute->attrib.pValue == NULL) {
  87.     return NULL;
  88. }
  89. PORT_Memcpy(attribute->attrib.pValue,value,len);
  90. attribute->attrib.ulValueLen = len;
  91.     } else {
  92. attribute->attrib.pValue = NULL;
  93. attribute->attrib.ulValueLen = 0;
  94.     }
  95. #else
  96. #ifdef REF_COUNT_ATTRIBUTE
  97.     attribute = (PK11Attribute*)PORT_Alloc(sizeof(PK11Attribute));
  98. #else
  99.     attribute = (PK11Attribute*)PORT_ArenaAlloc(object->arena,sizeof(PK11Attribute));
  100. #endif /* REF_COUNT_ATTRIBUTE */
  101.     if (attribute == NULL) return NULL;
  103.     if (value) {
  104. #ifdef REF_COUNT_ATTRIBUTE
  105. attribute->attrib.pValue = PORT_Alloc(len);
  106. #else
  107. attribute->attrib.pValue = PORT_ArenaAlloc(object->arena,len);
  108. #endif /* REF_COUNT_ATTRIBUTE */
  109. if (attribute->attrib.pValue == NULL) {
  110. #ifdef REF_COUNT_ATTRIBUTE
  111.     PORT_Free(attribute);
  112. #endif /* REF_COUNT_ATTRIBUTE */
  113.     return NULL;
  114. }
  115. PORT_Memcpy(attribute->attrib.pValue,value,len);
  116. attribute->attrib.ulValueLen = len;
  117.     } else {
  118. attribute->attrib.pValue = NULL;
  119. attribute->attrib.ulValueLen = 0;
  120.     }
  121. #endif /* NO_ARENA */
  122.     attribute->attrib.type = type;
  123.     attribute->handle = type;
  124.     attribute->next = attribute->prev = NULL;
  125. #ifdef REF_COUNT_ATTRIBUTE
  126.     attribute->refCount = 1;
  127. #ifdef PKCS11_USE_THREADS
  128.     attribute->refLock = PR_NewLock();
  129.     if (attribute->refLock == NULL) {
  130. if (attribute->attrib.pValue) PORT_Free(attribute->attrib.pValue);
  131. PORT_Free(attribute);
  132. return NULL;
  133.     }
  134. #else
  135.     attribute->refLock = NULL;
  136. #endif
  137. #endif /* REF_COUNT_ATTRIBUTE */
  138.     return attribute;
  139. }
  141. /*
  142.  * Free up all the memory associated with an attribute. Reference count
  143.  * must be zero to call this.
  144.  */
  145. static void
  146. pk11_DestroyAttribute(PK11Attribute *attribute)
  147. {
  148. #ifdef REF_COUNT_ATTRIBUTE
  149.     PORT_Assert(attribute->refCount == 0);
  150.     PK11_USE_THREADS(PR_DestroyLock(attribute->refLock);)
  151.     if (attribute->attrib.pValue) {
  152.  /* clear out the data in the attribute value... it may have been
  153.   * sensitive data */
  154.  PORT_Memset(attribute->attrib.pValue,0,attribute->attrib.ulValueLen);
  155.  PORT_Free(attribute->attrib.pValue);
  156.     }
  157.     PORT_Free(attribute);
  158. #endif
  159. }
  160.     
  161.     
  162. /*
  163.  * look up and attribute structure from a type and Object structure.
  164.  * The returned attribute is referenced and needs to be freed when 
  165.  * it is no longer needed.
  166.  */
  167. PK11Attribute *
  168. pk11_FindAttribute(PK11Object *object,CK_ATTRIBUTE_TYPE type)
  169. {
  170.     PK11Attribute *attribute;
  172.     PK11_USE_THREADS(PR_Lock(object->attributeLock);)
  173.     pk11queue_find(attribute,type,object->head,ATTRIBUTE_HASH_SIZE);
  174. #ifdef REF_COUNT_ATTRIBUTE
  175.     if (attribute) {
  176. /* atomic increment would be nice here */
  177. PK11_USE_THREADS(PR_Lock(attribute->refLock);)
  178. attribute->refCount++;
  179. PK11_USE_THREADS(PR_Unlock(attribute->refLock);)
  180.     }
  181. #endif
  182.     PK11_USE_THREADS(PR_Unlock(object->attributeLock);)
  184.     return(attribute);
  185. }
  188. /*
  189.  * release a reference to an attribute structure
  190.  */
  191. void
  192. pk11_FreeAttribute(PK11Attribute *attribute)
  193. {
  194. #ifdef REF_COUNT_ATTRIBUTE
  195.     PRBool destroy = PR_FALSE;
  197.     PK11_USE_THREADS(PR_Lock(attribute->refLock);)
  198.     if (attribute->refCount == 1) destroy = PR_TRUE;
  199.     attribute->refCount--;
  200.     PK11_USE_THREADS(PR_Unlock(attribute->refLock);)
  202.     if (destroy) pk11_DestroyAttribute(attribute);
  203. #endif
  204. }
  207. /*
  208.  * return true if object has attribute
  209.  */
  210. PRBool
  211. pk11_hasAttribute(PK11Object *object,CK_ATTRIBUTE_TYPE type)
  212. {
  213.     PK11Attribute *attribute;
  215.     PK11_USE_THREADS(PR_Lock(object->attributeLock);)
  216.     pk11queue_find(attribute,type,object->head,ATTRIBUTE_HASH_SIZE);
  217.     PK11_USE_THREADS(PR_Unlock(object->attributeLock);)
  219.     return (PRBool)(attribute != NULL);
  220. }
  222. /*
  223.  * add an attribute to an object
  224.  */
  225. static
  226. void pk11_AddAttribute(PK11Object *object,PK11Attribute *attribute)
  227. {
  228.     PK11_USE_THREADS(PR_Lock(object->attributeLock);)
  229.     pk11queue_add(attribute,attribute->handle,object->head,ATTRIBUTE_HASH_SIZE);
  230.     PK11_USE_THREADS(PR_Unlock(object->attributeLock);)
  231. }
  233. /* 
  234.  * copy an unsigned attribute into a 'signed' SECItem. Secitem is allocated in
  235.  * the specified arena.
  236.  */
  237. CK_RV
  238. pk11_Attribute2SSecItem(PLArenaPool *arena,SECItem *item,PK11Object *object,
  239.                                       CK_ATTRIBUTE_TYPE type)
  240. {
  241.     int len;
  242.     PK11Attribute *attribute;
  243.     unsigned char *start;
  244.     int real_len;
  246.     attribute = pk11_FindAttribute(object, type);
  247.     if (attribute == NULL) return CKR_TEMPLATE_INCOMPLETE;
  248.     real_len = len = attribute->attrib.ulValueLen;
  249.     if ((*((unsigned char *)attribute->attrib.pValue) & 0x80) != 0) {
  250. real_len++;
  251.     }
  253.     if (arena) {
  254. start = item->data = (unsigned char *) PORT_ArenaAlloc(arena,real_len);
  255.     } else {
  256. start = item->data = (unsigned char *) PORT_Alloc(real_len);
  257.     }
  258.     if (item->data == NULL) {
  259. pk11_FreeAttribute(attribute);
  260. return CKR_HOST_MEMORY;
  261.     }
  262.     item->len = real_len;
  263.     if (real_len != len) {
  264. *start = 0;
  265. start++;
  266.     }
  267.     PORT_Memcpy(start, attribute->attrib.pValue, len);
  268.     pk11_FreeAttribute(attribute);
  269.     return CKR_OK;
  270. }
  273. /*
  274.  * delete an attribute from an object
  275.  */
  276. static void
  277. pk11_DeleteAttribute(PK11Object *object, PK11Attribute *attribute)
  278. {
  279.     PK11_USE_THREADS(PR_Lock(object->attributeLock);)
  280.     if (pk11queue_is_queued(attribute,attribute->handle,
  281. object->head,ATTRIBUTE_HASH_SIZE)) {
  282. pk11queue_delete(attribute,attribute->handle,
  283. object->head,ATTRIBUTE_HASH_SIZE);
  284.     }
  285.     PK11_USE_THREADS(PR_Unlock(object->attributeLock);)
  286.     pk11_FreeAttribute(attribute);
  287. }
  289. /*
  290.  * this is only valid for CK_BBOOL type attributes. Return the state
  291.  * of that attribute.
  292.  */
  293. PRBool
  294. pk11_isTrue(PK11Object *object,CK_ATTRIBUTE_TYPE type)
  295. {
  296.     PK11Attribute *attribute;
  297.     PRBool tok = PR_FALSE;
  299.     attribute=pk11_FindAttribute(object,type);
  300.     if (attribute == NULL) { return PR_FALSE; }
  301.     tok = (PRBool)(*(CK_BBOOL *)attribute->attrib.pValue);
  302.     pk11_FreeAttribute(attribute);
  304.     return tok;
  305. }
  307. /*
  308.  * force an attribute to null.
  309.  * this is for sensitive keys which are stored in the database, we don't
  310.  * want to keep this info around in memory in the clear.
  311.  */
  312. void
  313. pk11_nullAttribute(PK11Object *object,CK_ATTRIBUTE_TYPE type)
  314. {
  315.     PK11Attribute *attribute;
  317.     attribute=pk11_FindAttribute(object,type);
  318.     if (attribute == NULL) return;
  320.     if (attribute->attrib.pValue != NULL) {
  321. PORT_Memset(attribute->attrib.pValue,0,attribute->attrib.ulValueLen);
  322. #ifdef REF_COUNT_ATTRIBUTE
  323. PORT_Free(attribute->attrib.pValue);
  324. #endif /* REF_COUNT_ATTRIBUTE */
  325. #ifdef NO_ARENA
  326. if (attribute->attrib.pValue != attribute->space) {
  327.     PORT_Free(attribute->attrib.pValue);
  328. }
  329. #endif /* NO_ARENA */
  330. attribute->attrib.pValue = NULL;
  331. attribute->attrib.ulValueLen = 0;
  332.     }
  333.     pk11_FreeAttribute(attribute);
  334. }
  336. /*
  337.  * force an attribute to a spaecif value.
  338.  */
  339. CK_RV
  340. pk11_forceAttribute(PK11Object *object,CK_ATTRIBUTE_TYPE type, void *value,
  341. unsigned int len)
  342. {
  343.     PK11Attribute *attribute;
  344.     void *att_val = NULL;
  346.     attribute=pk11_FindAttribute(object,type);
  347.     if (attribute == NULL) return pk11_AddAttributeType(object,type,value,len);
  350.     if (value) {
  351. #ifdef NO_ARENA
  352.         if (len <= ATTR_SPACE) {
  353.     att_val = attribute->space;
  354. } else {
  355.     att_val = PORT_Alloc(len);
  356. }
  357. #else
  358. #ifdef REF_COUNT_ATTRIBUTE
  359. att_val = PORT_Alloc(len);
  360. #else
  361. att_val = PORT_ArenaAlloc(object->arena,len);
  362. #endif /* REF_COUNT_ATTRIBUTE */
  363. #endif /* NO_ARENA */
  364. if (att_val == NULL) {
  365.     return CKR_HOST_MEMORY;
  366. }
  367. if (attribute->attrib.pValue == att_val) {
  368.     PORT_Memset(attribute->attrib.pValue,0,
  369. attribute->attrib.ulValueLen);
  370. }
  371. PORT_Memcpy(att_val,value,len);
  372.     }
  373.     if (attribute->attrib.pValue != NULL) {
  374. if (attribute->attrib.pValue != att_val) {
  375.     PORT_Memset(attribute->attrib.pValue,0,
  376. attribute->attrib.ulValueLen);
  377. }
  378. #ifdef REF_COUNT_ATTRIBUTE
  379. PORT_Free(attribute->attrib.pValue);
  380. #endif /* REF_COUNT_ATTRIBUTE */
  381. #ifdef NO_ARENA
  382. if (attribute->attrib.pValue != attribute->space) {
  383.     PORT_Free(attribute->attrib.pValue);
  384. }
  385. #endif /* NO_ARENA */
  386. attribute->attrib.pValue = NULL;
  387. attribute->attrib.ulValueLen = 0;
  388.     }
  389.     if (att_val) {
  390. attribute->attrib.pValue = att_val;
  391. attribute->attrib.ulValueLen = len;
  392.     }
  393.     return CKR_OK;
  394. }
  396. /*
  397.  * return a null terminated string from attribute 'type'. This string
  398.  * is allocated and needs to be freed with PORT_Free() When complete.
  399.  */
  400. char *
  401. pk11_getString(PK11Object *object,CK_ATTRIBUTE_TYPE type)
  402. {
  403.     PK11Attribute *attribute;
  404.     char *label = NULL;
  406.     attribute=pk11_FindAttribute(object,type);
  407.     if (attribute == NULL) return NULL;
  409.     if (attribute->attrib.pValue != NULL) {
  410. label = (char *) PORT_Alloc(attribute->attrib.ulValueLen+1);
  411. if (label == NULL) {
  412.          pk11_FreeAttribute(attribute);
  413.     return NULL;
  414. }
  416. PORT_Memcpy(label,attribute->attrib.pValue,
  417. attribute->attrib.ulValueLen);
  418. label[attribute->attrib.ulValueLen] = 0;
  419.     }
  420.     pk11_FreeAttribute(attribute);
  421.     return label;
  422. }
  424. /*
  425.  * decode when a particular attribute may be modified
  426.  *  PK11_NEVER: This attribute must be set at object creation time and
  427.  *  can never be modified.
  428.  * PK11_ONCOPY: This attribute may be modified only when you copy the
  429.  *  object.
  430.  * PK11_SENSITIVE: The CKA_SENSITIVE attribute can only be changed from
  431.  *  CK_FALSE to CK_TRUE.
  432.  * PK11_ALWAYS: This attribute can always be modified.
  433.  * Some attributes vary their modification type based on the class of the 
  434.  *   object.
  435.  */
  436. PK11ModifyType
  437. pk11_modifyType(CK_ATTRIBUTE_TYPE type, CK_OBJECT_CLASS inClass)
  438. {
  439.     /* if we don't know about it, user user defined, always allow modify */
  440.     PK11ModifyType mtype = PK11_ALWAYS; 
  442.     switch(type) {
  443.     /* NEVER */
  444.     case CKA_CLASS:
  445.     case CKA_CERTIFICATE_TYPE:
  446.     case CKA_KEY_TYPE:
  447.     case CKA_MODULUS:
  448.     case CKA_MODULUS_BITS:
  449.     case CKA_PUBLIC_EXPONENT:
  450.     case CKA_PRIVATE_EXPONENT:
  451.     case CKA_PRIME:
  452.     case CKA_SUBPRIME:
  453.     case CKA_BASE:
  454.     case CKA_PRIME_1:
  455.     case CKA_PRIME_2:
  456.     case CKA_EXPONENT_1:
  457.     case CKA_EXPONENT_2:
  458.     case CKA_COEFFICIENT:
  459.     case CKA_VALUE_LEN:
  460.     case CKA_ALWAYS_SENSITIVE:
  461.     case CKA_NEVER_EXTRACTABLE:
  462.     case CKA_NETSCAPE_DB:
  463. mtype = PK11_NEVER;
  464. break;
  466.     /* ONCOPY */
  467.     case CKA_TOKEN:
  468.     case CKA_PRIVATE:
  469.     case CKA_MODIFIABLE:
  470. mtype = PK11_ONCOPY;
  471. break;
  473.     /* SENSITIVE */
  474.     case CKA_SENSITIVE:
  475.     case CKA_EXTRACTABLE:
  476. mtype = PK11_SENSITIVE;
  477. break;
  479.     /* ALWAYS */
  480.     case CKA_LABEL:
  481.     case CKA_APPLICATION:
  482.     case CKA_ID:
  483.     case CKA_SERIAL_NUMBER:
  484.     case CKA_START_DATE:
  485.     case CKA_END_DATE:
  486.     case CKA_DERIVE:
  487.     case CKA_ENCRYPT:
  488.     case CKA_DECRYPT:
  489.     case CKA_SIGN:
  490.     case CKA_VERIFY:
  491.     case CKA_SIGN_RECOVER:
  492.     case CKA_VERIFY_RECOVER:
  493.     case CKA_WRAP:
  494.     case CKA_UNWRAP:
  495. mtype = PK11_ALWAYS;
  496. break;
  498.     /* DEPENDS ON CLASS */
  499.     case CKA_VALUE:
  500. mtype = (inClass == CKO_DATA) ? PK11_ALWAYS : PK11_NEVER;
  501. break;
  503.     case CKA_SUBJECT:
  504. mtype = (inClass == CKO_CERTIFICATE) ? PK11_NEVER : PK11_ALWAYS;
  505. break;
  506.     default:
  507. break;
  508.     }
  509.     return mtype;
  510. }
  512. /* decode if a particular attribute is sensitive (cannot be read
  513.  * back to the user of if the object is set to SENSITIVE) */
  514. PRBool
  515. pk11_isSensitive(CK_ATTRIBUTE_TYPE type, CK_OBJECT_CLASS inClass)
  516. {
  517.     switch(type) {
  518.     /* ALWAYS */
  519.     case CKA_PRIVATE_EXPONENT:
  520.     case CKA_PRIME_1:
  521.     case CKA_PRIME_2:
  522.     case CKA_EXPONENT_1:
  523.     case CKA_EXPONENT_2:
  524.     case CKA_COEFFICIENT:
  525. return PR_TRUE;
  527.     /* DEPENDS ON CLASS */
  528.     case CKA_VALUE:
  529. /* PRIVATE and SECRET KEYS have SENSITIVE values */
  530. return (PRBool)((inClass == CKO_PRIVATE_KEY) || (inClass == CKO_SECRET_KEY));
  532.     default:
  533. break;
  534.     }
  535.     return PR_FALSE;
  536. }
  538. /* 
  539.  * copy an attribute into a SECItem. Secitem is allocated in the specified
  540.  * arena.
  541.  */
  542. CK_RV
  543. pk11_Attribute2SecItem(PLArenaPool *arena,SECItem *item,PK11Object *object,
  544. CK_ATTRIBUTE_TYPE type)
  545. {
  546.     int len;
  547.     PK11Attribute *attribute;
  549.     attribute = pk11_FindAttribute(object, type);
  550.     if (attribute == NULL) return CKR_TEMPLATE_INCOMPLETE;
  551.     len = attribute->attrib.ulValueLen;
  553.     if (arena) {
  554.      item->data = (unsigned char *) PORT_ArenaAlloc(arena,len);
  555.     } else {
  556.      item->data = (unsigned char *) PORT_Alloc(len);
  557.     }
  558.     if (item->data == NULL) {
  559. pk11_FreeAttribute(attribute);
  560. return CKR_HOST_MEMORY;
  561.     }
  562.     item->len = len;
  563.     PORT_Memcpy(item->data,attribute->attrib.pValue, len);
  564.     pk11_FreeAttribute(attribute);
  565.     return CKR_OK;
  566. }
  568. void
  569. pk11_DeleteAttributeType(PK11Object *object,CK_ATTRIBUTE_TYPE type)
  570. {
  571.     PK11Attribute *attribute;
  572.     attribute = pk11_FindAttribute(object, type);
  573.     if (attribute == NULL) return ;
  574.     pk11_DeleteAttribute(object,attribute);
  575.     pk11_FreeAttribute(attribute);
  576. }
  578. CK_RV
  579. pk11_AddAttributeType(PK11Object *object,CK_ATTRIBUTE_TYPE type,void *valPtr,
  580. CK_ULONG length)
  581. {
  582.     PK11Attribute *attribute;
  583.     attribute = pk11_NewAttribute(object,type,valPtr,length);
  584.     if (attribute == NULL) { return CKR_HOST_MEMORY; }
  585.     pk11_AddAttribute(object,attribute);
  586.     return CKR_OK;
  587. }
  589. /*
  590.  * ******************** Object Utilities *******************************
  591.  */
  593. /* allocation hooks that allow us to recycle old object structures */
  594. #ifdef MAX_OBJECT_LIST_SIZE
  595. static PK11Object * objectFreeList = NULL;
  596. static PRLock *objectLock = NULL;
  597. static int object_count = 0;
  598. #endif
  599. PK11Object *
  600. pk11_GetObjectFromList(PRBool *hasLocks) {
  601.     PK11Object *object;
  603. #if MAX_OBJECT_LIST_SIZE
  604.     if (objectLock == NULL) {
  605. objectLock = PR_NewLock();
  606.     }
  608.     PK11_USE_THREADS(PR_Lock(objectLock));
  609.     object = objectFreeList;
  610.     if (object) {
  611. objectFreeList = object->next;
  612. object_count--;
  613.     }    
  614.     PK11_USE_THREADS(PR_Unlock(objectLock));
  615.     if (object) {
  616. object->next = object->prev = NULL;
  617.         *hasLocks = PR_TRUE;
  618. return object;
  619.     }
  620. #endif
  622.     object  = (PK11Object*)PORT_ZAlloc(sizeof(PK11Object));
  623.     *hasLocks = PR_FALSE;
  624.     return object;
  625. }
  627. static void
  628. pk11_PutObjectToList(PK11Object *object) {
  629. #ifdef MAX_OBJECT_LIST_SIZE
  630.     if (object_count < MAX_OBJECT_LIST_SIZE) {
  631. PK11_USE_THREADS(PR_Lock(objectLock));
  632. object->next = objectFreeList;
  633. objectFreeList = object;
  634. object_count++;
  635. PK11_USE_THREADS(PR_Unlock(objectLock));
  636. return;
  637.      }
  638. #endif
  639.     PK11_USE_THREADS(PR_DestroyLock(object->attributeLock);)
  640.     PK11_USE_THREADS(PR_DestroyLock(object->refLock);)
  641.     object->attributeLock = object->refLock = NULL;
  642.     PORT_Free(object);
  643. }
  646. /*
  647.  * Create a new object
  648.  */
  649. PK11Object *
  650. pk11_NewObject(PK11Slot *slot)
  651. {
  652.     PK11Object *object;
  653.     PLArenaPool *arena;
  654.     PRBool hasLocks = PR_FALSE;
  655.     int i;
  658. #ifdef NO_ARENA
  659.     object = pk11_GetObjectFromList(&hasLocks);
  660.     if (object == NULL) {
  661. return NULL;
  662.     }
  663.     object->nextAttr = 0;
  664. #else
  665.     arena = PORT_NewArena(2048);
  666.     if (arena == NULL) return NULL;
  668.     object = (PK11Object*)PORT_ArenaAlloc(arena,sizeof(PK11Object));
  669.     if (object == NULL) {
  670. PORT_FreeArena(arena,PR_FALSE);
  671. return NULL;
  672.     }
  673.     object->arena = arena;
  675.     for (i=0; i < MAX_OBJS_ATTRS; i++) {
  676. object->attrList[i].attrib.pValue = NULL;
  677.     }
  678. #endif
  680.     object->handle = 0;
  681.     object->next = object->prev = NULL;
  682.     object->sessionList.next = NULL;
  683.     object->sessionList.prev = NULL;
  684.     object->sessionList.parent = object;
  685.     object->inDB = PR_FALSE;
  686.     object->label = NULL;
  687.     object->refCount = 1;
  688.     object->session = NULL;
  689.     object->slot = slot;
  690.     object->objclass = 0xffff;
  691.     object->wasDerived = PR_FALSE;
  692. #ifdef PKCS11_USE_THREADS
  693.     if (!hasLocks) object->refLock = PR_NewLock();
  694.     if (object->refLock == NULL) {
  695. #ifdef NO_ARENA
  696. PORT_Free(object);
  697. #else
  698. PORT_FreeArena(arena,PR_FALSE);
  699. #endif
  700. return NULL;
  701.     }
  702.     if (!hasLocks) object->attributeLock = PR_NewLock();
  703.     if (object->attributeLock == NULL) {
  704. PK11_USE_THREADS(PR_DestroyLock(object->refLock);)
  705. #ifdef NO_ARENA
  706. PORT_Free(object);
  707. #else
  708. PORT_FreeArena(arena,PR_FALSE);
  709. #endif
  710. return NULL;
  711.     }
  712. #else
  713.     object->attributeLock = NULL;
  714.     object->refLock = NULL;
  715. #endif
  716.     for (i=0; i < ATTRIBUTE_HASH_SIZE; i++) {
  717. object->head[i] = NULL;
  718.     }
  719.     object->objectInfo = NULL;
  720.     object->infoFree = NULL;
  721.     return object;
  722. }
  724. /*
  725.  * free all the data associated with an object. Object reference count must
  726.  * be 'zero'.
  727.  */
  728. static CK_RV
  729. pk11_DestroyObject(PK11Object *object)
  730. {
  731. #if defined(REF_COUNT_ATTRIBUTE) || defined(NO_ARENA)
  732.     int i;
  733. #endif
  734.     SECItem pubKey;
  735.     CK_RV crv = CKR_OK;
  736.     SECStatus rv;
  737.     PLArenaPool *arena = NULL;
  739.     PORT_Assert(object->refCount == 0);
  741.     /* delete the database value */
  742.     if (object->inDB) {
  743. if (pk11_isToken(object->handle)) {
  744. /* remove the objects from the real data base */
  745.     switch (object->handle & PK11_TOKEN_TYPE_MASK) {
  746.       case PK11_TOKEN_TYPE_PRIV:
  747. /* KEYID is the public KEY for DSA and DH, and the MODULUS for
  748.  *  RSA */
  749. crv=pk11_Attribute2SecItem(NULL,&pubKey,object,CKA_NETSCAPE_DB);
  750. if (crv != CKR_OK) break;
  751. rv = SECKEY_DeleteKey(SECKEY_GetDefaultKeyDB(), &pubKey);
  752. if (rv != SECSuccess) crv= CKR_DEVICE_ERROR;
  753. break;
  754.       case PK11_TOKEN_TYPE_CERT:
  755. rv = SEC_DeletePermCertificate((CERTCertificate *)object->objectInfo);
  756. if (rv != SECSuccess) crv = CKR_DEVICE_ERROR;
  757. break;
  758.     }
  759. }
  760.     } 
  761.     if (object->label) PORT_Free(object->label);
  763.     object->inDB = PR_FALSE;
  764.     object->label = NULL;
  766. #ifdef NO_ARENA
  767.     for (i=0; i < MAX_OBJS_ATTRS; i++) {
  768. unsigned char *value = object->attrList[i].attrib.pValue;
  769. if (value) {
  770.     PORT_Memset(value,0,object->attrList[i].attrib.ulValueLen);
  771.     if (value != object->attrList[i].space) {
  772. PORT_Free(value);
  773.     }
  774.     object->attrList[i].attrib.pValue = NULL;
  775. }
  776.     }
  777. #endif
  779. #ifdef REF_COUNT_ATTRIBUTE
  780.     /* clean out the attributes */
  781.     /* since no one is referencing us, it's safe to walk the chain
  782.      * without a lock */
  783.     for (i=0; i < ATTRIBUTE_HASH_SIZE; i++) {
  784. PK11Attribute *ap,*next;
  785. for (ap = object->head[i]; ap != NULL; ap = next) {
  786.     next = ap->next;
  787.     /* paranoia */
  788.     ap->next = ap->prev = NULL;
  789.     pk11_FreeAttribute(ap);
  790. }
  791. object->head[i] = NULL;
  792.     }
  793. #endif
  794.     if (object->objectInfo) {
  795. (*object->infoFree)(object->objectInfo);
  796.     }
  797. #ifdef NO_ARENA
  798.     pk11_PutObjectToList(object);
  799. #else
  800.     PK11_USE_THREADS(PR_DestroyLock(object->attributeLock);)
  801.     PK11_USE_THREADS(PR_DestroyLock(object->refLock);)
  802.     arena = object->arena;
  803.     PORT_FreeArena(arena,PR_FALSE);
  804. #endif
  805.     return crv;
  806. }
  808. void
  809. pk11_ReferenceObject(PK11Object *object)
  810. {
  811.     PK11_USE_THREADS(PR_Lock(object->refLock);)
  812.     object->refCount++;
  813.     PK11_USE_THREADS(PR_Unlock(object->refLock);)
  814. }
  816. static PK11Object *
  817. pk11_ObjectFromHandleOnSlot(CK_OBJECT_HANDLE handle, PK11Slot *slot)
  818. {
  819.     PK11Object **head;
  820.     PRLock *lock;
  821.     PK11Object *object;
  823.     head = slot->tokObjects;
  824.     lock = slot->objectLock;
  826.     PK11_USE_THREADS(PR_Lock(lock);)
  827.     pk11queue_find(object,handle,head,TOKEN_OBJECT_HASH_SIZE);
  828.     if (object) {
  829. pk11_ReferenceObject(object);
  830.     }
  831.     PK11_USE_THREADS(PR_Unlock(lock);)
  833.     return(object);
  834. }
  835. /*
  836.  * look up and object structure from a handle. OBJECT_Handles only make
  837.  * sense in terms of a given session.  make a reference to that object
  838.  * structure returned.
  839.  */
  840. PK11Object *
  841. pk11_ObjectFromHandle(CK_OBJECT_HANDLE handle, PK11Session *session)
  842. {
  843.     PK11Slot *slot = pk11_SlotFromSession(session);
  845.     return pk11_ObjectFromHandleOnSlot(handle,slot);
  846. }
  849. /*
  850.  * release a reference to an object handle
  851.  */
  852. PK11FreeStatus
  853. pk11_FreeObject(PK11Object *object)
  854. {
  855.     PRBool destroy = PR_FALSE;
  856.     CK_RV crv;
  858.     PK11_USE_THREADS(PR_Lock(object->refLock);)
  859.     if (object->refCount == 1) destroy = PR_TRUE;
  860.     object->refCount--;
  861.     PK11_USE_THREADS(PR_Unlock(object->refLock);)
  863.     if (destroy) {
  864. crv = pk11_DestroyObject(object);
  865. if (crv != CKR_OK) {
  866.    return PK11_DestroyFailure;
  867. } 
  868. return PK11_Destroyed;
  869.     }
  870.     return PK11_Busy;
  871. }
  872.  
  873. /*
  874.  * add an object to a slot and session queue. These two functions
  875.  * adopt the object.
  876.  */
  877. void
  878. pk11_AddSlotObject(PK11Slot *slot, PK11Object *object)
  879. {
  880.     PK11_USE_THREADS(PR_Lock(slot->objectLock);)
  881.     pk11queue_add(object,object->handle,slot->tokObjects,TOKEN_OBJECT_HASH_SIZE);
  882.     PK11_USE_THREADS(PR_Unlock(slot->objectLock);)
  883. }
  885. void
  886. pk11_AddObject(PK11Session *session, PK11Object *object)
  887. {
  888.     PK11Slot *slot = pk11_SlotFromSession(session);
  890.     if (!pk11_isToken(object->handle)) {
  891. PK11_USE_THREADS(PR_Lock(session->objectLock);)
  892. pk11queue_add(&object->sessionList,0,session->objects,0);
  893. object->session = session;
  894. PK11_USE_THREADS(PR_Unlock(session->objectLock);)
  895.     }
  896.     pk11_AddSlotObject(slot,object);
  897. } 
  899. /*
  900.  * add an object to a slot andsession queue
  901.  */
  902. void
  903. pk11_DeleteObject(PK11Session *session, PK11Object *object)
  904. {
  905.     PK11Slot *slot = pk11_SlotFromSession(session);
  907.     if (object->session) {
  908. PK11Session *session = object->session;
  909. PK11_USE_THREADS(PR_Lock(session->objectLock);)
  910. pk11queue_delete(&object->sessionList,0,session->objects,0);
  911. PK11_USE_THREADS(PR_Unlock(session->objectLock);)
  912.     }
  913.     PK11_USE_THREADS(PR_Lock(slot->objectLock);)
  914.     pk11queue_delete(object,object->handle,slot->tokObjects,
  915. TOKEN_OBJECT_HASH_SIZE);
  916.     PK11_USE_THREADS(PR_Unlock(slot->objectLock);)
  917.     pk11_FreeObject(object);
  918. }
  920. /*
  921.  * copy the attributes from one object to another. Don't overwrite existing
  922.  * attributes. NOTE: This is a pretty expensive operation since it
  923.  * grabs the attribute locks for the src object for a *long* time.
  924.  */
  925. CK_RV
  926. pk11_CopyObject(PK11Object *destObject,PK11Object *srcObject)
  927. {
  928.     PK11Attribute *attribute;
  929.     int i;
  931.     PK11_USE_THREADS(PR_Lock(srcObject->attributeLock);)
  932.     for(i=0; i < ATTRIBUTE_HASH_SIZE; i++) {
  933. attribute = srcObject->head[i];
  934. do {
  935.     if (attribute) {
  936. if (!pk11_hasAttribute(destObject,attribute->handle)) {
  937.     /* we need to copy the attribute since each attribute
  938.      * only has one set of link list pointers */
  939.     PK11Attribute *newAttribute = pk11_NewAttribute(
  940.   destObject,pk11_attr_expand(&attribute->attrib));
  941.     if (newAttribute == NULL) {
  942. PK11_USE_THREADS(PR_Unlock(srcObject->attributeLock);)
  943. return CKR_HOST_MEMORY;
  944.     }
  945.     pk11_AddAttribute(destObject,newAttribute);
  946. }
  947. attribute=attribute->next;
  948.     }
  949. } while (attribute != NULL);
  950.     }
  951.     PK11_USE_THREADS(PR_Unlock(srcObject->attributeLock);)
  952.     return CKR_OK;
  953. }
  955. /*
  956.  * ******************** Search Utilities *******************************
  957.  */
  959. /* add an object to a search list */
  960. CK_RV
  961. AddToList(PK11ObjectListElement **list,PK11Object *object)
  962. {
  963.      PK11ObjectListElement *newElem = 
  964. (PK11ObjectListElement *)PORT_Alloc(sizeof(PK11ObjectListElement));
  966.      if (newElem == NULL) return CKR_HOST_MEMORY;
  968.      newElem->next = *list;
  969.      newElem->object = object;
  970.      pk11_ReferenceObject(object);
  972.     *list = newElem;
  973.     return CKR_OK;
  974. }
  977. /* return true if the object matches the template */
  978. PRBool
  979. pk11_objectMatch(PK11Object *object,CK_ATTRIBUTE_PTR theTemplate,int count)
  980. {
  981.     int i;
  983.     for (i=0; i < count; i++) {
  984. PK11Attribute *attribute = pk11_FindAttribute(object,theTemplate[i].type);
  985. if (attribute == NULL) {
  986.     return PR_FALSE;
  987. }
  988. if (attribute->attrib.ulValueLen == theTemplate[i].ulValueLen) {
  989.     if (PORT_Memcmp(attribute->attrib.pValue,theTemplate[i].pValue,
  990. theTemplate[i].ulValueLen) == 0) {
  991.          pk11_FreeAttribute(attribute);
  992. continue;
  993.     }
  994. }
  995.         pk11_FreeAttribute(attribute);
  996. return PR_FALSE;
  997.     }
  998.     return PR_TRUE;
  999. }
  1001. /* search through all the objects in the queue and return the template matches
  1002.  * in the object list.
  1003.  */
  1004. CK_RV
  1005. pk11_searchObjectList(PK11ObjectListElement **objectList,PK11Object **head,
  1006.         PRLock *lock, CK_ATTRIBUTE_PTR theTemplate, int count, PRBool isLoggedIn)
  1007. {
  1008.     int i;
  1009.     PK11Object *object;
  1010.     CK_RV crv = CKR_OK;
  1012.     for(i=0; i < TOKEN_OBJECT_HASH_SIZE; i++) {
  1013.         /* We need to hold the lock to copy a consistant version of
  1014.          * the linked list. */
  1015.         PK11_USE_THREADS(PR_Lock(lock);)
  1016. for (object = head[i]; object != NULL; object= object->next) {
  1017.     if (pk11_objectMatch(object,theTemplate,count)) {
  1018. /* don't return objects that aren't yet visible */
  1019. if ((!isLoggedIn) && pk11_isTrue(object,CKA_PRIVATE)) continue;
  1020.         crv = AddToList(objectList,object);
  1021. if (crv != CKR_OK) {
  1022.     break;
  1023. }
  1024.     }
  1025. }
  1026.         PK11_USE_THREADS(PR_Unlock(lock);)
  1027.     }
  1028.     return crv;
  1029. }
  1031. /*
  1032.  * free a single list element. Return the Next object in the list.
  1033.  */
  1034. PK11ObjectListElement *
  1035. pk11_FreeObjectListElement(PK11ObjectListElement *objectList)
  1036. {
  1037.     PK11ObjectListElement *ol = objectList->next;
  1039.     pk11_FreeObject(objectList->object);
  1040.     PORT_Free(objectList);
  1041.     return ol;
  1042. }
  1044. /* free an entire object list */
  1045. void
  1046. pk11_FreeObjectList(PK11ObjectListElement *objectList)
  1047. {
  1048.     PK11ObjectListElement *ol;
  1050.     for (ol= objectList; ol != NULL; ol = pk11_FreeObjectListElement(ol)) {}
  1051. }
  1053. /*
  1054.  * free a search structure
  1055.  */
  1056. void
  1057. pk11_FreeSearch(PK11SearchResults *search)
  1058. {
  1059.     if (search->handles) {
  1060. PORT_Free(search->handles);
  1061.     }
  1062.     PORT_Free(search);
  1063. }
  1065. /*
  1066.  * ******************** Session Utilities *******************************
  1067.  */
  1069. /* update the sessions state based in it's flags and wether or not it's
  1070.  * logged in */
  1071. void
  1072. pk11_update_state(PK11Slot *slot,PK11Session *session)
  1073. {
  1074.     if (slot->isLoggedIn) {
  1075. if (slot->ssoLoggedIn) {
  1076.          session->info.state = CKS_RW_SO_FUNCTIONS;
  1077. } else if (session->info.flags & CKF_RW_SESSION) {
  1078.          session->info.state = CKS_RW_USER_FUNCTIONS;
  1079. } else {
  1080.          session->info.state = CKS_RO_USER_FUNCTIONS;
  1081. }
  1082.     } else {
  1083. if (session->info.flags & CKF_RW_SESSION) {
  1084.          session->info.state = CKS_RW_PUBLIC_SESSION;
  1085. } else {
  1086.          session->info.state = CKS_RO_PUBLIC_SESSION;
  1087. }
  1088.     }
  1089. }
  1091. /* update the state of all the sessions on a slot */
  1092. void
  1093. pk11_update_all_states(PK11Slot *slot)
  1094. {
  1095.     int i;
  1096.     PK11Session *session;
  1098.     for (i=0; i < SESSION_HASH_SIZE; i++) {
  1099. PK11_USE_THREADS(PR_Lock(slot->sessionLock);)
  1100. for (session = slot->head[i]; session; session = session->next) {
  1101.     pk11_update_state(slot,session);
  1102. }
  1103. PK11_USE_THREADS(PR_Unlock(slot->sessionLock);)
  1104.     }
  1105. }
  1107. /*
  1108.  * context are cipher and digest contexts that are associated with a session
  1109.  */
  1110. void
  1111. pk11_FreeContext(PK11SessionContext *context)
  1112. {
  1113.     if (context->cipherInfo) {
  1114. (*context->destroy)(context->cipherInfo,PR_TRUE);
  1115.     }
  1116.     if (context->hashInfo) {
  1117. (*context->hashdestroy)(context->hashInfo,PR_TRUE);
  1118.     }
  1119.     PORT_Free(context);
  1120. }
  1122. /* look up a slot structure from the ID (used to be a macro when we only
  1123.  * had two slots) */
  1124. PK11Slot *
  1125. pk11_SlotFromID(CK_SLOT_ID slotID)
  1126. {
  1127.     switch (slotID) {
  1128.     case NETSCAPE_SLOT_ID:
  1129. return &pk11_slot[0];
  1130.     case PRIVATE_KEY_SLOT_ID:
  1131. return &pk11_slot[1];
  1132.     case FIPS_SLOT_ID:
  1133. return &pk11_slot[2];
  1134.     default:
  1135. break; /* fall through to NULL */
  1136.     }
  1137.     return NULL;
  1138. }
  1140. PK11Slot *
  1141. pk11_SlotFromSessionHandle(CK_SESSION_HANDLE handle)
  1142. {
  1143.     if (handle & PK11_PRIVATE_KEY_FLAG) {
  1144. return &pk11_slot[1];
  1145.     }
  1146.     if (handle & PK11_FIPS_FLAG) {
  1147. return &pk11_slot[2];
  1148.     }
  1149.     return &pk11_slot[0];
  1150. }
  1152. /*
  1153.  * create a new nession. NOTE: The session handle is not set, and the
  1154.  * session is not added to the slot's session queue.
  1155.  */
  1156. PK11Session *
  1157. pk11_NewSession(CK_SLOT_ID slotID, CK_NOTIFY notify, CK_VOID_PTR pApplication,
  1158.      CK_FLAGS flags)
  1159. {
  1160.     PK11Session *session;
  1161.     PK11Slot *slot = pk11_SlotFromID(slotID);
  1163.     if (slot == NULL) return NULL;
  1165.     session = (PK11Session*)PORT_Alloc(sizeof(PK11Session));
  1166.     if (session == NULL) return NULL;
  1168.     session->next = session->prev = NULL;
  1169.     session->refCount = 1;
  1170.     session->enc_context = NULL;
  1171.     session->hash_context = NULL;
  1172.     session->sign_context = NULL;
  1173.     session->search = NULL;
  1174.     session->objectIDCount = 1;
  1175. #ifdef PKCS11_USE_THREADS
  1176.     session->refLock = PR_NewLock();
  1177.     if (session->refLock == NULL) {
  1178. PORT_Free(session);
  1179. return NULL;
  1180.     }
  1181.     session->objectLock = PR_NewLock();
  1182.     if (session->objectLock == NULL) {
  1183. PK11_USE_THREADS(PR_DestroyLock(session->refLock);)
  1184. PORT_Free(session);
  1185. return NULL;
  1186.     }
  1187. #else
  1188.     session->refLock = NULL;
  1189.     session->objectLock = NULL;
  1190. #endif
  1191.     session->objects[0] = NULL;
  1193.     session->slot = slot;
  1194.     session->notify = notify;
  1195.     session->appData = pApplication;
  1196.     session->info.flags = flags;
  1197.     session->info.slotID = slotID;
  1198.     pk11_update_state(slot,session);
  1199.     return session;
  1200. }
  1203. /* free all the data associated with a session. */
  1204. static void
  1205. pk11_DestroySession(PK11Session *session)
  1206. {
  1207.     PK11ObjectList *op,*next;
  1208.     PORT_Assert(session->refCount == 0);
  1210.     /* clean out the attributes */
  1211.     /* since no one is referencing us, it's safe to walk the chain
  1212.      * without a lock */
  1213.     for (op = session->objects[0]; op != NULL; op = next) {
  1214.         next = op->next;
  1215.         /* paranoia */
  1216. op->next = op->prev = NULL;
  1217. pk11_DeleteObject(session,op->parent);
  1218.     }
  1219.     PK11_USE_THREADS(PR_DestroyLock(session->objectLock);)
  1220.     PK11_USE_THREADS(PR_DestroyLock(session->refLock);)
  1221.     if (session->enc_context) {
  1222. pk11_FreeContext(session->enc_context);
  1223.     }
  1224.     if (session->hash_context) {
  1225. pk11_FreeContext(session->hash_context);
  1226.     }
  1227.     if (session->sign_context) {
  1228. pk11_FreeContext(session->sign_context);
  1229.     }
  1230.     if (session->search) {
  1231. pk11_FreeSearch(session->search);
  1232.     }
  1233.     PORT_Free(session);
  1234. }
  1237. /*
  1238.  * look up a session structure from a session handle
  1239.  * generate a reference to it.
  1240.  */
  1241. PK11Session *
  1242. pk11_SessionFromHandle(CK_SESSION_HANDLE handle)
  1243. {
  1244.     PK11Slot *slot = pk11_SlotFromSessionHandle(handle);
  1245.     PK11Session *session;
  1247.     PK11_USE_THREADS(PR_Lock(slot->sessionLock);)
  1248.     pk11queue_find(session,handle,slot->head,SESSION_HASH_SIZE);
  1249.     if (session) session->refCount++;
  1250.     PK11_USE_THREADS(PR_Unlock(slot->sessionLock);)
  1252.     return (session);
  1253. }
  1255. /*
  1256.  * release a reference to a session handle
  1257.  */
  1258. void
  1259. pk11_FreeSession(PK11Session *session)
  1260. {
  1261.     PRBool destroy = PR_FALSE;
  1262.     PK11_USE_THREADS(PK11Slot *slot = pk11_SlotFromSession(session);)
  1264.     PK11_USE_THREADS(PR_Lock(slot->sessionLock);)
  1265.     if (session->refCount == 1) destroy = PR_TRUE;
  1266.     session->refCount--;
  1267.     PK11_USE_THREADS(PR_Unlock(slot->sessionLock);)
  1269.     if (destroy) pk11_DestroySession(session);
  1270. }