CBC results from the CPAN

Crypt-PKCS11

view release on metacpan or search on metacpan

lib/Crypt/PKCS11/Attribute/UlongArray.pod
lib/Crypt/PKCS11/Attribute/Value.pm
lib/Crypt/PKCS11/Attribute/Value.pod
lib/Crypt/PKCS11/Object.pm
lib/Crypt/PKCS11/Object.pod
lib/Crypt/PKCS11.pm
lib/Crypt/PKCS11.pod
lib/Crypt/PKCS11/Session.pm
lib/Crypt/PKCS11/Session.pod
lib/Crypt/PKCS11/XS.pod
lib/Crypt/PKCS11/CK_AES_CBC_ENCRYPT_DATA_PARAMS.pod
lib/Crypt/PKCS11/CK_AES_CCM_PARAMS.pod
lib/Crypt/PKCS11/CK_AES_CTR_PARAMS.pod
lib/Crypt/PKCS11/CK_AES_GCM_PARAMS.pod
lib/Crypt/PKCS11/CK_ARIA_CBC_ENCRYPT_DATA_PARAMS.pod
lib/Crypt/PKCS11/CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS.pod
lib/Crypt/PKCS11/CK_CAMELLIA_CTR_PARAMS.pod
lib/Crypt/PKCS11/CK_CMS_SIG_PARAMS.pod
lib/Crypt/PKCS11/CK_DES_CBC_ENCRYPT_DATA_PARAMS.pod
lib/Crypt/PKCS11/CK_ECDH1_DERIVE_PARAMS.pod
lib/Crypt/PKCS11/CK_ECDH2_DERIVE_PARAMS.pod
lib/Crypt/PKCS11/CK_ECMQV_DERIVE_PARAMS.pod
lib/Crypt/PKCS11/CK_KEA_DERIVE_PARAMS.pod
lib/Crypt/PKCS11/CK_KEY_DERIVATION_STRING_DATA.pod
lib/Crypt/PKCS11/CK_KEY_WRAP_SET_OAEP_PARAMS.pod
lib/Crypt/PKCS11/CK_KIP_PARAMS.pod
lib/Crypt/PKCS11/CK_MECHANISM.pod
lib/Crypt/PKCS11/CK_OTP_PARAM.pod
lib/Crypt/PKCS11/CK_OTP_PARAMS.pod
lib/Crypt/PKCS11/CK_OTP_SIGNATURE_INFO.pod
lib/Crypt/PKCS11/CK_PBE_PARAMS.pod
lib/Crypt/PKCS11/CK_PKCS5_PBKD2_PARAMS.pod
lib/Crypt/PKCS11/CK_RC2_CBC_PARAMS.pod
lib/Crypt/PKCS11/CK_RC2_MAC_GENERAL_PARAMS.pod
lib/Crypt/PKCS11/CK_RC5_CBC_PARAMS.pod
lib/Crypt/PKCS11/CK_RC5_MAC_GENERAL_PARAMS.pod
lib/Crypt/PKCS11/CK_RC5_PARAMS.pod
lib/Crypt/PKCS11/CK_RSA_PKCS_OAEP_PARAMS.pod
lib/Crypt/PKCS11/CK_RSA_PKCS_PSS_PARAMS.pod
lib/Crypt/PKCS11/CK_SKIPJACK_PRIVATE_WRAP_PARAMS.pod
lib/Crypt/PKCS11/CK_SKIPJACK_RELAYX_PARAMS.pod
lib/Crypt/PKCS11/CK_SSL3_KEY_MAT_OUT.pod
lib/Crypt/PKCS11/CK_SSL3_KEY_MAT_PARAMS.pod
lib/Crypt/PKCS11/CK_SSL3_MASTER_KEY_DERIVE_PARAMS.pod
lib/Crypt/PKCS11/CK_SSL3_RANDOM_DATA.pod

crypt_pkcs11_struct.h view on Meta::CPAN

CK_RV crypt_pkcs11_ck_kea_derive_params_fromBytes(Crypt__PKCS11__CK_KEA_DERIVE_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_kea_derive_params_get_isSender(Crypt__PKCS11__CK_KEA_DERIVE_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_kea_derive_params_set_isSender(Crypt__PKCS11__CK_KEA_DERIVE_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_kea_derive_params_get_pRandomA(Crypt__PKCS11__CK_KEA_DERIVE_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_kea_derive_params_set_pRandomA(Crypt__PKCS11__CK_KEA_DERIVE_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_kea_derive_params_get_pRandomB(Crypt__PKCS11__CK_KEA_DERIVE_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_kea_derive_params_set_pRandomB(Crypt__PKCS11__CK_KEA_DERIVE_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_kea_derive_params_get_pPublicData(Crypt__PKCS11__CK_KEA_DERIVE_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_kea_derive_params_set_pPublicData(Crypt__PKCS11__CK_KEA_DERIVE_PARAMS* object, SV* sv);

typedef struct Crypt__PKCS11__CK_RC2_CBC_PARAMS {
    CK_RC2_CBC_PARAMS private;
} Crypt__PKCS11__CK_RC2_CBC_PARAMS;
Crypt__PKCS11__CK_RC2_CBC_PARAMS* crypt_pkcs11_ck_rc2_cbc_params_new(const char* class);
void crypt_pkcs11_ck_rc2_cbc_params_DESTROY(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object);
SV* crypt_pkcs11_ck_rc2_cbc_params_toBytes(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object);
CK_RV crypt_pkcs11_ck_rc2_cbc_params_fromBytes(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc2_cbc_params_get_ulEffectiveBits(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc2_cbc_params_set_ulEffectiveBits(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc2_cbc_params_get_iv(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc2_cbc_params_set_iv(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object, SV* sv);

typedef struct Crypt__PKCS11__CK_RC2_MAC_GENERAL_PARAMS {
    CK_RC2_MAC_GENERAL_PARAMS private;
} Crypt__PKCS11__CK_RC2_MAC_GENERAL_PARAMS;
Crypt__PKCS11__CK_RC2_MAC_GENERAL_PARAMS* crypt_pkcs11_ck_rc2_mac_general_params_new(const char* class);
void crypt_pkcs11_ck_rc2_mac_general_params_DESTROY(Crypt__PKCS11__CK_RC2_MAC_GENERAL_PARAMS* object);
SV* crypt_pkcs11_ck_rc2_mac_general_params_toBytes(Crypt__PKCS11__CK_RC2_MAC_GENERAL_PARAMS* object);
CK_RV crypt_pkcs11_ck_rc2_mac_general_params_fromBytes(Crypt__PKCS11__CK_RC2_MAC_GENERAL_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc2_mac_general_params_get_ulEffectiveBits(Crypt__PKCS11__CK_RC2_MAC_GENERAL_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc2_mac_general_params_set_ulEffectiveBits(Crypt__PKCS11__CK_RC2_MAC_GENERAL_PARAMS* object, SV* sv);

crypt_pkcs11_struct.h view on Meta::CPAN

} Crypt__PKCS11__CK_RC5_PARAMS;
Crypt__PKCS11__CK_RC5_PARAMS* crypt_pkcs11_ck_rc5_params_new(const char* class);
void crypt_pkcs11_ck_rc5_params_DESTROY(Crypt__PKCS11__CK_RC5_PARAMS* object);
SV* crypt_pkcs11_ck_rc5_params_toBytes(Crypt__PKCS11__CK_RC5_PARAMS* object);
CK_RV crypt_pkcs11_ck_rc5_params_fromBytes(Crypt__PKCS11__CK_RC5_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_params_get_ulWordsize(Crypt__PKCS11__CK_RC5_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_params_set_ulWordsize(Crypt__PKCS11__CK_RC5_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_params_get_ulRounds(Crypt__PKCS11__CK_RC5_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_params_set_ulRounds(Crypt__PKCS11__CK_RC5_PARAMS* object, SV* sv);

typedef struct Crypt__PKCS11__CK_RC5_CBC_PARAMS {
    CK_RC5_CBC_PARAMS private;
} Crypt__PKCS11__CK_RC5_CBC_PARAMS;
Crypt__PKCS11__CK_RC5_CBC_PARAMS* crypt_pkcs11_ck_rc5_cbc_params_new(const char* class);
void crypt_pkcs11_ck_rc5_cbc_params_DESTROY(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object);
SV* crypt_pkcs11_ck_rc5_cbc_params_toBytes(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object);
CK_RV crypt_pkcs11_ck_rc5_cbc_params_fromBytes(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_cbc_params_get_ulWordsize(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_cbc_params_set_ulWordsize(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_cbc_params_get_ulRounds(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_cbc_params_set_ulRounds(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_cbc_params_get_pIv(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_cbc_params_set_pIv(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv);

typedef struct Crypt__PKCS11__CK_RC5_MAC_GENERAL_PARAMS {
    CK_RC5_MAC_GENERAL_PARAMS private;
} Crypt__PKCS11__CK_RC5_MAC_GENERAL_PARAMS;
Crypt__PKCS11__CK_RC5_MAC_GENERAL_PARAMS* crypt_pkcs11_ck_rc5_mac_general_params_new(const char* class);
void crypt_pkcs11_ck_rc5_mac_general_params_DESTROY(Crypt__PKCS11__CK_RC5_MAC_GENERAL_PARAMS* object);
SV* crypt_pkcs11_ck_rc5_mac_general_params_toBytes(Crypt__PKCS11__CK_RC5_MAC_GENERAL_PARAMS* object);
CK_RV crypt_pkcs11_ck_rc5_mac_general_params_fromBytes(Crypt__PKCS11__CK_RC5_MAC_GENERAL_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_mac_general_params_get_ulWordsize(Crypt__PKCS11__CK_RC5_MAC_GENERAL_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_mac_general_params_set_ulWordsize(Crypt__PKCS11__CK_RC5_MAC_GENERAL_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_mac_general_params_get_ulRounds(Crypt__PKCS11__CK_RC5_MAC_GENERAL_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_rc5_mac_general_params_set_ulRounds(Crypt__PKCS11__CK_RC5_MAC_GENERAL_PARAMS* object, SV* sv);

typedef struct Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS {
    CK_DES_CBC_ENCRYPT_DATA_PARAMS private;
} Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS;
Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* crypt_pkcs11_ck_des_cbc_encrypt_data_params_new(const char* class);
void crypt_pkcs11_ck_des_cbc_encrypt_data_params_DESTROY(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object);
SV* crypt_pkcs11_ck_des_cbc_encrypt_data_params_toBytes(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object);
CK_RV crypt_pkcs11_ck_des_cbc_encrypt_data_params_fromBytes(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_des_cbc_encrypt_data_params_get_iv(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_des_cbc_encrypt_data_params_set_iv(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_des_cbc_encrypt_data_params_get_pData(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_des_cbc_encrypt_data_params_set_pData(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);

typedef struct Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS {
    CK_AES_CBC_ENCRYPT_DATA_PARAMS private;
} Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS;
Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* crypt_pkcs11_ck_aes_cbc_encrypt_data_params_new(const char* class);
void crypt_pkcs11_ck_aes_cbc_encrypt_data_params_DESTROY(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object);
SV* crypt_pkcs11_ck_aes_cbc_encrypt_data_params_toBytes(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object);
CK_RV crypt_pkcs11_ck_aes_cbc_encrypt_data_params_fromBytes(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_aes_cbc_encrypt_data_params_get_iv(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_aes_cbc_encrypt_data_params_set_iv(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_aes_cbc_encrypt_data_params_get_pData(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_aes_cbc_encrypt_data_params_set_pData(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);

typedef struct Crypt__PKCS11__CK_SKIPJACK_PRIVATE_WRAP_PARAMS {
    CK_SKIPJACK_PRIVATE_WRAP_PARAMS private;
} Crypt__PKCS11__CK_SKIPJACK_PRIVATE_WRAP_PARAMS;
Crypt__PKCS11__CK_SKIPJACK_PRIVATE_WRAP_PARAMS* crypt_pkcs11_ck_skipjack_private_wrap_params_new(const char* class);
void crypt_pkcs11_ck_skipjack_private_wrap_params_DESTROY(Crypt__PKCS11__CK_SKIPJACK_PRIVATE_WRAP_PARAMS* object);
SV* crypt_pkcs11_ck_skipjack_private_wrap_params_toBytes(Crypt__PKCS11__CK_SKIPJACK_PRIVATE_WRAP_PARAMS* object);
CK_RV crypt_pkcs11_ck_skipjack_private_wrap_params_fromBytes(Crypt__PKCS11__CK_SKIPJACK_PRIVATE_WRAP_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_skipjack_private_wrap_params_get_pPassword(Crypt__PKCS11__CK_SKIPJACK_PRIVATE_WRAP_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_skipjack_private_wrap_params_set_pPassword(Crypt__PKCS11__CK_SKIPJACK_PRIVATE_WRAP_PARAMS* object, SV* sv);

crypt_pkcs11_struct.h view on Meta::CPAN

} Crypt__PKCS11__CK_CAMELLIA_CTR_PARAMS;
Crypt__PKCS11__CK_CAMELLIA_CTR_PARAMS* crypt_pkcs11_ck_camellia_ctr_params_new(const char* class);
void crypt_pkcs11_ck_camellia_ctr_params_DESTROY(Crypt__PKCS11__CK_CAMELLIA_CTR_PARAMS* object);
SV* crypt_pkcs11_ck_camellia_ctr_params_toBytes(Crypt__PKCS11__CK_CAMELLIA_CTR_PARAMS* object);
CK_RV crypt_pkcs11_ck_camellia_ctr_params_fromBytes(Crypt__PKCS11__CK_CAMELLIA_CTR_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_camellia_ctr_params_get_ulCounterBits(Crypt__PKCS11__CK_CAMELLIA_CTR_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_camellia_ctr_params_set_ulCounterBits(Crypt__PKCS11__CK_CAMELLIA_CTR_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_camellia_ctr_params_get_cb(Crypt__PKCS11__CK_CAMELLIA_CTR_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_camellia_ctr_params_set_cb(Crypt__PKCS11__CK_CAMELLIA_CTR_PARAMS* object, SV* sv);

typedef struct Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS {
    CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS private;
} Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS;
Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_new(const char* class);
void crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_DESTROY(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object);
SV* crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_toBytes(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object);
CK_RV crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_fromBytes(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_get_iv(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_set_iv(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_get_pData(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_set_pData(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);

typedef struct Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS {
    CK_ARIA_CBC_ENCRYPT_DATA_PARAMS private;
} Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS;
Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* crypt_pkcs11_ck_aria_cbc_encrypt_data_params_new(const char* class);
void crypt_pkcs11_ck_aria_cbc_encrypt_data_params_DESTROY(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object);
SV* crypt_pkcs11_ck_aria_cbc_encrypt_data_params_toBytes(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object);
CK_RV crypt_pkcs11_ck_aria_cbc_encrypt_data_params_fromBytes(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_aria_cbc_encrypt_data_params_get_iv(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_aria_cbc_encrypt_data_params_set_iv(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_aria_cbc_encrypt_data_params_get_pData(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);
CK_RV crypt_pkcs11_ck_aria_cbc_encrypt_data_params_set_pData(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv);

crypt_pkcs11_struct_aes.c view on Meta::CPAN

extern int __test_devel_cover_calloc_always_fail;
#define myNewxz(a,b,c) if (__test_devel_cover_calloc_always_fail) { a = 0; } else { Newxz(a, b, c); }
#define __croak(x) return 0
#else
#define myNewxz Newxz
#define __croak(x) croak(x)
#endif

extern int crypt_pkcs11_xs_SvUOK(SV* sv);

Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* crypt_pkcs11_ck_aes_cbc_encrypt_data_params_new(const char* class) {
    Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object = 0;
    myNewxz(object, 1, Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS);

    if (!object) {
        /* uncoverable block 0 */
        __croak("memory allocation error");
    }
    return object;
}

SV* crypt_pkcs11_ck_aes_cbc_encrypt_data_params_toBytes(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object) {
    if (!object) {
        return 0;
    }

    return newSVpvn((const char*)&(object->private), sizeof(CK_AES_CBC_ENCRYPT_DATA_PARAMS));
}

CK_RV crypt_pkcs11_ck_aes_cbc_encrypt_data_params_fromBytes(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);

    if (!SvPOK(sv)
        || !(p = SvPVbyte(sv, l))
        || l != sizeof(CK_AES_CBC_ENCRYPT_DATA_PARAMS))
    {
        return CKR_ARGUMENTS_BAD;
    }

    if (object->private.pData) {
        Safefree(object->private.pData);
    }
    Copy(p, &(object->private), l, char);

    if (object->private.pData) {

crypt_pkcs11_struct_aes.c view on Meta::CPAN

        if (!pData) {
            /* uncoverable block 0 */
            __croak("memory allocation error");
        }
        Copy(object->private.pData, pData, object->private.length, CK_BYTE);
        object->private.pData = pData;
    }
    return CKR_OK;
}

void crypt_pkcs11_ck_aes_cbc_encrypt_data_params_DESTROY(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object) {
    if (object) {
        if (object->private.pData) {
            Safefree(object->private.pData);
        }
        Safefree(object);
    }
}

CK_RV crypt_pkcs11_ck_aes_cbc_encrypt_data_params_get_iv(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setpvn(sv, object->private.iv, 16 * sizeof(CK_BYTE));
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_aes_cbc_encrypt_data_params_set_iv(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    char* p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

crypt_pkcs11_struct_aes.c view on Meta::CPAN

    }
    if (l != (16 * sizeof(CK_BYTE))) {
        return CKR_ARGUMENTS_BAD;
    }

    Copy(p, object->private.iv, 16, CK_BYTE);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_aes_cbc_encrypt_data_params_get_pData(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setpvn(sv, object->private.pData, object->private.length * sizeof(CK_BYTE));
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_aes_cbc_encrypt_data_params_set_pData(Crypt__PKCS11__CK_AES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    CK_BYTE_PTR n = 0;
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

crypt_pkcs11_struct_aria.c view on Meta::CPAN

extern int __test_devel_cover_calloc_always_fail;
#define myNewxz(a,b,c) if (__test_devel_cover_calloc_always_fail) { a = 0; } else { Newxz(a, b, c); }
#define __croak(x) return 0
#else
#define myNewxz Newxz
#define __croak(x) croak(x)
#endif

extern int crypt_pkcs11_xs_SvUOK(SV* sv);

Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* crypt_pkcs11_ck_aria_cbc_encrypt_data_params_new(const char* class) {
    Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object = 0;
    myNewxz(object, 1, Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS);

    if (!object) {
        /* uncoverable block 0 */
        __croak("memory allocation error");
    }
    return object;
}

SV* crypt_pkcs11_ck_aria_cbc_encrypt_data_params_toBytes(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object) {
    if (!object) {
        return 0;
    }

    return newSVpvn((const char*)&(object->private), sizeof(CK_ARIA_CBC_ENCRYPT_DATA_PARAMS));
}

CK_RV crypt_pkcs11_ck_aria_cbc_encrypt_data_params_fromBytes(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);

    if (!SvPOK(sv)
        || !(p = SvPVbyte(sv, l))
        || l != sizeof(CK_ARIA_CBC_ENCRYPT_DATA_PARAMS))
    {
        return CKR_ARGUMENTS_BAD;
    }

    if (object->private.pData) {
        Safefree(object->private.pData);
    }
    Copy(p, &(object->private), l, char);

    if (object->private.pData) {

crypt_pkcs11_struct_aria.c view on Meta::CPAN

        if (!pData) {
            /* uncoverable block 0 */
            __croak("memory allocation error");
        }
        Copy(object->private.pData, pData, object->private.length, CK_BYTE);
        object->private.pData = pData;
    }
    return CKR_OK;
}

void crypt_pkcs11_ck_aria_cbc_encrypt_data_params_DESTROY(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object) {
    if (object) {
        if (object->private.pData) {
            Safefree(object->private.pData);
        }
        Safefree(object);
    }
}

CK_RV crypt_pkcs11_ck_aria_cbc_encrypt_data_params_get_iv(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setpvn(sv, object->private.iv, 16 * sizeof(CK_BYTE));
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_aria_cbc_encrypt_data_params_set_iv(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    char* p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

crypt_pkcs11_struct_aria.c view on Meta::CPAN

    }
    if (l != (16 * sizeof(CK_BYTE))) {
        return CKR_ARGUMENTS_BAD;
    }

    Copy(p, object->private.iv, 16, CK_BYTE);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_aria_cbc_encrypt_data_params_get_pData(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setpvn(sv, object->private.pData, object->private.length * sizeof(CK_BYTE));
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_aria_cbc_encrypt_data_params_set_pData(Crypt__PKCS11__CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    CK_BYTE_PTR n = 0;
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

crypt_pkcs11_struct_camellia.c view on Meta::CPAN

    }
    if (l != (16 * sizeof(CK_BYTE))) {
        return CKR_ARGUMENTS_BAD;
    }

    Copy(p, object->private.cb, 16, CK_BYTE);

    return CKR_OK;
}

Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_new(const char* class) {
    Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object = 0;
    myNewxz(object, 1, Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS);

    if (!object) {
        /* uncoverable block 0 */
        __croak("memory allocation error");
    }
    return object;
}

SV* crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_toBytes(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object) {
    if (!object) {
        return 0;
    }

    return newSVpvn((const char*)&(object->private), sizeof(CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS));
}

CK_RV crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_fromBytes(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);

    if (!SvPOK(sv)
        || !(p = SvPVbyte(sv, l))
        || l != sizeof(CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS))
    {
        return CKR_ARGUMENTS_BAD;
    }

    if (object->private.pData) {
        Safefree(object->private.pData);
    }
    Copy(p, &(object->private), l, char);

    if (object->private.pData) {

crypt_pkcs11_struct_camellia.c view on Meta::CPAN

        if (!pData) {
            /* uncoverable block 0 */
            __croak("memory allocation error");
        }
        Copy(object->private.pData, pData, object->private.length, CK_BYTE);
        object->private.pData = pData;
    }
    return CKR_OK;
}

void crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_DESTROY(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object) {
    if (object) {
        if (object->private.pData) {
            Safefree(object->private.pData);
        }
        Safefree(object);
    }
}

CK_RV crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_get_iv(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setpvn(sv, object->private.iv, 16 * sizeof(CK_BYTE));
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_set_iv(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    char* p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

crypt_pkcs11_struct_camellia.c view on Meta::CPAN

    }
    if (l != (16 * sizeof(CK_BYTE))) {
        return CKR_ARGUMENTS_BAD;
    }

    Copy(p, object->private.iv, 16, CK_BYTE);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_get_pData(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setpvn(sv, object->private.pData, object->private.length * sizeof(CK_BYTE));
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_set_pData(Crypt__PKCS11__CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    CK_BYTE_PTR n = 0;
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

crypt_pkcs11_struct_des.c view on Meta::CPAN

extern int __test_devel_cover_calloc_always_fail;
#define myNewxz(a,b,c) if (__test_devel_cover_calloc_always_fail) { a = 0; } else { Newxz(a, b, c); }
#define __croak(x) return 0
#else
#define myNewxz Newxz
#define __croak(x) croak(x)
#endif

extern int crypt_pkcs11_xs_SvUOK(SV* sv);

Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* crypt_pkcs11_ck_des_cbc_encrypt_data_params_new(const char* class) {
    Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object = 0;
    myNewxz(object, 1, Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS);

    if (!object) {
        /* uncoverable block 0 */
        __croak("memory allocation error");
    }
    return object;
}

SV* crypt_pkcs11_ck_des_cbc_encrypt_data_params_toBytes(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object) {
    if (!object) {
        return 0;
    }

    return newSVpvn((const char*)&(object->private), sizeof(CK_DES_CBC_ENCRYPT_DATA_PARAMS));
}

CK_RV crypt_pkcs11_ck_des_cbc_encrypt_data_params_fromBytes(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);

    if (!SvPOK(sv)
        || !(p = SvPVbyte(sv, l))
        || l != sizeof(CK_DES_CBC_ENCRYPT_DATA_PARAMS))
    {
        return CKR_ARGUMENTS_BAD;
    }

    if (object->private.pData) {
        Safefree(object->private.pData);
    }
    Copy(p, &(object->private), l, char);

    if (object->private.pData) {

crypt_pkcs11_struct_des.c view on Meta::CPAN

        if (!pData) {
            /* uncoverable block 0 */
            __croak("memory allocation error");
        }
        Copy(object->private.pData, pData, object->private.length, CK_BYTE);
        object->private.pData = pData;
    }
    return CKR_OK;
}

void crypt_pkcs11_ck_des_cbc_encrypt_data_params_DESTROY(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object) {
    if (object) {
        if (object->private.pData) {
            Safefree(object->private.pData);
        }
        Safefree(object);
    }
}

CK_RV crypt_pkcs11_ck_des_cbc_encrypt_data_params_get_iv(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setpvn(sv, object->private.iv, 8 * sizeof(CK_BYTE));
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_des_cbc_encrypt_data_params_set_iv(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    char* p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

crypt_pkcs11_struct_des.c view on Meta::CPAN

    }
    if (l != (8 * sizeof(CK_BYTE))) {
        return CKR_ARGUMENTS_BAD;
    }

    Copy(p, object->private.iv, 8, CK_BYTE);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_des_cbc_encrypt_data_params_get_pData(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setpvn(sv, object->private.pData, object->private.length * sizeof(CK_BYTE));
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_des_cbc_encrypt_data_params_set_pData(Crypt__PKCS11__CK_DES_CBC_ENCRYPT_DATA_PARAMS* object, SV* sv) {
    CK_BYTE_PTR n = 0;
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

crypt_pkcs11_struct_rc2.c view on Meta::CPAN

extern int __test_devel_cover_calloc_always_fail;
#define myNewxz(a,b,c) if (__test_devel_cover_calloc_always_fail) { a = 0; } else { Newxz(a, b, c); }
#define __croak(x) return 0
#else
#define myNewxz Newxz
#define __croak(x) croak(x)
#endif

extern int crypt_pkcs11_xs_SvUOK(SV* sv);

Crypt__PKCS11__CK_RC2_CBC_PARAMS* crypt_pkcs11_ck_rc2_cbc_params_new(const char* class) {
    Crypt__PKCS11__CK_RC2_CBC_PARAMS* object = 0;
    myNewxz(object, 1, Crypt__PKCS11__CK_RC2_CBC_PARAMS);

    if (!object) {
        /* uncoverable block 0 */
        __croak("memory allocation error");
    }
    return object;
}

SV* crypt_pkcs11_ck_rc2_cbc_params_toBytes(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object) {
    if (!object) {
        return 0;
    }

    return newSVpvn((const char*)&(object->private), sizeof(CK_RC2_CBC_PARAMS));
}

CK_RV crypt_pkcs11_ck_rc2_cbc_params_fromBytes(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object, SV* sv) {
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);

    if (!SvPOK(sv)
        || !(p = SvPVbyte(sv, l))
        || l != sizeof(CK_RC2_CBC_PARAMS))
    {
        return CKR_ARGUMENTS_BAD;
    }

    Copy(p, &(object->private), l, char);

    return CKR_OK;
}

void crypt_pkcs11_ck_rc2_cbc_params_DESTROY(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object) {
    if (object) {
        Safefree(object);
    }
}

CK_RV crypt_pkcs11_ck_rc2_cbc_params_get_ulEffectiveBits(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setuv(sv, object->private.ulEffectiveBits);
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_rc2_cbc_params_set_ulEffectiveBits(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    if (!crypt_pkcs11_xs_SvUOK(sv)) {
        return CKR_ARGUMENTS_BAD;
    }

    object->private.ulEffectiveBits = SvUV(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_rc2_cbc_params_get_iv(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setpvn(sv, object->private.iv, 8 * sizeof(CK_BYTE));
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_rc2_cbc_params_set_iv(Crypt__PKCS11__CK_RC2_CBC_PARAMS* object, SV* sv) {
    char* p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

crypt_pkcs11_struct_rc5.c view on Meta::CPAN

    SvGETMAGIC(sv);
    if (!crypt_pkcs11_xs_SvUOK(sv)) {
        return CKR_ARGUMENTS_BAD;
    }

    object->private.ulRounds = SvUV(sv);

    return CKR_OK;
}

Crypt__PKCS11__CK_RC5_CBC_PARAMS* crypt_pkcs11_ck_rc5_cbc_params_new(const char* class) {
    Crypt__PKCS11__CK_RC5_CBC_PARAMS* object = 0;
    myNewxz(object, 1, Crypt__PKCS11__CK_RC5_CBC_PARAMS);

    if (!object) {
        /* uncoverable block 0 */
        __croak("memory allocation error");
    }
    return object;
}

SV* crypt_pkcs11_ck_rc5_cbc_params_toBytes(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object) {
    if (!object) {
        return 0;
    }

    return newSVpvn((const char*)&(object->private), sizeof(CK_RC5_CBC_PARAMS));
}

CK_RV crypt_pkcs11_ck_rc5_cbc_params_fromBytes(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv) {
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);

    if (!SvPOK(sv)
        || !(p = SvPVbyte(sv, l))
        || l != sizeof(CK_RC5_CBC_PARAMS))
    {
        return CKR_ARGUMENTS_BAD;
    }

    if (object->private.pIv) {
        Safefree(object->private.pIv);
    }
    Copy(p, &(object->private), l, char);

    if (object->private.pIv) {

crypt_pkcs11_struct_rc5.c view on Meta::CPAN

        if (!pIv) {
            /* uncoverable block 0 */
            __croak("memory allocation error");
        }
        Copy(object->private.pIv, pIv, object->private.ulIvLen, CK_BYTE);
        object->private.pIv = pIv;
    }
    return CKR_OK;
}

void crypt_pkcs11_ck_rc5_cbc_params_DESTROY(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object) {
    if (object) {
        if (object->private.pIv) {
            Safefree(object->private.pIv);
        }
        Safefree(object);
    }
}

CK_RV crypt_pkcs11_ck_rc5_cbc_params_get_ulWordsize(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setuv(sv, object->private.ulWordsize);
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_rc5_cbc_params_set_ulWordsize(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    if (!crypt_pkcs11_xs_SvUOK(sv)) {
        return CKR_ARGUMENTS_BAD;
    }

    object->private.ulWordsize = SvUV(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_rc5_cbc_params_get_ulRounds(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setuv(sv, object->private.ulRounds);
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_rc5_cbc_params_set_ulRounds(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    if (!crypt_pkcs11_xs_SvUOK(sv)) {
        return CKR_ARGUMENTS_BAD;
    }

    object->private.ulRounds = SvUV(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_rc5_cbc_params_get_pIv(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv) {
    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

    SvGETMAGIC(sv);
    sv_setpvn(sv, object->private.pIv, object->private.ulIvLen * sizeof(CK_BYTE));
    SvSETMAGIC(sv);

    return CKR_OK;
}

CK_RV crypt_pkcs11_ck_rc5_cbc_params_set_pIv(Crypt__PKCS11__CK_RC5_CBC_PARAMS* object, SV* sv) {
    CK_BYTE_PTR n = 0;
    CK_BYTE_PTR p;
    STRLEN l;

    if (!object) {
        return CKR_ARGUMENTS_BAD;
    }
    if (!sv) {
        return CKR_ARGUMENTS_BAD;
    }

lib/Crypt/PKCS11.pm view on Meta::CPAN

use constant CKM_SHA256_RSA_PKCS => 0x00000040;
use constant CKM_SHA384_RSA_PKCS => 0x00000041;
use constant CKM_SHA512_RSA_PKCS => 0x00000042;
use constant CKM_SHA256_RSA_PKCS_PSS => 0x00000043;
use constant CKM_SHA384_RSA_PKCS_PSS => 0x00000044;
use constant CKM_SHA512_RSA_PKCS_PSS => 0x00000045;
use constant CKM_SHA224_RSA_PKCS => 0x00000046;
use constant CKM_SHA224_RSA_PKCS_PSS => 0x00000047;
use constant CKM_RC2_KEY_GEN => 0x00000100;
use constant CKM_RC2_ECB => 0x00000101;
use constant CKM_RC2_CBC => 0x00000102;
use constant CKM_RC2_MAC => 0x00000103;
use constant CKM_RC2_MAC_GENERAL => 0x00000104;
use constant CKM_RC2_CBC_PAD => 0x00000105;
use constant CKM_RC4_KEY_GEN => 0x00000110;
use constant CKM_RC4 => 0x00000111;
use constant CKM_DES_KEY_GEN => 0x00000120;
use constant CKM_DES_ECB => 0x00000121;
use constant CKM_DES_CBC => 0x00000122;
use constant CKM_DES_MAC => 0x00000123;
use constant CKM_DES_MAC_GENERAL => 0x00000124;
use constant CKM_DES_CBC_PAD => 0x00000125;
use constant CKM_DES2_KEY_GEN => 0x00000130;
use constant CKM_DES3_KEY_GEN => 0x00000131;
use constant CKM_DES3_ECB => 0x00000132;
use constant CKM_DES3_CBC => 0x00000133;
use constant CKM_DES3_MAC => 0x00000134;
use constant CKM_DES3_MAC_GENERAL => 0x00000135;
use constant CKM_DES3_CBC_PAD => 0x00000136;
use constant CKM_CDMF_KEY_GEN => 0x00000140;
use constant CKM_CDMF_ECB => 0x00000141;
use constant CKM_CDMF_CBC => 0x00000142;
use constant CKM_CDMF_MAC => 0x00000143;
use constant CKM_CDMF_MAC_GENERAL => 0x00000144;
use constant CKM_CDMF_CBC_PAD => 0x00000145;
use constant CKM_DES_OFB64 => 0x00000150;
use constant CKM_DES_OFB8 => 0x00000151;
use constant CKM_DES_CFB64 => 0x00000152;
use constant CKM_DES_CFB8 => 0x00000153;
use constant CKM_MD2 => 0x00000200;
use constant CKM_MD2_HMAC => 0x00000201;
use constant CKM_MD2_HMAC_GENERAL => 0x00000202;
use constant CKM_MD5 => 0x00000210;
use constant CKM_MD5_HMAC => 0x00000211;
use constant CKM_MD5_HMAC_GENERAL => 0x00000212;

lib/Crypt/PKCS11.pm view on Meta::CPAN

use constant CKM_SHA512_HMAC => 0x00000271;
use constant CKM_SHA512_HMAC_GENERAL => 0x00000272;
use constant CKM_SECURID_KEY_GEN => 0x00000280;
use constant CKM_SECURID => 0x00000282;
use constant CKM_HOTP_KEY_GEN => 0x00000290;
use constant CKM_HOTP => 0x00000291;
use constant CKM_ACTI => 0x000002A0;
use constant CKM_ACTI_KEY_GEN => 0x000002A1;
use constant CKM_CAST_KEY_GEN => 0x00000300;
use constant CKM_CAST_ECB => 0x00000301;
use constant CKM_CAST_CBC => 0x00000302;
use constant CKM_CAST_MAC => 0x00000303;
use constant CKM_CAST_MAC_GENERAL => 0x00000304;
use constant CKM_CAST_CBC_PAD => 0x00000305;
use constant CKM_CAST3_KEY_GEN => 0x00000310;
use constant CKM_CAST3_ECB => 0x00000311;
use constant CKM_CAST3_CBC => 0x00000312;
use constant CKM_CAST3_MAC => 0x00000313;
use constant CKM_CAST3_MAC_GENERAL => 0x00000314;
use constant CKM_CAST3_CBC_PAD => 0x00000315;
use constant CKM_CAST5_KEY_GEN => 0x00000320;
use constant CKM_CAST128_KEY_GEN => 0x00000320;
use constant CKM_CAST5_ECB => 0x00000321;
use constant CKM_CAST128_ECB => 0x00000321;
use constant CKM_CAST5_CBC => 0x00000322;
use constant CKM_CAST128_CBC => 0x00000322;
use constant CKM_CAST5_MAC => 0x00000323;
use constant CKM_CAST128_MAC => 0x00000323;
use constant CKM_CAST5_MAC_GENERAL => 0x00000324;
use constant CKM_CAST128_MAC_GENERAL => 0x00000324;
use constant CKM_CAST5_CBC_PAD => 0x00000325;
use constant CKM_CAST128_CBC_PAD => 0x00000325;
use constant CKM_RC5_KEY_GEN => 0x00000330;
use constant CKM_RC5_ECB => 0x00000331;
use constant CKM_RC5_CBC => 0x00000332;
use constant CKM_RC5_MAC => 0x00000333;
use constant CKM_RC5_MAC_GENERAL => 0x00000334;
use constant CKM_RC5_CBC_PAD => 0x00000335;
use constant CKM_IDEA_KEY_GEN => 0x00000340;
use constant CKM_IDEA_ECB => 0x00000341;
use constant CKM_IDEA_CBC => 0x00000342;
use constant CKM_IDEA_MAC => 0x00000343;
use constant CKM_IDEA_MAC_GENERAL => 0x00000344;
use constant CKM_IDEA_CBC_PAD => 0x00000345;
use constant CKM_GENERIC_SECRET_KEY_GEN => 0x00000350;
use constant CKM_CONCATENATE_BASE_AND_KEY => 0x00000360;
use constant CKM_CONCATENATE_BASE_AND_DATA => 0x00000362;
use constant CKM_CONCATENATE_DATA_AND_BASE => 0x00000363;
use constant CKM_XOR_BASE_AND_DATA => 0x00000364;
use constant CKM_EXTRACT_KEY_FROM_KEY => 0x00000365;
use constant CKM_SSL3_PRE_MASTER_KEY_GEN => 0x00000370;
use constant CKM_SSL3_MASTER_KEY_DERIVE => 0x00000371;
use constant CKM_SSL3_KEY_AND_MAC_DERIVE => 0x00000372;
use constant CKM_SSL3_MASTER_KEY_DERIVE_DH => 0x00000373;

lib/Crypt/PKCS11.pm view on Meta::CPAN

use constant CKM_TLS_PRF => 0x00000378;
use constant CKM_SSL3_MD5_MAC => 0x00000380;
use constant CKM_SSL3_SHA1_MAC => 0x00000381;
use constant CKM_MD5_KEY_DERIVATION => 0x00000390;
use constant CKM_MD2_KEY_DERIVATION => 0x00000391;
use constant CKM_SHA1_KEY_DERIVATION => 0x00000392;
use constant CKM_SHA256_KEY_DERIVATION => 0x00000393;
use constant CKM_SHA384_KEY_DERIVATION => 0x00000394;
use constant CKM_SHA512_KEY_DERIVATION => 0x00000395;
use constant CKM_SHA224_KEY_DERIVATION => 0x00000396;
use constant CKM_PBE_MD2_DES_CBC => 0x000003A0;
use constant CKM_PBE_MD5_DES_CBC => 0x000003A1;
use constant CKM_PBE_MD5_CAST_CBC => 0x000003A2;
use constant CKM_PBE_MD5_CAST3_CBC => 0x000003A3;
use constant CKM_PBE_MD5_CAST5_CBC => 0x000003A4;
use constant CKM_PBE_MD5_CAST128_CBC => 0x000003A4;
use constant CKM_PBE_SHA1_CAST5_CBC => 0x000003A5;
use constant CKM_PBE_SHA1_CAST128_CBC => 0x000003A5;
use constant CKM_PBE_SHA1_RC4_128 => 0x000003A6;
use constant CKM_PBE_SHA1_RC4_40 => 0x000003A7;
use constant CKM_PBE_SHA1_DES3_EDE_CBC => 0x000003A8;
use constant CKM_PBE_SHA1_DES2_EDE_CBC => 0x000003A9;
use constant CKM_PBE_SHA1_RC2_128_CBC => 0x000003AA;
use constant CKM_PBE_SHA1_RC2_40_CBC => 0x000003AB;
use constant CKM_PKCS5_PBKD2 => 0x000003B0;
use constant CKM_PBA_SHA1_WITH_SHA1_HMAC => 0x000003C0;
use constant CKM_WTLS_PRE_MASTER_KEY_GEN => 0x000003D0;
use constant CKM_WTLS_MASTER_KEY_DERIVE => 0x000003D1;
use constant CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC => 0x000003D2;
use constant CKM_WTLS_PRF => 0x000003D3;
use constant CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE => 0x000003D4;
use constant CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE => 0x000003D5;
use constant CKM_KEY_WRAP_LYNKS => 0x00000400;
use constant CKM_KEY_WRAP_SET_OAEP => 0x00000401;
use constant CKM_CMS_SIG => 0x00000500;
use constant CKM_KIP_DERIVE => 0x00000510;
use constant CKM_KIP_WRAP => 0x00000511;
use constant CKM_KIP_MAC => 0x00000512;
use constant CKM_CAMELLIA_KEY_GEN => 0x00000550;
use constant CKM_CAMELLIA_ECB => 0x00000551;
use constant CKM_CAMELLIA_CBC => 0x00000552;
use constant CKM_CAMELLIA_MAC => 0x00000553;
use constant CKM_CAMELLIA_MAC_GENERAL => 0x00000554;
use constant CKM_CAMELLIA_CBC_PAD => 0x00000555;
use constant CKM_CAMELLIA_ECB_ENCRYPT_DATA => 0x00000556;
use constant CKM_CAMELLIA_CBC_ENCRYPT_DATA => 0x00000557;
use constant CKM_CAMELLIA_CTR => 0x00000558;
use constant CKM_ARIA_KEY_GEN => 0x00000560;
use constant CKM_ARIA_ECB => 0x00000561;
use constant CKM_ARIA_CBC => 0x00000562;
use constant CKM_ARIA_MAC => 0x00000563;
use constant CKM_ARIA_MAC_GENERAL => 0x00000564;
use constant CKM_ARIA_CBC_PAD => 0x00000565;
use constant CKM_ARIA_ECB_ENCRYPT_DATA => 0x00000566;
use constant CKM_ARIA_CBC_ENCRYPT_DATA => 0x00000567;
use constant CKM_SKIPJACK_KEY_GEN => 0x00001000;
use constant CKM_SKIPJACK_ECB64 => 0x00001001;
use constant CKM_SKIPJACK_CBC64 => 0x00001002;
use constant CKM_SKIPJACK_OFB64 => 0x00001003;
use constant CKM_SKIPJACK_CFB64 => 0x00001004;
use constant CKM_SKIPJACK_CFB32 => 0x00001005;
use constant CKM_SKIPJACK_CFB16 => 0x00001006;
use constant CKM_SKIPJACK_CFB8 => 0x00001007;
use constant CKM_SKIPJACK_WRAP => 0x00001008;
use constant CKM_SKIPJACK_PRIVATE_WRAP => 0x00001009;
use constant CKM_SKIPJACK_RELAYX => 0x0000100a;
use constant CKM_KEA_KEY_PAIR_GEN => 0x00001010;
use constant CKM_KEA_KEY_DERIVE => 0x00001011;
use constant CKM_FORTEZZA_TIMESTAMP => 0x00001020;
use constant CKM_BATON_KEY_GEN => 0x00001030;
use constant CKM_BATON_ECB128 => 0x00001031;
use constant CKM_BATON_ECB96 => 0x00001032;
use constant CKM_BATON_CBC128 => 0x00001033;
use constant CKM_BATON_COUNTER => 0x00001034;
use constant CKM_BATON_SHUFFLE => 0x00001035;
use constant CKM_BATON_WRAP => 0x00001036;
use constant CKM_ECDSA_KEY_PAIR_GEN => 0x00001040;
use constant CKM_EC_KEY_PAIR_GEN => 0x00001040;
use constant CKM_ECDSA => 0x00001041;
use constant CKM_ECDSA_SHA1 => 0x00001042;
use constant CKM_ECDH1_DERIVE => 0x00001050;
use constant CKM_ECDH1_COFACTOR_DERIVE => 0x00001051;
use constant CKM_ECMQV_DERIVE => 0x00001052;
use constant CKM_JUNIPER_KEY_GEN => 0x00001060;
use constant CKM_JUNIPER_ECB128 => 0x00001061;
use constant CKM_JUNIPER_CBC128 => 0x00001062;
use constant CKM_JUNIPER_COUNTER => 0x00001063;
use constant CKM_JUNIPER_SHUFFLE => 0x00001064;
use constant CKM_JUNIPER_WRAP => 0x00001065;
use constant CKM_FASTHASH => 0x00001070;
use constant CKM_AES_KEY_GEN => 0x00001080;
use constant CKM_AES_ECB => 0x00001081;
use constant CKM_AES_CBC => 0x00001082;
use constant CKM_AES_MAC => 0x00001083;
use constant CKM_AES_MAC_GENERAL => 0x00001084;
use constant CKM_AES_CBC_PAD => 0x00001085;
use constant CKM_AES_CTR => 0x00001086;
use constant CKM_BLOWFISH_KEY_GEN => 0x00001090;
use constant CKM_BLOWFISH_CBC => 0x00001091;
use constant CKM_TWOFISH_KEY_GEN => 0x00001092;
use constant CKM_TWOFISH_CBC => 0x00001093;
use constant CKM_DES_ECB_ENCRYPT_DATA => 0x00001100;
use constant CKM_DES_CBC_ENCRYPT_DATA => 0x00001101;
use constant CKM_DES3_ECB_ENCRYPT_DATA => 0x00001102;
use constant CKM_DES3_CBC_ENCRYPT_DATA => 0x00001103;
use constant CKM_AES_ECB_ENCRYPT_DATA => 0x00001104;
use constant CKM_AES_CBC_ENCRYPT_DATA => 0x00001105;
use constant CKM_DSA_PARAMETER_GEN => 0x00002000;
use constant CKM_DH_PKCS_PARAMETER_GEN => 0x00002001;
use constant CKM_X9_42_DH_PARAMETER_GEN => 0x00002002;
use constant CKM_VENDOR_DEFINED => 0x80000000;
use constant CKF_HW => 0x00000001;
use constant CKF_ENCRYPT => 0x00000100;
use constant CKF_DECRYPT => 0x00000200;
use constant CKF_DIGEST => 0x00000400;
use constant CKF_SIGN => 0x00000800;
use constant CKF_SIGN_RECOVER => 0x00001000;

lib/Crypt/PKCS11.pm view on Meta::CPAN

use constant CKA_GOSTR3411_PARAMS => 0x00000251;
use constant CKA_GOST28147_PARAMS => 0x00000252;
use constant CKM_DSA_SHA224 => 0x00000013;
use constant CKM_DSA_SHA256 => 0x00000014;
use constant CKM_DSA_SHA384 => 0x00000015;
use constant CKM_DSA_SHA512 => 0x00000016;
use constant CKM_DES3_CMAC_GENERAL => 0x00000137;
use constant CKM_DES3_CMAC => 0x00000138;
use constant CKM_SEED_KEY_GEN => 0x00000650;
use constant CKM_SEED_ECB => 0x00000651;
use constant CKM_SEED_CBC => 0x00000652;
use constant CKM_SEED_MAC => 0x00000653;
use constant CKM_SEED_MAC_GENERAL => 0x00000654;
use constant CKM_SEED_CBC_PAD => 0x00000655;
use constant CKM_SEED_ECB_ENCRYPT_DATA => 0x00000656;
use constant CKM_SEED_CBC_ENCRYPT_DATA => 0x00000657;
use constant CKM_ECDSA_SHA224 => 0x00001043;
use constant CKM_ECDSA_SHA256 => 0x00001044;
use constant CKM_ECDSA_SHA384 => 0x00001045;
use constant CKM_ECDSA_SHA512 => 0x00001046;
use constant CKM_AES_CTS => 0x00001089;
use constant CKM_AES_CMAC => 0x0000108A;
use constant CKM_AES_CMAC_GENERAL => 0x0000108B;
use constant CKM_AES_GCM => 0x00001087;
use constant CKM_AES_CCM => 0x00001088;
use constant CKM_AES_KEY_WRAP => 0x00001090;
use constant CKM_AES_KEY_WRAP_PAD => 0x00001091;
use constant CKM_BLOWFISH_CBC_PAD => 0x00001094;
use constant CKM_TWOFISH_CBC_PAD => 0x00001095;
use constant CKM_GOSTR3410_KEY_PAIR_GEN => 0x00001200;
use constant CKM_GOSTR3410 => 0x00001201;
use constant CKM_GOSTR3410_WITH_GOSTR3411 => 0x00001202;
use constant CKM_GOSTR3410_KEY_WRAP => 0x00001203;
use constant CKM_GOSTR3410_DERIVE => 0x00001204;
use constant CKM_GOSTR3411 => 0x00001210;
use constant CKM_GOSTR3411_HMAC => 0x00001211;
use constant CKM_GOST28147_KEY_GEN => 0x00001220;
use constant CKM_GOST28147_ECB => 0x00001221;
use constant CKM_GOST28147 => 0x00001222;

lib/Crypt/PKCS11.pm view on Meta::CPAN

    CKK_SHA512_HMAC() => 'CKK_SHA512_HMAC',
    CKK_SKIPJACK() => 'CKK_SKIPJACK',
    CKK_TWOFISH() => 'CKK_TWOFISH',
    CKK_VENDOR_DEFINED() => 'CKK_VENDOR_DEFINED',
    CKK_X9_42_DH() => 'CKK_X9_42_DH',
);

our %CKM_NAME = (
    CKM_ACTI() => 'CKM_ACTI',
    CKM_ACTI_KEY_GEN() => 'CKM_ACTI_KEY_GEN',
    CKM_AES_CBC() => 'CKM_AES_CBC',
    CKM_AES_CBC_ENCRYPT_DATA() => 'CKM_AES_CBC_ENCRYPT_DATA',
    CKM_AES_CBC_PAD() => 'CKM_AES_CBC_PAD',
    CKM_AES_CCM() => 'CKM_AES_CCM',
    CKM_AES_CFB128() => 'CKM_AES_CFB128',
    CKM_AES_CFB64() => 'CKM_AES_CFB64',
    CKM_AES_CFB8() => 'CKM_AES_CFB8',
    CKM_AES_CMAC() => 'CKM_AES_CMAC',
    CKM_AES_CMAC_GENERAL() => 'CKM_AES_CMAC_GENERAL',
    CKM_AES_CTR() => 'CKM_AES_CTR',
    CKM_AES_CTS() => 'CKM_AES_CTS',
    CKM_AES_ECB() => 'CKM_AES_ECB',
    CKM_AES_ECB_ENCRYPT_DATA() => 'CKM_AES_ECB_ENCRYPT_DATA',
    CKM_AES_GCM() => 'CKM_AES_GCM',
    CKM_AES_KEY_GEN() => 'CKM_AES_KEY_GEN',
    CKM_AES_KEY_WRAP() => 'CKM_AES_KEY_WRAP',
    CKM_AES_KEY_WRAP_PAD() => 'CKM_AES_KEY_WRAP_PAD',
    CKM_AES_MAC() => 'CKM_AES_MAC',
    CKM_AES_MAC_GENERAL() => 'CKM_AES_MAC_GENERAL',
    CKM_AES_OFB() => 'CKM_AES_OFB',
    CKM_ARIA_CBC() => 'CKM_ARIA_CBC',
    CKM_ARIA_CBC_ENCRYPT_DATA() => 'CKM_ARIA_CBC_ENCRYPT_DATA',
    CKM_ARIA_CBC_PAD() => 'CKM_ARIA_CBC_PAD',
    CKM_ARIA_ECB() => 'CKM_ARIA_ECB',
    CKM_ARIA_ECB_ENCRYPT_DATA() => 'CKM_ARIA_ECB_ENCRYPT_DATA',
    CKM_ARIA_KEY_GEN() => 'CKM_ARIA_KEY_GEN',
    CKM_ARIA_MAC() => 'CKM_ARIA_MAC',
    CKM_ARIA_MAC_GENERAL() => 'CKM_ARIA_MAC_GENERAL',
    CKM_BATON_CBC128() => 'CKM_BATON_CBC128',
    CKM_BATON_COUNTER() => 'CKM_BATON_COUNTER',
    CKM_BATON_ECB128() => 'CKM_BATON_ECB128',
    CKM_BATON_ECB96() => 'CKM_BATON_ECB96',
    CKM_BATON_KEY_GEN() => 'CKM_BATON_KEY_GEN',
    CKM_BATON_SHUFFLE() => 'CKM_BATON_SHUFFLE',
    CKM_BATON_WRAP() => 'CKM_BATON_WRAP',
    CKM_BLOWFISH_CBC() => 'CKM_BLOWFISH_CBC',
    CKM_BLOWFISH_CBC_PAD() => 'CKM_BLOWFISH_CBC_PAD',
    CKM_BLOWFISH_KEY_GEN() => 'CKM_BLOWFISH_KEY_GEN',
    CKM_CAMELLIA_CBC() => 'CKM_CAMELLIA_CBC',
    CKM_CAMELLIA_CBC_ENCRYPT_DATA() => 'CKM_CAMELLIA_CBC_ENCRYPT_DATA',
    CKM_CAMELLIA_CBC_PAD() => 'CKM_CAMELLIA_CBC_PAD',
    CKM_CAMELLIA_CTR() => 'CKM_CAMELLIA_CTR',
    CKM_CAMELLIA_ECB() => 'CKM_CAMELLIA_ECB',
    CKM_CAMELLIA_ECB_ENCRYPT_DATA() => 'CKM_CAMELLIA_ECB_ENCRYPT_DATA',
    CKM_CAMELLIA_KEY_GEN() => 'CKM_CAMELLIA_KEY_GEN',
    CKM_CAMELLIA_MAC() => 'CKM_CAMELLIA_MAC',
    CKM_CAMELLIA_MAC_GENERAL() => 'CKM_CAMELLIA_MAC_GENERAL',
    CKM_CAST128_CBC() => 'CKM_CAST128_CBC',
    CKM_CAST128_CBC_PAD() => 'CKM_CAST128_CBC_PAD',
    CKM_CAST128_ECB() => 'CKM_CAST128_ECB',
    CKM_CAST128_KEY_GEN() => 'CKM_CAST128_KEY_GEN',
    CKM_CAST128_MAC() => 'CKM_CAST128_MAC',
    CKM_CAST128_MAC_GENERAL() => 'CKM_CAST128_MAC_GENERAL',
    CKM_CAST3_CBC() => 'CKM_CAST3_CBC',
    CKM_CAST3_CBC_PAD() => 'CKM_CAST3_CBC_PAD',
    CKM_CAST3_ECB() => 'CKM_CAST3_ECB',
    CKM_CAST3_KEY_GEN() => 'CKM_CAST3_KEY_GEN',
    CKM_CAST3_MAC() => 'CKM_CAST3_MAC',
    CKM_CAST3_MAC_GENERAL() => 'CKM_CAST3_MAC_GENERAL',
    CKM_CAST5_CBC() => 'CKM_CAST5_CBC',
    CKM_CAST5_CBC_PAD() => 'CKM_CAST5_CBC_PAD',
    CKM_CAST5_ECB() => 'CKM_CAST5_ECB',
    CKM_CAST5_KEY_GEN() => 'CKM_CAST5_KEY_GEN',
    CKM_CAST5_MAC() => 'CKM_CAST5_MAC',
    CKM_CAST5_MAC_GENERAL() => 'CKM_CAST5_MAC_GENERAL',
    CKM_CAST_CBC() => 'CKM_CAST_CBC',
    CKM_CAST_CBC_PAD() => 'CKM_CAST_CBC_PAD',
    CKM_CAST_ECB() => 'CKM_CAST_ECB',
    CKM_CAST_KEY_GEN() => 'CKM_CAST_KEY_GEN',
    CKM_CAST_MAC() => 'CKM_CAST_MAC',
    CKM_CAST_MAC_GENERAL() => 'CKM_CAST_MAC_GENERAL',
    CKM_CDMF_CBC() => 'CKM_CDMF_CBC',
    CKM_CDMF_CBC_PAD() => 'CKM_CDMF_CBC_PAD',
    CKM_CDMF_ECB() => 'CKM_CDMF_ECB',
    CKM_CDMF_KEY_GEN() => 'CKM_CDMF_KEY_GEN',
    CKM_CDMF_MAC() => 'CKM_CDMF_MAC',
    CKM_CDMF_MAC_GENERAL() => 'CKM_CDMF_MAC_GENERAL',
    CKM_CMS_SIG() => 'CKM_CMS_SIG',
    CKM_CONCATENATE_BASE_AND_DATA() => 'CKM_CONCATENATE_BASE_AND_DATA',
    CKM_CONCATENATE_BASE_AND_KEY() => 'CKM_CONCATENATE_BASE_AND_KEY',
    CKM_CONCATENATE_DATA_AND_BASE() => 'CKM_CONCATENATE_DATA_AND_BASE',
    CKM_DES2_KEY_GEN() => 'CKM_DES2_KEY_GEN',
    CKM_DES3_CBC() => 'CKM_DES3_CBC',
    CKM_DES3_CBC_ENCRYPT_DATA() => 'CKM_DES3_CBC_ENCRYPT_DATA',
    CKM_DES3_CBC_PAD() => 'CKM_DES3_CBC_PAD',
    CKM_DES3_CMAC() => 'CKM_DES3_CMAC',
    CKM_DES3_CMAC_GENERAL() => 'CKM_DES3_CMAC_GENERAL',
    CKM_DES3_ECB() => 'CKM_DES3_ECB',
    CKM_DES3_ECB_ENCRYPT_DATA() => 'CKM_DES3_ECB_ENCRYPT_DATA',
    CKM_DES3_KEY_GEN() => 'CKM_DES3_KEY_GEN',
    CKM_DES3_MAC() => 'CKM_DES3_MAC',
    CKM_DES3_MAC_GENERAL() => 'CKM_DES3_MAC_GENERAL',
    CKM_DES_CBC() => 'CKM_DES_CBC',
    CKM_DES_CBC_ENCRYPT_DATA() => 'CKM_DES_CBC_ENCRYPT_DATA',
    CKM_DES_CBC_PAD() => 'CKM_DES_CBC_PAD',
    CKM_DES_CFB64() => 'CKM_DES_CFB64',
    CKM_DES_CFB8() => 'CKM_DES_CFB8',
    CKM_DES_ECB() => 'CKM_DES_ECB',
    CKM_DES_ECB_ENCRYPT_DATA() => 'CKM_DES_ECB_ENCRYPT_DATA',
    CKM_DES_KEY_GEN() => 'CKM_DES_KEY_GEN',
    CKM_DES_MAC() => 'CKM_DES_MAC',
    CKM_DES_MAC_GENERAL() => 'CKM_DES_MAC_GENERAL',
    CKM_DES_OFB64() => 'CKM_DES_OFB64',
    CKM_DES_OFB8() => 'CKM_DES_OFB8',
    CKM_DH_PKCS_DERIVE() => 'CKM_DH_PKCS_DERIVE',

lib/Crypt/PKCS11.pm view on Meta::CPAN

    CKM_GOST28147_MAC() => 'CKM_GOST28147_MAC',
    CKM_GOSTR3410() => 'CKM_GOSTR3410',
    CKM_GOSTR3410_DERIVE() => 'CKM_GOSTR3410_DERIVE',
    CKM_GOSTR3410_KEY_PAIR_GEN() => 'CKM_GOSTR3410_KEY_PAIR_GEN',
    CKM_GOSTR3410_KEY_WRAP() => 'CKM_GOSTR3410_KEY_WRAP',
    CKM_GOSTR3410_WITH_GOSTR3411() => 'CKM_GOSTR3410_WITH_GOSTR3411',
    CKM_GOSTR3411() => 'CKM_GOSTR3411',
    CKM_GOSTR3411_HMAC() => 'CKM_GOSTR3411_HMAC',
    CKM_HOTP() => 'CKM_HOTP',
    CKM_HOTP_KEY_GEN() => 'CKM_HOTP_KEY_GEN',
    CKM_IDEA_CBC() => 'CKM_IDEA_CBC',
    CKM_IDEA_CBC_PAD() => 'CKM_IDEA_CBC_PAD',
    CKM_IDEA_ECB() => 'CKM_IDEA_ECB',
    CKM_IDEA_KEY_GEN() => 'CKM_IDEA_KEY_GEN',
    CKM_IDEA_MAC() => 'CKM_IDEA_MAC',
    CKM_IDEA_MAC_GENERAL() => 'CKM_IDEA_MAC_GENERAL',
    CKM_JUNIPER_CBC128() => 'CKM_JUNIPER_CBC128',
    CKM_JUNIPER_COUNTER() => 'CKM_JUNIPER_COUNTER',
    CKM_JUNIPER_ECB128() => 'CKM_JUNIPER_ECB128',
    CKM_JUNIPER_KEY_GEN() => 'CKM_JUNIPER_KEY_GEN',
    CKM_JUNIPER_SHUFFLE() => 'CKM_JUNIPER_SHUFFLE',
    CKM_JUNIPER_WRAP() => 'CKM_JUNIPER_WRAP',
    CKM_KEA_KEY_DERIVE() => 'CKM_KEA_KEY_DERIVE',
    CKM_KEA_KEY_PAIR_GEN() => 'CKM_KEA_KEY_PAIR_GEN',
    CKM_KEY_WRAP_LYNKS() => 'CKM_KEY_WRAP_LYNKS',
    CKM_KEY_WRAP_SET_OAEP() => 'CKM_KEY_WRAP_SET_OAEP',
    CKM_KIP_DERIVE() => 'CKM_KIP_DERIVE',

lib/Crypt/PKCS11.pm view on Meta::CPAN

    CKM_MD2_HMAC() => 'CKM_MD2_HMAC',
    CKM_MD2_HMAC_GENERAL() => 'CKM_MD2_HMAC_GENERAL',
    CKM_MD2_KEY_DERIVATION() => 'CKM_MD2_KEY_DERIVATION',
    CKM_MD2_RSA_PKCS() => 'CKM_MD2_RSA_PKCS',
    CKM_MD5() => 'CKM_MD5',
    CKM_MD5_HMAC() => 'CKM_MD5_HMAC',
    CKM_MD5_HMAC_GENERAL() => 'CKM_MD5_HMAC_GENERAL',
    CKM_MD5_KEY_DERIVATION() => 'CKM_MD5_KEY_DERIVATION',
    CKM_MD5_RSA_PKCS() => 'CKM_MD5_RSA_PKCS',
    CKM_PBA_SHA1_WITH_SHA1_HMAC() => 'CKM_PBA_SHA1_WITH_SHA1_HMAC',
    CKM_PBE_MD2_DES_CBC() => 'CKM_PBE_MD2_DES_CBC',
    CKM_PBE_MD5_CAST128_CBC() => 'CKM_PBE_MD5_CAST128_CBC',
    CKM_PBE_MD5_CAST3_CBC() => 'CKM_PBE_MD5_CAST3_CBC',
    CKM_PBE_MD5_CAST5_CBC() => 'CKM_PBE_MD5_CAST5_CBC',
    CKM_PBE_MD5_CAST_CBC() => 'CKM_PBE_MD5_CAST_CBC',
    CKM_PBE_MD5_DES_CBC() => 'CKM_PBE_MD5_DES_CBC',
    CKM_PBE_SHA1_CAST128_CBC() => 'CKM_PBE_SHA1_CAST128_CBC',
    CKM_PBE_SHA1_CAST5_CBC() => 'CKM_PBE_SHA1_CAST5_CBC',
    CKM_PBE_SHA1_DES2_EDE_CBC() => 'CKM_PBE_SHA1_DES2_EDE_CBC',
    CKM_PBE_SHA1_DES3_EDE_CBC() => 'CKM_PBE_SHA1_DES3_EDE_CBC',
    CKM_PBE_SHA1_RC2_128_CBC() => 'CKM_PBE_SHA1_RC2_128_CBC',
    CKM_PBE_SHA1_RC2_40_CBC() => 'CKM_PBE_SHA1_RC2_40_CBC',
    CKM_PBE_SHA1_RC4_128() => 'CKM_PBE_SHA1_RC4_128',
    CKM_PBE_SHA1_RC4_40() => 'CKM_PBE_SHA1_RC4_40',
    CKM_PKCS5_PBKD2() => 'CKM_PKCS5_PBKD2',
    CKM_RC2_CBC() => 'CKM_RC2_CBC',
    CKM_RC2_CBC_PAD() => 'CKM_RC2_CBC_PAD',
    CKM_RC2_ECB() => 'CKM_RC2_ECB',
    CKM_RC2_KEY_GEN() => 'CKM_RC2_KEY_GEN',
    CKM_RC2_MAC() => 'CKM_RC2_MAC',
    CKM_RC2_MAC_GENERAL() => 'CKM_RC2_MAC_GENERAL',
    CKM_RC4() => 'CKM_RC4',
    CKM_RC4_KEY_GEN() => 'CKM_RC4_KEY_GEN',
    CKM_RC5_CBC() => 'CKM_RC5_CBC',
    CKM_RC5_CBC_PAD() => 'CKM_RC5_CBC_PAD',
    CKM_RC5_ECB() => 'CKM_RC5_ECB',
    CKM_RC5_KEY_GEN() => 'CKM_RC5_KEY_GEN',
    CKM_RC5_MAC() => 'CKM_RC5_MAC',
    CKM_RC5_MAC_GENERAL() => 'CKM_RC5_MAC_GENERAL',
    CKM_RIPEMD128() => 'CKM_RIPEMD128',
    CKM_RIPEMD128_HMAC() => 'CKM_RIPEMD128_HMAC',
    CKM_RIPEMD128_HMAC_GENERAL() => 'CKM_RIPEMD128_HMAC_GENERAL',
    CKM_RIPEMD128_RSA_PKCS() => 'CKM_RIPEMD128_RSA_PKCS',
    CKM_RIPEMD160() => 'CKM_RIPEMD160',
    CKM_RIPEMD160_HMAC() => 'CKM_RIPEMD160_HMAC',

lib/Crypt/PKCS11.pm view on Meta::CPAN

    CKM_RSA_PKCS_KEY_PAIR_GEN() => 'CKM_RSA_PKCS_KEY_PAIR_GEN',
    CKM_RSA_PKCS_OAEP() => 'CKM_RSA_PKCS_OAEP',
    CKM_RSA_PKCS_OAEP_TPM_1_1() => 'CKM_RSA_PKCS_OAEP_TPM_1_1',
    CKM_RSA_PKCS_PSS() => 'CKM_RSA_PKCS_PSS',
    CKM_RSA_PKCS_TPM_1_1() => 'CKM_RSA_PKCS_TPM_1_1',
    CKM_RSA_X_509() => 'CKM_RSA_X_509',
    CKM_RSA_X9_31() => 'CKM_RSA_X9_31',
    CKM_RSA_X9_31_KEY_PAIR_GEN() => 'CKM_RSA_X9_31_KEY_PAIR_GEN',
    CKM_SECURID() => 'CKM_SECURID',
    CKM_SECURID_KEY_GEN() => 'CKM_SECURID_KEY_GEN',
    CKM_SEED_CBC() => 'CKM_SEED_CBC',
    CKM_SEED_CBC_ENCRYPT_DATA() => 'CKM_SEED_CBC_ENCRYPT_DATA',
    CKM_SEED_CBC_PAD() => 'CKM_SEED_CBC_PAD',
    CKM_SEED_ECB() => 'CKM_SEED_ECB',
    CKM_SEED_ECB_ENCRYPT_DATA() => 'CKM_SEED_ECB_ENCRYPT_DATA',
    CKM_SEED_KEY_GEN() => 'CKM_SEED_KEY_GEN',
    CKM_SEED_MAC() => 'CKM_SEED_MAC',
    CKM_SEED_MAC_GENERAL() => 'CKM_SEED_MAC_GENERAL',
    CKM_SHA_1() => 'CKM_SHA_1',
    CKM_SHA_1_HMAC() => 'CKM_SHA_1_HMAC',
    CKM_SHA_1_HMAC_GENERAL() => 'CKM_SHA_1_HMAC_GENERAL',
    CKM_SHA1_KEY_DERIVATION() => 'CKM_SHA1_KEY_DERIVATION',
    CKM_SHA1_RSA_PKCS() => 'CKM_SHA1_RSA_PKCS',

lib/Crypt/PKCS11.pm view on Meta::CPAN

    CKM_SSL3_MASTER_KEY_DERIVE() => 'CKM_SSL3_MASTER_KEY_DERIVE',
    CKM_SSL3_MASTER_KEY_DERIVE_DH() => 'CKM_SSL3_MASTER_KEY_DERIVE_DH',
    CKM_SSL3_MD5_MAC() => 'CKM_SSL3_MD5_MAC',
    CKM_SSL3_PRE_MASTER_KEY_GEN() => 'CKM_SSL3_PRE_MASTER_KEY_GEN',
    CKM_SSL3_SHA1_MAC() => 'CKM_SSL3_SHA1_MAC',
    CKM_TLS_KEY_AND_MAC_DERIVE() => 'CKM_TLS_KEY_AND_MAC_DERIVE',
    CKM_TLS_MASTER_KEY_DERIVE() => 'CKM_TLS_MASTER_KEY_DERIVE',
    CKM_TLS_MASTER_KEY_DERIVE_DH() => 'CKM_TLS_MASTER_KEY_DERIVE_DH',
    CKM_TLS_PRE_MASTER_KEY_GEN() => 'CKM_TLS_PRE_MASTER_KEY_GEN',
    CKM_TLS_PRF() => 'CKM_TLS_PRF',
    CKM_TWOFISH_CBC() => 'CKM_TWOFISH_CBC',
    CKM_TWOFISH_CBC_PAD() => 'CKM_TWOFISH_CBC_PAD',
    CKM_TWOFISH_KEY_GEN() => 'CKM_TWOFISH_KEY_GEN',
    CKM_VENDOR_DEFINED() => 'CKM_VENDOR_DEFINED',
    CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE() => 'CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE',
    CKM_WTLS_MASTER_KEY_DERIVE() => 'CKM_WTLS_MASTER_KEY_DERIVE',
    CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC() => 'CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC',
    CKM_WTLS_PRE_MASTER_KEY_GEN() => 'CKM_WTLS_PRE_MASTER_KEY_GEN',
    CKM_WTLS_PRF() => 'CKM_WTLS_PRF',
    CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE() => 'CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE',
    CKM_X9_42_DH_DERIVE() => 'CKM_X9_42_DH_DERIVE',
    CKM_X9_42_DH_HYBRID_DERIVE() => 'CKM_X9_42_DH_HYBRID_DERIVE',

lib/Crypt/PKCS11.pm view on Meta::CPAN

CKA_SUPPORTED_CMS_ATTRIBUTES CKA_ALLOWED_MECHANISMS CKA_VENDOR_DEFINED
CKM_RSA_PKCS_KEY_PAIR_GEN CKM_RSA_PKCS CKM_RSA_9796 CKM_RSA_X_509
CKM_MD2_RSA_PKCS CKM_MD5_RSA_PKCS CKM_SHA1_RSA_PKCS CKM_RIPEMD128_RSA_PKCS
CKM_RIPEMD160_RSA_PKCS CKM_RSA_PKCS_OAEP CKM_RSA_X9_31_KEY_PAIR_GEN
CKM_RSA_X9_31 CKM_SHA1_RSA_X9_31 CKM_RSA_PKCS_PSS CKM_SHA1_RSA_PKCS_PSS
CKM_DSA_KEY_PAIR_GEN CKM_DSA CKM_DSA_SHA1 CKM_DH_PKCS_KEY_PAIR_GEN
CKM_DH_PKCS_DERIVE CKM_X9_42_DH_KEY_PAIR_GEN CKM_X9_42_DH_DERIVE
CKM_X9_42_DH_HYBRID_DERIVE CKM_X9_42_MQV_DERIVE CKM_SHA256_RSA_PKCS
CKM_SHA384_RSA_PKCS CKM_SHA512_RSA_PKCS CKM_SHA256_RSA_PKCS_PSS
CKM_SHA384_RSA_PKCS_PSS CKM_SHA512_RSA_PKCS_PSS CKM_SHA224_RSA_PKCS
CKM_SHA224_RSA_PKCS_PSS CKM_RC2_KEY_GEN CKM_RC2_ECB CKM_RC2_CBC CKM_RC2_MAC
CKM_RC2_MAC_GENERAL CKM_RC2_CBC_PAD CKM_RC4_KEY_GEN CKM_RC4 CKM_DES_KEY_GEN
CKM_DES_ECB CKM_DES_CBC CKM_DES_MAC CKM_DES_MAC_GENERAL CKM_DES_CBC_PAD
CKM_DES2_KEY_GEN CKM_DES3_KEY_GEN CKM_DES3_ECB CKM_DES3_CBC CKM_DES3_MAC
CKM_DES3_MAC_GENERAL CKM_DES3_CBC_PAD CKM_CDMF_KEY_GEN CKM_CDMF_ECB
CKM_CDMF_CBC CKM_CDMF_MAC CKM_CDMF_MAC_GENERAL CKM_CDMF_CBC_PAD CKM_DES_OFB64
CKM_DES_OFB8 CKM_DES_CFB64 CKM_DES_CFB8 CKM_MD2 CKM_MD2_HMAC
CKM_MD2_HMAC_GENERAL CKM_MD5 CKM_MD5_HMAC CKM_MD5_HMAC_GENERAL CKM_SHA_1
CKM_SHA_1_HMAC CKM_SHA_1_HMAC_GENERAL CKM_RIPEMD128 CKM_RIPEMD128_HMAC
CKM_RIPEMD128_HMAC_GENERAL CKM_RIPEMD160 CKM_RIPEMD160_HMAC
CKM_RIPEMD160_HMAC_GENERAL CKM_SHA256 CKM_SHA256_HMAC CKM_SHA256_HMAC_GENERAL
CKM_SHA224 CKM_SHA224_HMAC CKM_SHA224_HMAC_GENERAL CKM_SHA384 CKM_SHA384_HMAC
CKM_SHA384_HMAC_GENERAL CKM_SHA512 CKM_SHA512_HMAC CKM_SHA512_HMAC_GENERAL
CKM_SECURID_KEY_GEN CKM_SECURID CKM_HOTP_KEY_GEN CKM_HOTP CKM_ACTI
CKM_ACTI_KEY_GEN CKM_CAST_KEY_GEN CKM_CAST_ECB CKM_CAST_CBC CKM_CAST_MAC
CKM_CAST_MAC_GENERAL CKM_CAST_CBC_PAD CKM_CAST3_KEY_GEN CKM_CAST3_ECB
CKM_CAST3_CBC CKM_CAST3_MAC CKM_CAST3_MAC_GENERAL CKM_CAST3_CBC_PAD
CKM_CAST5_KEY_GEN CKM_CAST128_KEY_GEN CKM_CAST5_ECB CKM_CAST128_ECB
CKM_CAST5_CBC CKM_CAST128_CBC CKM_CAST5_MAC CKM_CAST128_MAC
CKM_CAST5_MAC_GENERAL CKM_CAST128_MAC_GENERAL CKM_CAST5_CBC_PAD
CKM_CAST128_CBC_PAD CKM_RC5_KEY_GEN CKM_RC5_ECB CKM_RC5_CBC CKM_RC5_MAC
CKM_RC5_MAC_GENERAL CKM_RC5_CBC_PAD CKM_IDEA_KEY_GEN CKM_IDEA_ECB CKM_IDEA_CBC
CKM_IDEA_MAC CKM_IDEA_MAC_GENERAL CKM_IDEA_CBC_PAD CKM_GENERIC_SECRET_KEY_GEN
CKM_CONCATENATE_BASE_AND_KEY CKM_CONCATENATE_BASE_AND_DATA
CKM_CONCATENATE_DATA_AND_BASE CKM_XOR_BASE_AND_DATA CKM_EXTRACT_KEY_FROM_KEY
CKM_SSL3_PRE_MASTER_KEY_GEN CKM_SSL3_MASTER_KEY_DERIVE
CKM_SSL3_KEY_AND_MAC_DERIVE CKM_SSL3_MASTER_KEY_DERIVE_DH
CKM_TLS_PRE_MASTER_KEY_GEN CKM_TLS_MASTER_KEY_DERIVE CKM_TLS_KEY_AND_MAC_DERIVE
CKM_TLS_MASTER_KEY_DERIVE_DH CKM_TLS_PRF CKM_SSL3_MD5_MAC CKM_SSL3_SHA1_MAC
CKM_MD5_KEY_DERIVATION CKM_MD2_KEY_DERIVATION CKM_SHA1_KEY_DERIVATION
CKM_SHA256_KEY_DERIVATION CKM_SHA384_KEY_DERIVATION CKM_SHA512_KEY_DERIVATION
CKM_SHA224_KEY_DERIVATION CKM_PBE_MD2_DES_CBC CKM_PBE_MD5_DES_CBC
CKM_PBE_MD5_CAST_CBC CKM_PBE_MD5_CAST3_CBC CKM_PBE_MD5_CAST5_CBC
CKM_PBE_MD5_CAST128_CBC CKM_PBE_SHA1_CAST5_CBC CKM_PBE_SHA1_CAST128_CBC
CKM_PBE_SHA1_RC4_128 CKM_PBE_SHA1_RC4_40 CKM_PBE_SHA1_DES3_EDE_CBC
CKM_PBE_SHA1_DES2_EDE_CBC CKM_PBE_SHA1_RC2_128_CBC CKM_PBE_SHA1_RC2_40_CBC
CKM_PKCS5_PBKD2 CKM_PBA_SHA1_WITH_SHA1_HMAC CKM_WTLS_PRE_MASTER_KEY_GEN
CKM_WTLS_MASTER_KEY_DERIVE CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC CKM_WTLS_PRF
CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE
CKM_KEY_WRAP_LYNKS CKM_KEY_WRAP_SET_OAEP CKM_CMS_SIG CKM_KIP_DERIVE
CKM_KIP_WRAP CKM_KIP_MAC CKM_CAMELLIA_KEY_GEN CKM_CAMELLIA_ECB CKM_CAMELLIA_CBC
CKM_CAMELLIA_MAC CKM_CAMELLIA_MAC_GENERAL CKM_CAMELLIA_CBC_PAD
CKM_CAMELLIA_ECB_ENCRYPT_DATA CKM_CAMELLIA_CBC_ENCRYPT_DATA CKM_CAMELLIA_CTR
CKM_ARIA_KEY_GEN CKM_ARIA_ECB CKM_ARIA_CBC CKM_ARIA_MAC CKM_ARIA_MAC_GENERAL
CKM_ARIA_CBC_PAD CKM_ARIA_ECB_ENCRYPT_DATA CKM_ARIA_CBC_ENCRYPT_DATA
CKM_SKIPJACK_KEY_GEN CKM_SKIPJACK_ECB64 CKM_SKIPJACK_CBC64 CKM_SKIPJACK_OFB64
CKM_SKIPJACK_CFB64 CKM_SKIPJACK_CFB32 CKM_SKIPJACK_CFB16 CKM_SKIPJACK_CFB8
CKM_SKIPJACK_WRAP CKM_SKIPJACK_PRIVATE_WRAP CKM_SKIPJACK_RELAYX
CKM_KEA_KEY_PAIR_GEN CKM_KEA_KEY_DERIVE CKM_FORTEZZA_TIMESTAMP
CKM_BATON_KEY_GEN CKM_BATON_ECB128 CKM_BATON_ECB96 CKM_BATON_CBC128
CKM_BATON_COUNTER CKM_BATON_SHUFFLE CKM_BATON_WRAP CKM_ECDSA_KEY_PAIR_GEN
CKM_EC_KEY_PAIR_GEN CKM_ECDSA CKM_ECDSA_SHA1 CKM_ECDH1_DERIVE
CKM_ECDH1_COFACTOR_DERIVE CKM_ECMQV_DERIVE CKM_JUNIPER_KEY_GEN
CKM_JUNIPER_ECB128 CKM_JUNIPER_CBC128 CKM_JUNIPER_COUNTER CKM_JUNIPER_SHUFFLE
CKM_JUNIPER_WRAP CKM_FASTHASH CKM_AES_KEY_GEN CKM_AES_ECB CKM_AES_CBC
CKM_AES_MAC CKM_AES_MAC_GENERAL CKM_AES_CBC_PAD CKM_AES_CTR
CKM_BLOWFISH_KEY_GEN CKM_BLOWFISH_CBC CKM_TWOFISH_KEY_GEN CKM_TWOFISH_CBC
CKM_DES_ECB_ENCRYPT_DATA CKM_DES_CBC_ENCRYPT_DATA CKM_DES3_ECB_ENCRYPT_DATA
CKM_DES3_CBC_ENCRYPT_DATA CKM_AES_ECB_ENCRYPT_DATA CKM_AES_CBC_ENCRYPT_DATA
CKM_DSA_PARAMETER_GEN CKM_DH_PKCS_PARAMETER_GEN CKM_X9_42_DH_PARAMETER_GEN
CKM_VENDOR_DEFINED CKF_HW CKF_ENCRYPT CKF_DECRYPT CKF_DIGEST CKF_SIGN
CKF_SIGN_RECOVER CKF_VERIFY CKF_VERIFY_RECOVER CKF_GENERATE
CKF_GENERATE_KEY_PAIR CKF_WRAP CKF_UNWRAP CKF_DERIVE CKF_EC_F_P CKF_EC_F_2M
CKF_EC_ECPARAMETERS CKF_EC_NAMEDCURVE CKF_EC_UNCOMPRESS CKF_EC_COMPRESS
CKF_EXTENSION CKR_OK CKR_CANCEL CKR_HOST_MEMORY CKR_SLOT_ID_INVALID
CKR_GENERAL_ERROR CKR_FUNCTION_FAILED CKR_ARGUMENTS_BAD CKR_NO_EVENT
CKR_NEED_TO_CREATE_THREADS CKR_CANT_LOCK CKR_ATTRIBUTE_READ_ONLY
CKR_ATTRIBUTE_SENSITIVE CKR_ATTRIBUTE_TYPE_INVALID CKR_ATTRIBUTE_VALUE_INVALID
CKR_DATA_INVALID CKR_DATA_LEN_RANGE CKR_DEVICE_ERROR CKR_DEVICE_MEMORY

lib/Crypt/PKCS11.pm view on Meta::CPAN

CK_OTP_FLAGS CK_OTP_OUTPUT_LENGTH CK_OTP_OUTPUT_FORMAT CKF_NEXT_OTP
CKF_EXCLUDE_TIME CKF_EXCLUDE_COUNTER CKF_EXCLUDE_CHALLENGE CKF_EXCLUDE_PIN
CKF_USER_FRIENDLY_OTP

CKF_ERROR_STATE CKK_MD5_HMAC CKK_SHA_1_HMAC CKK_RIPEMD128_HMAC
CKK_RIPEMD160_HMAC CKK_SHA256_HMAC CKK_SHA384_HMAC CKK_SHA512_HMAC
CKK_SHA224_HMAC CKK_SEED CKK_GOSTR3410 CKK_GOSTR3411 CKK_GOST28147
CKA_DERIVE_TEMPLATE CKA_GOSTR3410_PARAMS CKA_GOSTR3411_PARAMS
CKA_GOST28147_PARAMS CKM_DSA_SHA224 CKM_DSA_SHA256 CKM_DSA_SHA384
CKM_DSA_SHA512 CKM_DES3_CMAC_GENERAL CKM_DES3_CMAC CKM_SEED_KEY_GEN
CKM_SEED_ECB CKM_SEED_CBC CKM_SEED_MAC CKM_SEED_MAC_GENERAL CKM_SEED_CBC_PAD
CKM_SEED_ECB_ENCRYPT_DATA CKM_SEED_CBC_ENCRYPT_DATA CKM_ECDSA_SHA224
CKM_ECDSA_SHA256 CKM_ECDSA_SHA384 CKM_ECDSA_SHA512 CKM_AES_CTS CKM_AES_CMAC
CKM_AES_CMAC_GENERAL CKM_AES_GCM CKM_AES_CCM CKM_AES_KEY_WRAP
CKM_AES_KEY_WRAP_PAD CKM_BLOWFISH_CBC_PAD CKM_TWOFISH_CBC_PAD
CKM_GOSTR3410_KEY_PAIR_GEN CKM_GOSTR3410 CKM_GOSTR3410_WITH_GOSTR3411
CKM_GOSTR3410_KEY_WRAP CKM_GOSTR3410_DERIVE CKM_GOSTR3411 CKM_GOSTR3411_HMAC
CKM_GOST28147_KEY_GEN CKM_GOST28147_ECB CKM_GOST28147 CKM_GOST28147_MAC
CKM_GOST28147_KEY_WRAP CKM_AES_OFB CKM_AES_CFB64 CKM_AES_CFB8 CKM_AES_CFB128
CKM_RSA_PKCS_TPM_1_1 CKM_RSA_PKCS_OAEP_TPM_1_1 CKR_EXCEEDED_MAX_ITERATIONS
CKR_FIPS_SELF_TEST_FAILED CKR_LIBRARY_LOAD_FAILED CKR_PIN_TOO_WEAK
CKR_PUBLIC_KEY_INVALID CKD_SHA224_KDF CKD_SHA256_KDF CKD_SHA384_KDF
CKD_SHA512_KDF CKD_CPDIVERSIFY_KDF

CKA_NAME_HASH_ALGORITHM CKA_COPYABLE)],

lib/Crypt/PKCS11.pm view on Meta::CPAN


sub errstr {
    return Crypt::PKCS11::XS::rv2str($_[0]->{rv});
}

package Crypt::PKCS11::struct;
use Carp;
sub toBytes {
    confess 'unimplemented';
}
package Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_AES_CCM_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_AES_CTR_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_AES_GCM_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_CMS_SIG_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_ECDH1_DERIVE_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_ECDH2_DERIVE_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_KEA_DERIVE_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_KEY_DERIVATION_STRING_DATA;

lib/Crypt/PKCS11.pm view on Meta::CPAN

package Crypt::PKCS11::CK_OTP_PARAM;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_OTP_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_OTP_SIGNATURE_INFO;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_PBE_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RC2_CBC_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RC5_CBC_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RC5_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RSA_PKCS_PSS_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS;

lib/Crypt/PKCS11.pm view on Meta::CPAN

use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_WTLS_RANDOM_DATA;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_X9_42_DH1_DERIVE_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS;
use base qw(Crypt::PKCS11::struct);

package Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_AES_CCM_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_AES_CTR_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_AES_GCM_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_CMS_SIG_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_ECDH1_DERIVE_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_ECDH2_DERIVE_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_KEA_DERIVE_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_KEY_DERIVATION_STRING_DATAPtr;

lib/Crypt/PKCS11.pm view on Meta::CPAN

package Crypt::PKCS11::CK_OTP_PARAMPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_OTP_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_OTP_SIGNATURE_INFOPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_PBE_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RC2_CBC_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RC5_CBC_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RC5_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_RSA_PKCS_PSS_PARAMSPtr;
use base qw(Crypt::PKCS11::struct);
package Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMSPtr;

lib/Crypt/PKCS11.pod view on Meta::CPAN

string.

=back

Following modules exist as an interface to its corresponding PKCS #11 C
structure, for more information about each structure see individual pod page and
PKCS #11 documentation.

=over 4

=item L<Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS>

=item L<Crypt::PKCS11::CK_AES_CCM_PARAMS>

=item L<Crypt::PKCS11::CK_AES_CTR_PARAMS>

=item L<Crypt::PKCS11::CK_AES_GCM_PARAMS>

=item L<Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS>

=item L<Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS>

=item L<Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS>

=item L<Crypt::PKCS11::CK_CMS_SIG_PARAMS>

=item L<Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS>

=item L<Crypt::PKCS11::CK_ECDH1_DERIVE_PARAMS>

=item L<Crypt::PKCS11::CK_ECDH2_DERIVE_PARAMS>

=item L<Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS>

=item L<Crypt::PKCS11::CK_KEA_DERIVE_PARAMS>

=item L<Crypt::PKCS11::CK_KEY_DERIVATION_STRING_DATA>

lib/Crypt/PKCS11.pod view on Meta::CPAN

=item L<Crypt::PKCS11::CK_OTP_PARAM>

=item L<Crypt::PKCS11::CK_OTP_PARAMS>

=item L<Crypt::PKCS11::CK_OTP_SIGNATURE_INFO>

=item L<Crypt::PKCS11::CK_PBE_PARAMS>

=item L<Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS>

=item L<Crypt::PKCS11::CK_RC2_CBC_PARAMS>

=item L<Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS>

=item L<Crypt::PKCS11::CK_RC5_CBC_PARAMS>

=item L<Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS>

=item L<Crypt::PKCS11::CK_RC5_PARAMS>

=item L<Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS>

=item L<Crypt::PKCS11::CK_RSA_PKCS_PSS_PARAMS>

=item L<Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS>

lib/Crypt/PKCS11/CK_AES_CBC_ENCRYPT_DATA_PARAMS.pod view on Meta::CPAN


=encoding utf8

=head1 NAME

Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS - Perl interface to PKCS #11 CK_AES_CBC_ENCRYPT_DATA_PARAMS structure

=head1 SYNPOSIS

  use Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS;
  my $obj = Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new;
  $obj->set...;
  $obj->get...;

=head1 DESCRIPTION

This is the Perl interface for the C structure CK_AES_CBC_ENCRYPT_DATA_PARAMS in PKCS #11.
See PKCS #11 documentation for more information about the structure and what it
is used for.

=head1 METHODS

=over 4

=item $obj = Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new

Returns a new Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS object.

=item $rv = $obj->get_iv($iv)

Retrieve the value B<iv> from the structure into C<$iv>.
Returns C<CKR_OK> on success otherwise a CKR describing the error.

=item $iv = $obj->iv

Returns the value B<iv> from the structure or undef on error.

lib/Crypt/PKCS11/CK_ARIA_CBC_ENCRYPT_DATA_PARAMS.pod view on Meta::CPAN


=encoding utf8

=head1 NAME

Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS - Perl interface to PKCS #11 CK_ARIA_CBC_ENCRYPT_DATA_PARAMS structure

=head1 SYNPOSIS

  use Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS;
  my $obj = Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new;
  $obj->set...;
  $obj->get...;

=head1 DESCRIPTION

This is the Perl interface for the C structure CK_ARIA_CBC_ENCRYPT_DATA_PARAMS in PKCS #11.
See PKCS #11 documentation for more information about the structure and what it
is used for.

=head1 METHODS

=over 4

=item $obj = Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new

Returns a new Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS object.

=item $rv = $obj->get_iv($iv)

Retrieve the value B<iv> from the structure into C<$iv>.
Returns C<CKR_OK> on success otherwise a CKR describing the error.

=item $iv = $obj->iv

Returns the value B<iv> from the structure or undef on error.

lib/Crypt/PKCS11/CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS.pod view on Meta::CPAN


=encoding utf8

=head1 NAME

Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS - Perl interface to PKCS #11 CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS structure

=head1 SYNPOSIS

  use Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS;
  my $obj = Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new;
  $obj->set...;
  $obj->get...;

=head1 DESCRIPTION

This is the Perl interface for the C structure CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS in PKCS #11.
See PKCS #11 documentation for more information about the structure and what it
is used for.

=head1 METHODS

=over 4

=item $obj = Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new

Returns a new Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS object.

=item $rv = $obj->get_iv($iv)

Retrieve the value B<iv> from the structure into C<$iv>.
Returns C<CKR_OK> on success otherwise a CKR describing the error.

=item $iv = $obj->iv

Returns the value B<iv> from the structure or undef on error.

lib/Crypt/PKCS11/CK_DES_CBC_ENCRYPT_DATA_PARAMS.pod view on Meta::CPAN


=encoding utf8

=head1 NAME

Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS - Perl interface to PKCS #11 CK_DES_CBC_ENCRYPT_DATA_PARAMS structure

=head1 SYNPOSIS

  use Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS;
  my $obj = Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new;
  $obj->set...;
  $obj->get...;

=head1 DESCRIPTION

This is the Perl interface for the C structure CK_DES_CBC_ENCRYPT_DATA_PARAMS in PKCS #11.
See PKCS #11 documentation for more information about the structure and what it
is used for.

=head1 METHODS

=over 4

=item $obj = Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new

Returns a new Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS object.

=item $rv = $obj->get_iv($iv)

Retrieve the value B<iv> from the structure into C<$iv>.
Returns C<CKR_OK> on success otherwise a CKR describing the error.

=item $iv = $obj->iv

Returns the value B<iv> from the structure or undef on error.

lib/Crypt/PKCS11/CK_RC2_CBC_PARAMS.pod view on Meta::CPAN


=encoding utf8

=head1 NAME

Crypt::PKCS11::CK_RC2_CBC_PARAMS - Perl interface to PKCS #11 CK_RC2_CBC_PARAMS structure

=head1 SYNPOSIS

  use Crypt::PKCS11::CK_RC2_CBC_PARAMS;
  my $obj = Crypt::PKCS11::CK_RC2_CBC_PARAMS->new;
  $obj->set...;
  $obj->get...;

=head1 DESCRIPTION

This is the Perl interface for the C structure CK_RC2_CBC_PARAMS in PKCS #11.
See PKCS #11 documentation for more information about the structure and what it
is used for.

=head1 METHODS

=over 4

=item $obj = Crypt::PKCS11::CK_RC2_CBC_PARAMS->new

Returns a new Crypt::PKCS11::CK_RC2_CBC_PARAMS object.

=item $rv = $obj->get_ulEffectiveBits($ulEffectiveBits)

Retrieve the value B<ulEffectiveBits> from the structure into C<$ulEffectiveBits>.
Returns C<CKR_OK> on success otherwise a CKR describing the error.

=item $ulEffectiveBits = $obj->ulEffectiveBits

Returns the value B<ulEffectiveBits> from the structure or undef on error.

lib/Crypt/PKCS11/CK_RC5_CBC_PARAMS.pod view on Meta::CPAN


=encoding utf8

=head1 NAME

Crypt::PKCS11::CK_RC5_CBC_PARAMS - Perl interface to PKCS #11 CK_RC5_CBC_PARAMS structure

=head1 SYNPOSIS

  use Crypt::PKCS11::CK_RC5_CBC_PARAMS;
  my $obj = Crypt::PKCS11::CK_RC5_CBC_PARAMS->new;
  $obj->set...;
  $obj->get...;

=head1 DESCRIPTION

This is the Perl interface for the C structure CK_RC5_CBC_PARAMS in PKCS #11.
See PKCS #11 documentation for more information about the structure and what it
is used for.

=head1 METHODS

=over 4

=item $obj = Crypt::PKCS11::CK_RC5_CBC_PARAMS->new

Returns a new Crypt::PKCS11::CK_RC5_CBC_PARAMS object.

=item $rv = $obj->get_ulWordsize($ulWordsize)

Retrieve the value B<ulWordsize> from the structure into C<$ulWordsize>.
Returns C<CKR_OK> on success otherwise a CKR describing the error.

=item $ulWordsize = $obj->ulWordsize

Returns the value B<ulWordsize> from the structure or undef on error.

pkcs11_struct_aes.xs view on Meta::CPAN

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "crypt_pkcs11_struct.h"

MODULE = Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS  PACKAGE = Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS  PREFIX = crypt_pkcs11_ck_aes_cbc_encrypt_data_params_

PROTOTYPES: ENABLE

Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS*
crypt_pkcs11_ck_aes_cbc_encrypt_data_params_new(class)
    const char* class
PROTOTYPE: $
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS  PACKAGE = Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMSPtr  PREFIX = crypt_pkcs11_ck_aes_cbc_encrypt_data_params_

PROTOTYPES: ENABLE

void
crypt_pkcs11_ck_aes_cbc_encrypt_data_params_DESTROY(object)
    Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $

SV*
crypt_pkcs11_ck_aes_cbc_encrypt_data_params_toBytes(object)
    Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_aes_cbc_encrypt_data_params_fromBytes(object, sv)
    Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_aes_cbc_encrypt_data_params_get_iv(object, sv)
    Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_aes_cbc_encrypt_data_params_iv(object)
    Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_aes_cbc_encrypt_data_params_get_iv(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_aes_cbc_encrypt_data_params_set_iv(object, sv)
    Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_aes_cbc_encrypt_data_params_get_pData(object, sv)
    Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_aes_cbc_encrypt_data_params_pData(object)
    Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_aes_cbc_encrypt_data_params_get_pData(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_aes_cbc_encrypt_data_params_set_pData(object, sv)
    Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_AES_CTR_PARAMS  PACKAGE = Crypt::PKCS11::CK_AES_CTR_PARAMS  PREFIX = crypt_pkcs11_ck_aes_ctr_params_

PROTOTYPES: ENABLE

Crypt::PKCS11::CK_AES_CTR_PARAMS*

pkcs11_struct_aria.xs view on Meta::CPAN

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "crypt_pkcs11_struct.h"

MODULE = Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS  PACKAGE = Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS  PREFIX = crypt_pkcs11_ck_aria_cbc_encrypt_data_params_

PROTOTYPES: ENABLE

Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS*
crypt_pkcs11_ck_aria_cbc_encrypt_data_params_new(class)
    const char* class
PROTOTYPE: $
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS  PACKAGE = Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMSPtr  PREFIX = crypt_pkcs11_ck_aria_cbc_encrypt_data_params_

PROTOTYPES: ENABLE

void
crypt_pkcs11_ck_aria_cbc_encrypt_data_params_DESTROY(object)
    Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $

SV*
crypt_pkcs11_ck_aria_cbc_encrypt_data_params_toBytes(object)
    Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_aria_cbc_encrypt_data_params_fromBytes(object, sv)
    Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_aria_cbc_encrypt_data_params_get_iv(object, sv)
    Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_aria_cbc_encrypt_data_params_iv(object)
    Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_aria_cbc_encrypt_data_params_get_iv(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_aria_cbc_encrypt_data_params_set_iv(object, sv)
    Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_aria_cbc_encrypt_data_params_get_pData(object, sv)
    Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_aria_cbc_encrypt_data_params_pData(object)
    Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_aria_cbc_encrypt_data_params_get_pData(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_aria_cbc_encrypt_data_params_set_pData(object, sv)
    Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL


MODULE = Crypt::PKCS11::CK_ARIA  PACKAGE = Crypt::PKCS11::CK_ARIA

pkcs11_struct_camellia.xs view on Meta::CPAN

    RETVAL

CK_RV
crypt_pkcs11_ck_camellia_ctr_params_set_cb(object, sv)
    Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS  PACKAGE = Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS  PREFIX = crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_

PROTOTYPES: ENABLE

Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS*
crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_new(class)
    const char* class
PROTOTYPE: $
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS  PACKAGE = Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMSPtr  PREFIX = crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_

PROTOTYPES: ENABLE

void
crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_DESTROY(object)
    Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $

SV*
crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_toBytes(object)
    Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_fromBytes(object, sv)
    Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_get_iv(object, sv)
    Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_iv(object)
    Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_get_iv(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_set_iv(object, sv)
    Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_get_pData(object, sv)
    Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_pData(object)
    Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_get_pData(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_camellia_cbc_encrypt_data_params_set_pData(object, sv)
    Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL


MODULE = Crypt::PKCS11::CK_CAMELLIA  PACKAGE = Crypt::PKCS11::CK_CAMELLIA

pkcs11_struct_des.xs view on Meta::CPAN

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "crypt_pkcs11_struct.h"

MODULE = Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS  PACKAGE = Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS  PREFIX = crypt_pkcs11_ck_des_cbc_encrypt_data_params_

PROTOTYPES: ENABLE

Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS*
crypt_pkcs11_ck_des_cbc_encrypt_data_params_new(class)
    const char* class
PROTOTYPE: $
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS  PACKAGE = Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMSPtr  PREFIX = crypt_pkcs11_ck_des_cbc_encrypt_data_params_

PROTOTYPES: ENABLE

void
crypt_pkcs11_ck_des_cbc_encrypt_data_params_DESTROY(object)
    Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $

SV*
crypt_pkcs11_ck_des_cbc_encrypt_data_params_toBytes(object)
    Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_des_cbc_encrypt_data_params_fromBytes(object, sv)
    Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_des_cbc_encrypt_data_params_get_iv(object, sv)
    Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_des_cbc_encrypt_data_params_iv(object)
    Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_des_cbc_encrypt_data_params_get_iv(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_des_cbc_encrypt_data_params_set_iv(object, sv)
    Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_des_cbc_encrypt_data_params_get_pData(object, sv)
    Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_des_cbc_encrypt_data_params_pData(object)
    Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_des_cbc_encrypt_data_params_get_pData(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_des_cbc_encrypt_data_params_set_pData(object, sv)
    Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL


MODULE = Crypt::PKCS11::CK_DES  PACKAGE = Crypt::PKCS11::CK_DES

pkcs11_struct_rc2.xs view on Meta::CPAN

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "crypt_pkcs11_struct.h"

MODULE = Crypt::PKCS11::CK_RC2_CBC_PARAMS  PACKAGE = Crypt::PKCS11::CK_RC2_CBC_PARAMS  PREFIX = crypt_pkcs11_ck_rc2_cbc_params_

PROTOTYPES: ENABLE

Crypt::PKCS11::CK_RC2_CBC_PARAMS*
crypt_pkcs11_ck_rc2_cbc_params_new(class)
    const char* class
PROTOTYPE: $
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_RC2_CBC_PARAMS  PACKAGE = Crypt::PKCS11::CK_RC2_CBC_PARAMSPtr  PREFIX = crypt_pkcs11_ck_rc2_cbc_params_

PROTOTYPES: ENABLE

void
crypt_pkcs11_ck_rc2_cbc_params_DESTROY(object)
    Crypt::PKCS11::CK_RC2_CBC_PARAMS* object
PROTOTYPE: $

SV*
crypt_pkcs11_ck_rc2_cbc_params_toBytes(object)
    Crypt::PKCS11::CK_RC2_CBC_PARAMS* object
PROTOTYPE: $
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc2_cbc_params_fromBytes(object, sv)
    Crypt::PKCS11::CK_RC2_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc2_cbc_params_get_ulEffectiveBits(object, sv)
    Crypt::PKCS11::CK_RC2_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_rc2_cbc_params_ulEffectiveBits(object)
    Crypt::PKCS11::CK_RC2_CBC_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_rc2_cbc_params_get_ulEffectiveBits(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc2_cbc_params_set_ulEffectiveBits(object, sv)
    Crypt::PKCS11::CK_RC2_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc2_cbc_params_get_iv(object, sv)
    Crypt::PKCS11::CK_RC2_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_rc2_cbc_params_iv(object)
    Crypt::PKCS11::CK_RC2_CBC_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_rc2_cbc_params_get_iv(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc2_cbc_params_set_iv(object, sv)
    Crypt::PKCS11::CK_RC2_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS  PACKAGE = Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS  PREFIX = crypt_pkcs11_ck_rc2_mac_general_params_

PROTOTYPES: ENABLE

Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS*

pkcs11_struct_rc5.xs view on Meta::CPAN

    RETVAL

CK_RV
crypt_pkcs11_ck_rc5_params_set_ulRounds(object, sv)
    Crypt::PKCS11::CK_RC5_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_RC5_CBC_PARAMS  PACKAGE = Crypt::PKCS11::CK_RC5_CBC_PARAMS  PREFIX = crypt_pkcs11_ck_rc5_cbc_params_

PROTOTYPES: ENABLE

Crypt::PKCS11::CK_RC5_CBC_PARAMS*
crypt_pkcs11_ck_rc5_cbc_params_new(class)
    const char* class
PROTOTYPE: $
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_RC5_CBC_PARAMS  PACKAGE = Crypt::PKCS11::CK_RC5_CBC_PARAMSPtr  PREFIX = crypt_pkcs11_ck_rc5_cbc_params_

PROTOTYPES: ENABLE

void
crypt_pkcs11_ck_rc5_cbc_params_DESTROY(object)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
PROTOTYPE: $

SV*
crypt_pkcs11_ck_rc5_cbc_params_toBytes(object)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
PROTOTYPE: $
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc5_cbc_params_fromBytes(object, sv)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc5_cbc_params_get_ulWordsize(object, sv)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_rc5_cbc_params_ulWordsize(object)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_rc5_cbc_params_get_ulWordsize(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc5_cbc_params_set_ulWordsize(object, sv)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc5_cbc_params_get_ulRounds(object, sv)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_rc5_cbc_params_ulRounds(object)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_rc5_cbc_params_get_ulRounds(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc5_cbc_params_set_ulRounds(object, sv)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc5_cbc_params_get_pIv(object, sv)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

SV*
crypt_pkcs11_ck_rc5_cbc_params_pIv(object)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
PROTOTYPE: $
CODE:
    RETVAL = newSV(0);
    crypt_pkcs11_ck_rc5_cbc_params_get_pIv(object, RETVAL);
OUTPUT:
    RETVAL

CK_RV
crypt_pkcs11_ck_rc5_cbc_params_set_pIv(object, sv)
    Crypt::PKCS11::CK_RC5_CBC_PARAMS* object
    SV* sv
PROTOTYPE: $$
OUTPUT:
    RETVAL

MODULE = Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS  PACKAGE = Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS  PREFIX = crypt_pkcs11_ck_rc5_mac_general_params_

PROTOTYPES: ENABLE

Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS*

pkcs11t.h view on Meta::CPAN

#define CKM_SHA512_RSA_PKCS            0x00000042
#define CKM_SHA256_RSA_PKCS_PSS        0x00000043
#define CKM_SHA384_RSA_PKCS_PSS        0x00000044
#define CKM_SHA512_RSA_PKCS_PSS        0x00000045

#define CKM_SHA224_RSA_PKCS            0x00000046
#define CKM_SHA224_RSA_PKCS_PSS        0x00000047

#define CKM_RC2_KEY_GEN                0x00000100
#define CKM_RC2_ECB                    0x00000101
#define CKM_RC2_CBC                    0x00000102
#define CKM_RC2_MAC                    0x00000103

#define CKM_RC2_MAC_GENERAL            0x00000104
#define CKM_RC2_CBC_PAD                0x00000105

#define CKM_RC4_KEY_GEN                0x00000110
#define CKM_RC4                        0x00000111
#define CKM_DES_KEY_GEN                0x00000120
#define CKM_DES_ECB                    0x00000121
#define CKM_DES_CBC                    0x00000122
#define CKM_DES_MAC                    0x00000123

#define CKM_DES_MAC_GENERAL            0x00000124
#define CKM_DES_CBC_PAD                0x00000125

#define CKM_DES2_KEY_GEN               0x00000130
#define CKM_DES3_KEY_GEN               0x00000131
#define CKM_DES3_ECB                   0x00000132
#define CKM_DES3_CBC                   0x00000133
#define CKM_DES3_MAC                   0x00000134

#define CKM_DES3_MAC_GENERAL           0x00000135
#define CKM_DES3_CBC_PAD               0x00000136
#define CKM_DES3_CMAC_GENERAL          0x00000137
#define CKM_DES3_CMAC                  0x00000138
#define CKM_CDMF_KEY_GEN               0x00000140
#define CKM_CDMF_ECB                   0x00000141
#define CKM_CDMF_CBC                   0x00000142
#define CKM_CDMF_MAC                   0x00000143
#define CKM_CDMF_MAC_GENERAL           0x00000144
#define CKM_CDMF_CBC_PAD               0x00000145

#define CKM_DES_OFB64                  0x00000150
#define CKM_DES_OFB8                   0x00000151
#define CKM_DES_CFB64                  0x00000152
#define CKM_DES_CFB8                   0x00000153

#define CKM_MD2                        0x00000200

#define CKM_MD2_HMAC                   0x00000201
#define CKM_MD2_HMAC_GENERAL           0x00000202

pkcs11t.h view on Meta::CPAN

#define CKM_SHA512_HMAC_GENERAL        0x00000272
#define CKM_SECURID_KEY_GEN            0x00000280
#define CKM_SECURID                    0x00000282
#define CKM_HOTP_KEY_GEN               0x00000290
#define CKM_HOTP                       0x00000291
#define CKM_ACTI                       0x000002A0
#define CKM_ACTI_KEY_GEN               0x000002A1

#define CKM_CAST_KEY_GEN               0x00000300
#define CKM_CAST_ECB                   0x00000301
#define CKM_CAST_CBC                   0x00000302
#define CKM_CAST_MAC                   0x00000303
#define CKM_CAST_MAC_GENERAL           0x00000304
#define CKM_CAST_CBC_PAD               0x00000305
#define CKM_CAST3_KEY_GEN              0x00000310
#define CKM_CAST3_ECB                  0x00000311
#define CKM_CAST3_CBC                  0x00000312
#define CKM_CAST3_MAC                  0x00000313
#define CKM_CAST3_MAC_GENERAL          0x00000314
#define CKM_CAST3_CBC_PAD              0x00000315
/* Note that CAST128 and CAST5 are the same algorithm */
#define CKM_CAST5_KEY_GEN              0x00000320
#define CKM_CAST128_KEY_GEN            0x00000320
#define CKM_CAST5_ECB                  0x00000321
#define CKM_CAST128_ECB                0x00000321
#define CKM_CAST5_CBC                  0x00000322
#define CKM_CAST128_CBC                0x00000322
#define CKM_CAST5_MAC                  0x00000323
#define CKM_CAST128_MAC                0x00000323
#define CKM_CAST5_MAC_GENERAL          0x00000324
#define CKM_CAST128_MAC_GENERAL        0x00000324
#define CKM_CAST5_CBC_PAD              0x00000325
#define CKM_CAST128_CBC_PAD            0x00000325
#define CKM_RC5_KEY_GEN                0x00000330
#define CKM_RC5_ECB                    0x00000331
#define CKM_RC5_CBC                    0x00000332
#define CKM_RC5_MAC                    0x00000333
#define CKM_RC5_MAC_GENERAL            0x00000334
#define CKM_RC5_CBC_PAD                0x00000335
#define CKM_IDEA_KEY_GEN               0x00000340
#define CKM_IDEA_ECB                   0x00000341
#define CKM_IDEA_CBC                   0x00000342
#define CKM_IDEA_MAC                   0x00000343
#define CKM_IDEA_MAC_GENERAL           0x00000344
#define CKM_IDEA_CBC_PAD               0x00000345
#define CKM_GENERIC_SECRET_KEY_GEN     0x00000350
#define CKM_CONCATENATE_BASE_AND_KEY   0x00000360
#define CKM_CONCATENATE_BASE_AND_DATA  0x00000362
#define CKM_CONCATENATE_DATA_AND_BASE  0x00000363
#define CKM_XOR_BASE_AND_DATA          0x00000364
#define CKM_EXTRACT_KEY_FROM_KEY       0x00000365
#define CKM_SSL3_PRE_MASTER_KEY_GEN    0x00000370
#define CKM_SSL3_MASTER_KEY_DERIVE     0x00000371
#define CKM_SSL3_KEY_AND_MAC_DERIVE    0x00000372

pkcs11t.h view on Meta::CPAN

#define CKM_MD5_KEY_DERIVATION         0x00000390
#define CKM_MD2_KEY_DERIVATION         0x00000391
#define CKM_SHA1_KEY_DERIVATION        0x00000392

#define CKM_SHA256_KEY_DERIVATION      0x00000393
#define CKM_SHA384_KEY_DERIVATION      0x00000394
#define CKM_SHA512_KEY_DERIVATION      0x00000395

#define CKM_SHA224_KEY_DERIVATION      0x00000396

#define CKM_PBE_MD2_DES_CBC            0x000003A0
#define CKM_PBE_MD5_DES_CBC            0x000003A1
#define CKM_PBE_MD5_CAST_CBC           0x000003A2
#define CKM_PBE_MD5_CAST3_CBC          0x000003A3
#define CKM_PBE_MD5_CAST5_CBC          0x000003A4
#define CKM_PBE_MD5_CAST128_CBC        0x000003A4
#define CKM_PBE_SHA1_CAST5_CBC         0x000003A5
#define CKM_PBE_SHA1_CAST128_CBC       0x000003A5
#define CKM_PBE_SHA1_RC4_128           0x000003A6
#define CKM_PBE_SHA1_RC4_40            0x000003A7
#define CKM_PBE_SHA1_DES3_EDE_CBC      0x000003A8
#define CKM_PBE_SHA1_DES2_EDE_CBC      0x000003A9
#define CKM_PBE_SHA1_RC2_128_CBC       0x000003AA
#define CKM_PBE_SHA1_RC2_40_CBC        0x000003AB

#define CKM_PKCS5_PBKD2                0x000003B0

#define CKM_PBA_SHA1_WITH_SHA1_HMAC    0x000003C0

#define CKM_WTLS_PRE_MASTER_KEY_GEN         0x000003D0
#define CKM_WTLS_MASTER_KEY_DERIVE          0x000003D1
#define CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC   0x000003D2
#define CKM_WTLS_PRF                        0x000003D3
#define CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE  0x000003D4

pkcs11t.h view on Meta::CPAN

#define CKM_KEY_WRAP_SET_OAEP          0x00000401

#define CKM_CMS_SIG                    0x00000500

#define CKM_KIP_DERIVE	               0x00000510
#define CKM_KIP_WRAP	               0x00000511
#define CKM_KIP_MAC	                   0x00000512

#define CKM_CAMELLIA_KEY_GEN           0x00000550
#define CKM_CAMELLIA_ECB               0x00000551
#define CKM_CAMELLIA_CBC               0x00000552
#define CKM_CAMELLIA_MAC               0x00000553
#define CKM_CAMELLIA_MAC_GENERAL       0x00000554
#define CKM_CAMELLIA_CBC_PAD           0x00000555
#define CKM_CAMELLIA_ECB_ENCRYPT_DATA  0x00000556
#define CKM_CAMELLIA_CBC_ENCRYPT_DATA  0x00000557
#define CKM_CAMELLIA_CTR               0x00000558

#define CKM_ARIA_KEY_GEN               0x00000560
#define CKM_ARIA_ECB                   0x00000561
#define CKM_ARIA_CBC                   0x00000562
#define CKM_ARIA_MAC                   0x00000563
#define CKM_ARIA_MAC_GENERAL           0x00000564
#define CKM_ARIA_CBC_PAD               0x00000565
#define CKM_ARIA_ECB_ENCRYPT_DATA      0x00000566
#define CKM_ARIA_CBC_ENCRYPT_DATA      0x00000567

#define CKM_SEED_KEY_GEN               0x00000650
#define CKM_SEED_ECB                   0x00000651
#define CKM_SEED_CBC                   0x00000652
#define CKM_SEED_MAC                   0x00000653
#define CKM_SEED_MAC_GENERAL           0x00000654
#define CKM_SEED_CBC_PAD               0x00000655
#define CKM_SEED_ECB_ENCRYPT_DATA      0x00000656
#define CKM_SEED_CBC_ENCRYPT_DATA      0x00000657

#define CKM_SKIPJACK_KEY_GEN           0x00001000
#define CKM_SKIPJACK_ECB64             0x00001001
#define CKM_SKIPJACK_CBC64             0x00001002
#define CKM_SKIPJACK_OFB64             0x00001003
#define CKM_SKIPJACK_CFB64             0x00001004
#define CKM_SKIPJACK_CFB32             0x00001005
#define CKM_SKIPJACK_CFB16             0x00001006
#define CKM_SKIPJACK_CFB8              0x00001007
#define CKM_SKIPJACK_WRAP              0x00001008
#define CKM_SKIPJACK_PRIVATE_WRAP      0x00001009
#define CKM_SKIPJACK_RELAYX            0x0000100a
#define CKM_KEA_KEY_PAIR_GEN           0x00001010
#define CKM_KEA_KEY_DERIVE             0x00001011
#define CKM_FORTEZZA_TIMESTAMP         0x00001020
#define CKM_BATON_KEY_GEN              0x00001030
#define CKM_BATON_ECB128               0x00001031
#define CKM_BATON_ECB96                0x00001032
#define CKM_BATON_CBC128               0x00001033
#define CKM_BATON_COUNTER              0x00001034
#define CKM_BATON_SHUFFLE              0x00001035
#define CKM_BATON_WRAP                 0x00001036

/* CKM_ECDSA_KEY_PAIR_GEN is deprecated in v2.11,
 * CKM_EC_KEY_PAIR_GEN is preferred */
#define CKM_ECDSA_KEY_PAIR_GEN         0x00001040
#define CKM_EC_KEY_PAIR_GEN            0x00001040

#define CKM_ECDSA                      0x00001041

pkcs11t.h view on Meta::CPAN

#define CKM_ECDSA_SHA256               0x00001044
#define CKM_ECDSA_SHA384               0x00001045
#define CKM_ECDSA_SHA512               0x00001046

#define CKM_ECDH1_DERIVE               0x00001050
#define CKM_ECDH1_COFACTOR_DERIVE      0x00001051
#define CKM_ECMQV_DERIVE               0x00001052

#define CKM_JUNIPER_KEY_GEN            0x00001060
#define CKM_JUNIPER_ECB128             0x00001061
#define CKM_JUNIPER_CBC128             0x00001062
#define CKM_JUNIPER_COUNTER            0x00001063
#define CKM_JUNIPER_SHUFFLE            0x00001064
#define CKM_JUNIPER_WRAP               0x00001065
#define CKM_FASTHASH                   0x00001070

#define CKM_AES_KEY_GEN                0x00001080
#define CKM_AES_ECB                    0x00001081
#define CKM_AES_CBC                    0x00001082
#define CKM_AES_MAC                    0x00001083
#define CKM_AES_MAC_GENERAL            0x00001084
#define CKM_AES_CBC_PAD                0x00001085
#define CKM_AES_CTR                    0x00001086
#define CKM_AES_CTS                    0x00001089
#define CKM_AES_CMAC                   0x0000108A
#define CKM_AES_CMAC_GENERAL           0x0000108B

#define CKM_BLOWFISH_KEY_GEN           0x00001090
#define CKM_BLOWFISH_CBC               0x00001091
#define CKM_TWOFISH_KEY_GEN            0x00001092
#define CKM_TWOFISH_CBC                0x00001093

#define CKM_AES_GCM                    0x00001087
#define CKM_AES_CCM                    0x00001088
#define CKM_AES_KEY_WRAP               0x00001090
#define CKM_AES_KEY_WRAP_PAD           0x00001091

#define CKM_BLOWFISH_CBC_PAD           0x00001094 
#define CKM_TWOFISH_CBC_PAD            0x00001095

#define CKM_DES_ECB_ENCRYPT_DATA       0x00001100
#define CKM_DES_CBC_ENCRYPT_DATA       0x00001101
#define CKM_DES3_ECB_ENCRYPT_DATA      0x00001102
#define CKM_DES3_CBC_ENCRYPT_DATA      0x00001103
#define CKM_AES_ECB_ENCRYPT_DATA       0x00001104
#define CKM_AES_CBC_ENCRYPT_DATA       0x00001105

#define CKM_GOSTR3410_KEY_PAIR_GEN     0x00001200
#define CKM_GOSTR3410                  0x00001201
#define CKM_GOSTR3410_WITH_GOSTR3411   0x00001202
#define CKM_GOSTR3410_KEY_WRAP         0x00001203
#define CKM_GOSTR3410_DERIVE           0x00001204
#define CKM_GOSTR3411                  0x00001210
#define CKM_GOSTR3411_HMAC             0x00001211
#define CKM_GOST28147_KEY_GEN          0x00001220
#define CKM_GOST28147_ECB              0x00001221

pkcs11t.h view on Meta::CPAN



/* CK_RC2_PARAMS provides the parameters to the CKM_RC2_ECB and
 * CKM_RC2_MAC mechanisms.  An instance of CK_RC2_PARAMS just
 * holds the effective keysize */
typedef CK_ULONG          CK_RC2_PARAMS;

typedef CK_RC2_PARAMS CK_PTR CK_RC2_PARAMS_PTR;


/* CK_RC2_CBC_PARAMS provides the parameters to the CKM_RC2_CBC
 * mechanism */
typedef struct CK_RC2_CBC_PARAMS {
  CK_ULONG      ulEffectiveBits;  /* effective bits (1-1024) */

  CK_BYTE       iv[8];            /* IV for CBC mode */
} CK_RC2_CBC_PARAMS;

typedef CK_RC2_CBC_PARAMS CK_PTR CK_RC2_CBC_PARAMS_PTR;


/* CK_RC2_MAC_GENERAL_PARAMS provides the parameters for the
 * CKM_RC2_MAC_GENERAL mechanism */
typedef struct CK_RC2_MAC_GENERAL_PARAMS {
  CK_ULONG      ulEffectiveBits;  /* effective bits (1-1024) */
  CK_ULONG      ulMacLength;      /* Length of MAC in bytes */
} CK_RC2_MAC_GENERAL_PARAMS;

typedef CK_RC2_MAC_GENERAL_PARAMS CK_PTR \

pkcs11t.h view on Meta::CPAN

/* CK_RC5_PARAMS provides the parameters to the CKM_RC5_ECB and
 * CKM_RC5_MAC mechanisms */
typedef struct CK_RC5_PARAMS {
  CK_ULONG      ulWordsize;  /* wordsize in bits */
  CK_ULONG      ulRounds;    /* number of rounds */
} CK_RC5_PARAMS;

typedef CK_RC5_PARAMS CK_PTR CK_RC5_PARAMS_PTR;


/* CK_RC5_CBC_PARAMS provides the parameters to the CKM_RC5_CBC
 * mechanism */
typedef struct CK_RC5_CBC_PARAMS {
  CK_ULONG      ulWordsize;  /* wordsize in bits */
  CK_ULONG      ulRounds;    /* number of rounds */
  CK_BYTE_PTR   pIv;         /* pointer to IV */
  CK_ULONG      ulIvLen;     /* length of IV in bytes */
} CK_RC5_CBC_PARAMS;

typedef CK_RC5_CBC_PARAMS CK_PTR CK_RC5_CBC_PARAMS_PTR;


/* CK_RC5_MAC_GENERAL_PARAMS provides the parameters for the
 * CKM_RC5_MAC_GENERAL mechanism */
typedef struct CK_RC5_MAC_GENERAL_PARAMS {
  CK_ULONG      ulWordsize;   /* wordsize in bits */
  CK_ULONG      ulRounds;     /* number of rounds */
  CK_ULONG      ulMacLength;  /* Length of MAC in bytes */
} CK_RC5_MAC_GENERAL_PARAMS;

pkcs11t.h view on Meta::CPAN

  CK_RC5_MAC_GENERAL_PARAMS_PTR;


/* CK_MAC_GENERAL_PARAMS provides the parameters to most block
 * ciphers' MAC_GENERAL mechanisms.  Its value is the length of
 * the MAC */
typedef CK_ULONG          CK_MAC_GENERAL_PARAMS;

typedef CK_MAC_GENERAL_PARAMS CK_PTR CK_MAC_GENERAL_PARAMS_PTR;

typedef struct CK_DES_CBC_ENCRYPT_DATA_PARAMS {
  CK_BYTE      iv[8];
  CK_BYTE_PTR  pData;
  CK_ULONG     length;
} CK_DES_CBC_ENCRYPT_DATA_PARAMS;

typedef CK_DES_CBC_ENCRYPT_DATA_PARAMS CK_PTR CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR;

typedef struct CK_AES_CBC_ENCRYPT_DATA_PARAMS {
  CK_BYTE      iv[16];
  CK_BYTE_PTR  pData;
  CK_ULONG     length;
} CK_AES_CBC_ENCRYPT_DATA_PARAMS;

typedef CK_AES_CBC_ENCRYPT_DATA_PARAMS CK_PTR CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR;

/* CK_SKIPJACK_PRIVATE_WRAP_PARAMS provides the parameters to the
 * CKM_SKIPJACK_PRIVATE_WRAP mechanism */
typedef struct CK_SKIPJACK_PRIVATE_WRAP_PARAMS {
  CK_ULONG      ulPasswordLen;
  CK_BYTE_PTR   pPassword;
  CK_ULONG      ulPublicDataLen;
  CK_BYTE_PTR   pPublicData;
  CK_ULONG      ulPAndGLen;
  CK_ULONG      ulQLen;

pkcs11t.h view on Meta::CPAN


typedef CK_AES_CCM_PARAMS CK_PTR CK_AES_CCM_PARAMS_PTR;

typedef struct CK_CAMELLIA_CTR_PARAMS {
    CK_ULONG ulCounterBits;
    CK_BYTE cb[16];
} CK_CAMELLIA_CTR_PARAMS;

typedef CK_CAMELLIA_CTR_PARAMS CK_PTR CK_CAMELLIA_CTR_PARAMS_PTR;

typedef struct CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS {
    CK_BYTE      iv[16];
    CK_BYTE_PTR  pData;
    CK_ULONG     length;
} CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS;

typedef CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS CK_PTR CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS_PTR;

typedef struct CK_ARIA_CBC_ENCRYPT_DATA_PARAMS {
    CK_BYTE      iv[16];
    CK_BYTE_PTR  pData;
    CK_ULONG     length;
} CK_ARIA_CBC_ENCRYPT_DATA_PARAMS;

typedef CK_ARIA_CBC_ENCRYPT_DATA_PARAMS CK_PTR CK_ARIA_CBC_ENCRYPT_DATA_PARAMS_PTR;

#endif

t/cover.t view on Meta::CPAN

    myok( defined Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->kdf, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->kdf' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->pOtherInfo, undef, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->pOtherInfo' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->pPublicData, undef, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->pPublicData' );
    myok( defined Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->hPrivateData, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->hPrivateData' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->pPublicData2, undef, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->pPublicData2' );
    myok( defined Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->publicKey, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->publicKey' );
    myok( defined Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->isSender, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->isSender' );
    myis( Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->pRandomA, undef, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->pRandomA' );
    myis( Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->pRandomB, undef, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->pRandomB' );
    myis( Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->pPublicData, undef, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->pPublicData' );
    myok( defined Crypt::PKCS11::CK_RC2_CBC_PARAMS->new->ulEffectiveBits, 'Crypt::PKCS11::CK_RC2_CBC_PARAMS->new->ulEffectiveBits' );
    myok( defined Crypt::PKCS11::CK_RC2_CBC_PARAMS->new->iv, 'Crypt::PKCS11::CK_RC2_CBC_PARAMS->new->iv' );
    myok( defined Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS->new->ulEffectiveBits, 'Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS->new->ulEffectiveBits' );
    myok( defined Crypt::PKCS11::CK_RC5_PARAMS->new->ulWordsize, 'Crypt::PKCS11::CK_RC5_PARAMS->new->ulWordsize' );
    myok( defined Crypt::PKCS11::CK_RC5_PARAMS->new->ulRounds, 'Crypt::PKCS11::CK_RC5_PARAMS->new->ulRounds' );
    myok( defined Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->ulWordsize, 'Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->ulWordsize' );
    myok( defined Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->ulRounds, 'Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->ulRounds' );
    myis( Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->pIv, undef, 'Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->pIv' );
    myok( defined Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new->ulWordsize, 'Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new->ulWordsize' );
    myok( defined Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new->ulRounds, 'Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new->ulRounds' );
    myok( defined Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new->iv, 'Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new->iv' );
    myis( Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new->pData, undef, 'Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new->pData' );
    myok( defined Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new->iv, 'Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new->iv' );
    myis( Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new->pData, undef, 'Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new->pData' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pPassword, undef, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pPassword' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pPublicData, undef, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pPublicData' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pRandomA, undef, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pRandomA' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pPrimeP, undef, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pPrimeP' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pBaseG, undef, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pBaseG' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pSubprimeQ, undef, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->pSubprimeQ' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->pOldWrappedX, undef, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->pOldWrappedX' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->pOldPassword, undef, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->pOldPassword' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->pOldPublicData, undef, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->pOldPublicData' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->pOldRandomA, undef, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->pOldRandomA' );

t/cover.t view on Meta::CPAN

    myok( defined Crypt::PKCS11::CK_AES_CTR_PARAMS->new->ulCounterBits, 'Crypt::PKCS11::CK_AES_CTR_PARAMS->new->ulCounterBits' );
    myok( defined Crypt::PKCS11::CK_AES_CTR_PARAMS->new->cb, 'Crypt::PKCS11::CK_AES_CTR_PARAMS->new->cb' );
    myis( Crypt::PKCS11::CK_AES_GCM_PARAMS->new->pIv, undef, 'Crypt::PKCS11::CK_AES_GCM_PARAMS->new->pIv' );
    myok( defined Crypt::PKCS11::CK_AES_GCM_PARAMS->new->ulIvBits, 'Crypt::PKCS11::CK_AES_GCM_PARAMS->new->ulIvBits' );
    myis( Crypt::PKCS11::CK_AES_GCM_PARAMS->new->pAAD, undef, 'Crypt::PKCS11::CK_AES_GCM_PARAMS->new->pAAD' );
    myok( defined Crypt::PKCS11::CK_AES_GCM_PARAMS->new->ulTagBits, 'Crypt::PKCS11::CK_AES_GCM_PARAMS->new->ulTagBits' );
    myis( Crypt::PKCS11::CK_AES_CCM_PARAMS->new->pNonce, undef, 'Crypt::PKCS11::CK_AES_CCM_PARAMS->new->pNonce' );
    myis( Crypt::PKCS11::CK_AES_CCM_PARAMS->new->pAAD, undef, 'Crypt::PKCS11::CK_AES_CCM_PARAMS->new->pAAD' );
    myok( defined Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS->new->ulCounterBits, 'Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS->new->ulCounterBits' );
    myok( defined Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS->new->cb, 'Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS->new->cb' );
    myok( defined Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new->iv, 'Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new->iv' );
    myis( Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new->pData, undef, 'Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new->pData' );
    myok( defined Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new->iv, 'Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new->iv' );
    myis( Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new->pData, undef, 'Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new->pData' );

    myisa_ok( $obj = Crypt::PKCS11::CK_VERSION->new, 'Crypt::PKCS11::CK_VERSIONPtr', 'Crypt::PKCS11::CK_VERSION->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_MECHANISM->new, 'Crypt::PKCS11::CK_MECHANISMPtr', 'Crypt::PKCS11::CK_MECHANISM->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );

t/cover.t view on Meta::CPAN

    myisa_ok( $obj = Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMSPtr', 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMSPtr', 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_RC2_CBC_PARAMS->new, 'Crypt::PKCS11::CK_RC2_CBC_PARAMSPtr', 'Crypt::PKCS11::CK_RC2_CBC_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS->new, 'Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMSPtr', 'Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_RC5_PARAMS->new, 'Crypt::PKCS11::CK_RC5_PARAMSPtr', 'Crypt::PKCS11::CK_RC5_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_RC5_CBC_PARAMS->new, 'Crypt::PKCS11::CK_RC5_CBC_PARAMSPtr', 'Crypt::PKCS11::CK_RC5_CBC_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new, 'Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMSPtr', 'Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMSPtr', 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMSPtr', 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new' );

t/cover.t view on Meta::CPAN

    myisa_ok( $obj = Crypt::PKCS11::CK_AES_CCM_PARAMS->new, 'Crypt::PKCS11::CK_AES_CCM_PARAMSPtr', 'Crypt::PKCS11::CK_AES_CCM_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS->new, 'Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMSPtr', 'Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myis( $obj->fromBytes(undef), CKR_ARGUMENTS_BAD, '$obj->fromBytes(undef)' );
    myis( $obj->fromBytes(''), CKR_ARGUMENTS_BAD, '$obj->fromBytes("")' );
    myis( $obj->fromBytes($bytes), CKR_OK, '$obj->fromBytes($bytes)' );

    myisa_ok( $obj = Crypt::PKCS11::CK_VERSION->new, 'Crypt::PKCS11::CK_VERSIONPtr', 'Crypt::PKCS11::CK_VERSION->new' );
    myis( $obj->set_major(1), CKR_OK, '$obj->set_major(1)' );
    myis( $obj->set_major(1), CKR_OK, '$obj->set_major(1)' );
    myis( $obj->set_minor(1), CKR_OK, '$obj->set_minor(1)' );
    myis( $obj->set_minor(1), CKR_OK, '$obj->set_minor(1)' );

t/cover.t view on Meta::CPAN

    myis( $obj->set_pRandomB(undef), CKR_OK, '$obj->set_pRandomB(undef)' );
    myis( $obj->set_pRandomB('1'), CKR_OK, '$obj->set_pRandomB("1")' );
    myis( $obj->set_pPublicData('1'), CKR_OK, '$obj->set_pPublicData("1")' );
    myis( $obj->set_pPublicData('1'), CKR_OK, '$obj->set_pPublicData("1")' );
    myis( $obj->set_pPublicData(undef), CKR_OK, '$obj->set_pPublicData(undef)' );
    myis( $obj->set_pPublicData('1'), CKR_OK, '$obj->set_pPublicData("1")' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMSPtr', 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_RC2_CBC_PARAMS->new, 'Crypt::PKCS11::CK_RC2_CBC_PARAMSPtr', 'Crypt::PKCS11::CK_RC2_CBC_PARAMS->new' );
    myis( $obj->set_ulEffectiveBits(1), CKR_OK, '$obj->set_ulEffectiveBits(1)' );
    myis( $obj->set_ulEffectiveBits(1), CKR_OK, '$obj->set_ulEffectiveBits(1)' );
    myis( $obj->set_iv('123456789'), CKR_ARGUMENTS_BAD, '$obj->set_iv("123456789")' );
    myis( $obj->set_iv(-1), CKR_ARGUMENTS_BAD, '$obj->set_iv(-1)' );
    myis( $obj->set_iv('12345678'), CKR_OK, '$obj->set_iv("12345678")' );
    myis( $obj->set_iv('12345678'), CKR_OK, '$obj->set_iv("12345678")' );
    myis( $obj->set_iv(undef), CKR_OK, '$obj->set_iv(undef)' );
    myis( $obj->set_iv('12345678'), CKR_OK, '$obj->set_iv("12345678")' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_RC2_CBC_PARAMS->new, 'Crypt::PKCS11::CK_RC2_CBC_PARAMSPtr', 'Crypt::PKCS11::CK_RC2_CBC_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS->new, 'Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMSPtr', 'Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS->new' );
    myis( $obj->set_ulEffectiveBits(1), CKR_OK, '$obj->set_ulEffectiveBits(1)' );
    myis( $obj->set_ulEffectiveBits(1), CKR_OK, '$obj->set_ulEffectiveBits(1)' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS->new, 'Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMSPtr', 'Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_RC5_PARAMS->new, 'Crypt::PKCS11::CK_RC5_PARAMSPtr', 'Crypt::PKCS11::CK_RC5_PARAMS->new' );
    myis( $obj->set_ulWordsize(1), CKR_OK, '$obj->set_ulWordsize(1)' );
    myis( $obj->set_ulWordsize(1), CKR_OK, '$obj->set_ulWordsize(1)' );
    myis( $obj->set_ulRounds(1), CKR_OK, '$obj->set_ulRounds(1)' );
    myis( $obj->set_ulRounds(1), CKR_OK, '$obj->set_ulRounds(1)' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_RC5_PARAMS->new, 'Crypt::PKCS11::CK_RC5_PARAMSPtr', 'Crypt::PKCS11::CK_RC5_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_RC5_CBC_PARAMS->new, 'Crypt::PKCS11::CK_RC5_CBC_PARAMSPtr', 'Crypt::PKCS11::CK_RC5_CBC_PARAMS->new' );
    myis( $obj->set_ulWordsize(1), CKR_OK, '$obj->set_ulWordsize(1)' );
    myis( $obj->set_ulWordsize(1), CKR_OK, '$obj->set_ulWordsize(1)' );
    myis( $obj->set_ulRounds(1), CKR_OK, '$obj->set_ulRounds(1)' );
    myis( $obj->set_ulRounds(1), CKR_OK, '$obj->set_ulRounds(1)' );
    myis( $obj->set_pIv('1'), CKR_OK, '$obj->set_pIv("1")' );
    myis( $obj->set_pIv('1'), CKR_OK, '$obj->set_pIv("1")' );
    myis( $obj->set_pIv(undef), CKR_OK, '$obj->set_pIv(undef)' );
    myis( $obj->set_pIv('1'), CKR_OK, '$obj->set_pIv("1")' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_RC5_CBC_PARAMS->new, 'Crypt::PKCS11::CK_RC5_CBC_PARAMSPtr', 'Crypt::PKCS11::CK_RC5_CBC_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new, 'Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMSPtr', 'Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new' );
    myis( $obj->set_ulWordsize(1), CKR_OK, '$obj->set_ulWordsize(1)' );
    myis( $obj->set_ulWordsize(1), CKR_OK, '$obj->set_ulWordsize(1)' );
    myis( $obj->set_ulRounds(1), CKR_OK, '$obj->set_ulRounds(1)' );
    myis( $obj->set_ulRounds(1), CKR_OK, '$obj->set_ulRounds(1)' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new, 'Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMSPtr', 'Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new' );
    myis( $obj->set_iv('123456789'), CKR_ARGUMENTS_BAD, '$obj->set_iv("123456789")' );
    myis( $obj->set_iv(-1), CKR_ARGUMENTS_BAD, '$obj->set_iv(-1)' );
    myis( $obj->set_iv('12345678'), CKR_OK, '$obj->set_iv("12345678")' );
    myis( $obj->set_iv('12345678'), CKR_OK, '$obj->set_iv("12345678")' );
    myis( $obj->set_iv(undef), CKR_OK, '$obj->set_iv(undef)' );
    myis( $obj->set_iv('12345678'), CKR_OK, '$obj->set_iv("12345678")' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myis( $obj->set_pData(undef), CKR_OK, '$obj->set_pData(undef)' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new' );
    myis( $obj->set_iv('12345678123456789'), CKR_ARGUMENTS_BAD, '$obj->set_iv("12345678123456789")' );
    myis( $obj->set_iv(-1), CKR_ARGUMENTS_BAD, '$obj->set_iv(-1)' );
    myis( $obj->set_iv('1234567812345678'), CKR_OK, '$obj->set_iv("1234567812345678")' );
    myis( $obj->set_iv('1234567812345678'), CKR_OK, '$obj->set_iv("1234567812345678")' );
    myis( $obj->set_iv(undef), CKR_OK, '$obj->set_iv(undef)' );
    myis( $obj->set_iv('1234567812345678'), CKR_OK, '$obj->set_iv("1234567812345678")' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myis( $obj->set_pData(undef), CKR_OK, '$obj->set_pData(undef)' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMSPtr', 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new' );
    myis( $obj->set_pPassword('1'), CKR_OK, '$obj->set_pPassword("1")' );
    myis( $obj->set_pPassword('1'), CKR_OK, '$obj->set_pPassword("1")' );
    myis( $obj->set_pPassword(undef), CKR_OK, '$obj->set_pPassword(undef)' );
    myis( $obj->set_pPassword('1'), CKR_OK, '$obj->set_pPassword("1")' );
    myis( $obj->set_pPublicData('1'), CKR_OK, '$obj->set_pPublicData("1")' );
    myis( $obj->set_pPublicData('1'), CKR_OK, '$obj->set_pPublicData("1")' );
    myis( $obj->set_pPublicData(undef), CKR_OK, '$obj->set_pPublicData(undef)' );

t/cover.t view on Meta::CPAN

    myis( $obj->set_cb('12345678123456789'), CKR_ARGUMENTS_BAD, '$obj->set_cb("12345678123456789")' );
    myis( $obj->set_cb(-1), CKR_ARGUMENTS_BAD, '$obj->set_cb(-1)' );
    myis( $obj->set_cb('1234567812345678'), CKR_OK, '$obj->set_cb("1234567812345678")' );
    myis( $obj->set_cb('1234567812345678'), CKR_OK, '$obj->set_cb("1234567812345678")' );
    myis( $obj->set_cb(undef), CKR_OK, '$obj->set_cb(undef)' );
    myis( $obj->set_cb('1234567812345678'), CKR_OK, '$obj->set_cb("1234567812345678")' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS->new, 'Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMSPtr', 'Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new' );
    myis( $obj->set_iv('12345678123456789'), CKR_ARGUMENTS_BAD, '$obj->set_iv("12345678123456789")' );
    myis( $obj->set_iv(-1), CKR_ARGUMENTS_BAD, '$obj->set_iv(-1)' );
    myis( $obj->set_iv('1234567812345678'), CKR_OK, '$obj->set_iv("1234567812345678")' );
    myis( $obj->set_iv('1234567812345678'), CKR_OK, '$obj->set_iv("1234567812345678")' );
    myis( $obj->set_iv(undef), CKR_OK, '$obj->set_iv(undef)' );
    myis( $obj->set_iv('1234567812345678'), CKR_OK, '$obj->set_iv("1234567812345678")' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myis( $obj->set_pData(undef), CKR_OK, '$obj->set_pData(undef)' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myok( $bytes = $obj->toBytes, '$obj->toBytes' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myisa_ok( $obj = Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new' );
    myis( $obj->set_iv('12345678123456789'), CKR_ARGUMENTS_BAD, '$obj->set_iv("12345678123456789")' );
    myis( $obj->set_iv(-1), CKR_ARGUMENTS_BAD, '$obj->set_iv(-1)' );
    myis( $obj->set_iv('1234567812345678'), CKR_OK, '$obj->set_iv("1234567812345678")' );
    myis( $obj->set_iv('1234567812345678'), CKR_OK, '$obj->set_iv("1234567812345678")' );
    myis( $obj->set_iv(undef), CKR_OK, '$obj->set_iv(undef)' );
    myis( $obj->set_iv('1234567812345678'), CKR_OK, '$obj->set_iv("1234567812345678")' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myis( $obj->set_pData(undef), CKR_OK, '$obj->set_pData(undef)' );
    myis( $obj->set_pData('1'), CKR_OK, '$obj->set_pData("1")' );
    myisa_ok( $obj2 = Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new, 'Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMSPtr', 'Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );
    myis( $obj2->fromBytes($bytes), CKR_OK, '$obj2->fromBytes($bytes)' );

    myis( Crypt::PKCS11::CK_VERSION->new->set_major(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_VERSION->new->set_major(-1)' );
    myis( Crypt::PKCS11::CK_VERSION->new->set_minor(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_VERSION->new->set_minor(-1)' );
    myis( Crypt::PKCS11::CK_MECHANISM->new->set_mechanism(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_MECHANISM->new->set_mechanism(-1)' );
    myis( Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS->new->set_hashAlg(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS->new->set_hashAlg(-1)' );
    myis( Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS->new->set_mgf(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS->new->set_mgf(-1)' );
    myis( Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS->new->set_source(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS->new->set_source(-1)' );
    myis( Crypt::PKCS11::CK_RSA_PKCS_PSS_PARAMS->new->set_hashAlg(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RSA_PKCS_PSS_PARAMS->new->set_hashAlg(-1)' );

t/cover.t view on Meta::CPAN

    myis( Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS->new->set_kdf(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS->new->set_kdf(-1)' );
    myis( Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS->new->set_hPrivateData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS->new->set_hPrivateData(-1)' );
    myis( Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS->new->set_publicKey(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS->new->set_publicKey(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_DH1_DERIVE_PARAMS->new->set_kdf(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_DH1_DERIVE_PARAMS->new->set_kdf(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_kdf(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_kdf(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_hPrivateData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_hPrivateData(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_kdf(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_kdf(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_hPrivateData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_hPrivateData(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_publicKey(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_publicKey(-1)' );
    myis( Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_isSender(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_isSender(-1)' );
    myis( Crypt::PKCS11::CK_RC2_CBC_PARAMS->new->set_ulEffectiveBits(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RC2_CBC_PARAMS->new->set_ulEffectiveBits(-1)' );
    myis( Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS->new->set_ulEffectiveBits(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS->new->set_ulEffectiveBits(-1)' );
    myis( Crypt::PKCS11::CK_RC5_PARAMS->new->set_ulWordsize(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RC5_PARAMS->new->set_ulWordsize(-1)' );
    myis( Crypt::PKCS11::CK_RC5_PARAMS->new->set_ulRounds(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RC5_PARAMS->new->set_ulRounds(-1)' );
    myis( Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->set_ulWordsize(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->set_ulWordsize(-1)' );
    myis( Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->set_ulRounds(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->set_ulRounds(-1)' );
    myis( Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new->set_ulWordsize(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new->set_ulWordsize(-1)' );
    myis( Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new->set_ulRounds(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS->new->set_ulRounds(-1)' );
    myis( Crypt::PKCS11::CK_PBE_PARAMS->new->set_ulIteration(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_PBE_PARAMS->new->set_ulIteration(-1)' );
    myis( Crypt::PKCS11::CK_KEY_WRAP_SET_OAEP_PARAMS->new->set_bBC(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_KEY_WRAP_SET_OAEP_PARAMS->new->set_bBC(-1)' );
    myis( Crypt::PKCS11::CK_SSL3_KEY_MAT_OUT->new->set_hClientMacSecret(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SSL3_KEY_MAT_OUT->new->set_hClientMacSecret(-1)' );
    myis( Crypt::PKCS11::CK_SSL3_KEY_MAT_OUT->new->set_hServerMacSecret(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SSL3_KEY_MAT_OUT->new->set_hServerMacSecret(-1)' );
    myis( Crypt::PKCS11::CK_SSL3_KEY_MAT_OUT->new->set_hClientKey(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SSL3_KEY_MAT_OUT->new->set_hClientKey(-1)' );
    myis( Crypt::PKCS11::CK_SSL3_KEY_MAT_OUT->new->set_hServerKey(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SSL3_KEY_MAT_OUT->new->set_hServerKey(-1)' );
    myis( Crypt::PKCS11::CK_SSL3_KEY_MAT_PARAMS->new->set_ulMacSizeInBits(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SSL3_KEY_MAT_PARAMS->new->set_ulMacSizeInBits(-1)' );
    myis( Crypt::PKCS11::CK_SSL3_KEY_MAT_PARAMS->new->set_ulKeySizeInBits(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SSL3_KEY_MAT_PARAMS->new->set_ulKeySizeInBits(-1)' );

t/cover.t view on Meta::CPAN

    myis( Crypt::PKCS11::CK_X9_42_DH1_DERIVE_PARAMS->new->set_pPublicData(undef), CKR_OK, 'Crypt::PKCS11::CK_X9_42_DH1_DERIVE_PARAMS->new->set_pPublicData(undef)' );
    myis( Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pOtherInfo(undef), CKR_OK, 'Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pOtherInfo(undef)' );
    myis( Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pPublicData(undef), CKR_OK, 'Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pPublicData(undef)' );
    myis( Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pPublicData2(undef), CKR_OK, 'Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pPublicData2(undef)' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pOtherInfo(undef), CKR_OK, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pOtherInfo(undef)' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pPublicData(undef), CKR_OK, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pPublicData(undef)' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pPublicData2(undef), CKR_OK, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pPublicData2(undef)' );
    myis( Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pRandomA(undef), CKR_OK, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pRandomA(undef)' );
    myis( Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pRandomB(undef), CKR_OK, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pRandomB(undef)' );
    myis( Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pPublicData(undef), CKR_OK, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pPublicData(undef)' );
    myis( Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->set_pIv(undef), CKR_OK, 'Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->set_pIv(undef)' );
    myis( Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(undef), CKR_OK, 'Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(undef)' );
    myis( Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(undef), CKR_OK, 'Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(undef)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPassword(undef), CKR_OK, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPassword(undef)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPublicData(undef), CKR_OK, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPublicData(undef)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pRandomA(undef), CKR_OK, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pRandomA(undef)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPrimeP(undef), CKR_OK, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPrimeP(undef)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pBaseG(undef), CKR_OK, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pBaseG(undef)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pSubprimeQ(undef), CKR_OK, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pSubprimeQ(undef)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldWrappedX(undef), CKR_OK, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldWrappedX(undef)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldPassword(undef), CKR_OK, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldPassword(undef)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldPublicData(undef), CKR_OK, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldPublicData(undef)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldRandomA(undef), CKR_OK, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldRandomA(undef)' );

t/cover.t view on Meta::CPAN

    myis( Crypt::PKCS11::CK_KEY_DERIVATION_STRING_DATA->new->set_pData(undef), CKR_OK, 'Crypt::PKCS11::CK_KEY_DERIVATION_STRING_DATA->new->set_pData(undef)' );
    myis( Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pSaltSourceData(undef), CKR_OK, 'Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pSaltSourceData(undef)' );
    myis( Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pPrfData(undef), CKR_OK, 'Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pPrfData(undef)' );
    myis( Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pPassword(undef), CKR_OK, 'Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pPassword(undef)' );
    myis( Crypt::PKCS11::CK_OTP_PARAM->new->set_pValue(undef), CKR_OK, 'Crypt::PKCS11::CK_OTP_PARAM->new->set_pValue(undef)' );
    myis( Crypt::PKCS11::CK_KIP_PARAMS->new->set_pSeed(undef), CKR_OK, 'Crypt::PKCS11::CK_KIP_PARAMS->new->set_pSeed(undef)' );
    myis( Crypt::PKCS11::CK_AES_GCM_PARAMS->new->set_pIv(undef), CKR_OK, 'Crypt::PKCS11::CK_AES_GCM_PARAMS->new->set_pIv(undef)' );
    myis( Crypt::PKCS11::CK_AES_GCM_PARAMS->new->set_pAAD(undef), CKR_OK, 'Crypt::PKCS11::CK_AES_GCM_PARAMS->new->set_pAAD(undef)' );
    myis( Crypt::PKCS11::CK_AES_CCM_PARAMS->new->set_pNonce(undef), CKR_OK, 'Crypt::PKCS11::CK_AES_CCM_PARAMS->new->set_pNonce(undef)' );
    myis( Crypt::PKCS11::CK_AES_CCM_PARAMS->new->set_pAAD(undef), CKR_OK, 'Crypt::PKCS11::CK_AES_CCM_PARAMS->new->set_pAAD(undef)' );
    myis( Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(undef), CKR_OK, 'Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(undef)' );
    myis( Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(undef), CKR_OK, 'Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(undef)' );

    myis( Crypt::PKCS11::CK_MECHANISM->new->set_pParameter(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_MECHANISM->new->set_pParameter(-1)' );
    myis( Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS->new->set_pSourceData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS->new->set_pSourceData(-1)' );
    myis( Crypt::PKCS11::CK_ECDH1_DERIVE_PARAMS->new->set_pSharedData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ECDH1_DERIVE_PARAMS->new->set_pSharedData(-1)' );
    myis( Crypt::PKCS11::CK_ECDH1_DERIVE_PARAMS->new->set_pPublicData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ECDH1_DERIVE_PARAMS->new->set_pPublicData(-1)' );
    myis( Crypt::PKCS11::CK_ECDH2_DERIVE_PARAMS->new->set_pSharedData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ECDH2_DERIVE_PARAMS->new->set_pSharedData(-1)' );
    myis( Crypt::PKCS11::CK_ECDH2_DERIVE_PARAMS->new->set_pPublicData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ECDH2_DERIVE_PARAMS->new->set_pPublicData(-1)' );
    myis( Crypt::PKCS11::CK_ECDH2_DERIVE_PARAMS->new->set_pPublicData2(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ECDH2_DERIVE_PARAMS->new->set_pPublicData2(-1)' );
    myis( Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS->new->set_pSharedData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS->new->set_pSharedData(-1)' );
    myis( Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS->new->set_pPublicData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS->new->set_pPublicData(-1)' );

t/cover.t view on Meta::CPAN

    myis( Crypt::PKCS11::CK_X9_42_DH1_DERIVE_PARAMS->new->set_pPublicData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_DH1_DERIVE_PARAMS->new->set_pPublicData(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pOtherInfo(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pOtherInfo(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pPublicData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pPublicData(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pPublicData2(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS->new->set_pPublicData2(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pOtherInfo(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pOtherInfo(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pPublicData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pPublicData(-1)' );
    myis( Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pPublicData2(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS->new->set_pPublicData2(-1)' );
    myis( Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pRandomA(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pRandomA(-1)' );
    myis( Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pRandomB(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pRandomB(-1)' );
    myis( Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pPublicData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_KEA_DERIVE_PARAMS->new->set_pPublicData(-1)' );
    myis( Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->set_pIv(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_RC5_CBC_PARAMS->new->set_pIv(-1)' );
    myis( Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(-1)' );
    myis( Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(-1)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPassword(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPassword(-1)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPublicData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPublicData(-1)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pRandomA(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pRandomA(-1)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPrimeP(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pPrimeP(-1)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pBaseG(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pBaseG(-1)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pSubprimeQ(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS->new->set_pSubprimeQ(-1)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldWrappedX(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldWrappedX(-1)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldPassword(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldPassword(-1)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldPublicData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldPublicData(-1)' );
    myis( Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldRandomA(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS->new->set_pOldRandomA(-1)' );

t/cover.t view on Meta::CPAN

    myis( Crypt::PKCS11::CK_KEY_DERIVATION_STRING_DATA->new->set_pData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_KEY_DERIVATION_STRING_DATA->new->set_pData(-1)' );
    myis( Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pSaltSourceData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pSaltSourceData(-1)' );
    myis( Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pPrfData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pPrfData(-1)' );
    myis( Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pPassword(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS->new->set_pPassword(-1)' );
    myis( Crypt::PKCS11::CK_OTP_PARAM->new->set_pValue(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_OTP_PARAM->new->set_pValue(-1)' );
    myis( Crypt::PKCS11::CK_KIP_PARAMS->new->set_pSeed(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_KIP_PARAMS->new->set_pSeed(-1)' );
    myis( Crypt::PKCS11::CK_AES_GCM_PARAMS->new->set_pIv(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_AES_GCM_PARAMS->new->set_pIv(-1)' );
    myis( Crypt::PKCS11::CK_AES_GCM_PARAMS->new->set_pAAD(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_AES_GCM_PARAMS->new->set_pAAD(-1)' );
    myis( Crypt::PKCS11::CK_AES_CCM_PARAMS->new->set_pNonce(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_AES_CCM_PARAMS->new->set_pNonce(-1)' );
    myis( Crypt::PKCS11::CK_AES_CCM_PARAMS->new->set_pAAD(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_AES_CCM_PARAMS->new->set_pAAD(-1)' );
    myis( Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(-1)' );
    myis( Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(-1), CKR_ARGUMENTS_BAD, 'Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS->new->set_pData(-1)' );
}

#{
#    local $SIG{__WARN__} = sub {};
#    my $sub = *Crypt::PKCS11::XS::new{CODE};
#    *Crypt::PKCS11::XS::new = sub ($) {};
#    $@ = undef; eval { Crypt::PKCS11->new; };
#    myok( $@, '*Crypt::PKCS11::XS::new undef' );
#    *Crypt::PKCS11::XS::new = $sub;
#}

typemap.struct view on Meta::CPAN

Crypt::PKCS11::CK_MECHANISM* T_PTROBJ
Crypt::PKCS11::CK_RSA_PKCS_OAEP_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_RSA_PKCS_PSS_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_ECDH1_DERIVE_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_ECDH2_DERIVE_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_ECMQV_DERIVE_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_X9_42_DH1_DERIVE_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_X9_42_DH2_DERIVE_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_X9_42_MQV_DERIVE_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_KEA_DERIVE_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_RC2_CBC_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_RC2_MAC_GENERAL_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_RC5_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_RC5_CBC_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_RC5_MAC_GENERAL_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_DES_CBC_ENCRYPT_DATA_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_AES_CBC_ENCRYPT_DATA_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_SKIPJACK_PRIVATE_WRAP_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_SKIPJACK_RELAYX_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_PBE_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_KEY_WRAP_SET_OAEP_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_SSL3_RANDOM_DATA* T_PTROBJ
Crypt::PKCS11::CK_SSL3_MASTER_KEY_DERIVE_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_SSL3_KEY_MAT_OUT* T_PTROBJ
Crypt::PKCS11::CK_SSL3_KEY_MAT_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_TLS_PRF_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_WTLS_RANDOM_DATA* T_PTROBJ

typemap.struct view on Meta::CPAN

Crypt::PKCS11::CK_KEY_DERIVATION_STRING_DATA* T_PTROBJ
Crypt::PKCS11::CK_PKCS5_PBKD2_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_OTP_PARAM* T_PTROBJ
Crypt::PKCS11::CK_OTP_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_OTP_SIGNATURE_INFO* T_PTROBJ
Crypt::PKCS11::CK_KIP_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_AES_CTR_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_AES_GCM_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_AES_CCM_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_CAMELLIA_CTR_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS* T_PTROBJ
Crypt::PKCS11::CK_ARIA_CBC_ENCRYPT_DATA_PARAMS* T_PTROBJ

( run in 1.638 second using v1.01-cache-2.11-cpan-e1769b4cff6 )