CryptX
view release on metacpan or search on metacpan
}
return saw_formatting;
}
typedef adler32_state *Crypt__Checksum__Adler32;
typedef crc32_state *Crypt__Checksum__CRC32;
typedef struct cryptx_authenc_ccm_struct {
ccm_state state;
int finalized;
} *Crypt__AuthEnc__CCM;
typedef struct cryptx_authenc_eax_struct {
eax_state state;
int finalized;
} *Crypt__AuthEnc__EAX;
typedef struct cryptx_authenc_gcm_struct {
gcm_state state;
int finalized;
} *Crypt__AuthEnc__GCM;
typedef struct cryptx_authenc_chacha20poly1305_struct {
chacha20poly1305_state state;
int finalized;
} *Crypt__AuthEnc__ChaCha20Poly1305;
typedef struct cryptx_authenc_ocb_struct {
ocb3_state state;
int finalized;
} *Crypt__AuthEnc__OCB;
typedef chacha_state *Crypt__Stream__ChaCha;
typedef chacha_state *Crypt__Stream__XChaCha;
typedef salsa20_state *Crypt__Stream__Salsa20;
typedef salsa20_state *Crypt__Stream__XSalsa20;
typedef sosemanuk_state *Crypt__Stream__Sosemanuk;
typedef rabbit_state *Crypt__Stream__Rabbit;
typedef rc4_state *Crypt__Stream__RC4;
typedef sober128_state *Crypt__Stream__Sober128;
typedef struct cryptx_mac_f9_struct {
f9_state state;
int finalized;
} *Crypt__Mac__F9;
typedef struct cryptx_mac_hmac_struct {
hmac_state state;
int finalized;
} *Crypt__Mac__HMAC;
typedef struct cryptx_mac_omac_struct {
omac_state state;
int finalized;
} *Crypt__Mac__OMAC;
typedef struct cryptx_mac_pelican_struct {
pelican_state state;
int finalized;
} *Crypt__Mac__Pelican;
typedef struct cryptx_mac_pmac_struct {
pmac_state state;
int finalized;
} *Crypt__Mac__PMAC;
typedef struct cryptx_mac_xcbc_struct {
xcbc_state state;
int finalized;
} *Crypt__Mac__XCBC;
typedef struct cryptx_mac_poly1305_struct {
poly1305_state state;
int finalized;
} *Crypt__Mac__Poly1305;
typedef struct cryptx_mac_blake2s_struct {
blake2smac_state state;
int finalized;
} *Crypt__Mac__BLAKE2s;
typedef struct cryptx_mac_blake2b_struct {
blake2bmac_state state;
int finalized;
} *Crypt__Mac__BLAKE2b;
typedef struct cryptx_mac_kmac_struct {
kmac_state state;
int finalized;
int variant;
} *Crypt__Mac__KMAC;
typedef struct cipher_struct { /* used by Crypt::Cipher */
symmetric_key skey;
struct ltc_cipher_descriptor *desc;
} *Crypt__Cipher;
typedef struct digest_struct { /* used by Crypt::Digest */
hash_state state;
struct ltc_hash_descriptor *desc;
int finalized;
} *Crypt__Digest;
STATIC int cryptx_internal_noclone_hash(const char *name) {
if (name == NULL) return 0;
return strcmp(name, "sha1") == 0
|| strcmp(name, "sha224") == 0
|| strcmp(name, "sha256") == 0;
}
typedef struct digest_shake_struct { /* used by Crypt::Digest::SHAKE, TurboSHAKE, KangarooTwelve */
hash_state state;
int num;
int squeezing;
} *Crypt__Digest__SHAKE;
typedef struct digest_shake_struct *Crypt__Digest__TurboSHAKE;
typedef struct digest_shake_struct *Crypt__Digest__KangarooTwelve;
/* --- Crypt::ASN1 helper -------------------------------------------------- */
static const char * const s_asn1_class_names[] = {
"UNIVERSAL", "APPLICATION", "CONTEXT_SPECIFIC", "PRIVATE"
};
typedef struct { int int_fmt; int bin_fmt; int dt_fmt; HV *oidmap; } asn1_opts_t;
/* int_fmt: 0=decimal(default) 1=hex 2=bytes */
/* bin_fmt: 0=raw(default) 1=hex 2=base64 */
/* dt_fmt: 0=rfc3339(default) 1=epoch */
static SV * s_asn1_oid_name_sv(pTHX_ HV *oidmap, SV *oid_sv)
{
STRLEN len = 0;
const char *oid = NULL;
SV **name_sv = NULL;
s_asn1_append_tlv(aTHX_ out, 0x16, data, (unsigned long)vlen);
}
else if (strEQ(type, "PRINTABLE_STRING")) {
STRLEN vlen = 0;
const char *data = (sv_value && SvOK(*sv_value)) ? SvPVbyte(*sv_value, vlen) : "";
s_asn1_append_tlv(aTHX_ out, 0x13, data, (unsigned long)vlen);
}
else if (strEQ(type, "TELETEX_STRING")) {
STRLEN vlen = 0;
const char *data = (sv_value && SvOK(*sv_value)) ? SvPVbyte(*sv_value, vlen) : "";
s_asn1_append_tlv(aTHX_ out, 0x14, data, (unsigned long)vlen);
}
else if (strEQ(type, "UTCTIME")) {
STRLEN vlen = 0;
const char *data = (sv_value && SvOK(*sv_value)) ? SvPV(*sv_value, vlen) : "";
s_asn1_append_tlv(aTHX_ out, 0x17, data, (unsigned long)vlen);
}
else if (strEQ(type, "GENERALIZEDTIME")) {
STRLEN vlen = 0;
const char *data = (sv_value && SvOK(*sv_value)) ? SvPV(*sv_value, vlen) : "";
s_asn1_append_tlv(aTHX_ out, 0x18, data, (unsigned long)vlen);
}
else if (strEQ(type, "SEQUENCE") || strEQ(type, "SET")) {
unsigned char tag = strEQ(type, "SEQUENCE") ? 0x30 : 0x31;
if (sv_value && SvROK(*sv_value) && SvTYPE(SvRV(*sv_value)) == SVt_PVAV) {
SV *content = newSVpvn("", 0);
s_asn1_encode_nodes(aTHX_ content, (AV *)SvRV(*sv_value));
{ STRLEN clen; const char *cdata = SvPV(content, clen);
s_asn1_append_tlv(aTHX_ out, tag, cdata, (unsigned long)clen); }
SvREFCNT_dec(content);
} else {
s_asn1_append_tlv(aTHX_ out, tag, NULL, 0);
}
}
else if (strEQ(type, "CUSTOM")) {
SV **sv_class = hv_fetchs(node, "class", 0);
SV **sv_constr = hv_fetchs(node, "constructed", 0);
SV **sv_tag = hv_fetchs(node, "tag", 0);
unsigned int klass = (sv_class && SvOK(*sv_class)) ? (unsigned int)SvIV(*sv_class) : 2;
unsigned int pc = (sv_constr && SvOK(*sv_constr) && SvIV(*sv_constr)) ? 1 : 0;
unsigned long tag = (sv_tag && SvOK(*sv_tag)) ? (unsigned long)SvUV(*sv_tag) : 0;
if (pc && sv_value && SvROK(*sv_value) && SvTYPE(SvRV(*sv_value)) == SVt_PVAV) {
SV *content = newSVpvn("", 0);
s_asn1_encode_nodes(aTHX_ content, (AV *)SvRV(*sv_value));
{ STRLEN clen; const char *cdata = SvPV(content, clen);
s_asn1_append_custom_tlv(aTHX_ out, klass, pc, tag, cdata, (unsigned long)clen); }
SvREFCNT_dec(content);
} else {
STRLEN vlen = 0;
const char *data = (sv_value && SvOK(*sv_value)) ? SvPVbyte(*sv_value, vlen) : "";
s_asn1_append_custom_tlv(aTHX_ out, klass, pc, tag, data, (unsigned long)vlen);
}
}
else {
croak("FATAL: asn1_encode: unsupported type '%s'", type);
}
}
/* --- end Crypt::ASN1 encoder helpers ------------------------------------- */
typedef struct cbc_struct { /* used by Crypt::Mode::CBC */
int cipher_id, cipher_rounds;
symmetric_CBC state;
unsigned char pad[MAXBLOCKSIZE];
int padlen;
int padding_mode;
int direction;
} *Crypt__Mode__CBC;
typedef struct ecb_struct { /* used by Crypt::Mode::ECB */
int cipher_id, cipher_rounds;
symmetric_ECB state;
unsigned char pad[MAXBLOCKSIZE];
int padlen;
int padding_mode;
int direction;
} *Crypt__Mode__ECB;
typedef struct cfb_struct { /* used by Crypt::Mode::CFB */
int cipher_id, cipher_rounds;
symmetric_CFB state;
int direction;
} *Crypt__Mode__CFB;
typedef struct ctr_struct { /* used by Crypt::Mode::CTR */
int cipher_id, cipher_rounds;
int ctr_mode_param;
symmetric_CTR state;
int direction;
} *Crypt__Mode__CTR;
typedef struct f8_struct { /* used by Crypt::Mode::F8 */
int cipher_id, cipher_rounds;
symmetric_F8 state;
int direction;
} *Crypt__Mode__F8;
typedef struct lrw_struct { /* used by Crypt::Mode::LRW */
int cipher_id, cipher_rounds;
symmetric_LRW state;
int direction;
} *Crypt__Mode__LRW;
typedef struct ofb_struct { /* used by Crypt::Mode::OFB */
int cipher_id, cipher_rounds;
symmetric_OFB state;
int direction;
} *Crypt__Mode__OFB;
typedef struct xts_struct { /* used by Crypt::Mode::XTS */
int cipher_id, cipher_rounds;
symmetric_xts state;
int direction;
} *Crypt__Mode__XTS;
typedef struct prng_struct { /* used by Crypt::PRNG */
prng_state state;
struct ltc_prng_descriptor *desc;
IV last_pid;
} *Crypt__PRNG;
typedef struct rsa_struct { /* used by Crypt::PK::RSA */
prng_state pstate;
int pindex;
IV last_pid;
rsa_key key;
} *Crypt__PK__RSA;
}
}
}
OUTPUT:
RETVAL
SV *
slow_eq(SV *a, SV *b)
CODE:
{
STRLEN a_len, b_len;
unsigned char *a_data, *b_data;
const void *first;
int result = 0;
if (!SvPOK_spec(a) || !SvPOK_spec(b)) XSRETURN_UNDEF;
a_data = (unsigned char *)SvPVbyte(a, a_len);
b_data = (unsigned char *)SvPVbyte(b, b_len);
first = a_data;
if (a_len != b_len) { first = b_data; result = 1; }
result |= mem_neq(first, b_data, b_len);
RETVAL = newSViv(result == 0 ? 1 : 0);
}
OUTPUT:
RETVAL
###############################################################################
INCLUDE: inc/CryptX_ASN1.xs.inc
INCLUDE: inc/CryptX_Digest.xs.inc
INCLUDE: inc/CryptX_Digest_SHAKE.xs.inc
INCLUDE: inc/CryptX_Digest_TurboSHAKE.xs.inc
INCLUDE: inc/CryptX_Digest_KangarooTwelve.xs.inc
INCLUDE: inc/CryptX_Cipher.xs.inc
INCLUDE: inc/CryptX_Checksum_Adler32.xs.inc
INCLUDE: inc/CryptX_Checksum_CRC32.xs.inc
INCLUDE: inc/CryptX_AuthEnc_EAX.xs.inc
INCLUDE: inc/CryptX_AuthEnc_GCM.xs.inc
INCLUDE: inc/CryptX_AuthEnc_OCB.xs.inc
INCLUDE: inc/CryptX_AuthEnc_CCM.xs.inc
INCLUDE: inc/CryptX_AuthEnc_ChaCha20Poly1305.xs.inc
INCLUDE: inc/CryptX_AuthEnc_SIV.xs.inc
INCLUDE: inc/CryptX_AuthEnc_GCMSIV.xs.inc
INCLUDE: inc/CryptX_Stream_ChaCha.xs.inc
INCLUDE: inc/CryptX_Stream_XChaCha.xs.inc
INCLUDE: inc/CryptX_Stream_Salsa20.xs.inc
INCLUDE: inc/CryptX_Stream_XSalsa20.xs.inc
INCLUDE: inc/CryptX_Stream_RC4.xs.inc
INCLUDE: inc/CryptX_Stream_Sober128.xs.inc
INCLUDE: inc/CryptX_Stream_Sosemanuk.xs.inc
INCLUDE: inc/CryptX_Stream_Rabbit.xs.inc
INCLUDE: inc/CryptX_Mac_F9.xs.inc
INCLUDE: inc/CryptX_Mac_HMAC.xs.inc
INCLUDE: inc/CryptX_Mac_OMAC.xs.inc
INCLUDE: inc/CryptX_Mac_Pelican.xs.inc
INCLUDE: inc/CryptX_Mac_PMAC.xs.inc
INCLUDE: inc/CryptX_Mac_XCBC.xs.inc
INCLUDE: inc/CryptX_Mac_Poly1305.xs.inc
INCLUDE: inc/CryptX_Mac_BLAKE2s.xs.inc
INCLUDE: inc/CryptX_Mac_BLAKE2b.xs.inc
INCLUDE: inc/CryptX_Mac_KMAC.xs.inc
INCLUDE: inc/CryptX_Mode_CBC.xs.inc
INCLUDE: inc/CryptX_Mode_ECB.xs.inc
INCLUDE: inc/CryptX_Mode_CFB.xs.inc
INCLUDE: inc/CryptX_Mode_OFB.xs.inc
INCLUDE: inc/CryptX_Mode_CTR.xs.inc
#INCLUDE: inc/CryptX_Mode_F8.xs.inc
#INCLUDE: inc/CryptX_Mode_LRW.xs.inc
#INCLUDE: inc/CryptX_Mode_XTS.xs.inc
INCLUDE: inc/CryptX_PRNG.xs.inc
INCLUDE: inc/CryptX_PK_RSA.xs.inc
INCLUDE: inc/CryptX_PK_DSA.xs.inc
INCLUDE: inc/CryptX_PK_DH.xs.inc
INCLUDE: inc/CryptX_PK_ECC.xs.inc
INCLUDE: inc/CryptX_PK_Ed25519.xs.inc
INCLUDE: inc/CryptX_PK_X25519.xs.inc
INCLUDE: inc/CryptX_PK_Ed448.xs.inc
INCLUDE: inc/CryptX_PK_X448.xs.inc
INCLUDE: inc/CryptX_KeyDerivation.xs.inc
INCLUDE: inc/CryptX_BigInt_LTM.xs.inc
( run in 0.810 second using v1.01-cache-2.11-cpan-e1769b4cff6 )