CryptX
view release on metacpan or search on metacpan
inc/CryptX_AuthEnc_CCM.xs.inc view on Meta::CPAN
SvREFCNT_dec(RETVAL);
croak("FATAL: ccm_process failed: %s", error_to_string(rv));
}
}
}
OUTPUT:
RETVAL
void
encrypt_done(Crypt::AuthEnc::CCM self)
PPCODE:
{
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = MAXBLOCKSIZE;
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = ccm_done(&self->state, tag, &tag_len);
if (rv != CRYPT_OK) croak("FATAL: ccm_done failed: %s", error_to_string(rv));
self->finalized = 1;
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
zeromem(tag, sizeof(tag));
}
void
decrypt_done(Crypt::AuthEnc::CCM self, ...)
PPCODE:
{
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = MAXBLOCKSIZE;
STRLEN expected_tag_len;
unsigned char *expected_tag;
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = ccm_done(&self->state, tag, &tag_len);
if (rv != CRYPT_OK) croak("FATAL: ccm_done failed: %s", error_to_string(rv));
inc/CryptX_AuthEnc_CCM.xs.inc view on Meta::CPAN
XPUSHs(sv_2mortal(newSViv(0))); /* false */
}
else {
XPUSHs(sv_2mortal(newSViv(1))); /* true */
}
}
}
void
ccm_encrypt_authenticate(char *cipher_name, SV *key, SV *nonce, SV *header, unsigned long tag_len, SV *plaintext)
PPCODE:
{
STRLEN k_len = 0, n_len = 0, h_len = 0, pt_len = 0;
unsigned char *k = NULL, *n = NULL, *h = NULL, *pt = NULL;
int rv, id;
unsigned char tag[MAXBLOCKSIZE];
SV *output;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
if (!SvPOK_spec(nonce)) croak("FATAL: nonce must be string/buffer scalar");
inc/CryptX_AuthEnc_CCM.xs.inc view on Meta::CPAN
if (rv != CRYPT_OK) {
SvREFCNT_dec(output);
croak("FATAL: ccm_memory failed: %s", error_to_string(rv));
}
XPUSHs(sv_2mortal(output));
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
}
void
ccm_decrypt_verify(char *cipher_name, SV *key, SV *nonce, SV *header, SV *ciphertext, SV *tagsv)
PPCODE:
{
STRLEN k_len = 0, n_len = 0, h_len = 0, ct_len = 0, t_len = 0;
unsigned char *k = NULL, *n = NULL, *h = NULL, *ct = NULL, *t = NULL;
int rv, id;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len;
SV *output;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_AuthEnc_ChaCha20Poly1305.xs.inc view on Meta::CPAN
clone(Crypt::AuthEnc::ChaCha20Poly1305 self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_authenc_chacha20poly1305_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_authenc_chacha20poly1305_struct);
OUTPUT:
RETVAL
void
set_iv(Crypt::AuthEnc::ChaCha20Poly1305 self, SV * nonce)
PPCODE:
{
int rv;
STRLEN iv_len=0;
unsigned char *iv=NULL;
if (!SvPOK_spec(nonce)) croak("FATAL: nonce must be string/buffer scalar");
iv = (unsigned char *) SvPVbyte(nonce, iv_len);
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = chacha20poly1305_setiv(&self->state, iv, (unsigned long)iv_len);
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_setiv failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */;
}
void
set_iv_rfc7905(Crypt::AuthEnc::ChaCha20Poly1305 self, SV * nonce, UV seqnum)
PPCODE:
{
int rv;
STRLEN iv_len=0;
unsigned char *iv=NULL;
if (!SvPOK_spec(nonce)) croak("FATAL: nonce must be string/buffer scalar");
iv = (unsigned char *) SvPVbyte(nonce, iv_len);
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = chacha20poly1305_setiv_rfc7905(&self->state, iv, (unsigned long)iv_len, (ulong64)seqnum);
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_setiv_rfc7905 failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
adata_add(Crypt::AuthEnc::ChaCha20Poly1305 self, SV * data)
PPCODE:
{
int rv;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: AEAD object already finalized");
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
rv = chacha20poly1305_add_aad(&self->state, in_data, (unsigned long)in_data_len);
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_add_aad failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
inc/CryptX_AuthEnc_ChaCha20Poly1305.xs.inc view on Meta::CPAN
SvREFCNT_dec(RETVAL);
croak("FATAL: chacha20poly1305_encrypt failed: %s", error_to_string(rv));
}
}
}
OUTPUT:
RETVAL
void
encrypt_done(Crypt::AuthEnc::ChaCha20Poly1305 self)
PPCODE:
{
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = chacha20poly1305_done(&self->state, tag, &tag_len);
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_done failed: %s", error_to_string(rv));
self->finalized = 1;
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
zeromem(tag, sizeof(tag));
}
void
decrypt_done(Crypt::AuthEnc::ChaCha20Poly1305 self, ...)
PPCODE:
{
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
STRLEN expected_tag_len;
unsigned char *expected_tag;
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = chacha20poly1305_done(&self->state, tag, &tag_len);
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_done failed: %s", error_to_string(rv));
inc/CryptX_AuthEnc_ChaCha20Poly1305.xs.inc view on Meta::CPAN
XPUSHs(sv_2mortal(newSViv(0))); /* false */
}
else {
XPUSHs(sv_2mortal(newSViv(1))); /* true */
}
}
}
void
chacha20poly1305_encrypt_authenticate(SV *key, SV *nonce, SV *header, SV *plaintext)
PPCODE:
{
STRLEN k_len = 0, n_len = 0, h_len = 0, pt_len = 0;
unsigned char *k = NULL, *n = NULL, *h = NULL, *pt = NULL;
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
SV *output;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_AuthEnc_ChaCha20Poly1305.xs.inc view on Meta::CPAN
if (rv != CRYPT_OK) {
SvREFCNT_dec(output);
croak("FATAL: chacha20poly1305_memory failed: %s", error_to_string(rv));
}
XPUSHs(sv_2mortal(output));
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
}
void
chacha20poly1305_decrypt_verify(SV *key, SV *nonce, SV *header, SV *ciphertext, SV *tagsv)
PPCODE:
{
STRLEN k_len = 0, n_len = 0, h_len = 0, ct_len = 0, t_len = 0;
unsigned char *k = NULL, *n = NULL, *h = NULL, *ct = NULL, *t = NULL;
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len;
SV *output;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_AuthEnc_EAX.xs.inc view on Meta::CPAN
SvREFCNT_dec(RETVAL);
croak("FATAL: eax_decrypt failed: %s", error_to_string(rv));
}
}
}
OUTPUT:
RETVAL
void
encrypt_done(Crypt::AuthEnc::EAX self)
PPCODE:
{
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = eax_done(&self->state, tag, &tag_len);
if (rv != CRYPT_OK) croak("FATAL: eax_done failed: %s", error_to_string(rv));
self->finalized = 1;
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
zeromem(tag, sizeof(tag));
}
void
decrypt_done(Crypt::AuthEnc::EAX self, ...)
PPCODE:
{
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
STRLEN expected_tag_len;
unsigned char *expected_tag;
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = eax_done(&self->state, tag, &tag_len);
if (rv != CRYPT_OK) croak("FATAL: eax_done failed: %s", error_to_string(rv));
inc/CryptX_AuthEnc_EAX.xs.inc view on Meta::CPAN
XPUSHs(sv_2mortal(newSViv(0))); /* false */
}
else {
XPUSHs(sv_2mortal(newSViv(1))); /* true */
}
}
}
void
adata_add(Crypt::AuthEnc::EAX self, SV * adata)
PPCODE:
{
STRLEN h_len;
int rv;
unsigned char *h;
if (self->finalized) croak("FATAL: AEAD object already finalized");
h = (unsigned char *)SvPVbyte(adata, h_len);
rv = eax_addheader(&self->state, h, (unsigned long)h_len);
if (rv != CRYPT_OK) croak("FATAL: eax_addheader failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
eax_encrypt_authenticate(char *cipher_name, SV *key, SV *nonce, SV *header, SV *plaintext)
PPCODE:
{
STRLEN k_len = 0, n_len = 0, h_len = 0, pt_len = 0;
unsigned char *k = NULL, *n = NULL, *h = NULL, *pt = NULL;
int rv, id;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
SV *output;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_AuthEnc_EAX.xs.inc view on Meta::CPAN
if (rv != CRYPT_OK) {
SvREFCNT_dec(output);
croak("FATAL: eax_encrypt_authenticate_memory failed: %s", error_to_string(rv));
}
XPUSHs(sv_2mortal(output));
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
}
void
eax_decrypt_verify(char *cipher_name, SV *key, SV *nonce, SV *header, SV *ciphertext, SV *tagsv)
PPCODE:
{
STRLEN k_len = 0, n_len = 0, h_len = 0, ct_len = 0, t_len = 0;
unsigned char *k = NULL, *n = NULL, *h = NULL, *ct = NULL, *t = NULL;
int rv, id, stat = 0;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len;
SV *output;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_AuthEnc_GCM.xs.inc view on Meta::CPAN
clone(Crypt::AuthEnc::GCM self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_authenc_gcm_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_authenc_gcm_struct);
OUTPUT:
RETVAL
void
reset(Crypt::AuthEnc::GCM self)
PPCODE:
{
int rv;
rv = gcm_reset(&self->state);
if (rv != CRYPT_OK) croak("FATAL: gcm_reset failed: %s", error_to_string(rv));
self->finalized = 0;
XPUSHs(ST(0)); /* return self */
}
SV *
encrypt_add(Crypt::AuthEnc::GCM self, SV * data)
inc/CryptX_AuthEnc_GCM.xs.inc view on Meta::CPAN
SvREFCNT_dec(RETVAL);
croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv));
}
}
}
OUTPUT:
RETVAL
void
iv_add(Crypt::AuthEnc::GCM self, SV * data)
PPCODE:
{
int rv;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: AEAD object already finalized");
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
rv = gcm_add_iv(&self->state, in_data, (unsigned long)in_data_len);
if (rv != CRYPT_OK) croak("FATAL: gcm_add_iv failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
adata_add(Crypt::AuthEnc::GCM self, SV * data)
PPCODE:
{
int rv;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: AEAD object already finalized");
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
rv = gcm_add_aad(&self->state, in_data, (unsigned long)in_data_len);
if (rv != CRYPT_OK) croak("FATAL: gcm_add_aad failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
inc/CryptX_AuthEnc_GCM.xs.inc view on Meta::CPAN
croak("FATAL: decrypt_add/gcm_process failed: %s", error_to_string(rv));
}
}
}
OUTPUT:
RETVAL
void
encrypt_done(Crypt::AuthEnc::GCM self)
PPCODE:
{
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = gcm_done(&self->state, tag, &tag_len);
if (rv != CRYPT_OK) croak("FATAL: gcm_done failed: %s", error_to_string(rv));
self->finalized = 1;
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
zeromem(tag, sizeof(tag));
}
void
decrypt_done(Crypt::AuthEnc::GCM self, ...)
PPCODE:
{
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
STRLEN expected_tag_len;
unsigned char *expected_tag;
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = gcm_done(&self->state, tag, &tag_len);
if (rv != CRYPT_OK) croak("FATAL: gcm_done failed: %s", error_to_string(rv));
inc/CryptX_AuthEnc_GCM.xs.inc view on Meta::CPAN
XPUSHs(sv_2mortal(newSViv(0))); /* false */
}
else {
XPUSHs(sv_2mortal(newSViv(1))); /* true */
}
}
}
void
gcm_encrypt_authenticate(char *cipher_name, SV *key, SV *nonce, SV *header = NULL, SV *plaintext)
PPCODE:
{
STRLEN k_len = 0, n_len = 0, h_len = 0, pt_len = 0;
unsigned char *k = NULL, *n = NULL, *h = NULL, *pt = NULL;
int rv, id;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
SV *output;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_AuthEnc_GCM.xs.inc view on Meta::CPAN
if (rv != CRYPT_OK) {
SvREFCNT_dec(output);
croak("FATAL: gcm_memory failed: %s", error_to_string(rv));
}
XPUSHs(sv_2mortal(output));
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
}
void
gcm_decrypt_verify(char *cipher_name, SV *key, SV *nonce, SV *header, SV *ciphertext, SV *tagsv)
PPCODE:
{
STRLEN k_len = 0, n_len = 0, h_len = 0, ct_len = 0, t_len = 0;
unsigned char *k = NULL, *n = NULL, *h = NULL, *ct = NULL, *t = NULL;
int rv, id;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len;
SV *output;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_AuthEnc_OCB.xs.inc view on Meta::CPAN
clone(Crypt::AuthEnc::OCB self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_authenc_ocb_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_authenc_ocb_struct);
OUTPUT:
RETVAL
void
adata_add(Crypt::AuthEnc::OCB self, SV * data)
PPCODE:
{
int rv;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: AEAD object already finalized");
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
if (in_data_len>0) {
rv = ocb3_add_aad(&self->state, in_data, (unsigned long)in_data_len);
inc/CryptX_AuthEnc_OCB.xs.inc view on Meta::CPAN
SvREFCNT_dec(RETVAL);
croak("FATAL: ocb3_decrypt_last failed: %s", error_to_string(rv));
}
}
}
OUTPUT:
RETVAL
void
encrypt_done(Crypt::AuthEnc::OCB self)
PPCODE:
{
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = ocb3_done(&self->state, tag, &tag_len);
if (rv != CRYPT_OK) croak("FATAL: ocb3_done_encrypt failed: %s", error_to_string(rv));
self->finalized = 1;
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
zeromem(tag, sizeof(tag));
}
void
decrypt_done(Crypt::AuthEnc::OCB self, ...)
PPCODE:
{
int rv;
unsigned char tag[MAXBLOCKSIZE];
unsigned long tag_len = sizeof(tag);
STRLEN expected_tag_len;
unsigned char *expected_tag;
if (self->finalized) croak("FATAL: AEAD object already finalized");
rv = ocb3_done(&self->state, tag, &tag_len);
if (rv != CRYPT_OK) croak("FATAL: ocb3_done_decrypt failed: %s", error_to_string(rv));
inc/CryptX_AuthEnc_OCB.xs.inc view on Meta::CPAN
XPUSHs(sv_2mortal(newSViv(0))); /* false */
}
else {
XPUSHs(sv_2mortal(newSViv(1))); /* true */
}
}
}
void
ocb_encrypt_authenticate(char *cipher_name, SV *key, SV *nonce, SV *header, unsigned long tag_len, SV *plaintext)
PPCODE:
{
STRLEN k_len = 0, n_len = 0, h_len = 0, pt_len = 0;
unsigned char *k = NULL, *n = NULL, *h = NULL, *pt = NULL;
int rv, id;
unsigned char tag[MAXBLOCKSIZE];
SV *output;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
if (!SvPOK_spec(nonce)) croak("FATAL: nonce must be string/buffer scalar");
inc/CryptX_AuthEnc_OCB.xs.inc view on Meta::CPAN
if (rv != CRYPT_OK) {
SvREFCNT_dec(output);
croak("FATAL: ocb3_encrypt_authenticate_memory failed: %s", error_to_string(rv));
}
XPUSHs(sv_2mortal(output));
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
}
void
ocb_decrypt_verify(char *cipher_name, SV *key, SV *nonce, SV *header, SV *ciphertext, SV *tagsv)
PPCODE:
{
STRLEN k_len = 0, n_len = 0, h_len = 0, ct_len = 0, t_len = 0;
unsigned char *k = NULL, *n = NULL, *h = NULL, *ct = NULL, *t = NULL;
int rv, id, stat = 0;
SV *output;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
if (!SvPOK_spec(nonce)) croak("FATAL: nonce must be string/buffer scalar");
n = (unsigned char *) SvPVbyte(nonce, n_len);
inc/CryptX_AuthEnc_SIV.xs.inc view on Meta::CPAN
SvREFCNT_dec(RETVAL);
croak("FATAL: siv_encrypt_memory failed: %s", error_to_string(rv));
}
SvCUR_set(RETVAL, ct_len);
}
OUTPUT:
RETVAL
void
siv_decrypt_verify(char *cipher_name, SV *key, SV *ciphertext, SV *aad = &PL_sv_undef)
PPCODE:
{
STRLEN k_len = 0, ct_len = 0;
unsigned char *k, *ct, *pt;
unsigned long pt_len;
int rv, id;
SV *output;
const unsigned char *ad_ptrs[126];
unsigned long ad_lens[126];
unsigned long n_ad = 0;
STRLEN tmp;
inc/CryptX_BigInt_LTM.xs.inc view on Meta::CPAN
merr = mp_expt_n(RETVAL, x, RETVAL);
PERL_UNUSED_VAR(merr);
OUTPUT:
RETVAL
##############################################################################
# DESTROY() - free memory of a GMP number
void
DESTROY(Math::BigInt::LTM n)
PPCODE:
if (n) {
mp_clear(n);
Safefree(n);
}
##############################################################################
# _str() - return string so that atof() and atoi() can use it
SV *
_str(Class, Math::BigInt::LTM n)
inc/CryptX_BigInt_LTM.xs.inc view on Meta::CPAN
##############################################################################
# _modinv() - compute the inverse of x % y
void
_modinv(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
int rc;
SV* s;
mp_int* RETVAL;
PPCODE:
Newz(0, RETVAL, 1, mp_int);
merr = mp_init(RETVAL);
rc = mp_invmod(x, y, RETVAL);
EXTEND(SP, 2); /* we return two values */
if (rc != MP_OKAY) {
/* Inverse doesn't exist. Return both values undefined. */
PUSHs(&PL_sv_undef);
PUSHs(&PL_sv_undef);
}
else {
inc/CryptX_BigInt_LTM.xs.inc view on Meta::CPAN
}
PERL_UNUSED_VAR(merr);
##############################################################################
# _add() - add $y to $x in place
void
_add(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_add(x, y, x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _inc() - modify x inline by doing x++
void
_inc(Class, Math::BigInt::LTM x)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_add_d(x, 1, x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _dec() - modify x inline by doing x--
void
_dec(Class, Math::BigInt::LTM x)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_sub_d(x, 1, x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _sub() - $x - $y
# $x is always larger than $y! So overflow/underflow can not happen here.
void
_sub(Class, Math::BigInt::LTM x, Math::BigInt::LTM y, ...)
PREINIT:
mp_err merr;
PPCODE:
if ( items == 4 && SvTRUE(ST(3)) ) {
/* y -= x */
merr = mp_sub(x, y, y);
XPUSHs(ST(2)); /* y */
}
else {
/* x -= y */
merr = mp_sub(x, y, x);
XPUSHs(ST(1)); /* x */
}
PERL_UNUSED_VAR(merr);
##############################################################################
# _rsft()
void
_rsft(Class, Math::BigInt::LTM x, Math::BigInt::LTM y, unsigned long base_int)
PREINIT:
mp_err merr;
mp_int* BASE;
PPCODE:
Newz(0, BASE, 1, mp_int);
merr = mp_init(BASE);
mp_set_ul(BASE, base_int);
merr = mp_expt_n(BASE, mp_get_l(y), BASE);
merr = mp_div(x, BASE, x, NULL);
PERL_UNUSED_VAR(merr);
mp_clear(BASE);
Safefree(BASE);
XPUSHs(ST(1)); /* x */
##############################################################################
# _lsft()
void
_lsft(Class, Math::BigInt::LTM x, Math::BigInt::LTM y, unsigned long base_int)
PREINIT:
mp_err merr;
mp_int* BASE;
PPCODE:
Newz(0, BASE, 1, mp_int);
merr = mp_init(BASE);
mp_set_ul(BASE, base_int);
merr = mp_expt_n(BASE, mp_get_l(y), BASE);
merr = mp_mul(x, BASE, x);
PERL_UNUSED_VAR(merr);
mp_clear(BASE);
Safefree(BASE);
XPUSHs(ST(1)); /* x */
##############################################################################
# _mul()
void
_mul(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_mul(x, y, x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _div(): x /= y or (x,rem) = x / y
void
_div(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
mp_int * rem;
PPCODE:
if (GIMME_V == G_ARRAY) {
Newz(0, rem, 1, mp_int);
merr = mp_init(rem);
merr = mp_div(x, y, x, rem);
EXTEND(SP, 2);
PUSHs(ST(1)); /* x */
PUSHs(sv_2mortal(sv_from_mpi(rem)));
}
else {
merr = mp_div(x, y, x, NULL);
inc/CryptX_BigInt_LTM.xs.inc view on Meta::CPAN
}
PERL_UNUSED_VAR(merr);
##############################################################################
# _mod() - x %= y
void
_mod(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_mod(x, y, x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _acmp() - cmp two numbers
int
_acmp(Class, Math::BigInt::LTM m, Math::BigInt::LTM n)
CODE:
inc/CryptX_BigInt_LTM.xs.inc view on Meta::CPAN
OUTPUT:
RETVAL
##############################################################################
# _pow() - x **= y
void
_pow(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_expt_n(x, mp_get_l(y), x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _gcd() - gcd(m,n)
Math::BigInt::LTM
_gcd(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
inc/CryptX_BigInt_LTM.xs.inc view on Meta::CPAN
OUTPUT:
RETVAL
##############################################################################
# _and() - m &= n
void
_and(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_and(x, y, x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _xor() - m =^ n
void
_xor(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_xor(x, y, x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _or() - m =| n
void
_or(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_or(x, y, x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _copy()
Math::BigInt::LTM
_copy(Class, Math::BigInt::LTM m)
PREINIT:
inc/CryptX_BigInt_LTM.xs.inc view on Meta::CPAN
OUTPUT:
RETVAL
##############################################################################
# _sqrt() - square root
void
_sqrt(Class, Math::BigInt::LTM x)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_sqrt(x, x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _root() - integer roots
void
_root(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_root_n(x, mp_get_l(y), x);
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# _lcm() - least common multiple
void
_lcm(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
PREINIT:
mp_err merr;
PPCODE:
merr = mp_lcm(x, y, x) ;
PERL_UNUSED_VAR(merr);
XPUSHs(ST(1)); /* x */
##############################################################################
# Storable hooks
void
STORABLE_thaw(blank_obj, cloning, serialized, ...)
SV *blank_obj
SV *cloning = NO_INIT
SV *serialized
PREINIT:
mp_err merr;
SV *target;
mp_int *mpi;
PPCODE:
PERL_UNUSED_VAR(cloning);
if (SvROK(blank_obj) && sv_isa(blank_obj, "Math::BigInt::LTM")) {
Newz(0, mpi, 1, mp_int);
merr = mp_init(mpi);
merr = mp_read_radix(mpi, SvPV_nolen(serialized), 10);
PERL_UNUSED_VAR(merr);
target = SvRV(blank_obj);
SvIV_set(target, PTR2IV(mpi));
SvIOK_on(target);
PUSHs(target);
inc/CryptX_Checksum_Adler32.xs.inc view on Meta::CPAN
OUTPUT:
RETVAL
void
DESTROY(Crypt::Checksum::Adler32 self)
CODE:
Safefree(self);
void
reset(Crypt::Checksum::Adler32 self)
PPCODE:
{
adler32_init(self); /* returns void */
XPUSHs(ST(0)); /* return self */
}
Crypt::Checksum::Adler32
clone(Crypt::Checksum::Adler32 self)
CODE:
Newz(0, RETVAL, 1, adler32_state);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, adler32_state);
OUTPUT:
RETVAL
void
add(Crypt::Checksum::Adler32 self, ...)
PPCODE:
{
STRLEN inlen;
int i;
unsigned char *in;
for(i=1; i<items; i++) {
in = (unsigned char *)SvPVbyte(ST(i), inlen);
if (inlen > 0) {
adler32_update(self, in, (unsigned long)inlen); /* returns void */
}
}
inc/CryptX_Checksum_CRC32.xs.inc view on Meta::CPAN
OUTPUT:
RETVAL
void
DESTROY(Crypt::Checksum::CRC32 self)
CODE:
Safefree(self);
void
reset(Crypt::Checksum::CRC32 self)
PPCODE:
{
crc32_init(self); /* returns void */
XPUSHs(ST(0)); /* return self */
}
Crypt::Checksum::CRC32
clone(Crypt::Checksum::CRC32 self)
CODE:
Newz(0, RETVAL, 1, crc32_state);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, crc32_state);
OUTPUT:
RETVAL
void
add(Crypt::Checksum::CRC32 self, ...)
PPCODE:
{
STRLEN inlen;
int i;
unsigned char *in;
for(i=1; i<items; i++) {
in = (unsigned char *)SvPVbyte(ST(i), inlen);
if (inlen > 0) {
crc32_update(self, in, (unsigned long)inlen); /* returns void */
}
}
inc/CryptX_Digest.xs.inc view on Meta::CPAN
void
DESTROY(Crypt::Digest self)
CODE:
{
zeromem(self, sizeof(*self));
Safefree(self);
}
void
reset(Crypt::Digest self)
PPCODE:
{
int rv;
rv = self->desc->init(&self->state);
if (rv != CRYPT_OK) croak("FATAL: digest init failed: %s", error_to_string(rv));
self->finalized = 0;
XPUSHs(ST(0)); /* return self */
}
Crypt::Digest
clone(Crypt::Digest self)
inc/CryptX_Digest.xs.inc view on Meta::CPAN
croak("FATAL: clone is not supported for given hash state");
}
Newz(0, RETVAL, 1, struct digest_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct digest_struct);
OUTPUT:
RETVAL
void
add(Crypt::Digest self, ...)
PPCODE:
{
STRLEN inlen;
int rv, i;
unsigned char *in;
if (self->finalized) croak("FATAL: digest object already finalized");
for(i = 1; i < items; i++) {
in = (unsigned char *)SvPVbyte(ST(i), inlen);
if (inlen > 0) {
rv = self->desc->process(&self->state, in, (unsigned long)inlen);
inc/CryptX_Digest_KangarooTwelve.xs.inc view on Meta::CPAN
OUTPUT:
RETVAL
void
DESTROY(Crypt::Digest::KangarooTwelve self)
CODE:
Safefree(self);
void
reset(Crypt::Digest::KangarooTwelve self)
PPCODE:
{
int rv;
rv = kangaroo_twelve_init(&self->state, self->num);
if (rv != CRYPT_OK) croak("FATAL: kangaroo_twelve_init failed: %s", error_to_string(rv));
self->squeezing = 0;
XPUSHs(ST(0)); /* return self */
}
Crypt::Digest::KangarooTwelve
clone(Crypt::Digest::KangarooTwelve self)
CODE:
Newz(0, RETVAL, 1, struct digest_shake_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct digest_shake_struct);
OUTPUT:
RETVAL
void
add(Crypt::Digest::KangarooTwelve self, ...)
PPCODE:
{
STRLEN inlen;
int rv, i;
unsigned char *in;
if (self->squeezing) croak("FATAL: cannot add after done; call reset first");
for(i=1; i<items; i++) {
in = (unsigned char *)SvPVbyte(ST(i), inlen);
if (inlen>0) {
rv = kangaroo_twelve_process(&self->state, in, (unsigned long)inlen);
if (rv != CRYPT_OK) croak("FATAL: kangaroo_twelve_process failed: %s", error_to_string(rv));
}
}
XPUSHs(ST(0)); /* return self */
}
void
customization(Crypt::Digest::KangarooTwelve self, ...)
PPCODE:
{
STRLEN inlen;
int rv, i;
unsigned char *in;
if (self->squeezing) croak("FATAL: cannot add after done; call reset first");
for(i=1; i<items; i++) {
in = (unsigned char *)SvPVbyte(ST(i), inlen);
if (inlen>0) {
inc/CryptX_Digest_SHAKE.xs.inc view on Meta::CPAN
RETVAL
void
DESTROY(Crypt::Digest::SHAKE self)
CODE:
zeromem(self, sizeof(*self));
Safefree(self);
void
reset(Crypt::Digest::SHAKE self)
PPCODE:
{
int rv;
rv = sha3_shake_init(&self->state, self->num);
if (rv != CRYPT_OK) croak("FATAL: sha3_shake_init failed: %s", error_to_string(rv));
self->squeezing = 0;
XPUSHs(ST(0)); /* return self */
}
Crypt::Digest::SHAKE
clone(Crypt::Digest::SHAKE self)
CODE:
Newz(0, RETVAL, 1, struct digest_shake_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct digest_shake_struct);
OUTPUT:
RETVAL
void
add(Crypt::Digest::SHAKE self, ...)
PPCODE:
{
STRLEN inlen;
int rv, i;
unsigned char *in;
if (self->squeezing) croak("FATAL: cannot add after done; call reset first");
for(i=1; i<items; i++) {
in = (unsigned char *)SvPVbyte(ST(i), inlen);
if (inlen>0) {
inc/CryptX_Digest_TurboSHAKE.xs.inc view on Meta::CPAN
OUTPUT:
RETVAL
void
DESTROY(Crypt::Digest::TurboSHAKE self)
CODE:
Safefree(self);
void
reset(Crypt::Digest::TurboSHAKE self)
PPCODE:
{
int rv;
rv = turbo_shake_init(&self->state, self->num);
if (rv != CRYPT_OK) croak("FATAL: turbo_shake_init failed: %s", error_to_string(rv));
self->squeezing = 0;
XPUSHs(ST(0)); /* return self */
}
Crypt::Digest::TurboSHAKE
clone(Crypt::Digest::TurboSHAKE self)
CODE:
Newz(0, RETVAL, 1, struct digest_shake_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct digest_shake_struct);
OUTPUT:
RETVAL
void
add(Crypt::Digest::TurboSHAKE self, ...)
PPCODE:
{
STRLEN inlen;
int rv, i;
unsigned char *in;
if (self->squeezing) croak("FATAL: cannot add after done; call reset first");
for(i=1; i<items; i++) {
in = (unsigned char *)SvPVbyte(ST(i), inlen);
if (inlen>0) {
inc/CryptX_Mac_BLAKE2b.xs.inc view on Meta::CPAN
clone(Crypt::Mac::BLAKE2b self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_mac_blake2b_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_mac_blake2b_struct);
OUTPUT:
RETVAL
void
add(Crypt::Mac::BLAKE2b self, ...)
PPCODE:
{
int rv, i;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: MAC object already finalized");
for(i = 1; i < items; i++) {
in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
if (in_data_len > 0) {
rv = blake2bmac_process(&self->state, in_data, (unsigned long)in_data_len);
inc/CryptX_Mac_BLAKE2s.xs.inc view on Meta::CPAN
clone(Crypt::Mac::BLAKE2s self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_mac_blake2s_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_mac_blake2s_struct);
OUTPUT:
RETVAL
void
add(Crypt::Mac::BLAKE2s self, ...)
PPCODE:
{
int rv, i;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: MAC object already finalized");
for(i = 1; i < items; i++) {
in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
if (in_data_len > 0) {
rv = blake2smac_process(&self->state, in_data, (unsigned long)in_data_len);
inc/CryptX_Mac_F9.xs.inc view on Meta::CPAN
clone(Crypt::Mac::F9 self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_mac_f9_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_mac_f9_struct);
OUTPUT:
RETVAL
void
add(Crypt::Mac::F9 self, ...)
PPCODE:
{
int rv, i;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: MAC object already finalized");
for(i = 1; i < items; i++) {
in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
if (in_data_len > 0) {
rv = f9_process(&self->state, in_data, (unsigned long)in_data_len);
inc/CryptX_Mac_HMAC.xs.inc view on Meta::CPAN
croak("FATAL: clone is not supported for given hash state");
}
Newz(0, RETVAL, 1, struct cryptx_mac_hmac_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_mac_hmac_struct);
OUTPUT:
RETVAL
void
add(Crypt::Mac::HMAC self, ...)
PPCODE:
{
int rv, i;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: MAC object already finalized");
for(i = 1; i < items; i++) {
in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
if (in_data_len > 0) {
rv = hmac_process(&self->state, in_data, (unsigned long)in_data_len);
inc/CryptX_Mac_OMAC.xs.inc view on Meta::CPAN
clone(Crypt::Mac::OMAC self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_mac_omac_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_mac_omac_struct);
OUTPUT:
RETVAL
void
add(Crypt::Mac::OMAC self, ...)
PPCODE:
{
int rv, i;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: MAC object already finalized");
for(i = 1; i < items; i++) {
in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
if (in_data_len > 0) {
rv = omac_process(&self->state, in_data, (unsigned long)in_data_len);
inc/CryptX_Mac_PMAC.xs.inc view on Meta::CPAN
clone(Crypt::Mac::PMAC self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_mac_pmac_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_mac_pmac_struct);
OUTPUT:
RETVAL
void
add(Crypt::Mac::PMAC self, ...)
PPCODE:
{
int rv, i;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: MAC object already finalized");
for(i = 1; i < items; i++) {
in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
if (in_data_len > 0) {
rv = pmac_process(&self->state, in_data, (unsigned long)in_data_len);
inc/CryptX_Mac_Pelican.xs.inc view on Meta::CPAN
clone(Crypt::Mac::Pelican self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_mac_pelican_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_mac_pelican_struct);
OUTPUT:
RETVAL
void
add(Crypt::Mac::Pelican self, ...)
PPCODE:
{
int rv, i;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: MAC object already finalized");
for(i = 1; i < items; i++) {
in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
if (in_data_len > 0) {
rv = pelican_process(&self->state, in_data, (unsigned long)in_data_len);
inc/CryptX_Mac_Poly1305.xs.inc view on Meta::CPAN
clone(Crypt::Mac::Poly1305 self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_mac_poly1305_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_mac_poly1305_struct);
OUTPUT:
RETVAL
void
add(Crypt::Mac::Poly1305 self, ...)
PPCODE:
{
int rv, i;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: MAC object already finalized");
for(i = 1; i < items; i++) {
in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
if (in_data_len > 0) {
rv = poly1305_process(&self->state, in_data, (unsigned long)in_data_len);
inc/CryptX_Mac_XCBC.xs.inc view on Meta::CPAN
clone(Crypt::Mac::XCBC self)
CODE:
Newz(0, RETVAL, 1, struct cryptx_mac_xcbc_struct);
if (!RETVAL) croak("FATAL: Newz failed");
Copy(self, RETVAL, 1, struct cryptx_mac_xcbc_struct);
OUTPUT:
RETVAL
void
add(Crypt::Mac::XCBC self, ...)
PPCODE:
{
int rv, i;
STRLEN in_data_len;
unsigned char *in_data;
if (self->finalized) croak("FATAL: MAC object already finalized");
for(i = 1; i < items; i++) {
in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
if (in_data_len > 0) {
rv = xcbc_process(&self->state, in_data, (unsigned long)in_data_len);
inc/CryptX_Mode_CBC.xs.inc view on Meta::CPAN
{
zeromem(&self->state, sizeof(symmetric_CBC));
zeromem(self->pad, sizeof(self->pad));
Safefree(self);
}
void
start_decrypt(Crypt::Mode::CBC self, SV * key, SV * iv)
ALIAS:
start_encrypt = 1
PPCODE:
{
int rv;
STRLEN k_len=0;
unsigned char *k=NULL;
STRLEN i_len=0;
unsigned char *i=NULL;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_Mode_CFB.xs.inc view on Meta::CPAN
CODE:
{
zeromem(&self->state, sizeof(symmetric_CFB));
Safefree(self);
}
void
start_decrypt(Crypt::Mode::CFB self, SV * key, SV * iv)
ALIAS:
start_encrypt = 1
PPCODE:
{
STRLEN k_len=0;
unsigned char *k=NULL;
STRLEN i_len=0;
unsigned char *i=NULL;
int rv;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_Mode_CTR.xs.inc view on Meta::CPAN
CODE:
{
zeromem(&self->state, sizeof(symmetric_CTR));
Safefree(self);
}
void
start_decrypt(Crypt::Mode::CTR self, SV * key, SV * iv)
ALIAS:
start_encrypt = 1
PPCODE:
{
STRLEN k_len=0;
unsigned char *k=NULL;
STRLEN i_len=0;
unsigned char *i=NULL;
int rv;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_Mode_ECB.xs.inc view on Meta::CPAN
{
zeromem(&self->state, sizeof(symmetric_ECB));
zeromem(self->pad, sizeof(self->pad));
Safefree(self);
}
void
start_decrypt(Crypt::Mode::ECB self, SV * key)
ALIAS:
start_encrypt = 1
PPCODE:
{
int rv;
STRLEN k_len=0;
unsigned char *k=NULL;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
rv = ecb_start(self->cipher_id, k, (int)k_len, self->cipher_rounds, &self->state);
if (rv != CRYPT_OK) {
inc/CryptX_Mode_OFB.xs.inc view on Meta::CPAN
CODE:
{
zeromem(&self->state, sizeof(symmetric_OFB));
Safefree(self);
}
void
start_decrypt(Crypt::Mode::OFB self, SV * key, SV * iv)
ALIAS:
start_encrypt = 1
PPCODE:
{
STRLEN k_len=0;
unsigned char *k=NULL;
STRLEN i_len=0;
unsigned char *i=NULL;
int rv;
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
k = (unsigned char *) SvPVbyte(key, k_len);
inc/CryptX_PK_DH.xs.inc view on Meta::CPAN
zeromem(RETVAL, sizeof(*RETVAL));
Safefree(RETVAL);
croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
}
}
OUTPUT:
RETVAL
void
_generate_key_size(Crypt::PK::DH self, int groupsize=256)
PPCODE:
{
int rv;
cryptx_internal_pk_prng_reseed(&self->pstate, self->pindex, &self->last_pid);
if (self->key.type != -1) { dh_free(&self->key); self->key.type = -1; }
rv = dh_set_pg_groupsize(groupsize, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dh_set_pg_groupsize failed: %s", error_to_string(rv));
rv = dh_generate_key(&self->pstate, self->pindex, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dh_generate_key failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_generate_key_gp(Crypt::PK::DH self, char *g, char *p)
PPCODE:
{
int rv;
unsigned char pbin[1536], gbin[512]; /* 1536 = headroom above 8192-bit (1024-byte) groups */
unsigned long plen=sizeof(pbin), glen=sizeof(gbin);
cryptx_internal_pk_prng_reseed(&self->pstate, self->pindex, &self->last_pid);
if (self->key.type != -1) { dh_free(&self->key); self->key.type = -1; }
if (p && strlen(p) > 0 && g && strlen(g) > 0) {
rv = radix_to_bin(p, 16, pbin, &plen);
if (rv != CRYPT_OK) croak("FATAL: radix_to_bin(p) failed: %s", error_to_string(rv));
inc/CryptX_PK_DH.xs.inc view on Meta::CPAN
}
else {
croak("FATAL: generate_key: invalid g or p");
}
XPUSHs(ST(0)); /* return self */
}
void
_generate_key_dhparam(Crypt::PK::DH self, SV * dhparam)
PPCODE:
{
int rv;
unsigned char *data=NULL;
STRLEN data_len=0;
cryptx_internal_pk_prng_reseed(&self->pstate, self->pindex, &self->last_pid);
if (self->key.type != -1) { dh_free(&self->key); self->key.type = -1; }
data = (unsigned char *)SvPVbyte(dhparam, data_len);
/* load d p q */
rv = dh_set_pg_dhparam(data, (unsigned long)data_len, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dh_set_pg_dhparam failed: %s", error_to_string(rv));
/* gen the key */
rv = dh_generate_key(&self->pstate, self->pindex, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dh_generate_key failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_import(Crypt::PK::DH self, SV * key_data)
PPCODE:
{
int rv;
unsigned char *data=NULL;
STRLEN data_len=0;
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { dh_free(&self->key); self->key.type = -1; }
rv = dh_import(data, (unsigned long)data_len, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dh_import failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_import_raw(Crypt::PK::DH self, SV * raw_key, int type, char * g, char * p)
PPCODE:
{
int rv;
unsigned char *data=NULL;
STRLEN data_len=0;
unsigned char pbin[1536], gbin[512]; /* 1536 = headroom above 8192-bit (1024-byte) groups */
unsigned long plen=sizeof(pbin), glen=sizeof(gbin);
data = (unsigned char *)SvPVbyte(raw_key, data_len);
if (self->key.type != -1) { dh_free(&self->key); self->key.type = -1; }
inc/CryptX_PK_DSA.xs.inc view on Meta::CPAN
zeromem(RETVAL, sizeof(*RETVAL));
Safefree(RETVAL);
croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
}
}
OUTPUT:
RETVAL
void
_generate_key_size(Crypt::PK::DSA self, int group_size=30, int modulus_size=256)
PPCODE:
{
int rv;
cryptx_internal_pk_prng_reseed(&self->pstate, self->pindex, &self->last_pid);
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
/* gen the key */
rv = dsa_make_key(&self->pstate, self->pindex, group_size, modulus_size, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dsa_make_key failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_generate_key_dsaparam(Crypt::PK::DSA self, SV * dsaparam)
PPCODE:
{
int rv;
unsigned char *data=NULL;
STRLEN data_len=0;
cryptx_internal_pk_prng_reseed(&self->pstate, self->pindex, &self->last_pid);
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
data = (unsigned char *)SvPVbyte(dsaparam, data_len);
/* load d p q */
rv = dsa_set_pqg_dsaparam(data, (unsigned long)data_len, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dsa_set_pqg_dsaparam failed: %s", error_to_string(rv));
/* gen the key */
rv = dsa_generate_key(&self->pstate, self->pindex, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dsa_generate_key failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_generate_key_pqg_hex(Crypt::PK::DSA self, char *p, char *q, char *g)
PPCODE:
{
int rv;
unsigned char pbin[512], qbin[512], gbin[512];
unsigned long plen=sizeof(pbin), qlen=sizeof(qbin), glen=sizeof(gbin);
cryptx_internal_pk_prng_reseed(&self->pstate, self->pindex, &self->last_pid);
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
if (!p || !strlen(p) || !q || !strlen(q) || !g || !strlen(g)) {
croak("FATAL: generate_key_pqg_hex incomplete args");
}
/* set p q g */
inc/CryptX_PK_DSA.xs.inc view on Meta::CPAN
rv = dsa_set_pqg(pbin, plen, qbin, qlen, gbin, glen, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dsa_set_pqg failed: %s", error_to_string(rv));
/* gen the key */
rv = dsa_generate_key(&self->pstate, self->pindex, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dsa_generate_key failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_import(Crypt::PK::DSA self, SV * key_data)
PPCODE:
{
int rv;
unsigned char *data=NULL;
STRLEN data_len=0;
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
rv = dsa_import(data, (unsigned long)data_len, &self->key);
if (rv != CRYPT_OK) croak("FATAL: dsa_import failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_import_pkcs8(Crypt::PK::DSA self, SV * key_data, SV * passwd)
PPCODE:
{
int rv;
unsigned char *data = NULL;
STRLEN data_len = 0;
password_ctx pw_ctx = { cryptx_internal_password_cb_getpw, cryptx_internal_password_cb_free, passwd };
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
if (SvOK(passwd)) {
rv = dsa_import_pkcs8(data, (unsigned long)data_len, &pw_ctx, &self->key);
}
else {
rv = dsa_import_pkcs8(data, (unsigned long)data_len, NULL, &self->key);
}
if (rv != CRYPT_OK) croak("FATAL: dsa_import_pkcs8 failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_import_pem(Crypt::PK::DSA self, SV * key_data, SV * passwd)
PPCODE:
{
int rv;
unsigned char *data = NULL;
STRLEN data_len = 0;
password_ctx pw_ctx = { cryptx_internal_password_cb_getpw, cryptx_internal_password_cb_free, passwd };
ltc_pka_key key_from_pem;
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
if (SvOK(passwd)) {
inc/CryptX_PK_DSA.xs.inc view on Meta::CPAN
rv = pem_decode_pkcs(data, (unsigned long)data_len, &key_from_pem, NULL);
}
if (rv != CRYPT_OK) croak("FATAL: pem_decode_pkcs failed: %s", error_to_string(rv));
if (key_from_pem.id != LTC_PKA_DSA) croak("FATAL: pem_decode_pkcs decoded non-DSA key");
self->key = key_from_pem.u.dsa;
XPUSHs(ST(0)); /* return self */
}
void
_import_openssh(Crypt::PK::DSA self, SV * key_data, SV * passwd)
PPCODE:
{
int rv;
unsigned char *data = NULL;
STRLEN data_len = 0;
password_ctx pw_ctx = { cryptx_internal_password_cb_getpw, cryptx_internal_password_cb_free, passwd };
ltc_pka_key key_from_pem;
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
if (SvOK(passwd)) {
inc/CryptX_PK_DSA.xs.inc view on Meta::CPAN
rv = pem_decode_openssh(data, (unsigned long)data_len, &key_from_pem, NULL);
}
if (rv != CRYPT_OK) croak("FATAL: pem_decode_openssh failed: %s", error_to_string(rv));
if (key_from_pem.id != LTC_PKA_DSA) croak("FATAL: pem_decode_openssh decoded non-DSA key");
self->key = key_from_pem.u.dsa;
XPUSHs(ST(0)); /* return self */
}
void
_import_hex(Crypt::PK::DSA self, char *p, char *q, char *g, char *x, char *y)
PPCODE:
{
int rv;
unsigned char pbin[512], qbin[512], gbin[512], xbin[512], ybin[512];
unsigned long plen=sizeof(pbin), qlen=sizeof(qbin), glen=sizeof(gbin), xlen=sizeof(xbin), ylen=sizeof(ybin);
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
if (p && strlen(p) > 0 && q && strlen(q) > 0 && g && strlen(g) > 0 && y && strlen(y) > 0) {
rv = radix_to_bin(p, 16, pbin, &plen);
if (rv != CRYPT_OK) croak("FATAL: radix_to_bin(p) failed: %s", error_to_string(rv));
inc/CryptX_PK_ECC.xs.inc view on Meta::CPAN
zeromem(RETVAL, sizeof(*RETVAL));
Safefree(RETVAL);
croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
}
}
OUTPUT:
RETVAL
void
generate_key(Crypt::PK::ECC self, SV *curve)
PPCODE:
{
int rv;
cryptx_internal_pk_prng_reseed(&self->pstate, self->pindex, &self->last_pid);
/* setup dp structure */
rv = cryptx_internal_ecc_set_curve_from_SV(&self->key, curve); /* croaks on error */
if (rv != CRYPT_OK) croak("FATAL: ecc_set_curve failed: %s", error_to_string(rv));
/* gen the key */
rv = ecc_generate_key(&self->pstate, self->pindex, &self->key);
if (rv != CRYPT_OK) croak("FATAL: ecc_generate_key failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_import(Crypt::PK::ECC self, SV * key_data)
PPCODE:
{
int rv;
unsigned char *data=NULL;
STRLEN data_len=0;
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { ecc_free(&self->key); self->key.type = -1; }
rv = ecc_import_openssl(data, (unsigned long)data_len, &self->key);
if (rv != CRYPT_OK) croak("FATAL: ecc_import_openssl failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_import_old(Crypt::PK::ECC self, SV * key_data)
PPCODE:
{
int rv;
unsigned char *data=NULL;
STRLEN data_len=0;
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { ecc_free(&self->key); self->key.type = -1; }
rv = ecc_import(data, (unsigned long)data_len, &self->key);
if (rv != CRYPT_OK) croak("FATAL: ecc_import failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_import_pkcs8(Crypt::PK::ECC self, SV * key_data, SV * passwd)
PPCODE:
{
int rv;
unsigned char *data = NULL;
STRLEN data_len = 0;
password_ctx pw_ctx = { cryptx_internal_password_cb_getpw, cryptx_internal_password_cb_free, passwd };
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { ecc_free(&self->key); self->key.type = -1; }
if (SvOK(passwd)) {
rv = ecc_import_pkcs8(data, (unsigned long)data_len, &pw_ctx, &self->key);
}
else {
rv = ecc_import_pkcs8(data, (unsigned long)data_len, NULL, &self->key);
}
if (rv != CRYPT_OK) croak("FATAL: ecc_import_pkcs8 failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
_import_pem(Crypt::PK::ECC self, SV * key_data, SV * passwd)
PPCODE:
{
int rv;
unsigned char *data = NULL;
STRLEN data_len = 0;
password_ctx pw_ctx = { cryptx_internal_password_cb_getpw, cryptx_internal_password_cb_free, passwd };
ltc_pka_key key_from_pem;
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { ecc_free(&self->key); self->key.type = -1; }
if (SvOK(passwd)) {
inc/CryptX_PK_ECC.xs.inc view on Meta::CPAN
rv = pem_decode_pkcs(data, (unsigned long)data_len, &key_from_pem, NULL);
}
if (rv != CRYPT_OK) croak("FATAL: pem_decode_pkcs failed: %s", error_to_string(rv));
if (key_from_pem.id != LTC_PKA_EC) croak("FATAL: pem_decode_pkcs decoded non-ECC key");
self->key = key_from_pem.u.ecc;
XPUSHs(ST(0)); /* return self */
}
void
_import_openssh(Crypt::PK::ECC self, SV * key_data, SV * passwd)
PPCODE:
{
int rv;
unsigned char *data = NULL;
STRLEN data_len = 0;
password_ctx pw_ctx = { cryptx_internal_password_cb_getpw, cryptx_internal_password_cb_free, passwd };
ltc_pka_key key_from_pem;
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { ecc_free(&self->key); self->key.type = -1; }
if (SvOK(passwd)) {
inc/CryptX_PK_ECC.xs.inc view on Meta::CPAN
rv = pem_decode_openssh(data, (unsigned long)data_len, &key_from_pem, NULL);
}
if (rv != CRYPT_OK) croak("FATAL: pem_decode_openssh failed: %s", error_to_string(rv));
if (key_from_pem.id != LTC_PKA_EC) croak("FATAL: pem_decode_openssh decoded non-ECC key");
self->key = key_from_pem.u.ecc;
XPUSHs(ST(0)); /* return self */
}
void
_import_x509(Crypt::PK::ECC self, SV * key_data)
PPCODE:
{
int rv;
unsigned char *data=NULL;
STRLEN data_len=0;
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { ecc_free(&self->key); self->key.type = -1; }
rv = ecc_import_x509(data, (unsigned long)data_len, &self->key);
if (rv != CRYPT_OK) croak("FATAL: ecc_import_x509 failed: %s", error_to_string(rv));
XPUSHs(ST(0)); /* return self */
}
void
import_key_raw(Crypt::PK::ECC self, SV * key_data, SV * curve)
PPCODE:
{
int rv, type;
unsigned char *data=NULL;
STRLEN data_len=0;
data = (unsigned char *)SvPVbyte(key_data, data_len);
if (self->key.type != -1) { ecc_free(&self->key); self->key.type = -1; }
/* setup dp structure */
rv = cryptx_internal_ecc_set_curve_from_SV(&self->key, curve); /* croaks on error */
if (rv != CRYPT_OK) croak("FATAL: ecc_set_curve failed: %s", error_to_string(rv));
( run in 1.945 second using v1.01-cache-2.11-cpan-71847e10f99 )