File Coverage

blib/lib/Sodium/FFI.pm

Criterion	Covered	Total	%
statement	51	59	86.4
branch	5	20	25.0
condition	5	12	41.6
subroutine	15	16	93.7
pod	4	4	100.0
total	80	111	72.0

package Sodium::FFI;
use strict;
use warnings;

our $VERSION = '0.009';

use Carp qw(croak);
use Exporter qw(import);

use Alien::Sodium;
use FFI::Platypus;
use Path::Tiny qw(path);
use Sub::Util qw(set_subname);

# these are the methods we can easily attach
our @EXPORT_OK = qw(
    randombytes_random randombytes_uniform
    sodium_version_string sodium_library_version_minor sodium_base64_encoded_len
    crypto_aead_aes256gcm_keygen crypto_aead_chacha20poly1305_keygen
    crypto_aead_chacha20poly1305_ietf_keygen crypto_auth_keygen
);

# add the various C Constants
push @EXPORT_OK, qw(
    crypto_auth_BYTES crypto_auth_KEYBYTES
    SODIUM_VERSION_STRING SIZE_MAX randombytes_SEEDBYTES SODIUM_LIBRARY_MINIMAL
    SODIUM_LIBRARY_VERSION_MAJOR SODIUM_LIBRARY_VERSION_MINOR
    sodium_base64_VARIANT_ORIGINAL sodium_base64_VARIANT_ORIGINAL_NO_PADDING
    sodium_base64_VARIANT_URLSAFE sodium_base64_VARIANT_URLSAFE_NO_PADDING
    crypto_aead_aes256gcm_KEYBYTES crypto_aead_aes256gcm_NPUBBYTES crypto_aead_aes256gcm_ABYTES
    HAVE_AEAD_DETACHED HAVE_AESGCM
    crypto_aead_chacha20poly1305_KEYBYTES crypto_aead_chacha20poly1305_NPUBBYTES
    crypto_aead_chacha20poly1305_ABYTES
    crypto_aead_chacha20poly1305_IETF_KEYBYTES crypto_aead_chacha20poly1305_IETF_NPUBBYTES
    crypto_aead_chacha20poly1305_IETF_ABYTES
    crypto_sign_SEEDBYTES crypto_sign_BYTES crypto_sign_SECRETKEYBYTES crypto_sign_PUBLICKEYBYTES
    crypto_box_SEALBYTES crypto_box_PUBLICKEYBYTES crypto_box_SECRETKEYBYTES
    crypto_box_MACBYTES crypto_box_NONCEBYTES crypto_box_SEEDBYTES crypto_box_BEFORENMBYTES
);

our $ffi;
BEGIN {
    $ffi = FFI::Platypus->new(api => 1, lib => Alien::Sodium->dynamic_libs);
    $ffi->bundle();
}
# All of these functions don't need to be gated by version.
$ffi->attach('randombytes_random' => [] => 'uint32');
$ffi->attach('randombytes_uniform' => ['uint32'] => 'uint32');
$ffi->attach('sodium_version_string' => [] => 'string');
$ffi->attach('sodium_library_version_major' => [] => 'int');
$ffi->attach('sodium_library_version_minor' => [] => 'int');
$ffi->attach('sodium_base64_encoded_len' => ['size_t', 'int'] => 'size_t');

sub crypto_aead_aes256gcm_keygen {
    my $len = Sodium::FFI::crypto_aead_aes256gcm_KEYBYTES;
    return Sodium::FFI::randombytes_buf($len);
}

sub crypto_aead_chacha20poly1305_ietf_keygen {
    my $len = Sodium::FFI::crypto_aead_chacha20poly1305_IETF_KEYBYTES;
    return Sodium::FFI::randombytes_buf($len);
}

sub crypto_aead_chacha20poly1305_keygen {
    my $len = Sodium::FFI::crypto_aead_chacha20poly1305_KEYBYTES;
    return Sodium::FFI::randombytes_buf($len);
}

sub crypto_auth_keygen {
    my $len = Sodium::FFI::crypto_auth_KEYBYTES;
    return Sodium::FFI::randombytes_buf($len);
}

our %function = (
    # int
    # crypto_auth(unsigned char *out, const unsigned char *in,
    #     unsigned long long inlen, const unsigned char *k);
    'crypto_auth' => [
        ['string', 'string', 'size_t', 'string'] => 'int',
        sub {
            my ($xsub, $msg, $key) = @_;
            my $msg_len = length($msg);
            my $key_len = length($key);

            unless($key_len == Sodium::FFI::crypto_auth_KEYBYTES) {
                croak("Secret key length should be crypto_auth_KEYBYTES bytes");
            }

            my $mac = "\0" x Sodium::FFI::crypto_auth_BYTES;
            my $real_len = 0;
            my $ret = $xsub->($mac, $msg, $msg_len, $key);
            croak("Internal error") unless $ret == 0;
            return $mac;
        }
    ],

    # int
    # crypto_auth_verify(const unsigned char *h, const unsigned char *in,
    #     unsigned long long inlen, const unsigned char *k);
    'crypto_auth_verify' => [
        ['string', 'string', 'size_t', 'string'] => 'int',
        sub {
            my ($xsub, $mac, $msg, $key) = @_;
            my $mac_len = length($mac);
            my $msg_len = length($msg);
            my $key_len = length($key);
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;

            unless ($key_len == Sodium::FFI::crypto_auth_KEYBYTES) {
                croak("Secret key length should be crypto_auth_KEYBYTES bytes");
            }
            unless ($mac_len == Sodium::FFI::crypto_auth_BYTES) {
                croak("authentication tag length should be crypto_auth_BYTES bytes");
            }

            my $ret = $xsub->($mac, $msg, $msg_len, $key);
            return 1 if $ret == 0;
            return 0;
        }
    ],

    # int
    # crypto_aead_chacha20poly1305_ietf_decrypt(unsigned char *m,
    #     unsigned long long *mlen_p,
    #     unsigned char *nsec,
    #     const unsigned char *c,
    #     unsigned long long clen,
    #     const unsigned char *ad,
    #     unsigned long long adlen,
    #     const unsigned char *npub,
    #     const unsigned char *k);
    'crypto_aead_chacha20poly1305_ietf_decrypt' => [
        ['string', 'size_t*', 'string', 'string', 'size_t', 'string', 'size_t', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $ciphertext, $ad, $nonce, $key) = @_;
            my $ciphertext_len = length($ciphertext);
            my $ad_len = length($ad);
            my $nonce_len = length($nonce);
            my $key_len = length($key);
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;

            unless ($nonce_len == Sodium::FFI::crypto_aead_chacha20poly1305_IETF_NPUBBYTES) {
                croak("Nonce length should be crypto_aead_chacha20poly1305_IETF_NPUBBYTES bytes");
            }
            unless($key_len == Sodium::FFI::crypto_aead_chacha20poly1305_IETF_KEYBYTES) {
                croak("Secret key length should be crypto_aead_chacha20poly1305_IETF_KEYBYTES bytes");
            }
            if ($ciphertext_len < Sodium::FFI::crypto_aead_chacha20poly1305_IETF_ABYTES) {
                croak("cipher text length not right");
            }
            my $msg_len = $ciphertext_len;
            if ($msg_len > $SIZE_MAX) {
                croak("Message length greater than max size");
            }
            my $msg = "\0" x $msg_len;
            my $real_len = 0;
            my $ret = $xsub->($msg, \$real_len, undef, $ciphertext, $ciphertext_len, $ad, $ad_len, $nonce, $key);
            croak("Internal error") unless $ret == 0;
            if ($real_len <= 0 || $real_len >= $SIZE_MAX || $real_len > $msg_len) {
                croak("Invalid resultant length");
            }
            if ($real_len >= $SIZE_MAX || $real_len > $msg_len) {
                croak("arithmetic overflow");
            }
            return substr($msg, 0, $real_len);
        }
    ],

    # int
    # crypto_aead_chacha20poly1305_ietf_encrypt(unsigned char *c,
    #     unsigned long long *clen_p,
    #     const unsigned char *m,
    #     unsigned long long mlen,
    #     const unsigned char *ad,
    #     unsigned long long adlen,
    #     const unsigned char *nsec,
    #     const unsigned char *npub,
    #     const unsigned char *k);
    'crypto_aead_chacha20poly1305_ietf_encrypt' => [
        ['string', 'size_t*', 'string', 'size_t', 'string', 'size_t', 'string', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $msg, $ad, $nonce, $key) = @_;
            my $msg_len = length($msg);
            my $ad_len = length($ad);
            my $nonce_len = length($nonce);
            my $key_len = length($key);
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;

            unless ($nonce_len == Sodium::FFI::crypto_aead_chacha20poly1305_IETF_NPUBBYTES) {
                croak("Nonce length should be crypto_aead_chacha20poly1305_IETF_NPUBBYTES bytes");
            }
            unless($key_len == Sodium::FFI::crypto_aead_chacha20poly1305_IETF_KEYBYTES) {
                croak("Secret key length should be crypto_aead_chacha20poly1305_IETF_KEYBYTES bytes");
            }
            if ($SIZE_MAX - $msg_len <= Sodium::FFI::crypto_aead_chacha20poly1305_IETF_ABYTES) {
                croak("arithmetic overflow");
            }

            my $ciphertext_len = $msg_len + Sodium::FFI::crypto_aead_chacha20poly1305_IETF_ABYTES;
            my $ciphertext = "\0" x $ciphertext_len;
            my $real_len = 0;
            my $ret = $xsub->($ciphertext, \$real_len, $msg, $msg_len, $ad, $ad_len, undef, $nonce, $key);
            croak("Internal error") unless $ret == 0;
            if ($real_len <= 0 || $real_len > $SIZE_MAX || $real_len > $ciphertext_len) {
                croak("Invalid resultant length");
            }
            return substr($ciphertext, 0, $real_len);
        }
    ],

    # int
    # crypto_aead_chacha20poly1305_decrypt(unsigned char *m,
        # unsigned long long *mlen_p,
        # unsigned char *nsec,
        # const unsigned char *c,
        # unsigned long long clen,
        # const unsigned char *ad,
        # unsigned long long adlen,
        # const unsigned char *npub,
        # const unsigned char *k);
    'crypto_aead_chacha20poly1305_decrypt' => [
        ['string', 'size_t*', 'string', 'string', 'size_t', 'string', 'size_t', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $ciphertext, $ad, $nonce, $key) = @_;
            my $ciphertext_len = length($ciphertext);
            my $ad_len = length($ad);
            my $nonce_len = length($nonce);
            my $key_len = length($key);
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;

            unless ($nonce_len == Sodium::FFI::crypto_aead_chacha20poly1305_NPUBBYTES) {
                croak("Nonce length should be crypto_aead_chacha20poly1305_NPUBBYTES bytes");
            }
            unless($key_len == Sodium::FFI::crypto_aead_chacha20poly1305_KEYBYTES) {
                croak("Secret key length should be crypto_aead_chacha20poly1305_KEYBYTES bytes");
            }
            if ($ciphertext_len < Sodium::FFI::crypto_aead_chacha20poly1305_ABYTES) {
                croak("cipher text length not right");
            }
            my $msg_len = $ciphertext_len;
            if ($msg_len > $SIZE_MAX) {
                croak("Message length greater than max size");
            }
            my $msg = "\0" x $msg_len;
            my $real_len = 0;
            my $ret = $xsub->($msg, \$real_len, undef, $ciphertext, $ciphertext_len, $ad, $ad_len, $nonce, $key);
            croak("Internal error") unless $ret == 0;
            if ($real_len <= 0 || $real_len >= $SIZE_MAX || $real_len > $msg_len) {
                croak("Invalid resultant length");
            }
            if ($real_len >= $SIZE_MAX || $real_len > $msg_len) {
                croak("arithmetic overflow");
            }
            return substr($msg, 0, $real_len);
        }
    ],

    # int
    # crypto_aead_chacha20poly1305_encrypt(unsigned char *c,
    #     unsigned long long *clen_p,
    #     const unsigned char *m,
    #     unsigned long long mlen,
    #     const unsigned char *ad,
    #     unsigned long long adlen,
    #     const unsigned char *nsec,
    #     const unsigned char *npub,
    #     const unsigned char *k)
    'crypto_aead_chacha20poly1305_encrypt' => [
        ['string', 'size_t*', 'string', 'size_t', 'string', 'size_t', 'string', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $msg, $ad, $nonce, $key) = @_;
            my $msg_len = length($msg);
            my $ad_len = length($ad);
            my $nonce_len = length($nonce);
            my $key_len = length($key);
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;

            unless ($nonce_len == Sodium::FFI::crypto_aead_chacha20poly1305_NPUBBYTES) {
                croak("Nonce length should be crypto_aead_chacha20poly1305_NPUBBYTES bytes");
            }
            unless($key_len == Sodium::FFI::crypto_aead_chacha20poly1305_KEYBYTES) {
                croak("Secret key length should be crypto_aead_chacha20poly1305_KEYBYTES bytes");
            }
            if ($SIZE_MAX - $msg_len <= Sodium::FFI::crypto_aead_chacha20poly1305_ABYTES) {
                croak("arithmetic overflow");
            }

            my $ciphertext_len = $msg_len + Sodium::FFI::crypto_aead_chacha20poly1305_ABYTES;
            my $ciphertext = "\0" x $ciphertext_len;
            my $real_len = 0;
            my $ret = $xsub->($ciphertext, \$real_len, $msg, $msg_len, $ad, $ad_len, undef, $nonce, $key);
            croak("Internal error") unless $ret == 0;
            if ($real_len <= 0 || $real_len > $SIZE_MAX || $real_len > $ciphertext_len) {
                croak("Invalid resultant length");
            }
            return substr($ciphertext, 0, $real_len);
        }
    ],

    # int
    # crypto_aead_aes256gcm_encrypt(unsigned char *c,
        # unsigned long long *clen_p,
        # const unsigned char *m,
        # unsigned long long mlen,
        # const unsigned char *ad,
        # unsigned long long adlen,
        # const unsigned char *nsec,
        # const unsigned char *npub,
        # const unsigned char *k);
    'crypto_aead_aes256gcm_encrypt' => [
        ['string', 'size_t*', 'string', 'size_t', 'string', 'size_t', 'string', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $msg, $ad, $nonce, $key) = @_;
            croak("AESGCM not available.") unless Sodium::FFI::crypto_aead_aes256gcm_is_available();
            my $msg_len = length($msg);
            my $ad_len = length($ad);
            my $nonce_len = length($nonce);
            my $key_len = length($key);
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;

            unless ($nonce_len == Sodium::FFI::crypto_aead_aes256gcm_NPUBBYTES) {
                croak("Nonce length should be crypto_aead_aes256gcm_NPUBBYTES bytes");
            }
            unless($key_len == Sodium::FFI::crypto_aead_aes256gcm_KEYBYTES) {
                croak("Secret key length should be crypto_aead_aes256gcm_KEYBYTES bytes");
            }
            if ($SIZE_MAX - $msg_len <= Sodium::FFI::crypto_aead_aes256gcm_ABYTES) {
                croak("arithmetic overflow");
            }
            if ($msg_len > (16 * ((1 << 32) - 2)) - Sodium::FFI::crypto_aead_aes256gcm_ABYTES) {
                croak("message too long for a single key");
            }
            my $ciphertext_len = $msg_len + Sodium::FFI::crypto_aead_aes256gcm_ABYTES;
            my $ciphertext = "\0" x $ciphertext_len;
            my $real_len = 0;
            my $ret = $xsub->($ciphertext, \$real_len, $msg, $msg_len, $ad, $ad_len, undef, $nonce, $key);
            croak("Internal error") unless $ret == 0;
            if ($real_len <= 0 || $real_len > $SIZE_MAX || $real_len > $ciphertext_len) {
                croak("Invalid resultant length");
            }
            return substr($ciphertext, 0, $real_len);
        }
    ],

    # int
    # crypto_aead_aes256gcm_decrypt(unsigned char *m,
        # unsigned long long *mlen_p,
        # unsigned char *nsec,
        # const unsigned char *c,
        # unsigned long long clen,
        # const unsigned char *ad,
        # unsigned long long adlen,
        # const unsigned char *npub,
        # const unsigned char *k);
    'crypto_aead_aes256gcm_decrypt' => [
        ['string', 'size_t*', 'string', 'string', 'size_t', 'string', 'size_t', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $ciphertext, $ad, $nonce, $key) = @_;
            croak("AESGCM not available.") unless Sodium::FFI::crypto_aead_aes256gcm_is_available();
            my $ciphertext_len = length($ciphertext);
            my $ad_len = length($ad);
            my $nonce_len = length($nonce);
            my $key_len = length($key);
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;

            unless ($nonce_len == Sodium::FFI::crypto_aead_aes256gcm_NPUBBYTES) {
                croak("Nonce length should be crypto_aead_aes256gcm_NPUBBYTES bytes");
            }
            unless($key_len == Sodium::FFI::crypto_aead_aes256gcm_KEYBYTES) {
                croak("Secret key length should be crypto_aead_aes256gcm_KEYBYTES bytes");
            }
            if ($ciphertext_len < Sodium::FFI::crypto_aead_aes256gcm_ABYTES) {
                croak("cipher text length not right");
            }
            if ($ciphertext_len - Sodium::FFI::crypto_aead_aes256gcm_ABYTES > 16 * ((1 << 32) - 2)) {
                croak("cipher text too long for a single key");
            }
            my $msg_len = $ciphertext_len;
            if ($msg_len > $SIZE_MAX) {
                croak("Message length greater than max size");
            }
            my $msg = "\0" x $msg_len;
            my $real_len = 0;
            my $ret = $xsub->($msg, \$real_len, undef, $ciphertext, $ciphertext_len, $ad, $ad_len, $nonce, $key);
            croak("Internal error") unless $ret == 0;
            if ($real_len <= 0 || $real_len >= $SIZE_MAX || $real_len > $msg_len) {
                croak("Invalid resultant length");
            }
            return substr($msg, 0, $real_len);
        }
    ],

    # int
    # crypto_aead_aes256gcm_is_available()
    'crypto_aead_aes256gcm_is_available' => [
        [] => 'int',
        sub {
            my ($xsub) = @_;
            if (Sodium::FFI::HAVE_AESGCM) {
                return $xsub->();
            }
            return 0;
        }
    ],

    # int
    # crypto_box_easy(unsigned char *c, const unsigned char *m,
    #   unsigned long long mlen, const unsigned char *n,
    #   const unsigned char *pk, const unsigned char *sk);
    'crypto_box_easy' => [
        ['string', 'string', 'size_t', 'string', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $msg, $nonce, $pk, $sk) = @_;
            my $msg_len = length($msg);
            my $nonce_len = length($nonce);
            my $pk_len = length($pk);
            my $sk_len = length($sk);
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;
            if ($nonce_len != Sodium::FFI::crypto_box_NONCEBYTES) {
                croak("The nonce must be crypto_box_NONCEBYTES in length");
            }
            if ($pk_len != Sodium::FFI::crypto_box_PUBLICKEYBYTES) {
                croak("The public key must be crypto_box_PUBLICKEYBYTES in length");
            }
            if ($sk_len != Sodium::FFI::crypto_box_SECRETKEYBYTES) {
                croak("The secret key must be crypto_box_SECRETKEYBYTES in length");
            }
            if ($SIZE_MAX - $msg_len <= Sodium::FFI::crypto_box_MACBYTES) {
                croak("Arithmetic overflow");
            }
            my $cipher_len = Sodium::FFI::crypto_box_MACBYTES + $msg_len;
            my $cipher_text = "\0" x $cipher_len;
            my $ret = $xsub->($cipher_text, $msg, $msg_len, $nonce, $pk, $sk);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            return $cipher_text;
        }
    ],

    # int
    # crypto_box_keypair(unsigned char *pk, unsigned char *sk);
    'crypto_box_keypair' => [
        ['string', 'string'] => 'int',
        sub {
            my ($xsub) = @_;
            my $pubkey = "\0" x Sodium::FFI::crypto_box_PUBLICKEYBYTES ;
            my $seckey = "\0" x Sodium::FFI::crypto_box_SECRETKEYBYTES;
            my $ret = $xsub->($pubkey, $seckey);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            return ($pubkey, $seckey);
        }
    ],

    # int
    # crypto_box_open_easy(unsigned char *m, const unsigned char *c,
    #   unsigned long long clen, const unsigned char *n,
    #   const unsigned char *pk, const unsigned char *sk);
    'crypto_box_open_easy' => [
        ['string', 'string', 'size_t', 'string', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $cipher_text, $nonce, $pk, $sk) = @_;
            my $cipher_len = length($cipher_text);
            my $nonce_len = length($nonce);
            my $pk_len = length($pk);
            my $sk_len = length($sk);
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;
            if ($nonce_len != Sodium::FFI::crypto_box_NONCEBYTES) {
                croak("The nonce must be crypto_box_NONCEBYTES in length");
            }
            if ($pk_len != Sodium::FFI::crypto_box_PUBLICKEYBYTES) {
                croak("The public key must be crypto_box_PUBLICKEYBYTES in length");
            }
            if ($sk_len != Sodium::FFI::crypto_box_SECRETKEYBYTES) {
                croak("The secret key must be crypto_box_SECRETKEYBYTES in length");
            }
            if ($cipher_len <= Sodium::FFI::crypto_box_MACBYTES) {
                croak("The cipher text should be larger than crypto_box_MACBYTES bytes");
            }

            my $msg_len = $cipher_len - Sodium::FFI::crypto_box_MACBYTES;
            my $msg = "\0" x $msg_len;
            my $ret = $xsub->($msg, $cipher_text, $cipher_len, $nonce, $pk, $sk);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            return $msg;
        }
    ],

    # int
    # crypto_box_seal(unsigned char *c, const unsigned char *m,
    #               unsigned long long mlen, const unsigned char *pk)
    'crypto_box_seal' => [
        ['string', 'string', 'size_t', 'string'] => 'int',
        sub {
            my ($xsub, $message, $pk) = @_;

            if (length($pk) != Sodium::FFI::crypto_box_PUBLICKEYBYTES) {
                croak(
                    "The public key must be crypto_box_PUBLICKEYBYTES in length"
                );
            }

            my $message_len = length($message);

            my $cipher_len  = Sodium::FFI::crypto_box_SEALBYTES + $message_len;
            my $cipher_text = "\0" x $cipher_len;

            my $ret = $xsub->($cipher_text, $message, $message_len, $pk);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            return $cipher_text;
        }
    ],

    # crypto_box_seal_open(unsigned char *m, const unsigned char *c,
    #               unsigned long long clen,
    #               const unsigned char *pk, const unsigned char *sk)
    'crypto_box_seal_open' => [
        ['string', 'string', 'size_t', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $cipher_text, $pk, $sk) = @_;

            if (length($pk) != Sodium::FFI::crypto_box_PUBLICKEYBYTES) {
                croak(
                    "The public key must be crypto_box_PUBLICKEYBYTES in length"
                );
            }
            if (length($sk) != Sodium::FFI::crypto_box_SECRETKEYBYTES) {
                croak(
                    "The secret key must be crypto_box_SECRETKEYBYTES in length"
                );
            }

            if (length($cipher_text) < crypto_box_SEALBYTES) {
                return -1;
            }

            my $msg = "\0" x (length($cipher_text) - crypto_box_SEALBYTES);
            my $ret
                = $xsub->($msg, $cipher_text, length($cipher_text), $pk, $sk);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            return $msg;
        }
    ],

    # int
    # crypto_box_seed_keypair(unsigned char *pk, unsigned char *sk, const unsigned char *seed);
    'crypto_box_seed_keypair' => [
        ['string', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $seed) = @_;
            my $seed_len = length($seed);
            unless ($seed_len == Sodium::FFI::crypto_box_SEEDBYTES) {
                croak("Seed length must be crypto_box_SEEDBYTES in length");
            }
            my $pubkey = "\0" x Sodium::FFI::crypto_box_PUBLICKEYBYTES;
            my $seckey = "\0" x Sodium::FFI::crypto_box_SECRETKEYBYTES;
            my $ret = $xsub->($pubkey, $seckey, $seed);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            return ($pubkey, $seckey);
        }
    ],

    # int
    # crypto_scalarmult_base(unsigned char *q, const unsigned char *n);
    'crypto_scalarmult_base' => [
        ['string', 'string'] => 'int',
        sub {
            my ($xsub, $secret_key) = @_;
            my $sk_len = length($secret_key);
            unless ($sk_len == Sodium::FFI::crypto_box_SECRETKEYBYTES) {
                croak("Secret Key length must be crypto_box_SECRETKEYBYTES in length");
            }
            my $pubkey = "\0" x Sodium::FFI::crypto_box_PUBLICKEYBYTES;
            my $ret = $xsub->($pubkey, $secret_key);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            return $pubkey;
        }
    ],

    # int
    # crypto_sign_keypair(unsigned char *pk, unsigned char *sk);
    'crypto_sign_keypair' => [
        ['string', 'string'] => 'int',
        sub {
            my ($xsub) = @_;
            my $pubkey = "\0" x Sodium::FFI::crypto_sign_PUBLICKEYBYTES;
            my $seckey = "\0" x Sodium::FFI::crypto_sign_SECRETKEYBYTES;
            my $ret = $xsub->($pubkey, $seckey);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            return ($pubkey, $seckey);
        }
    ],

    # int
    # crypto_sign_seed_keypair(unsigned char *pk, unsigned char *sk, const unsigned char *seed);
    'crypto_sign_seed_keypair' => [
        ['string', 'string', 'string'] => 'int',
        sub {
            my ($xsub, $seed) = @_;
            my $seed_len = length($seed);
            unless ($seed_len == Sodium::FFI::crypto_sign_SEEDBYTES) {
                croak("Seed length must be crypto_sign_SEEDBYTES in length");
            }
            my $pubkey = "\0" x Sodium::FFI::crypto_sign_PUBLICKEYBYTES;
            my $seckey = "\0" x Sodium::FFI::crypto_sign_SECRETKEYBYTES;
            my $ret = $xsub->($pubkey, $seckey, $seed);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            return ($pubkey, $seckey);
        }
    ],

    # int
    # crypto_sign(unsigned char *sm, unsigned long long *smlen_p,
    #     const unsigned char *m, unsigned long long mlen,
    #     const unsigned char *sk);
    'crypto_sign' => [
        ['string', 'size_t*', 'string', 'size_t', 'string'] => 'int',
        sub {
            my ($xsub, $msg, $key) = @_;
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;
            my $msg_len = length($msg);
            my $key_len = length($key);
            unless ($key_len == Sodium::FFI::crypto_sign_SECRETKEYBYTES) {
                croak("Secret Key length must be crypto_sign_SECRETKEYBYTES in length");
            }
            if ($SIZE_MAX - $msg_len <= Sodium::FFI::crypto_sign_BYTES) {
                croak("Arithmetic overflow");
            }
            my $real_len = 0;
            my $signed_len = $msg_len + Sodium::FFI::crypto_sign_BYTES;
            my $signed = "\0" x $signed_len;
            my $ret = $xsub->($signed, \$real_len, $msg, $msg_len, $key);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            if ($real_len >= $SIZE_MAX || $real_len > $signed_len) {
                croak("Arithmetic overflow");
            }
            return substr($signed, 0, $real_len);
        }
    ],

    # int
    # crypto_sign_detached(unsigned char *sig, unsigned long long *siglen_p,
    #     const unsigned char *m, unsigned long long mlen,
    #     const unsigned char *sk);
    'crypto_sign_detached' => [
        ['string', 'size_t*', 'string', 'size_t', 'string'] => 'int',
        sub {
            my ($xsub, $msg, $key) = @_;
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;
            my $msg_len = length($msg);
            my $key_len = length($key);
            unless ($key_len == Sodium::FFI::crypto_sign_SECRETKEYBYTES) {
                croak("Secret Key length must be crypto_sign_SECRETKEYBYTES in length");
            }
            my $signature = "\0" x Sodium::FFI::crypto_sign_BYTES;
            my $real_len = 0;
            my $ret = $xsub->($signature, \$real_len, $msg, $msg_len, $key);
            if ($ret != 0) {
                croak("Signature creation failed.");
            }
            if ($real_len <= 0 || $real_len > Sodium::FFI::crypto_sign_BYTES) {
                croak("Signature size isn't correct.");
            }
            return substr($signature, 0, $real_len);
        }
    ],

    # int
    # crypto_sign_open(unsigned char *m, unsigned long long *mlen_p,
    #     const unsigned char *sm, unsigned long long smlen,
    #     const unsigned char *pk);
    'crypto_sign_open' => [
        ['string', 'size_t*', 'string', 'size_t', 'string'] => 'int',
        sub {
            my ($xsub, $msg, $key) = @_;
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;
            my $msg_len = length($msg);
            my $key_len = length($key);
            unless ($key_len == Sodium::FFI::crypto_sign_PUBLICKEYBYTES) {
                croak("Public Key length must be crypto_sign_PUBLICKEYBYTES in length");
            }
            if ($SIZE_MAX - $msg_len <= Sodium::FFI::crypto_sign_BYTES) {
                croak("Arithmetic overflow");
            }
            my $real_len = 0;
            my $open = "\0" x $msg_len;
            my $ret = $xsub->($open, \$real_len, $msg, $msg_len, $key);
            if ($ret != 0) {
                croak("Some internal error happened");
            }
            if ($real_len >= $SIZE_MAX || $real_len > $msg_len) {
                croak("Arithmetic overflow");
            }
            return substr($open, 0, $real_len);
        }
    ],

    # int
    # crypto_sign_verify_detached(const unsigned char *sig,
    #     const unsigned char *m,
    #     unsigned long long mlen,
    #     const unsigned char *pk);
    'crypto_sign_verify_detached' => [
        ['string', 'string', 'size_t', 'string'] => 'int',
        sub {
            my ($xsub, $sig, $msg, $key) = @_;
            my $SIZE_MAX = Sodium::FFI::SIZE_MAX;
            my $sig_len = length($sig);
            my $msg_len = length($msg);
            my $key_len = length($key);
            unless ($sig_len == Sodium::FFI::crypto_sign_BYTES) {
                croak("Signature length must be crypto_sign_BYTES in length");
            }
            unless ($key_len == Sodium::FFI::crypto_sign_PUBLICKEYBYTES) {
                croak("Public Key length must be crypto_sign_PUBLICKEYBYTES in length");
            }
            my $ret = $xsub->($sig, $msg, $msg_len, $key);
            return 1 if ($ret == 0);
            return 0;
        }
    ],

    # void
    # randombytes_buf(void * const buf, const size_t size)
    'randombytes_buf' => [
        ['string', 'size_t'] => 'void',
        sub {
            my ($xsub, $len) = @_;
            $len //= 0;
            return '' unless $len > 0;
            my $buffer = "\0" x ($len + 1);
            $xsub->($buffer, $len);
            return substr($buffer, 0, $len);
        }
    ],

    # void
    # sodium_add(unsigned char *a, const unsigned char *b, const size_t len)
    'sodium_add' => [
        ['string', 'string', 'size_t'] => 'void',
        sub {
            my ($xsub, $bin_string1, $bin_string2, $len) = @_;
            return unless $bin_string1 && $bin_string2;
            $len //= length($bin_string1);
            my $copy = substr($bin_string1, 0);
            $xsub->($copy, $bin_string2, $len);
            return $copy;
        }
    ],

    # int
    # sodium_base642bin(
    #   unsigned char * const bin, const size_t bin_maxlen,
    #   const char * const b64, const size_t b64_len,
    #   const char * const ignore, size_t * const bin_len,
    #   const char ** const b64_end, const int variant);
    'sodium_base642bin' => [
        ['string', 'size_t', 'string', 'size_t', 'string', 'size_t*', 'string*', 'int'] => 'int',
        sub {
            my ($xsub, $b64, $variant) = @_;
            my $b64_len = length($b64);
            $variant //= Sodium::FFI::sodium_base64_VARIANT_ORIGINAL;

            my $bin_max_len = $b64_len / 4 * 3 + 2;
            my $bin = "\0" x $bin_max_len;
            my $bin_real_len = 0;

            my $ignore = undef;
            my $end = undef;
            $xsub->($bin, $bin_max_len, $b64, $b64_len, $ignore, \$bin_real_len, \$end, $variant);
            # $bin =~ s/\0//g;
            return substr($bin, 0, $bin_real_len);
        }
    ],

    # char *
    # sodium_bin2base64(char * const b64, const size_t b64_maxlen,
    #   const unsigned char * const bin, const size_t bin_len,
    #   const int variant);
    'sodium_bin2base64' => [
        ['string', 'size_t', 'string', 'size_t', 'int'] => 'string',
        sub {
            my ($xsub, $bin, $variant) = @_;
            my $bin_len = length($bin);
            $variant //= Sodium::FFI::sodium_base64_VARIANT_ORIGINAL;

            my $b64_len = Sodium::FFI::sodium_base64_encoded_len($bin_len, $variant);
            my $b64 = "\0" x $b64_len;

            $xsub->($b64, $b64_len, $bin, $bin_len, $variant);
            $b64 =~ s/\0//g;
            return $b64;
        }
    ],

    # char *
    # sodium_bin2hex(char *const hex, const size_t hex_maxlen,
    #   const unsigned char *const bin, const size_t bin_len)
    'sodium_bin2hex' => [
        ['string', 'size_t', 'string', 'size_t'] => 'string',
        sub {
            my ($xsub, $bin_string) = @_;
            return unless $bin_string;
            my $bin_len = length($bin_string);
            my $hex_max = $bin_len * 2;

            my $buffer = "\0" x ($hex_max + 1);
            $xsub->($buffer, $hex_max + 1, $bin_string, $bin_len);
            return substr($buffer, 0, $hex_max);
        }
    ],

    # int
    # sodium_hex2bin(
    #    unsigned char *const bin, const size_t bin_maxlen,
    #    const char *const hex, const size_t hex_len,
    #    const char *const ignore, size_t *const bin_len, const char **const hex_end)
    'sodium_hex2bin' => [
        ['string', 'size_t', 'string', 'size_t', 'string', 'size_t *', 'string *'] => 'int',
        sub {
            my ($xsub, $hex_string, %params) = @_;
            $hex_string //= '';
            my $hex_len = length($hex_string);

            # these two are mostly always void/undef
            my $ignore = $params{ignore};
            my $hex_end = $params{hex_end};

            my $bin_max_len = $params{max_len} // 0;
            if ($bin_max_len <= 0) {
                $bin_max_len = $hex_len;
                $bin_max_len = int($hex_len / 2) unless $ignore;
            }
            my $buffer = "\0" x ($hex_len + 1);
            my $bin_len = 0;

            my $ret = $xsub->($buffer, $hex_len, $hex_string, $hex_len, $ignore, \$bin_len, \$hex_end);
            unless ($ret == 0) {
                croak("sodium_hex2bin failed with: $ret");
            }

            return substr($buffer, 0, $bin_max_len) if $bin_max_len < $bin_len;
            return substr($buffer, 0, $bin_len);
        }
    ],

    # void
    # sodium_increment(unsigned char *n, const size_t nlen)
    'sodium_increment' => [
        ['string', 'size_t'] => 'void',
        sub {
            my ($xsub, $bin_string, $len) = @_;
            return unless $bin_string;
            $len //= length($bin_string);
            my $copy = substr($bin_string, 0);
            $xsub->($copy, $len);
            return $copy;
        }
    ],

    # int
    # sodium_is_zero(const unsigned char *n, const size_t nlen)
    'sodium_is_zero' => [
        ['string', 'size_t'] => 'int',
        sub {
            my ($xsub, $bin_string, $len) = @_;
            $len //= length($bin_string);
            return $xsub->($bin_string, $len);
        }
    ],

    # int
    # sodium_memcmp(const void * const b1_, const void * const b2_, size_t len);
    'sodium_memcmp' => [
        ['string', 'string', 'size_t'] => 'int',
        sub {
            my ($xsub, $string_x, $string_y, $len) = @_;
            return unless $string_x;
            $len //= length($string_x);
            return $xsub->($string_x, $string_y, $len);
        }
    ],

);

our %maybe_function = (
    # void
    # randombytes_buf_deterministic(void * const buf, const size_t size,
    #   const unsigned char seed[randombytes_SEEDBYTES]);
    'randombytes_buf_deterministic' => {
        added => [1,0,12],
        ffi => [
            ['string', 'size_t', 'string'] => 'void',
            sub {
                my ($xsub, $len, $seed) = @_;
                $len //= 0;
                return '' unless $len > 0;
                my $buffer = "\0" x ($len + 1);
                $xsub->($buffer, $len, $seed);
                return substr($buffer, 0, $len);
            }
        ],
        fallback => sub { croak("randombytes_buf_deterministic not implemented until libsodium v1.0.12"); },
    },


    # int
    # sodium_compare(const unsigned char *b1_,
    #   const unsigned char *b2_, size_t len)
    'sodium_compare' => {
        added => [1,0,4],
        ffi => [
            ['string', 'string', 'size_t'] => 'int',
            sub {
                my ($xsub, $bin_string1, $bin_string2, $len) = @_;
                return unless $bin_string1 && $bin_string2;
                $len //= length($bin_string1);
                my $int = $xsub->($bin_string1, $bin_string2, $len);
                return $int;
            }
        ],
        fallback => sub { croak("sodium_compare not implemented until libsodium v1.0.4"); },
    },

    # int
    # sodium_library_minimal(void)
    'sodium_library_minimal' => {
        added => [1,0,12],
        ffi => [[], 'int'],
        fallback => sub { croak("sodium_library_minimal not implemented until libsodium v1.0.12"); },
    },

    # int
    # sodium_pad(size_t *padded_buflen_p, unsigned char *buf,
    # size_t unpadded_buflen, size_t blocksize, size_t max_buflen)
    'sodium_pad' => {
        added => [1,0,14],
        ffi => [
            ['size_t', 'string', 'size_t', 'size_t', 'size_t'] => 'int',
            sub {
                my ($xsub, $unpadded, $block_size) = @_;
                my $SIZE_MAX = Sodium::FFI::SIZE_MAX;
                my $unpadded_len = length($unpadded);
                $block_size //= 16;
                $block_size = 16 if $block_size < 0;

                my $xpadlen = $block_size - 1;
                if (($block_size & ($block_size - 1)) == 0) {
                    $xpadlen -= $unpadded_len & ($block_size - 1);
                } else {
                    $xpadlen -= $unpadded_len % $block_size;
                }
                if ($SIZE_MAX - $unpadded_len <= $xpadlen) {
                    croak("Input is too large.");
                }

                my $xpadded_len = $unpadded_len + $xpadlen;
                my $padded = "\0" x ($xpadded_len + 1);
                if ($unpadded_len > 0) {
                    my $st = 1;
                    my $i = 0;
                    my $k = $unpadded_len;
                    for my $j (0..$xpadded_len) {
                        substr($padded, $j, 1) = substr($unpadded, $i, 1);
                        $k -= $st;
                        $st = (~((((($k >> 48) | ($k >> 32) | ($k >> 16) | $k) & 0xffff) - 1) >> 16)) & 1;
                        $i += $st;
                    }
                }
                my $int = $xsub->(undef, $padded, $unpadded_len, $block_size, $xpadded_len + 1);
                return $padded;
            }
        ],
        fallback => sub { croak("sodium_pad not implemented until libsodium v1.0.14"); },
    },

    # void
    # sodium_sub(unsigned char *a, const unsigned char *b, const size_t len);
    'sodium_sub' => {
        added => [1,0,17],
        ffi => [
            ['string', 'string', 'size_t'] => 'void',
            sub {
                my ($xsub, $bin_string1, $bin_string2, $len) = @_;
                return unless $bin_string1 && $bin_string2;
                $len //= length($bin_string1);
                my $copy = substr($bin_string1, 0);
                $xsub->($copy, $bin_string2, $len);
                return $copy;
            }
        ],
        fallback => sub { croak("sodium_sub not implemented until libsodium v1.0.17"); },
    },

    # int
    # sodium_unpad(size_t *unpadded_buflen_p, const unsigned char *buf,
    # size_t padded_buflen, size_t blocksize)
    'sodium_unpad' => {
        added => [1,0,14],
        ffi => [
            ['size_t*', 'string', 'size_t', 'size_t'] => 'int',
            sub {
                my ($xsub, $padded, $block_size) = @_;
                $block_size //= 16;
                $block_size = 16 if $block_size < 0;

                my $SIZE_MAX = Sodium::FFI::SIZE_MAX;
                my $padded_len = length($padded);
                if ($padded_len < $block_size) {
                    croak("Invalid padding.");
                }
                my $unpadded_len = 0;
                my $int = $xsub->(\$unpadded_len, $padded, $padded_len, $block_size);
                return substr($padded, 0, $unpadded_len);
            }
        ],
        fallback => sub { croak("sodium_unpad not implemented until libsodium v1.0.14"); },
    },
);

foreach my $func (keys %function) {
    $ffi->attach($func, @{$function{$func}});
    push(@EXPORT_OK, $func) unless ref($func);
}

foreach my $func (keys %maybe_function) {
    my $href = $maybe_function{$func};
    if (_version_or_better(@{$href->{added}})) {
        $ffi->attach($func, @{$href->{ffi}});
    }
    else {
        # monkey patch in the subref
        no strict 'refs';
        no warnings 'redefine';
        my $pkg = __PACKAGE__;
        *{"${pkg}::$func"} = set_subname("${pkg}::$func", $href->{fallback});
    }
    push @EXPORT_OK, $func;
}

sub _version_or_better {
    my ($maj, $min, $pat) = @_;
    $maj //= 0;
    $min //= 0;
    $pat //= 0;
    foreach my $partial ($maj, $min, $pat) {
        if ($partial =~ /[^0-9]/) {
            croak("_version_or_better requires 1 - 3 integers representing major, minor and patch numbers");
        }
    }
    # if no number was passed in, then the current version is higher
    return 1 unless ($maj || $min || $pat);

    my $version_string = Sodium::FFI::sodium_version_string();
    croak("No version string") unless $version_string;
    my ($smaj, $smin, $spatch) = split(/\./, $version_string);
    return 0 if $smaj < $maj; # full version behind of requested
    return 1 if $smaj > $maj; # full version ahead of requested
    # now we should be matching major versions
    return 1 unless $min; # if we were only given major, move on
    return 0 if $smin < $min; # same major, lower minor
    return 1 if $smaj > $min; # same major, higher minor
    # now we should be matching major and minor, check patch
    return 1 unless $pat; # move on if we were given maj, min only
    return 0 if $spatch < $pat;
    return 1;
}

1;

__END__