From b3740fd72528dba16f4837860be6240dd489a2a6 Mon Sep 17 00:00:00 2001 From: Karel Miko Date: Fri, 26 Jan 2018 01:06:55 +0100 Subject: moving more code to XS --- inc/CryptX_Mac_BLAKE2b.xs.inc | 87 ++++++++++++++++++++++++- inc/CryptX_Mac_BLAKE2s.xs.inc | 87 ++++++++++++++++++++++++- inc/CryptX_Mac_F9.xs.inc | 89 +++++++++++++++++++++++++ inc/CryptX_Mac_HMAC.xs.inc | 89 +++++++++++++++++++++++++ inc/CryptX_Mac_OMAC.xs.inc | 89 +++++++++++++++++++++++++ inc/CryptX_Mac_PMAC.xs.inc | 89 +++++++++++++++++++++++++ inc/CryptX_Mac_Pelican.xs.inc | 85 ++++++++++++++++++++++++ inc/CryptX_Mac_Poly1305.xs.inc | 81 +++++++++++++++++++++++ inc/CryptX_Mac_XCBC.xs.inc | 89 +++++++++++++++++++++++++ inc/CryptX_PK_DH.xs.inc | 2 +- inc/CryptX_PK_DSA.xs.inc | 10 +-- inc/CryptX_PK_ECC.xs.inc | 2 +- inc/CryptX_PK_RSA.xs.inc | 14 ++-- inc/CryptX_PRNG.xs.inc | 143 ++++++++++++++++++++++++++++++++++++++--- 14 files changed, 930 insertions(+), 26 deletions(-) (limited to 'inc') diff --git a/inc/CryptX_Mac_BLAKE2b.xs.inc b/inc/CryptX_Mac_BLAKE2b.xs.inc index 4a748238..a9cb4b7c 100644 --- a/inc/CryptX_Mac_BLAKE2b.xs.inc +++ b/inc/CryptX_Mac_BLAKE2b.xs.inc @@ -3,7 +3,7 @@ MODULE = CryptX PACKAGE = Crypt::Mac::BLAKE2b ### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY! Crypt::Mac::BLAKE2b -new(char * class, int size, SV * key) +new(char * class, unsigned long size, SV * key) CODE: { STRLEN k_len=0; @@ -131,3 +131,88 @@ hexmac(Crypt::Mac::BLAKE2b self) } OUTPUT: RETVAL + +SV * +blake2b(unsigned long size, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac); + if (size < len) len = size; + rv = blake2bmac_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: blake2b_memory failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) mac, len); + } + OUTPUT: + RETVAL + +SV * +blake2b_hex(unsigned long size, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + if (size < len) len = size; + rv = blake2bmac_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: blake2b_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = _base16_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL + +SV * +blake2b_b64(unsigned long size, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + if (size < len) len = size; + rv = blake2bmac_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: blake2b_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + + } + OUTPUT: + RETVAL + +SV * +blake2b_b64u(unsigned long size, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + if (size < len) len = size; + rv = blake2bmac_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: blake2b_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64url_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL diff --git a/inc/CryptX_Mac_BLAKE2s.xs.inc b/inc/CryptX_Mac_BLAKE2s.xs.inc index c1595e3c..26e67270 100644 --- a/inc/CryptX_Mac_BLAKE2s.xs.inc +++ b/inc/CryptX_Mac_BLAKE2s.xs.inc @@ -3,7 +3,7 @@ MODULE = CryptX PACKAGE = Crypt::Mac::BLAKE2s ### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY! Crypt::Mac::BLAKE2s -new(char * class, int size, SV * key) +new(char * class, unsigned long size, SV * key) CODE: { STRLEN k_len=0; @@ -131,3 +131,88 @@ hexmac(Crypt::Mac::BLAKE2s self) } OUTPUT: RETVAL + +SV * +blake2s(unsigned long size, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac); + if (size < len) len = size; + rv = blake2smac_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: blake2s_memory failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) mac, len); + } + OUTPUT: + RETVAL + +SV * +blake2s_hex(unsigned long size, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + if (size < len) len = size; + rv = blake2smac_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: blake2s_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = _base16_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL + +SV * +blake2s_b64(unsigned long size, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + if (size < len) len = size; + rv = blake2smac_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: blake2s_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + + } + OUTPUT: + RETVAL + +SV * +blake2s_b64u(unsigned long size, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + if (size < len) len = size; + rv = blake2smac_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: blake2s_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64url_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL diff --git a/inc/CryptX_Mac_F9.xs.inc b/inc/CryptX_Mac_F9.xs.inc index d7f51dc0..a956d817 100644 --- a/inc/CryptX_Mac_F9.xs.inc +++ b/inc/CryptX_Mac_F9.xs.inc @@ -135,3 +135,92 @@ hexmac(Crypt::Mac::F9 self) } OUTPUT: RETVAL + +SV * +f9(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac); + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = f9_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: f9_memory failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) mac, len); + } + OUTPUT: + RETVAL + +SV * +f9_hex(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = f9_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: f9_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = _base16_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL + +SV * +f9_b64(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = f9_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: f9_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + + } + OUTPUT: + RETVAL + +SV * +f9_b64u(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = f9_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: f9_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64url_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL diff --git a/inc/CryptX_Mac_HMAC.xs.inc b/inc/CryptX_Mac_HMAC.xs.inc index ba808c76..f6732b38 100644 --- a/inc/CryptX_Mac_HMAC.xs.inc +++ b/inc/CryptX_Mac_HMAC.xs.inc @@ -135,3 +135,92 @@ hexmac(Crypt::Mac::HMAC self) } OUTPUT: RETVAL + +SV * +hmac(char * hash_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac); + int id = _find_hash(hash_name); + if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name); + rv = hmac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: hmac_memory failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) mac, len); + } + OUTPUT: + RETVAL + +SV * +hmac_hex(char * hash_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_hash(hash_name); + if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name); + rv = hmac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: hmac_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = _base16_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL + +SV * +hmac_b64(char * hash_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_hash(hash_name); + if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name); + rv = hmac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: hmac_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + + } + OUTPUT: + RETVAL + +SV * +hmac_b64u(char * hash_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_hash(hash_name); + if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name); + rv = hmac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: hmac_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64url_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL diff --git a/inc/CryptX_Mac_OMAC.xs.inc b/inc/CryptX_Mac_OMAC.xs.inc index 96f3d614..798c647d 100644 --- a/inc/CryptX_Mac_OMAC.xs.inc +++ b/inc/CryptX_Mac_OMAC.xs.inc @@ -135,3 +135,92 @@ hexmac(Crypt::Mac::OMAC self) } OUTPUT: RETVAL + +SV * +omac(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac); + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = omac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: omac_memory failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) mac, len); + } + OUTPUT: + RETVAL + +SV * +omac_hex(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = omac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: omac_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = _base16_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL + +SV * +omac_b64(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = omac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: omac_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + + } + OUTPUT: + RETVAL + +SV * +omac_b64u(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = omac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: omac_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64url_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL diff --git a/inc/CryptX_Mac_PMAC.xs.inc b/inc/CryptX_Mac_PMAC.xs.inc index 4fbe3f0e..6ad5849d 100644 --- a/inc/CryptX_Mac_PMAC.xs.inc +++ b/inc/CryptX_Mac_PMAC.xs.inc @@ -135,3 +135,92 @@ hexmac(Crypt::Mac::PMAC self) } OUTPUT: RETVAL + +SV * +pmac(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac); + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = pmac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: pmac_memory failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) mac, len); + } + OUTPUT: + RETVAL + +SV * +pmac_hex(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = pmac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: pmac_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = _base16_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL + +SV * +pmac_b64(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = pmac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: pmac_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + + } + OUTPUT: + RETVAL + +SV * +pmac_b64u(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = pmac_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: pmac_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64url_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL diff --git a/inc/CryptX_Mac_Pelican.xs.inc b/inc/CryptX_Mac_Pelican.xs.inc index dc171dbc..4d7f6e2b 100644 --- a/inc/CryptX_Mac_Pelican.xs.inc +++ b/inc/CryptX_Mac_Pelican.xs.inc @@ -131,3 +131,88 @@ hexmac(Crypt::Mac::Pelican self) } OUTPUT: RETVAL + +SV * +pelican(SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac); + len = 16; + rv = pelican_memory(k, klen, in, inlen, mac); + if (rv != CRYPT_OK) croak("FATAL: pelican_memory failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) mac, len); + } + OUTPUT: + RETVAL + +SV * +pelican_hex(SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + len = 16; + rv = pelican_memory(k, klen, in, inlen, mac); + if (rv != CRYPT_OK) croak("FATAL: pelican_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = _base16_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL + +SV * +pelican_b64(SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + len = 16; + rv = pelican_memory(k, klen, in, inlen, mac); + if (rv != CRYPT_OK) croak("FATAL: pelican_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + + } + OUTPUT: + RETVAL + +SV * +pelican_b64u(SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + len = 16; + rv = pelican_memory(k, klen, in, inlen, mac); + if (rv != CRYPT_OK) croak("FATAL: pelican_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64url_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL diff --git a/inc/CryptX_Mac_Poly1305.xs.inc b/inc/CryptX_Mac_Poly1305.xs.inc index 947288a7..00f3aa2f 100644 --- a/inc/CryptX_Mac_Poly1305.xs.inc +++ b/inc/CryptX_Mac_Poly1305.xs.inc @@ -131,3 +131,84 @@ hexmac(Crypt::Mac::Poly1305 self) } OUTPUT: RETVAL + +SV * +poly1305(SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac); + rv = poly1305_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: poly1305_memory failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) mac, len); + } + OUTPUT: + RETVAL + +SV * +poly1305_hex(SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + rv = poly1305_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: poly1305_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = _base16_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL + +SV * +poly1305_b64(SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + rv = poly1305_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: poly1305_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + + } + OUTPUT: + RETVAL + +SV * +poly1305_b64u(SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + rv = poly1305_memory(k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: poly1305_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64url_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL diff --git a/inc/CryptX_Mac_XCBC.xs.inc b/inc/CryptX_Mac_XCBC.xs.inc index 48647f7f..2d269187 100644 --- a/inc/CryptX_Mac_XCBC.xs.inc +++ b/inc/CryptX_Mac_XCBC.xs.inc @@ -135,3 +135,92 @@ hexmac(Crypt::Mac::XCBC self) } OUTPUT: RETVAL + +SV * +xcbc(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac); + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = xcbc_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: xcbc_memory failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) mac, len); + } + OUTPUT: + RETVAL + +SV * +xcbc_hex(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = xcbc_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: xcbc_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = _base16_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL + +SV * +xcbc_b64(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = xcbc_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: xcbc_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + + } + OUTPUT: + RETVAL + +SV * +xcbc_b64u(char * cipher_name, SV * key, SV * data) + CODE: + { + STRLEN inlen, klen; + unsigned char *in = (unsigned char *)SvPVbyte(data, inlen); + unsigned char *k = (unsigned char *)SvPVbyte(key, klen); + int rv; + unsigned char mac[MAXBLOCKSIZE]; + unsigned long len = sizeof(mac), outlen; + char out[MAXBLOCKSIZE*2]; + int id = _find_cipher(cipher_name); + if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name); + rv = xcbc_memory(id, k, klen, in, inlen, mac, &len); + if (rv != CRYPT_OK) croak("FATAL: xcbc_memory failed: %s", error_to_string(rv)); + outlen = sizeof(out); + rv = base64url_encode(mac, len, (unsigned char *)out, &outlen); + if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv)); + RETVAL = newSVpvn((char *) out, outlen); + } + OUTPUT: + RETVAL diff --git a/inc/CryptX_PK_DH.xs.inc b/inc/CryptX_PK_DH.xs.inc index 0898e805..0bad80a1 100644 --- a/inc/CryptX_PK_DH.xs.inc +++ b/inc/CryptX_PK_DH.xs.inc @@ -1,7 +1,7 @@ MODULE = CryptX PACKAGE = Crypt::PK::DH Crypt::PK::DH -_new() +_new(char * class) CODE: { int rv; diff --git a/inc/CryptX_PK_DSA.xs.inc b/inc/CryptX_PK_DSA.xs.inc index 8e70df9f..e2e716d2 100644 --- a/inc/CryptX_PK_DSA.xs.inc +++ b/inc/CryptX_PK_DSA.xs.inc @@ -1,7 +1,7 @@ MODULE = CryptX PACKAGE = Crypt::PK::DSA Crypt::PK::DSA -_new() +_new(char * class) CODE: { int rv; @@ -261,7 +261,7 @@ export_key_der(Crypt::PK::DSA self, char * type) RETVAL SV * -_encrypt(Crypt::PK::DSA self, SV * data, char * hash_name) +encrypt(Crypt::PK::DSA self, SV * data, char * hash_name="SHA1") CODE: { int rv, hash_id; @@ -284,7 +284,7 @@ _encrypt(Crypt::PK::DSA self, SV * data, char * hash_name) RETVAL SV * -_decrypt(Crypt::PK::DSA self, SV * data) +decrypt(Crypt::PK::DSA self, SV * data) CODE: { int rv; @@ -303,7 +303,7 @@ _decrypt(Crypt::PK::DSA self, SV * data) RETVAL SV * -_sign(Crypt::PK::DSA self, SV * data) +sign_hash(Crypt::PK::DSA self, SV * data) CODE: { int rv; @@ -324,7 +324,7 @@ _sign(Crypt::PK::DSA self, SV * data) RETVAL int -_verify(Crypt::PK::DSA self, SV * sig, SV * data) +verify_hash(Crypt::PK::DSA self, SV * sig, SV * data) CODE: { int rv, stat; diff --git a/inc/CryptX_PK_ECC.xs.inc b/inc/CryptX_PK_ECC.xs.inc index 9ac6eb5d..d17649c5 100644 --- a/inc/CryptX_PK_ECC.xs.inc +++ b/inc/CryptX_PK_ECC.xs.inc @@ -1,7 +1,7 @@ MODULE = CryptX PACKAGE = Crypt::PK::ECC Crypt::PK::ECC -_new() +_new(char * class) CODE: { int rv; diff --git a/inc/CryptX_PK_RSA.xs.inc b/inc/CryptX_PK_RSA.xs.inc index 1e4e38e2..21225d85 100644 --- a/inc/CryptX_PK_RSA.xs.inc +++ b/inc/CryptX_PK_RSA.xs.inc @@ -1,7 +1,7 @@ MODULE = CryptX PACKAGE = Crypt::PK::RSA Crypt::PK::RSA -_new() +_new(char * class) CODE: { int rv; @@ -293,7 +293,7 @@ export_key_der(Crypt::PK::RSA self, char * type) RETVAL SV * -_encrypt(Crypt::PK::RSA self, SV * data, char * padding, char * oaep_hash, SV * oaep_lparam) +encrypt(Crypt::PK::RSA self, SV * data, char * padding="oaep", char * oaep_hash="SHA1", SV * oaep_lparam=NULL) CODE: { int rv, hash_id; @@ -310,7 +310,7 @@ _encrypt(Crypt::PK::RSA self, SV * data, char * padding, char * oaep_hash, SV * if (strnEQ(padding, "oaep", 4)) { hash_id = _find_hash(oaep_hash); if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", oaep_hash); - lparam_ptr = (unsigned char *)SvPVbyte(oaep_lparam, lparam_len); + if (oaep_lparam) lparam_ptr = (unsigned char *)SvPVbyte(oaep_lparam, lparam_len); rv = rsa_encrypt_key_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, lparam_ptr, (unsigned long)lparam_len, &self->pstate, self->pindex, hash_id, LTC_PKCS_1_OAEP, &self->key); @@ -338,7 +338,7 @@ _encrypt(Crypt::PK::RSA self, SV * data, char * padding, char * oaep_hash, SV * RETVAL SV * -_decrypt(Crypt::PK::RSA self, SV * data, char * padding, char * oaep_hash, SV * oaep_lparam) +decrypt(Crypt::PK::RSA self, SV * data, char * padding="oaep", char * oaep_hash="SHA1", SV * oaep_lparam=NULL) CODE: { int rv, hash_id, stat; @@ -355,7 +355,7 @@ _decrypt(Crypt::PK::RSA self, SV * data, char * padding, char * oaep_hash, SV * if (strnEQ(padding, "oaep", 4)) { hash_id = _find_hash(oaep_hash); if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", oaep_hash); - lparam_ptr = (unsigned char *)SvPVbyte(oaep_lparam, lparam_len); + if (oaep_lparam) lparam_ptr = (unsigned char *)SvPVbyte(oaep_lparam, lparam_len); rv = rsa_decrypt_key_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, lparam_ptr, (unsigned long)lparam_len, hash_id, LTC_PKCS_1_OAEP, &stat, &self->key); if (rv != CRYPT_OK) croak("FATAL: rsa_decrypt_key_ex failed: %s", error_to_string(rv)); @@ -383,7 +383,7 @@ _decrypt(Crypt::PK::RSA self, SV * data, char * padding, char * oaep_hash, SV * RETVAL SV * -_sign(Crypt::PK::RSA self, SV * data, char * padding, char * hash_name=NULL, unsigned long saltlen=12) +sign_hash(Crypt::PK::RSA self, SV * data, char * hash_name="SHA1", char * padding="pss", unsigned long saltlen=12) CODE: { int rv, hash_id; @@ -427,7 +427,7 @@ _sign(Crypt::PK::RSA self, SV * data, char * padding, char * hash_name=NULL, uns RETVAL int -_verify(Crypt::PK::RSA self, SV * sig, SV * data, char * padding, char * hash_name=NULL, unsigned long saltlen=12) +verify_hash(Crypt::PK::RSA self, SV * sig, SV * data, char * hash_name="SHA1", char * padding="pss", unsigned long saltlen=12) CODE: { int rv, hash_id, stat; diff --git a/inc/CryptX_PRNG.xs.inc b/inc/CryptX_PRNG.xs.inc index 192f1f6e..f15264b8 100644 --- a/inc/CryptX_PRNG.xs.inc +++ b/inc/CryptX_PRNG.xs.inc @@ -1,18 +1,30 @@ MODULE = CryptX PACKAGE = Crypt::PRNG Crypt::PRNG -_new(IV curpid, char * prng_name, SV * entropy=&PL_sv_undef) +new(char * class, ...) CODE: { - int rv, id; + IV curpid = (IV)PerlProc_getpid(); + int rv, id, idx; unsigned char *ent=NULL; STRLEN ent_len=0; unsigned char entropy_buf[40]; + char *default_name = "ChaCha20"; + char *prng_name = default_name; + SV *entropy = &PL_sv_undef; + + /* we need to handle: + Crypt::PRNG->new('RC4'); + Crypt::Cipher::RC4->new(); + */ + idx = strcmp("Crypt::PRNG", class) == 0 ? 1 : 0; + if (idx + 1 <= items) prng_name = SvPVX(ST(idx)); + if (idx + 2 <= items) entropy = ST(idx + 1); Newz(0, RETVAL, 1, struct prng_struct); if (!RETVAL) croak("FATAL: Newz failed"); - id = find_prng(prng_name); + id = _find_prng(prng_name); if (id == -1) { Safefree(RETVAL); croak("FATAL: find_prng failed for '%s'", prng_name); @@ -58,9 +70,7 @@ _new(IV curpid, char * prng_name, SV * entropy=&PL_sv_undef) void DESTROY(Crypt::PRNG self) CODE: - { Safefree(self); - } void add_entropy(Crypt::PRNG self, SV * entropy=&PL_sv_undef) @@ -85,9 +95,10 @@ add_entropy(Crypt::PRNG self, SV * entropy=&PL_sv_undef) } SV * -_bytes(Crypt::PRNG self, IV curpid, STRLEN output_len) +bytes(Crypt::PRNG self, STRLEN output_len) CODE: { + IV curpid = (IV)PerlProc_getpid(); int rv_len; unsigned char *rdata; unsigned char entropy_buf[40]; @@ -112,10 +123,121 @@ _bytes(Crypt::PRNG self, IV curpid, STRLEN output_len) OUTPUT: RETVAL +SV * +bytes_hex(Crypt::PRNG self, STRLEN output_len) + CODE: + { + IV curpid = (IV)PerlProc_getpid(); + int rv_len, rv; + unsigned long len; + unsigned char *rdata, *tmp; + unsigned char entropy_buf[40]; + + if (self->last_pid != curpid) { + if (rng_get_bytes(entropy_buf, 40, NULL) != 40) croak("FATAL: rng_get_bytes failed"); + self->desc->add_entropy(entropy_buf, 40, &self->state); + self->desc->ready(&self->state); + self->last_pid = curpid; + } + + Newz(0, tmp, output_len, unsigned char); + if (tmp == NULL) croak("FATAL: Newz failed"); + rv_len = (self->desc->read)(tmp, (unsigned long)output_len, &self->state); + if ((UV)rv_len != output_len) croak("FATAL: PRNG_read failed"); + RETVAL = NEWSV(0, output_len * 2); + SvPOK_only(RETVAL); + SvCUR_set(RETVAL, output_len * 2); + rdata = (unsigned char *)SvPVX(RETVAL); + len = output_len * 2; + rv = _base16_encode(tmp, output_len, rdata, &len); + Safefree(tmp); + if (rv != CRYPT_OK) { + SvREFCNT_dec(RETVAL); + croak("FATAL: base16_encode failed"); + } + } + OUTPUT: + RETVAL + +SV * +bytes_b64(Crypt::PRNG self, STRLEN output_len) + CODE: + { + IV curpid = (IV)PerlProc_getpid(); + int rv_len, rv; + unsigned long len; + unsigned char *rdata, *tmp; + unsigned char entropy_buf[40]; + + if (self->last_pid != curpid) { + if (rng_get_bytes(entropy_buf, 40, NULL) != 40) croak("FATAL: rng_get_bytes failed"); + self->desc->add_entropy(entropy_buf, 40, &self->state); + self->desc->ready(&self->state); + self->last_pid = curpid; + } + + Newz(0, tmp, output_len, unsigned char); + if (tmp == NULL) croak("FATAL: Newz failed"); + rv_len = (self->desc->read)(tmp, (unsigned long)output_len, &self->state); + if ((UV)rv_len != output_len) croak("FATAL: PRNG_read failed"); + RETVAL = NEWSV(0, output_len * 2); + SvPOK_only(RETVAL); + SvCUR_set(RETVAL, output_len * 2); + rdata = (unsigned char *)SvPVX(RETVAL); + len = output_len * 2; + rv = base64_encode(tmp, output_len, rdata, &len); + SvCUR_set(RETVAL, len); + Safefree(tmp); + if (rv != CRYPT_OK) { + SvREFCNT_dec(RETVAL); + croak("FATAL: base64_encode failed"); + } + } + OUTPUT: + RETVAL + +SV * +bytes_b64u(Crypt::PRNG self, STRLEN output_len) + CODE: + { + IV curpid = (IV)PerlProc_getpid(); + int rv_len, rv; + unsigned long len; + unsigned char *rdata, *tmp; + unsigned char entropy_buf[40]; + + if (self->last_pid != curpid) { + if (rng_get_bytes(entropy_buf, 40, NULL) != 40) croak("FATAL: rng_get_bytes failed"); + self->desc->add_entropy(entropy_buf, 40, &self->state); + self->desc->ready(&self->state); + self->last_pid = curpid; + } + + Newz(0, tmp, output_len, unsigned char); + if (tmp == NULL) croak("FATAL: Newz failed"); + rv_len = (self->desc->read)(tmp, (unsigned long)output_len, &self->state); + if ((UV)rv_len != output_len) croak("FATAL: PRNG_read failed"); + RETVAL = NEWSV(0, output_len * 2); + SvPOK_only(RETVAL); + SvCUR_set(RETVAL, output_len * 2); + rdata = (unsigned char *)SvPVX(RETVAL); + len = output_len * 2; + rv = base64url_encode(tmp, output_len, rdata, &len); + SvCUR_set(RETVAL, len); + Safefree(tmp); + if (rv != CRYPT_OK) { + SvREFCNT_dec(RETVAL); + croak("FATAL: base64url_encode failed"); + } + } + OUTPUT: + RETVAL + UV -_int32(Crypt::PRNG self, IV curpid) +int32(Crypt::PRNG self) CODE: { + IV curpid = (IV)PerlProc_getpid(); int i; unsigned char rdata[4]; unsigned char entropy_buf[40]; @@ -135,9 +257,10 @@ _int32(Crypt::PRNG self, IV curpid) RETVAL NV -_double(Crypt::PRNG self, IV curpid, ...) +double(Crypt::PRNG self, ...) CODE: { + IV curpid = (IV)PerlProc_getpid(); int i; unsigned long a, b; /* 32bit is enough */ unsigned char rdata[7]; /* for double we need 53 bits */ @@ -156,8 +279,8 @@ _double(Crypt::PRNG self, IV curpid, ...) a = (((unsigned long)(rdata[0])<<16) + ((unsigned long)(rdata[1])<<8) + ((unsigned long)(rdata[2]))) & 0x1FFFFF; /* 21 bits */ b = ((unsigned long)(rdata[3])<<24) + ((unsigned long)(rdata[4])<<16) + ((unsigned long)(rdata[5])<<8) + ((unsigned long)(rdata[6])); /* 32 bits */ RETVAL = ( (NV)a * 4294967296.0 + (NV)b ) / 9007199254740992.0; /* (a * 2^32 + b) / 2^53 */ - if (items>2 && SvOK(ST(2))) { - limit = SvNV(ST(2)); + if (items > 1 && SvOK(ST(1))) { + limit = SvNV(ST(1)); if (limit > 0 || limit < 0) RETVAL = RETVAL * limit; } } -- cgit v1.2.3