message GetMechanismListRequest {
    }
    message GetMechanismListResponse {
      repeated uint64 Mechs = 2;
    }
    

    CK_RV m_GetMechanismList (
      CK_SLOT_ID slot,
      CK_MECHANISM_TYPE_PTR mechs, CK_ULONG_PTR mechslen,
      target_t 目標
    );
    

C_GetMechanismList 用來取得記號所支援的機制類型清單。 SlotID 是記號空位的 ID；pulCount 指向接收機制數目的位置。

有兩種方法可供應用程式呼叫 C_GetMechanismList:

1. 如果 pMechanismList 是 NULL_PTR，則 C_GetMechanismList 只會傳回機制數目 (在 *pulCount中)，而不會傳回機制清單。 在這種情況下，進入 C_GetMechanismList 時 *pulCount 的內容沒有任何意義，並且該呼叫會傳回值 CKR_OK。
2. 如果 pMechanism清單 不是 NULL_PTR，則 *pulCount 必須包含 pMechanism清單所指向之緩衝區的大小 (就 CK_MECHANISM_TYPE 元素而言)。 如果該緩衝區夠大，而無法保留機制清單，則會在其中傳回該清單，並傳回 CKR_OK。 否則，呼叫 C_GetMechanismList 會傳回值 CKR_BUFFER_TOO_SMALL。 在任一情況下，值 *pulCount 都會設定為保留機制數目。

因為 C_GetMechanismList 不會配置自己的任何空間，所以應用程式通常會兩次呼叫 C_GetMechanismList。 不過，這不是必要行為。

    CK_DEFINE_FUNCTION(CK_RV, C_GetMechanismList)(
      CK_SLOT_ID slotID,
      CK_MECHANISM_TYPE_PTR pMechanismList,
      CK_ULONG_PTR pulCount
    );
    

    message GetMechanismInfoRequest {
      uint64 Mech = 2;
    }
    message GetMechanismInfoResponse {
      MechanismInfo MechInfo = 3;
    }
    

    CK_RV m_GetMechanismInfo (
      CK_SLOT_ID slot,
      CK_MECHANISM_TYPE mech,
      CK_MECHANISM_INFO_PTR mechInfo,
      target_t 目標
    );
    

C_GetMechanism資訊 會取得記號可能支援之特定機制的相關資訊。slotID 是記號插槽的 ID; type 是機制的類型; pInfo 指向接收機制資訊的位置。

    CK_DEFINE_FUNCTION(CK_RV, C_GetMechanismInfo)(
      CK_SLOT_ID slotID,
      CK_MECHANISM_TYPE type,
      CK_MECHANISM_INFO_PTR pInfo
    );
    

    message GenerateKeyRequest {
      Mechanism Mech = 1;
      map<uint64,AttributeValue> 範本 = 6;
    }
    message GenerateKeyResponse {
      bytes KeyBytes = 4;
      bytes CheckSum = 5;
    }
    

PKCS #11 C_GenerateKey 的實作。

TDES 金鑰是以主機無法觀察到的適當同位檢查來產生。 但是需要它才能適當的交互作業能力: 其他 PKCS #11 實作需要拒絕具有同位檢查問題的 DES 金鑰。

如果物件關聯於階段作業，則 登入 必須傳回 (pin，plen) 給該階段作業。 將 pin 保留為 NULL 會建立一個未連結至登入階段作業的公用物件。

(key，klen) 會傳回金鑰二進位大型物件。(csum，clen) 包含金鑰的總和檢查，亦即，由金鑰加密的全零區塊中最重要的位元組。 例如，針對不使用 CKA_CHECK_VALUE 參數的對稱金鑰機制（如 RC4），可以使用 NULL clen。

只有在機制需要金鑰長度 (即 CKA_VALUE_LEN 屬性) 時，才會使用 ptempl。 如果機制隱含地指定金鑰大小，則不會檢查 ptempl 以取得大小。

DSA 和 DH 參數產生會忽略 (csum, clen)，並且只會產生參數結構。

DSA，DH 參數 (CKM_DSA_PARAMETER_GEN): 在屬性的 CKA_PRIME_BITS 中傳遞模數位元計數。 將 P、Q、G 結構寫入為明碼輸出 (亦即，不是二進位大型物件)。

pin 二進位大型物件是來自 Login 的輸出。

PKCS #11 phKey 未對映至任何 EP11 參數。 （主機程式庫必須將已包裝的金鑰連結到控點。）

    CK_RV m_GenerateKey (
      CK_MECHANISM_PTR mech,
      CK_ATTRIBUTE_PTR template, CK_ULONG templatelen,
      const unsigned char *pin, size_t pinlen,
      unsigned char * key，size_t * keylen，
      unsigned char *checkSum，size_t *checkSumlen，
      target_t 目標
      );
    

C_GenerateKey 會產生秘密金鑰或網域參數集，以建立新物件。hSession 是階段作業的控點; pMechanism 指向產生機制; pTemplate 指向新金鑰或網域參數集的範本; ulCount 是範本中的屬性數目; phKey 指向接收新金鑰或網域參數集控點的位置。

如果產生機制用於網域參數產生，則 CKA_CLASS 屬性具有值 CKO_DOMAIN_PARAMETERS; 否則，它具有值 CKO_SECRET_KEY。

因為要產生的金鑰或網域參數的類型在產生機制中是隱含的，所以範本不需要提供金鑰類型。 如果它提供的金鑰類型與產生機制不一致，則 C_GenerateKey 會失敗，並傳回錯誤碼 CKR_TEMPLATE_INCONSISTENT。 CKA_CLASS 屬性的處理方式相同。

如果對 C_GenerateKey 的呼叫無法支援提供給它的精確範本，則它會失敗並在未建立物件的情況下返回。

成功呼叫 C_GenerateKey 所建立的物件會將 CKA_LOCAL 屬性設為 CK_TRUE。

    CK_DEFINE_FUNCTION(CK_RV, C_GenerateKey)(
      CK_SESSION_HANDLE hSession
      CK_MECHANISM_PTR pMechanism,
      CK_ATTRIBUTE_PTR pTemplate,
      CK_ULONG ulCount,
      CK_OBJECT_HANDLE_PTR phKey
      );
    

    message GenerateKeyPairRequest {
      Mechanism Mech = 1;
      map<uint64,AttributeValue> PrivKey範本 = 7;
      map<uint64,AttributeValue> PubKey範本 = 8;
      }
    message GenerateKeyPairResponse {
      bytes PrivKeyBytes = 5;
      bytes PubKeyBytes = 6;
    }
    

PKCS #11 C_GenerateKeyPair 的實作。

金鑰組參數是從 pmech、ppublic 和 pprivate 參數中所擷取。 對於 RSA 金鑰，ppublic 指定模數大小。

在 FIPS 模式中，僅支援 1024 + 256 n 位元的 RSA 模數 (整數 n)。 非 FIPS 模式可以在機制參數清單的限制之間產生任何偶數位元數目的金鑰。

公開金鑰格式化為標準 SPKI (主體公開金鑰資訊)，可供大部分程式庫讀取。 它由傳輸金鑰特有的 MAC 進行完整性保護，該 MAC 不屬於 SPKI 本身。 DSA 參數產生會在公開金鑰欄位中傳回非 SPKI 結構。

如果您將物件連結至階段作業，則 登入 該階段作業必須傳回 (pin，plen)。 離開 pin NULL 會建立公用物件，在登入階段作業之後仍然存在。

將已包裝的私密金鑰傳回到 (key, klen)，而將公開金鑰傳回為 (pubkey, pklen) 中的已設定 MAC 的 ASN.1/DER 結構。

下列受支援具有特殊注意事項的參數組合超出 PKCS #11所記載的範圍:

RSA 金鑰拒絕低於 17 (0x11) 的公用指數。 控制點可以進一步限制接受的最小值。 Fermat4 指數 (0x10001) 由特定控制點進行控制，並符合 FIPS 186-3（第 B.3.1 節）的公用指數限制。

EC 金鑰 (CKM_EC_KEY_PAIR_GEN): 曲線參數可以指定為 OID 或符號名稱 (我們的 namedCurve 變式)。 支援的符號名稱為 "P-nnn" 代表 NIST 曲線 (nnn 是支援的主要位元計數，192-521)，"BP-nnnR" 代表一般 BP 曲線。 （名稱必須以 ASCII 字串形式提供，並且不能以零終止。）

DSA 金鑰 (CKM_DSA_KEY_PAIR_GEN)：將 P,Q,G 結構作為公用屬性的 CKA_IBM_STRUCT_PARAMS 屬性傳遞。 個別 P、Q、G 參數可能不會透過一般 PKCS #11 參數傳遞，它們必須結合成單一結構。

DH 金鑰 (CKM_DH_PKCS_KEY_PAIR_GEN)：將 P,G 結構作為公用屬性的 CKA_IBM_STRUCT_PARAMS 屬性傳遞。 個別 P、G 參數可能不會透過一般 PKCS #11 參數傳遞，它們必須結合成單一結構。 當您選取私密金鑰 (X) 位元計數時，請使用 XCP_U32_VALUE_BITS 屬性。 如果此屬性不存在，或提供明確 0，則會根據 P 位元計數來選取位元計數。

階段作業 (登入) 狀態的使用會取代階段作業的標準使用。 對映在程式庫範圍之外。

pin 二進位大型物件是來自 Login 的輸出。

PKCS #11 hSession 未對映至任何 EP11 參數。 （呼叫未直接與任何階段作業相關聯。）

PKCS #11 phPublicKey 未對映至任何 EP11 參數。 （主機程式庫必須將公開金鑰 (SPKI) 與控點相關聯。）

PKCS #11 phPrivateKey 未對映至任何 EP11 參數。 （主機程式庫必須將私密金鑰與控點相關聯。）

    CK_RV m_GenerateKeyPair (
      CK_MECHANISM_PTR mech,
      CK_ATTRIBUTE_PTR pubKeyTemplate, CK_ULONG pubKeyTemplatelen,
      CK_ATTRIBUTE_PTR privKeyTemplate, CK_ULONG privKeyTemplatelen,
      const unsigned char *pin, size_t pinlen,
      unsigned char *privKey，size_t *privKeylen，
      unsigned char *pubKey，size_t *pubKeylen，
      target_t 目標
      );
    

C_GenerateKey配對 會產生公開和私密金鑰組，以建立新的金鑰物件。hSession 是階段作業的控點; pMechanism 指向金鑰產生機制; pPublicKeyTemplate 指向公開金鑰的範本; ulPublicKeyAttributeCount 是公開金鑰範本中的屬性數目; pPrivateKeyTemplate 指向私密金鑰的範本; ulPrivateKeyAttributeCount 是私密金鑰範本中的屬性數目; phPublic金鑰 指向接收新公開金鑰控點的位置; phPrivate金鑰 指向接收新私密金鑰控點的位置。

因為要產生的金鑰類型隱含在金鑰組產生機制中，所以範本不需要提供金鑰類型。 如果其中一個範本提供的金鑰類型與金鑰產生機制不一致，C_GenerateKeyPair 會失敗，並傳回錯誤碼 CKR_TEMPLATE_INCONSISTENT。 CKA_CLASS 屬性的處理方式類似。

如果呼叫 C_GenerateKeyPair 無法支援提供給它的精確範本，則會失敗並傳回，而不會建立任何金鑰物件。

對 C_GenerateKeyPair 的呼叫絕不會只建立一個金鑰並返回。 呼叫可能失敗，且不會建立任何金鑰; 也可能成功，並建立相符的公開和私密金鑰組。

成功呼叫 C_GenerateKeyPair 所建立的金鑰物件，會將 CKA_LOCAL 屬性設為 CK_TRUE。

請仔細注意 C_GenerateKeyPair 的引數順序。 最後兩個引數的順序與原始 Cryptoki 1.0 版文件中的順序不同。 這兩個論點的先後次序引起了一些不幸的混亂。

    CK_DEFINE_FUNCTION(CK_RV, C_GenerateKeyPair)(
      CK_SESSION_HANDLE hSession,
      CK_MECHANISM_PTR pMechanism,
      CK_ATTRIBUTE_PTR pPublicKeyTemplate,
      CK_ULONG ulPublicKeyAttributeCount,
      CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
      CK_ULONG ulPrivateKeyAttributeCount,
      CK_OBJECT_HANDLE_PTR phPublicKey,
      CK_OBJECT_HANDLE_PTR phPrivateKey
      );
    

    message DeriveKeyRequest {
        Mechanism Mech = 1;
        bytes BaseKey = 3;
        bytes Data = 4;
        map<uint64,AttributeValue> 範本 = 8;
    }
    message DeriveKeyResponse {
        bytes NewKeyBytes = 6;
        bytes CheckSum = 7;
    }
    

PKCS #11 C_DeriveKey 的實作。

basekey,bklen 二進位大型物件必須從 PKCS #11 hBaseKey 參數對映。

PKCS #11 hSession 未對映至任何 EP11 參數。 （呼叫未直接與任何階段作業相關聯。）

PKCS #11 phKey 未對映至任何 EP11 參數。 （主機程式庫必須將傳回的金鑰連結至控點。）

    CK_RV m_DeriveKey (
        CK_MECHANISM_PTR mech,
        CK_ATTRIBUTE_PTR template, CK_ULONG templatelen,
        const unsigned char *baseKey, size_t baseKeylen,
        const unsigned char *data, size_t datalen,
        const unsigned char *pin, size_t pinlen,
        unsigned char *newKey，size_t *newKeylen，
        unsigned char *checkSum，size_t *checkSumlen，
        target_t 目標
    );
    

C_DeriveKey 會從基本金鑰衍生金鑰，以建立新的金鑰物件。hSession 是階段作業的控點; pMechanism 指向指定金鑰衍生項的結構; hBaseKey 是基本金鑰的控點; pTemplate 指向新金鑰的範本; ulAttributeCount 是範本中的屬性數目; 及 phKey 指向接收衍生金鑰控點的位置。

基本索引鍵的 CKA_SENSITIVE、CKA_ALWAYS_SENSITIVE、CKA_EXTRACTTABLE及 KA_NER_ 可擷取 屬性值會影響這些屬性可以為新衍生金鑰保留的值。 如需此類型的任何限制，請參閱 PKCS #11 API 規格 第 5.16.2 節中每一個特定金鑰衍生機制的說明。

如果對 C_DeriveKey 的呼叫無法支援提供給它的精確範本，則它會失敗並返回，而不會建立任何金鑰物件。

成功呼叫 C_DeriveKey 所建立的金鑰物件將 CKA_LOCAL 屬性設為 CK_FALSE。

    CK_DEFINE_FUNCTION(CK_RV, C_DeriveKey)(
        CK_SESSION_HANDLE hSession,
        CK_MECHANISM_PTR pMechanism,
        CK_OBJECT_HANDLE hBaseKey,
        CK_ATTRIBUTE_PTR pTemplate,
        CK_ULONG ulAttributeCount,
        CK_OBJECT_HANDLE_PTR phKey
    );
    

    message WrapKeyRequest {
        bytes Key = 1;
        bytes KeK = 2;
        bytes MacKey = 3;
        Mechanism Mech = 4;
    }
    message WrapKeyResponse {
        bytes Wrapped = 5;
    }
    

    CK_RV m_WrapKey (
        const unsigned char *key, size_t keylen,
        const unsigned char *keK, size_t keKlen,
        const unsigned char *macKey, size_t macKeylen,
        const CK_MECHANISM_PTR mech,
        CK_BYTE_PTR wrapped, CK_ULONG_PTR wrappedlen,
        target_t 目標
    );
    

C_WrapKey 會包裝 (即加密) 私密金鑰或秘密金鑰。hSession 是階段作業的控點; pMechanism 指向包裝機制; hWrapping金鑰 是包裝金鑰的控點; hKey 是要包裝的金鑰控點; pWrapped金鑰 指向接收已包裝金鑰的位置; 及 pulWrappedKeyLen 指向接收包裝金鑰長度的位置。

C_WrapKey 使用 PKCS #11 API 規格 第 5.2 節中關於產生輸出的說明。

包裝金鑰的 CKA_WRAP 屬性（指出金鑰是否支援包裝）必須是 CK_TRUE。 要包裝的金鑰的 CKA_EXTRACTABLE 屬性也必須是 CK_TRUE。

如果因某種記號特有原因，盡管要包裝的金鑰的 CKA_EXTRACTABLE 屬性設定為 CK_TRUE 仍然無法包裝該金鑰，則 C_WrapKey 會失敗，錯誤碼為 CKR_KEY_NOT_WRAPABLE。 如果金鑰只因其長度而無法使用指定的包裝金鑰和機制進行包裝，則 C_WrapKey 會失敗，錯誤碼為 CKR_KEY_SIZE_RANGE。

C_WrapKey 可以用於下列情境：

• 使用支援加密和解密的公開金鑰包裝任何秘密金鑰。
• 使用其他任何秘密金鑰包裝任何秘密金鑰。 必須考量金鑰大小及機制強度，否則記號可能不容許作業。
• 使用任何秘密金鑰包裝私密金鑰。

記號會改變哪些類型的金鑰可以使用哪些機制來包裝。

若要分割包裝金鑰，以便它們只能包裝可擷取金鑰的子集，可以在包裝金鑰上使用屬性 CKA_WRAP_TEMPLATE，以指定可與要包裝之金鑰的屬性進行比較的屬性集。 如果所有屬性都符合屬性比對的 C_FindObject 規則，則 wrap 作業會繼續進行。 這個屬性的值是一個屬性範本，而大小是範本中的項目數乘上 CK_ATTRIBUTE 的大小。 如果未提供此屬性，則可接受任何範本。 如果屬性不存在，則不會檢查它。 如果嘗試包裝金鑰時發生任何屬性不符，則函數會傳回 CKR_KEY_HANDLE_INVALID。

    CK_DEFINE_FUNCTION(CK_RV, C_WrapKey)(
        CK_SESSION_HANDLE hSession,
        CK_MECHANISM_PTR pMechanism,
        CK_OBJECT_HANDLE hWrappingKey,
        CK_OBJECT_HANDLE hKey,
        CK_BYTE_PTR pWrappedKey,
        CK_ULONG_PTR pulWrappedKeyLen
    );
    

    message UnwrapKeyRequest {
        bytes Wrapped = 1;
        bytes KeK = 2;
        bytes MacKey = 3;
        Mechanism Mech = 5;
        map<uint64,AttributeValue> 範本 = 9;
    }
    message UnwrapKeyResponse {
        bytes UnwrappedBytes = 7;
        bytes CheckSum = 8;
    }
    

PKCS #11 C_UnwrapKey 的實作。

uwmech 指定用來解密已包裝資料的加密機制。ptempl 是一個 金鑰 (配對) 參數清單，指定如何將未包裝的資料轉換成新的金鑰 (必須包括 CKA_KEY_TYPE)。

產生的物件在 (unwrapped, uwlen) 下作為二進位大型物件傳回。 對稱金鑰在 (csum, cslen) 下傳回其金鑰總和檢查（3 位元組）；公開金鑰物件在 (csum, cslen) 中將其公開金鑰作為 SPKI 傳回。 這兩種形式的後面都會有一個 4 位元組的大序排列法值，並對已解除包裝金鑰的位元計數進行編碼。

當 SPKI 轉換成 MACed SPKI 時，必須使用 CKM_IBM_TRANSPORTKEY 作為解除包裝機制。 此模式會提供原始 SPKI 作為已包裝的資料，並忽略 KEK。

UnwrapKey 會產生同位檢查調整 DES 金鑰 (在二進位大型物件內)，但容許輸入不適當的同位檢查。

    CK_RV m_UnwrapKey (
        const CK_BYTE_PTR wrapped, CK_ULONG wrappedlen,
        const unsigned char *keK, size_t keKlen,
        const unsigned char *macKey, size_t macKeylen,
        const unsigned char *pin, size_t pinlen,
        const CK_MECHANISM_PTR mech,
        const CK_ATTRIBUTE_PTR template, CK_ULONG templatelen,
        unsigned char * unwrapped，size_t * unwrappedlen，
        CK_BYTE_PTR checkSum, CK_ULONG *checkSumlen,
        target_t 目標
    );
    

C_UnwrapKey 會解除包裝 (亦即，解密) 已包裝的金鑰，並建立新的私密金鑰或秘密金鑰物件。hSession 是階段作業的控點; pMechanism 指向解除包裝機制; hUnwrappingKey 是解除包裝金鑰的控點; pWrappedKey 指向已包裝金鑰; ulWrappedKeyLen 是已包裝金鑰的長度; pTemplate 指向新金鑰的範本; ulAttribute計數 是範本中的屬性數目; phKey 會指向接收回復金鑰控點的位置。

解除包裝金鑰的 CKA_UNWRAP 屬性（指出金鑰是否支援解除包裝）必須為 CK_TRUE。

新機碼將 CKA_ALWAYS_SENSITIVE 屬性設為 CK_FALSE，並將 CKA_NEVER_EXTRACTABLE 屬性設為 CK_FALSE。 依預設，CKA_EXTRACTABLE 屬性會設定為 CK_TRUE。

部分機制可以修改，或嘗試修改。 在解除包裝金鑰的同時，pMechanism 結構的內容。

如果呼叫 C_UnwrapKey 無法支援提供給它的精確範本，則它會失敗並傳回，而不會建立任何金鑰物件。

成功呼叫 C_UnwrapKey 所建立的金鑰物件將其 CKA_LOCAL 屬性設為 CK_FALSE。

若要分割解除包裝金鑰，以便它們只能解除包裝金鑰的子集，可以在解除包裝金鑰上使用屬性 CKA_UNWRAP_TEMPLATE，以指定新增至要解除包裝之金鑰屬性的屬性集。 如果屬性與使用者提供的屬性範本不衝突，在 pTemplate中，unwrap 作業會繼續進行。 這個屬性的值是一個屬性範本，而大小是範本中的項目數乘上 CK_ATTRIBUTE 的大小。 如果解除包裝金鑰上不存在此屬性，則不會新增任何額外屬性。 如果嘗試解除包裝金鑰時發生任何屬性衝突，則函數 SHALL 會傳回 CKR_TEMPLATE_INCONSISTENT。

    CK_DEFINE_FUNCTION(CK_RV, C_UnwrapKey)(
        CK_SESSION_HANDLE hSession,
        CK_MECHANISM_PTR pMechanism,
        CK_OBJECT_HANDLE hUnwrappingKey,
        CK_BYTE_PTR pWrappedKey,
        CK_ULONG ulWrappedKeyLen,
        CK_ATTRIBUTE_PTR pTemplate,
        CK_ULONG ulAttributeCount,
        CK_OBJECT_HANDLE_PTR phKey
    );
    

    message RewrapKeyBlobRequest {
    	bytes WrappedKey = 1;
    }
    message RewrapKeyBlobResponse {
    	bytes RewrappedKey = 1;
    }
    

    message GetAttributeValueRequest {
        bytes Object = 1;
        map<uint64,AttributeValue> 屬性 = 3;
    }
    message GetAttributeValueResponse {
        map<uint64,AttributeValue> 屬性 = 4;
    }
    

PKCS #11 C_GetAttributeValue 的實作。

不代表或不需要階段作業 (二進位大型物件的一部分)，因此不使用 hSession 參數。

EP11 使用更直接明確的方式來解碼，例如列舉實際值，而不是採取較一般的方式。

    CK_RV m_GetAttributeValue (
        const unsigned char *object, size_t objectlen,
        CK_ATTRIBUTE_PTR attributes, CK_ULONG attributeslen,
        target_t 目標
    );
    

C_GetAttribute值 會取得物件一個以上屬性的值。hSession 是階段作業的控點; hObject 是物件的控點; pTemplate 指向指定要取得哪些屬性值並接收屬性值的範本; ulCount 是範本中的屬性數目。

對於範本中的每個 (type, pValue, ulValueLen) 三項值，C_GetAttributeValue 會執行下列演算法：

1. 如果無法顯示物件的指定屬性 (亦即，由類型欄位指定的屬性)，因為該物件是機密或無法擷取的，則會修改該三項值中的 ulValueLen 欄位，以保留值 CK_UNAVAILABLE_XX_ENCODE_CASE_ONE information。
2. 否則，如果物件的指定值無效（物件不會處理這類屬性），則該三項值中的 ulValueLen 欄位會修改為保留值 CK_UNAVAILABLE_INFORMATION。
3. 否則，如果 pValue 欄位的值為 NULL_PTR，則 ulValueLen 欄位會修改為保留物件的指定屬性的精確長度。
4. 否則，如果 ulValueLen 中指定的長度足以保留物件之指定屬性的值，則該屬性會複製到位於 pValue的緩衝區，並修改 ulValueLen 欄位以保留屬性的確切長度。
5. 否則，ulValueLen 值會修改為保留值 CK_UNAVAILABLE_INFORMATION。

如果案例 1 適用於任何所要求的屬性，則呼叫需要傳回值 CKR_ATTRIBUTE_SENSITIVE。 如果案例 2 適用於任何所要求的屬性，則呼叫需要傳回值 CKR_ATTRIBUTE_TYPE_INVALID。 如果案例 5 適用於任何所要求的屬性，則呼叫需要傳回值 CKR_BUFFER_TOO_SMALL。 通常，如果這些錯誤碼有多個適用，則 Cryptoki 可以傳回其中任何錯誤碼。 只有在它們都不適用於任何所要求的屬性時，才會傳回 CKR_OK。

在屬性值為屬性陣列 (例如 CKA_WRAP_TEMPLATE) 的特殊情況下，以 pValue 非空值傳入，如果陣列內元素的 pValue 是 NULL_PTR，則陣列內元素的 ulValueLen 會設為所需的長度。 如果陣列內元素的 pValue 不是 NULL_PTR，則陣列中屬性的 ulValueLen 元素必須反映出對應 pValue 所指向的空間，如果有足夠的空間，則會填入 pValue。 因此，在呼叫 C_GetAttributeValue 以取得這類陣列值之前，請務必起始設定緩衝區的內容。 如果陣列內的任何 ulValueLen 不夠大，它會設為 CK_UNAVAILABLE_XX_ENCODE_CASE_ONE information，且函數會傳回 CKR_BUFFER_TOO_SMALL，如同它在 pTemplate 引數中的屬性 ulValueLen 太小時一樣。 其值為屬性陣列的任何屬性都可透過屬性類型的 CKF_ARRAY_ATTRIBUTE 集進行識別。

錯誤碼 CKR_ATTRIBUTE_SENSITIVE、CKR_ATTRIBUTE_TYPE_INVALID及 CKR_BUFFER_TOO_SMALL 不表示 C_GetAttributeValue的 true 錯誤。 如果對 C_GetAttribute值 的呼叫傳回這三個值中的任何一個值，則該呼叫仍然必須已處理範本中提供給 C_GetAttribute值的每個屬性。 範本中其值可由呼叫 C_GetAttribute值 所傳回的每一個屬性，由呼叫 C_GetAttribute值所傳回。

    CK_DEFINE_FUNCTION(CK_RV, C_GetAttributeValue)(
        CK_SESSION_HANDLE hSession,
        CK_OBJECT_HANDLE hObject,
        CK_ATTRIBUTE_PTR pTemplate,
        CK_ULONG ulCount
    );
    

    message SetAttributeValueRequest {
        bytes Object = 1;
        map<uint64,AttributeValue> 屬性 = 3;
    }
    message SetAttributeValueResponse {
        bytes Object = 1;
    }
    

PKCS #11 C_SetAttributeValue 的實作。

屬性包裝：請參閱 _GetAttrValue

目前，EP11 只會傳送布林值屬性，其他所有屬性都是由主機處理（並且 EP11 不允許修改陣列，例如 WRAP_TEMPLATE）。

不代表或不需要階段作業 (二進位大型物件的一部分)，因此不使用 PKCS #11 hSession 參數。

    CK_RV m_SetAttributeValue (
        unsigned char *object, size_t objectlen,
        CK_ATTRIBUTE_PTR attributes, CK_ULONG attributeslen,
        target_t 目標
    );
    

C_SetAttributeValue 會修改物件的一或多個屬性值。hSession 是階段作業的控點; hObject 是物件的控點; pTemplate 指向指定要修改哪些屬性值及其新值的範本; ulCount 是範本中的屬性數目。

某些物件可能未修改。 對此類物件呼叫 C_SetAttribute值 會導致 CKR_ACTION_PROHIBITED 錯誤碼。 應用程式可以查閱物件的 CKA_MODIFIABLE 屬性，以判定是否可以修改物件。

在唯讀階段作業期間，只能修改階段作業物件。

範本可以為物件的任何屬性指定可修改的新值。 如果範本指定的屬性值與物件的其他現有屬性不相容，則呼叫會失敗，回覆碼為 CKR_TEMPLATE_INCONSISTENT。

並非所有屬性都可以修改; 如需相關資訊，請參閱 PKCS #11 API 規格 的 4.1.2 小節。

    CK_DEFINE_FUNCTION(CK_RV, C_SetAttributeValue)(
        CK_SESSION_HANDLE hSession,
        CK_OBJECT_HANDLE hObject,
        CK_ATTRIBUTE_PTR pTemplate,
        CK_ULONG ulCount
    );
    

    message GenerateRandomRequest {
        uint64 Len = 1;
    }
    message GenerateRandomResponse {
        bytes Rnd = 1;
    }
    

PKCS #11 C_GenerateRandom 的實作。

GenerateRandom 相等於原始 PKCS #11 函數。 在內部，透過符合 FIPS 標準的 DRNG（ANSI X9.31/ISO 18031，取決於 Clic 版本）來傳遞以硬體為種子的熵。

如果主機上有適用的功能可用，則主機程式庫可能會產生亂數，而不分派給後端。 在現行實作中不會這樣做。

此函數不支援大小查詢。

    CK_RV m_GenerateRandom (
        CK_BYTE_PTR rnd, CK_ULONG rndlen,
        target_t 目標
    );
    

    CK_DEFINE_FUNCTION(CK_RV, C_GenerateRandom)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pRandomData,
        CK_ULONG ulRandomLen
    );
    

    message EncryptInitRequest {
        Mechanism Mech = 2;
        bytes Key = 3;
    }
    message EncryptInitResponse {
        bytes State = 1;
    }
    

PKCS #11 C_EncryptInit 的實作。

(key，klen) 二進位大型物件可以是公開金鑰物件或秘密金鑰二進位大型物件。 金鑰類型必須與 pmech 一致。

針對公開金鑰機制，(key, klen) 必須包含 SPKI。 此 SPKI 使用 MAC 金鑰進行完整性保護，如 GenerateKeyPair 或 UnwrapKey 傳回的內容。 建立加密狀態時，而且沒有階段作業限制。

對於秘密金鑰機制，加密狀態會從 (key，klen)繼承物件階段作業限制。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。

(key, klen) 必須是金鑰二進位大型物件。

    CK_RV m_EncryptInit (
        unsigned char * state，size_t * statelen，
        CK_MECHANISM_PTR mech,
        const unsigned char *key, size_t keylen,
        target_t 目標
    );
    

C_EncryptInit 會起始設定加密作業。hSession 是階段作業的控點; pMechanism 指向加密機制; hKey 是加密金鑰的控點。

加密金鑰的 CKA_ENCRYPT 屬性（指出金鑰是否支援加密）必須為 CK_TRUE。

在應用程式呼叫 C_EncryptInit之後，應用程式可以呼叫 C_Encrypt 來加密單一部分中的資料; 或呼叫 C_EncryptUpdate 零或多次，後面接著 C_EncryptFinal來加密多個部分中的資料。 加密作業在作用中，直到應用程式使用 C_Encrypt 或 C_EncryptFinal 的呼叫來取得最後一段密文為止。 若要處理額外資料 (在單一或多個組件中)，應用程式必須再次呼叫 C_EncryptInit。

    CK_DEFINE_FUNCTION(CK_RV, C_EncryptInit)(
        CK_SESSION_HANDLE hSession,
        CK_MECHANISM_PTR pMechanism,
        CK_OBJECT_HANDLE hKey
    );
    

    message EncryptRequest {
        bytes State = 1;
        bytes Plain = 2;
    }
    message EncryptResponse {
        bytes Ciphered = 3;
    }
    

PKCS #11 C_Encrypt 的實作。

不會更新 (state, slen)。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。

state 二進位大型物件是來自 EncryptInit 的輸出。

    CK_RV m_Encrypt (
        const unsigned char *state, size_t statelen,
        CK_BYTE_PTR plain, CK_ULONG plainlen,
        CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen,
        target_t 目標
    );
    

C_Encrypt 會加密單一組件資料。hSession 是階段作業的控點; pData 指向資料; ulDataLen 是資料的長度 (以位元組為單位); pEncryptedData 指向接收已加密資料的位置; pulEncryptedDataLen 指向保留已加密資料長度 (以位元組為單位) 的位置。

C_Encrypt 使用 PKCS #11 API 規格 第 5.2 節中關於產生輸出的說明。

加密作業必須以 C_EncryptInit來起始設定。 呼叫 C_Encrypt 一律會終止作用中的加密作業，除非它傳回 CKR_BUFFER_TOO_SMALL 或成功呼叫 (亦即，傳回 CKR_OK) 來決定保留密文所需的緩衝區長度。

C_Encrypt 不能用於終止多部分作業，並且必須在 C_EncryptInit 之後進行呼叫，才不會介入 C_EncryptUpdate 呼叫。

對於部分加密機制，輸入純文字資料具有特定長度限制 (因為該機制只能加密相對較短的純文字片段，或因為該機制的輸入資料必須由整數區塊組成)。 如果未滿足這些限制，則 C_Encrypt 會失敗，回覆碼為 CKR_DATA_LEN_RANGE。

純文字及密文可以位於相同位置，亦即，如果 pData 及 pEncryptedData 指向相同位置，則可以正常。

對於大部分機制，C_Encrypt 相當於後面接著 C_EncryptFinal 的一系列 C_EncryptUpdate 作業。

    CK_DEFINE_FUNCTION(CK_RV, C_Encrypt)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pData,
        CK_ULONG ulDataLen,
        CK_BYTE_PTR pEncryptedData,
        CK_ULONG_PTR pulEncryptedDataLen
    );
    

    message EncryptUpdateRequest {
        bytes State = 1;
        bytes Plain = 2;
    }
    message EncryptUpdateResponse {
        bytes State = 1;
        bytes Ciphered = 3;
    }
    

PKCS #11 C_EncryptUpdate 的實作。

必須從 PKCS #11 hSession 參數對映 狀態 slen 二進位大型物件。

state 二進位大型物件是來自 EncryptInit 的輸出。

    CK_RV m_EncryptUpdate (
        unsigned char *state, size_t statelen,
        CK_BYTE_PTR plain, CK_ULONG plainlen,
        CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen,
        target_t 目標
    );
    

C_EncryptUpdate 會繼續多組件加密作業，並處理另一個資料組件。hSession 是階段作業的控點; pPart 指向資料組件; ulPartLen 是資料組件的長度; pEncryptedPart 指向接收已加密資料組件的位置; pulEncryptedPartLen 指向保留已加密資料組件長度 (以位元組為單位) 的位置。

C_EncryptUpdate 使用 PKCS #11 API 規格 產生輸出的 5.2 小節中說明的慣例。

加密作業必須以 C_EncryptInit來起始設定。 此函數可以連續呼叫任意次數。 如果呼叫 C_EncryptUpdate 導致 CKR_BUFFER_TOO_SMALL 以外的錯誤，則該呼叫會終止現行加密作業。

純文字 和 密文 可以位於相同位置，亦即，pPart 和 pEncryptedPart 可以指向相同位置。

    CK_DEFINE_FUNCTION(CK_RV, C_EncryptUpdate)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pPart,
        CK_ULONG ulPartLen,
        CK_BYTE_PTR pEncryptedPart,
        CK_ULONG_PTR pulEncryptedPartLen
    );
    

    message EncryptFinalRequest {
        bytes State = 1;
    }
    message EncryptFinalResponse {
        bytes Ciphered = 2;
    }
    

PKCS #11 C_EncryptFinal 的實作。

不會更新 (state, slen)。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。

state 二進位大型物件是從 EncryptInit 和 EncryptUpdate 所輸出。

    CK_RV m_EncryptFinal (
        const unsigned char *state, size_t statelen,
        CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen,
        target_t 目標
    );
    

C_EncryptFinal 會完成多組件加密作業。hSession 是階段作業的控點; pLastEncryptedPart 會指向接收最後一個加密資料組件的位置 (如果有的話); pulLastEncryptedPartLen 會指向保留最後一個加密資料組件長度的位置。

C_EncryptFinal 使用 PKCS #11 API 規格 產生輸出的 5.2 小節中說明的慣例。

加密作業必須以 C_EncryptInit來起始設定。 對 C_EncryptFinal 的呼叫一律會終止作用中加密作業，除非它傳回 CKR_BUFFER_TOO_SMALL 或成功呼叫 (亦即，傳回 CKR_OK) 來決定保留密文所需的緩衝區長度。

對於部分多部分加密機制，輸入純文字資料具有特定長度限制，因為機制的輸入資料必須由整數區塊組成。 如果未滿足這些限制，則 C_EncryptFinal 會失敗，回覆碼為 CKR_DATA_LEN_RANGE。

    CK_DEFINE_FUNCTION(CK_RV, C_EncryptFinal)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pLastEncryptedPart,
        CK_ULONG_PTR pulLastEncryptedPartLen
    );
    

    message EncryptSingleRequest {
        bytes Key = 1;
        Mechanism Mech = 2;
        bytes Plain = 3;
    }
    message EncryptSingleResponse {
        bytes Ciphered = 4;
    }
    

Encrypt 的非標準變式。 一次處理資料，使用一次呼叫。 不會傳回任何狀態給主機，只會傳回已加密資料。

這針對可感知 XCP 的應用程式而言，一次加密資料的偏好方法。 在功能上，它相當於 EncryptInit，後面接著 Encrypt，但它會儲存來回轉換、覆蓋及解除覆蓋。

如果後端支援常駐金鑰，則金鑰也可以是常駐金鑰控點。

另請參閱：Encrypt、EncryptInit 和 DecryptSingle。

key 二進位大型物件是來自 GenerateKey、UnwrapKey 的輸出。

    CK_RV m_EncryptSingle (
        const unsigned char *key, size_t keylen,
        CK_MECHANISM_PTR mech,
        CK_BYTE_PTR plain, CK_ULONG plainlen,
        CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen,
        target_t 目標
    );
    

    message ReencryptSingleRequest {
        bytes DecKey = 1;
        bytes EncKey = 2;
        機制 DecMech = 3;
        機制 EncMech = 4;
        bytes Ciphered = 5;
    }
    message ReencryptSingleResponse {
        已接收位元組 = 6;
    }
    

Encrypt 的非標準變式。 一次處理資料，使用一次呼叫。 不會傳回任何狀態給主機，只會傳回重新加密的資料。

使用原始金鑰來解密資料，然後在雲端 HSM 內使用不同的金鑰來加密原始資料。

    CK_RV m_ReencryptSingle (
        const unsigned char * dkey，size_t dkeylen，
        const unsigned char * ekey，size_t ekeylen，
        CK_MECHANISM_PTR decmech，
        CK_MECHANISM_PTR encmech，
        CK_BYTE_PTR in，CK_ULONG inlen，
        CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen,
        target_t 目標
    );
    

    message DecryptInitRequest {
        Mechanism Mech = 2;
        bytes Key = 3;
    }
    message DecryptInitResponse {
        bytes State = 1;
    }
    

    CK_RV m_DecryptInit (
        unsigned char * state，size_t * statelen，
        CK_MECHANISM_PTR mech,
        const unsigned char *key, size_t keylen,
        target_t 目標
    );
    

C_DecryptInit 會起始設定解密作業。hSession 是階段作業的控點; pMechanism 指向解密機制; hKey 是解密金鑰的控點。

解密金鑰的 CKA_DECRYPT 屬性（指出金鑰是否支援解密）必須為 CK_TRUE。

在應用程式呼叫 C_DecryptInit之後，應用程式可以呼叫 C_Decrypt 來解密單一組件中的資料; 或呼叫 C_DecryptUpdate 零或多次，後面接著 C_DecryptFinal來解密多個組件中的資料。 解密作業在作用中，直到應用程式使用 C_Decrypt 或 C_DecryptFinal 的呼叫來取得純文字的最終部分為止。 若要處理額外資料 (在單一或多個組件中)，應用程式必須再次呼叫 C_DecryptInit。

    CK_DEFINE_FUNCTION(CK_RV, C_DecryptInit)(
        K_SESSION_HANDLE hSession,
        CK_MECHANISM_PTR pMechanism,
        CK_OBJECT_HANDLE hKey
    );
    

    message DecryptRequest {
        bytes State = 1;
        bytes Ciphered = 2;
    }
    message DecryptResponse {
       bytes Plain = 3;
    }
    

PKCS #11 C_Decrypt的實作。 它不會更新 (state，slen)。

state, slen 二進位大型物件 (BLOB) 必須從 PKCS #11 hSession 參數對映。 state 二進位大型物件是從 DecryptInit 所輸出。

    CK_RV m_Decrypt (const unsigned char *state, size_t slen,
        CK_BYTE_PTR cipher, CK_ULONG clen,
        CK_BYTE_PTR plain, CK_ULONG_PTR plen,
        target_t 目標
    );
    

C_Decrypt 會解密單一部分中的加密資料。

• hSession 是階段作業控點。
• pEncryptedData 指向加密資料。
• ulEncryptedDataLen 是加密資料的長度。
• pData 指向接收所回復資料的位置。
• pulDataLen 指向保留所回復資料長度的位置。

C_Decrypt 使用 PKCS #11 API 規格 第 5.2 節中所說明的產生輸出慣例。

解密作業需要以 C_DecryptInit起始設定。 對 C_Decrypt 的呼叫一律會終止作用中解密作業，除非它傳回 CKR_BUFFER_TOO_SMALL 或成功呼叫傳回 CKR_OK 以決定保留純文字所需的緩衝區長度。

C_Decrypt 無法用來終止多組件作業，需要在 C_DecryptInit 之後呼叫，而不介入 C_DecryptUpdate 呼叫。

密文和純文字可以位於相同位置，這表示如果 pEncryptedData 和 pData 指向相同位置，就可以接受。

如果輸入密文資料因長度不適當而無法解密，則可能會傳回 CKR_ENCRYPTED_DATA_INVALID 或 CKR_ENCRYPTED_DATA_LEN_RANGE。

    CK_DEFINE_FUNCTION(CK_RV, C_Decrypt)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pEncryptedData,
        CK_ULONG ulEncryptedDataLen,
        CK_BYTE_PTR pData,
        CK_ULONG_PTR pulDataLen
    );
    

    message DecryptUpdateRequest {
        bytes State = 1;
        bytes Ciphered = 2;
    }
    message DecryptUpdateResponse {
        bytes State = 1;
        bytes Plain = 3;
    }
    

PKCS #11 C_DecryptUpdate 的實作。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。

state 二進位大型物件是從 DecryptInit 所輸出。

    CK_RV m_DecryptUpdate (
        unsigned char *state, size_t statelen,
        CK_BYTE_PTR ciphered, CK_ULONG cipheredlen,
        CK_BYTE_PTR plain, CK_ULONG_PTR plainlen,
        target_t 目標
    );
    

C_DecryptUpdate 會繼續多部分解密作業，並處理另一個加密資料部分。hSession 是階段作業的控點; pEncryptedPart 指向已加密資料部分; ulEncryptedPartLen 是已加密資料部分的長度; pPart 指向接收回復資料部分的位置; pulPartLen 指向保留回復資料部分長度的位置。

C_DecryptUpdate 使用 PKCS #11 API 規格 第 5.2 節中關於產生輸出的慣例。

解密作業必須以 C_DecryptInit起始設定。 此函數可以連續呼叫任意次數。 如果呼叫 C_DecryptUpdate 導致 CKR_BUFFER_TOO_SMALL 以外的錯誤，則該呼叫會終止現行解密作業。

密文和純文字可以位於相同位置，亦即，如果 pEncryptedPart 和 pPart 指向相同位置，則可以正常。

    CK_DEFINE_FUNCTION(CK_RV, C_DecryptUpdate)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pEncryptedPart,
        CK_ULONG ulEncryptedPartLen,
        CK_BYTE_PTR pPart,
        CK_ULONG_PTR pulPartLen
    );
    

    message DecryptFinalRequest {
        bytes State = 1;
    }
    message DecryptFinalResponse {
        bytes Plain = 2;
    }
    

PKCS #11 C_DecryptFinal 的實作。

不會更新 (state, slen)。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。

state 二進位大型物件是從 DecryptInit 和 DecryptUpdate 所輸出。

    CK_RV m_DecryptFinal (
        const unsigned char *state, size_t statelen,
        CK_BYTE_PTR plain, CK_ULONG_PTR plainlen,
        target_t 目標
    );
    

C_DecryptFinal 完成多部分解密作業。hSession 是階段作業的控點; pLast組件 指向接收前次回復資料組件的位置 (如果有的話); pulLastPartLen 指向保留前次回復資料組件長度的位置。

C_DecryptFinal 使用 PKCS #11 API 規格 產生輸出的 5.2 小節中說明的慣例。

解密作業必須以 C_DecryptInit起始設定。 對 C_DecryptFinal 的呼叫一律會終止作用中解密作業，除非它傳回 CKR_BUFFER_TOO_SMALL 或成功呼叫 (亦即，傳回 CKR_OK)，以決定保留純文字所需的緩衝區長度。

如果輸入密文資料因為長度不適當而無法解密，則可以傳回 CKR_ENCRYPTED_DATA_INVALID 或 CKR_ENCRYPTED_DATA_LEN_RANGE。

    CK_DEFINE_FUNCTION(CK_RV, C_DecryptFinal)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pLastPart,
        CK_ULONG_PTR pulLastPartLen
    );
    

    message DecryptSingleRequest {
        bytes Key = 1;
        Mechanism Mech = 2;
        bytes Ciphered = 3;
    }
    message DecryptSingleResponse {
        bytes Plain = 4;
    }
    

Decrypt 的非標準變式。 一次處理資料，使用一次呼叫。 不會傳回任何狀態給主機，只會傳回已解密資料。

這針對可感知 XCP 的應用程式而言，一次加密資料的偏好方法。 在功能上，它相當於 DecryptInit，後面接著 Decrypt，但它會儲存來回轉換、覆蓋及解除覆蓋。

如果後端支援常駐金鑰，則金鑰也可以是常駐金鑰控點。

另請參閱：Decrypt、DecryptInit 和 EncryptSingle。

key 二進位大型物件是來自 GenerateKey、UnwrapKey 的輸出。

    CK_RV m_DecryptSingle (
        const unsigned char *key, size_t keylen,
        CK_MECHANISM_PTR mech,
        CK_BYTE_PTR ciphered, CK_ULONG cipheredlen,
        CK_BYTE_PTR plain, CK_ULONG_PTR plainlen,
        target_t 目標
    );
    

    message SignInitRequest {
        Mechanism Mech = 2;
        bytes PrivKey = 3;
    }
    message SignInitResponse {
        bytes State = 1;
    }
    

    CK_RV m_SignInit (
        unsigned char * state，size_t * statelen，
        CK_MECHANISM_PTR mech,
        const unsigned char *privKey, size_t privKeylen,
        target_t 目標
    );
    

C_SignInit 會起始設定簽章作業，其中簽章是資料的附錄。hSession 是階段作業的控點; pMechanism 指向簽章機制; hKey 是簽章金鑰的控點。

簽章金鑰的 CKA_SIGN 屬性（指出金鑰是否支援具有附錄的簽章）必須為 CK_TRUE。

在應用程式呼叫 C_SignInit之後，應用程式可以呼叫 C_Sign 來登入單一組件; 或呼叫 C_SignUpdate 一次以上，後面接著 C_SignFinal來簽署多個組件中的資料。 簽章作業在作用中，直到應用程式使用呼叫 C_Sign 或 C_SignFinal 來取得簽章為止。 若要處理額外資料 (在單一或多個組件中)，應用程式必須再次呼叫 C_SignInit。

    CK_DEFINE_FUNCTION(CK_RV, C_SignInit)(
        CK_SESSION_HANDLE hSession,
        CK_MECHANISM_PTR pMechanism,
        CK_OBJECT_HANDLE hKey
    );
    

    message SignRequest {
        bytes State = 1;
        bytes Data = 2;
    }
    message SignResponse {
        bytes Signature = 3;
    }
    

PKCS #11 C_Sign 的實作。

不會更新 (state, slen)。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。 （主機程式庫必須將階段作業對映至儲存的狀態。）

state 二進位大型物件是來自 SignInit 的輸出。

    CK_RV m_Sign (
        const unsigned char *state, size_t statelen,
        CK_BYTE_PTR data, CK_ULONG datalen,
        CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen,
        target_t 目標
    );
    

C_Sign 會在單一部分中簽署資料，其中簽章是資料的附錄。hSession 是階段作業的控點; pData 指向資料; ulDataLen 是資料的長度; pSignature 指向接收簽章的位置; pulSignatureLen 指向保留簽章長度的位置。

C_Sign 使用 PKCS #11 API 規格 第 5.2 節中關於產生輸出的說明慣例。

簽署作業必須以 C_SignInit來起始設定。 呼叫 C_Sign 一律會終止作用中簽署作業，除非它傳回 CKR_BUFFER_TOO_SMALL 或成功呼叫 (亦即，傳回 CKR_OK)，以決定保留簽章所需的緩衝區長度。

C_Sign 不能用於終止多部分作業，並且必須在 C_SignInit 之後進行呼叫，才不會介入 C_SignUpdate 呼叫。

對於大部分機制，C_Sign 相當於後面接著 C_SignFinal 的一系列 C_SignUpdate 作業。

    CK_DEFINE_FUNCTION(CK_RV, C_Sign)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pData,
        CK_ULONG ulDataLen,
        CK_BYTE_PTR pSignature,
        CK_ULONG_PTR pulSignatureLen
    );
    

    message SignUpdateRequest {
        bytes State = 1;
        bytes Data = 2;
    }
    message SignUpdateResponse {
        bytes State = 1;
    }
    

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。 （主機程式庫必須將階段作業對映至儲存的狀態。）

state 二進位大型物件是來自 SignInit 的輸出。

    CK_RV m_SignUpdate (
        unsigned char *state, size_t statelen,
        CK_BYTE_PTR data, CK_ULONG datalen,
        target_t 目標
    );
    

C_SignUpdate 會繼續多組件簽章作業，並處理另一個資料組件。hSession 是階段作業的控點，pPart 指向資料部分; ulPartLen 是資料部分的長度。

簽章作業必須以 C_SignInit來起始設定。 此函數可以連續呼叫任意次數。 如果呼叫 C_SignUpdate 導致錯誤，則該呼叫會終止現行簽章作業。

    CK_DEFINE_FUNCTION(CK_RV, C_SignUpdate)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pPart,
        CK_ULONG ulPartLen
    );
    

    message SignFinalRequest {
        bytes State = 1;
    }
    message SignFinalResponse {
        bytes Signature = 2;
    }
    

PKCS #11 C_SignFinal 的實作。

不會更新 (state, slen)。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。 （主機程式庫必須將階段作業對映至儲存的狀態。）

state 二進位大型物件是來自 SignInit、SignUpdate 的輸出。

    CK_RV m_SignFinal (
        const unsigned char *state, size_t statelen,
        CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen,
        target_t 目標
    );
    

C_SignFinal 會完成多部分簽章作業，並傳回簽章。hSession 是階段作業的控點; pSignature 指向接收簽章的位置; pulSignatureLen 指向保留簽章長度的位置。

C_SignFinal 使用 PKCS #11 API 規格 第 5.2 節中關於產生輸出的慣例。

簽署作業必須以 C_SignInit來起始設定。 C_SignFinal 的呼叫一律會終止作用中的簽署作業，除非它傳回 CKR_BUFFER_TOO_SMALL 或成功呼叫 (亦即，傳回 CKR_OK)，以決定保留簽章所需的緩衝區長度。

    CK_DEFINE_FUNCTION(CK_RV, C_SignFinal)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pSignature,
        CK_ULONG_PTR pulSignatureLen
    );
    

    message SignSingleRequest {
        bytes PrivKey = 1;
        Mechanism Mech = 2;
        bytes Data = 3;
    }
    message SignSingleResponse {
        bytes Signature = 4;
    }
    

非標準延伸，SignInit 和 Sign 的組合。 一次簽署資料或對其執行 MAC，使用一次呼叫，且不建構中間的摘要狀態。 不會傳回任何狀態給主機，只會傳回結果。

這是偏好的簽署方式，不需要額外的來回轉換、加密及解密。 在功能上，SignSingle 相當於後面直接跟著 Sign 的 SignInit。

(key, klen) 二進位大型物件和 pmech 機制必須能夠一起傳遞到 SignInit。

支援 HMAC 和 CMAC 簽章的多重資料要求 (子變式 2 和 3)。

另請參閱：SignInit、Sign 和 VerifySingle。

    CK_RV m_SignSingle (
        const unsigned char *privKey, size_t privKeylen,
        CK_MECHANISM_PTR mech,
        CK_BYTE_PTR data, CK_ULONG datalen,
        CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen,
        target_t 目標
    );
    

    message VerifyInitRequest {
        Mechanism Mech = 2;
        bytes PubKey = 3;
    }
    message VerifyInitResponse {
        bytes State = 1;
    }
    

PKCS #11 C_VerifyInit 的實作。 在給定金鑰二進位大型物件 (key, klen) 的情況下，起始設定 (state, slen) 中的驗證階段作業狀態。 金鑰二進位大型物件可以是公開金鑰物件或 HMAC 金鑰位元組。 金鑰二進位大型物件類型必須與 pmech 一致。

針對公開金鑰機制，(key, klen) 必須包含 SPKI。 此 SPKI CKA_UNWRAP 可以是 MACed (例如，先前由 GenerateKeyPair所傳回) 或只是 SPKI 本身 (如果從外部來源 (例如憑證) 取得)。

如果起始設定 HMAC 作業，則會從 HMAC 金鑰繼承 Verify 物件的階段作業限制。 因為 SPKI 未關聯於階段作業，所以公開金鑰驗證狀態與階段作業無關。

key,klen 二進位大型物件必須從 PKCS #11 hKey 參數對映。

附註: SignInit 和 VerifyInit 在內部 適用於 HMAC 和其他 symmetric/MAC 機制。

    CK_RV m_VerifyInit (
        unsigned char * state，size_t * statelen，
        CK_MECHANISM_PTR mech,
        const unsigned char *pubKey, size_t pubKeylen,
        target_t 目標
    );
    

C_VerifyInit 會起始設定驗證作業，其中簽章是資料的附錄。hSession 是階段作業的控點; pMechanism 指向指定驗證機制的結構; hKey 是驗證金鑰的控點。

驗證金鑰的 CKA_VERIFY 屬性（指出金鑰是否支援簽章是資料附錄的驗證）必須為 CK_TRUE。

在應用程式呼叫 C_VerifyInit之後，應用程式可以呼叫 C_Verify 以驗證單一組件中資料的簽章; 或呼叫 C_VerifyUpdate 一或多次，後面接著 C_VerifyFinal以驗證多個組件中資料的簽章。 驗證作業一直處於作用中狀態，直到應用程式呼叫 C_Verify 或 C_VerifyFinal。 若要處理額外資料 (在單一或多個組件中)，應用程式必須再次呼叫 C_VerifyInit。

    CK_DEFINE_FUNCTION(CK_RV, C_VerifyInit)(
        CK_SESSION_HANDLE hSession,
        CK_MECHANISM_PTR pMechanism,
        CK_OBJECT_HANDLE hKey
    );
    

    message VerifyRequest {
        bytes State = 1;
        bytes Data = 2;
        bytes Signature = 3;
    }
    message VerifyResponse {
    }
    

PKCS #11 C_Verify 的實作。

不會更新 (state, slen)。

資料和簽章的相對順序相反 至 VerifySingle。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。 （主機程式庫必須將階段作業對映至儲存的狀態。）

state 二進位大型物件是來自 VerifyInit 的輸出。

    CK_RV m_Verify (
        const unsigned char *state, size_t statelen,
        CK_BYTE_PTR data, CK_ULONG datalen,
        CK_BYTE_PTR signature, CK_ULONG signaturelen,
        target_t 目標
    );
    

C_Verify 會驗證單一部分作業中的簽章，其中簽章是資料的附錄。hSession 是階段作業的控點; pData 指向資料; ulDataLen 是資料的長度; pSignature 指向簽章; ulSignatureLen 是簽章的長度。

驗證作業必須以 C_VerifyInit起始設定。 呼叫 C_Verify 一律會終止作用中驗證作業。

成功呼叫 C_Verify 需要傳回值 CKR_OK (指出提供的簽章有效) 或 CKR_SIGNATURE_INVALID (指出提供的簽章無效)。 如果簽章純粹根據其長度而無效，則需要傳回 CKR_SIGNATURE_LEN_RANGE。 在上述任何情況下，都會終止作用中簽署作業。

C_Verify 不能用於終止多部分作業，並且必須在 C_VerifyInit 之後進行呼叫，才不會介入 C_VerifyUpdate 呼叫。

對於大部分機制，C_Verify 相當於後面接著 C_VerifyFinal 的一系列 C_VerifyUpdate 作業。

    CK_DEFINE_FUNCTION(CK_RV, C_Verify)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pData,
        CK_ULONG ulDataLen,
        CK_BYTE_PTR pSignature,
        CK_ULONG ulSignatureLen
    );
    

    message VerifyUpdateRequest {
        bytes State = 1;
        bytes Data = 2;
    }
    message VerifyUpdateResponse {
        bytes State = 1;
    }
    

PKCS #11 C_VerifyUpdate 的實作。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。 （主機程式庫必須將階段作業對映至儲存的狀態。）

state 二進位大型物件是來自 VerifyInit 的輸出。

    CK_RV m_VerifyUpdate (
        unsigned char *state, size_t statelen,
        CK_BYTE_PTR data, CK_ULONG datalen,
        target_t 目標
    );
    

C_VerifyUpdate 會繼續多組件驗證作業，並處理另一個資料組件。hSession 是階段作業的控點，pPart 指向資料部分; ulPartLen 是資料部分的長度。

驗證作業必須以 C_VerifyInit起始設定。 此函數可以連續呼叫任意次數。 呼叫 C_VerifyUpdate 會導致錯誤的呼叫會終止現行驗證作業。

    CK_DEFINE_FUNCTION(CK_RV, C_VerifyUpdate)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pPart,
        CK_ULONG ulPartLen
    );
    

    message VerifyFinalRequest {
        bytes State = 1;
        bytes Signature = 2;
    }
    message VerifyFinalResponse {
    }
    

PKCS #11 C_VerifyFinal 的實作。

不會更新 (state, slen)。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。 （主機程式庫必須將階段作業對映至儲存的狀態。）

state 二進位大型物件是來自 VerifyInit、VerifyUpdate 的輸出。

    CK_RV m_VerifyFinal (
        const unsigned char *state, size_t statelen,
        CK_BYTE_PTR signature, CK_ULONG signaturelen,
        target_t 目標
    );
    

C_VerifyFinal 會完成多組件驗證作業，並檢查簽章。hSession 是階段作業的控點; pSignature 指向簽章; ulSignatureLen 是簽章的長度。

驗證作業必須以 C_VerifyInit起始設定。 呼叫 C_VerifyFinal 一律會終止作用中驗證作業。

成功呼叫 C_VerifyFinal 需要傳回值 CKR_OK (指出提供的簽章有效) 或 CKR_SIGNATURE_INVALID (指出提供的簽章無效)。 如果簽章根據其長度而無效，則需要傳回 CKR_SIGNATURE_LEN_RANGE。 在上述任何情況下，都會終止作用中驗證作業。

    CK_DEFINE_FUNCTION(CK_RV, C_VerifyFinal)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pSignature,
        CK_ULONG ulSignatureLen
    );
    

    message VerifySingleRequest {
        bytes PubKey = 1;
        Mechanism Mech = 2;
        bytes Data = 3;
        bytes Signature = 4;
    }
    message VerifySingleResponse {
    }
    

非標準延伸，VerifyInit 和 Verify 的組合。 一次簽署資料或對其執行 MAC，使用一次呼叫，且不建構中間的摘要狀態。 不會傳回任何狀態給主機，只會傳回驗證結果。 沒有可用的大小查詢，因為此函數傳回布林。

這是驗證簽章的偏好方式，不需要額外的來回轉換、加密、解密。 在功能上，VerifySingle 相當於後面跟著 Verify 的 VerifyInit。

(key, klen) 二進位大型物件和 pmech 機制必須能夠一起傳遞到 VerifyInit。

針對公開金鑰機制，(key, klen) 必須包含 SPKI。 此 SPKI 可以是 MACed (例如從 GenerateKeyPair傳回的公開金鑰)，也可以是 SPKI 本身 (如果從外部來源 (例如憑證) 取得)。

另請參閱：VerifyInit、Verify 和 SignSingle。

    CK_RV m_VerifySingle (
        const unsigned char *pubKey, size_t pubKeylen,
        CK_MECHANISM_PTR mech,
        CK_BYTE_PTR data, CK_ULONG datalen,
        CK_BYTE_PTR signature, CK_ULONG signaturelen,
        target_t 目標
    );
    

    message DigestInitRequest {
        Mechanism Mech = 2;
    }
    message DigestInitResponse {
        bytes State = 1;
    }
    

PKCS #11 C_DigestInit 的實作。

建立已包裝的摘要狀態。

附註：支援大小查詢，但是已包裝狀態一律由後端傳回，這與大多數大小查詢不同（後者傳回輸出大小，而不是實際輸出）。 Digest 狀態足夠小，因此不會產生明顯的傳輸額外負擔。

在大小查詢期間，主機只會捨棄傳回的狀態，而報告二進位大型物件大小（在 len 中）。 當傳回二進位大型物件時，會根據傳回的大小來檢查 len。

state,len 二進位大型物件必須從 PKCS #11 hSession 參數對映。 （主機程式庫必須將二進位大型物件連結到階段作業。）

    CK_RV m_DigestInit (
        unsigned char * state，size_t * len，
        const CK_MECHANISM_PTR mech,
        target_t 目標
    );
    

C_DigestInit 會起始設定訊息摘要作業。hSession 是階段作業的控點; pMechanism 指向摘要機制。

在應用程式呼叫 C_DigestInit之後，應用程式可以呼叫 C_Digest 來摘要單一組件中的資料; 或呼叫 C_DigestUpdate 零或多次，後面接著 C_DigestFinal來摘要多個組件中的資料。 除非應用程式使用呼叫 C_DigestFinal 或 C_DigestFinal 來取得訊息摘要，否則訊息摘要作業會處於作用中。 若要處理額外資料 (在單一或多個組件中)，應用程式必須再次呼叫 1C_DigestInit1。

    CK_DEFINE_FUNCTION(CK_RV, C_DigestInit)(
        CK_SESSION_HANDLE hSession,
        CK_MECHANISM_PTR pMechanism
    );
    

    message DigestRequest {
        bytes State = 1;
        bytes Data = 2;
    }
    message DigestResponse {
        bytes Digest = 3;
    }
    

PKCS #11 C_Digest 的實作。

如果摘要物件在建立之後剛好有 0 (零) 個位元組附加到它，則在零位元組傳送的任何組合中，它仍然可以執行一次摘要，即使嚴格實作需要拒絕它也一樣。

不會更新 (state, slen)。

實作可能執行 對主機程式碼中明碼摘要物件的 DigestUpdate、DigestFinal或 Digest 呼叫，完全略過 HSM 後端。 此選項不一定對主機程式碼可見，且不會影響作業的安全 (因為清除物件可能不會摘要機密資料)。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。 state 二進位大型物件是來自 DigestInit 的輸出。

    CK_RV m_Digest (
        const unsigned char *state, size_t statelen,
        CK_BYTE_PTR data, CK_ULONG datalen,
        CK_BYTE_PTR digest, CK_ULONG_PTR digestlen,
        target_t 目標
    );
    

C_Digest 會在單一組件中對資料進行摘要。hSession 是階段作業的控點，pData 指向資料; ulDataLen 是資料的長度; pDigest 指向接收訊息摘要的位置; pulDigestLen 指向保留訊息摘要長度的位置。

C_Digest 使用 PKCS #11 API 規格 第 5.2 節中所說明的產生輸出慣例。

摘要作業必須以 C_DigestInit來起始設定。 對 C_Digest 的呼叫一律會終止作用中摘要作業，除非它傳回 CKR_BUFFER_TOO_SMALL 或成功呼叫 (亦即，傳回 CKR_OK)，以決定保留訊息摘要所需的緩衝區長度。

C_Digest 不能用於終止多部分作業，並且必須在 C_DigestInit 之後進行呼叫，才不會介入 C_DigestUpdate 呼叫。

輸入資料及摘要輸出可以位於相同位置，亦即，如果 pData 及 pDigest 指向相同位置，則可以正常。

C_Digest 相當於後面接著 C_DigestFinal 的一系列 C_DigestUpdate 作業。

    CK_DEFINE_FUNCTION(CK_RV, C_Digest)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pData,
        CK_ULONG ulDataLen,
        CK_BYTE_PTR pDigest,
        CK_ULONG_PTR pulDigestLen
    );
    

    message DigestUpdateRequest {
        bytes State = 1;
        bytes Data = 2;
    }
    message DigestUpdateResponse {
        bytes State = 1;
    }
    

PKCS #11 C_DigestUpdate 的實作。

DigestUpdate 是多型、 同時接受已包裝或清除摘要物件，以相同格式更新狀態。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。 （主機程式庫必須將階段作業對映至儲存的狀態。）

state 二進位大型物件是來自 DigestInit、DigestUpdate、DigestKey 的輸出。

另請參閱：DigestInit

    CK_RV m_DigestUpdate (
        unsigned char *state, size_t statelen,
        CK_BYTE_PTR data, CK_ULONG datalen,
        target_t 目標
    );
    

C_DigestUpdate 會繼續多組件訊息摘要作業，並處理另一個資料組件。hSession 是階段作業的控點，pPart 指向資料部分; ulPartLen 是資料部分的長度。

訊息摘要作業必須以 C_DigestInit來起始設定。 對此函數及 C_DigestKey 的呼叫可以任意順序任意散佈。 如果呼叫 C_DigestUpdate 導致錯誤，則該呼叫會終止現行摘要作業。

    CK_DEFINE_FUNCTION(CK_RV, C_DigestUpdate)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pPart,
        CK_ULONG ulPartLen
    );
    

    message DigestFinalRequest {
        bytes State = 1;
    }
    message DigestFinalResponse {
        bytes Digest = 2;
    }
    

PKCS #11 C_DigestFinal 的實作。

DigestFinal 是多態函數，並接受已包裝的摘要物件或明文摘要物件。

不會更新 (state, slen)。

state,slen 二進位大型物件必須從 PKCS #11 hSession 參數對映。

state 二進位大型物件是來自 DigestInit、DigestUpdate、DigestKey 的輸出。

    CK_RV m_DigestFinal (
        const unsigned char *state, size_t statelen,
        CK_BYTE_PTR digest, CK_ULONG_PTR digestlen,
        target_t 目標
    );
    

C_DigestFinal 會完成多組件訊息摘要作業，並傳回訊息摘要。hSession 是階段作業的控點; pDigest 指向接收訊息摘要的位置; pulDigestLen 指向保留訊息摘要長度的位置。

C_DigestFinal 使用 PKCS #11 API 規格 產生輸出的 5.2 小節中說明的慣例。

摘要作業必須以 C_DigestInit來起始設定。 對 C_DigestFinal 的呼叫一律會終止作用中摘要作業，除非它傳回 CKR_BUFFER_TOO_SMALL 或成功呼叫 (即傳回 CKR_OK)，以決定保留訊息摘要所需的緩衝區長度。

    CK_DEFINE_FUNCTION(CK_RV, C_DigestFinal)(
        CK_SESSION_HANDLE hSession,
        CK_BYTE_PTR pDigest,
        CK_ULONG_PTR pulDigestLen
    );
    

    message DigestSingleRequest {
        Mechanism Mech = 1;
        bytes Data = 2;
    }
    message DigestSingleResponse {
        bytes Digest = 3;
    }
    

非標準延伸，DigestInit 和 Digest 的組合。 一次取得資料摘要，使用一次呼叫，而不建構中間摘要狀態，避免不必要的往返。

這針對可感知 XCP 的應用程式而言是對純文字進行摘要的偏好方法。 在功能上，DigestSingle 相當於 DigestInit 後面直接跟著 Digest。

如果需要對金鑰進行摘要，則必須 使用 DigestInit 和 DigestKey，因為此函數不會處理金鑰二進位大型物件。

不會傳回任何狀態給主機，只會傳回摘要結果。 沒有非 PKCS #11 參數，因為所有內容都直接透過 PKCS #11 呼叫來使用。

    CK_RV m_DigestSingle (
        CK_MECHANISM_PTR mech,
        CK_BYTE_PTR data, CK_ULONG datalen,
        CK_BYTE_PTR digest, CK_ULONG_PTR digestlen,
        target_t 目標
    );