eccrypto/ecdh.cc

132 lines
4.4 KiB
C++
Raw Normal View History

2015-01-13 20:39:37 +01:00
#include <node.h>
#include <nan.h>
#include <openssl/evp.h>
#include <openssl/ec.h>
using v8::FunctionTemplate;
using v8::Object;
using v8::String;
2015-01-15 22:15:22 +01:00
static const size_t PRIVKEY_SIZE = 32;
static const size_t PUBKEY_SIZE = 65;
2018-12-11 15:47:43 +01:00
static const size_t COMPRESSED_PUBKEY_SIZE = 33;
2015-01-15 22:15:22 +01:00
#define CHECK(cond) do { if (!(cond)) goto error; } while (0)
2015-01-14 22:29:34 +01:00
2015-01-13 20:39:37 +01:00
int derive(const uint8_t* privkey_a, const uint8_t* pubkey_b, uint8_t* shared) {
int rc = -1;
int res;
BIGNUM* pkey_bn = NULL;
EC_KEY* pkey = NULL;
2018-12-11 15:47:43 +01:00
bool compressed = false;
2015-01-13 20:39:37 +01:00
EC_KEY* peerkey = NULL;
2018-12-11 15:47:43 +01:00
int compressed_y_bit = 0;
EC_POINT* peerkey_p = NULL;
EC_GROUP* peerkey_group = NULL;
BN_CTX* peerkey_ctx = NULL;
BIGNUM* peerkey_bn = NULL;
BIGNUM* peerkey_bn_x = NULL;
BIGNUM* peerkey_bn_y = NULL;
2015-01-13 20:39:37 +01:00
EVP_PKEY* evp_pkey = NULL;
EVP_PKEY* evp_peerkey = NULL;
EVP_PKEY_CTX* ctx = NULL;
size_t shared_len = PRIVKEY_SIZE;
// Private key A.
CHECK((pkey_bn = BN_bin2bn(privkey_a, PRIVKEY_SIZE, NULL)) != NULL);
CHECK((pkey = EC_KEY_new_by_curve_name(NID_secp256k1)) != NULL);
CHECK(EC_KEY_set_private_key(pkey, pkey_bn) == 1);
CHECK((evp_pkey = EVP_PKEY_new()) != NULL);
CHECK(EVP_PKEY_set1_EC_KEY(evp_pkey, pkey) == 1);
// Public key B.
CHECK((peerkey = EC_KEY_new_by_curve_name(NID_secp256k1)) != NULL);
2018-12-11 15:47:43 +01:00
(pubkey_b[0] == 2 || pubkey_b[0] == 3) ? compressed = true : compressed = false;
if (compressed) {
(pubkey_b[0] == 2) ? compressed_y_bit = 0 : compressed_y_bit = 1;
CHECK((peerkey_group = EC_GROUP_new_by_curve_name(NID_secp256k1)) != NULL);
CHECK((peerkey_p = EC_POINT_new(peerkey_group)) != NULL);
CHECK((peerkey_ctx = BN_CTX_new()) != NULL);
CHECK((peerkey_bn = BN_bin2bn(pubkey_b+1, COMPRESSED_PUBKEY_SIZE-1, NULL)) != NULL);
res = EC_POINT_set_compressed_coordinates_GFp(peerkey_group,
peerkey_p,
peerkey_bn,
compressed_y_bit,
NULL);
CHECK(res == 1);
res = EC_KEY_set_public_key(peerkey, peerkey_p);
}
else {
CHECK((peerkey_bn_x = BN_bin2bn(pubkey_b+1, PRIVKEY_SIZE, NULL)) != NULL);
CHECK((peerkey_bn_y = BN_bin2bn(pubkey_b+33, PRIVKEY_SIZE, NULL)) != NULL);
res = EC_KEY_set_public_key_affine_coordinates(peerkey,
2015-01-13 20:39:37 +01:00
peerkey_bn_x,
peerkey_bn_y);
2018-12-11 15:47:43 +01:00
}
2015-01-13 20:39:37 +01:00
CHECK(res == 1);
CHECK((evp_peerkey = EVP_PKEY_new()) != NULL);
CHECK(EVP_PKEY_set1_EC_KEY(evp_peerkey, peerkey) == 1);
// Derive shared secret.
CHECK((ctx = EVP_PKEY_CTX_new(evp_pkey, NULL)) != NULL);
CHECK(EVP_PKEY_derive_init(ctx) == 1);
CHECK(EVP_PKEY_derive_set_peer(ctx, evp_peerkey) == 1);
CHECK((EVP_PKEY_derive(ctx, shared, &shared_len)) == 1);
CHECK(shared_len == PRIVKEY_SIZE);
rc = 0;
error:
EVP_PKEY_CTX_free(ctx);
EVP_PKEY_free(evp_peerkey);
EC_KEY_free(peerkey);
BN_free(peerkey_bn_y);
BN_free(peerkey_bn_x);
2018-12-11 15:47:43 +01:00
BN_free(peerkey_bn);
BN_CTX_free(peerkey_ctx);
EC_GROUP_free(peerkey_group);
EC_POINT_free(peerkey_p);
2015-01-13 20:39:37 +01:00
EVP_PKEY_free(evp_pkey);
EC_KEY_free(pkey);
BN_free(pkey_bn);
return rc;
}
2015-01-15 22:15:22 +01:00
#undef CHECK
2015-01-13 20:39:37 +01:00
NAN_METHOD(Derive) {
if (info.Length() != 2 ||
!node::Buffer::HasInstance(info[0]) || // privkey_a
!node::Buffer::HasInstance(info[1])) { // pubkey_b
return Nan::ThrowError("Bad input");
2015-01-13 20:39:37 +01:00
}
char* privkey_a = node::Buffer::Data(info[0]);
size_t privkey_a_len = node::Buffer::Length(info[0]);
char* pubkey_b = node::Buffer::Data(info[1]);
size_t pubkey_b_len = node::Buffer::Length(info[1]);
2015-01-13 20:39:37 +01:00
if (privkey_a == NULL ||
privkey_a_len != PRIVKEY_SIZE ||
pubkey_b == NULL ||
2018-12-11 15:47:43 +01:00
!(pubkey_b_len == PUBKEY_SIZE || pubkey_b_len == COMPRESSED_PUBKEY_SIZE) ||
!(pubkey_b[0] == 4 || pubkey_b[0] == 3 || pubkey_b[0] == 2) ) {
return Nan::ThrowError("Bad input");
2015-01-13 20:39:37 +01:00
}
uint8_t* shared = (uint8_t *)malloc(PRIVKEY_SIZE);
2015-01-14 00:53:13 +01:00
if (shared == NULL ||
derive((uint8_t *)privkey_a, (uint8_t *)pubkey_b, shared)) {
2015-01-13 20:39:37 +01:00
free(shared);
return Nan::ThrowError("Internal error");
2015-01-13 20:39:37 +01:00
}
info.GetReturnValue().Set(
Nan::NewBuffer((char *)shared, PRIVKEY_SIZE).ToLocalChecked());
2015-01-13 20:39:37 +01:00
}
NAN_MODULE_INIT(InitAll) {
Nan::Set(target, Nan::New<String>("derive").ToLocalChecked(),
Nan::GetFunction(Nan::New<FunctionTemplate>(Derive)).ToLocalChecked());
2015-01-13 20:39:37 +01:00
}
NODE_MODULE(ecdh, InitAll)