moving more code to XS

14 files changed, 930 insertions, 26 deletions

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;
         }
     }