Exemplo n.º 1
0
CK_RV
dp_dh_set_default_attributes( TEMPLATE *tmpl, CK_ULONG mode )
{
   CK_RV		rc;
   CK_ATTRIBUTE         *prime_attr;
   CK_ATTRIBUTE         *base_attr;
   CK_ATTRIBUTE         *primebits_attr;
   CK_ATTRIBUTE         *type_attr;

   rc = dp_object_set_default_attributes( tmpl, mode );
   if (rc != CKR_OK)
      return rc;

   prime_attr = (CK_ATTRIBUTE *)malloc( sizeof(CK_ATTRIBUTE) );
   base_attr = (CK_ATTRIBUTE *)malloc( sizeof(CK_ATTRIBUTE) );
   primebits_attr = (CK_ATTRIBUTE *)malloc( sizeof(CK_ATTRIBUTE) );
   type_attr = (CK_ATTRIBUTE *)malloc( sizeof(CK_ATTRIBUTE) + sizeof(CK_KEY_TYPE) );

   if (!prime_attr || !base_attr || !primebits_attr || !type_attr) {
      if (prime_attr) free( prime_attr );
      if (base_attr) free( base_attr );
      if (primebits_attr) free( primebits_attr );
      if (type_attr) free( type_attr );
      TRACE_ERROR("%s\n", ock_err(ERR_HOST_MEMORY));
      return CKR_HOST_MEMORY;
   }

   prime_attr->type       = CKA_PRIME;
   prime_attr->ulValueLen = 0;
   prime_attr->pValue     = NULL;

   base_attr->type       = CKA_BASE;
   base_attr->ulValueLen = 0;
   base_attr->pValue     = NULL;

   primebits_attr->type       = CKA_PRIME_BITS;
   primebits_attr->ulValueLen = 0;
   primebits_attr->pValue     = NULL;

   type_attr->type       = CKA_KEY_TYPE;
   type_attr->ulValueLen = sizeof(CK_KEY_TYPE);
   type_attr->pValue     = (CK_BYTE *)type_attr + sizeof(CK_ATTRIBUTE);
   *(CK_KEY_TYPE *)type_attr->pValue = CKK_DH;

   template_update_attribute( tmpl, prime_attr );
   template_update_attribute( tmpl, base_attr );
   template_update_attribute( tmpl, primebits_attr );
   template_update_attribute( tmpl, type_attr );

   return CKR_OK;

}
Exemplo n.º 2
0
CK_RV
clock_set_default_attributes( TEMPLATE *tmpl, CK_ULONG mode )
{
   CK_RV		rc;
   CK_ATTRIBUTE		*value_attr;
	
   rc = hwf_object_set_default_attributes( tmpl, mode );
   if (rc != CKR_OK)
      return rc;
   
   value_attr = (CK_ATTRIBUTE *)malloc( sizeof(CK_ATTRIBUTE) );

   if (!value_attr) {
      OCK_LOG_ERR(ERR_HOST_MEMORY);
      return CKR_HOST_MEMORY;
   }

   value_attr->type       = CKA_VALUE;
   value_attr->ulValueLen = 0;
   value_attr->pValue     = NULL;

   template_update_attribute( tmpl, value_attr );

   return CKR_OK;
}
Exemplo n.º 3
0
CK_RV
counter_set_default_attributes( TEMPLATE *tmpl, CK_ULONG mode )
{
   CK_RV                rc;
   CK_ATTRIBUTE         *value_attr;
   CK_ATTRIBUTE         *hasreset_attr;
   CK_ATTRIBUTE         *resetoninit_attr;

   rc = hwf_object_set_default_attributes( tmpl, mode );
   if (rc != CKR_OK)
      return rc;

   value_attr = (CK_ATTRIBUTE *)malloc( sizeof(CK_ATTRIBUTE) );
   hasreset_attr = (CK_ATTRIBUTE *)malloc( sizeof(CK_ATTRIBUTE) + sizeof(CK_BBOOL));
   resetoninit_attr = (CK_ATTRIBUTE *)malloc( sizeof(CK_ATTRIBUTE) + sizeof(CK_BBOOL));

   if (!value_attr || !hasreset_attr || !resetoninit_attr) {
      if (value_attr) free( value_attr );
      if (hasreset_attr) free( hasreset_attr );
      if (resetoninit_attr) free( resetoninit_attr );
      OCK_LOG_ERR(ERR_HOST_MEMORY);
      return CKR_HOST_MEMORY;
   }

   value_attr->type       = CKA_VALUE;
   value_attr->ulValueLen = 0;
   value_attr->pValue     = NULL;

   hasreset_attr->type       = CKA_HAS_RESET;
   hasreset_attr->ulValueLen = sizeof(CK_BBOOL);
   hasreset_attr->pValue     = (CK_BYTE *)hasreset_attr + sizeof(CK_ATTRIBUTE);
   *(CK_BBOOL *)hasreset_attr->pValue = FALSE;

   /* Hmm...  Not sure if we should be setting this here. */
   resetoninit_attr->type       = CKA_RESET_ON_INIT;
   resetoninit_attr->ulValueLen = sizeof(CK_BBOOL);
   resetoninit_attr->pValue     = (CK_BYTE *)resetoninit_attr + sizeof(CK_ATTRIBUTE);
   *(CK_BBOOL *)resetoninit_attr->pValue = FALSE;

   template_update_attribute( tmpl, value_attr );
   template_update_attribute( tmpl, hasreset_attr );
   template_update_attribute( tmpl, resetoninit_attr );

   return CKR_OK;
}
Exemplo n.º 4
0
CK_RV
counter_set_default_attributes(TEMPLATE *tmpl)
{
	CK_ATTRIBUTE	 *value_attr;
	CK_ATTRIBUTE	 *hasreset_attr;
	CK_ATTRIBUTE	 *resetoninit_attr;

	value_attr = (CK_ATTRIBUTE *)malloc(sizeof (CK_ATTRIBUTE));
	hasreset_attr = (CK_ATTRIBUTE *)malloc(sizeof (CK_ATTRIBUTE) +
	    sizeof (CK_BBOOL));
	resetoninit_attr = (CK_ATTRIBUTE *)malloc(sizeof (CK_ATTRIBUTE) +
	    sizeof (CK_BBOOL));

	if (! value_attr || ! hasreset_attr || ! resetoninit_attr) {
		if (value_attr) free(value_attr);
		if (hasreset_attr) free(hasreset_attr);
		if (resetoninit_attr) free(resetoninit_attr);
		return (CKR_HOST_MEMORY);
	}

	value_attr->type	= CKA_VALUE;
	value_attr->ulValueLen = 0;
	value_attr->pValue	= NULL;

	hasreset_attr->type	= CKA_HAS_RESET;
	hasreset_attr->ulValueLen = sizeof (CK_BBOOL);
	hasreset_attr->pValue	= (CK_BYTE *)hasreset_attr +
	    sizeof (CK_ATTRIBUTE);
	*(CK_BBOOL *)hasreset_attr->pValue = FALSE;

	/* Hmm...  Not sure if we should be setting this here. */
	resetoninit_attr->type	= CKA_RESET_ON_INIT;
	resetoninit_attr->ulValueLen = sizeof (CK_BBOOL);
	resetoninit_attr->pValue = (CK_BYTE *)resetoninit_attr +
	    sizeof (CK_ATTRIBUTE);
	*(CK_BBOOL *)resetoninit_attr->pValue = FALSE;

	(void) template_update_attribute(tmpl, value_attr);
	(void) template_update_attribute(tmpl, hasreset_attr);
	(void) template_update_attribute(tmpl, resetoninit_attr);

	return (CKR_OK);
}
Exemplo n.º 5
0
/*
 * data_object_set_default_attributes()
 *
 * Set the default attributes for data objects:
 *
 *    CKA_APPLICATION :  empty string
 *    CKA_VALUE       :  empty byte array
 */
CK_RV
data_object_set_default_attributes(TEMPLATE *tmpl, CK_ULONG mode)
{
	CK_ATTRIBUTE    *class_attr = NULL;
	CK_ATTRIBUTE    *app_attr   = NULL;
	CK_ATTRIBUTE    *value_attr = NULL;

	if (mode)
	app_attr = NULL;

	class_attr = (CK_ATTRIBUTE *)malloc(sizeof (CK_ATTRIBUTE) +
	    sizeof (CK_OBJECT_CLASS));
	app_attr   = (CK_ATTRIBUTE *)malloc(sizeof (CK_ATTRIBUTE));
	value_attr = (CK_ATTRIBUTE *)malloc(sizeof (CK_ATTRIBUTE));

	if (! class_attr || ! app_attr || ! value_attr) {
		if (class_attr) free(class_attr);
		if (app_attr)   free(app_attr);
		if (value_attr) free(value_attr);
		return (CKR_HOST_MEMORY);
	}

	app_attr->type		= CKA_APPLICATION;
	app_attr->ulValueLen	= 0;  // empty string
	app_attr->pValue	= NULL;

	value_attr->type	= CKA_VALUE;
	value_attr->ulValueLen	= 0;  // empty byte array
	value_attr->pValue	= NULL;

	class_attr->type	= CKA_CLASS;
	class_attr->ulValueLen	= sizeof (CK_OBJECT_CLASS);
	class_attr->pValue	= (CK_BYTE *)class_attr + sizeof (CK_ATTRIBUTE);
	*(CK_OBJECT_CLASS *)class_attr->pValue = CKO_DATA;

	(void) template_update_attribute(tmpl, class_attr);
	(void) template_update_attribute(tmpl, app_attr);
	(void) template_update_attribute(tmpl, value_attr);

	return (CKR_OK);
}
Exemplo n.º 6
0
CK_RV
clock_set_default_attributes(TEMPLATE *tmpl)
{
	CK_ATTRIBUTE		*value_attr;

	value_attr = (CK_ATTRIBUTE *)malloc(sizeof (CK_ATTRIBUTE));

	if (! value_attr) {
		return (CKR_HOST_MEMORY);
	}

	value_attr->type	= CKA_VALUE;
	value_attr->ulValueLen = 0;
	value_attr->pValue	= NULL;

	(void) template_update_attribute(tmpl, value_attr);

	return (CKR_OK);
}
Exemplo n.º 7
0
// dp_object_set_default_attributes()
//
CK_RV
dp_object_set_default_attributes( TEMPLATE *tmpl, CK_ULONG mode )
{
   CK_ATTRIBUTE * local_attr  = NULL;

   local_attr     = (CK_ATTRIBUTE *)malloc( sizeof(CK_ATTRIBUTE) + sizeof(CK_BBOOL) );

   if (!local_attr) {
      TRACE_ERROR("%s\n", ock_err(ERR_HOST_MEMORY));
      return CKR_HOST_MEMORY;
   }

   local_attr->type        = CKA_LOCAL;
   local_attr->ulValueLen  = sizeof(CK_BBOOL);
   local_attr->pValue      = (CK_BYTE *)local_attr + sizeof(CK_ATTRIBUTE);
   *(CK_BBOOL *)local_attr->pValue = FALSE;

   template_update_attribute( tmpl, local_attr  );

   return CKR_OK;
}
Exemplo n.º 8
0
// hwf_object_set_default_attributes()
//
CK_RV
hwf_object_set_default_attributes( TEMPLATE *tmpl, CK_ULONG mode )
{
#if 0
   CK_ATTRIBUTE * local_attr  = NULL;

   local_attr     = (CK_ATTRIBUTE *)malloc( sizeof(CK_ATTRIBUTE) + sizeof(CK_BBOOL) );

   if (!local_attr) {
      OCK_LOG_ERR(ERR_HOST_MEMORY);
      return CKR_HOST_MEMORY;
   }

   local_attr->type        = CKA_LOCAL;
   local_attr->ulValueLen  = sizeof(CK_BBOOL);
   local_attr->pValue      = (CK_BYTE *)local_attr + sizeof(CK_ATTRIBUTE);
   *(CK_BBOOL *)local_attr->pValue = FALSE;

   template_update_attribute( tmpl, local_attr  );
#endif
   return CKR_OK;
}
Exemplo n.º 9
0
/* template_add_attributes()
 *
 * blindly add the given attributes to the template. do no sanity checking
 * at this point. sanity checking will occur later.
 */
CK_RV template_add_attributes(TEMPLATE *tmpl, CK_ATTRIBUTE *pTemplate,
			      CK_ULONG ulCount)
{
	CK_ATTRIBUTE *attr = NULL;
	CK_RV rc;
	unsigned int i;

	for (i = 0; i < ulCount; i++) {
		if (!is_attribute_defined(pTemplate[i].type)) {
			TRACE_ERROR("%s\n", ock_err(ERR_ATTRIBUTE_TYPE_INVALID));
			return CKR_ATTRIBUTE_TYPE_INVALID;
		}
		attr = (CK_ATTRIBUTE *)malloc(sizeof(CK_ATTRIBUTE) +
					      pTemplate[i].ulValueLen);
		if (!attr) {
			TRACE_ERROR("%s\n", ock_err(ERR_HOST_MEMORY));
			return CKR_HOST_MEMORY;
		}
		attr->type = pTemplate[i].type;
		attr->ulValueLen = pTemplate[i].ulValueLen;

		if (attr->ulValueLen != 0) {
			attr->pValue = (CK_BYTE *)attr + sizeof(CK_ATTRIBUTE);
			memcpy(attr->pValue, pTemplate[i].pValue,
				attr->ulValueLen);
		} else
			attr->pValue = NULL;

		rc = template_update_attribute(tmpl, attr);
		if (rc != CKR_OK) {
			free(attr);
			TRACE_DEVEL("template_update_attribute failed.\n");
			return rc;
		}
	}

	return CKR_OK;
}