Crypt-NaCl-Sodium
view release on metacpan or search on metacpan
sodium_add(copy, right_buf, right_len);
RETVAL = newSVpvn((const char * const)copy, left_len);
}
OUTPUT:
RETVAL
CLEANUP:
sodium_free(copy);
void
has_aes128ctr()
PPCODE:
{
#ifdef AES128CTR_IS_AVAILABLE
XSRETURN_YES;
#else
XSRETURN_NO;
#endif
}
void
memcmp(left, right, length = 0)
SV * left
SV * right
unsigned long length
INIT:
unsigned char * left_buf;
unsigned char * right_buf;
STRLEN left_len;
STRLEN right_len;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
left_buf = (unsigned char *)SvPV(left, left_len);
right_buf = (unsigned char *)SvPV(right, right_len);
if ( length == 0 ) {
if ( left_len != right_len ) {
croak("Variables of unequal length cannot be automatically compared. Please provide the length argument");
void
compare(left, right, length = 0)
SV * left
SV * right
unsigned long length
INIT:
unsigned char * left_buf;
unsigned char * right_buf;
STRLEN left_len;
STRLEN right_len;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
left_buf = (unsigned char *)SvPV(left, left_len);
right_buf = (unsigned char *)SvPV(right, right_len);
if ( length == 0 ) {
if ( left_len != right_len ) {
croak("Variables of unequal length cannot be automatically compared. Please provide the length argument");
XSRETURN_IV( sodium_compare(left_buf, right_buf, length) );
}
void
increment(...)
INIT:
unsigned char * number_buf;
STRLEN len;
unsigned int i;
PPCODE:
{
for ( i = 0; i < items; i++ ) {
if (sv_derived_from(ST(i), "Data::BytesLocker")) {
croak("This function does not handle BytesLocker objects");
}
number_buf = (unsigned char *)SvPV(ST(i), len);
sodium_increment(number_buf, len);
}
XSRETURN_EMPTY;
}
void
memzero(...)
INIT:
unsigned char * buf;
STRLEN len;
unsigned int i;
PPCODE:
{
for ( i = 0; i < items; i++ ) {
buf = (unsigned char *)SvPV_force(ST(i), len);
sodium_memzero( buf, len);
}
XSRETURN_YES;
}
SV *
random_number(...)
PROTOTYPE: $$$$
INIT:
STRLEN msg_len;
STRLEN nonce_len;
STRLEN key_len;
STRLEN enc_len;
unsigned char * msg_buf;
unsigned char * nonce_buf;
unsigned char * key_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
nonce_buf = (unsigned char *)SvPV(nonce, nonce_len);
if ( nonce_len != crypto_secretbox_NONCEBYTES ) {
croak("Invalid nonce");
PROTOTYPE: $$$$
INIT:
STRLEN msg_len;
STRLEN nonce_len;
STRLEN key_len;
STRLEN enc_len;
unsigned char * msg_buf;
unsigned char * nonce_buf;
unsigned char * key_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
nonce_buf = (unsigned char *)SvPV(nonce, nonce_len);
if ( nonce_len != crypto_secretbox_NONCEBYTES ) {
croak("Invalid nonce");
INIT:
STRLEN msg_len;
STRLEN nonce_len;
STRLEN key_len;
STRLEN mac_len;
unsigned char * msg_buf;
unsigned char * nonce_buf;
unsigned char * key_buf;
unsigned char * mac_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
nonce_buf = (unsigned char *)SvPV(nonce, nonce_len);
if ( nonce_len != crypto_secretbox_NONCEBYTES ) {
croak("Invalid nonce");
SV * msg
SV * key
PROTOTYPE: $$$$
INIT:
STRLEN msg_len;
STRLEN key_len;
STRLEN mac_len;
unsigned char * msg_buf;
unsigned char * mac_buf;
unsigned char * key_buf;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
mac_buf = (unsigned char *)SvPV(mac, mac_len);
if ( mac_len != crypto_auth_BYTES ) {
croak("Invalid mac");
void
hmacsha256_init(self, key)
SV * self
SV * key
PROTOTYPE: $$
INIT:
STRLEN key_len;
unsigned char * key_buf;
CryptNaClSodiumAuthHmacsha256Stream *stream;
PPCODE:
{
PERL_UNUSED_VAR(self);
key_buf = (unsigned char *)SvPV(key, key_len);
Newx(stream, 1, CryptNaClSodiumAuthHmacsha256Stream);
stream->state = sodium_malloc(sizeof(crypto_auth_hmacsha256_state));
if ( stream->state == NULL ) {
croak("Could not allocate memory");
}
void
hmacsha512_init(self, key)
SV * self
SV * key
PROTOTYPE: $$
INIT:
STRLEN key_len;
unsigned char * key_buf;
CryptNaClSodiumAuthHmacsha512Stream *stream;
PPCODE:
{
PERL_UNUSED_VAR(self);
key_buf = (unsigned char *)SvPV(key, key_len);
Newx(stream, 1, CryptNaClSodiumAuthHmacsha512Stream);
stream->state = sodium_malloc(sizeof(crypto_auth_hmacsha512_state));
if ( stream->state == NULL ) {
croak("Could not allocate memory");
}
void
hmacsha512256_init(self, key)
SV * self
SV * key
PROTOTYPE: $$
INIT:
STRLEN key_len;
unsigned char * key_buf;
CryptNaClSodiumAuthHmacsha512256Stream *stream;
PPCODE:
{
PERL_UNUSED_VAR(self);
key_buf = (unsigned char *)SvPV(key, key_len);
Newx(stream, 1, CryptNaClSodiumAuthHmacsha512256Stream);
stream->state = sodium_malloc(sizeof(crypto_auth_hmacsha512256_state));
if ( stream->state == NULL ) {
croak("Could not allocate memory");
}
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::auth::hmacsha256stream
void
clone(self)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha256Stream* cur_stream = GetAuthHmacsha256Stream(aTHX_ self);
INIT:
CryptNaClSodiumAuthHmacsha256Stream* new_stream;
PPCODE:
{
CLONESTATE(CryptNaClSodiumAuthHmacsha256Stream, auth_hmacsha256, 0, ((void)0))
ST(0) = sv_2mortal(AuthHmacsha256Stream2SV(aTHX_ new_stream));
XSRETURN(1);
}
void
update(self, ...)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha256Stream* stream = GetAuthHmacsha256Stream(aTHX_ self);
INIT:
STRLEN msg_len;
unsigned char * msg_buf;
int i;
PPCODE:
{
for ( i = 1; i < items ; i++ ) {
msg_buf = (unsigned char *)SvPV(ST(i), msg_len);
crypto_auth_hmacsha256_update(stream->state, msg_buf, msg_len);
}
XSRETURN(1);
}
RETVAL = DataBytesLocker2SV(aTHX_ bl);
}
OUTPUT:
RETVAL
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha256Stream* stream = GetAuthHmacsha256Stream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::auth::hmacsha512stream
void
clone(self)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha512Stream* cur_stream = GetAuthHmacsha512Stream(aTHX_ self);
INIT:
CryptNaClSodiumAuthHmacsha512Stream* new_stream;
PPCODE:
{
CLONESTATE(CryptNaClSodiumAuthHmacsha512Stream, auth_hmacsha512, 0, ((void)0))
ST(0) = sv_2mortal(AuthHmacsha512Stream2SV(aTHX_ new_stream));
XSRETURN(1);
}
void
update(self, ...)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha512Stream* stream = GetAuthHmacsha512Stream(aTHX_ self);
INIT:
STRLEN msg_len;
unsigned char * msg_buf;
int i;
PPCODE:
{
for ( i = 1; i < items ; i++ ) {
msg_buf = (unsigned char *)SvPV(ST(i), msg_len);
crypto_auth_hmacsha512_update(stream->state, msg_buf, msg_len);
}
XSRETURN(1);
}
}
OUTPUT:
RETVAL
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha512Stream* stream = GetAuthHmacsha512Stream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::auth::hmacsha512256stream
void
clone(self)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha512256Stream* cur_stream = GetAuthHmacsha512256Stream(aTHX_ self);
INIT:
CryptNaClSodiumAuthHmacsha512256Stream* new_stream;
PPCODE:
{
CLONESTATE(CryptNaClSodiumAuthHmacsha512256Stream, auth_hmacsha512256, 0, ((void)0))
ST(0) = sv_2mortal(AuthHmacsha512256Stream2SV(aTHX_ new_stream));
XSRETURN(1);
}
void
update(self, ...)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha512256Stream* stream = GetAuthHmacsha512256Stream(aTHX_ self);
INIT:
STRLEN msg_len;
unsigned char * msg_buf;
int i;
PPCODE:
{
for ( i = 1; i < items ; i++ ) {
msg_buf = (unsigned char *)SvPV(ST(i), msg_len);
crypto_auth_hmacsha512256_update(stream->state, msg_buf, msg_len);
}
XSRETURN(1);
}
}
OUTPUT:
RETVAL
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha512256Stream* stream = GetAuthHmacsha512256Stream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::aead
PROTOTYPES: DISABLE
CODE:
RETVAL = crypto_aead_chacha20poly1305_ABYTES;
OUTPUT:
RETVAL
PROTOTYPES: ENABLE
void
aes256gcm_is_available(self)
SV * self
PPCODE:
{
if ( crypto_aead_aes256gcm_is_available() ) {
XSRETURN_YES;
}
XSRETURN_NO;
}
SV *
keygen(self)
SV * self
unsigned char * msg_buf;
unsigned char * adata_buf;
unsigned char * nonce_buf;
unsigned char * key_buf;
unsigned int nonce_size;
unsigned int adlen_size;
unsigned int key_size;
int (*encrypt_function)(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 *);
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
switch(ix) {
case 1:
nonce_size = crypto_aead_chacha20poly1305_IETF_NPUBBYTES;
unsigned char * msg_buf;
unsigned char * adata_buf;
unsigned char * nonce_buf;
unsigned char * key_buf;
unsigned int nonce_size;
unsigned int adlen_size;
unsigned int key_size;
int (*decrypt_function)(unsigned char *, unsigned long long *, unsigned char *, const unsigned char *, unsigned long long,
const unsigned char *, unsigned long long, const unsigned char *, const unsigned char *);
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
switch(ix) {
case 1:
nonce_size = crypto_aead_chacha20poly1305_IETF_NPUBBYTES;
aes256gcm_beforenm(self, key)
SV * self
SV * key
PROTOTYPE: $;%
INIT:
STRLEN key_len = 0;
unsigned char * key_buf = NULL;
#if defined(AES256GCM_IS_AVAILABLE)
CryptNaClSodiumAeadAes256gcmState *state;
#endif
PPCODE:
{
PERL_UNUSED_VAR(self);
#if defined(AES256GCM_IS_AVAILABLE)
key_buf = (unsigned char *)SvPV(key, key_len);
if ( key_len != crypto_aead_aes256gcm_KEYBYTES ) {
croak("Invalid key");
}
state = InitAeadAes256gcmState(aTHX_ key_buf);
STRLEN adata_len;
STRLEN nonce_len;
STRLEN enc_len;
unsigned char * msg_buf;
unsigned char * adata_buf;
unsigned char * nonce_buf;
#if defined(AES256GCM_IS_AVAILABLE)
CryptNaClSodiumAeadAes256gcmState * precal_key;
#endif
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
#if defined(AES256GCM_IS_AVAILABLE)
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
nonce_buf = (unsigned char *)SvPV(nonce, nonce_len);
if ( nonce_len != crypto_aead_aes256gcm_NPUBBYTES ) {
STRLEN adata_len;
STRLEN nonce_len;
STRLEN enc_len;
unsigned char * msg_buf;
unsigned char * adata_buf;
unsigned char * nonce_buf;
#if defined(AES256GCM_IS_AVAILABLE)
CryptNaClSodiumAeadAes256gcmState * precal_key;
#endif
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
#if defined(AES256GCM_IS_AVAILABLE)
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
nonce_buf = (unsigned char *)SvPV(nonce, nonce_len);
if ( nonce_len != crypto_aead_aes256gcm_NPUBBYTES ) {
#else
croak("AES256-GCM is not supported by this CPU");
#endif
}
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::aead::aes256gcmstate
void
lock(self)
SV * self
PPCODE:
{
int rc;
#if defined(AES256GCM_IS_AVAILABLE)
CryptNaClSodiumAeadAes256gcmState* state;
state = GetAeadAes256gcmState(aTHX_ self);
rc = sodium_mprotect_noaccess((void *)state->ctx);
if (rc == 0 ) {
croak("Unable to lock memory: %s", Strerror(errno));
#else
croak("AES256-GCM is not supported by this CPU");
#endif
}
void
unlock(self)
SV * self
PPCODE:
{
int rc;
#if defined(AES256GCM_IS_AVAILABLE)
CryptNaClSodiumAeadAes256gcmState* state;
state = GetAeadAes256gcmState(aTHX_ self);
rc = sodium_mprotect_readonly((void *)state->ctx);
if (rc == 0 ) {
}
croak("Unable to unlock memory: %s", Strerror(errno));
#else
croak("AES256-GCM is not supported by this CPU");
#endif
}
void
is_locked(self, ...)
SV * self
PPCODE:
{
#if defined(AES256GCM_IS_AVAILABLE)
CryptNaClSodiumAeadAes256gcmState* state;
state = GetAeadAes256gcmState(aTHX_ self);
if ( state->locked ) {
XSRETURN_YES;
} else {
XSRETURN_NO;
}
#else
croak("AES256-GCM is not supported by this CPU");
#endif
}
void
DESTROY(self)
SV * self
PPCODE:
{
#if defined(AES256GCM_IS_AVAILABLE)
CryptNaClSodiumAeadAes256gcmState* state;
state = GetAeadAes256gcmState(aTHX_ self);
sodium_free( state->ctx );
Safefree(state);
#else
croak("AES256-GCM is not supported by this CPU");
#endif
}
PROTOTYPES: ENABLE
void
keypair(self, ...)
SV * self
PROTOTYPE: $;$
INIT:
DataBytesLocker *blp;
DataBytesLocker *bls;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( items > 2 ) {
croak("Invalid number of arguments");
}
/* from seed */
else if ( items == 2 ) {
if ( SvPOK(ST(1)) || (SvROK(ST(1)) && sv_derived_from(ST(1), "Data::BytesLocker"))) {
STRLEN seed_len;
STRLEN nonce_len;
STRLEN pkey_len;
STRLEN skey_len;
STRLEN enc_len;
unsigned char * msg_buf;
unsigned char * nonce_buf;
unsigned char * pkey_buf;
unsigned char * skey_buf;
DataBytesLocker *bl;
DataBytesLocker *blm;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
nonce_buf = (unsigned char *)SvPV(nonce, nonce_len);
if ( nonce_len != crypto_box_NONCEBYTES ) {
croak("Invalid nonce");
INIT:
STRLEN msg_len;
STRLEN nonce_len;
STRLEN key_len;
STRLEN enc_len;
unsigned char * msg_buf;
unsigned char * nonce_buf;
unsigned char * key_buf;
DataBytesLocker *bl;
DataBytesLocker *blm;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
nonce_buf = (unsigned char *)SvPV(nonce, nonce_len);
if ( nonce_len != crypto_box_NONCEBYTES ) {
croak("Invalid nonce");
PROTOTYPES: ENABLE
void
keypair(self, ...)
SV * self
PROTOTYPE: $;$
INIT:
DataBytesLocker *blp;
DataBytesLocker *bls;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( items > 2 ) {
croak("Invalid number of arguments");
}
/* from seed */
else if ( items == 2 ) {
if ( SvPOK(ST(1)) || (SvROK(ST(1)) && sv_derived_from(ST(1), "Data::BytesLocker"))) {
STRLEN seed_len;
SV * pubkey
SV * seckey
PROTOTYPE: $$$
INIT:
STRLEN pkey_len;
STRLEN skey_len;
unsigned char * pkey_buf;
unsigned char * skey_buf;
DataBytesLocker *blp;
DataBytesLocker *bls;
PPCODE:
{
PERL_UNUSED_VAR(self);
pkey_buf = (unsigned char *)SvPV(pubkey, pkey_len);
if ( pkey_len != crypto_sign_ed25519_PUBLICKEYBYTES ) {
croak("Invalid public key");
}
skey_buf = (unsigned char *)SvPV(seckey, skey_len);
if ( skey_len != crypto_sign_ed25519_SECRETKEYBYTES ) {
void
public_key(self, seckey)
SV * self
SV * seckey
INIT:
STRLEN skey_len;
unsigned char * skey_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
skey_buf = (unsigned char *)SvPV(seckey, skey_len);
if ( skey_len != crypto_sign_SECRETKEYBYTES ) {
croak("Invalid secret key");
}
bl = InitDataBytesLocker(aTHX_ crypto_sign_PUBLICKEYBYTES);
crypto_sign_ed25519_sk_to_pk(bl->bytes, skey_buf);
mXPUSHs( DataBytesLocker2SV(aTHX_ bl) );
}
void
extract_seed(self, seckey)
SV * self
SV * seckey
INIT:
STRLEN skey_len;
unsigned char * skey_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
skey_buf = (unsigned char *)SvPV(seckey, skey_len);
if ( skey_len != crypto_sign_SECRETKEYBYTES ) {
croak("Invalid secret key");
}
bl = InitDataBytesLocker(aTHX_ crypto_sign_SEEDBYTES);
crypto_sign_ed25519_sk_to_seed(bl->bytes, skey_buf);
mXPUSHs( DataBytesLocker2SV(aTHX_ bl) );
XSRETURN(1);
}
void
seed(self)
SV * self
INIT:
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
bl = InitDataBytesLocker(aTHX_ crypto_sign_SEEDBYTES);
randombytes_buf(bl->bytes, bl->length);
mXPUSHs( DataBytesLocker2SV(aTHX_ bl) );
XSRETURN(1);
}
void
SV * msg
SV * seckey
PROTOTYPE: $$$
INIT:
STRLEN msg_len;
STRLEN skey_len;
STRLEN enc_len;
unsigned char * msg_buf;
unsigned char * skey_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
skey_buf = (unsigned char *)SvPV(seckey, skey_len);
if ( skey_len != crypto_sign_SECRETKEYBYTES ) {
croak("Invalid secret key");
SV * self
SV * msg
SV * seckey
PROTOTYPE: $$$
INIT:
STRLEN msg_len;
STRLEN skey_len;
unsigned char * msg_buf;
unsigned char * skey_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
skey_buf = (unsigned char *)SvPV(seckey, skey_len);
if ( skey_len != crypto_sign_SECRETKEYBYTES ) {
croak("Invalid secret key");
SV * msg
SV * pubkey
PROTOTYPE: $$$$
INIT:
STRLEN msg_len;
STRLEN sig_len;
STRLEN pkey_len;
unsigned char * msg_buf;
unsigned char * sig_buf;
unsigned char * pkey_buf;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
sig_buf = (unsigned char *)SvPV(sig, sig_len);
if ( sig_len != crypto_sign_BYTES ) {
croak("Invalid signature");
SV * smsg
SV * pubkey
PROTOTYPE: $$$
INIT:
STRLEN msg_len;
STRLEN pkey_len;
STRLEN enc_len;
unsigned char * msg_buf;
unsigned char * pkey_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
pkey_buf = (unsigned char *)SvPV(pubkey, pkey_len);
if ( pkey_len != crypto_sign_PUBLICKEYBYTES ) {
croak("Invalid public key");
SV * self
SV * msg
PROTOTYPE: $$;%
INIT:
unsigned char * msg_buf;
DataBytesLocker *bl;
unsigned char * key_buf = NULL;
STRLEN msg_len = 0;
STRLEN key_len = 0;
size_t bytes = crypto_generichash_BYTES;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( items > 2 && ( items > 6 || items % 2 != 0 ) ) {
croak("Invalid number of arguments");
} else if ( items > 2 ) {
int i = 0;
STRLEN keylen = 0;
char * key;
void
init(self, ...)
SV * self
PROTOTYPE: $;%
INIT:
STRLEN key_len = 0;
unsigned char * key_buf = NULL;
CryptNaClSodiumGenerichashStream *stream;
size_t bytes = crypto_generichash_BYTES;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( items > 1 && ( items > 5 || (items + 1) % 2 != 0 ) ) {
croak("Invalid number of arguments");
} else if ( items > 1 ) {
int i = 0;
STRLEN keylen = 0;
char * key;
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::generichash::stream
void
clone(self)
SV * self
PREINIT:
CryptNaClSodiumGenerichashStream* cur_stream = GetGenerichashStream(aTHX_ self);
INIT:
CryptNaClSodiumGenerichashStream* new_stream;
PPCODE:
{
CLONESTATE(CryptNaClSodiumGenerichashStream, generichash, (size_t)63U & ~(size_t) 63U, new_stream->init_bytes=cur_stream->init_bytes)
ST(0) = sv_2mortal(GenerichashStream2SV(aTHX_ new_stream));
XSRETURN(1);
}
void
update(self, ...)
SV * self
PREINIT:
CryptNaClSodiumGenerichashStream* stream = GetGenerichashStream(aTHX_ self);
INIT:
STRLEN msg_len;
unsigned char * msg_buf;
int i;
PPCODE:
{
for ( i = 1; i < items ; i++ ) {
msg_buf = (unsigned char *)SvPV(ST(i), msg_len);
crypto_generichash_update(stream->state, msg_buf, msg_len);
}
XSRETURN(1);
}
void
final(self, ...)
SV * self
PROTOTYPE: $%
PREINIT:
CryptNaClSodiumGenerichashStream* stream = GetGenerichashStream(aTHX_ self);
INIT:
DataBytesLocker *bl;
size_t bytes;
PPCODE:
{
bytes = stream->init_bytes;
if ( items > 1 && items != 3 ) {
croak("Invalid number of arguments");
} else if ( items > 1 ) {
int i = 0;
STRLEN keylen = 0;
char * key;
mXPUSHs( DataBytesLocker2SV(aTHX_ bl) );
XSRETURN(1);
}
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumGenerichashStream* stream = GetGenerichashStream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::shorthash
PROTOTYPES: DISABLE
unsigned int
PROTOTYPE: $$$$;%
INIT:
DataBytesLocker *bl;
STRLEN pwd_len = 0;
STRLEN salt_len = 0;
char * pwd_buf;
unsigned char * salt_buf;
unsigned long long outlen = crypto_pwhash_scryptsalsa208sha256_STRBYTES;
unsigned long long opslimit = crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE;
size_t memlimit = crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( items > 3 && ( ( items + 1 ) % 2 != 0 || items > 9 ) ) {
croak("Invalid number of arguments");
} else if ( items > 4 ) {
int i = 0;
STRLEN keylen = 0;
char * key;
str(self, passphrase, ... )
SV * self
SV * passphrase
PROTOTYPE: $$;%
INIT:
DataBytesLocker *bl;
STRLEN pwd_len = 0;
char * pwd_buf;
unsigned long long opslimit = crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE;
size_t memlimit = crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( items > 2 && ( items % 2 != 0 || items > 6 ) ) {
croak("Invalid number of arguments");
} else if ( items > 2 ) {
int i = 0;
STRLEN keylen = 0;
char * key;
sha256(self, msg)
SV * self
SV * msg
PROTOTYPE: $$
ALIAS:
sha512 = 1
INIT:
STRLEN msg_len = 0;
unsigned char * msg_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
msg_buf = (unsigned char *)SvPV(msg, msg_len);
switch(ix) {
case 1:
bl = InitDataBytesLocker(aTHX_ crypto_hash_sha512_BYTES);
crypto_hash_sha512(bl->bytes, msg_buf, msg_len);
break;
mXPUSHs( DataBytesLocker2SV(aTHX_ bl) );
XSRETURN(1);
}
void
sha256_init(self)
SV * self
PROTOTYPE: $
INIT:
CryptNaClSodiumHashSha256Stream *stream;
PPCODE:
{
PERL_UNUSED_VAR(self);
Newx(stream, 1, CryptNaClSodiumHashSha256Stream);
stream->state = sodium_malloc(sizeof(crypto_hash_sha256_state));
if ( stream->state == NULL ) {
croak("Could not allocate memory");
}
crypto_hash_sha256_init(stream->state);
XSRETURN(1);
}
void
sha512_init(self)
SV * self
PROTOTYPE: $
INIT:
CryptNaClSodiumHashSha512Stream *stream;
PPCODE:
{
PERL_UNUSED_VAR(self);
Newx(stream, 1, CryptNaClSodiumHashSha512Stream);
stream->state = sodium_malloc(sizeof(crypto_hash_sha512_state));
if ( stream->state == NULL ) {
croak("Could not allocate memory");
}
crypto_hash_sha512_init(stream->state);
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::hash::sha256stream
void
clone(self)
SV * self
PREINIT:
CryptNaClSodiumHashSha256Stream* cur_stream = GetHashSha256Stream(aTHX_ self);
INIT:
CryptNaClSodiumHashSha256Stream* new_stream;
PPCODE:
{
CLONESTATE(CryptNaClSodiumHashSha256Stream, hash_sha256, 0, ((void)0))
ST(0) = sv_2mortal(HashSha256Stream2SV(aTHX_ new_stream));
XSRETURN(1);
}
void
update(self, ...)
SV * self
PREINIT:
CryptNaClSodiumHashSha256Stream* stream = GetHashSha256Stream(aTHX_ self);
INIT:
STRLEN msg_len;
unsigned char * msg_buf;
int i;
PPCODE:
{
for ( i = 1; i < items ; i++ ) {
msg_buf = (unsigned char *)SvPV(ST(i), msg_len);
crypto_hash_sha256_update(stream->state, msg_buf, msg_len);
}
XSRETURN(1);
}
void
final(self)
SV * self
PROTOTYPE: $
PREINIT:
CryptNaClSodiumHashSha256Stream* stream = GetHashSha256Stream(aTHX_ self);
INIT:
DataBytesLocker *bl;
PPCODE:
{
bl = InitDataBytesLocker(aTHX_ crypto_hash_sha256_BYTES);
crypto_hash_sha256_final(stream->state, bl->bytes);
mXPUSHs( DataBytesLocker2SV(aTHX_ bl) );
XSRETURN(1);
}
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumHashSha256Stream* stream = GetHashSha256Stream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::hash::sha512stream
void
clone(self)
SV * self
PREINIT:
CryptNaClSodiumHashSha512Stream* cur_stream = GetHashSha512Stream(aTHX_ self);
INIT:
CryptNaClSodiumHashSha512Stream* new_stream;
PPCODE:
{
CLONESTATE(CryptNaClSodiumHashSha512Stream, hash_sha512, 0, ((void)0))
ST(0) = sv_2mortal(HashSha512Stream2SV(aTHX_ new_stream));
XSRETURN(1);
}
void
update(self, ...)
SV * self
PREINIT:
CryptNaClSodiumHashSha512Stream* stream = GetHashSha512Stream(aTHX_ self);
INIT:
STRLEN msg_len;
unsigned char * msg_buf;
int i;
PPCODE:
{
for ( i = 1; i < items ; i++ ) {
msg_buf = (unsigned char *)SvPV(ST(i), msg_len);
crypto_hash_sha512_update(stream->state, msg_buf, msg_len);
}
XSRETURN(1);
}
void
final(self)
SV * self
PROTOTYPE: $
PREINIT:
CryptNaClSodiumHashSha512Stream* stream = GetHashSha512Stream(aTHX_ self);
INIT:
DataBytesLocker *bl;
PPCODE:
{
bl = InitDataBytesLocker(aTHX_ crypto_hash_sha512_BYTES);
crypto_hash_sha512_final(stream->state, bl->bytes);
mXPUSHs( DataBytesLocker2SV(aTHX_ bl) );
XSRETURN(1);
}
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumHashSha512Stream* stream = GetHashSha512Stream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::onetimeauth
PROTOTYPES: DISABLE
SV * self
SV * msg
SV * key
PROTOTYPE: $$$
INIT:
STRLEN msg_len;
STRLEN key_len;
unsigned char * msg_buf;
unsigned char * key_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
key_buf = (unsigned char *)SvPV(key, key_len);
if ( key_len != crypto_onetimeauth_KEYBYTES ) {
croak("Invalid key");
}
msg_buf = (unsigned char *)SvPV(msg, msg_len);
SV * msg
SV * key
PROTOTYPE: $$$$
INIT:
STRLEN msg_len;
STRLEN key_len;
STRLEN mac_len;
unsigned char * msg_buf;
unsigned char * mac_buf;
unsigned char * key_buf;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
mac_buf = (unsigned char *)SvPV(mac, mac_len);
if ( mac_len != crypto_onetimeauth_BYTES ) {
croak("Invalid mac");
void
init(self, key)
SV * self
SV * key
PROTOTYPE: $;%
INIT:
STRLEN key_len;
unsigned char * key_buf;
CryptNaClSodiumOnetimeauthStream *stream;
PPCODE:
{
PERL_UNUSED_VAR(self);
key_buf = (unsigned char *)SvPV(key, key_len);
if ( key_len != crypto_onetimeauth_KEYBYTES ) {
croak("Invalid key");
}
Newx(stream, 1, CryptNaClSodiumOnetimeauthStream);
stream->state = sodium_malloc(sizeof(crypto_onetimeauth_state));
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::onetimeauth::stream
void
clone(self)
SV * self
PREINIT:
CryptNaClSodiumOnetimeauthStream* cur_stream = GetOnetimeauthStream(aTHX_ self);
INIT:
CryptNaClSodiumOnetimeauthStream* new_stream;
PPCODE:
{
CLONESTATE(CryptNaClSodiumOnetimeauthStream, onetimeauth, 0, ((void)0))
ST(0) = sv_2mortal(OnetimeauthStream2SV(aTHX_ new_stream));
XSRETURN(1);
}
void
update(self, ...)
SV * self
PREINIT:
CryptNaClSodiumOnetimeauthStream* stream = GetOnetimeauthStream(aTHX_ self);
INIT:
STRLEN msg_len;
unsigned char * msg_buf;
int i;
PPCODE:
{
for ( i = 1; i < items ; i++ ) {
msg_buf = (unsigned char *)SvPV(ST(i), msg_len);
crypto_onetimeauth_update(stream->state, msg_buf, msg_len);
}
XSRETURN(1);
}
void
final(self)
SV * self
PROTOTYPE: $
PREINIT:
CryptNaClSodiumOnetimeauthStream* stream = GetOnetimeauthStream(aTHX_ self);
INIT:
DataBytesLocker *bl;
PPCODE:
{
bl = InitDataBytesLocker(aTHX_ crypto_onetimeauth_BYTES);
crypto_onetimeauth_final(stream->state, bl->bytes);
mXPUSHs( DataBytesLocker2SV(aTHX_ bl) );
XSRETURN(1);
}
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumOnetimeauthStream* stream = GetOnetimeauthStream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
MODULE = Crypt::NaCl::Sodium PACKAGE = Crypt::NaCl::Sodium::scalarmult
PROTOTYPES: DISABLE
void
base(self, secret_key)
SV * self
SV * secret_key
PROTOTYPE: $$
INIT:
STRLEN key_len;
unsigned char * key_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
key_buf = (unsigned char *)SvPV(secret_key, key_len);
if ( key_len != crypto_scalarmult_SCALARBYTES ) {
croak("Invalid key");
SV * secret_key
SV * public_key
PROTOTYPE: $$$$
INIT:
STRLEN skey_len;
STRLEN pkey_len;
unsigned char * skey_buf;
unsigned char * pkey_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
skey_buf = (unsigned char *)SvPV(secret_key, skey_len);
if ( skey_len != crypto_scalarmult_SCALARBYTES ) {
croak("Invalid secret key");
INIT:
STRLEN nonce_len;
STRLEN key_len;
unsigned char * nonce_buf;
unsigned char * key_buf;
unsigned int nonce_size;
unsigned int key_size;
unsigned int bytes_len;
int (*bytes_function)(unsigned char *, unsigned long long, const unsigned char *, const unsigned char *);
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
switch(ix) {
case 1:
nonce_size = crypto_stream_chacha20_NONCEBYTES;
STRLEN msg_len;
STRLEN nonce_len;
STRLEN key_len;
unsigned char * msg_buf;
unsigned char * nonce_buf;
unsigned char * key_buf;
unsigned int nonce_size;
unsigned int key_size;
int (*xor_function)(unsigned char *, const unsigned char *, unsigned long long, const unsigned char *, const unsigned char *);
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
switch(ix) {
case 1:
nonce_size = crypto_stream_chacha20_NONCEBYTES;
STRLEN nonce_len;
unsigned int bc;
STRLEN key_len;
unsigned char * msg_buf;
unsigned char * nonce_buf;
unsigned char * key_buf;
unsigned int nonce_size;
unsigned int key_size;
int (*xor_ic_function)(unsigned char *, const unsigned char *, unsigned long long, const unsigned char *, uint64_t, const unsigned char *);
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
switch(ix) {
case 1:
nonce_size = crypto_stream_chacha20_NONCEBYTES;
SV * key
INIT:
STRLEN msg_len;
STRLEN nonce_len;
unsigned int bc;
STRLEN key_len;
unsigned char * msg_buf;
unsigned char * nonce_buf;
unsigned char * key_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
bc = SvUV(ic);
nonce_buf = (unsigned char *)SvPV(nonce, nonce_len);
RETVAL
void
_overload_bool(self, ...)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
int res;
OVERLOAD: bool
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
if ( sbl->length ) {
res = 1;
} else {
res = 0;
}
void
_overload_not(self, ...)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
int res;
OVERLOAD: !
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
if ( sbl->length ) {
res = 0;
} else {
res = 1;
SV * self
SV * other
SV * swapped
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
unsigned char *buf;
STRLEN buf_len;
int res;
OVERLOAD: eq
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
buf = (unsigned char *)SvPV(other, buf_len);
if ( sbl->length != buf_len ) {
croak("Variables of unequal length cannot be automatically compared. Please use memcmp() with the length argument provided");
}
SV * self
SV * other
SV * swapped
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
unsigned char *buf;
STRLEN buf_len;
int res;
OVERLOAD: ne
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
buf = (unsigned char *)SvPV(other, buf_len);
if ( sbl->length != buf_len ) {
croak("Variables of unequal length cannot be automatically compared. Please use memcmp() with the length argument provided");
}
}
void
_overload_str(self, ...)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
SV * pv;
OVERLOAD: \"\"
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
pv = newSVpvn((unsigned char *)sbl->bytes, sbl->length);
SvREADONLY_on(pv);
mXPUSHs(pv);
}
void
_overload_nomethod(self, ...)
SV * self
OVERLOAD: nomethod
INIT:
char * operator;
PPCODE:
{
operator = SvPV_nolen(ST(3));
croak("Operation \"%s\" is not supported", operator);
}
SV *
clone(self)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
OUTPUT:
RETVAL
void
lock(self)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
int rc;
PPCODE:
{
rc = sodium_mprotect_noaccess((void *)sbl->bytes);
if (rc == 0 ) {
sbl->locked = 1;
XSRETURN_YES;
}
croak("Unable to lock memory: %s", Strerror(errno));
}
void
unlock(self)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
int rc;
PPCODE:
{
rc = sodium_mprotect_readonly((void *)sbl->bytes);
if (rc == 0 ) {
sbl->locked = 0;
XSRETURN_YES;
}
croak("Unable to unlock memory: %s", Strerror(errno));
}
RETVAL = newSVuv((UV)sbl->length);
}
OUTPUT:
RETVAL
void
is_locked(self, ...)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
PPCODE:
{
if ( sbl->locked ) {
XSRETURN_YES;
} else {
XSRETURN_NO;
}
}
SV *
to_hex(self)
CLEANUP:
sodium_free(hex);
void
bytes(self)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
SV * pv;
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
pv = newSVpvn((unsigned char *)sbl->bytes, sbl->length);
mXPUSHs(pv);
}
void
memcmp(self, bytes, length = 0)
SV * self
SV * bytes
unsigned long length
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
unsigned char * bytes_buf;
STRLEN bytes_len;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
if (sv_derived_from(bytes, "Data::BytesLocker")) {
void
compare(self, num, length = 0)
SV * self
SV * num
unsigned long length
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
unsigned char * num_buf;
STRLEN num_len;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
if (sv_derived_from(num, "Data::BytesLocker")) {
}
void
increment(self)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
SV * pv;
DataBytesLocker *bl;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
bl = InitDataBytesLocker(aTHX_ sbl->length);
add(self, num, ...)
SV * self
SV * num
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
unsigned char * num_buf;
STRLEN num_len;
STRLEN inc_len;
DataBytesLocker *bl;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
if (sv_derived_from(num, "Data::BytesLocker")) {
XSRETURN(1);
}
void
is_zero(self, ...)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
SV * pv;
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
if ( sodium_is_zero(sbl->bytes, sbl->length) == 1 ) {
XSRETURN_YES;
}
XSRETURN_NO;
}
void
DESTROY(self)
SV * self
PREINIT:
DataBytesLocker* bl = GetBytesLocker(aTHX_ self);
PPCODE:
{
sodium_free( bl->bytes );
Safefree(bl);
}
( run in 1.790 second using v1.01-cache-2.11-cpan-71847e10f99 )