CryptX
view release on metacpan - search on metacpan
view release on metacpan or search on metacpan
src/ltc/headers/tomcrypt_pk.h view on Meta::CPAN
int dh_set_pg(const unsigned char *p, unsigned long plen,
const unsigned char *g, unsigned long glen,
dh_key *key);
int dh_set_pg_dhparam(const unsigned char *dhparam, unsigned long dhparamlen, dh_key *key);
int dh_set_pg_groupsize(int groupsize, dh_key *key);
int dh_set_key(const unsigned char *in, unsigned long inlen, int type, dh_key *key);
int dh_generate_key(prng_state *prng, int wprng, dh_key *key);
int dh_shared_secret(const dh_key *private_key, const dh_key *public_key,
unsigned char *out, unsigned long *outlen);
void dh_free(dh_key *key);
int dh_export_key(void *out, unsigned long *outlen, int type, const dh_key *key);
#endif /* LTC_MDH */
/* ---- ECC Routines ---- */
#ifdef LTC_MECC
src/ltc/pk/dh/dh_shared_secret.c view on Meta::CPAN
/* LibTomCrypt, modular cryptographic library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#include "tomcrypt_private.h"
#ifdef LTC_MDH
/**
Create a DH shared secret.
@param private_key The private DH key in the pair
@param public_key The public DH key in the pair
@param out [out] The destination of the shared data
@param outlen [in/out] The max size and resulting size of the shared data.
@return CRYPT_OK if successful
*/
int dh_shared_secret(const dh_key *private_key, const dh_key *public_key,
unsigned char *out, unsigned long *outlen)
{
void *tmp;
unsigned long x;
int err;
LTC_ARGCHK(private_key != NULL);
LTC_ARGCHK(public_key != NULL);
LTC_ARGCHK(out != NULL);
LTC_ARGCHK(outlen != NULL);
/* types valid? */
if (private_key->type != PK_PRIVATE) {
return CRYPT_PK_NOT_PRIVATE;
}
/* same DH group? */
if (mp_cmp(private_key->prime, public_key->prime) != LTC_MP_EQ) { return CRYPT_PK_TYPE_MISMATCH; }
if (mp_cmp(private_key->base, public_key->base) != LTC_MP_EQ) { return CRYPT_PK_TYPE_MISMATCH; }
/* init big numbers */
if ((err = mp_init(&tmp)) != CRYPT_OK) {
return err;
}
/* check public key */
if ((err = dh_check_pubkey(public_key)) != CRYPT_OK) {
goto error;
}
/* compute tmp = y^x mod p */
if ((err = mp_exptmod(public_key->y, private_key->x, private_key->prime, tmp)) != CRYPT_OK) {
goto error;
}
/* enough space for output? */
x = (unsigned long)mp_unsigned_bin_size(tmp);
if (*outlen < x) {
*outlen = x;
err = CRYPT_BUFFER_OVERFLOW;
goto error;
}
src/ltc/pk/dsa/dsa_shared_secret.c view on Meta::CPAN
/**
@file dsa_shared_secret.c
DSA Crypto, Tom St Denis
*/
#ifdef LTC_MDSA
/**
Create a DSA shared secret between two keys
@param private_key The private DSA key (the exponent)
@param base The base of the exponentiation (allows this to be used for both encrypt and decrypt)
@param public_key The public key
@param out [out] Destination of the shared secret
@param outlen [in/out] The max size and resulting size of the shared secret
@return CRYPT_OK if successful
*/
int dsa_shared_secret(void *private_key, void *base,
const dsa_key *public_key,
unsigned char *out, unsigned long *outlen)
{
unsigned long x;
void *res;
int err;
LTC_ARGCHK(private_key != NULL);
LTC_ARGCHK(public_key != NULL);
LTC_ARGCHK(out != NULL);
LTC_ARGCHK(outlen != NULL);
/* make new point */
if ((err = mp_init(&res)) != CRYPT_OK) {
return err;
}
if ((err = mp_exptmod(base, private_key, public_key->p, res)) != CRYPT_OK) {
mp_clear(res);
return err;
}
x = (unsigned long)mp_unsigned_bin_size(res);
if (*outlen < x) {
*outlen = x;
err = CRYPT_BUFFER_OVERFLOW;
goto done;
}
src/ltc/pk/ec25519/ec25519_export.c view on Meta::CPAN
@return CRYPT_OK if successful
*/
int ec25519_export( unsigned char *out, unsigned long *outlen,
int which,
const curve25519_key *key)
{
int err, std;
const char* OID;
unsigned long oid[16], oidlen;
ltc_asn1_list alg_id[1];
unsigned char private_key[34];
unsigned long version, private_key_len = sizeof(private_key);
LTC_ARGCHK(out != NULL);
LTC_ARGCHK(outlen != NULL);
LTC_ARGCHK(key != NULL);
std = which & PK_STD;
which &= ~PK_STD;
if (which == PK_PRIVATE) {
if(key->type != PK_PRIVATE) return CRYPT_PK_INVALID_TYPE;
src/ltc/pk/ecc/ecc_shared_secret.c view on Meta::CPAN
/**
@file ecc_shared_secret.c
ECC Crypto, Tom St Denis
*/
#ifdef LTC_MECC
/**
Create an ECC shared secret between two keys
@param private_key The private ECC key
@param public_key The public key
@param out [out] Destination of the shared secret (Conforms to EC-DH from ANSI X9.63)
@param outlen [in/out] The max size and resulting size of the shared secret
@return CRYPT_OK if successful
*/
int ecc_shared_secret(const ecc_key *private_key, const ecc_key *public_key,
unsigned char *out, unsigned long *outlen)
{
unsigned long x;
ecc_point *result;
void *prime, *a;
int err;
LTC_ARGCHK(private_key != NULL);
LTC_ARGCHK(public_key != NULL);
LTC_ARGCHK(out != NULL);
LTC_ARGCHK(outlen != NULL);
/* type valid? */
if (private_key->type != PK_PRIVATE) {
return CRYPT_PK_NOT_PRIVATE;
}
/* make new point */
result = ltc_ecc_new_point();
if (result == NULL) {
return CRYPT_MEM;
}
prime = private_key->dp.prime;
a = private_key->dp.A;
if ((err = ltc_mp.ecc_ptmul(private_key->k, &public_key->pubkey, result, a, prime, 1)) != CRYPT_OK) { goto done; }
x = (unsigned long)mp_unsigned_bin_size(prime);
if (*outlen < x) {
*outlen = x;
err = CRYPT_BUFFER_OVERFLOW;
goto done;
}
zeromem(out, x);
if ((err = mp_to_unsigned_bin(result->x, out + (x - mp_unsigned_bin_size(result->x)))) != CRYPT_OK) { goto done; }
src/ltc/pk/ed25519/ed25519_sign.c view on Meta::CPAN
/**
@file ed25519_shared_secret.c
Create an Ed25519 signature, Steffen Jaeckel
*/
#ifdef LTC_CURVE25519
static int s_ed25519_sign(const unsigned char *msg, unsigned long msglen,
unsigned char *sig, unsigned long *siglen,
const unsigned char *ctx, unsigned long ctxlen,
const curve25519_key *private_key)
{
unsigned char *s;
unsigned long long smlen;
int err;
LTC_ARGCHK(msg != NULL);
LTC_ARGCHK(sig != NULL);
LTC_ARGCHK(siglen != NULL);
LTC_ARGCHK(private_key != NULL);
if (private_key->algo != LTC_OID_ED25519) return CRYPT_PK_INVALID_TYPE;
if (private_key->type != PK_PRIVATE) return CRYPT_PK_INVALID_TYPE;
if (*siglen < 64uL) {
*siglen = 64uL;
return CRYPT_BUFFER_OVERFLOW;
}
smlen = msglen + 64;
s = XMALLOC(smlen);
if (s == NULL) return CRYPT_MEM;
err = tweetnacl_crypto_sign(s, &smlen,
msg, msglen,
private_key->priv, private_key->pub,
ctx, ctxlen);
XMEMCPY(sig, s, 64uL);
*siglen = 64uL;
#ifdef LTC_CLEAN_STACK
zeromem(s, smlen);
#endif
XFREE(s);
return err;
}
/**
Create an Ed25519ctx signature.
@param msg The data to be signed
@param msglen [in] The size of the date to be signed
@param sig [out] The destination of the shared data
@param siglen [in/out] The max size and resulting size of the shared data.
@param ctx [in] The context is a constant null terminated string
@param private_key The private Ed25519 key in the pair
@return CRYPT_OK if successful
*/
int ed25519ctx_sign(const unsigned char *msg, unsigned long msglen,
unsigned char *sig, unsigned long *siglen,
const unsigned char *ctx, unsigned long ctxlen,
const curve25519_key *private_key)
{
int err;
unsigned char ctx_prefix[292];
unsigned long ctx_prefix_size = sizeof(ctx_prefix);
LTC_ARGCHK(ctx != NULL);
if ((err = ec25519_crypto_ctx(ctx_prefix, &ctx_prefix_size, 0, ctx, ctxlen)) != CRYPT_OK)
return err;
return s_ed25519_sign(msg, msglen, sig, siglen, ctx_prefix, ctx_prefix_size, private_key);
}
/**
Create an Ed25519ph signature.
@param msg The data to be signed
@param msglen [in] The size of the date to be signed
@param sig [out] The destination of the shared data
@param siglen [in/out] The max size and resulting size of the shared data.
@param ctx [in] The context is a constant null terminated string
@param private_key The private Ed25519 key in the pair
@return CRYPT_OK if successful
*/
int ed25519ph_sign(const unsigned char *msg, unsigned long msglen,
unsigned char *sig, unsigned long *siglen,
const unsigned char *ctx, unsigned long ctxlen,
const curve25519_key *private_key)
{
int err;
unsigned char msg_hash[64];
unsigned char ctx_prefix[292];
unsigned long ctx_prefix_size = sizeof(ctx_prefix);
if ((err = ec25519_crypto_ctx(ctx_prefix, &ctx_prefix_size, 1, ctx, ctxlen)) != CRYPT_OK)
return err;
if ((err = tweetnacl_crypto_ph(msg_hash, msg, msglen)) != CRYPT_OK)
return err;
return s_ed25519_sign(msg_hash, sizeof(msg_hash), sig, siglen, ctx_prefix, ctx_prefix_size, private_key);
}
/**
Create an Ed25519 signature.
@param msg The data to be signed
@param msglen [in] The size of the date to be signed
@param sig [out] The destination of the shared data
@param siglen [in/out] The max size and resulting size of the shared data.
@param private_key The private Ed25519 key in the pair
@return CRYPT_OK if successful
*/
int ed25519_sign(const unsigned char *msg, unsigned long msglen,
unsigned char *sig, unsigned long *siglen,
const curve25519_key *private_key)
{
return s_ed25519_sign(msg, msglen, sig, siglen, NULL, 0, private_key);
}
#endif
src/ltc/pk/x25519/x25519_shared_secret.c view on Meta::CPAN
/**
@file x25519_shared_secret.c
Create a X25519 shared secret, Steffen Jaeckel
*/
#ifdef LTC_CURVE25519
/**
Create a X25519 shared secret.
@param private_key The private X25519 key in the pair
@param public_key The public X25519 key in the pair
@param out [out] The destination of the shared data
@param outlen [in/out] The max size and resulting size of the shared data.
@return CRYPT_OK if successful
*/
int x25519_shared_secret(const curve25519_key *private_key,
const curve25519_key *public_key,
unsigned char *out, unsigned long *outlen)
{
LTC_ARGCHK(private_key != NULL);
LTC_ARGCHK(public_key != NULL);
LTC_ARGCHK(out != NULL);
LTC_ARGCHK(outlen != NULL);
if(private_key->type != PK_PRIVATE) return CRYPT_PK_INVALID_TYPE;
if(*outlen < 32uL) {
*outlen = 32uL;
return CRYPT_BUFFER_OVERFLOW;
}
tweetnacl_crypto_scalarmult(out, private_key->priv, public_key->pub);
*outlen = 32uL;
return CRYPT_OK;
}
#endif
view release on metacpan - search on metacpan
( run in 1.866 second using v1.00-cache-2.02-grep-82fe00e-cpan-f73e49a70403 )