Crypt-Sodium-XS
view release on metacpan or search on metacpan
if (sodium_init() != 0)
croak("Failed to initialze library");
has_aes256gcm = crypto_aead_aes256gcm_is_available();
PROTOTYPES: ENABLE
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS", 0);
PPCODE:
newCONSTSUB(stash, "SODIUM_VERSION_STRING", newSVpvs(SODIUM_VERSION_STRING));
newCONSTSUB(stash, "SODIUM_LIBRARY_VERSION_MAJOR",
newSVuv(SODIUM_LIBRARY_VERSION_MAJOR));
newCONSTSUB(stash, "SODIUM_LIBRARY_VERSION_MINOR",
newSVuv(SODIUM_LIBRARY_VERSION_MINOR));
XSRETURN_YES;
const char *
sodium_version_string()
inc/aead.xs view on Meta::CPAN
=cut
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::aead
void
_define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::aead", 0);
PPCODE:
newCONSTSUB(stash, "aead_chacha20poly1305_ABYTES",
newSVuv(crypto_aead_chacha20poly1305_ABYTES));
newCONSTSUB(stash, "aead_chacha20poly1305_ietf_ABYTES",
newSVuv(crypto_aead_chacha20poly1305_ietf_ABYTES));
newCONSTSUB(stash, "aead_aes256gcm_ABYTES",
newSVuv(crypto_aead_aes256gcm_ABYTES));
newCONSTSUB(stash, "aead_xchacha20poly1305_ietf_ABYTES",
newSVuv(crypto_aead_xchacha20poly1305_ietf_ABYTES));
newCONSTSUB(stash, "aead_chacha20poly1305_KEYBYTES",
newSVuv(crypto_aead_chacha20poly1305_KEYBYTES));
inc/aead.xs view on Meta::CPAN
STRLEN msg_len, adata_len = 0, nonce_len, key_len;
STRLEN adata_req_len, nonce_req_len, key_req_len, out_len;
int (*comb_func)(unsigned char *, unsigned long long *, const unsigned char *,
unsigned long long, const unsigned char *, unsigned long long,
const unsigned char *, const unsigned char *, const unsigned char *);
int (*detached_func)(unsigned char *, unsigned char *, unsigned long long *,
const unsigned char *, unsigned long long, const unsigned char *,
unsigned long long, const unsigned char *, const unsigned char *,
const unsigned char *);
PPCODE:
switch(ix) {
case 2: /* fallthrough */
case 3:
adata_req_len = crypto_aead_chacha20poly1305_ietf_ABYTES;
nonce_req_len = crypto_aead_chacha20poly1305_ietf_NPUBBYTES;
key_req_len = crypto_aead_chacha20poly1305_ietf_KEYBYTES;
comb_func = crypto_aead_chacha20poly1305_ietf_encrypt;
detached_func = crypto_aead_chacha20poly1305_ietf_encrypt_detached;
break;
case 4: /* fallthrough */
inc/aead.xs view on Meta::CPAN
OUTPUT:
RETVAL
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::aead::precalc
void DESTROY(SV * self)
PREINIT:
protmem *precalc_pm;
PPCODE:
precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::aead::precalc");
protmem_free(aTHX_ precalc_pm);
SV * decrypt( \
SV * self, \
SV * ciphertext, \
SV * nonce, \
SV * adata = &PL_sv_undef, \
SV * flags = &PL_sv_undef \
)
inc/aead.xs view on Meta::CPAN
ALIAS:
encrypt_detached = 1
PREINIT:
protmem *precalc_pm, *msg_pm = NULL;
SV *ct, *adata_out = NULL;
unsigned char *msg_buf, *adata_buf = NULL, *nonce_buf, *ct_buf, *adata_out_buf;
STRLEN msg_len, adata_len = 0, nonce_len, out_len;
PPCODE:
nonce_buf = (unsigned char *)SvPVbyte(nonce, nonce_len);
if (nonce_len != crypto_aead_aes256gcm_NPUBBYTES)
croak("encrypt: Invalid nonce length %lu", nonce_len);
SvGETMAGIC(adata);
if (SvOK(adata))
adata_buf = (unsigned char *)SvPVbyte_nomg(adata, adata_len);
if (sv_derived_from(msg, MEMVAULT_CLASS)) {
msg_pm = protmem_get(aTHX_ msg, MEMVAULT_CLASS);
inc/auth.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::auth
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::auth", 0);
PPCODE:
newCONSTSUB(stash, "auth_BYTES",
newSVuv(crypto_auth_BYTES));
newCONSTSUB(stash, "auth_hmacsha256_BYTES",
newSVuv(crypto_auth_hmacsha256_BYTES));
newCONSTSUB(stash, "auth_hmacsha512_BYTES",
newSVuv(crypto_auth_hmacsha512_BYTES));
newCONSTSUB(stash, "auth_hmacsha512256_BYTES",
newSVuv(crypto_auth_hmacsha512256_BYTES));
newCONSTSUB(stash, "auth_KEYBYTES",
newSVuv(crypto_auth_KEYBYTES));
inc/auth.xs view on Meta::CPAN
auth_hmacsha512256_verify = 2
PREINIT:
protmem *msg_pm = NULL, *key_pm = NULL;
unsigned char *msg_buf, *key_buf = NULL, *mac_buf;
STRLEN msg_len, key_len = 0, key_req_len, mac_len, mac_req_len;
int ret;
int (*func)(const unsigned char *, const unsigned char *,
unsigned long long, const unsigned char *);
PPCODE:
switch(ix) {
case 1:
key_req_len = crypto_auth_hmacsha512_KEYBYTES;
mac_req_len = crypto_auth_hmacsha512_BYTES;
func = crypto_auth_hmacsha512_verify;
break;
case 2:
key_req_len = crypto_auth_hmacsha512256_KEYBYTES;
mac_req_len = crypto_auth_hmacsha512256_BYTES;
func = crypto_auth_hmacsha512256_verify;
inc/auth.xs view on Meta::CPAN
void DESTROY(SV * self)
ALIAS:
Crypt::Sodium::XS::auth::hmacsha512_multi::DESTROY = 1
Crypt::Sodium::XS::auth::hmacsha512256_multi::DESTROY= 2
PREINIT:
protmem *state_pm;
PPCODE:
switch (ix) {
case 1:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512_multi");
break;
case 2:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512256_multi");
break;
default:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha256_multi");
}
inc/auth.xs view on Meta::CPAN
ALIAS:
Crypt::Sodium::XS::auth::hmacsha512_multi::update = 1
Crypt::Sodium::XS::auth::hmacsha512256_multi::update = 2
PREINIT:
protmem *state_pm, *msg_mv = NULL;
unsigned char *msg_buf;
STRLEN msg_len;
I32 i;
PPCODE:
switch(ix) {
case 1:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512_multi");
break;
case 2:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512256_multi");
break;
default:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha256_multi");
}
inc/base64.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::Base64
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::Base64", 0);
PPCODE:
newCONSTSUB(stash, "BASE64_VARIANT_ORIGINAL",
newSVuv(sodium_base64_VARIANT_ORIGINAL));
newCONSTSUB(stash, "BASE64_VARIANT_ORIGINAL_NO_PADDING",
newSVuv(sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
newCONSTSUB(stash, "BASE64_VARIANT_URLSAFE",
newSVuv(sodium_base64_VARIANT_URLSAFE));
newCONSTSUB(stash, "BASE64_VARIANT_URLSAFE_NO_PADDING",
newSVuv(sodium_base64_VARIANT_URLSAFE_NO_PADDING));
XSRETURN_YES;
also of note, no curve25519xsalsa20poly1305 seal interfaces. same deal.
=cut
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::box
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::box", 0);
PPCODE:
newCONSTSUB(stash, "box_BEFORENMBYTES",
newSVuv(crypto_box_BEFORENMBYTES));
newCONSTSUB(stash, "box_curve25519xchacha20poly1305_BEFORENMBYTES",
newSVuv(crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES));
newCONSTSUB(stash, "box_curve25519xsalsa20poly1305_BEFORENMBYTES",
newSVuv(crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES));
newCONSTSUB(stash, "box_MACBYTES",
newSVuv(crypto_box_MACBYTES));
newCONSTSUB(stash, "box_curve25519xchacha20poly1305_MACBYTES",
newSVuv(crypto_box_curve25519xchacha20poly1305_MACBYTES));
STRLEN msg_len, nonce_len, pk_len, sk_len, mac_len;
STRLEN nonce_req_len, pk_req_len, sk_req_len;
int (*detached_func)(unsigned char *, unsigned char *,
const unsigned char *, unsigned long long,
const unsigned char *, const unsigned char *,
const unsigned char *);
int (*easy_func)(unsigned char *, const unsigned char *,
unsigned long long, const unsigned char *,
const unsigned char *, const unsigned char *);
PPCODE:
switch(ix) {
case 2: /* fallthrough */
case 3:
nonce_req_len = crypto_box_curve25519xchacha20poly1305_NONCEBYTES;
pk_req_len = crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
sk_req_len = crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES;
mac_len = crypto_box_curve25519xchacha20poly1305_MACBYTES;
detached_func = crypto_box_curve25519xchacha20poly1305_detached;
easy_func = crypto_box_curve25519xchacha20poly1305_easy;
break;
box_curve25519xchacha20poly1305_keypair = 1
box_curve25519xsalsa20poly1305_keypair = 2
PREINIT:
protmem *seed_pm = NULL, *sk_pm;
SV *pk_sv;
unsigned char *pk_buf, *seed_buf;
STRLEN seed_len, seed_req_len, pk_len, sk_len;
unsigned int sk_flags = g_protmem_default_flags_key;
PPCODE:
SvGETMAGIC(flags);
if (SvOK(flags))
sk_flags = SvUV_nomg(flags);
switch(ix) {
case 1:
seed_req_len = crypto_box_curve25519xchacha20poly1305_SEEDBYTES;
pk_len = crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
sk_len = crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES;
break;
void DESTROY(SV * self)
ALIAS:
Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305::DESTROY = 1
Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305::DESTROY = 2
PREINIT:
protmem *precalc_pm;
PPCODE:
switch(ix) {
case 1:
precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305");
break;
case 2:
precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305");
break;
default:
precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc");
}
SV *ct, *mac = NULL;
unsigned char *msg_buf, *nonce_buf, *ct_buf, *mac_buf;
STRLEN msg_len, nonce_len, nonce_req_len, mac_len;
int (*detached_func)(unsigned char *, unsigned char *,
const unsigned char *, unsigned long long,
const unsigned char *, const unsigned char *);
int (*easy_func)(unsigned char *, const unsigned char *,
unsigned long long, const unsigned char *,
const unsigned char *);
PPCODE:
switch(ix) {
case 2: /* fallthrough */
case 3:
nonce_req_len = crypto_box_curve25519xchacha20poly1305_NONCEBYTES;
mac_len = crypto_box_curve25519xchacha20poly1305_MACBYTES;
precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305");
detached_func = crypto_box_curve25519xchacha20poly1305_detached_afternm;
easy_func = crypto_box_curve25519xchacha20poly1305_easy_afternm;
break;
case 4: /* fallthrough */
inc/core.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::Core
void
_define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::Core", 0);
PPCODE:
newCONSTSUB(stash, "ed25519_BYTES",
newSVuv(crypto_core_ed25519_BYTES));
newCONSTSUB(stash, "ed25519_HASHBYTES",
newSVuv(crypto_core_ed25519_HASHBYTES));
newCONSTSUB(stash, "ed25519_NONREDUCEDSCALARBYTES",
newSVuv(crypto_core_ed25519_NONREDUCEDSCALARBYTES));
newCONSTSUB(stash, "ed25519_SCALARBYTES",
newSVuv(crypto_core_ed25519_SCALARBYTES));
newCONSTSUB(stash, "ed25519_UNIFORMBYTES",
newSVuv(crypto_core_ed25519_UNIFORMBYTES));
inc/core.xs view on Meta::CPAN
ALIAS:
ristretto255_is_valid_point = 1
PREINIT:
protmem *p_pm = NULL;
int ret;
unsigned char *p_buf;
STRLEN p_len, p_req_len;
PPCODE:
PERL_UNUSED_VAR(RETVAL);
switch(ix) {
case 1:
p_req_len = crypto_core_ristretto255_BYTES;
break;
default:
p_req_len = crypto_core_ed25519_BYTES;
}
if (sv_derived_from(p, MEMVAULT_CLASS)) {
p_pm = protmem_get(aTHX_ p, MEMVAULT_CLASS);
inc/curve25519.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::curve25519
void
_define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::curve25519", 0);
PPCODE:
newCONSTSUB(stash, "core_ed25519_BYTES",
newSVuv(crypto_core_ed25519_BYTES));
newCONSTSUB(stash, "core_ed25519_HASHBYTES",
newSVuv(crypto_core_ed25519_HASHBYTES));
newCONSTSUB(stash, "core_ed25519_NONREDUCEDSCALARBYTES",
newSVuv(crypto_core_ed25519_NONREDUCEDSCALARBYTES));
newCONSTSUB(stash, "core_ed25519_SCALARBYTES",
newSVuv(crypto_core_ed25519_SCALARBYTES));
newCONSTSUB(stash, "core_ed25519_UNIFORMBYTES",
newSVuv(crypto_core_ed25519_UNIFORMBYTES));
inc/curve25519.xs view on Meta::CPAN
ALIAS:
core_ristretto255_is_valid_point = 1
PREINIT:
protmem *p_pm = NULL;
int ret;
unsigned char *p_buf;
STRLEN p_len, p_req_len;
PPCODE:
PERL_UNUSED_VAR(RETVAL);
switch(ix) {
case 1:
p_req_len = crypto_core_ristretto255_BYTES;
break;
default:
p_req_len = crypto_core_ed25519_BYTES;
}
if (sv_derived_from(p, MEMVAULT_CLASS)) {
p_pm = protmem_get(aTHX_ p, MEMVAULT_CLASS);
inc/generichash.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::generichash
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::generichash", 0);
PPCODE:
newCONSTSUB(stash, "generichash_BYTES",
newSVuv(crypto_generichash_BYTES));
newCONSTSUB(stash, "generichash_blake2b_BYTES",
newSVuv(crypto_generichash_blake2b_BYTES));
newCONSTSUB(stash, "generichash_BYTES_MAX",
newSVuv(crypto_generichash_BYTES_MAX));
newCONSTSUB(stash, "generichash_blake2b_BYTES_MAX",
newSVuv(crypto_generichash_blake2b_BYTES_MAX));
newCONSTSUB(stash, "generichash_BYTES_MIN",
newSVuv(crypto_generichash_BYTES_MIN));
inc/generichash.xs view on Meta::CPAN
void DESTROY(SV * self)
ALIAS:
Crypt::Sodium::XS::generichash::blake2b_multi::DESTROY = 1
PREINIT:
protmem *state_pm;
SV *obj, **state;
PPCODE:
obj = SvRV(self);
if (SvTYPE(obj) != SVt_PVHV)
croak("BUG: DESTROY: not a hash ref");
state = hv_fetchs((HV *)obj, "state", 0);
if (state == NULL)
croak("BUG: DESTROY: missing state");
switch(ix) {
case 1:
state_pm = protmem_get(aTHX_ *state, "Crypt::Sodium::XS::generichash::blake2b_multistate");
inc/generichash.xs view on Meta::CPAN
ALIAS:
Crypt::Sodium::XS::generichash::blake2b_multi::update = 1
PREINIT:
protmem *state_pm, *msg_pm = NULL;
unsigned char *msg_buf;
STRLEN msg_len;
SV *obj, **state;
I32 i;
PPCODE:
obj = SvRV(self);
if (SvTYPE(obj) != SVt_PVHV)
croak("BUG: final: not a hash ref");
state = hv_fetchs((HV *)obj, "state", 0);
if (state == NULL)
croak("BUG: update: missing state");
switch(ix) {
case 1:
state_pm = protmem_get(aTHX_ *state, "Crypt::Sodium::XS::generichash::blake2b_multistate");
inc/hash.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::hash
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::hash", 0);
PPCODE:
newCONSTSUB(stash, "hash_BYTES", newSVuv(crypto_hash_BYTES));
newCONSTSUB(stash, "hash_sha256_BYTES", newSVuv(crypto_hash_sha256_BYTES));
newCONSTSUB(stash, "hash_sha512_BYTES", newSVuv(crypto_hash_sha512_BYTES));
newCONSTSUB(stash, "hash_PRIMITIVE", newSVpvs(crypto_hash_PRIMITIVE));
SV * hash(SV * msg)
ALIAS:
hash_sha256 = 1
hash_sha512 = 2
inc/hash.xs view on Meta::CPAN
ALIAS:
Crypt::Sodium::XS::hash::sha512_multi::update = 1
PREINIT:
protmem *state_pm, *msg_pm = NULL;
unsigned char *msg_buf;
STRLEN msg_len;
I32 i;
PPCODE:
switch(ix) {
case 1:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::hash::sha512_multi");
break;
default:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::hash::sha256_multi");
}
if (protmem_grant(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0)
croak("update: Failed to grant state protmem RW");
inc/hkdf.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::hkdf
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::hkdf", 0);
PPCODE:
#ifdef SODIUM_HAS_HKDF
newCONSTSUB(stash, "hkdf_sha256_BYTES_MAX",
newSVuv(crypto_kdf_hkdf_sha256_BYTES_MAX));
newCONSTSUB(stash, "hkdf_sha512_BYTES_MAX",
newSVuv(crypto_kdf_hkdf_sha512_BYTES_MAX));
newCONSTSUB(stash, "hkdf_sha256_BYTES_MIN",
newSVuv(crypto_kdf_hkdf_sha256_BYTES_MIN));
newCONSTSUB(stash, "hkdf_sha512_BYTES_MIN",
newSVuv(crypto_kdf_hkdf_sha512_BYTES_MIN));
newCONSTSUB(stash, "hkdf_sha256_KEYBYTES",
inc/hkdf.xs view on Meta::CPAN
ALIAS:
Crypt::Sodium::XS::hkdf::sha512_multi::update = 1
PREINIT:
protmem *state_pm, *msg_pm = NULL;
unsigned char *msg_buf;
STRLEN msg_len;
I32 i;
PPCODE:
PERL_UNUSED_VAR(RETVAL);
switch(ix) {
case 1:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::hkdf::sha512_multi");
break;
default:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::hkdf::sha256_multi");
}
if (protmem_grant(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0)
croak("update: Failed to grant state protmem RW");
inc/ipcrypt.xs view on Meta::CPAN
# NB: some constants added for consistency which are not provided by libsodium.
# for deterministic and pfx INPUTBYTES and OUTPUTBYTES are defined to be the
# same as BYTES. TWEAKBYTES is also defined as a constant of 0.
=cut
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::ipcrypt", 0);
PPCODE:
#ifdef SODIUM_HAS_IPCRYPT
newCONSTSUB(stash, "ipcrypt_BYTES",
newSVuv(crypto_ipcrypt_BYTES));
newCONSTSUB(stash, "ipcrypt_INPUTBYTES",
newSVuv(crypto_ipcrypt_BYTES));
newCONSTSUB(stash, "ipcrypt_KEYBYTES",
newSVuv(crypto_ipcrypt_KEYBYTES));
newCONSTSUB(stash, "ipcrypt_OUTPUTBYTES",
newSVuv(crypto_ipcrypt_BYTES));
newCONSTSUB(stash, "ipcrypt_TWEAKBYTES",
#define csxs_kdf_DERIVE_ID_CEILING 0x1p+53
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::kdf
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::kdf", 0);
PPCODE:
newCONSTSUB(stash, "kdf_BYTES_MAX", newSVuv(crypto_kdf_BYTES_MAX));
newCONSTSUB(stash, "kdf_blake2b_BYTES_MAX",
newSVuv(crypto_kdf_blake2b_BYTES_MAX));
newCONSTSUB(stash, "kdf_BYTES_MIN", newSVuv(crypto_kdf_BYTES_MIN));
newCONSTSUB(stash, "kdf_blake2b_BYTES_MIN",
newSVuv(crypto_kdf_blake2b_BYTES_MIN));
newCONSTSUB(stash, "kdf_CONTEXTBYTES", newSVuv(crypto_kdf_CONTEXTBYTES));
newCONSTSUB(stash, "kdf_blake2b_CONTEXTBYTES",
newSVuv(crypto_kdf_blake2b_CONTEXTBYTES));
newCONSTSUB(stash, "kdf_KEYBYTES", newSVuv(crypto_kdf_KEYBYTES));
functions.
=cut
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::kx
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::kx", 0);
PPCODE:
newCONSTSUB(stash, "kx_PUBLICKEYBYTES", newSVuv(crypto_kx_PUBLICKEYBYTES));
newCONSTSUB(stash, "kx_x25519blake2b_PUBLICKEYBYTES",
newSVuv(crypto_kx_PUBLICKEYBYTES));
newCONSTSUB(stash, "kx_SECRETKEYBYTES", newSVuv(crypto_kx_SECRETKEYBYTES));
newCONSTSUB(stash, "kx_x25519blake2b_SECRETKEYBYTES",
newSVuv(crypto_kx_SECRETKEYBYTES));
newCONSTSUB(stash, "kx_SEEDBYTES", newSVuv(crypto_kx_SEEDBYTES));
newCONSTSUB(stash, "kx_x25519blake2b_SEEDBYTES",
newSVuv(crypto_kx_SEEDBYTES));
newCONSTSUB(stash, "kx_SESSIONKEYBYTES", newSVuv(crypto_kx_SESSIONKEYBYTES));
ALIAS:
kx_x25519blake2b_keypair = 1
PREINIT:
protmem *sk_pm;
SV *pk_sv;
unsigned char *pk_buf;
unsigned int sk_flags = g_protmem_default_flags_key;
PPCODE:
PERL_UNUSED_VAR(ix);
SvGETMAGIC(flags);
if (SvOK(flags))
sk_flags = SvUV_nomg(flags);
Newx(pk_buf, crypto_kx_PUBLICKEYBYTES + 1, unsigned char);
if (pk_buf == NULL)
croak("kx_keypair: Failed to allocate memory");
pk_buf[crypto_kx_PUBLICKEYBYTES] = '\0';
ALIAS:
kx_x25519blake2b_client_session_keys = 1
PREINIT:
protmem *rx, *tx, *csk_pm = NULL;
unsigned char * cpk_buf, * csk_buf, * spk_buf;
STRLEN cpk_len, csk_len, spk_len;
unsigned int key_flags = g_protmem_default_flags_key;
int ret;
PPCODE:
PERL_UNUSED_VAR(ix);
SvGETMAGIC(flags);
if (SvOK(flags))
key_flags = SvUV_nomg(flags);
cpk_buf = (unsigned char *)SvPVbyte(cpk, cpk_len);
if (cpk_len != crypto_kx_PUBLICKEYBYTES)
croak("kx_client_session_keys: Invalid public key length %lu", cpk_len);
ALIAS:
kx_x25519blake2b_server_session_keys = 1
PREINIT:
protmem *rx, *tx, *ssk_pm = NULL;
unsigned char * spk_buf, * ssk_buf, * cpk_buf;
STRLEN spk_len, ssk_len, cpk_len;
unsigned int key_flags = g_protmem_default_flags_key;
int ret;
PPCODE:
PERL_UNUSED_VAR(ix);
SvGETMAGIC(flags);
if (SvOK(flags))
key_flags = SvUV_nomg(flags);
spk_buf = (unsigned char *)SvPVbyte(spk, spk_len);
if (spk_len != crypto_kx_PUBLICKEYBYTES)
croak("kx_server_session_keys: Invalid public key length %lu", spk_len);
inc/memvault.xs view on Meta::CPAN
CODE:
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
protmem_free(aTHX_ self_pm);
void _overload_bool(SV * self, ...)
PREINIT:
protmem *self_pm;
PPCODE:
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
if (self_pm->size)
XSRETURN_YES;
else
XSRETURN_NO;
SV * _overload_mult(SV * self, SV * other, SV * swapped)
PREINIT:
inc/memvault.xs view on Meta::CPAN
RETVAL = protmem_to_sv(aTHX_ new_pm, MEMVAULT_CLASS);
OUTPUT:
RETVAL
void _overload_nomethod(SV * self, ...)
PREINIT:
char *operator;
PPCODE:
PERL_UNUSED_VAR(self);
operator = SvPVbyte_nolen(ST(3));
croak("Operation \"%s\" on MemVault is not supported", operator);
void bitwise_and(SV * self, SV * other, ...)
ALIAS:
bitwise_or = 1
bitwise_xor = 2
bitwise_and_equals = 100
inc/memvault.xs view on Meta::CPAN
PREINIT:
protmem *self_pm;
protmem *other_pm = NULL;
protmem *new_pm = NULL;
unsigned char *buf;
unsigned char *other_buf;
STRLEN other_len;
STRLEN i;
unsigned int new_flags;
PPCODE:
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
if (sv_derived_from(other, MEMVAULT_CLASS)) {
other_pm = protmem_get(aTHX_ other, MEMVAULT_CLASS);
other_buf = other_pm->pm_ptr;
other_len = other_pm->size;
}
else
other_buf = (unsigned char *)SvPVbyte(other, other_len);
if (other_len != self_pm->size)
inc/memvault.xs view on Meta::CPAN
_overload_eq = 1
_overload_ne = 2
memcmp = 3
PREINIT:
protmem *self_pm = NULL, *other_pm = NULL;
unsigned char *self_buf, *other_buf;
STRLEN self_size, other_size;
int ret = 0;
PPCODE:
/* since used for overloads, args could be swapped. could require either self
* or other to be a memvault */
if (sv_derived_from(self, MEMVAULT_CLASS)) {
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
if (ix == 0 && !(self_pm->flags & PROTMEM_FLAG_LOCK_UNLOCKED))
croak("compare: Unlock MemVault object before comparison");
self_buf = self_pm->pm_ptr;
self_size = self_pm->size;
}
else
inc/memvault.xs view on Meta::CPAN
PREINIT:
protmem *self_pm;
protmem *other_pm = NULL;
protmem *new_pm;
unsigned char *buf;
MAGIC *mg, *mg_found=NULL;
STRLEN buf_len;
unsigned int new_flags;
PPCODE:
if (sv_derived_from(other, MEMVAULT_CLASS)) {
other_pm = protmem_get(aTHX_ other, MEMVAULT_CLASS);
buf = other_pm->pm_ptr;
buf_len = other_pm->size;
}
else
buf = (unsigned char *)SvPVbyte(other, buf_len);
/* should probably zero buf afterwards */
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
inc/memvault.xs view on Meta::CPAN
RETVAL = protmem_to_sv(aTHX_ new_pm, MEMVAULT_CLASS);
OUTPUT:
RETVAL
void increment(SV * self)
PREINIT:
protmem *self_pm;
PPCODE:
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
if (protmem_grant(aTHX_ self_pm, PROTMEM_FLAG_MPROTECT_RW) != 0)
croak("increment: Failed to grant self protmem RW");
sodium_increment(self_pm->pm_ptr, self_pm->size);
if (protmem_release(aTHX_ self_pm, PROTMEM_FLAG_MPROTECT_RW) != 0)
croak("increment: Failed to release self protmem RW");
XSRETURN(1);
inc/memvault.xs view on Meta::CPAN
croak("index: Failed to release self protmem RO");
OUTPUT:
RETVAL
void is_locked(SV * self)
PREINIT:
protmem *self_pm;
PPCODE:
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
if (self_pm->flags & PROTMEM_FLAG_LOCK_UNLOCKED)
XSRETURN_NO;
XSRETURN_YES;
void is_zero(SV * self)
PREINIT:
protmem *self_pm;
int ret;
PPCODE:
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
if (protmem_grant(aTHX_ self_pm, PROTMEM_FLAG_MPROTECT_RO) != 0)
croak("is_zero: Failed to grant self protmem RO");
ret = sodium_is_zero(self_pm->pm_ptr, self_pm->size);
if (protmem_release(aTHX_ self_pm, PROTMEM_FLAG_MPROTECT_RO) != 0)
croak("is_zero: Failed to release self protmem RO");
if (ret)
inc/memvault.xs view on Meta::CPAN
RETVAL = newSVuv((UV)self_pm->size);
OUTPUT:
RETVAL
void lock(SV * self)
PREINIT:
protmem *self_pm;
PPCODE:
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
self_pm->flags &= ~PROTMEM_FLAG_LOCK_UNLOCKED;
XSRETURN(1);
SV * pad(SV * self, STRLEN blocksize)
PREINIT:
protmem *self_pm, *realloc_pm;
STRLEN buf_len, pad_len, padded_len;
inc/memvault.xs view on Meta::CPAN
RETVAL = newSVuv(t);
OUTPUT:
RETVAL
void unlock(SV * self)
PREINIT:
protmem *self_pm;
PPCODE:
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
self_pm->flags |= PROTMEM_FLAG_LOCK_UNLOCKED;
XSRETURN(1);
SV * unpad(SV * self, STRLEN blocksize)
PREINIT:
protmem *self_pm, *realloc_pm;
STRLEN buf_len, unpadded_len;
inc/memvault.xs view on Meta::CPAN
RETVAL = protmem_to_sv(aTHX_ realloc_pm, MEMVAULT_CLASS);
OUTPUT:
RETVAL
void memzero(SV * self)
PREINIT:
protmem *self_pm;
PPCODE:
self_pm = protmem_get(aTHX_ self, MEMVAULT_CLASS);
if (protmem_grant(aTHX_ self_pm, PROTMEM_FLAG_MPROTECT_RW) < 0)
croak("memzero: Failed to grant self protmem RW");
sodium_memzero(self_pm->pm_ptr, self_pm->size);
if (protmem_release(aTHX_ self_pm, PROTMEM_FLAG_MPROTECT_RW) < 0)
croak("memzero: Failed to release self protmem RW");
=for FIXME
separate methods for xor (modify in place) from the overload (new
inc/onetimeauth.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::onetimeauth
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::onetimeauth", 0);
PPCODE:
newCONSTSUB(stash, "onetimeauth_BYTES", newSVuv(crypto_onetimeauth_BYTES));
newCONSTSUB(stash, "onetimeauth_poly1305_BYTES",
newSVuv(crypto_onetimeauth_poly1305_BYTES));
newCONSTSUB(stash, "onetimeauth_KEYBYTES",
newSVuv(crypto_onetimeauth_KEYBYTES));
newCONSTSUB(stash, "onetimeauth_poly1305_KEYBYTES",
newSVuv(crypto_onetimeauth_poly1305_KEYBYTES));
newCONSTSUB(stash, "onetimeauth_PRIMITIVE",
newSVpvs(crypto_onetimeauth_PRIMITIVE));
inc/onetimeauth.xs view on Meta::CPAN
ALIAS:
Crypt::Sodium::XS::onetimeauth::poly1305_multi::update = 1
PREINIT:
protmem *state_pm, *msg_mv = NULL;
unsigned char *msg_buf;
STRLEN msg_len;
I32 i;
PPCODE:
switch(ix) {
case 1:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::onetimeauth::poly1305_multi");
break;
default:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::onetimeauth::multi");
}
if (protmem_grant(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0)
croak("update: Failed to grant state protmem RW");
inc/protmem.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::ProtMem
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::ProtMem", 0);
PPCODE:
newCONSTSUB(stash, "PROTMEM_ALL_DISABLED",
newSVuv(PROTMEM_FLAG_ALL_DISABLED));
newCONSTSUB(stash, "PROTMEM_ALL_ENABLED",
newSVuv(PROTMEM_FLAG_ALL_ENABLED));
newCONSTSUB(stash, "PROTMEM_MASK_MPROTECT",
newSVuv(PROTMEM_FLAG_MPROTECT_MASK));
newCONSTSUB(stash, "PROTMEM_FLAGS_MPROTECT_NOACCESS",
newSVuv(PROTMEM_FLAG_MPROTECT_NOACCESS));
newCONSTSUB(stash, "PROTMEM_FLAGS_MPROTECT_RO",
newSVuv(PROTMEM_FLAG_MPROTECT_RO));
inc/protmem.xs view on Meta::CPAN
protmem_default_flags_decrypt_memzero = 18
protmem_default_flags_state_memzero = 19
protmem_default_flags_key_malloc = 20
protmem_default_flags_memvault_malloc = 21
protmem_default_flags_decrypt_malloc = 22
protmem_default_flags_state_malloc = 23
PREINIT:
U32 new_flags, old_flags, *global, mask = 0;
PPCODE:
switch(ix % 4) {
case 1:
global = &g_protmem_default_flags_key;
break;
case 2:
global = &g_protmem_default_flags_decrypt;
break;
case 3:
global = &g_protmem_default_flags_state;
break;
inc/pwhash.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::pwhash
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::pwhash", 0);
PPCODE:
newCONSTSUB(stash, "pwhash_BYTES_MAX", newSVuv(crypto_pwhash_BYTES_MAX));
newCONSTSUB(stash, "pwhash_argon2i_BYTES_MAX",
newSVuv(crypto_pwhash_argon2i_BYTES_MAX));
newCONSTSUB(stash, "pwhash_argon2id_BYTES_MAX",
newSVuv(crypto_pwhash_argon2id_BYTES_MAX));
newCONSTSUB(stash, "pwhash_scryptsalsa208sha256_BYTES_MAX",
newSVuv(crypto_pwhash_scryptsalsa208sha256_BYTES_MAX));
newCONSTSUB(stash, "pwhash_BYTES_MIN", newSVuv(crypto_pwhash_BYTES_MIN));
newCONSTSUB(stash, "pwhash_argon2i_BYTES_MIN",
newSVuv(crypto_pwhash_argon2i_BYTES_MIN));
inc/pwhash.xs view on Meta::CPAN
newCONSTSUB(stash, "pwhash_STRPREFIX", newSVpvs(crypto_pwhash_STRPREFIX));
newCONSTSUB(stash, "pwhash_argon2i_STRPREFIX",
newSVpvs(crypto_pwhash_argon2i_STRPREFIX));
newCONSTSUB(stash, "pwhash_argon2id_STRPREFIX",
newSVpvs(crypto_pwhash_argon2id_STRPREFIX));
newCONSTSUB(stash, "pwhash_scryptsalsa208sha256_STRPREFIX",
newSVpvs(crypto_pwhash_scryptsalsa208sha256_STRPREFIX));
newCONSTSUB(stash, "pwhash_PRIMITIVE", newSVpvs(crypto_pwhash_PRIMITIVE));
void pwhash_scryptsalsa208sha256_MEMLIMIT_MODERATE()
PPCODE:
croak("This primitive does not support MEMLIMIT_MODERATE");
void pwhash_scryptsalsa208sha256_OPSLIMIT_MODERATE()
PPCODE:
croak("This primitive does not support OPSLIMIT_MODERATE");
SV * pwhash( \
SV * passphrase, \
SV * salt, \
STRLEN out_len = 0, \
STRLEN opslimit = 0, \
STRLEN memlimit = 0, \
U32 flags = 0 \
)
inc/pwhash.xs view on Meta::CPAN
PREINIT:
protmem *str_pm = NULL;
char *str_buf;
size_t opslimit_def, opslimit_min, opslimit_max;
size_t memlimit_def, memlimit_min, memlimit_max;
STRLEN str_len;
int ret;
int (*func)(const char *, unsigned long long, size_t);
PPCODE:
switch(ix) {
case 1:
opslimit_def = crypto_pwhash_argon2i_OPSLIMIT_INTERACTIVE;
opslimit_min = crypto_pwhash_argon2i_OPSLIMIT_MIN;
opslimit_max = crypto_pwhash_argon2i_OPSLIMIT_MAX;
memlimit_def = crypto_pwhash_argon2i_MEMLIMIT_INTERACTIVE;
memlimit_min = crypto_pwhash_argon2i_MEMLIMIT_MIN;
memlimit_max = crypto_pwhash_argon2i_MEMLIMIT_MAX;
func = crypto_pwhash_argon2i_str_needs_rehash;
break;
inc/scalarmult.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::scalarmult
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::scalarmult", 0);
PPCODE:
newCONSTSUB(stash, "scalarmult_BYTES",
newSVuv(crypto_scalarmult_BYTES));
newCONSTSUB(stash, "scalarmult_SCALARBYTES",
newSVuv(crypto_scalarmult_SCALARBYTES));
newCONSTSUB(stash, "scalarmult_x25519_BYTES",
newSVuv(crypto_scalarmult_BYTES));
newCONSTSUB(stash, "scalarmult_x25519_SCALARBYTES",
newSVuv(crypto_scalarmult_SCALARBYTES));
newCONSTSUB(stash, "scalarmult_ed25519_BYTES",
newSVuv(crypto_scalarmult_ed25519_BYTES));
inc/secretbox.xs view on Meta::CPAN
through to the defaults.
=cut
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::secretbox
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::secretbox", 0);
PPCODE:
newCONSTSUB(stash, "secretbox_KEYBYTES", newSVuv(crypto_secretbox_KEYBYTES));
newCONSTSUB(stash, "secretbox_xchacha20poly1305_KEYBYTES",
newSVuv(crypto_secretbox_xchacha20poly1305_KEYBYTES));
newCONSTSUB(stash, "secretbox_xsalsa20poly1305_KEYBYTES",
newSVuv(crypto_secretbox_xsalsa20poly1305_KEYBYTES));
newCONSTSUB(stash, "secretbox_MACBYTES", newSVuv(crypto_secretbox_MACBYTES));
newCONSTSUB(stash, "secretbox_xchacha20poly1305_MACBYTES",
newSVuv(crypto_secretbox_xchacha20poly1305_MACBYTES));
newCONSTSUB(stash, "secretbox_xsalsa20poly1305_MACBYTES",
newSVuv(crypto_secretbox_xsalsa20poly1305_MACBYTES));
inc/secretbox.xs view on Meta::CPAN
SV *ct, *mac = NULL;
unsigned char *msg_buf, *nonce_buf, *key_buf, *ct_buf, *mac_buf;
STRLEN msg_len, nonce_len, key_len, nonce_req_len, key_req_len, mac_len;
int (*detached_func)(unsigned char *, unsigned char *,
const unsigned char *, unsigned long long,
const unsigned char *, const unsigned char *);
int (*easy_func)(unsigned char *, const unsigned char *,
unsigned long long, const unsigned char *,
const unsigned char *);
PPCODE:
switch(ix) {
case 2:
case 3: /* fallthrough */
nonce_req_len = crypto_secretbox_xchacha20poly1305_NONCEBYTES;
key_req_len = crypto_secretbox_xchacha20poly1305_KEYBYTES;
mac_len = crypto_secretbox_xchacha20poly1305_MACBYTES;
detached_func = crypto_secretbox_xchacha20poly1305_detached;
easy_func = crypto_secretbox_xchacha20poly1305_easy;
break;
case 4: /* fallthrough */
inc/secretstream.xs view on Meta::CPAN
libsodium secretstream includes only xchacha20poly1305-specific functions.
=cut
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::secretstream
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::secretstream", 0);
PPCODE:
newCONSTSUB(stash, "secretstream_xchacha20poly1305_ABYTES",
newSVuv(crypto_secretstream_xchacha20poly1305_ABYTES));
newCONSTSUB(stash, "secretstream_xchacha20poly1305_HEADERBYTES",
newSVuv(crypto_secretstream_xchacha20poly1305_HEADERBYTES));
newCONSTSUB(stash, "secretstream_xchacha20poly1305_KEYBYTES",
newSVuv(crypto_secretstream_xchacha20poly1305_KEYBYTES));
newCONSTSUB(stash, "secretstream_xchacha20poly1305_MESSAGEBYTES_MAX",
newSVuv(crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX));
newCONSTSUB(stash, "secretstream_xchacha20poly1305_TAG_MESSAGE",
newSVuv(crypto_secretstream_xchacha20poly1305_TAG_MESSAGE));
inc/secretstream.xs view on Meta::CPAN
secretstream_xchacha20poly1305_init_push = 1
PREINIT:
PERL_UNUSED_VAR(ix);
protmem *state_pm, *key_pm = NULL;
SV * header;
unsigned char *key_buf, *header_buf;
STRLEN key_len;
unsigned int state_flags = g_protmem_default_flags_key;
PPCODE:
SvGETMAGIC(flags);
if (SvOK(flags))
state_flags = SvUV_nomg(flags);
if (sv_derived_from(key, MEMVAULT_CLASS)) {
key_pm = protmem_get(aTHX_ key, MEMVAULT_CLASS);
key_buf = key_pm->pm_ptr;
key_len = key_pm->size;
}
else
inc/secretstream.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::secretstream::xchacha20poly1305_decrypt
void DESTROY(SV * self)
ALIAS:
Crypt::Sodium::XS::secretstream::xchachapoly1305_encrypt = 1
PREINIT:
protmem *state_pm;
PPCODE:
switch(ix) {
case 1:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::secretstream::xchacha20poly1305_encrypt");
break;
default:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::secretstream::xchacha20poly1305_decrypt");
}
protmem_free(aTHX_ state_pm);
void decrypt( \
inc/secretstream.xs view on Meta::CPAN
pull = 1
PREINIT:
PERL_UNUSED_VAR(ix);
protmem *state_pm, *ct_pm = NULL, *msg_pm;
unsigned char *ct_buf, *adata_buf = NULL, tag;
STRLEN ct_len, adata_len = 0;
unsigned int msg_flags = g_protmem_default_flags_decrypt;
int ret;
PPCODE:
SvGETMAGIC(flags);
if (SvOK(flags))
msg_flags = SvUV_nomg(flags);
if (sv_derived_from(ciphertext, MEMVAULT_CLASS)) {
ct_pm = protmem_get(aTHX_ ciphertext, MEMVAULT_CLASS);
ct_buf = ct_pm->pm_ptr;
ct_len = ct_pm->size;
}
else
inc/shorthash.xs view on Meta::CPAN
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::shorthash
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::shorthash", 0);
PPCODE:
newCONSTSUB(stash, "shorthash_BYTES", newSVuv(crypto_shorthash_BYTES));
newCONSTSUB(stash, "shorthash_siphash24_BYTES",
newSVuv(crypto_shorthash_siphash24_BYTES));
newCONSTSUB(stash, "shorthash_siphashx24_BYTES",
newSVuv(crypto_shorthash_siphashx24_BYTES));
newCONSTSUB(stash, "shorthash_KEYBYTES", newSVuv(crypto_shorthash_KEYBYTES));
newCONSTSUB(stash, "shorthash_siphash24_KEYBYTES",
newSVuv(crypto_shorthash_siphash24_KEYBYTES));
newCONSTSUB(stash, "shorthash_siphashx24_KEYBYTES",
newSVuv(crypto_shorthash_siphashx24_KEYBYTES));
inc/sign.xs view on Meta::CPAN
aliases for sign_ed25519 as with other packages, though it is the default.
=cut
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::sign
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::sign", 0);
PPCODE:
newCONSTSUB(stash, "sign_BYTES", newSVuv(crypto_sign_BYTES));
newCONSTSUB(stash, "sign_ed25519_BYTES", newSVuv(crypto_sign_ed25519_BYTES));
newCONSTSUB(stash, "sign_MESSAGEBYTES_MAX",
newSVuv(crypto_sign_MESSAGEBYTES_MAX));
newCONSTSUB(stash, "sign_ed25519_MESSAGEBYTES_MAX",
newSVuv(crypto_sign_ed25519_MESSAGEBYTES_MAX));
newCONSTSUB(stash, "sign_PUBLICKEYBYTES",
newSVuv(crypto_sign_PUBLICKEYBYTES));
newCONSTSUB(stash, "sign_ed25519_PUBLICKEYBYTES",
newSVuv(crypto_sign_ed25519_PUBLICKEYBYTES));
inc/sign.xs view on Meta::CPAN
sign_ed25519_keypair = 1
PREINIT:
protmem *seed_pm = NULL, *sk_pm;
SV *pk_sv;
unsigned char *pk_buf, *seed_buf;
STRLEN seed_req_len, seed_len;
STRLEN pk_len, sk_len;
unsigned int sk_flags = g_protmem_default_flags_key;
PPCODE:
SvGETMAGIC(flags);
if (SvOK(flags))
sk_flags = SvUV_nomg(flags);
switch(ix) {
case 1:
seed_req_len = crypto_sign_ed25519_SEEDBYTES;
pk_len = crypto_sign_ed25519_PUBLICKEYBYTES;
sk_len = crypto_sign_ed25519_SECRETKEYBYTES;
break;
inc/sign.xs view on Meta::CPAN
ALIAS:
sign_ed25519_to_curve25519 = 1
PREINIT:
protmem *sk_pm = NULL, *sk_ed_pm;
SV *pk_ed_sv;
unsigned char *pk_buf, *sk_buf, *pk_ed_buf;
STRLEN pk_len, sk_len;
unsigned int sk_flags = g_protmem_default_flags_key;
PPCODE:
PERL_UNUSED_VAR(ix);
SvGETMAGIC(flags);
if (SvOK(flags))
sk_flags = SvUV_nomg(flags);
pk_buf = (unsigned char *)SvPVbyte(pk, pk_len);
if (pk_len != crypto_sign_ed25519_PUBLICKEYBYTES)
croak("sign_to_curve25519: Invalid public key length %lu", pk_len);
inc/sign.xs view on Meta::CPAN
sign_ed25519_verify = 1
PREINIT:
protmem *msg_pm = NULL;
unsigned char *msg_buf, *sig_buf, *pk_buf;
STRLEN msg_len, sig_len, pk_len, sig_req_len, pk_req_len;
int ret;
int (*func)(const unsigned char *, const unsigned char *,
unsigned long long, const unsigned char *);
PPCODE:
switch(ix) {
case 1:
sig_req_len = crypto_sign_ed25519_BYTES;
pk_req_len = crypto_sign_ed25519_PUBLICKEYBYTES;
func = crypto_sign_ed25519_verify_detached;
break;
default:
sig_req_len = crypto_sign_BYTES;
pk_req_len = crypto_sign_PUBLICKEYBYTES;
func = crypto_sign_verify_detached;
inc/sign.xs view on Meta::CPAN
ALIAS:
Crypt::Sodium::XS::sign::ed25519ph_multi::final_verify = 1
PREINIT:
protmem *state_pm;
unsigned char *sig_buf, *pk_buf;
STRLEN sig_len, pk_len;
int ret;
PPCODE:
sig_buf = (unsigned char *)SvPVbyte(sig, sig_len);
pk_buf = (unsigned char *)SvPVbyte(pk, pk_len);
switch(ix) {
case 1:
if (sig_len != crypto_sign_ed25519_BYTES)
croak("final_verify: Invalid signature length %lu", sig_len);
if (pk_len != crypto_sign_ed25519_PUBLICKEYBYTES)
croak("final_verify: Invalid public key length %lu", pk_len);
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::sign::ed25519ph_multi");
inc/sign.xs view on Meta::CPAN
ALIAS:
Crypt::Sodium::XS::sign::ed25519ph_multi::update = 1
PREINIT:
protmem *state_pm, *msg_pm;
unsigned char *msg_buf;
STRLEN msg_len;
I32 i;
PPCODE:
switch(ix) {
case 1:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::sign::ed25519ph_multi");
break;
default:
state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::sign::multi");
}
if (protmem_grant(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0)
croak("update: Failed to grant state protmem RW");
inc/stream.xs view on Meta::CPAN
needed internally for output size.
=cut
MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::stream
void _define_constants()
PREINIT:
HV *stash = gv_stashpv("Crypt::Sodium::XS::stream", 0);
PPCODE:
newCONSTSUB(stash, "stream_KEYBYTES", newSVuv(crypto_stream_KEYBYTES));
newCONSTSUB(stash, "stream_chacha20_KEYBYTES",
newSVuv(crypto_stream_chacha20_KEYBYTES));
newCONSTSUB(stash, "stream_chacha20_ietf_KEYBYTES",
newSVuv(crypto_stream_chacha20_ietf_KEYBYTES));
newCONSTSUB(stash, "stream_salsa20_KEYBYTES",
newSVuv(crypto_stream_salsa20_KEYBYTES));
newCONSTSUB(stash, "stream_salsa2012_KEYBYTES",
newSVuv(crypto_stream_salsa2012_KEYBYTES));
newCONSTSUB(stash, "stream_xchacha20_KEYBYTES",
inc/util.xs view on Meta::CPAN
OUTPUT:
RETVAL
void sodium_memzero(...)
PREINIT:
unsigned char *arg_buf;
STRLEN arg_len;
int i;
PPCODE:
if (!items)
croak("Missing arguments");
for (i = 0; i < items; i++) {
arg_buf = (unsigned char *)SvPVbyte_force(ST(i), arg_len);
sodium_memzero(arg_buf, arg_len);
}
XSRETURN_EMPTY;
( run in 3.117 seconds using v1.01-cache-2.11-cpan-71847e10f99 )