Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
home:Ledest:erlang:24
erlang
2554-crypto-generate_key-and-compute_key-error-...
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File 2554-crypto-generate_key-and-compute_key-error-ERR-error-.patch of Package erlang
From 8aa62ec02cd5cf5acd49f30dc532f9a3d3ae47d8 Mon Sep 17 00:00:00 2001 From: Hans Nilsson <hans@erlang.org> Date: Wed, 9 Mar 2022 09:03:29 +0100 Subject: [PATCH 4/8] crypto:generate_key and compute_key error:ERR -> error:{ERR,FileInfo,Description} --- lib/crypto/c_src/crypto.c | 2 +- lib/crypto/c_src/dh.c | 101 ++++++++++++++++------------------ lib/crypto/c_src/ec.c | 22 ++++---- lib/crypto/c_src/ec.h | 2 +- lib/crypto/c_src/ecdh.c | 41 ++++++-------- lib/crypto/c_src/evp.c | 67 +++++++++++----------- lib/crypto/doc/src/crypto.xml | 1 + lib/crypto/src/crypto.erl | 46 ++++++++++------ 8 files changed, 141 insertions(+), 141 deletions(-) diff --git a/lib/crypto/c_src/crypto.c b/lib/crypto/c_src/crypto.c index 519d35b93f..042d122f53 100644 --- a/lib/crypto/c_src/crypto.c +++ b/lib/crypto/c_src/crypto.c @@ -109,7 +109,7 @@ static ErlNifFunc nif_funcs[] = { {"srp_user_secret_nif", 7, srp_user_secret_nif, 0}, {"srp_host_secret_nif", 5, srp_host_secret_nif, 0}, - {"ec_key_generate", 2, ec_key_generate, 0}, + {"ec_generate_key_nif", 2, ec_generate_key_nif, 0}, {"ecdh_compute_key_nif", 3, ecdh_compute_key_nif, 0}, {"rand_seed_nif", 1, rand_seed_nif, 0}, diff --git a/lib/crypto/c_src/dh.c b/lib/crypto/c_src/dh.c index 67be0c81f0..8d3f53d06e 100644 --- a/lib/crypto/c_src/dh.c +++ b/lib/crypto/c_src/dh.c @@ -45,43 +45,43 @@ ERL_NIF_TERM dh_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar if (argv[0] != atom_undefined) { if (!get_bn_from_bin(env, argv[0], &priv_key_in)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 0, "Can't get bignum from binary")); } if (!enif_get_list_cell(env, argv[1], &head, &tail)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 1, "List with exactly two elements expected")); if (!get_bn_from_bin(env, head, &dh_p)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 1, "Can't get bignum from binary")); if (!enif_get_list_cell(env, tail, &head, &tail)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 1, "List with exactly two elements expected")); if (!get_bn_from_bin(env, head, &dh_g)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 1, "Can't get bignum from binary")); if (!enif_is_empty_list(env, tail)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 1, "List with exactly two elements expected")); if (!enif_get_uint(env, argv[2], &mpint)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 2, "Integer expected")); if (mpint != 0 && mpint != 4) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 2, "Integer 0 or 4 expected")); if (!enif_get_ulong(env, argv[3], &len)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 3, "Integer expected")); if (len > LONG_MAX) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 3, "Too big integer")); /* Load dh_params with values to use by the generator. Mem mgmnt transferred from dh_p etc to dh_params */ if ((dh_params = DH_new()) == NULL) - goto bad_arg; + assign_goto(ret, err, EXCP_ERROR(env, "Can't do DH_new")); if (priv_key_in) { if (!DH_set0_key(dh_params, NULL, priv_key_in)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 0, "Not accepted as private key")); /* On success, dh_params owns priv_key_in */ priv_key_in = NULL; } if (!DH_set0_pqg(dh_params, dh_p, NULL, dh_g)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 1, "P and/or G not accepted")); dh_p_shared = dh_p; /* Don't free this because dh_params owns it */ /* On success, dh_params owns dh_p and dh_g */ dh_p = NULL; @@ -91,56 +91,56 @@ ERL_NIF_TERM dh_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar int bn_len; if ((bn_len = BN_num_bits(dh_p_shared)) < 0) - goto bad_arg; + assign_goto(ret, err, EXCP_ERROR(env, "BN_num_bits < 0")); dh_p_shared = NULL; /* dh_params owns the reference */ if (len >= (size_t)bn_len) - goto bad_arg; + assign_goto(ret, err, EXCP_ERROR_N(env, 3, "Too big length")); if (!DH_set_length(dh_params, (long)len)) - goto bad_arg; + assign_goto(ret, err, EXCP_ERROR_N(env, 3, "The length is not accepted")); } #if defined(HAS_EVP_PKEY_CTX) && (! DISABLE_EVP_DH) if ((params = EVP_PKEY_new()) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_new")); /* set the key referenced by params to dh_params... */ if (EVP_PKEY_set1_DH(params, dh_params) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_set1_DH")); if ((ctx = EVP_PKEY_CTX_new(params, NULL)) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_CTX_new")); if (EVP_PKEY_keygen_init(ctx) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_keygen_init")); if ((dhkey = EVP_PKEY_new()) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_new")); /* key gen op, key written to ppkey (=last arg) */ if (EVP_PKEY_keygen(ctx, &dhkey) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_keygen")); DH_free(dh_params); if ((dh_params = EVP_PKEY_get1_DH(dhkey)) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_get1_DH")); #else if (!DH_generate_key(dh_params)) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't DH_generate_key")); #endif DH_get0_key(dh_params, &pub_key_gen, &priv_key_gen); if ((pub_len = BN_num_bytes(pub_key_gen)) < 0) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't get public key length")); if ((prv_len = BN_num_bytes(priv_key_gen)) < 0) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't get private key length")); if ((pub_ptr = enif_make_new_binary(env, (size_t)pub_len+mpint, &ret_pub)) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't allocate pub_ptr")); if ((prv_ptr = enif_make_new_binary(env, (size_t)prv_len+mpint, &ret_prv)) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't allocate prv_ptr")); if (mpint) { put_uint32(pub_ptr, (unsigned int)pub_len); @@ -151,9 +151,9 @@ ERL_NIF_TERM dh_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar } if (BN_bn2bin(pub_key_gen, pub_ptr) < 0) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't BN_bn2bin")); if (BN_bn2bin(priv_key_gen, prv_ptr) < 0) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't BN_bn2bin")); ERL_VALGRIND_MAKE_MEM_DEFINED(pub_ptr, pub_len); ERL_VALGRIND_MAKE_MEM_DEFINED(prv_ptr, prv_len); @@ -161,13 +161,7 @@ ERL_NIF_TERM dh_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar ret = enif_make_tuple2(env, ret_pub, ret_prv); goto done; - bad_arg: - ret = enif_make_badarg(env); - goto done; - err: - ret = atom_error; - done: if (priv_key_in) BN_free(priv_key_in); @@ -216,22 +210,22 @@ ERL_NIF_TERM dh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM arg ASSERT(argc == 3); if (!get_bn_from_bin(env, argv[0], &other_pub_key)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 0, "Can't get bignum from binary")); if (!get_bn_from_bin(env, argv[1], &priv_key)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 1, "Can't get bignum from binary")); if (!enif_get_list_cell(env, argv[2], &head, &tail)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 2, "List with exactly two elements expected")); if (!get_bn_from_bin(env, head, &dh_p)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 2, "Can't get bignum from binary")); if (!enif_get_list_cell(env, tail, &head, &tail)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 2, "List with exactly two elements expected")); if (!get_bn_from_bin(env, head, &dh_g)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 2, "Can't get bignum from binary")); if (!enif_is_empty_list(env, tail)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 2, "List with exactly two elements expected")); /* Note: DH_set0_key() does not allow setting only the * private key, although DH_compute_key() does not use the @@ -239,48 +233,45 @@ ERL_NIF_TERM dh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM arg * the public key to a copy of the private key. */ if ((dummy_pub_key = BN_dup(priv_key)) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't BN_dup")); if ((dh_priv = DH_new()) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't DH_new")); if (!DH_set0_key(dh_priv, dummy_pub_key, priv_key)) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't DH_set0_key")); /* dh_priv owns dummy_pub_key and priv_key now */ dummy_pub_key = NULL; priv_key = NULL; if (!DH_set0_pqg(dh_priv, dh_p, NULL, dh_g)) - goto err; + assign_goto(ret, err, EXCP_BADARG_N(env, 2, "P and/or G not accepted")); /* dh_priv owns dh_p and dh_g now */ dh_p = NULL; dh_g = NULL; if ((dh_size = DH_size(dh_priv)) < 0) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't DH_size")); if (!enif_alloc_binary((size_t)dh_size, &ret_bin)) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't allcate binary")); ret_bin_alloc = 1; if ((size = DH_compute_key(ret_bin.data, other_pub_key, dh_priv)) < 0) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't DH_compute_key")); if (size == 0) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "size == 0")); if ((size_t)size != ret_bin.size) { if (!enif_realloc_binary(&ret_bin, (size_t)size)) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't realloc binary")); } ret = enif_make_binary(env, &ret_bin); ret_bin_alloc = 0; goto done; - bad_arg: err: if (ret_bin_alloc) enif_release_binary(&ret_bin); - ret = enif_make_badarg(env); - done: if (other_pub_key) BN_free(other_pub_key); diff --git a/lib/crypto/c_src/ec.c b/lib/crypto/c_src/ec.c index fd66ecfab4..a7497f014a 100644 --- a/lib/crypto/c_src/ec.c +++ b/lib/crypto/c_src/ec.c @@ -426,11 +426,9 @@ int get_ec_key_sz(ErlNifEnv* env, return 1; } -#endif /* HAVE_EC */ -ERL_NIF_TERM ec_key_generate(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +ERL_NIF_TERM ec_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { /* (Curve, PrivKey) */ -#if defined(HAVE_EC) EC_KEY *key = NULL; const EC_GROUP *group; const EC_POINT *public_key; @@ -440,11 +438,11 @@ ERL_NIF_TERM ec_key_generate(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[] size_t size; if (!get_ec_key_sz(env, argv[0], argv[1], atom_undefined, &key, &size)) - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 1, "Couldn't get EC key")); if (argv[1] == atom_undefined) { if (!EC_KEY_generate_key(key)) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Couldn't generate EC key")); } group = EC_KEY_get0_group(key); @@ -463,15 +461,17 @@ ERL_NIF_TERM ec_key_generate(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[] goto done; err: - bad_arg: - ret = make_badarg_maybe(env); - done: if (key) EC_KEY_free(key); return ret; +} +#endif /* HAVE_EC */ -#else - return atom_notsup; -#endif + +#if ! defined(HAVE_EC) +ERL_NIF_TERM ec_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ /* (Curve, PrivKey) */ + return EXCP_NOTSUP_N(env, 0, "EC not supported"); } +#endif diff --git a/lib/crypto/c_src/ec.h b/lib/crypto/c_src/ec.h index e7b885cb0f..96e02643c8 100644 --- a/lib/crypto/c_src/ec.h +++ b/lib/crypto/c_src/ec.h @@ -33,6 +33,6 @@ int term2point(ErlNifEnv* env, ERL_NIF_TERM term, EC_GROUP *group, EC_POINT **pp ERL_NIF_TERM make_badarg_maybe(ErlNifEnv* env); #endif -ERL_NIF_TERM ec_key_generate(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]); +ERL_NIF_TERM ec_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]); #endif /* E_EC_H__ */ diff --git a/lib/crypto/c_src/ecdh.c b/lib/crypto/c_src/ecdh.c index 041c658808..9133878b58 100644 --- a/lib/crypto/c_src/ecdh.c +++ b/lib/crypto/c_src/ecdh.c @@ -29,7 +29,7 @@ ERL_NIF_TERM ecdh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM a /* (OtherPublicKey, Curve, My) */ { #if defined(HAVE_EC) - ERL_NIF_TERM ret; + ERL_NIF_TERM ret = atom_undefined; unsigned char *p; EC_KEY* key = NULL; int degree; @@ -39,44 +39,37 @@ ERL_NIF_TERM ecdh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM a EC_POINT *my_ecpoint = NULL; EC_KEY *other_ecdh = NULL; - ASSERT(argc == 3); - if (!get_ec_key_sz(env, argv[1], argv[2], atom_undefined, &key, NULL)) // my priv key - goto bad_arg; + assign_goto(ret, err, EXCP_BADARG_N(env, 2, "Couldn't get local key")); + if ((group = EC_GROUP_dup(EC_KEY_get0_group(key))) == NULL) - goto bad_arg; + assign_goto(ret, err, EXCP_ERROR(env, "Couldn't duplicate EC key")); + priv_key = EC_KEY_get0_private_key(key); - if (!term2point(env, argv[0], group, &my_ecpoint)) { - goto err; - } + if (!term2point(env, argv[0], group, &my_ecpoint)) + assign_goto(ret, err, EXCP_BADARG_N(env, 0, "Couldn't get ecpoint")); if ((other_ecdh = EC_KEY_new()) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Couldn't allocate EC_KEY")); + if (!EC_KEY_set_group(other_ecdh, group)) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Couldn't set group")); + if (!EC_KEY_set_private_key(other_ecdh, priv_key)) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Couldn't set private key")); if ((degree = EC_GROUP_get_degree(group)) <= 0) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Couldn't get degree")); field_size = (size_t)degree; if ((p = enif_make_new_binary(env, (field_size+7)/8, &ret)) == NULL) - goto err; - if (ECDH_compute_key(p, (field_size+7)/8, my_ecpoint, other_ecdh, NULL) < 1) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Couldn't allocate binary")); - goto done; - - bad_arg: - ret = make_badarg_maybe(env); - goto done; + if (ECDH_compute_key(p, (field_size+7)/8, my_ecpoint, other_ecdh, NULL) < 1) + assign_goto(ret, err, EXCP_ERROR(env, "Couldn't compute key")); err: - ret = enif_make_badarg(env); - - done: if (group) EC_GROUP_free(group); if (my_ecpoint) @@ -89,6 +82,6 @@ ERL_NIF_TERM ecdh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM a return ret; #else - return atom_notsup; + return EXCP_NOTSUP_N(env, 0, "EC not supported"); #endif } diff --git a/lib/crypto/c_src/evp.c b/lib/crypto/c_src/evp.c index 7491db3d57..00a6fe16ed 100644 --- a/lib/crypto/c_src/evp.c +++ b/lib/crypto/c_src/evp.c @@ -34,43 +34,53 @@ ERL_NIF_TERM evp_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar ASSERT(argc == 3); + /* Arg 0, Curve */ if (argv[0] == atom_x25519) type = EVP_PKEY_X25519; else if (argv[0] == atom_x448) type = EVP_PKEY_X448; else - goto bad_arg; + assign_goto(ret, bad_arg, EXCP_BADARG_N(env, 0, "Bad curve")); - if (!enif_inspect_binary(env, argv[1], &peer_bin)) - goto bad_arg; + /* Arg 2, MyBin (My private key) */ if (!enif_inspect_binary(env, argv[2], &my_bin)) - goto bad_arg; + assign_goto(ret, bad_arg, EXCP_BADARG_N(env, 2, "Binary expected")); if ((my_key = EVP_PKEY_new_raw_private_key(type, NULL, my_bin.data, my_bin.size)) == NULL) - goto err; + assign_goto(ret, err, EXCP_BADARG_N(env, 2, "Not a valid raw private key")); + if ((ctx = EVP_PKEY_CTX_new(my_key, NULL)) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR_N(env, 2, "Can't make context")); if (EVP_PKEY_derive_init(ctx) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_derive_init")); + + /* Arg 1, PeerBin (Peer public key) */ + if (!enif_inspect_binary(env, argv[1], &peer_bin)) + assign_goto(ret, bad_arg, EXCP_BADARG_N(env, 1, "Binary expected")); if ((peer_key = EVP_PKEY_new_raw_public_key(type, NULL, peer_bin.data, peer_bin.size)) == NULL) - goto err; + assign_goto(ret, err, EXCP_BADARG_N(env, 1, "Not a raw public peer key")); + if (EVP_PKEY_derive_set_peer(ctx, peer_key) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR_N(env, 1, "Can't EVP_PKEY_derive_set_peer")); + /* Find max size of the common key */ if (EVP_PKEY_derive(ctx, NULL, &max_size) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR_N(env, 1, "Can't get max size")); if (!enif_alloc_binary(max_size, &key_bin)) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't allocate")); + key_bin_alloc = 1; + + /* Derive the common key */ if (EVP_PKEY_derive(ctx, key_bin.data, &key_bin.size) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_derive")); if (key_bin.size < max_size) { if (!enif_realloc_binary(&key_bin, (size_t)key_bin.size)) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't shrink binary")); } ret = enif_make_binary(env, &key_bin); @@ -81,7 +91,6 @@ ERL_NIF_TERM evp_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar err: if (key_bin_alloc) enif_release_binary(&key_bin); - ret = enif_make_badarg(env); done: if (my_key) @@ -98,6 +107,7 @@ ERL_NIF_TERM evp_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar #endif } + ERL_NIF_TERM evp_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) /* (Curve) */ { @@ -119,46 +129,41 @@ ERL_NIF_TERM evp_generate_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM a else if (argv[0] == atom_ed448) type = EVP_PKEY_ED448; else - goto bad_arg; + assign_goto(ret, bad_arg, EXCP_BADARG_N(env, 0, "Bad curve")); if (argv[1] == atom_undefined) { if ((ctx = EVP_PKEY_CTX_new_id(type, NULL)) == NULL) - goto bad_arg; + assign_goto(ret, err, EXCP_ERROR(env, "Can't make context")); if (EVP_PKEY_keygen_init(ctx) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_keygen_init")); if (EVP_PKEY_keygen(ctx, &pkey) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_keygen")); } else { if (!enif_inspect_binary(env, argv[1], &prv_key)) - goto bad_arg; + assign_goto(ret, err, EXCP_ERROR_N(env, 1, "Can't get max size")); if ((pkey = EVP_PKEY_new_raw_private_key(type, NULL, prv_key.data, prv_key.size)) == NULL) - goto bad_arg; + assign_goto(ret, err, EXCP_ERROR_N(env, 1, "Can't EVP_PKEY_new_raw_private_key")); } if (EVP_PKEY_get_raw_public_key(pkey, NULL, &key_len) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR_N(env, 1, "Can't get max size")); if ((out_pub = enif_make_new_binary(env, key_len, &ret_pub)) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't allocate")); if (EVP_PKEY_get_raw_public_key(pkey, out_pub, &key_len) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_get_raw_public_key")); if (EVP_PKEY_get_raw_private_key(pkey, NULL, &key_len) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR_N(env, 1, "Can't get max size")); if ((out_priv = enif_make_new_binary(env, key_len, &ret_prv)) == NULL) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't allocate")); if (EVP_PKEY_get_raw_private_key(pkey, out_priv, &key_len) != 1) - goto err; + assign_goto(ret, err, EXCP_ERROR(env, "Can't EVP_PKEY_get_raw_private_key")); ret = enif_make_tuple2(env, ret_pub, ret_prv); goto done; bad_arg: - ret = enif_make_badarg(env); - goto done; - err: - ret = atom_error; - done: if (pkey) EVP_PKEY_free(pkey); diff --git a/lib/crypto/doc/src/crypto.xml b/lib/crypto/doc/src/crypto.xml index 0b20d715df..9ee2653c0c 100644 --- a/lib/crypto/doc/src/crypto.xml +++ b/lib/crypto/doc/src/crypto.xml @@ -1050,6 +1050,7 @@ end <name name="compute_key" arity="4" since="OTP R16B01"/> <fsummary>Computes the shared secret</fsummary> <desc> + <p>Uses the <seeerl marker="#error_3tup">3-tuple style</seeerl> for error handling.</p> <p>Computes the shared secret from the private key and the other party's public key. See also <seemfa marker="public_key:public_key#compute_key/2">public_key:compute_key/2</seemfa> </p> diff --git a/lib/crypto/src/crypto.erl b/lib/crypto/src/crypto.erl index bfdc8b784c..bffaacb043 100644 --- a/lib/crypto/src/crypto.erl +++ b/lib/crypto/src/crypto.erl @@ -1602,9 +1602,11 @@ generate_key(dh, DHParameters0, PrivateKey) -> [P,G,L] -> {[P,G], L}; [P,G] -> {[P,G], 0} end, - dh_generate_key_nif(ensure_int_as_bin(PrivateKey), - map_ensure_int_as_bin(DHParameters), - 0, Len); + ?nif_call(dh_generate_key_nif(ensure_int_as_bin(PrivateKey), + map_ensure_int_as_bin(DHParameters), + 0, Len), + {3, 2, -1, 2}, + [dh, DHParameters0, PrivateKey]); generate_key(srp, {host, [Verifier, Generator, Prime, Version]}, PrivArg) when is_binary(Verifier), is_binary(Generator), is_binary(Prime), is_atom(Version) -> @@ -1648,14 +1650,20 @@ generate_key(ecdh, Curve, PrivKey) when Curve == x448 ; generate_key(eddh, Curve, PrivKey); generate_key(eddh, Curve, PrivKey) when Curve == x448 ; Curve == x25519 -> - evp_generate_key_nif(Curve, ensure_int_as_bin(PrivKey)); + ?nif_call(evp_generate_key_nif(Curve, ensure_int_as_bin(PrivKey)), + {2, 3}, + [eddh, Curve, PrivKey] + ); generate_key(ecdh, Curve, PrivKey) -> - ec_key_generate(nif_curve_params(Curve), ensure_int_as_bin(PrivKey)); + ?nif_call(ec_generate_key_nif(nif_curve_params(Curve), ensure_int_as_bin(PrivKey))); generate_key(eddsa, Curve, PrivKey) when Curve == ed448 ; Curve == ed25519 -> - evp_generate_key_nif(Curve, ensure_int_as_bin(PrivKey)). + ?nif_call(evp_generate_key_nif(Curve, ensure_int_as_bin(PrivKey)), + {2, 3}, + [eddsa, Curve, PrivKey] + ). evp_generate_key_nif(_Curve, _PrivKey) -> ?nif_stub. @@ -1670,13 +1678,11 @@ evp_generate_key_nif(_Curve, _PrivKey) -> ?nif_stub. . compute_key(dh, OthersPublicKey, MyPrivateKey, DHParameters) -> - case dh_compute_key_nif(ensure_int_as_bin(OthersPublicKey), - ensure_int_as_bin(MyPrivateKey), - map_ensure_int_as_bin(DHParameters)) of - error -> erlang:error(computation_failed, - [dh,OthersPublicKey,MyPrivateKey,DHParameters]); - Ret -> Ret - end; + ?nif_call(dh_compute_key_nif(ensure_int_as_bin(OthersPublicKey), + ensure_int_as_bin(MyPrivateKey), + map_ensure_int_as_bin(DHParameters)), + {2, 3, 4}, + [dh, OthersPublicKey, MyPrivateKey, DHParameters]); compute_key(srp, HostPublic, {UserPublic, UserPrivate}, {user, [DerivedKey, Prime, Generator, Version | ScramblerArg]}) when @@ -1715,12 +1721,16 @@ compute_key(ecdh, Others, My, Curve) when Curve == x448 ; compute_key(eddh, Others, My, Curve) when Curve == x448 ; Curve == x25519 -> - evp_compute_key_nif(Curve, ensure_int_as_bin(Others), ensure_int_as_bin(My)); + ?nif_call(evp_compute_key_nif(Curve, ensure_int_as_bin(Others), ensure_int_as_bin(My)), + {2, 3, 4}, + [eddh, Others, My, Curve]); compute_key(ecdh, Others, My, Curve) -> - ecdh_compute_key_nif(ensure_int_as_bin(Others), - nif_curve_params(Curve), - ensure_int_as_bin(My)). + ?nif_call(ecdh_compute_key_nif(ensure_int_as_bin(Others), + nif_curve_params(Curve), + ensure_int_as_bin(My)), + {2, 4, 3}, + [ecdh, Others, My, Curve]). evp_compute_key_nif(_Curve, _OthersBin, _MyBin) -> ?nif_stub. @@ -2274,7 +2284,7 @@ dh_generate_key_nif(_PrivateKey, _DHParameters, _Mpint, _Length) -> ?nif_stub. %% MyPrivKey, OthersPublicKey = mpint() dh_compute_key_nif(_OthersPublicKey, _MyPrivateKey, _DHParameters) -> ?nif_stub. -ec_key_generate(_Curve, _Key) -> ?nif_stub. +ec_generate_key_nif(_Curve, _Key) -> ?nif_stub. ecdh_compute_key_nif(_Others, _Curve, _My) -> ?nif_stub. -- 2.34.1
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
