File Coverage

CryptX.xs

Criterion	Covered	Total	%
statement	616	733	84.0
branch	460	778	59.1
condition			n/a
subroutine			n/a
pod			n/a
total	1076	1511	71.2

#define PERL_NO_GET_CONTEXT     /* we want efficiency */
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#define NEED_sv_2pvbyte_GLOBAL
#define NEED_sv_2pv_flags_GLOBAL
#define NEED_newRV_noinc_GLOBAL
#include "ppport.h"

/* assert_not_ROK is broken in 5.8.1 */
#if PERL_VERSION == 8 && PERL_SUBVERSION == 1
# undef assert_not_ROK
# if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
#  define assert_not_ROK(sv)  ({assert(!SvROK(sv) || !SvRV(sv));}),
# else
#  define assert_not_ROK(sv)
# endif
#endif

/* HACK: https://github.com/DCIT/perl-CryptX/issues/105 (replacement for SvPOK(sv) suggestet by Leont) */
#define SvPOK_spec(sv) (SvOK(sv) && (!SvROK(sv) || SvAMAGIC(sv)))

#undef LTC_SOURCE
#include "tomcrypt.h"
#include "tommath.h"

STATIC int cryptx_internal_input_has_no_payload(const char *in, STRLEN len) {
  STRLEN i;
  int saw_formatting = 0;

  if (in == NULL || len == 0) return 0;

  for (i = 0; i < len; i++) {
    if (in[i] == '=') {
      saw_formatting = 1;
      continue;
    }
    if (in[i] == ' ' || in[i] == '\t' || in[i] == '\n' || in[i] == '\r') {
      saw_formatting = 1;
      continue;
    }
    return 0;
  }
  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 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;

    if (!oidmap || !oid_sv || !SvOK(oid_sv)) return NULL;

    oid = SvPV(oid_sv, len);
    name_sv = hv_fetch(oidmap, oid, (I32)len, 0);
    if (!name_sv || !SvOK(*name_sv)) return NULL;

    return newSVsv(*name_sv);
}

/* Encode binary data according to bin_fmt */
static SV * s_asn1_bin_sv(pTHX_ const void *data, unsigned long size, int bin_fmt)
{
    if (!data || size == 0) return newSVpvn("", 0);
    if (bin_fmt == 1) { /* hex */
        SV *s;
        unsigned long outlen = size * 2 + 1;
        char *buf; Newz(0, buf, outlen, char);
        { unsigned long ol = outlen; base16_encode((const unsigned char*)data, size, buf, &ol, 0); }
        s = newSVpvn(buf, size * 2); Safefree(buf);
        return s;
    } else if (bin_fmt == 2) { /* base64 */
        SV *s;
        unsigned long outlen = ((size + 2) / 3) * 4 + 4;
        char *buf; Newz(0, buf, outlen, char);
        base64_encode((const unsigned char*)data, size, buf, &outlen);
        s = newSVpvn(buf, outlen); Safefree(buf);
        return s;
    }
    return newSVpvn((const char *)data, size); /* raw */
}

/* Convert Gregorian date+time to Unix epoch (portable, no timegm needed) */
static IV s_asn1_to_epoch(unsigned YYYY, unsigned MM, unsigned DD,
                           unsigned hh, unsigned mm, unsigned ss,
                           unsigned off_dir, unsigned off_hh, unsigned off_mm)
{
    long y = YYYY, m = MM, d = DD;
    long days;
    IV epoch, offset;
    if (m <= 2) { y--; m += 12; }
    days = 365*y + y/4 - y/100 + y/400 + (153*m - 457)/5 + d - 719469;
    epoch = (IV)days * 86400 + (IV)hh * 3600 + (IV)mm * 60 + (IV)ss;
    offset = (IV)(off_hh * 3600 + off_mm * 60);
    /* off_dir: 0 = '+' (local ahead of UTC, subtract to get UTC)
     *          1 = '-' (local behind UTC, add to get UTC) */
    epoch += (off_dir ? offset : -offset);
    return epoch;
}

static SV * s_ltc_asn1_to_perl(pTHX_ ltc_asn1_list *node, asn1_opts_t opts)
{
    AV *av = newAV();
    while (node != NULL && node->type != LTC_ASN1_EOL) {
        HV   *hv         = newHV();
        SV   *value_sv   = NULL;
        const char *type_str   = "UNKNOWN";
        const char *format_str = "unknown";
        switch (node->type) {
            case LTC_ASN1_BOOLEAN:
                type_str = "BOOLEAN"; format_str = "bool";
                if (node->data) value_sv = newSViv(*(int *)node->data ? 1 : 0);
                break;
            case LTC_ASN1_INTEGER: {
                mp_int *mpi = (mp_int *)node->data;
                type_str = "INTEGER";
                if (mpi) {
                    if (opts.int_fmt == 2) { /* bytes */
                        if (mp_isneg(mpi)) {
                            SvREFCNT_dec(hv);
                            croak("FATAL: asn1_decode_der: negative INTEGER cannot be represented with int=>'bytes'");
                        }
                        format_str = "bytes";
                        if (mp_iszero(mpi)) {
                            value_sv = newSVpvn("\0", 1);
                        } else {
                            unsigned long usize = mp_ubin_size(mpi);
                            unsigned char *ubuf; Newz(0, ubuf, usize, unsigned char);
                            { mp_err me = mp_to_ubin(mpi, ubuf, usize, NULL); PERL_UNUSED_VAR(me); }
                            value_sv = newSVpvn((char *)ubuf, usize); Safefree(ubuf);
                        }
                    } else {
                        int radix = (opts.int_fmt == 1) ? 16 : 10;
                        int len;
                        char *buf;
                        format_str = (opts.int_fmt == 1) ? "hex" : "decimal";
                        len = mp_count_bits(mpi) / (opts.int_fmt == 1 ? 4 : 3) + 4;
                        Newz(0, buf, len, char);
                        { mp_err me = mp_to_radix(mpi, buf, len, NULL, radix); PERL_UNUSED_VAR(me); }
                        if (opts.int_fmt == 1) { /* lowercase hex */
                            char *p; for (p = buf; *p; p++) if (*p >= 'A' && *p <= 'F') *p += 32;
                        }
                        value_sv = newSVpv(buf, 0); Safefree(buf);
                    }
                }
                break;
            }
            case LTC_ASN1_SHORT_INTEGER: {
                type_str = "INTEGER";
                if (node->data) {
                    unsigned long v = *(unsigned long *)node->data;
                    if (opts.int_fmt == 1) { /* hex */
                        char buf[32];
                        format_str = "hex";
                        snprintf(buf, sizeof(buf), "%lx", v);
                        value_sv = newSVpv(buf, 0);
                    } else if (opts.int_fmt == 2) { /* bytes */
                        unsigned char b[8], be[8];
                        int n = 0, k;
                        unsigned long tmp = v;
                        format_str = "bytes";
                        while (tmp) { b[n++] = (unsigned char)(tmp & 0xff); tmp >>= 8; }
                        if (!n) { b[0] = 0; n = 1; }
                        for (k = 0; k < n; k++) be[k] = b[n - 1 - k];
                        value_sv = newSVpvn((char *)be, n);
                    } else {
                        format_str = "decimal";
                        value_sv = newSVuv((UV)v);
                    }
                }
                break;
            }
            case LTC_ASN1_BIT_STRING: {
                unsigned char *bits = (unsigned char *)node->data;
                unsigned long nbits = node->size, nbytes = (nbits + 7) / 8;
                type_str = "BIT_STRING";
                format_str = (opts.bin_fmt == 1) ? "hex" : (opts.bin_fmt == 2) ? "base64" : "bytes";
                if (bits && nbytes > 0) {
                    unsigned long i;
                    unsigned char *packed;
                    Newz(0, packed, nbytes, unsigned char);
                    for (i = 0; i < nbits; i++)
                        if (bits[i]) packed[i/8] |= (unsigned char)(0x80u >> (i%8));
                    value_sv = s_asn1_bin_sv(aTHX_ packed, nbytes, opts.bin_fmt);
                    Safefree(packed);
                }
                hv_stores(hv, "bits", newSVuv((UV)nbits));
                break;
            }
            case LTC_ASN1_RAW_BIT_STRING: {
                unsigned long nbits_raw = node->size;
                unsigned long nbytes_raw = (nbits_raw + 7) / 8;
                type_str = "BIT_STRING";
                format_str = (opts.bin_fmt == 1) ? "hex" : (opts.bin_fmt == 2) ? "base64" : "bytes";
                value_sv = s_asn1_bin_sv(aTHX_ node->data, nbytes_raw, opts.bin_fmt);
                hv_stores(hv, "bits", newSVuv((UV)nbits_raw));
                break;
            }
            case LTC_ASN1_OCTET_STRING:
                type_str = "OCTET_STRING";
                format_str = (opts.bin_fmt == 1) ? "hex" : (opts.bin_fmt == 2) ? "base64" : "bytes";
                value_sv = s_asn1_bin_sv(aTHX_ node->data, node->size, opts.bin_fmt);
                break;
            case LTC_ASN1_NULL:
                type_str = "NULL"; format_str = "null";
                break;
            case LTC_ASN1_OBJECT_IDENTIFIER: {
                unsigned long *oid = (unsigned long *)node->data;
                type_str = "OID"; format_str = "oid";
                if (oid && node->size > 0) {
                    unsigned long i; SV *s = newSVpvn("", 0);
                    for (i = 0; i < node->size; i++) {
                        if (i > 0) sv_catpv(s, "."); sv_catpvf(s, "%lu", oid[i]);
                    }
                    value_sv = s;
                    {
                        SV *name_sv = s_asn1_oid_name_sv(aTHX_ opts.oidmap, value_sv);
                        if (name_sv) hv_stores(hv, "name", name_sv);
                    }
                }
                break;
            }
            case LTC_ASN1_IA5_STRING:
                type_str = "IA5_STRING"; format_str = "string";
                if (node->data && node->size > 0) value_sv = newSVpvn((char *)node->data, node->size);
                break;
            case LTC_ASN1_PRINTABLE_STRING:
                type_str = "PRINTABLE_STRING"; format_str = "string";
                if (node->data && node->size > 0) value_sv = newSVpvn((char *)node->data, node->size);
                break;
            case LTC_ASN1_TELETEX_STRING:
                type_str = "TELETEX_STRING"; format_str = "string";
                if (node->data && node->size > 0) value_sv = newSVpvn((char *)node->data, node->size);
                break;
            case LTC_ASN1_UTF8_STRING: {
                wchar_t *wstr = (wchar_t *)node->data;
                type_str = "UTF8_STRING"; format_str = "utf8";
                if (wstr && node->size > 0) {
                    unsigned long i;
                    SV *s = newSVpvn("", 0); SvUTF8_on(s);
                    for (i = 0; i < node->size; i++) {
                        U8 ubuf[UTF8_MAXBYTES + 1];
                        U8 *end = uvchr_to_utf8(ubuf, (UV)wstr[i]);
                        sv_catpvn(s, (char *)ubuf, end - ubuf);
                    }
                    value_sv = s;
                }
                break;
            }
            case LTC_ASN1_UTCTIME: {
                ltc_utctime *t = (ltc_utctime *)node->data;
                type_str = "UTCTIME";
                if (t) {
                    unsigned YYYY = (t->YY >= 50) ? 1900 + t->YY : 2000 + t->YY;
                    if (opts.dt_fmt == 1) { /* epoch */
                        format_str = "epoch";
                        value_sv = newSViv(s_asn1_to_epoch(YYYY, t->MM, t->DD, t->hh, t->mm, t->ss,
                                                            t->off_dir, t->off_hh, t->off_mm));
                    } else { /* rfc3339 */
                        char buf[32];
                        format_str = "rfc3339";
                        if (t->off_dir == 0 && t->off_hh == 0 && t->off_mm == 0)
                            snprintf(buf, sizeof(buf), "%04u-%02u-%02uT%02u:%02u:%02uZ",
                                     YYYY, t->MM, t->DD, t->hh, t->mm, t->ss);
                        else
                            snprintf(buf, sizeof(buf), "%04u-%02u-%02uT%02u:%02u:%02u%c%02u:%02u",
                                     YYYY, t->MM, t->DD, t->hh, t->mm, t->ss,
                                     t->off_dir ? '-' : '+', t->off_hh, t->off_mm);
                        value_sv = newSVpv(buf, 0);
                    }
                }
                break;
            }
            case LTC_ASN1_GENERALIZEDTIME: {
                ltc_generalizedtime *t = (ltc_generalizedtime *)node->data;
                type_str = "GENERALIZEDTIME";
                if (t) {
                    if (opts.dt_fmt == 1) { /* epoch */
                        format_str = "epoch";
                        value_sv = newSViv(s_asn1_to_epoch(t->YYYY, t->MM, t->DD, t->hh, t->mm, t->ss,
                                                            t->off_dir, t->off_hh, t->off_mm));
                    } else { /* rfc3339 */
                        char buf[48];
                        int pos;
                        format_str = "rfc3339";
                        pos = snprintf(buf, sizeof(buf), "%04u-%02u-%02uT%02u:%02u:%02u",
                                       t->YYYY, t->MM, t->DD, t->hh, t->mm, t->ss);
                        if (t->fs > 0)
                            pos += snprintf(buf + pos, sizeof(buf) - pos, ".%u", t->fs);
                        if (t->off_dir == 0 && t->off_hh == 0 && t->off_mm == 0)
                            snprintf(buf + pos, sizeof(buf) - pos, "Z");
                        else
                            snprintf(buf + pos, sizeof(buf) - pos, "%c%02u:%02u",
                                     t->off_dir ? '-' : '+', t->off_hh, t->off_mm);
                        value_sv = newSVpv(buf, 0);
                    }
                }
                break;
            }
            case LTC_ASN1_SEQUENCE:
                type_str = "SEQUENCE"; format_str = "array";
                value_sv = node->child ? newRV_noinc(s_ltc_asn1_to_perl(aTHX_ node->child, opts)) : newRV_noinc((SV *)newAV());
                break;
            case LTC_ASN1_SET:
            case LTC_ASN1_SETOF:
                type_str = "SET"; format_str = "array";
                value_sv = node->child ? newRV_noinc(s_ltc_asn1_to_perl(aTHX_ node->child, opts)) : newRV_noinc((SV *)newAV());
                break;
            case LTC_ASN1_CUSTOM_TYPE: {
                unsigned int cls = (unsigned int)node->klass;
                type_str = "CUSTOM";
                hv_stores(hv, "class",       newSVpv((cls < 4) ? s_asn1_class_names[cls] : "UNKNOWN", 0));
                hv_stores(hv, "constructed", newSViv(node->pc == LTC_ASN1_PC_CONSTRUCTED ? 1 : 0));
                hv_stores(hv, "tag",         newSVuv((UV)node->tag));
                if (node->pc == LTC_ASN1_PC_CONSTRUCTED && node->child) {
                    format_str = "array";
                    value_sv = newRV_noinc(s_ltc_asn1_to_perl(aTHX_ node->child, opts));
                } else if (node->data && node->size > 0) {
                    format_str = (opts.bin_fmt == 1) ? "hex" : (opts.bin_fmt == 2) ? "base64" : "bytes";
                    value_sv = s_asn1_bin_sv(aTHX_ node->data, node->size, opts.bin_fmt);
                }
                break;
            }
            default:
                /* Unknown ltc_asn1_type — skip rather than emit unroundtrippable node */
                SvREFCNT_dec(hv);
                node = node->next;
                continue;
        }
        hv_stores(hv, "type",   newSVpv(type_str,   0));
        hv_stores(hv, "format", newSVpv(format_str, 0));
        hv_stores(hv, "value",  value_sv ? value_sv : newSV(0));
        av_push(av, newRV_noinc((SV *)hv));
        node = node->next;
    }
    return (SV *)av;
}
/* --- end Crypt::ASN1 decoder helper -------------------------------------- */

/* --- Crypt::ASN1 encoder helpers ----------------------------------------- */

/* Write DER length to buf, return bytes written (buf must be >= 5 bytes) */
static unsigned long s_asn1_put_der_length(pTHX_ unsigned char *buf, unsigned long len)
{
    if (len > 0xffffffffUL) {
        croak("FATAL: asn1_encode: DER length exceeds 0xffffffff bytes");
    }
    if (len < 128) {
        buf[0] = (unsigned char)len;
        return 1;
    } else if (len <= 0xffUL) {
        buf[0] = 0x81; buf[1] = (unsigned char)len;
        return 2;
    } else if (len <= 0xffffUL) {
        buf[0] = 0x82;
        buf[1] = (unsigned char)(len >> 8);
        buf[2] = (unsigned char)(len & 0xff);
        return 3;
    } else if (len <= 0xffffffUL) {
        buf[0] = 0x83;
        buf[1] = (unsigned char)(len >> 16);
        buf[2] = (unsigned char)((len >> 8) & 0xff);
        buf[3] = (unsigned char)(len & 0xff);
        return 4;
    }
    buf[0] = 0x84;
    buf[1] = (unsigned char)(len >> 24);
    buf[2] = (unsigned char)((len >> 16) & 0xff);
    buf[3] = (unsigned char)((len >> 8) & 0xff);
    buf[4] = (unsigned char)(len & 0xff);
    return 5;
}

/* Append single-byte tag + DER length + content to SV */
static void s_asn1_append_tlv(pTHX_ SV *out, unsigned char tag,
                               const void *content, unsigned long clen)
{
    unsigned char lbuf[5];
    unsigned long llen = s_asn1_put_der_length(aTHX_ lbuf, clen);
    sv_catpvn(out, (char *)&tag, 1);
    sv_catpvn(out, (char *)lbuf, llen);
    if (clen > 0 && content) sv_catpvn(out, (const char *)content, clen);
}

/* Append multi-byte tag (for CUSTOM) + DER length + content to SV */
static void s_asn1_append_custom_tlv(pTHX_ SV *out,
                                      unsigned int klass, unsigned int pc,
                                      unsigned long tag,
                                      const void *content, unsigned long clen)
{
    unsigned char tbuf[12], lbuf[5];
    unsigned long tlen, llen;
    unsigned char first = (unsigned char)(((klass & 0x3) << 6) | ((pc & 0x1) << 5));

    if (tag < 31) {
        tbuf[0] = first | (unsigned char)tag;
        tlen = 1;
    } else {
        unsigned char tmp[10];
        int n = 0, i;
        unsigned long t = tag;
        tbuf[0] = first | 0x1f;
        /* base-128 big-endian */
        do { tmp[n++] = (unsigned char)(t & 0x7f); t >>= 7; } while (t > 0);
        tlen = 1;
        for (i = n - 1; i >= 0; i--) tbuf[tlen++] = tmp[i] | (i > 0 ? 0x80 : 0x00);
    }
    llen = s_asn1_put_der_length(aTHX_ lbuf, clen);
    sv_catpvn(out, (char *)tbuf, tlen);
    sv_catpvn(out, (char *)lbuf, llen);
    if (clen > 0 && content) sv_catpvn(out, (const char *)content, clen);
}

/* Forward declarations */
static void s_asn1_encode_node(pTHX_ SV *out, HV *node);

static void s_asn1_encode_nodes(pTHX_ SV *out, AV *nodes)
{
    I32 i, len = av_top_index(nodes);
    for (i = 0; i <= len; i++) {
        SV **elem = av_fetch(nodes, i, 0);
        if (!elem || !SvROK(*elem) || SvTYPE(SvRV(*elem)) != SVt_PVHV) continue;
        s_asn1_encode_node(aTHX_ out, (HV *)SvRV(*elem));
    }
}

static void s_asn1_encode_node(pTHX_ SV *out, HV *node)
{
    SV **sv_type = hv_fetchs(node, "type", 0);
    SV **sv_value = hv_fetchs(node, "value", 0);
    const char *type;

    if (!sv_type || !SvOK(*sv_type)) croak("FATAL: asn1_encode: node missing 'type'");
    type = SvPV_nolen(*sv_type);

    if (strEQ(type, "BOOLEAN")) {
        int val = (sv_value && SvOK(*sv_value)) ? SvIV(*sv_value) : 0;
        unsigned char c = val ? 0xFF : 0x00;
        s_asn1_append_tlv(aTHX_ out, 0x01, &c, 1);
    }
    else if (strEQ(type, "NULL")) {
        s_asn1_append_tlv(aTHX_ out, 0x05, NULL, 0);
    }
    else if (strEQ(type, "INTEGER")) {
        STRLEN slen; const char *str;
        mp_int mpi; int rv;
        unsigned long outlen; unsigned char *buf;

        if (!sv_value || !SvOK(*sv_value)) croak("FATAL: asn1_encode: INTEGER missing value");
        str = SvPV(*sv_value, slen);

        if (mp_init(&mpi) != MP_OKAY) croak("FATAL: asn1_encode: mp_init failed");
        if (mp_read_radix(&mpi, str, 10) != MP_OKAY) { mp_clear(&mpi); croak("FATAL: asn1_encode: invalid INTEGER value '%s'", str); }

        rv = der_length_integer(&mpi, &outlen);
        if (rv != CRYPT_OK) { mp_clear(&mpi); croak("FATAL: asn1_encode: der_length_integer failed"); }

        Newx(buf, outlen, unsigned char);
        rv = der_encode_integer(&mpi, buf, &outlen);
        mp_clear(&mpi);
        if (rv != CRYPT_OK) { Safefree(buf); croak("FATAL: asn1_encode: der_encode_integer failed"); }

        sv_catpvn(out, (char *)buf, outlen);
        Safefree(buf);
    }
    else if (strEQ(type, "OID")) {
        STRLEN slen; const char *str; const char *p;
        unsigned long words[64], nwords = 0, outlen;
        unsigned char *buf; int rv;

        if (!sv_value || !SvOK(*sv_value)) croak("FATAL: asn1_encode: OID missing value");
        str = SvPV(*sv_value, slen);

        p = str;
        while (*p && nwords < 64) {
            words[nwords++] = strtoul(p, (char **)&p, 10);
            if (*p == '.') p++;
        }
        if (nwords < 2) croak("FATAL: asn1_encode: OID must have at least 2 arcs");

        rv = der_length_object_identifier(words, nwords, &outlen);
        if (rv != CRYPT_OK) croak("FATAL: asn1_encode: der_length_object_identifier failed");

        Newx(buf, outlen, unsigned char);
        rv = der_encode_object_identifier(words, nwords, buf, &outlen);
        if (rv != CRYPT_OK) { Safefree(buf); croak("FATAL: asn1_encode: der_encode_object_identifier failed"); }

        sv_catpvn(out, (char *)buf, outlen);
        Safefree(buf);
    }
    else if (strEQ(type, "OCTET_STRING")) {
        STRLEN vlen = 0;
        const char *data = (sv_value && SvOK(*sv_value)) ? SvPVbyte(*sv_value, vlen) : "";
        s_asn1_append_tlv(aTHX_ out, 0x04, data, (unsigned long)vlen);
    }
    else if (strEQ(type, "BIT_STRING")) {
        STRLEN vlen = 0;
        const char *data = (sv_value && SvOK(*sv_value)) ? SvPVbyte(*sv_value, vlen) : "";
        SV **sv_bits = hv_fetchs(node, "bits", 0);
        unsigned long nbits = (sv_bits && SvOK(*sv_bits)) ? (unsigned long)SvUV(*sv_bits) : (unsigned long)(vlen * 8);
        unsigned long nbytes = (nbits + 7) / 8;
        unsigned char unused = (nbytes > 0) ? (unsigned char)(8 * nbytes - nbits) : 0;
        unsigned long content_len = 1 + nbytes;
        unsigned char *content;

        Newxz(content, content_len, unsigned char);
        content[0] = unused;
        if (nbytes > 0 && vlen > 0) {
            Copy(data, content + 1, nbytes < (unsigned long)vlen ? nbytes : (unsigned long)vlen, unsigned char);
            if (unused > 0) content[nbytes] &= (unsigned char)(0xFF << unused);
        }
        s_asn1_append_tlv(aTHX_ out, 0x03, content, content_len);
        Safefree(content);
    }
    else if (strEQ(type, "UTF8_STRING")) {
        STRLEN vlen = 0;
        const char *data = (sv_value && SvOK(*sv_value)) ? SvPVutf8(*sv_value, vlen) : "";
        s_asn1_append_tlv(aTHX_ out, 0x0C, data, (unsigned long)vlen);
    }
    else if (strEQ(type, "IA5_STRING")) {
        STRLEN vlen = 0;
        const char *data = (sv_value && SvOK(*sv_value)) ? SvPVbyte(*sv_value, vlen) : "";
        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;

typedef struct dsa_struct {             /* used by Crypt::PK::DSA */
  prng_state pstate;
  int pindex;
  IV last_pid;
  dsa_key key;
} *Crypt__PK__DSA;

typedef struct dh_struct {              /* used by Crypt::PK::DH */
  prng_state pstate;
  int pindex;
  IV last_pid;
  dh_key key;
} *Crypt__PK__DH;

typedef struct ecc_struct {             /* used by Crypt::PK::ECC */
  prng_state pstate;
  int pindex;
  IV last_pid;
  ecc_key key;
} *Crypt__PK__ECC;

typedef struct ed25519_struct {         /* used by Crypt::PK::Ed25519 */
  prng_state pstate;
  int pindex;
  IV last_pid;
  curve25519_key key;
  int initialized;
} *Crypt__PK__Ed25519;

typedef struct x25519_struct {          /* used by Crypt::PK::X25519 */
  prng_state pstate;
  int pindex;
  IV last_pid;
  curve25519_key key;
  int initialized;
} *Crypt__PK__X25519;

typedef struct ed448_struct {           /* used by Crypt::PK::Ed448 */
  prng_state pstate;
  int pindex;
  IV last_pid;
  curve448_key key;
  int initialized;
} *Crypt__PK__Ed448;

typedef struct x448_struct {            /* used by Crypt::PK::X448 */
  prng_state pstate;
  int pindex;
  IV last_pid;
  curve448_key key;
  int initialized;
} *Crypt__PK__X448;

STATIC int cryptx_internal_password_cb_getpw(void **p, unsigned long *l, void *u) {
  dTHX; /* fetch context */
  SV *passwd = u;
  void *pwd = NULL;
  STRLEN pwd_len = 0;

  if (p == NULL) {
    *l = 0;
    return 1;
  }
  if (passwd == NULL || !SvOK(passwd)) {
    *p = NULL;
    *l = 0;
    return 1;
  }
  pwd = SvPVbyte(passwd, pwd_len);
  if (pwd == NULL || pwd_len == 0) {
    *p = NULL;
    *l = 0;
    return 1;
  }
  Newz(0, *p, pwd_len, unsigned char);
  if (*p == NULL) {
    *l = 0;
    return 1;
  }
  Copy(pwd, *p, pwd_len, unsigned char);
  *l = (unsigned long)pwd_len;

  return 0;
}

STATIC void cryptx_internal_pk_prng_reseed(prng_state *state, int pindex, IV *last_pid) {
  dTHX; /* fetch context */
  IV curpid = (IV)PerlProc_getpid();
  unsigned char entropy_buf[40];
  int rv;

  if (*last_pid == curpid) return;

  if (rng_get_bytes(entropy_buf, sizeof(entropy_buf), NULL) != sizeof(entropy_buf)) {
    croak("FATAL: rng_get_bytes failed");
  }
  rv = prng_descriptor[pindex].add_entropy(entropy_buf, sizeof(entropy_buf), state);
  if (rv != CRYPT_OK) croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));
  rv = prng_descriptor[pindex].ready(state);
  if (rv != CRYPT_OK) croak("FATAL: PRNG_ready failed: %s", error_to_string(rv));
  zeromem(entropy_buf, sizeof(entropy_buf));
  *last_pid = curpid;
}

STATIC void cryptx_internal_prng_done(struct prng_struct *prng) {
  if (prng != NULL && prng->desc != NULL && prng->desc->done != NULL) {
    (void)prng->desc->done(&prng->state);
  }
}

STATIC void cryptx_internal_prng_reseed(struct prng_struct *prng) {
  dTHX; /* fetch context */
  IV curpid = (IV)PerlProc_getpid();
  unsigned char entropy_buf[40];
  int rv;

  if (prng == NULL || prng->desc == NULL || prng->last_pid == curpid) return;

  if (rng_get_bytes(entropy_buf, sizeof(entropy_buf), NULL) != sizeof(entropy_buf)) {
    croak("FATAL: rng_get_bytes failed");
  }
  rv = prng->desc->add_entropy(entropy_buf, sizeof(entropy_buf), &prng->state);
  zeromem(entropy_buf, sizeof(entropy_buf));
  if (rv != CRYPT_OK) croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));
  rv = prng->desc->ready(&prng->state);
  if (rv != CRYPT_OK) croak("FATAL: PRNG_ready failed: %s", error_to_string(rv));
  prng->last_pid = curpid;
}

STATIC void cryptx_internal_password_cb_free(void *p) {
  dTHX; /* fetch context */
  Safefree(p);
  return;
}

STATIC int cryptx_internal_mp2hex_with_leading_zero(mp_int * a, char *str, int maxlen, int minlen) {
  int len, rv;

  if (mp_isneg(a) == MP_YES) {
    *str = '\0';
    return MP_VAL;
  }

  rv = mp_to_radix(a, str, maxlen, NULL, 16);
  if (rv != MP_OKAY) {
    *str = '\0';
    return rv;
  }

  len = (int)strlen(str);
  if (len > 0 && len % 2 && len < maxlen-2) {
    memmove(str+1, str, len+1); /* incl. NUL byte */
    *str = '0';                 /* add leading zero */
  }

  len = (int)strlen(str);
  if (len < minlen && minlen < maxlen-1) {
    memmove(str+(minlen-len), str, len+1); /* incl. NUL byte */
    memset(str, '0', minlen-len);          /* add leading zero */
  }

  return MP_OKAY;
}

STATIC size_t cryptx_internal_find_start(const char *name, char *ltcname, size_t ltclen)
{
   size_t i, start = 0;
   if (name == NULL || strlen(name) + 1 > ltclen) croak("FATAL: invalid name") ;
   /* normalize */
   for (i = 0; i < ltclen && name[i] > 0; i++) {
     if (name[i] >= 'A' && name[i] <= 'Z') {
       ltcname[i] = name[i] + 32; /* lowecase */
     }
     else if (name[i] == '_') {
       ltcname[i] = '-';
     }
     else {
       ltcname[i] = name[i];
     }
     if (name[i] == ':') start = i + 1;
   }
   return start;
}

STATIC int cryptx_internal_find_hash(const char *name)
{
   char ltcname[100] = { 0 };
   size_t start = cryptx_internal_find_start(name, ltcname, sizeof(ltcname) - 1);
   /* special cases */
   if (strcmp(ltcname + start, "ripemd128") == 0) return find_hash("rmd128");
   if (strcmp(ltcname + start, "ripemd160") == 0) return find_hash("rmd160");
   if (strcmp(ltcname + start, "ripemd256") == 0) return find_hash("rmd256");
   if (strcmp(ltcname + start, "ripemd320") == 0) return find_hash("rmd320");
   if (strcmp(ltcname + start, "tiger192")  == 0) return find_hash("tiger");
   if (strcmp(ltcname + start, "chaes")     == 0) return find_hash("chc_hash");
   if (strcmp(ltcname + start, "chc-hash")  == 0) return find_hash("chc_hash");
   return find_hash(ltcname + start);
}

STATIC int cryptx_internal_find_cipher(const char *name)
{
   char ltcname[100] = { 0 };
   size_t start = cryptx_internal_find_start(name, ltcname, sizeof(ltcname) - 1);
   /* special cases */
   if (strcmp(ltcname + start, "des-ede") == 0) return find_cipher("3des");
   if (strcmp(ltcname + start, "saferp")  == 0) return find_cipher("safer+");
   return find_cipher(ltcname + start);
}

STATIC int cryptx_internal_find_prng(const char *name)
{
  char ltcname[100] = { 0 };
  size_t start = cryptx_internal_find_start(name, ltcname, sizeof(ltcname) - 1);
  return find_prng(ltcname + start);
}

/* Math::BigInt::LTM related */
typedef mp_int * Math__BigInt__LTM;
STATIC SV * sv_from_mpi(mp_int *mpi) {
  dTHX; /* fetch context */
  SV *obj = newSV(0);
  sv_setref_pv(obj, "Math::BigInt::LTM", (void*)mpi);
  return obj;
}

STATIC void cryptx_internal_ecc_oid_lookup(ecc_key *key)
{
   int err;
   unsigned i, j;
   void *tmp;
   const ltc_ecc_curve *cu;

   key->dp.oidlen = 0;
   if ((err = ltc_mp.init(&tmp)) != CRYPT_OK) return;
   for (cu = ltc_ecc_curves; cu->prime != NULL; cu++) {
      if ((err = mp_read_radix(tmp, cu->prime, 16)) != CRYPT_OK) continue;
      if ((mp_cmp(tmp, key->dp.prime) != LTC_MP_EQ))             continue;
      if ((err = mp_read_radix(tmp, cu->order, 16)) != CRYPT_OK) continue;
      if ((mp_cmp(tmp, key->dp.order) != LTC_MP_EQ))             continue;
      if ((err = mp_read_radix(tmp, cu->A,     16)) != CRYPT_OK) continue;
      if ((mp_cmp(tmp, key->dp.A) != LTC_MP_EQ))                 continue;
      if ((err = mp_read_radix(tmp, cu->B,     16)) != CRYPT_OK) continue;
      if ((mp_cmp(tmp, key->dp.B) != LTC_MP_EQ))                 continue;
      if ((err = mp_read_radix(tmp, cu->Gx,    16)) != CRYPT_OK) continue;
      if ((mp_cmp(tmp, key->dp.base.x) != LTC_MP_EQ))            continue;
      if ((err = mp_read_radix(tmp, cu->Gy,    16)) != CRYPT_OK) continue;
      if ((mp_cmp(tmp, key->dp.base.y) != LTC_MP_EQ))            continue;
      if (key->dp.cofactor != cu->cofactor)                      continue;
      break; /* found */
   }
   ltc_mp.deinit(tmp);
   if (cu->prime && cu->OID) {
     for (i = 0; i < 16; i++) key->dp.oid[i] = 0;
     for (i = 0, j = 0; i < strlen(cu->OID); i++) {
       if (cu->OID[i] == '.') {
         if (++j >= 16) return;
       }
       else if(cu->OID[i] >= '0' && cu->OID[i] <= '9') {
         key->dp.oid[j] = key->dp.oid[j] * 10 + (cu->OID[i] - '0');
       }
       else {
         return;
       }
     }
     key->dp.oidlen = j + 1;
   }
}

STATIC int cryptx_internal_ecc_set_curve_from_SV(ecc_key *key, SV *curve)
{
  dTHX; /* fetch context */
  HV *hc, *h;
  SV *sv_crv, **pref;
  SV **sv_cofactor, **sv_prime, **sv_A, **sv_B, **sv_order, **sv_Gx, **sv_Gy, **sv_oid;
  char *ptr_crv;
  STRLEN len_crv;
  int err;

  if (!SvOK(curve)) croak("FATAL: undefined curve");

  if (SvPOK_spec(curve)) {
    /* string */
    ptr_crv = SvPV(curve, len_crv);
    if ((hc = get_hv("Crypt::PK::ECC::curve", 0)) == NULL) croak("FATAL: no curve register");
    pref = hv_fetch(hc, ptr_crv, (U32)len_crv, 0);
    if (pref && SvOK(*pref)) {
      sv_crv = *pref; /* found in %curve */
    }
    else {
      sv_crv = curve;
    }
  }
  else if (SvROK(curve) && SvTYPE(SvRV(curve)) == SVt_PVHV) {
    /* hashref */
    sv_crv = curve;
  }
  else {
    croak("FATAL: curve has to be a string or a hashref");
  }

  if (SvPOK_spec(sv_crv)) {
    /* string - curve name */
    const ltc_ecc_curve *cu;
    ptr_crv = SvPV(sv_crv, len_crv);
    if (ecc_find_curve(ptr_crv, &cu) != CRYPT_OK) croak("FATAL: ecparams: unknown curve '%s'", ptr_crv);
    return ecc_set_curve(cu, key);
  }
  else {
    /* hashref */
    ltc_ecc_curve cu = { 0 };

    if ((h = (HV*)(SvRV(sv_crv))) == NULL) croak("FATAL: ecparams: param is not valid hashref");

    if ((sv_prime    = hv_fetchs(h, "prime",    0)) == NULL) croak("FATAL: ecparams: missing param prime");
    if ((sv_A        = hv_fetchs(h, "A",        0)) == NULL) croak("FATAL: ecparams: missing param A");
    if ((sv_B        = hv_fetchs(h, "B",        0)) == NULL) croak("FATAL: ecparams: missing param B");
    if ((sv_order    = hv_fetchs(h, "order",    0)) == NULL) croak("FATAL: ecparams: missing param order");
    if ((sv_Gx       = hv_fetchs(h, "Gx",       0)) == NULL) croak("FATAL: ecparams: missing param Gx");
    if ((sv_Gy       = hv_fetchs(h, "Gy",       0)) == NULL) croak("FATAL: ecparams: missing param Gy");
    if ((sv_cofactor = hv_fetchs(h, "cofactor", 0)) == NULL) croak("FATAL: ecparams: missing param cofactor");

    if (!SvOK(*sv_prime   )) croak("FATAL: ecparams: undefined param prime");
    if (!SvOK(*sv_A       )) croak("FATAL: ecparams: undefined param A");
    if (!SvOK(*sv_B       )) croak("FATAL: ecparams: undefined param B");
    if (!SvOK(*sv_order   )) croak("FATAL: ecparams: undefined param order");
    if (!SvOK(*sv_Gx      )) croak("FATAL: ecparams: undefined param Gx");
    if (!SvOK(*sv_Gy      )) croak("FATAL: ecparams: undefined param Gy");
    if (!SvOK(*sv_cofactor)) croak("FATAL: ecparams: undefined param cofactor");

    sv_oid = hv_fetchs(h, "oid", 0); /* 'oid' is optional */
    cu.OID = (sv_oid && SvOK(*sv_oid)) ? SvPV_nolen(*sv_oid) : NULL;

    cu.prime    = SvPV_nolen(*sv_prime);
    cu.A        = SvPV_nolen(*sv_A);
    cu.B        = SvPV_nolen(*sv_B);
    cu.order    = SvPV_nolen(*sv_order);
    cu.Gx       = SvPV_nolen(*sv_Gx);
    cu.Gy       = SvPV_nolen(*sv_Gy);
    cu.cofactor = (unsigned long)SvUV(*sv_cofactor);

    if ((err = ecc_set_curve(&cu, key)) != CRYPT_OK) return err;
    if (key->dp.oidlen == 0) cryptx_internal_ecc_oid_lookup(key);
    return CRYPT_OK;
  }
}

MODULE = CryptX       PACKAGE = CryptX      PREFIX = CryptX_

PROTOTYPES: DISABLE

BOOT:
    if(register_all_ciphers() != CRYPT_OK)     { croak("FATAL: register_all_ciphers failed"); }
    if(register_all_hashes()  != CRYPT_OK)     { croak("FATAL: register_all_hashes failed"); }
    if(register_all_prngs()   != CRYPT_OK)     { croak("FATAL: register_all_prngs failed"); }
    if(crypt_mp_init("ltm")   != CRYPT_OK)     { croak("FATAL: crypt_mp_init failed"); }

SV *
CryptX__ltc_build_settings()
    CODE:
        RETVAL = newSVpv(crypt_build_settings, 0);
    OUTPUT:
        RETVAL

SV *
CryptX__ltc_mp_name()
    CODE:
        RETVAL = newSVpv(ltc_mp.name, 0);
    OUTPUT:
        RETVAL

int
CryptX__ltc_mp_bits_per_digit()
    CODE:
        RETVAL = ltc_mp.bits_per_digit;
    OUTPUT:
        RETVAL

MODULE = CryptX       PACKAGE = Crypt::Misc

PROTOTYPES: DISABLE

SV *
_radix_to_bin(SV *in, int radix)
    CODE:
    {
        STRLEN in_len, len;
        unsigned char *out_data;
        char *in_data;
        mp_int mpi;

        if (!SvPOK_spec(in) || radix < 2 || radix > 64) XSRETURN_UNDEF;
        in_data = SvPVbyte(in, in_len);
        if (in_len > 0 && memchr(in_data, '\0', in_len) != NULL) XSRETURN_UNDEF;
        if (mp_init(&mpi) != MP_OKAY) XSRETURN_UNDEF;
        if (in_len == 0) {
          RETVAL = newSVpvn("", 0);
        }
        else if (mp_read_radix(&mpi, in_data, radix) == MP_OKAY) {
          len = mp_ubin_size(&mpi);
          if (len == 0) {
            RETVAL = newSVpvn("", 0);
          }
          else {
            RETVAL = NEWSV(0, len); /* avoid zero! */
            SvPOK_only(RETVAL);
            SvCUR_set(RETVAL, len);
            out_data = (unsigned char *)SvPVX(RETVAL);
            if (mp_to_ubin(&mpi, out_data, len, NULL) != MP_OKAY) {
              SvREFCNT_dec(RETVAL);
              RETVAL = newSVpvn(NULL, 0); /* undef */
            }
          }
        }
        else {
          RETVAL = newSVpvn(NULL, 0); /* undef */
        }
        mp_clear(&mpi);
    }
    OUTPUT:
        RETVAL

SV *
_bin_to_radix(SV *in, int radix)
    CODE:
    {
        STRLEN len;
        unsigned char *in_data;
        char *out_data;
        mp_int mpi, tmp;
        mp_digit d;
        mp_err merr;
        int digits = 0;

        if (!SvPOK_spec(in) || radix < 2 || radix > 64) XSRETURN_UNDEF;
        in_data = (unsigned char *) SvPVbyte(in, len);
        if (mp_init_multi(&mpi, &tmp, NULL) != MP_OKAY) XSRETURN_UNDEF;
        if (len == 0) {
          RETVAL = newSVpvn("", 0);
        }
        else {
          if (mp_from_ubin(&mpi, in_data, (size_t)len) == MP_OKAY) {
            merr = mp_copy(&mpi, &tmp);
            while (merr == MP_OKAY && mp_iszero(&tmp) == MP_NO) {
              merr = mp_div_d(&tmp, (mp_digit)radix, &tmp, &d);
              digits++;
            }
            if (merr != MP_OKAY) {
              RETVAL = newSVpvn(NULL, 0); /* undef */
            }
            else if (digits == 0) {
              RETVAL = newSVpvn("", 0);
            }
            else {
              RETVAL = NEWSV(0, digits + 2); /* +2 for sign and NUL byte */
              SvPOK_only(RETVAL);
              out_data = SvPVX(RETVAL);
              if (mp_to_radix(&mpi, out_data, digits + 2, NULL, radix) == MP_OKAY) {
                SvCUR_set(RETVAL, strlen(out_data));
              }
              else {
                SvREFCNT_dec(RETVAL);
                RETVAL = newSVpvn(NULL, 0); /* undef */
              }
            }
          }
          else {
            RETVAL = newSVpvn(NULL, 0); /* undef */
          }
        }
        mp_clear_multi(&tmp, &mpi, NULL);
    }
    OUTPUT:
        RETVAL

SV *
encode_b64(SV * in)
    ALIAS:
        encode_b64u = 1
    CODE:
    {
        int rv;
        STRLEN in_len;
        unsigned long out_len;
        unsigned char *in_data;
        char *out_data;

        if (!SvPOK_spec(in)) XSRETURN_UNDEF;
        in_data = (unsigned char *) SvPVbyte(in, in_len);
        if (in_len == 0) {
          RETVAL = newSVpvn("", 0);
        }
        else {
          out_len = (unsigned long)(4 * ((in_len + 2) / 3) + 1);
          RETVAL = NEWSV(0, out_len); /* avoid zero! */
          SvPOK_only(RETVAL);
          out_data = SvPVX(RETVAL);
          if (ix == 1)
            rv = base64url_encode(in_data, (unsigned long)in_len, out_data, &out_len);
          else
            rv = base64_encode(in_data, (unsigned long)in_len, out_data, &out_len);
          if (rv != CRYPT_OK) {
            SvREFCNT_dec(RETVAL);
            XSRETURN_UNDEF;
          }
          SvCUR_set(RETVAL, out_len);
        }
    }
    OUTPUT:
        RETVAL

SV *
decode_b64(SV * in)
    ALIAS:
        decode_b64u = 1
    CODE:
    {
        int rv;
        STRLEN in_len;
        unsigned long out_len;
        unsigned char *out_data;
        char *in_data;

        if (!SvPOK_spec(in)) XSRETURN_UNDEF;
        in_data = SvPVbyte(in, in_len);
        if (in_len == 0) {
          RETVAL = newSVpvn("", 0);
        }
        else {
          if (cryptx_internal_input_has_no_payload(in_data, in_len)) XSRETURN_UNDEF;
          out_len = (unsigned long)in_len;
          RETVAL = NEWSV(0, out_len); /* avoid zero! */
          SvPOK_only(RETVAL);
          out_data = (unsigned char *)SvPVX(RETVAL);
          if (ix == 1)
            rv = base64url_sane_decode(in_data, (unsigned long)in_len, out_data, &out_len);
          else
            rv = base64_sane_decode(in_data, (unsigned long)in_len, out_data, &out_len);
          if (rv != CRYPT_OK) {
            SvREFCNT_dec(RETVAL);
            XSRETURN_UNDEF;
          }
          SvCUR_set(RETVAL, out_len);
        }
    }
    OUTPUT:
        RETVAL

SV *
encode_b32r(SV *in)
    ALIAS:
        encode_b32b = 1
        encode_b32z = 2
        encode_b32c = 3
    CODE:
    {
        STRLEN in_len;
        unsigned long out_len;
        unsigned char *in_data;
        char *out_data;
        int id = -1, err;

        if (!SvPOK_spec(in)) XSRETURN_UNDEF;
        if (ix == 0) id = BASE32_RFC4648;
        if (ix == 1) id = BASE32_BASE32HEX;
        if (ix == 2) id = BASE32_ZBASE32;
        if (ix == 3) id = BASE32_CROCKFORD;
        if (id == -1) XSRETURN_UNDEF;
        in_data = (unsigned char *) SvPVbyte(in, in_len);
        if (in_len == 0) {
          RETVAL = newSVpvn("", 0);
        }
        else {
          out_len = (unsigned long)((8 * in_len + 4) / 5 + 1);
          RETVAL = NEWSV(0, out_len); /* avoid zero! */
          SvPOK_only(RETVAL);
          out_data = SvPVX(RETVAL);
          err = base32_encode(in_data, (unsigned long)in_len, out_data, &out_len, id);
          if (err != CRYPT_OK) {
            SvREFCNT_dec(RETVAL);
            XSRETURN_UNDEF;
          }
          SvCUR_set(RETVAL, out_len);
        }
    }
    OUTPUT:
        RETVAL

SV *
decode_b32r(SV *in)
    ALIAS:
        decode_b32b = 1
        decode_b32z = 2
        decode_b32c = 3
    CODE:
    {
        STRLEN in_len;
        unsigned long out_len;
        unsigned char *out_data;
        char *in_data;
        int id = -1, err;

        if (!SvPOK_spec(in)) XSRETURN_UNDEF;
        if (ix == 0) id = BASE32_RFC4648;
        if (ix == 1) id = BASE32_BASE32HEX;
        if (ix == 2) id = BASE32_ZBASE32;
        if (ix == 3) id = BASE32_CROCKFORD;
        if (id == -1) XSRETURN_UNDEF;
        in_data = SvPVbyte(in, in_len);
        if (in_len == 0) {
          RETVAL = newSVpvn("", 0);
        }
        else {
          if (cryptx_internal_input_has_no_payload(in_data, in_len)) XSRETURN_UNDEF;
          out_len = (unsigned long)in_len;
          RETVAL = NEWSV(0, out_len); /* avoid zero! */
          SvPOK_only(RETVAL);
          out_data = (unsigned char *)SvPVX(RETVAL);
          err = base32_decode(in_data, (unsigned long)in_len, out_data, &out_len, id);
          if (err != CRYPT_OK) {
            SvREFCNT_dec(RETVAL);
            XSRETURN_UNDEF;
          }
          SvCUR_set(RETVAL, out_len);
        }
    }
    OUTPUT:
        RETVAL

SV *
increment_octets_le(SV * in)
    CODE:
    {
        STRLEN len, i = 0;
        unsigned char *out_data, *in_data;

        if (!SvPOK_spec(in)) XSRETURN_UNDEF;
        in_data = (unsigned char *)SvPVbyte(in, len);
        if (len == 0) {
          RETVAL = newSVpvn("", 0);
        }
        else {
          RETVAL = NEWSV(0, len); /* avoid zero! */
          SvPOK_only(RETVAL);
          SvCUR_set(RETVAL, len);
          out_data = (unsigned char *)SvPVX(RETVAL);
          Copy(in_data, out_data, len, unsigned char);
          while (i < len) {
            out_data[i]++;
            if (0 != out_data[i]) break;
            i++;
          }
          if (i == len) {
            SvREFCNT_dec(RETVAL);
            croak("FATAL: increment_octets_le overflow");
          }
        }
    }
    OUTPUT:
        RETVAL

SV *
increment_octets_be(SV * in)
    CODE:
    {
        STRLEN len, i = 0;
        unsigned char *out_data, *in_data;

        if (!SvPOK_spec(in)) XSRETURN_UNDEF;
        in_data = (unsigned char *)SvPVbyte(in, len);
        if (len == 0) {
          RETVAL = newSVpvn("", 0);
        }
        else {
          RETVAL = NEWSV(0, len); /* avoid zero! */
          SvPOK_only(RETVAL);
          SvCUR_set(RETVAL, len);
          out_data = (unsigned char *)SvPVX(RETVAL);
          Copy(in_data, out_data, len, unsigned char);
          while (i < len) {
            out_data[len - 1 - i]++;
            if (0 != out_data[len - 1 - i]) break;
            i++;
          }
          if (i == len) {
            SvREFCNT_dec(RETVAL);
            croak("FATAL: increment_octets_be overflow");
          }
        }
    }
    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_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_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