Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 3.486 )
Crypt-GCrypt
view release on metacpan or search on metacpan
void
cgm_swap(sv_gcma, gcmb)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_swap(gcma, gcmb);
ST(0) = sv_gcma;
XSRETURN(1);
void
cgm_set(sv_gcma, gcmb)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_set(gcma, gcmb);
ST(0) = sv_gcma;
XSRETURN(1);
void
cgm_add(sv_gcma, gcmb)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_add(gcma, gcma, gcmb);
ST(0) = sv_gcma;
XSRETURN(1);
void
cgm_addm(sv_gcma, gcmb, gcmm)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
Crypt_GCrypt_MPI gcmm;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_addm(gcma, gcma, gcmb, gcmm);
ST(0) = sv_gcma;
XSRETURN(1);
void
cgm_sub(sv_gcma, gcmb)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_sub(gcma, gcma, gcmb);
ST(0) = sv_gcma;
XSRETURN(1);
void
cgm_subm(sv_gcma, gcmb, gcmm)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
Crypt_GCrypt_MPI gcmm;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_subm(gcma, gcma, gcmb, gcmm);
ST(0) = sv_gcma;
XSRETURN(1);
void
cgm_mul(sv_gcma, gcmb)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_mul(gcma, gcma, gcmb);
ST(0) = sv_gcma;
XSRETURN(1);
void
cgm_mulm(sv_gcma, gcmb, gcmm)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
Crypt_GCrypt_MPI gcmm;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_mulm(gcma, gcma, gcmb, gcmm);
ST(0) = sv_gcma;
XSRETURN(1);
void
cgm_mul_2exp(sv_gcm, e)
SV* sv_gcm;
int e;
PPCODE:
Crypt_GCrypt_MPI gcm = dereference_gcm(sv_gcm);
if (e >= 0) {
/* this can be dealt with by regular unsigned ints */
gcry_mpi_mul_2exp(gcm, gcm, e);
} else {
void
cgm_div(sv_gcma, gcmb)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_div(gcma, NULL, gcma, gcmb, 0);
ST(0) = sv_gcma;
/* FIXME: should we return the remainder as well, if called in a list context? */
XSRETURN(1);
void
cgm_mod(sv_gcma, gcmb)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_mod(gcma, gcma, gcmb);
ST(0) = sv_gcma;
XSRETURN(1);
void
cgm_powm(sv_gcma, gcme, gcmm)
SV* sv_gcma;
Crypt_GCrypt_MPI gcme;
Crypt_GCrypt_MPI gcmm;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_powm(gcma, gcma, gcme, gcmm);
ST(0) = sv_gcma;
XSRETURN(1);
void
cgm_invm(sv_gcma, gcmb)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_invm(gcma, gcma, gcmb);
ST(0) = sv_gcma;
/* FIXME: should we do anything with the return value (1 if invm actually exists)? */
XSRETURN(1);
void
cgm_gcd(sv_gcma, gcmb)
SV* sv_gcma;
Crypt_GCrypt_MPI gcmb;
PPCODE:
Crypt_GCrypt_MPI gcma = dereference_gcm(sv_gcma);
gcry_mpi_gcd(gcma, gcma, gcmb);
ST(0) = sv_gcma;
XSRETURN(1);
RETVAL
void
cgm_dump(sv_gcm)
SV* sv_gcm;
PPCODE:
Crypt_GCrypt_MPI gcm = dereference_gcm(sv_gcm);
gcry_mpi_dump(gcm);
ST(0) = sv_gcm;
XSRETURN(1);
Crypt-GpgME
view release on metacpan or search on metacpan
xs/GpgME.xs view on Meta::CPAN
void
gpgme_get_engine_info (ctx)
perl_gpgme_ctx_or_null_t ctx
PREINIT:
gpgme_engine_info_t info, i;
PPCODE:
if (ctx == NULL) {
gpgme_error_t err;
err = gpgme_get_engine_info (&info);
perl_gpgme_assert_error (err);
}
xs/GpgME.xs view on Meta::CPAN
void
gpgme_sig_notation_get (ctx)
gpgme_ctx_t ctx
PREINIT:
gpgme_sig_notation_t notations, i;
PPCODE:
notations = gpgme_sig_notation_get (ctx);
for (i = notations; i != NULL; i = i->next) {
XPUSHs (sv_2mortal (perl_gpgme_hashref_from_notation (i)));
}
xs/GpgME.xs view on Meta::CPAN
gpgme_data_seek (sig, 0, SEEK_SET);
if (signed_text) {
gpgme_data_seek (signed_text, 0, SEEK_SET);
}
PPCODE:
if (!signed_text) {
err = gpgme_data_new (&plain);
perl_gpgme_assert_error (err);
}
xs/GpgME.xs view on Meta::CPAN
perl_gpgme_assert_error (err);
err = gpgme_data_new (&seckey);
perl_gpgme_assert_error (err);
}
PPCODE:
err = gpgme_op_genkey (ctx, parms, pubkey, seckey);
perl_gpgme_assert_error (err);
result = gpgme_op_genkey_result (ctx);
xs/GpgME.xs view on Meta::CPAN
const char *pattern
int secret_only
PREINIT:
gpgme_error_t err;
gpgme_key_t key;
PPCODE:
err = gpgme_op_keylist_start (ctx, pattern, secret_only);
perl_gpgme_assert_error (err);
while ((err = gpgme_op_keylist_next (ctx, &key)) == GPG_ERR_NO_ERROR) {
XPUSHs (perl_gpgme_new_sv_from_ptr (key, "Crypt::GpgME::Key"));
xs/GpgME.xs view on Meta::CPAN
const char *pattern
int max_level
PREINIT:
gpgme_error_t err;
gpgme_trust_item_t item;
PPCODE:
err = gpgme_op_trustlist_start (ctx, pattern, max_level);
perl_gpgme_assert_error (err);
while ((err = gpgme_op_trustlist_next (ctx, &item)) == GPG_ERR_NO_ERROR) {
XPUSHs (perl_gpgme_hashref_from_trust_item (item));
Crypt-HSM
view release on metacpan or search on metacpan
lib/Crypt/HSM.xs view on Meta::CPAN
hv_stores(RETVAL, "library-version", version_to_sv(&info.libraryVersion));
OUTPUT: RETVAL
void slots(Crypt::HSM::Provider self, CK_BBOOL tokenPresent = 1)
PPCODE:
CK_ULONG count, i;
CK_RV result = self->funcs->C_GetSlotList(tokenPresent, NULL, &count);
if ( result != CKR_OK )
croak_with("Couldn't get slots", result);
lib/Crypt/HSM.xs view on Meta::CPAN
RETVAL->slot = slot_refcount_increment(self);
RETVAL->handle = handle;
OUTPUT: RETVAL
void mechanisms(Crypt::HSM::Slot self)
PPCODE:
CK_ULONG length, i;
CK_RV result = slot_funcs(self)->C_GetMechanismList(self->slot, NULL, &length);
if (result != CKR_OK)
croak_with("Couldn't get mechanisms length", result);
lib/Crypt/HSM.xs view on Meta::CPAN
RETVAL = (self->flags & flags) == flags;
OUTPUT: RETVAL
void flags(Crypt::HSM::Mechanism::Info self)
PPCODE:
CK_ULONG i;
for (i = 0; i < CHAR_BIT * sizeof(CK_ULONG); ++i) {
CK_ULONG right = 1ul << i;
if (self->flags & right)
mXPUSHs(entry_to_sv(map_reverse_find(mechanism_flags, right)));
lib/Crypt/HSM.xs view on Meta::CPAN
RETVAL = new_object(self, handle);
OUTPUT: RETVAL
void find_objects(Crypt::HSM::Session self, Attributes attributes = empty)
PPCODE:
CK_RV result = session_funcs(self)->C_FindObjectsInit(self->handle, attributes.member, attributes.length);
if (result != CKR_OK)
croak_with("Could not find objects", result);
CK_ULONG actual = 0;
lib/Crypt/HSM.xs view on Meta::CPAN
} while (actual > 0);
session_funcs(self)->C_FindObjectsFinal(self->handle);
void generate_keypair(Crypt::HSM::Session self, CK_MECHANISM_TYPE mechanism_type, Attributes publicKeyTemplate, Attributes privateKeyTemplate, ...)
PPCODE:
CK_OBJECT_HANDLE publicKey;
CK_OBJECT_HANDLE privateKey;
CK_MECHANISM mechanism = mechanism_from_args(mechanism_type, 4);
CK_RV result = session_funcs(self)->C_GenerateKeyPair(self->handle, &mechanism, publicKeyTemplate.member, publicKeyTemplate.length, privateKeyTemplate.member, privateKeyTemplate.length, &publicKey, &privateKey);
Crypt-Libmcrypt
view release on metacpan or search on metacpan
const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Crypt-Liboqs-Sign
view release on metacpan or search on metacpan
MODULE = Crypt::Liboqs::Sign PACKAGE = Crypt::Liboqs::Sign
void
_oqs_keypair(alg_name)
const char* alg_name
PPCODE:
OQS_SIG *sig = OQS_SIG_new(alg_name);
if (sig == NULL) {
croak("Unsupported or disabled algorithm: %s", alg_name);
}
unsigned char *pk = NULL;
void
_oqs_sign(alg_name, message, sk)
const char* alg_name
SV* message
SV* sk
PPCODE:
OQS_SIG *sig = OQS_SIG_new(alg_name);
if (sig == NULL) {
croak("Unsupported or disabled algorithm: %s", alg_name);
}
STRLEN msg_len, sk_len;
_oqs_verify(alg_name, signature, message, pk)
const char* alg_name
SV* signature
SV* message
SV* pk
PPCODE:
OQS_SIG *sig = OQS_SIG_new(alg_name);
if (sig == NULL) {
croak("Unsupported or disabled algorithm: %s", alg_name);
}
STRLEN sig_len, msg_len, pk_len;
OQS_SIG_free(sig);
XSRETURN_IV(rc == OQS_SUCCESS ? 1 : 0);
void
_oqs_alg_list()
PPCODE:
int count = OQS_SIG_alg_count();
int i;
for (i = 0; i < count; i++) {
const char *name = OQS_SIG_alg_identifier(i);
if (OQS_SIG_alg_is_enabled(name)) {
Crypt-Lucifer
view release on metacpan or search on metacpan
const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
type = constant(aTHX_ s, len);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
switch (type) {
case PERL_constant_NOTFOUND:
Crypt-MCrypt
view release on metacpan or search on metacpan
const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
type = constant(aTHX_ s, len);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
switch (type) {
case PERL_constant_NOTFOUND:
Crypt-MatrixSSL
view release on metacpan or search on metacpan
const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Crypt-NSS-X509
view release on metacpan or search on metacpan
PREINIT:
SECStatus rv;
PRTime time = 0;
PPCODE:
if ( items < 3 || SvIV(timedouble) == 0 ) {
time = PR_Now();
} else {
double tmptime = SvNV(timedouble);
// time contains seconds since epoch - netscape expects microseconds
void
DESTROY(crl)
Crypt::NSS::X509::CRL crl
PPCODE:
if ( crl ) {
SEC_DestroyCrl(crl);
crl = 0;
}
PREINIT:
CERTCrlEntry *entry;
int iv;
PPCODE:
if ( crl->crl.entries != NULL ) {
iv = 0;
while( (entry = crl->crl.entries[iv++]) != NULL) {
HV* h = newHV();
Crypt::NSS::X509::CertList certlist;
PREINIT:
CERTCertListNode *node;
PPCODE:
node = CERT_LIST_HEAD(certlist);
while ( !CERT_LIST_END(node, certlist) ) {
if ( node->cert ) {
void
DESTROY(certlist)
Crypt::NSS::X509::CertList certlist;
PPCODE:
if ( certlist ) {
CERT_DestroyCertList(certlist);
certlist = 0;
}
SECStatus secStatus;
PRTime time = 0;
CERTVerifyLog log;
CERTCertDBHandle *defaultDB;
PPCODE:
defaultDB = CERT_GetDefaultCertDB();
if ( items == 1 || SvIV(timedouble) == 0 ) {
time = PR_Now();
} else {
void DESTROY(cert)
Crypt::NSS::X509::Certificate cert;
PPCODE:
if ( cert ) {
if ( cert->nssCertificate ) {
//printf("Is nsscertificate\n");
//printf("Refcount: %d\n", cert->nssCertificate->object.refCount);
Crypt-NSS
view release on metacpan or search on metacpan
_peeraddr(self)
Net::NSS::SSL self;
PREINIT:
char * hostname;
PRNetAddr addr;
PPCODE:
if (self->ssl_fd == NULL || !self->is_connected) {
croak("Can't get peeraddr because we're not connected");
}
EVALUATE_PR_CALL(PR_GetPeerName(self->ssl_fd, &addr), "Failed to get peer addr")
Newz(1, hostname, 16, char);
_sockaddr(self)
Net::NSS::SSL self;
PREINIT:
char * hostname;
PRNetAddr addr;
PPCODE:
EVALUATE_PR_CALL(PR_GetSockName(self->ssl_fd, &addr), "Failed to get peer addr")
Newz(1, hostname, 16, char);
if (PR_NetAddrToString(&addr, hostname, 16) != PR_SUCCESS) {
Safefree(hostname);
throw_exception_from_nspr_error("Failed to convert PRNetAddr to string");
Crypt-NaCl-Sodium
view release on metacpan or search on metacpan
CLEANUP:
sodium_free(copy);
void
has_aes128ctr()
PPCODE:
{
#ifdef AES128CTR_IS_AVAILABLE
XSRETURN_YES;
#else
XSRETURN_NO;
INIT:
unsigned char * left_buf;
unsigned char * right_buf;
STRLEN left_len;
STRLEN right_len;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
INIT:
unsigned char * left_buf;
unsigned char * right_buf;
STRLEN left_len;
STRLEN right_len;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
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");
}
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);
}
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;
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;
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;
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;
PROTOTYPE: $$
INIT:
STRLEN key_len;
unsigned char * key_buf;
CryptNaClSodiumAuthHmacsha256Stream *stream;
PPCODE:
{
PERL_UNUSED_VAR(self);
key_buf = (unsigned char *)SvPV(key, key_len);
PROTOTYPE: $$
INIT:
STRLEN key_len;
unsigned char * key_buf;
CryptNaClSodiumAuthHmacsha512Stream *stream;
PPCODE:
{
PERL_UNUSED_VAR(self);
key_buf = (unsigned char *)SvPV(key, key_len);
PROTOTYPE: $$
INIT:
STRLEN key_len;
unsigned char * key_buf;
CryptNaClSodiumAuthHmacsha512256Stream *stream;
PPCODE:
{
PERL_UNUSED_VAR(self);
key_buf = (unsigned char *)SvPV(key, key_len);
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);
}
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);
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha256Stream* stream = GetAuthHmacsha256Stream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
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);
}
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);
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha512Stream* stream = GetAuthHmacsha512Stream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
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);
}
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);
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumAuthHmacsha512256Stream* stream = GetAuthHmacsha512256Stream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
PROTOTYPES: ENABLE
void
aes256gcm_is_available(self)
SV * self
PPCODE:
{
if ( crypto_aead_aes256gcm_is_available() ) {
XSRETURN_YES;
}
XSRETURN_NO;
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;
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;
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 ) {
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 ) {
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 ) {
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;
}
void
unlock(self)
SV * self
PPCODE:
{
int rc;
#if defined(AES256GCM_IS_AVAILABLE)
CryptNaClSodiumAeadAes256gcmState* state;
}
void
is_locked(self, ...)
SV * self
PPCODE:
{
#if defined(AES256GCM_IS_AVAILABLE)
CryptNaClSodiumAeadAes256gcmState* state;
state = GetAeadAes256gcmState(aTHX_ self);
}
void
DESTROY(self)
SV * self
PPCODE:
{
#if defined(AES256GCM_IS_AVAILABLE)
CryptNaClSodiumAeadAes256gcmState* state;
state = GetAeadAes256gcmState(aTHX_ self);
sodium_free( state->ctx );
SV * self
PROTOTYPE: $;$
INIT:
DataBytesLocker *blp;
DataBytesLocker *bls;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( items > 2 ) {
croak("Invalid number of arguments");
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;
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;
SV * self
PROTOTYPE: $;$
INIT:
DataBytesLocker *blp;
DataBytesLocker *bls;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( items > 2 ) {
croak("Invalid number of arguments");
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 ) {
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 ) {
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 ) {
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);
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;
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;
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;
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;
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");
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");
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);
}
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);
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");
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumGenerichashStream* stream = GetGenerichashStream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
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");
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");
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);
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));
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));
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);
}
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);
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);
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumHashSha256Stream* stream = GetHashSha256Stream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
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);
}
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);
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);
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumHashSha512Stream* stream = GetHashSha512Stream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
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 ) {
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;
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 ) {
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);
}
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);
PROTOTYPE: $
PREINIT:
CryptNaClSodiumOnetimeauthStream* stream = GetOnetimeauthStream(aTHX_ self);
INIT:
DataBytesLocker *bl;
PPCODE:
{
bl = InitDataBytesLocker(aTHX_ crypto_onetimeauth_BYTES);
crypto_onetimeauth_final(stream->state, bl->bytes);
void
DESTROY(self)
SV * self
PREINIT:
CryptNaClSodiumOnetimeauthStream* stream = GetOnetimeauthStream(aTHX_ self);
PPCODE:
{
sodium_free( stream->state );
Safefree(stream);
}
PROTOTYPE: $$
INIT:
STRLEN key_len;
unsigned char * key_buf;
DataBytesLocker *bl;
PPCODE:
{
PERL_UNUSED_VAR(self);
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
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;
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;
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;
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;
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;
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
int res;
OVERLOAD: bool
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
int res;
OVERLOAD: !
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
INIT:
unsigned char *buf;
STRLEN buf_len;
int res;
OVERLOAD: eq
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
INIT:
unsigned char *buf;
STRLEN buf_len;
int res;
OVERLOAD: ne
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
SV * pv;
OVERLOAD: \"\"
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
_overload_nomethod(self, ...)
SV * self
OVERLOAD: nomethod
INIT:
char * operator;
PPCODE:
{
operator = SvPV_nolen(ST(3));
croak("Operation \"%s\" is not supported", operator);
}
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;
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;
void
is_locked(self, ...)
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
PPCODE:
{
if ( sbl->locked ) {
XSRETURN_YES;
} else {
XSRETURN_NO;
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
SV * pv;
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
unsigned char * bytes_buf;
STRLEN bytes_len;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
unsigned char * num_buf;
STRLEN num_len;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
SV * pv;
DataBytesLocker *bl;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
INIT:
unsigned char * num_buf;
STRLEN num_len;
STRLEN inc_len;
DataBytesLocker *bl;
PPCODE:
{
if ( GIMME_V == G_VOID ) {
XSRETURN_EMPTY;
}
SV * self
PREINIT:
DataBytesLocker* sbl = GetBytesLocker(aTHX_ self);
INIT:
SV * pv;
PPCODE:
{
if ( sbl->locked ) {
croak("Unlock BytesLocker object before accessing the data");
}
void
DESTROY(self)
SV * self
PREINIT:
DataBytesLocker* bl = GetBytesLocker(aTHX_ self);
PPCODE:
{
sodium_free( bl->bytes );
Safefree(bl);
}
Crypt-NaCl-Tweet
view release on metacpan or search on metacpan
PREINIT:
STRLEN auth_len, key_len, msg_len;
unsigned char *auth_buf, *key_buf, *msg_buf;
PPCODE:
auth_buf = SvPVbyte(auth, auth_len);
if (auth_len != crypto_onetimeauth_BYTES)
croak("Invalid authenticator length");
key_buf = SvPVbyte(key, key_len);
STRLEN pk_len, sk_len;
unsigned char d[64], *pk_buf, *sk_buf;
long long p[4];
int i, n;
PPCODE:
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(crypto_sign_SECRETKEYBYTES)));
PUTBACK;
PREINIT:
STRLEN x_len, y_len, req_len;
unsigned char *x_buf, *y_buf;
int (*func) (const unsigned char *, const unsigned char *);
PPCODE:
switch(ix) {
case 2:
req_len = 32;
func = crypto_verify_32_tweet;
break;
Crypt-Nettle
view release on metacpan or search on metacpan
Crypt_Nettle_Hash cnh;
SV* data;
PREINIT:
const uint8_t* buf;
unsigned len;
PPCODE:
buf = SvPV(data, len);
cnh->hashtype->update(cnh->hash_context, len, buf);
XSRETURN(1);
SV *
void
cnh_algos_available()
PREINIT:
int i;
PPCODE:
for (i = 0; i < sizeof(hash_algos_available)/sizeof(*hash_algos_available); i++)
XPUSHs(sv_2mortal(newSVpv(hash_algos_available[i]->name, 0)));
void
cnh_DESTROY(cnh)
Crypt_Nettle_Cipher cnc;
SV * data;
PREINIT:
uint8_t * databuf;
int datalen;
PPCODE:
databuf = SvPV(data, datalen);
_cnc_process(cnc, datalen, databuf, databuf);
int
void
cnc_algos_available()
PREINIT:
int i;
PPCODE:
for (i = 0; i < sizeof(cipher_algos_available)/sizeof(*cipher_algos_available); i++)
XPUSHs(sv_2mortal(newSVpv(cipher_algos_available[i]->name, 0)));
void
cnc_modes_available()
PREINIT:
int i;
PPCODE:
for (i = 0; i < sizeof(cipher_modes_available)/sizeof(*cipher_modes_available); i++)
XPUSHs(sv_2mortal(newSVpv(cipher_modes_available[i].name, 0)));
void
cnc_DESTROY(cnc)
Crypt_Nettle_Yarrow cny;
SV * seed;
PREINIT:
int seedlen;
const uint8_t * seeddata;
PPCODE:
seeddata = SvPV(seed, seedlen);
yarrow256_seed(&cny->yarrow_ctx, seedlen, seeddata);
SV*
void
cnrsa_hashes_available()
PREINIT:
int i;
PPCODE:
for (i = 0; i < sizeof(_cnrsa_hashes_available)/sizeof(*_cnrsa_hashes_available); i++)
XPUSHs(sv_2mortal(newSVpv(_cnrsa_hashes_available[i].hash->name, 0)));
Crypt_Nettle_RSA
Crypt-OpenSSL-Bignum
view release on metacpan or search on metacpan
OUTPUT:
RETVAL
void
BN_bless_pointer(CLASS, void *pointer)
PPCODE:
ST(0) = new_obj(pointer);
XSRETURN(1);
char*
BN_to_decimal(Crypt::OpenSSL::Bignum self)
void
BN_add(Crypt::OpenSSL::Bignum self, Crypt::OpenSSL::Bignum b, ...)
PREINIT:
BIGNUM *bn;
PPCODE:
if( items > 3 )
croak( "usage: $bn->add( $bn2[, $target] )" );
bn = ( items < 3 ) ? BN_new() : sv2bn( ST(2) );
checkOpenSslCall( BN_add( bn, self, b ) );
ST(0) = ( (items < 3 ) ? new_obj( bn ) : ST(2) );
void
BN_sub(Crypt::OpenSSL::Bignum self, Crypt::OpenSSL::Bignum b, ...)
PREINIT:
BIGNUM *bn;
PPCODE:
if( items > 3 )
croak( "usage: $bn->sub( $bn2[, $target] )" );
bn = ( items < 3 ) ? BN_new() : sv2bn( ST(2) );
checkOpenSslCall( BN_sub( bn, self, b ) );
ST(0) = ( (items < 3 ) ? new_obj( bn ) : ST(2) );
Crypt::OpenSSL::Bignum self;
Crypt::OpenSSL::Bignum b;
Crypt::OpenSSL::Bignum::CTX ctx;
PREINIT:
BIGNUM* bn;
PPCODE:
if( items > 4 )
croak( "usage: $bn->mul( $bn2, $ctx, [, $target] )" );
bn = ( items < 4 ) ? BN_new() : sv2bn( ST(3) );
checkOpenSslCall( BN_mul( bn, self, b, ctx ) );
ST(0) = ( (items < 4 ) ? new_obj( bn ) : ST(3) );
Crypt::OpenSSL::Bignum b;
Crypt::OpenSSL::Bignum::CTX ctx;
PREINIT:
BIGNUM* quotient;
BIGNUM* remainder;
PPCODE:
if( items > 5 )
croak( "usage: $bn->div( $bn2, $ctx, [, $quotient [, $remainder ] ] )" );
quotient = ( items < 4 ) ? BN_new() : sv2bn( ST(3) );
remainder = ( items < 5 ) ? BN_new() : sv2bn( ST(4) );
checkOpenSslCall( BN_div( quotient, remainder, self, b, ctx ) );
Crypt::OpenSSL::Bignum self;
Crypt::OpenSSL::Bignum b;
Crypt::OpenSSL::Bignum::CTX ctx;
PREINIT:
BIGNUM* bn;
PPCODE:
if( items > 4 )
croak( "usage: $bn->mod( $bn2, $ctx, [, $target] )" );
bn = ( items < 4 ) ? BN_new() : sv2bn( ST(3) );
checkOpenSslCall( BN_mod( bn, self, b, ctx ) );
ST(0) = ( (items < 4 ) ? new_obj( bn ) : ST(3) );
Crypt-OpenSSL-EC
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Crypt-OpenSSL-ECDSA
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Crypt-OpenSSL-PKCS10
view release on metacpan or search on metacpan
pkcs10Data *pkcs10;
PREINIT:
//BIO *bio_err;
PPCODE:
//bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);
if (pkcs10->pk) EVP_PKEY_free(pkcs10->pk); pkcs10->pk = 0;
if (pkcs10->rsa) *pkcs10->rsa = 0;
if (pkcs10->req) X509_REQ_free(pkcs10->req); pkcs10->req = 0;
Safefree(pkcs10);
Crypt-OpenSSL-RSA
view release on metacpan or search on metacpan
const BIGNUM* q;
const BIGNUM* dmp1;
const BIGNUM* dmq1;
const BIGNUM* iqmp;
#endif
PPCODE:
{
EVP_PKEY* rsa;
rsa = p_rsa->rsa;
#if OLD_CRUFTY_SSL_VERSION
n = rsa->n;
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
int error = 0;
EVP_PKEY_CTX *ctx = NULL;
EVP_MD *md = NULL;
#endif
PPCODE:
{
unsigned char* sig;
unsigned char* digest;
STRLEN sig_length;
Crypt-OpenSSL-Random
view release on metacpan or search on metacpan
PROTOTYPES: DISABLE
void
random_bytes(num_bytes_SV)
SV * num_bytes_SV;
PPCODE:
{
unsigned char *rand_bytes;
int num_bytes = SvIV(num_bytes_SV);
if(New(0,rand_bytes, num_bytes, unsigned char) == NULL)
{
}
void
random_pseudo_bytes(num_bytes_SV)
SV * num_bytes_SV;
PPCODE:
{
unsigned char *rand_bytes;
int num_bytes = SvIV(num_bytes_SV);
if(New(0,rand_bytes, num_bytes, unsigned char) == NULL)
{
# seeding was sufficient.
void
random_seed(random_bytes_SV)
SV * random_bytes_SV;
PPCODE:
{
Size_t random_bytes_length;
char *random_bytes;
random_bytes = SvPV(random_bytes_SV, random_bytes_length);
RAND_seed(random_bytes, random_bytes_length);
#ifndef OPENSSL_NO_EGD
void
random_egd(egd_SV)
SV * egd_SV;
PPCODE:
{
Size_t egd_length;
int status;
char *egd = SvPV(egd_SV, egd_length);
status = RAND_egd(egd);
# Returns 1 if the PRNG has enough seed data
void
random_status()
PPCODE:
{
XPUSHs( sv_2mortal( newSViv( RAND_status() ) ) );
}
Crypt-OpenSSL-Verify
view release on metacpan or search on metacpan
RETVAL
#if OPENSSL_VERSION_NUMBER >= 10100
void __X509_cleanup(void)
PPCODE:
/* deinitialisation is done automatically */
#else
void __X509_cleanup(void)
PPCODE:
CRYPTO_cleanup_all_ex_data();
ERR_free_strings();
ERR_remove_state(0);
EVP_cleanup();
Crypt-OpenSSL-VerifyX509
view release on metacpan or search on metacpan
VerifyX509.xs view on Meta::CPAN
void
DESTROY(store)
Crypt::OpenSSL::VerifyX509 store;
PPCODE:
if (store) X509_STORE_free(store); store = 0;
#if OPENSSL_API_COMPAT >= 0x10100000L
void
__X509_cleanup(void)
PPCODE:
/* deinitialisation is done automatically */
#else
void
__X509_cleanup(void)
PPCODE:
CRYPTO_cleanup_all_ex_data();
ERR_free_strings();
ERR_remove_state(0);
EVP_cleanup();
Crypt-OpenSSL-X509
view release on metacpan or search on metacpan
void
DESTROY(x509)
Crypt::OpenSSL::X509 x509;
PPCODE:
if (x509) X509_free(x509); x509 = 0;
# This is called via an END block in the Perl module to clean up initialization that happened in BOOT.
void
__X509_cleanup(void)
PPCODE:
#if OPENSSL_VERSION_NUMBER < 0x10100000
CRYPTO_cleanup_all_ex_data();
ERR_free_strings();
ERR_remove_state(0);
EVP_cleanup();
Crypt-OpenSSL3
view release on metacpan or search on metacpan
lib/Crypt/OpenSSL3.xs view on Meta::CPAN
POSTCALL:
if (RETVAL == -2)
XSRETURN_UNDEF;
void ASN1_TIME_to_tm(Crypt::OpenSSL3::ASN1::Time s)
PPCODE:
struct tm tm;
if (ASN1_TIME_to_tm(s, &tm)) {
EXTEND(SP, 9);
mPUSHi(tm.tm_sec);
mPUSHi(tm.tm_min);
lib/Crypt/OpenSSL3.xs view on Meta::CPAN
const char *EVP_RAND_get_name(Crypt::OpenSSL3::Random rand)
const char *EVP_RAND_get_description(Crypt::OpenSSL3::Random rand)
void EVP_RAND_names_list_all(Crypt::OpenSSL3::Random rand)
PPCODE:
PUTBACK;
EVP_RAND_names_do_all(rand, EVP_name_callback, iTHX);
SPAGAIN;
void EVP_RAND_list_all_provided(classname)
PPCODE:
PUTBACK;
EVP_RAND_do_all_provided(NULL, EVP_RAND_provided_callback, iTHX);
SPAGAIN;
SV* EVP_RAND_get_param(Crypt::OpenSSL3::Random rand, const char* name)
lib/Crypt/OpenSSL3.xs view on Meta::CPAN
const char *EVP_CIPHER_get_name(Crypt::OpenSSL3::Cipher cipher)
const char *EVP_CIPHER_get_description(Crypt::OpenSSL3::Cipher cipher)
void EVP_CIPHER_names_list_all(Crypt::OpenSSL3::Cipher cipher)
PPCODE:
PUTBACK;
EVP_CIPHER_names_do_all(cipher, EVP_name_callback, iTHX);
SPAGAIN;
void EVP_CIPHER_list_all_provided(classname)
PPCODE:
PUTBACK;
EVP_CIPHER_do_all_provided(NULL, EVP_CIPHER_provided_callback, iTHX);
SPAGAIN;
SV* EVP_CIPHER_get_param(Crypt::OpenSSL3::Cipher cipher, const char* name)
lib/Crypt/OpenSSL3.xs view on Meta::CPAN
const char *EVP_MD_get_description(Crypt::OpenSSL3::MD md)
bool EVP_MD_is_a(Crypt::OpenSSL3::MD md, const char *name)
void EVP_MD_names_list_all(Crypt::OpenSSL3::MD md)
PPCODE:
PUTBACK;
EVP_MD_names_do_all(md, EVP_name_callback, iTHX);
SPAGAIN;
void EVP_MD_list_all_provided(classname)
PPCODE:
PUTBACK;
EVP_MD_do_all_provided(NULL, EVP_MD_provided_callback, iTHX);
SPAGAIN;
int EVP_MD_get_type(Crypt::OpenSSL3::MD md)
lib/Crypt/OpenSSL3.xs view on Meta::CPAN
const char *EVP_MAC_get_description(Crypt::OpenSSL3::MAC mac)
bool EVP_MAC_is_a(Crypt::OpenSSL3::MAC mac, const char *name)
void EVP_MAC_names_list_all(Crypt::OpenSSL3::MAC mac)
PPCODE:
PUTBACK;
EVP_MAC_names_do_all(mac, EVP_name_callback, iTHX);
SPAGAIN;
void EVP_MAC_list_all_provided(classname)
PPCODE:
PUTBACK;
EVP_MAC_do_all_provided(NULL, EVP_MAC_provided_callback, iTHX);
SPAGAIN;
SV* EVP_MAC_get_param(Crypt::OpenSSL3::MAC mac, const char* name)
lib/Crypt/OpenSSL3.xs view on Meta::CPAN
const char *EVP_KDF_get_description(Crypt::OpenSSL3::KDF kdf)
bool EVP_KDF_is_a(Crypt::OpenSSL3::KDF kdf, const char *name)
void EVP_KDF_names_list_all(Crypt::OpenSSL3::KDF kdf)
PPCODE:
PUTBACK;
EVP_KDF_names_do_all(kdf, EVP_name_callback, iTHX);
SPAGAIN;
void EVP_KDF_list_all_provided(classname)
PPCODE:
PUTBACK;
EVP_KDF_do_all_provided(NULL, EVP_KDF_provided_callback, iTHX);
SPAGAIN;
SV* EVP_KDF_get_param(Crypt::OpenSSL3::KDF kdf, const char* name)
lib/Crypt/OpenSSL3.xs view on Meta::CPAN
const char *EVP_SIGNATURE_get_description(Crypt::OpenSSL3::Signature signature)
bool EVP_SIGNATURE_is_a(Crypt::OpenSSL3::Signature signature, const char *name)
void EVP_SIGNATURE_names_list_all(Crypt::OpenSSL3::Signature signature)
PPCODE:
PUTBACK;
EVP_SIGNATURE_names_do_all(signature, EVP_name_callback, iTHX);
SPAGAIN;
void EVP_SIGNATURE_list_all_provided(classname)
PPCODE:
PUTBACK;
EVP_SIGNATURE_do_all_provided(NULL, EVP_SIGNATURE_provided_callback, iTHX);
SPAGAIN;
lib/Crypt/OpenSSL3.xs view on Meta::CPAN
bool EVP_PKEY_is_a(Crypt::OpenSSL3::PKey pkey, const char *name)
bool EVP_PKEY_can_sign(Crypt::OpenSSL3::PKey pkey)
void EVP_PKEY_type_names_list_all(Crypt::OpenSSL3::PKey pkey)
PPCODE:
PUTBACK;
EVP_PKEY_type_names_do_all(pkey, EVP_name_callback, iTHX);
SPAGAIN;
const char *EVP_PKEY_get_type_name(Crypt::OpenSSL3::PKey key)
Crypt-PQClean-Sign
view release on metacpan or search on metacpan
MODULE = Crypt::PQClean::Sign PACKAGE = Crypt::PQClean::Sign
void
falcon512_keypair()
PPCODE:
unsigned char pk[PQCLEAN_FALCON512_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_FALCON512_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_FALCON512_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
falcon512_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_FALCON512_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
falcon512_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
XSRETURN_IV(ret == 0 ? 1 : 0);
void
falcon1024_keypair()
PPCODE:
unsigned char pk[PQCLEAN_FALCON1024_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_FALCON1024_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_FALCON1024_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
falcon1024_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_FALCON1024_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
falcon1024_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
XSRETURN_IV(ret == 0 ? 1 : 0);
void
mldsa44_keypair()
PPCODE:
unsigned char pk[PQCLEAN_MLDSA44_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_MLDSA44_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_MLDSA44_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
mldsa44_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_MLDSA44_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
mldsa44_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
XSRETURN_IV(ret == 0 ? 1 : 0);
void
mldsa65_keypair()
PPCODE:
unsigned char pk[PQCLEAN_MLDSA65_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_MLDSA65_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_MLDSA65_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
mldsa65_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_MLDSA65_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
mldsa65_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
XSRETURN_IV(ret == 0 ? 1 : 0);
void
mldsa87_keypair()
PPCODE:
unsigned char pk[PQCLEAN_MLDSA87_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_MLDSA87_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_MLDSA87_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
mldsa87_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_MLDSA87_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
mldsa87_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
XSRETURN_IV(ret == 0 ? 1 : 0);
void
sphincs_shake128f_keypair()
PPCODE:
unsigned char pk[PQCLEAN_SPHINCSSHAKE128FSIMPLE_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_SPHINCSSHAKE128FSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_SPHINCSSHAKE128FSIMPLE_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
sphincs_shake128f_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_SPHINCSSHAKE128FSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
sphincs_shake128f_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
XSRETURN_IV(ret == 0 ? 1 : 0);
void
sphincs_shake128s_keypair()
PPCODE:
unsigned char pk[PQCLEAN_SPHINCSSHAKE128SSIMPLE_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_SPHINCSSHAKE128SSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_SPHINCSSHAKE128SSIMPLE_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
sphincs_shake128s_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_SPHINCSSHAKE128SSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
sphincs_shake128s_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
XSRETURN_IV(ret == 0 ? 1 : 0);
void
sphincs_shake192f_keypair()
PPCODE:
unsigned char pk[PQCLEAN_SPHINCSSHAKE192FSIMPLE_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_SPHINCSSHAKE192FSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_SPHINCSSHAKE192FSIMPLE_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
sphincs_shake192f_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_SPHINCSSHAKE192FSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
sphincs_shake192f_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
XSRETURN_IV(ret == 0 ? 1 : 0);
void
sphincs_shake192s_keypair()
PPCODE:
unsigned char pk[PQCLEAN_SPHINCSSHAKE192SSIMPLE_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_SPHINCSSHAKE192SSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_SPHINCSSHAKE192SSIMPLE_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
sphincs_shake192s_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_SPHINCSSHAKE192SSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
sphincs_shake192s_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
XSRETURN_IV(ret == 0 ? 1 : 0);
void
sphincs_shake256f_keypair()
PPCODE:
unsigned char pk[PQCLEAN_SPHINCSSHAKE256FSIMPLE_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_SPHINCSSHAKE256FSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_SPHINCSSHAKE256FSIMPLE_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
sphincs_shake256f_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_SPHINCSSHAKE256FSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
sphincs_shake256f_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
XSRETURN_IV(ret == 0 ? 1 : 0);
void
sphincs_shake256s_keypair()
PPCODE:
unsigned char pk[PQCLEAN_SPHINCSSHAKE256SSIMPLE_CLEAN_CRYPTO_PUBLICKEYBYTES];
unsigned char sk[PQCLEAN_SPHINCSSHAKE256SSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES];
int ret = PQCLEAN_SPHINCSSHAKE256SSIMPLE_CLEAN_crypto_sign_keypair(pk, sk);
if (ret != 0) {
croak("Key pair generation failed");
void
sphincs_shake256s_sign(message, sk)
SV* message
SV* sk
PPCODE:
STRLEN msg_len, sk_len;
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* sk_bytes = (unsigned char*)SvPVbyte(sk, sk_len);
if (sk_len != PQCLEAN_SPHINCSSHAKE256SSIMPLE_CLEAN_CRYPTO_SECRETKEYBYTES) {
int
sphincs_shake256s_verify(signature, message, pk)
SV* signature
SV* message
SV* pk
PPCODE:
STRLEN sig_len, msg_len, pk_len;
const unsigned char* sig = (unsigned char*)SvPVbyte(signature, sig_len);
const unsigned char* msg = (unsigned char*)SvPVbyte(message, msg_len);
const unsigned char* pk_bytes = (unsigned char*)SvPVbyte(pk, pk_len);
Crypt-RIPEMD160
view release on metacpan or search on metacpan
RIPEMD160.xs view on Meta::CPAN
void
reset(ripemd160)
Crypt::RIPEMD160 ripemd160
PPCODE:
{
RIPEMD160_init(ripemd160);
/* return self for method chaining */
XSRETURN(1);
}
RIPEMD160.xs view on Meta::CPAN
void
rmd160_add(ripemd160, ...)
Crypt::RIPEMD160 ripemd160
PPCODE:
{
STRLEN len;
byte *strptr;
int i;
Crypt-Scrypt
view release on metacpan or search on metacpan
double max_time
PREINIT:
char *in_str, *key_str, *out_str;
STRLEN in_len, key_len;
int status;
PPCODE:
if (SvROK(in)) in = SvRV(in);
in_str = SvPVbyte(in, in_len);
key_str = SvPVbyte(key, key_len);
Newx(out_str, 128 + in_len, char);
status = scryptenc_buf((const uint8_t *)in_str, in_len,
double max_time
PREINIT:
char *in_str, *key_str, *out_str;
STRLEN in_len, key_len, out_len;
int status;
PPCODE:
if (SvROK(in)) in = SvRV(in);
in_str = SvPVbyte(in, in_len);
key_str = SvPVbyte(key, key_len);
Newx(out_str, in_len - 128, char);
status = scryptdec_buf((const uint8_t *)in_str, in_len,
Crypt-SecretBuffer
view release on metacpan or search on metacpan
SecretBuffer.xs view on Meta::CPAN
Crypt::SecretBuffer::Exports::secret_buffer = 2
INIT:
SV *buf_ref= NULL;
secret_buffer *buf= secret_buffer_new(0, &buf_ref);
int i, next_arg= ix == 0? 1 : 0;
PPCODE:
if (items - next_arg == 1) {
secret_buffer_splice_sv(buf, 0, 0, ST(next_arg));
}
else {
if ((items - next_arg) & 1)
SecretBuffer.xs view on Meta::CPAN
secret_buffer_byte_range stack_ranges[16], *ranges= stack_ranges;
if ((items-1) > 16) {
Newx(ranges, (items-1), secret_buffer_byte_range);
SAVEFREEPV(ranges);
}
PPCODE:
for (i= 0; i < items-1; i++) {
ranges[i].ptr= secret_buffer_SvPVbyte(ST(i+1), &ranges[i].len);
len_sum += ranges[i].len;
}
secret_buffer_set_len(buf, from_ofs + len_sum);
SecretBuffer.xs view on Meta::CPAN
length(buf, val=NULL)
auto_secret_buffer buf
SV *val
ALIAS:
len = 1
PPCODE:
if (val) { /* writing */
IV ival= SvIV(val);
if (ival < 0) ival= 0;
secret_buffer_set_len(buf, ival);
/* return self, for chaining */
SecretBuffer.xs view on Meta::CPAN
void
capacity(buf, val=NULL, flags= 0)
auto_secret_buffer buf
SV *val
secret_buffer_alloc_flags flags
PPCODE:
if (val) { /* wiritng */
IV ival= SvIV(val);
if (ival < 0) ival= 0;
if (flags & SECRET_BUFFER_AT_LEAST)
secret_buffer_alloc_at_least(buf, ival);
SecretBuffer.xs view on Meta::CPAN
XSRETURN(1);
void
clear(buf)
auto_secret_buffer buf
PPCODE:
secret_buffer_realloc(buf, 0);
XSRETURN(1); /* self, for chaining */
IV
index(buf, pattern, ofs_sv= &PL_sv_undef)
SecretBuffer.xs view on Meta::CPAN
if (!secret_buffer_parse_init(&parse, buf,
ofs, ofs + normalize_offset(len, buf->len - ofs),
(flags & SECRET_BUFFER_ENCODING_MASK)
))
croak("%s", parse.error);
PPCODE:
if (secret_buffer_match(&parse, pattern, flags)) {
PUSHs(sv_2mortal(newSViv(parse.pos - (U8*) buf->data)));
PUSHs(sv_2mortal(newSViv(parse.lim - parse.pos)));
}
else if (parse.error)
SecretBuffer.xs view on Meta::CPAN
splice(buf, ofs, len, replacement)
secret_buffer *buf
IV ofs
IV len
SV *replacement
PPCODE:
/* normalize negative offset, and clamp to valid range */
ofs= normalize_offset(ofs, buf->len);
/* normalize negative count, and clamp to valid range */
len= normalize_offset(len, buf->len - ofs);
secret_buffer_splice_sv(buf, ofs, len, replacement);
SecretBuffer.xs view on Meta::CPAN
INIT:
unsigned char *sub_start;
secret_buffer *sub_buf= NULL;
SV *sub_ref= NULL;
IV count= count_sv? SvIV(count_sv) : buf->len;
PPCODE:
/* normalize negative offset, and clamp to valid range */
ofs= normalize_offset(ofs, buf->len);
/* normalize negative count, and clamp to valid range */
count= normalize_offset(count, buf->len - ofs);
sub_start= (unsigned char*) buf->data + ofs;
SecretBuffer.xs view on Meta::CPAN
void
append_asn1_der_length(buf, val)
secret_buffer *buf
UV val
PPCODE:
secret_buffer_append_uv_asn1_der_length(buf, val);
void
append_base128le(buf, val)
secret_buffer *buf
UV val
PPCODE:
secret_buffer_append_uv_base128le(buf, val);
void
append_base128be(buf, val)
secret_buffer *buf
UV val
PPCODE:
secret_buffer_append_uv_base128be(buf, val);
void
append_lenprefixed(buf, ...)
secret_buffer *buf
INIT:
size_t bytes_needed= 0;
IV i;
PPCODE:
/* Add up all the lengths and over-estimate 9 bytes for each length specifier */
for (i= 1; i < items; i++) {
STRLEN len;
secret_buffer_SvPVbyte(ST(i), &len);
bytes_needed += 9 + len;
SecretBuffer.xs view on Meta::CPAN
auto_secret_buffer buf
PerlIO *handle
IV count
INIT:
IV got;
PPCODE:
got= secret_buffer_append_sysread(buf, handle, count);
if (got < 0)
XSRETURN_UNDEF;
else
PUSHs(sv_2mortal(newSViv(got)));
SecretBuffer.xs view on Meta::CPAN
auto_secret_buffer buf
PerlIO *handle
IV count
INIT:
int got;
PPCODE:
got= secret_buffer_append_read(buf, handle, count);
if (got < 0)
XSRETURN_UNDEF;
else
PUSHs(sv_2mortal(newSViv(got)));
SecretBuffer.xs view on Meta::CPAN
_append_console_line(buf, handle)
auto_secret_buffer buf
PerlIO *handle
INIT:
int got;
PPCODE:
got= secret_buffer_append_console_line(buf, handle);
ST(0)= got == SECRET_BUFFER_GOTLINE? &PL_sv_yes
: got == SECRET_BUFFER_EOF? &PL_sv_no
: &PL_sv_undef;
XSRETURN(1);
SecretBuffer.xs view on Meta::CPAN
PerlIO *io
IV ofs
IV count
INIT:
IV wrote;
PPCODE:
wrote= secret_buffer_syswrite(buf, io, ofs, count);
ST(0)= (wrote < 0)? &PL_sv_undef : sv_2mortal(newSViv(wrote));
XSRETURN(1);
void
SecretBuffer.xs view on Meta::CPAN
IV ofs
IV count
INIT:
IV wrote;
SV *ref_out= NULL;
PPCODE:
wrote= secret_buffer_write_async(buf, io, ofs, count, GIMME_V == G_VOID? NULL : &ref_out);
/* wrote == 0 means that it supplied a result promise object, which is already mortal.
* but avoid creating one when called in void context. */
ST(0)= wrote? sv_2mortal(newSViv(wrote)) : ref_out? ref_out : &PL_sv_undef;
XSRETURN(1);
SecretBuffer.xs view on Meta::CPAN
void
stringify(buf, ...)
auto_secret_buffer buf
INIT:
SV **field= hv_fetch((HV*)SvRV(ST(0)), "stringify_mask", 14, 0);
PPCODE:
if (!field || !*field) {
ST(0)= sv_2mortal(newSVpvn("[REDACTED]", 10));
} else if (SvOK(*field)) {
ST(0)= *field;
} else {
SecretBuffer.xs view on Meta::CPAN
unmask_to(buf, coderef)
secret_buffer *buf
SV *coderef
INIT:
int count= 0;
PPCODE:
PUSHMARK(SP);
EXTEND(SP, 1);
PUSHs(secret_buffer_get_stringify_sv(buf));
PUTBACK;
count= call_sv(coderef, GIMME_V);
SecretBuffer.xs view on Meta::CPAN
unmask_secrets_to(coderef, ...)
SV *coderef
INIT:
int count= 0, i;
secret_buffer *buf= NULL;
PPCODE:
PUSHMARK(SP);
EXTEND(SP, items);
for (i= 1; i < items; i++) {
if (SvOK(ST(i)) && SvROK(ST(i)) && (buf= secret_buffer_from_magic(ST(i), 0)))
PUSHs(secret_buffer_get_stringify_sv(buf));
SecretBuffer.xs view on Meta::CPAN
void
_debug_charset(cset)
secret_buffer_charset *cset
INIT:
HV *hv;
PPCODE:
PUSHs(sv_2mortal((SV*)newRV_noinc((SV*)(hv= newHV()))));
hv_stores(hv, "bitmap", newSVpvn((char*)cset->bitmap, sizeof(cset->bitmap)));
hv_stores(hv, "unicode_above_7F", newSViv(cset->unicode_above_7F));
MODULE = Crypt::SecretBuffer PACKAGE = Crypt::SecretBuffer::AsyncResult
SecretBuffer.xs view on Meta::CPAN
wait(result, timeout=-1)
secret_buffer_async_result *result
NV timeout
INIT:
IV os_err, bytes_written;
PPCODE:
if (secret_buffer_async_result_recv(result, (IV)(timeout*1000), &bytes_written, &os_err)) {
EXTEND(sp, 2);
ST(0)= sv_2mortal(newSViv(bytes_written));
ST(1)= sv_2mortal(newSViv(os_err));
XSRETURN(2);
SecretBuffer.xs view on Meta::CPAN
}
}
}
if (!handle)
croak("'handle' is required");
PPCODE:
ST(0)= &PL_sv_undef;
/* if it fails to initialize, return undef for 'maybe_new', else die */
if (!sb_console_state_init(aTHX_ &cstate, handle)) {
if (ix == 0)
croak("Can't read console/tty state");
SecretBuffer.xs view on Meta::CPAN
IV base_pos= subspan? span->pos : 0;
IV pos=0, lim=0, len=0, base_lim=0;
int encoding= span? span->encoding : 0, i;
SV *encoding_sv= NULL;
bool have_pos= false, have_lim= false, have_len= false;
PPCODE:
//warn("items=%d span=%p buf=%p base_pos=%d", (int)items, span, buf, (int)base_pos);
// 3-argument form, only usable when first arg is a buffer or refs a buffer
if (buf && items >= 2 && looks_like_number(ST(1))) {
pos= SvIV(ST(1));
have_pos= true;
SecretBuffer.xs view on Meta::CPAN
SV *newval_sv
INIT:
SV *enc_const;
AV *encodings= get_av("Crypt::SecretBuffer::_encodings", 0);
if (!encodings) croak("BUG");
PPCODE:
if (newval_sv)
if (!parse_encoding(aTHX_ newval_sv, &span->encoding))
croak("Invalid encoding");
enc_const= *av_fetch(encodings, span->encoding, 1);
if (!enc_const || !SvOK(enc_const))
SecretBuffer.xs view on Meta::CPAN
secret_buffer_span *span= secret_buffer_span_from_magic(self, SECRET_BUFFER_MAGIC_OR_DIE);
secret_buffer_parse p;
if (!secret_buffer_parse_init_from_sv(&p, self))
croak("%s", p.error);
PERL_UNUSED_VAR(ix);
PPCODE:
if (p.lim - p.pos >= 3 && p.pos[0] == 0xEF && p.pos[1] == 0xBB && p.pos[2] == 0xBF) {
span->encoding= SECRET_BUFFER_ENCODING_UTF8;
span->pos += 3;
}
else if (p.lim - p.pos >= 2 && p.pos[0] == 0xFF && p.pos[1] == 0xFE) {
SecretBuffer.xs view on Meta::CPAN
if (op == 3 || op == 4 || op == 5)
pattern= get_sv("Crypt::SecretBuffer::Span::default_trim_regex", 0);
if (!pattern)
croak("pattern is required");
}
PPCODE:
matched= secret_buffer_match(&parse, pattern, flags);
if (parse.error)
croak("%s", parse.error);
switch (op) {
case 1: // parse
SecretBuffer.xs view on Meta::CPAN
UV len;
size_t ofs;
/* treat an invalid span as a bug, rather than returning it to the user in the err_out param */
if (!secret_buffer_parse_init_from_sv(&p, self))
croak("%s", p.error);
PPCODE:
while (count && p.pos < p.lim) {
if (!secret_buffer_parse_uv_base128be(&p, &len)) {
span->last_error= p.error;
XSRETURN_EMPTY;
}
SecretBuffer.xs view on Meta::CPAN
SV *dst_sv= NULL;
int next_arg, dst_encoding= -1;
secret_buffer_parse src;
if (!secret_buffer_parse_init_from_sv(&src, self))
croak("%s", src.error);
PPCODE:
if (ix > 0) { /* called as 'copy_to' or 'append_to' */
if (items < 2)
croak("Missing copy/append destination");
dst_sv= ST(1);
next_arg= 2;
Crypt-Sodium-Nitrate
view release on metacpan or search on metacpan
void
encrypt(SV* msg, SV* nonce, SV* key)
INIT:
SV* encrypted_sv;
PPCODE:
{
encrypted_sv = sodium_encrypt(msg, nonce, key);
mXPUSHs( encrypted_sv );
XSRETURN(1);
}
void
decrypt(SV* ciphertext, SV* nonce, SV* key)
INIT:
SV* decrypted_sv;
PPCODE:
{
decrypted_sv = sodium_decrypt(ciphertext, nonce, key);
mXPUSHs( decrypted_sv );
XSRETURN(1);
}
Crypt-Sodium-XS
view release on metacpan or search on metacpan
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));
Crypt-U2F-Server
view release on metacpan or search on metacpan
char * buf
INIT:
char* pk[65];
char kh[1000];
char* result;
PPCODE:
result = u2fclib_verifyRegistration(ctx, buf, pk);
if(!result) {
XSRETURN_UNDEF;
}
else {
( run in 3.486 seconds using v1.01-cache-2.11-cpan-71847e10f99 )