OSLock::OSLock(bool exceptionAllowed) { int rc; lockData = NULL; if (!needThread) { return; } #ifdef MAC if (!OSLock_attr_init) { rc = pthread_mutexattr_init(&OSLock_attr); if (rc < 0) { if (exceptionAllowed) { throw PKCS11Exception(CKR_DEVICE_ERROR, "lock init failed"); } else { return; } } OSLock_attr_init = 1; } #endif lockData = new OSLockData; if (lockData) { rc = pthread_mutex_init(&lockData->mutex, &OSLock_attr); if (rc < 0) { delete lockData; lockData = NULL; } } if (exceptionAllowed && !lockData) { throw PKCS11Exception(CKR_HOST_MEMORY, "lock allocation failed"); } }
CK_BBOOL StorageObject::readBBoolFromAttribute( const CK_ATTRIBUTE& a_Attribute ) { if( a_Attribute.ulValueLen != sizeof( CK_BBOOL ) ) { throw PKCS11Exception( CKR_ATTRIBUTE_VALUE_INVALID ); } CK_BBOOL val = *(CK_BBOOL*)a_Attribute.pValue; if( ( val != 0x00 ) && ( val != 0x01 ) ) { throw PKCS11Exception( CKR_ATTRIBUTE_VALUE_INVALID ); } return val; }
void StorageObject::putU4ArrayInAttribute( Marshaller::u4Array* value,CK_ATTRIBUTE_PTR attribute) { if( !attribute->pValue ) { if( !value ) { attribute->ulValueLen = 0; } else { attribute->ulValueLen = (value->GetLength() * 4); } return; } if( !value ) { attribute->ulValueLen = 0; return; } if( attribute->ulValueLen < ( value->GetLength( ) * 4 ) ) { attribute->ulValueLen = CK_UNAVAILABLE_INFORMATION; throw PKCS11Exception( CKR_BUFFER_TOO_SMALL ); } attribute->ulValueLen = value->GetLength() * 4; memcpy((CK_BYTE_PTR)attribute->pValue,(u1*)value->GetBuffer(),attribute->ulValueLen); }
void StorageObject::getAttribute( CK_ATTRIBUTE_PTR attribute ) { switch( attribute->type ) { case CKA_CLASS: StorageObject::putULongInAttribute(m_Class,attribute); break; case CKA_PRIVATE: StorageObject::putBBoolInAttribute(m_Private,attribute); break; case CKA_TOKEN: StorageObject::putBBoolInAttribute(m_Token,attribute); break; case CKA_MODIFIABLE: StorageObject::putBBoolInAttribute(m_Modifiable,attribute); break; case CKA_LABEL: StorageObject::putU1ArrayInAttribute(m_pLabel.get( ),attribute); break; default: attribute->ulValueLen = CK_UNAVAILABLE_INFORMATION; throw PKCS11Exception( CKR_ATTRIBUTE_TYPE_INVALID ); } }
FileLog::FileLog(const char *filename ) { file = fopen(filename, "at"); if( file == NULL ) { throw PKCS11Exception(CKR_GENERAL_ERROR, "Failed to open logfile"); } }
void KeyObject::setAttribute( const CK_ATTRIBUTE& a_Attribute, const bool& objCreation ) { if( !a_Attribute.ulValueLen ) { return; } if( !objCreation ){ switch(a_Attribute.type){ case CKA_KEY_TYPE: case CKA_LOCAL: case CKA_MECHANISM_TYPE: throw PKCS11Exception( CKR_ATTRIBUTE_READ_ONLY ); } } switch(a_Attribute.type){ case CKA_KEY_TYPE: _keyType = StorageObject::readULongFromAttribute( a_Attribute ); break; case CKA_ID: m_pID.reset( StorageObject::readU1ArrayFromAttribute( a_Attribute ) ); break; case CKA_START_DATE: m_pStartDate.reset( StorageObject::readDateFromAttribute( a_Attribute ) ); break; case CKA_END_DATE: m_pEndDate.reset( StorageObject::readDateFromAttribute( a_Attribute ) ); break; case CKA_LOCAL: _local = StorageObject::readBBoolFromAttribute( a_Attribute ); break; case CKA_DERIVE: _derive = StorageObject::readBBoolFromAttribute( a_Attribute ); break; case CKA_MECHANISM_TYPE: _mechanismType = StorageObject::readULongFromAttribute( a_Attribute ); break; case CKA_ALLOWED_MECHANISMS: m_pAllowedMechanism.reset( new Marshaller::u4Array( a_Attribute.ulValueLen / 4 ) ); memcpy( (unsigned char*)m_pAllowedMechanism->GetBuffer( ), (CK_BYTE_PTR)a_Attribute.pValue, a_Attribute.ulValueLen ); break; default: StorageObject::setAttribute( a_Attribute, objCreation ); } }
Marshaller::u1Array* StorageObject::readDateFromAttribute( const CK_ATTRIBUTE& a_Attribute ) { if( a_Attribute.ulValueLen != 8 ) { throw PKCS11Exception( CKR_ATTRIBUTE_VALUE_INVALID ); } return StorageObject::readU1ArrayFromAttribute( a_Attribute ); }
CK_ULONG StorageObject::readULongFromAttribute( const CK_ATTRIBUTE& a_Attribute ) { if( a_Attribute.ulValueLen != sizeof( CK_ULONG ) ) { throw PKCS11Exception( CKR_ATTRIBUTE_VALUE_INVALID ); } return *(CK_ULONG*)a_Attribute.pValue; }
void StorageObject::setAttribute( const CK_ATTRIBUTE& a_attribute, const bool& a_objCreation) { if( !a_attribute.ulValueLen ) { return; } if( !a_objCreation ) { switch( a_attribute.type ) { case CKA_CLASS: case CKA_PRIVATE: case CKA_TOKEN: case CKA_MODIFIABLE: throw PKCS11Exception( CKR_ATTRIBUTE_READ_ONLY ); } } switch( a_attribute.type ) { case CKA_CLASS: break; case CKA_PRIVATE: m_Private = StorageObject::readBBoolFromAttribute( a_attribute ); break; case CKA_TOKEN: m_Token = StorageObject::readBBoolFromAttribute( a_attribute ); break; case CKA_MODIFIABLE: m_Modifiable = StorageObject::readBBoolFromAttribute( a_attribute ); break; case CKA_LABEL: m_pLabel.reset( StorageObject::readU1ArrayFromAttribute( a_attribute ) ); break; default: throw PKCS11Exception( CKR_ATTRIBUTE_TYPE_INVALID ); } }
OSLock::OSLock(bool exceptionAllowed) { if (!needThread) { lockData = NULL; return; } lockData = new OSLockData; if (lockData) { InitializeCriticalSection(&lockData->mutex); } if (exceptionAllowed && !lockData) { throw PKCS11Exception(CKR_HOST_MEMORY, "lock allocation failed"); } }
void Pkcs11ObjectKeyPublic::setAttribute( const CK_ATTRIBUTE& a_Attribute, const bool& objCreation) { //if( 0 == a_Attribute.ulValueLen ) //{ // return; //} if(objCreation == CK_FALSE){ switch(a_Attribute.type){ case CKA_ENCRYPT: case CKA_TRUSTED: case CKA_VERIFY: case CKA_VERIFY_RECOVER: case CKA_WRAP: if(*(CK_BBOOL*)a_Attribute.pValue == CK_TRUE){ throw PKCS11Exception( CKR_ATTRIBUTE_READ_ONLY ); } break; } } switch(a_Attribute.type){ case CKA_ENCRYPT: _encrypt = StorageObject::readBBoolFromAttribute( a_Attribute ); break; case CKA_VERIFY: _verify = StorageObject::readBBoolFromAttribute( a_Attribute ); break; case CKA_VERIFY_RECOVER: _verifyRecover = StorageObject::readBBoolFromAttribute( a_Attribute ); break; case CKA_WRAP: _wrap = StorageObject::readBBoolFromAttribute( a_Attribute ); break; case CKA_SUBJECT: m_pSubject.reset( StorageObject::readU1ArrayFromAttribute( a_Attribute ) ); break; default: KeyObject::setAttribute(a_Attribute,objCreation); } }
void StorageObject::putULongInAttribute( const CK_ULONG& value, CK_ATTRIBUTE_PTR attribute ) { if( !attribute->pValue ) { attribute->ulValueLen = sizeof( CK_ULONG ); return; } if( attribute->ulValueLen < sizeof( CK_ULONG ) ) { attribute->ulValueLen = CK_UNAVAILABLE_INFORMATION; throw PKCS11Exception( CKR_BUFFER_TOO_SMALL ); } attribute->ulValueLen = sizeof( CK_ULONG ); *(CK_ULONG*)attribute->pValue = value; }