Closed. This question is off-topic。它当前不接受答案。
想改善这个问题吗？ Update the question，所以它是on-topic，用于堆栈溢出。
2年前关闭。
我正在使用PKCS11Interop在HSM中执行密钥管理操作。我使用的HSM是Thales PCI Express。以下是包装在HSM中执行的所有操作的类：
如果您注意到我正在使用两个对象来应用锁。对象_syncLockPkcs11用于在m_Pkcs11上实现单例，而_syncLockHSMLogin用于将Login同步到HSM。早些时候，当我没有这些锁时，我曾经从HSM，CKU_USER_ALREADY_LOGGED_IN和CKR_FUNCTION_FAILED中获得以下错误。我根据此link中提供的信息以及第6.7.7节“ document的会话使用示例”（即![c# - C#中PKCS11Interop库的线程安全用法-LMLPHP]( "c# - C#中PKCS11Interop库的线程安全用法-LMLPHP")
）实施了此更改
在我当前的实现中，我没有遇到任何这些错误，但是希望在这里了解专家的意见。
我的一些问题是：
以这种方式使用m_Pkcs11是否可以，即不在整个过程生命周期内对其进行处理？
是否可以对HSM登录方法应用锁定？我之所以问是因为我没有找到任何在线参考资料表明这一点。
有没有办法更好地实现这一目标？
想改善这个问题吗？ Update the question，所以它是on-topic，用于堆栈溢出。
2年前关闭。
我正在使用PKCS11Interop在HSM中执行密钥管理操作。我使用的HSM是Thales PCI Express。以下是包装在HSM中执行的所有操作的类：
public sealed class KeyStoreOperations
{
private KeyStoreContext m_keyStoreContext;
private static Pkcs11 m_Pkcs11;
private static readonly object _syncLockPkcs11 = new object();
private static readonly object _syncLockHSMLogin = new object();
public KeyStoreOperations(KeyStoreContext keyStoreContext)
{
m_keyStoreContext = keyStoreContext;
InitializePkcs11Object();
}
/// <summary>
/// Generates key in the key store
/// </summary>
/// <param name="keyName"></param>
/// <returns></returns>
public void GenerateKey(string keyName)
{
HSMTransactionHandler((Session session) =>
{
Mechanism mechanism = new Mechanism(CKM.CKM_RSA_PKCS_KEY_PAIR_GEN);
ObjectHandle publicKeyHandle = null;
ObjectHandle privateKeyHandle = null;
byte[] ckaId = session.GenerateRandom(20);
List<ObjectAttribute> publicKeyAttributes = CreatePublicKeyTemplate(keyName, ckaId);
List<ObjectAttribute> privateKeyAttributes = CreatePrivateKeyTemplate(keyName, ckaId);
session.GenerateKeyPair(mechanism, publicKeyAttributes, privateKeyAttributes, out publicKeyHandle, out privateKeyHandle);
});
}
/// <summary>
/// Destroys key in the key store
/// </summary>
/// <param name="keyLabel"></param>
/// <returns></returns>
public void DestroyKey(string keyName)
{
HSMTransactionHandler((Session session) =>
{
var publicKeyHandle = GetPublicKey(keyName, session);
var privateKeyHandle = GetPrivateKey(keyName, session);
if (publicKeyHandle != null && privateKeyHandle != null)
{
session.DestroyObject(publicKeyHandle);
session.DestroyObject(privateKeyHandle);
}
});
}
/// <summary>
/// Encrypts a message using the key in the key store
/// </summary>
/// <param name="keyName"></param>
/// <param name="message"></param>
/// <returns></returns>
public string Encrypt(string keyName, string message)
{
ValidateInputs(message, "Message");
var encryptedMessage = string.Empty;
HSMTransactionHandler((Session session) =>
{
Mechanism mechanism = new Mechanism(CKM.CKM_RSA_PKCS);
var publicKey = GetPublicKey(keyName, session);
if (publicKey == null)
throw new HSMException(ErrorConstant.HSM_ENCRYPTION_KEY_NOT_FOUND);
var originalKeyBytes = EncryptionHelper.Decode(message);
var encryptedKeyBytes = session.Encrypt(mechanism, publicKey, originalKeyBytes);
encryptedMessage = EncryptionHelper.Encode(encryptedKeyBytes);
});
return encryptedMessage;
}
/// <summary>
/// Decrypts a key using the key in the key store
/// </summary>
/// <param name="keyName"></param>
/// <param name="cipher"></param>
/// <returns></returns>
public string Decrypt(string keyName, string cipher)
{
ValidateInputs(cipher, "Cipher");
var decryptedMessage = string.Empty;
HSMTransactionHandler((Session session) =>
{
Mechanism mechanism = new Mechanism(CKM.CKM_RSA_PKCS);
var privateKey = GetPrivateKey(keyName, session);
if (privateKey == null)
throw new HSMException(ErrorConstant.HSM_ENCRYPTION_KEY_NOT_FOUND);
var encryptedSymmetricKeyBytes = EncryptionHelper.Decode(cipher);
var decryptedSymmetricKeyBytes = session.Decrypt(mechanism, privateKey, encryptedSymmetricKeyBytes);
decryptedMessage = EncryptionHelper.Encode(decryptedSymmetricKeyBytes);
});
return decryptedMessage;
}
#region Private methods
#region Validations
private void ValidateInputs(string input, string name)
{
if (string.IsNullOrEmpty(input))
throw new ArgumentNullException(name);
}
#endregion Validations
private void HSMTransactionHandler(Action<Session> action)
{
Slot hsmSlot = null;
Session hsmSession = null;
try
{
hsmSlot = GetSlot(m_keyStoreContext.ModuleToken);
hsmSession = hsmSlot.OpenSession(false);
lock (_syncLockHSMLogin)
{
hsmSession.Login(CKU.CKU_USER, m_keyStoreContext.SecurityPin);
action(hsmSession);
hsmSession.Logout();
}
}
catch (Pkcs11Exception ex)
{
HandleHSMErrors(ex);
}
finally
{
if (!(hsmSession == null))
hsmSession.CloseSession();
}
}
private ObjectHandle GetPrivateKey(string keyName, Session session)
{
ObjectHandle privateKey = null;
List<ObjectHandle> foundObjects = null;
List<ObjectAttribute> objectAttributes = new List<ObjectAttribute>();
objectAttributes.Add(new ObjectAttribute(CKA.CKA_LABEL, keyName));
objectAttributes.Add(new ObjectAttribute(CKA.CKA_PRIVATE, true));
foundObjects = session.FindAllObjects(objectAttributes);
if (foundObjects != null && foundObjects.Count > 0)
{
privateKey = foundObjects[0];
}
return privateKey;
}
private ObjectHandle GetPublicKey(string keyName, Session session)
{
ObjectHandle publicKey = null;
List<ObjectHandle> foundObjects = null;
List<ObjectAttribute> objectAttributes = new List<ObjectAttribute>();
objectAttributes.Add(new ObjectAttribute(CKA.CKA_LABEL, keyName));
objectAttributes.Add(new ObjectAttribute(CKA.CKA_PRIVATE, false));
foundObjects = session.FindAllObjects(objectAttributes);
if (foundObjects != null && foundObjects.Count > 0)
{
publicKey = foundObjects[0];
}
return publicKey;
}
private List<ObjectAttribute> CreatePublicKeyTemplate(string keyName, byte[] ckaId)
{
List<ObjectAttribute> publicKeyAttributes = new List<ObjectAttribute>();
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_TOKEN, true));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_PRIVATE, false));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_LABEL, keyName));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_ID, ckaId));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_ENCRYPT, true));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_VERIFY, true));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_VERIFY_RECOVER, true));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_WRAP, true));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_MODULUS_BITS, Convert.ToUInt64(m_keyStoreContext.KeySize)));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_PUBLIC_EXPONENT, new byte[] { 0x01, 0x00, 0x01 }));
return publicKeyAttributes;
}
private List<ObjectAttribute> CreatePrivateKeyTemplate(string keyName, byte[] ckaId)
{
List<ObjectAttribute> privateKeyAttributes = new List<ObjectAttribute>();
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_TOKEN, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_PRIVATE, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_LABEL, keyName));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_ID, ckaId));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_SENSITIVE, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_DECRYPT, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_SIGN, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_SIGN_RECOVER, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_UNWRAP, true));
return privateKeyAttributes;
}
private Slot GetSlot(string tokenLabel)
{
Slot matchingSlot = null;
List<Slot> slots = m_Pkcs11.GetSlotList(true);
matchingSlot = slots[0];
if (tokenLabel != null)
{
matchingSlot = null;
foreach (Slot slot in slots)
{
TokenInfo tokenInfo = null;
try
{
tokenInfo = slot.GetTokenInfo();
}
catch (Pkcs11Exception ex)
{
if (ex.RV != CKR.CKR_TOKEN_NOT_RECOGNIZED && ex.RV != CKR.CKR_TOKEN_NOT_PRESENT)
throw;
}
if (tokenInfo == null)
continue;
if (!string.IsNullOrEmpty(m_keyStoreContext.ModuleToken))
if (0 != string.Compare(m_keyStoreContext.ModuleToken, tokenInfo.Label, StringComparison.Ordinal))
continue;
matchingSlot = slot;
break;
}
if (matchingSlot == null)
throw new HSMException(string.Format(ErrorConstant.HSM_CONFIGURATION_ERROR_INCORRECT_SLOT, tokenLabel));
}
return matchingSlot;
}
private void InitializePkcs11Object()
{
if (m_Pkcs11 == null)
{
lock (_syncLockPkcs11)
{
m_Pkcs11 = new Pkcs11(m_keyStoreContext.PKCS11LibraryPath, true);
}
}
}
private void HandleHSMErrors(Pkcs11Exception ex)
{
if (ex.RV == CKR.CKR_PIN_INCORRECT)
{
throw new HSMException(ErrorConstant.HSM_CONFIGURATION_ERROR_PIN_INCORRECT, ex);
}
else
{
throw new HSMException(ErrorConstant.HSM_CONFIGURATION_ERROR_GENERIC, ex);
}
}
#endregion
}
如果您注意到我正在使用两个对象来应用锁。对象_syncLockPkcs11用于在m_Pkcs11上实现单例，而_syncLockHSMLogin用于将Login同步到HSM。早些时候，当我没有这些锁时，我曾经从HSM，CKU_USER_ALREADY_LOGGED_IN和CKR_FUNCTION_FAILED中获得以下错误。我根据此link中提供的信息以及第6.7.7节“ document的会话使用示例”（即
在我当前的实现中，我没有遇到任何这些错误，但是希望在这里了解专家的意见。
我的一些问题是：
以这种方式使用m_Pkcs11是否可以，即不在整个过程生命周期内对其进行处理？
是否可以对HSM登录方法应用锁定？我之所以问是因为我没有找到任何在线参考资料表明这一点。
有没有办法更好地实现这一目标？
最佳答案
您所有问题的答案都在PKCS#11 v2.20 specificiation中“隐藏”。
有关在整个过程生命周期中不废弃m_Pkcs11的更多信息，请参见第6.6章：
通过调用以下命令，应用程序变为“ Cryptoki应用程序”
加密函数C_Initialize（请参见第11.4节）之一
线程;进行此调用后，应用程序可以调用其他
加密功能。使用Cryptoki完成应用程序后，它将
调用Cryptoki函数C_Finalize（请参见第11.4节）并停止
成为Cryptoki应用程序。
换句话说，您只需创建一次Pkcs11类的实例，然后您的所有线程都可以访问PKCS＃11函数。我见过的应用程序确实使用Pkcs11类的单个实例，并且几个月都没有对其进行处理。这是一种完全有效的用法。
有关登录状态的更多信息，请参见第6.7.4章：
在Cryptoki中，应用程序与令牌进行的所有会话都必须
具有相同的登录/注销状态（即，对于给定的应用程序和
令牌，具有以下条件之一：所有会话均为公开会话；
所有会话均为SO会话；或所有会话都是用户会话）。什么时候
应用程序的会话登录到令牌，该应用程序的所有
使用该令牌的会话登录，以及应用程序的登录时间
会话注销令牌，该应用程序的所有会话均与
该令牌被注销。
换句话说，登录到一个会话后，您还将登录到所有现有会话以及将来打开的所有会话中。这是您收到CKU_USER_ALREADY_LOGGED_IN错误的主要原因。我见过登录到单个会话并保持打开状态数月的应用程序。顺便说一句，您可以使用Session::GetSessionInfo()方法来检查您的会话是否已经登录。
有关与您相似的类的真实示例，请查看Pkcs11RsaSignature项目中的Pkcs11Interop.PDF类。
关于c# - C#中PKCS11Interop库的线程安全用法，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/44715797/
10-09 21:57