public void _04_ObjectParameterTest()
{
byte[] data = new byte[24];
System.Random rng = new Random();
rng.NextBytes(data);
// Specify mechanism parameters
ICkKeyDerivationStringData parameter = Settings.Factories.MechanismParamsFactory.CreateCkKeyDerivationStringData(data);
// Create mechanism with the object as parameter
IMechanism mechanism = Settings.Factories.MechanismFactory.Create(CKM.CKM_XOR_BASE_AND_DATA, parameter);
Assert.IsTrue(mechanism.Type == ConvertUtils.UInt64FromCKM(CKM.CKM_XOR_BASE_AND_DATA));
// We access private Mechanism member here just for the testing purposes
if (Platform.NativeULongSize == 4)
{
if (Platform.StructPackingSize == 0)
{
HLA40.Mechanism mechanism40 = (HLA40.Mechanism)mechanism;
LLA40.CK_MECHANISM ckMechanism40 = (LLA40.CK_MECHANISM) typeof(HLA40.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism40);
Assert.IsTrue(ckMechanism40.Mechanism == ConvertUtils.UInt32FromCKM(CKM.CKM_XOR_BASE_AND_DATA));
Assert.IsTrue(ckMechanism40.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism40.ParameterLen) == UnmanagedMemory.SizeOf(typeof(LLA40.MechanismParams.CK_KEY_DERIVATION_STRING_DATA)));
}
else
{
HLA41.Mechanism mechanism41 = (HLA41.Mechanism)mechanism;
LLA41.CK_MECHANISM ckMechanism41 = (LLA41.CK_MECHANISM) typeof(HLA41.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism41);
Assert.IsTrue(ckMechanism41.Mechanism == ConvertUtils.UInt32FromCKM(CKM.CKM_XOR_BASE_AND_DATA));
Assert.IsTrue(ckMechanism41.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism41.ParameterLen) == UnmanagedMemory.SizeOf(typeof(LLA41.MechanismParams.CK_KEY_DERIVATION_STRING_DATA)));
}
}
else
{
if (Platform.StructPackingSize == 0)
{
HLA80.Mechanism mechanism80 = (HLA80.Mechanism)mechanism;
LLA80.CK_MECHANISM ckMechanism80 = (LLA80.CK_MECHANISM) typeof(HLA80.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism80);
Assert.IsTrue(ckMechanism80.Mechanism == ConvertUtils.UInt64FromCKM(CKM.CKM_XOR_BASE_AND_DATA));
Assert.IsTrue(ckMechanism80.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism80.ParameterLen) == UnmanagedMemory.SizeOf(typeof(LLA80.MechanismParams.CK_KEY_DERIVATION_STRING_DATA)));
}
else
{
HLA81.Mechanism mechanism81 = (HLA81.Mechanism)mechanism;
LLA81.CK_MECHANISM ckMechanism81 = (LLA81.CK_MECHANISM) typeof(HLA81.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism81);
Assert.IsTrue(ckMechanism81.Mechanism == ConvertUtils.UInt64FromCKM(CKM.CKM_XOR_BASE_AND_DATA));
Assert.IsTrue(ckMechanism81.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism81.ParameterLen) == UnmanagedMemory.SizeOf(typeof(LLA81.MechanismParams.CK_KEY_DERIVATION_STRING_DATA)));
}
}
}
public void _02_EmptyParameterTest()
{
// Create mechanism without the parameter
Mechanism mechanism = new Mechanism(CKM.CKM_RSA_PKCS);
Assert.IsTrue(mechanism.Type == (ulong)CKM.CKM_RSA_PKCS);
// We access private Mechanism member just for the testing purposes
if (Platform.UnmanagedLongSize == 4)
{
if (Platform.StructPackingSize == 0)
{
HLA40.Mechanism mechanism40 = (HLA40.Mechanism) typeof(Mechanism).GetField("_mechanism40", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA40.CK_MECHANISM ckMechanism40 = (LLA40.CK_MECHANISM) typeof(HLA40.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism40);
Assert.IsTrue(ckMechanism40.Mechanism == (uint)CKM.CKM_RSA_PKCS);
Assert.IsTrue(ckMechanism40.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism40.ParameterLen == 0);
}
else
{
HLA41.Mechanism mechanism41 = (HLA41.Mechanism) typeof(Mechanism).GetField("_mechanism41", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA41.CK_MECHANISM ckMechanism41 = (LLA41.CK_MECHANISM) typeof(HLA41.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism41);
Assert.IsTrue(ckMechanism41.Mechanism == (uint)CKM.CKM_RSA_PKCS);
Assert.IsTrue(ckMechanism41.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism41.ParameterLen == 0);
}
}
else
{
if (Platform.StructPackingSize == 0)
{
HLA80.Mechanism mechanism80 = (HLA80.Mechanism) typeof(Mechanism).GetField("_mechanism80", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA80.CK_MECHANISM ckMechanism80 = (LLA80.CK_MECHANISM) typeof(HLA80.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism80);
Assert.IsTrue(ckMechanism80.Mechanism == (ulong)CKM.CKM_RSA_PKCS);
Assert.IsTrue(ckMechanism80.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism80.ParameterLen == 0);
}
else
{
HLA81.Mechanism mechanism81 = (HLA81.Mechanism) typeof(Mechanism).GetField("_mechanism81", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA81.CK_MECHANISM ckMechanism81 = (LLA81.CK_MECHANISM) typeof(HLA81.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism81);
Assert.IsTrue(ckMechanism81.Mechanism == (ulong)CKM.CKM_RSA_PKCS);
Assert.IsTrue(ckMechanism81.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism81.ParameterLen == 0);
}
}
}
public void _02_EmptyParameterTest()
{
// Create mechanism without the parameter
IMechanism mechanism = Settings.Factories.MechanismFactory.Create(CKM.CKM_RSA_PKCS);
Assert.IsTrue(mechanism.Type == ConvertUtils.UInt64FromCKM(CKM.CKM_RSA_PKCS));
// We access private Mechanism member just for the testing purposes
if (Platform.NativeULongSize == 4)
{
if (Platform.StructPackingSize == 0)
{
HLA40.Mechanism mechanism40 = (HLA40.Mechanism)mechanism;
LLA40.CK_MECHANISM ckMechanism40 = (LLA40.CK_MECHANISM) typeof(HLA40.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism40);
Assert.IsTrue(ckMechanism40.Mechanism == ConvertUtils.UInt32FromCKM(CKM.CKM_RSA_PKCS));
Assert.IsTrue(ckMechanism40.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism40.ParameterLen == 0);
}
else
{
HLA41.Mechanism mechanism41 = (HLA41.Mechanism)mechanism;
LLA41.CK_MECHANISM ckMechanism41 = (LLA41.CK_MECHANISM) typeof(HLA41.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism41);
Assert.IsTrue(ckMechanism41.Mechanism == ConvertUtils.UInt32FromCKM(CKM.CKM_RSA_PKCS));
Assert.IsTrue(ckMechanism41.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism41.ParameterLen == 0);
}
}
else
{
if (Platform.StructPackingSize == 0)
{
HLA80.Mechanism mechanism80 = (HLA80.Mechanism)mechanism;
LLA80.CK_MECHANISM ckMechanism80 = (LLA80.CK_MECHANISM) typeof(HLA80.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism80);
Assert.IsTrue(ckMechanism80.Mechanism == ConvertUtils.UInt64FromCKM(CKM.CKM_RSA_PKCS));
Assert.IsTrue(ckMechanism80.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism80.ParameterLen == 0);
}
else
{
HLA81.Mechanism mechanism81 = (HLA81.Mechanism)mechanism;
LLA81.CK_MECHANISM ckMechanism81 = (LLA81.CK_MECHANISM) typeof(HLA81.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism81);
Assert.IsTrue(ckMechanism81.Mechanism == ConvertUtils.UInt64FromCKM(CKM.CKM_RSA_PKCS));
Assert.IsTrue(ckMechanism81.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism81.ParameterLen == 0);
}
}
}
internal static extern CKR C_SignInit(uint session, ref CK_MECHANISM mechanism, uint key);
/// <summary>
/// Creates mechanism of given type with structure as parameter
/// </summary>
/// <param name="mechanism">Mechanism type</param>
/// <param name="parameterStructure">Structure with mechanism parameters</param>
/// <returns>Mechanism of given type with structure as parameter</returns>
public static CK_MECHANISM CreateMechanism(uint mechanism, object parameterStructure)
{
if (parameterStructure == null)
throw new ArgumentNullException("parameterStructure");
CK_MECHANISM ckMechanism = new CK_MECHANISM();
ckMechanism.Mechanism = mechanism;
ckMechanism.ParameterLen = Convert.ToUInt32(UnmanagedMemory.SizeOf(parameterStructure.GetType()));
ckMechanism.Parameter = UnmanagedMemory.Allocate(Convert.ToInt32(ckMechanism.ParameterLen));
UnmanagedMemory.Write(ckMechanism.Parameter, parameterStructure);
return ckMechanism;
}
internal static extern NativeULong C_GenerateKey(NativeULong session, ref CK_MECHANISM mechanism, CK_ATTRIBUTE[] template, NativeULong count, ref NativeULong key);
internal static extern uint C_VerifyInit(uint session, ref CK_MECHANISM mechanism, uint key);
internal static extern uint C_DecryptInit(uint session, ref CK_MECHANISM mechanism, uint key);
internal static extern NativeULong C_SignInit(NativeULong session, ref CK_MECHANISM mechanism, NativeULong key);
internal static extern CKR C_DeriveKey(uint session, ref CK_MECHANISM mechanism, uint baseKey, CK_ATTRIBUTE[] template, uint attributeCount, ref uint key);
/// <summary>
/// Generates a public/private key pair, creating new key objects
/// </summary>
/// <param name="session">The session's handle</param>
/// <param name="mechanism">Key generation mechanism</param>
/// <param name="publicKeyTemplate">The template for the public key</param>
/// <param name="publicKeyAttributeCount">The number of attributes in the public-key template</param>
/// <param name="privateKeyTemplate">The template for the private key</param>
/// <param name="privateKeyAttributeCount">The number of attributes in the private-key template</param>
/// <param name="publicKey">Location that receives the handle of the new public key</param>
/// <param name="privateKey">Location that receives the handle of the new private key</param>
/// <returns>CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_READ_ONLY, CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_VALUE_INVALID, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_DOMAIN_PARAMS_INVALID, CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED, CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY, CKR_TEMPLATE_INCOMPLETE, CKR_TEMPLATE_INCONSISTENT, CKR_TOKEN_WRITE_PROTECTED, CKR_USER_NOT_LOGGED_IN</returns>
public CKR C_GenerateKeyPair(uint session, ref CK_MECHANISM mechanism, CK_ATTRIBUTE[] publicKeyTemplate, uint publicKeyAttributeCount, CK_ATTRIBUTE[] privateKeyTemplate, uint privateKeyAttributeCount, ref uint publicKey, ref uint privateKey)
{
if (this._disposed)
throw new ObjectDisposedException(this.GetType().FullName);
return _delegates.C_GenerateKeyPair(session, ref mechanism, publicKeyTemplate, publicKeyAttributeCount, privateKeyTemplate, privateKeyAttributeCount, ref publicKey, ref privateKey);
}
/// <summary>
/// Generates a secret key or set of domain parameters, creating a new object
/// </summary>
/// <param name="session">The session's handle</param>
/// <param name="mechanism">Key generation mechanism</param>
/// <param name="template">The template for the new key or set of domain parameters</param>
/// <param name="count">The number of attributes in the template</param>
/// <param name="key">Location that receives the handle of the new key or set of domain parameters</param>
/// <returns>CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_READ_ONLY, CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_VALUE_INVALID, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED, CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY, CKR_TEMPLATE_INCOMPLETE, CKR_TEMPLATE_INCONSISTENT, CKR_TOKEN_WRITE_PROTECTED, CKR_USER_NOT_LOGGED_IN</returns>
public CKR C_GenerateKey(uint session, ref CK_MECHANISM mechanism, CK_ATTRIBUTE[] template, uint count, ref uint key)
{
if (this._disposed)
throw new ObjectDisposedException(this.GetType().FullName);
return _delegates.C_GenerateKey(session, ref mechanism, template, count, ref key);
}
/// <summary>
/// Initializes a signature operation, where the signature is an appendix to the data
/// </summary>
/// <param name="session">The session's handle</param>
/// <param name="mechanism">Signature mechanism</param>
/// <param name="key">Handle of the signature key</param>
/// <returns>CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_KEY_FUNCTION_NOT_PERMITTED,CKR_KEY_HANDLE_INVALID, CKR_KEY_SIZE_RANGE, CKR_KEY_TYPE_INCONSISTENT, CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED, CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN</returns>
public CKR C_SignInit(uint session, ref CK_MECHANISM mechanism, uint key)
{
if (this._disposed)
throw new ObjectDisposedException(this.GetType().FullName);
uint rv = _delegates.C_SignInit(session, ref mechanism, key);
return (CKR)rv;
}
internal static extern NativeULong C_DeriveKey(NativeULong session, ref CK_MECHANISM mechanism, NativeULong baseKey, CK_ATTRIBUTE[] template, NativeULong attributeCount, ref NativeULong key);
internal static extern NativeULong C_UnwrapKey(NativeULong session, ref CK_MECHANISM mechanism, NativeULong unwrappingKey, byte[] wrappedKey, NativeULong wrappedKeyLen, CK_ATTRIBUTE[] template, NativeULong attributeCount, ref NativeULong key);
internal static extern NativeULong C_WrapKey(NativeULong session, ref CK_MECHANISM mechanism, NativeULong wrappingKey, NativeULong key, byte[] wrappedKey, ref NativeULong wrappedKeyLen);
internal static extern NativeULong C_GenerateKeyPair(NativeULong session, ref CK_MECHANISM mechanism, CK_ATTRIBUTE[] publicKeyTemplate, NativeULong publicKeyAttributeCount, CK_ATTRIBUTE[] privateKeyTemplate, NativeULong privateKeyAttributeCount, ref NativeULong publicKey, ref NativeULong privateKey);
internal static extern CKR C_GenerateKey(uint session, ref CK_MECHANISM mechanism, CK_ATTRIBUTE[] template, uint count, ref uint key);
internal static extern CKR C_WrapKey(uint session, ref CK_MECHANISM mechanism, uint wrappingKey, uint key, byte[] wrappedKey, ref uint wrappedKeyLen);
/// <summary>
/// Wraps (i.e., encrypts) a private or secret key
/// </summary>
/// <param name="session">The session's handle</param>
/// <param name="mechanism">Wrapping mechanism</param>
/// <param name="wrappingKey">The handle of the wrapping key</param>
/// <param name="key">The handle of the key to be wrapped</param>
/// <param name="wrappedKey">
/// If set to null then the length of wrapped key is returned in "wrappedKeyLen" parameter, without actually returning wrapped key.
/// If not set to null then "wrappedKeyLen" parameter must contain the lenght of wrappedKey array and wrapped key is returned in "wrappedKey" parameter.
/// </param>
/// <param name="wrappedKeyLen">Location that receives the length of the wrapped key</param>
/// <returns>CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_KEY_HANDLE_INVALID, CKR_KEY_NOT_WRAPPABLE, CKR_KEY_SIZE_RANGE, CKR_KEY_UNEXTRACTABLE, CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED, CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN, CKR_WRAPPING_KEY_HANDLE_INVALID, CKR_WRAPPING_KEY_SIZE_RANGE, CKR_WRAPPING_KEY_TYPE_INCONSISTENT</returns>
public CKR C_WrapKey(uint session, ref CK_MECHANISM mechanism, uint wrappingKey, uint key, byte[] wrappedKey, ref uint wrappedKeyLen)
{
if (this._disposed)
throw new ObjectDisposedException(this.GetType().FullName);
return _delegates.C_WrapKey(session, ref mechanism, wrappingKey, key, wrappedKey, ref wrappedKeyLen);
}
/// <summary>
/// Creates mechanism of given type with no parameter
/// </summary>
/// <param name="type">Mechanism type</param>
public Mechanism(CKM type)
{
_ckMechanism = CkmUtils.CreateMechanism(type);
}
/// <summary>
/// Unwraps (i.e. decrypts) a wrapped key, creating a new private key or secret key object
/// </summary>
/// <param name="session">The session's handle</param>
/// <param name="mechanism">Unwrapping mechanism</param>
/// <param name="unwrappingKey">The handle of the unwrapping key</param>
/// <param name="wrappedKey">Wrapped key</param>
/// <param name="wrappedKeyLen">The length of the wrapped key</param>
/// <param name="template">The template for the new key</param>
/// <param name="attributeCount">The number of attributes in the template</param>
/// <param name="key">Location that receives the handle of the unwrapped key</param>
/// <returns>CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_READ_ONLY, CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_VALUE_INVALID, CKR_BUFFER_TOO_SMALL, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_DOMAIN_PARAMS_INVALID, CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED, CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY, CKR_TEMPLATE_INCOMPLETE, CKR_TEMPLATE_INCONSISTENT, CKR_TOKEN_WRITE_PROTECTED, CKR_UNWRAPPING_KEY_HANDLE_INVALID, CKR_UNWRAPPING_KEY_SIZE_RANGE, CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT, CKR_USER_NOT_LOGGED_IN, CKR_WRAPPED_KEY_INVALID, CKR_WRAPPED_KEY_LEN_RANGE</returns>
public CKR C_UnwrapKey(uint session, ref CK_MECHANISM mechanism, uint unwrappingKey, byte[] wrappedKey, uint wrappedKeyLen, CK_ATTRIBUTE[] template, uint attributeCount, ref uint key)
{
if (this._disposed)
throw new ObjectDisposedException(this.GetType().FullName);
return _delegates.C_UnwrapKey(session, ref mechanism, unwrappingKey, wrappedKey, wrappedKeyLen, template, attributeCount, ref key);
}
internal static extern uint C_DeriveKey(uint session, ref CK_MECHANISM mechanism, uint baseKey, CK_ATTRIBUTE[] template, uint attributeCount, ref uint key);
/// <summary>
/// Derives a key from a base key, creating a new key object
/// </summary>
/// <param name="session">The session's handle</param>
/// <param name="mechanism">Key derivation mechanism</param>
/// <param name="baseKey">The handle of the base key</param>
/// <param name="template">The template for the new key</param>
/// <param name="attributeCount">The number of attributes in the template</param>
/// <param name="key">Location that receives the handle of the derived key</param>
/// <returns>CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_READ_ONLY, CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_VALUE_INVALID, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_DOMAIN_PARAMS_INVALID, CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_KEY_HANDLE_INVALID, CKR_KEY_SIZE_RANGE, CKR_KEY_TYPE_INCONSISTENT, CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED, CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY, CKR_TEMPLATE_INCOMPLETE, CKR_TEMPLATE_INCONSISTENT, CKR_TOKEN_WRITE_PROTECTED, CKR_USER_NOT_LOGGED_IN</returns>
public CKR C_DeriveKey(uint session, ref CK_MECHANISM mechanism, uint baseKey, CK_ATTRIBUTE[] template, uint attributeCount, ref uint key)
{
if (this._disposed)
throw new ObjectDisposedException(this.GetType().FullName);
return _delegates.C_DeriveKey(session, ref mechanism, baseKey, template, attributeCount, ref key);
}
internal static extern uint C_SignRecoverInit(uint session, ref CK_MECHANISM mechanism, uint key);
public void _03_ByteArrayParameterTest()
{
byte[] parameter = new byte[16];
System.Random rng = new Random();
rng.NextBytes(parameter);
// Create mechanism with the byte array parameter
IMechanism mechanism = Settings.Factories.MechanismFactory.Create(CKM.CKM_AES_CBC, parameter);
Assert.IsTrue(mechanism.Type == ConvertUtils.UInt64FromCKM(CKM.CKM_AES_CBC));
// We access private members here just for the testing purposes
if (Platform.NativeULongSize == 4)
{
if (Platform.StructPackingSize == 0)
{
HLA40.Mechanism mechanism40 = (HLA40.Mechanism)mechanism;
LLA40.CK_MECHANISM ckMechanism40 = (LLA40.CK_MECHANISM) typeof(HLA40.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism40);
Assert.IsTrue(ckMechanism40.Mechanism == ConvertUtils.UInt32FromCKM(CKM.CKM_AES_CBC));
Assert.IsTrue(ckMechanism40.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism40.ParameterLen) == parameter.Length);
}
else
{
HLA41.Mechanism mechanism41 = (HLA41.Mechanism)mechanism;
LLA41.CK_MECHANISM ckMechanism41 = (LLA41.CK_MECHANISM) typeof(HLA41.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism41);
Assert.IsTrue(ckMechanism41.Mechanism == ConvertUtils.UInt32FromCKM(CKM.CKM_AES_CBC));
Assert.IsTrue(ckMechanism41.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism41.ParameterLen) == parameter.Length);
}
}
else
{
if (Platform.StructPackingSize == 0)
{
HLA80.Mechanism mechanism80 = (HLA80.Mechanism)mechanism;
LLA80.CK_MECHANISM ckMechanism80 = (LLA80.CK_MECHANISM) typeof(HLA80.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism80);
Assert.IsTrue(ckMechanism80.Mechanism == ConvertUtils.UInt64FromCKM(CKM.CKM_AES_CBC));
Assert.IsTrue(ckMechanism80.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism80.ParameterLen) == parameter.Length);
}
else
{
HLA81.Mechanism mechanism81 = (HLA81.Mechanism)mechanism;
LLA81.CK_MECHANISM ckMechanism81 = (LLA81.CK_MECHANISM) typeof(HLA81.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism81);
Assert.IsTrue(ckMechanism81.Mechanism == ConvertUtils.UInt64FromCKM(CKM.CKM_AES_CBC));
Assert.IsTrue(ckMechanism81.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism81.ParameterLen) == parameter.Length);
}
}
parameter = null;
// Create mechanism with null byte array parameter
mechanism = Settings.Factories.MechanismFactory.Create(CKM.CKM_AES_CBC, parameter);
Assert.IsTrue(mechanism.Type == ConvertUtils.UInt64FromCKM(CKM.CKM_AES_CBC));
// We access private members here just for the testing purposes
if (Platform.NativeULongSize == 4)
{
if (Platform.StructPackingSize == 0)
{
HLA40.Mechanism mechanism40 = (HLA40.Mechanism)mechanism;
LLA40.CK_MECHANISM ckMechanism40 = (LLA40.CK_MECHANISM) typeof(HLA40.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism40);
Assert.IsTrue(ckMechanism40.Mechanism == ConvertUtils.UInt32FromCKM(CKM.CKM_AES_CBC));
Assert.IsTrue(ckMechanism40.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism40.ParameterLen == 0);
}
else
{
HLA41.Mechanism mechanism41 = (HLA41.Mechanism)mechanism;
LLA41.CK_MECHANISM ckMechanism41 = (LLA41.CK_MECHANISM) typeof(HLA41.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism41);
Assert.IsTrue(ckMechanism41.Mechanism == ConvertUtils.UInt32FromCKM(CKM.CKM_AES_CBC));
Assert.IsTrue(ckMechanism41.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism41.ParameterLen == 0);
}
}
else
{
if (Platform.StructPackingSize == 0)
{
HLA80.Mechanism mechanism80 = (HLA80.Mechanism)mechanism;
LLA80.CK_MECHANISM ckMechanism80 = (LLA80.CK_MECHANISM) typeof(HLA80.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism80);
Assert.IsTrue(ckMechanism80.Mechanism == ConvertUtils.UInt64FromCKM(CKM.CKM_AES_CBC));
Assert.IsTrue(ckMechanism80.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism80.ParameterLen == 0);
}
else
{
HLA81.Mechanism mechanism81 = (HLA81.Mechanism)mechanism;
LLA81.CK_MECHANISM ckMechanism81 = (LLA81.CK_MECHANISM) typeof(HLA81.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism81);
Assert.IsTrue(ckMechanism81.Mechanism == ConvertUtils.UInt64FromCKM(CKM.CKM_AES_CBC));
Assert.IsTrue(ckMechanism81.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism81.ParameterLen == 0);
}
}
}
/// <summary>
/// Initializes a message-digesting operation
/// </summary>
/// <param name="session">The session's handle</param>
/// <param name="mechanism">The digesting mechanism</param>
/// <returns>CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED, CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN</returns>
public CKR C_DigestInit(uint session, ref CK_MECHANISM mechanism)
{
if (this._disposed)
throw new ObjectDisposedException(this.GetType().FullName);
return _delegates.C_DigestInit(session, ref mechanism);
}
internal static extern NativeULong C_VerifyRecoverInit(NativeULong session, ref CK_MECHANISM mechanism, NativeULong key);
/// <summary>
/// Initializes a signature verification operation, where the data is recovered from the signature
/// </summary>
/// <param name="session">The session's handle</param>
/// <param name="mechanism">Verification mechanism</param>
/// <param name="key">The handle of the verification key</param>
/// <returns>CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_KEY_FUNCTION_NOT_PERMITTED, CKR_KEY_HANDLE_INVALID, CKR_KEY_SIZE_RANGE, CKR_KEY_TYPE_INCONSISTENT, CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED, CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN</returns>
public CKR C_VerifyRecoverInit(uint session, ref CK_MECHANISM mechanism, uint key)
{
if (this._disposed)
throw new ObjectDisposedException(this.GetType().FullName);
return _delegates.C_VerifyRecoverInit(session, ref mechanism, key);
}
internal static extern uint C_DigestInit(uint session, ref CK_MECHANISM mechanism);
/// <summary>
/// Creates mechanism of given type with parameter copied from managed byte array to the newly allocated unmanaged memory
/// </summary>
/// <param name="mechanism">Mechanism type</param>
/// <param name="parameter">Mechanism parameter</param>
/// <returns>Mechanism of given type with specified parameter</returns>
private static CK_MECHANISM _CreateMechanism(uint mechanism, byte[] parameter)
{
CK_MECHANISM mech = new CK_MECHANISM();
mech.Mechanism = mechanism;
if ((parameter != null) && (parameter.Length > 0))
{
mech.Parameter = UnmanagedMemory.Allocate(parameter.Length);
UnmanagedMemory.Write(mech.Parameter, parameter);
mech.ParameterLen = Convert.ToUInt32(parameter.Length);
}
else
{
mech.Parameter = IntPtr.Zero;
mech.ParameterLen = 0;
}
return mech;
}
internal static extern uint C_SignInit(uint session, ref CK_MECHANISM mechanism, uint key);
internal static extern CKR C_DigestInit(uint session, ref CK_MECHANISM mechanism);
internal static extern uint C_VerifyRecoverInit(uint session, ref CK_MECHANISM mechanism, uint key);
internal static extern CKR C_VerifyRecoverInit(uint session, ref CK_MECHANISM mechanism, uint key);
internal static extern uint C_GenerateKey(uint session, ref CK_MECHANISM mechanism, CK_ATTRIBUTE[] template, uint count, ref uint key);
internal static extern CKR C_GenerateKeyPair(uint session, ref CK_MECHANISM mechanism, CK_ATTRIBUTE[] publicKeyTemplate, uint publicKeyAttributeCount, CK_ATTRIBUTE[] privateKeyTemplate, uint privateKeyAttributeCount, ref uint publicKey, ref uint privateKey);
internal static extern uint C_GenerateKeyPair(uint session, ref CK_MECHANISM mechanism, CK_ATTRIBUTE[] publicKeyTemplate, uint publicKeyAttributeCount, CK_ATTRIBUTE[] privateKeyTemplate, uint privateKeyAttributeCount, ref uint publicKey, ref uint privateKey);
internal static extern CKR C_UnwrapKey(uint session, ref CK_MECHANISM mechanism, uint unwrappingKey, byte[] wrappedKey, uint wrappedKeyLen, CK_ATTRIBUTE[] template, uint attributeCount, ref uint key);
internal static extern uint C_WrapKey(uint session, ref CK_MECHANISM mechanism, uint wrappingKey, uint key, byte[] wrappedKey, ref uint wrappedKeyLen);
/// <summary>
/// Creates mechanism of given type with object parameter
/// </summary>
/// <param name="type">Mechanism type</param>
/// <param name="parameter">Mechanism parameter</param>
public Mechanism(CKM type, IMechanismParams parameter)
{
if (parameter == null)
throw new ArgumentNullException("parameter");
// Keep reference to parameter so GC will not free it while mechanism exists
_mechanismParams = parameter;
object lowLevelParams = _mechanismParams.ToMarshalableStructure();
_ckMechanism = CkmUtils.CreateMechanism(type, lowLevelParams);
}
internal static extern uint C_UnwrapKey(uint session, ref CK_MECHANISM mechanism, uint unwrappingKey, byte[] wrappedKey, uint wrappedKeyLen, CK_ATTRIBUTE[] template, uint attributeCount, ref uint key);
/// <summary>
/// Creates mechanism of given type with byte array parameter
/// </summary>
/// <param name="type">Mechanism type</param>
/// <param name="parameter">Mechanism parameter</param>
public Mechanism(uint type, byte[] parameter)
{
_ckMechanism = CkmUtils.CreateMechanism(type, parameter);
}
internal static extern NativeULong C_DigestInit(NativeULong session, ref CK_MECHANISM mechanism);
