Skip to content

Commit fcda409

Browse files
bnoordhuisbnoordhuis
committed
crypto: add crypto.createMac()
1 parent 066bdec commit fcda409

5 files changed

Lines changed: 237 additions & 3 deletions

File tree

‎lib/crypto.js‎

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,8 @@ const {
9191
} = require('internal/crypto/sig');
9292
const {
9393
Hash,
94-
Hmac
94+
Hmac,
95+
Mac
9596
} = require('internal/crypto/hash');
9697
const {
9798
getCiphers,
@@ -142,6 +143,10 @@ function createHmac(hmac, key, options) {
142143
return new Hmac(hmac, key, options);
143144
}
144145

146+
function createMac(mac, key, options) {
147+
return new Mac(mac, key, options);
148+
}
149+
145150
function createSign(algorithm, options) {
146151
return new Sign(algorithm, options);
147152
}
@@ -159,6 +164,7 @@ module.exports = {
159164
createECDH,
160165
createHash,
161166
createHmac,
167+
createMac,
162168
createPrivateKey,
163169
createPublicKey,
164170
createSecretKey,
@@ -203,6 +209,7 @@ module.exports = {
203209
Hash,
204210
Hmac,
205211
KeyObject,
212+
Mac,
206213
Sign,
207214
Verify
208215
};

‎lib/internal/crypto/hash.js‎

Lines changed: 48 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,8 +6,12 @@ const {
66
} = primordials;
77

88
const {
9+
EVP_PKEY_HMAC,
10+
EVP_PKEY_POLY1305,
11+
EVP_PKEY_SIPHASH,
912
Hash: _Hash,
10-
Hmac: _Hmac
13+
Hmac: _Hmac,
14+
Mac: _Mac
1115
} = internalBinding('crypto');
1216

1317
const {
@@ -140,7 +144,49 @@ Hmac.prototype.digest = function digest(outputEncoding) {
140144
Hmac.prototype._flush = Hash.prototype._flush;
141145
Hmac.prototype._transform = Hash.prototype._transform;
142146

147+
function Mac(mac, key, options) {
148+
if (!(this instanceof Mac))
149+
return new Mac(mac, key, options);
150+
151+
validateString(mac, 'mac');
152+
key = prepareSecretKey(key);
153+
154+
let nid = EVP_PKEY_HMAC;
155+
if (mac === 'poly1305') nid = EVP_PKEY_POLY1305;
156+
else if (mac === 'siphash') nid = EVP_PKEY_SIPHASH;
157+
158+
this[kHandle] = new _Mac(nid, toBuf(key), mac);
159+
this[kState] = {
160+
[kFinalized]: false
161+
};
162+
LazyTransform.call(this, options);
163+
}
164+
165+
ObjectSetPrototypeOf(Mac.prototype, LazyTransform.prototype);
166+
ObjectSetPrototypeOf(Mac, LazyTransform);
167+
168+
Mac.prototype.update = Hash.prototype.update;
169+
170+
Mac.prototype.digest = function digest(outputEncoding) {
171+
const state = this[kState];
172+
outputEncoding = outputEncoding || getDefaultEncoding();
173+
174+
if (state[kFinalized]) {
175+
const buf = Buffer.from('');
176+
return outputEncoding === 'buffer' ? buf : buf.toString(outputEncoding);
177+
}
178+
179+
// Explicit conversion for backward compatibility.
180+
const ret = this[kHandle].digest(`${outputEncoding}`);
181+
state[kFinalized] = true;
182+
return ret;
183+
};
184+
185+
Hmac.prototype._flush = Hash.prototype._flush;
186+
Hmac.prototype._transform = Hash.prototype._transform;
187+
143188
module.exports = {
144189
Hash,
145-
Hmac
190+
Hmac,
191+
Mac
146192
};

‎src/node_crypto.cc‎

Lines changed: 112 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -105,6 +105,8 @@ using v8::Value;
105105
# define IS_OCB_MODE(mode) ((mode) == EVP_CIPH_OCB_MODE)
106106
#endif
107107

108+
void CheckThrow(Environment* env, SignBase::Error error);
109+
108110
static const char* const root_certs[] = {
109111
#include "node_root_certs.h" // NOLINT(build/include_order)
110112
};
@@ -4349,6 +4351,112 @@ void Hash::HashDigest(const FunctionCallbackInfo<Value>& args) {
43494351
}
43504352

43514353

4354+
void Mac::Initialize(Environment* env, Local<Object> target) {
4355+
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
4356+
t->InstanceTemplate()->SetInternalFieldCount(Mac::kInternalFieldCount);
4357+
4358+
env->SetProtoMethod(t, "update", Update);
4359+
env->SetProtoMethod(t, "digest", Digest);
4360+
4361+
target->Set(env->context(),
4362+
FIXED_ONE_BYTE_STRING(env->isolate(), "Mac"),
4363+
t->GetFunction(env->context()).ToLocalChecked()).Check();
4364+
}
4365+
4366+
4367+
Mac::Mac(Environment* env, Local<Object> wrap, int nid, EVPMDPointer&& mdctx)
4368+
: BaseObject(env, wrap)
4369+
, nid_(nid)
4370+
, mdctx_(std::move(mdctx)) {
4371+
MakeWeak();
4372+
}
4373+
4374+
4375+
void Mac::New(const FunctionCallbackInfo<Value>& args) {
4376+
MarkPopErrorOnReturn mark_pop_error_on_return;
4377+
Environment* env = Environment::GetCurrent(args);
4378+
4379+
CHECK(args[0]->IsInt32());
4380+
const int nid = args[0].As<Int32>()->Value();
4381+
4382+
CHECK(args[1]->IsArrayBufferView());
4383+
ByteSource key = ByteSource::FromBuffer(args[1]);
4384+
4385+
const EVP_MD* md = nullptr;
4386+
if (nid == EVP_PKEY_HMAC) {
4387+
CHECK(args[2]->IsString());
4388+
const node::Utf8Value name(env->isolate(), args[2]);
4389+
md = EVP_get_digestbyname(*name);
4390+
if (md == nullptr)
4391+
return CheckThrow(env, SignBase::Error::kSignUnknownDigest);
4392+
}
4393+
4394+
ManagedEVPPKey pkey(
4395+
EVPKeyPointer(
4396+
EVP_PKEY_new_raw_private_key(
4397+
nid, nullptr, reinterpret_cast<const unsigned char*>(key.get()),
4398+
key.size())));
4399+
4400+
EVPMDPointer mdctx(EVP_MD_CTX_new());
4401+
4402+
4403+
EVP_PKEY_CTX* pkctx = nullptr;
4404+
if (!EVP_DigestSignInit(mdctx.get(), &pkctx, md, nullptr, pkey.get()))
4405+
return ThrowCryptoError(env, ERR_get_error(), "EVP_DigestSignInit");
4406+
4407+
// TODO(bnoordhuis) Call EVP_PKEY_CTX_ctrl() or EVP_PKEY_CTX_ctrl_str().
4408+
USE(pkctx);
4409+
4410+
new Mac(env, args.This(), nid, std::move(mdctx));
4411+
}
4412+
4413+
4414+
void Mac::Update(const FunctionCallbackInfo<Value>& args) {
4415+
Decode<Mac>(args, [](Mac* mac, const FunctionCallbackInfo<Value>& args,
4416+
const char* data, size_t size) {
4417+
const int rc = EVP_DigestSignUpdate(mac->mdctx_.get(), data, size);
4418+
args.GetReturnValue().Set(rc == 1);
4419+
});
4420+
}
4421+
4422+
4423+
void Mac::Digest(const FunctionCallbackInfo<Value>& args) {
4424+
Mac* mac;
4425+
ASSIGN_OR_RETURN_UNWRAP(&mac, args.Holder());
4426+
4427+
MarkPopErrorOnReturn mark_pop_error_on_return;
4428+
Environment* env = Environment::GetCurrent(args);
4429+
4430+
enum encoding encoding = BUFFER;
4431+
if (args.Length() > 0)
4432+
encoding = ParseEncoding(env->isolate(), args[0], BUFFER);
4433+
4434+
size_t size;
4435+
if (!EVP_DigestSignFinal(mac->mdctx_.get(), nullptr, &size))
4436+
return ThrowCryptoError(env, ERR_get_error(), "EVP_DigestSignFinal");
4437+
4438+
unsigned char* data = MallocOpenSSL<unsigned char>(size);
4439+
ByteSource source =
4440+
ByteSource::Allocated(reinterpret_cast<char*>(data), size);
4441+
4442+
if (!EVP_DigestSignFinal(mac->mdctx_.get(), data, &size))
4443+
return ThrowCryptoError(env, ERR_get_error(), "EVP_DigestSignFinal");
4444+
4445+
Local<Value> error;
4446+
MaybeLocal<Value> rc =
4447+
StringBytes::Encode(env->isolate(), source.get(), source.size(),
4448+
encoding, &error);
4449+
4450+
if (rc.IsEmpty()) {
4451+
CHECK(!error.IsEmpty());
4452+
env->isolate()->ThrowException(error);
4453+
return;
4454+
}
4455+
4456+
args.GetReturnValue().Set(rc.ToLocalChecked());
4457+
}
4458+
4459+
43524460
SignBase::Error SignBase::Init(const char* sign_type) {
43534461
CHECK_NULL(mdctx_);
43544462
// Historically, "dss1" and "DSS1" were DSA aliases for SHA-1
@@ -6864,6 +6972,7 @@ void Initialize(Local<Object> target,
68646972
ECDH::Initialize(env, target);
68656973
Hmac::Initialize(env, target);
68666974
Hash::Initialize(env, target);
6975+
Mac::Initialize(env, target);
68676976
Sign::Initialize(env, target);
68686977
Verify::Initialize(env, target);
68696978

@@ -6895,6 +7004,9 @@ void Initialize(Local<Object> target,
68957004
env->SetMethod(target, "generateKeyPairDH", GenerateKeyPairDH);
68967005
NODE_DEFINE_CONSTANT(target, EVP_PKEY_ED25519);
68977006
NODE_DEFINE_CONSTANT(target, EVP_PKEY_ED448);
7007+
NODE_DEFINE_CONSTANT(target, EVP_PKEY_HMAC);
7008+
NODE_DEFINE_CONSTANT(target, EVP_PKEY_POLY1305);
7009+
NODE_DEFINE_CONSTANT(target, EVP_PKEY_SIPHASH);
68987010
NODE_DEFINE_CONSTANT(target, EVP_PKEY_X25519);
68997011
NODE_DEFINE_CONSTANT(target, EVP_PKEY_X448);
69007012
NODE_DEFINE_CONSTANT(target, OPENSSL_EC_NAMED_CURVE);

‎src/node_crypto.h‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -589,6 +589,28 @@ class Hash final : public BaseObject {
589589
unsigned char* md_value_;
590590
};
591591

592+
class Mac : public BaseObject {
593+
public:
594+
static void Initialize(Environment* env, v8::Local<v8::Object> target);
595+
596+
// TODO(joyeecheung): track the memory used by OpenSSL types
597+
SET_NO_MEMORY_INFO()
598+
SET_MEMORY_INFO_NAME(Mac)
599+
SET_SELF_SIZE(Mac)
600+
601+
protected:
602+
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
603+
static void Update(const v8::FunctionCallbackInfo<v8::Value>& args);
604+
static void Digest(const v8::FunctionCallbackInfo<v8::Value>& args);
605+
606+
Mac(Environment* env, v8::Local<v8::Object> wrap,
607+
int nid, EVPMDPointer&& mdctx);
608+
609+
private:
610+
const int nid_;
611+
EVPMDPointer mdctx_;
612+
};
613+
592614
class SignBase : public BaseObject {
593615
public:
594616
typedef enum {

‎test/parallel/test-crypto-mac.js‎

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
'use strict';
2+
3+
const common = require('../common');
4+
if (!common.hasCrypto) common.skip('missing crypto');
5+
6+
const assert = require('assert');
7+
const crypto = require('crypto');
8+
9+
assert.throws(() => crypto.createMac('boom', 'secret'),
10+
/Unknown message digest/);
11+
12+
// hmac
13+
{
14+
const expected =
15+
Buffer.from('1b2c16b75bd2a870c114153ccda5bcfc' +
16+
'a63314bc722fa160d690de133ccbb9db', 'hex');
17+
const actual = crypto.createMac('sha256', 'secret').update('data').digest();
18+
assert.deepStrictEqual(actual, expected);
19+
}
20+
21+
// poly1305
22+
{
23+
const key =
24+
Buffer.from(
25+
'1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0',
26+
'hex');
27+
const data =
28+
Buffer.from(
29+
'2754776173206272696c6c69672c20616e642074686520736c6974687920' +
30+
'746f7665730a446964206779726520616e642067696d626c6520696e2074' +
31+
'686520776162653a0a416c6c206d696d737920776572652074686520626f' +
32+
'726f676f7665732c0a416e6420746865206d6f6d65207261746873206f75' +
33+
'7467726162652e',
34+
'hex');
35+
const expected = Buffer.from('4541669a7eaaee61e708dc7cbcc5eb62', 'hex');
36+
const actual = crypto.createMac('poly1305', key).update(data).digest();
37+
assert.deepStrictEqual(actual, expected);
38+
}
39+
40+
// siphash
41+
{
42+
const key = Buffer.from('000102030405060708090A0B0C0D0E0F', 'hex');
43+
const data = Buffer.from('000102030405', 'hex');
44+
const expected = Buffer.from('14eeca338b208613485ea0308fd7a15e', 'hex');
45+
const actual = crypto.createMac('siphash', key).update(data).digest();
46+
assert.deepStrictEqual(actual, expected);
47+
}

0 commit comments

Comments
 (0)