crypto: add randomFill and randomFillSync

crypto.randomFill and crypto.randomFillSync are similar to crypto.randomBytes, but allow passing in a buffer as the first argument. This allows us to reuse buffers to prevent having to create a new one on every call. PR-URL: #10209 Reviewed-By: Sam Roberts <[email protected]> Reviewed-By: James M Snell <[email protected]> Reviewed-By: Ben Noordhuis <[email protected]> Reviewed-By: Anna Henningsen <[email protected]>

Author: evanlucas

doc/api/crypto.md

@@ -1584,6 +1584,66 @@ This should normally never take longer than a few milliseconds. The only time
 when generating the random bytes may conceivably block for a longer period of
 time is right after boot, when the whole system is still low on entropy.
 
+### crypto.randomFillSync(buf[, offset][, size])
+<!-- YAML
+added: REPLACEME
+-->
+
+*`buf`{Buffer|Uint8Array} Must be supplied.
+*`offset`{number} Defaults to `0`.
+*`size`{number} Defaults to `buf.length - offset`.
+
+Synchronous version of [`crypto.randomFill()`][].
+
+Returns `buf`
+
+```js
+constbuf=Buffer.alloc(10);
+console.log(crypto.randomFillSync(buf).toString('hex'));
+
+crypto.randomFillSync(buf, 5);
+console.log(buf.toString('hex'));
+
+// The above is equivalent to the following:
+crypto.randomFillSync(buf, 5, 5);
+console.log(buf.toString('hex'));
+```
+
+### crypto.randomFill(buf[, offset][, size], callback)
+<!-- YAML
+added: REPLACEME
+-->
+
+*`buf`{Buffer|Uint8Array} Must be supplied.
+*`offset`{number} Defaults to `0`.
+*`size`{number} Defaults to `buf.length - offset`.
+*`callback`{Function} `function(err, buf){}`.
+
+This function is similar to [`crypto.randomBytes()`][] but requires the first
+argument to be a [`Buffer`][] that will be filled. It also
+requires that a callback is passed in.
+
+If the `callback` function is not provided, an error will be thrown.
+
+```js
+constbuf=Buffer.alloc(10);
+crypto.randomFill(buf, (err, buf) =>{
+if (err) throw err;
+console.log(buf.toString('hex'));
+});
+
+crypto.randomFill(buf, 5, (err, buf) =>{
+if (err) throw err;
+console.log(buf.toString('hex'));
+});
+
+// The above is equivalent to the following:
+crypto.randomFill(buf, 5, 5, (err, buf) =>{
+if (err) throw err;
+console.log(buf.toString('hex'));
+});
+```
+
 ### crypto.setEngine(engine[, flags])
 <!-- YAML
 added: v0.11.11
@@ -2003,6 +2063,8 @@ the `crypto`, `tls`, and `https` modules and are generally specific to OpenSSL.
 [`crypto.getCurves()`]: #crypto_crypto_getcurves
 [`crypto.getHashes()`]: #crypto_crypto_gethashes
 [`crypto.pbkdf2()`]: #crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback
+[`crypto.randomBytes()`]: #crypto_crypto_randombytes_size_callback
+[`crypto.randomFill()`]: #crypto_crypto_randombytesbuffer_buf_size_offset_cb
 [`decipher.final()`]: #crypto_decipher_final_output_encoding
 [`decipher.update()`]: #crypto_decipher_update_data_input_encoding_output_encoding
 [`diffieHellman.setPublicKey()`]: #crypto_diffiehellman_setpublickey_public_key_encoding

lib/crypto.js

@@ -19,8 +19,10 @@ const setFipsCrypto = binding.setFipsCrypto;
 consttimingSafeEqual=binding.timingSafeEqual;
 
 constBuffer=require('buffer').Buffer;
+constkBufferMaxLength=require('buffer').kMaxLength;
 conststream=require('stream');
 constutil=require('util');
+const{ isUint8Array }=process.binding('util');
 constLazyTransform=require('internal/streams/lazy_transform');
 
 constDH_GENERATOR=2;
@@ -634,6 +636,74 @@ exports.setEngine = function setEngine(id, flags){
 returnbinding.setEngine(id,flags);
 };
 
+constkMaxUint32=Math.pow(2,32)-1;
+
+functionrandomFillSync(buf,offset=0,size){
+if(!isUint8Array(buf)){
+thrownewTypeError('"buf" argument must be a Buffer or Uint8Array');
+}
+
+assertOffset(offset,buf.length);
+
+if(size===undefined)size=buf.length-offset;
+
+assertSize(size,offset,buf.length);
+
+returnbinding.randomFill(buf,offset,size);
+}
+exports.randomFillSync=randomFillSync;
+
+functionrandomFill(buf,offset,size,cb){
+if(!isUint8Array(buf)){
+thrownewTypeError('"buf" argument must be a Buffer or Uint8Array');
+}
+
+if(typeofoffset==='function'){
+cb=offset;
+offset=0;
+size=buf.length;
+}elseif(typeofsize==='function'){
+cb=size;
+size=buf.length-offset;
+}elseif(typeofcb!=='function'){
+thrownewTypeError('"cb" argument must be a function');
+}
+
+assertOffset(offset,buf.length);
+assertSize(size,offset,buf.length);
+
+returnbinding.randomFill(buf,offset,size,cb);
+}
+exports.randomFill=randomFill;
+
+functionassertOffset(offset,length){
+if(typeofoffset!=='number'||offset!==offset){
+thrownewTypeError('offset must be a number');
+}
+
+if(offset>kMaxUint32||offset<0){
+thrownewTypeError('offset must be a uint32');
+}
+
+if(offset>kBufferMaxLength||offset>length){
+thrownewRangeError('offset out of range');
+}
+}
+
+functionassertSize(size,offset,length){
+if(typeofsize!=='number'||size!==size){
+thrownewTypeError('size must be a number');
+}
+
+if(size>kMaxUint32||size<0){
+thrownewTypeError('size must be a uint32');
+}
+
+if(size+offset>length||size>kBufferMaxLength){
+thrownewRangeError('buffer too small');
+}
+}
+
 exports.randomBytes=exports.pseudoRandomBytes=randomBytes;
 
 exports.rng=exports.prng=randomBytes;

src/node_crypto.cc

@@ -5449,11 +5449,18 @@ void PBKDF2(const FunctionCallbackInfo<Value>& args){
 // Only instantiate within a valid HandleScope.
 classRandomBytesRequest : publicAsyncWrap{
 public:
-RandomBytesRequest(Environment* env, Local<Object> object, size_t size)
+enum FreeMode{FREE_DATA, DONT_FREE_DATA };
+
+RandomBytesRequest(Environment* env,
+ Local<Object> object,
+size_t size,
+char* data,
+ FreeMode free_mode)
  : AsyncWrap(env, object, AsyncWrap::PROVIDER_CRYPTO),
 error_(0),
  size_(size),
- data_(node::Malloc(size)){
+ data_(data),
+ free_mode_(free_mode){
 Wrap(object, this);
  }
 
@@ -5474,9 +5481,15 @@ class RandomBytesRequest : public AsyncWrap{
 return data_;
  }
 
+inlinevoidset_data(char* data){
+ data_ = data;
+ }
+
 inlinevoidrelease(){
-free(data_);
  size_ = 0;
+if (free_mode_ == FREE_DATA){
+free(data_);
+ }
  }
 
 inlinevoidreturn_memory(char** d, size_t* len){
@@ -5502,6 +5515,7 @@ class RandomBytesRequest : public AsyncWrap{
 unsignedlong error_; // NOLINT(runtime/int)
 size_t size_;
 char* data_;
+const FreeMode free_mode_;
 };
 
 
@@ -5540,7 +5554,18 @@ void RandomBytesCheck(RandomBytesRequest* req, Local<Value> argv[2]){
 size_t size;
  req->return_memory(&data, &size);
  argv[0] = Null(req->env()->isolate());
- argv[1] = Buffer::New(req->env(), data, size).ToLocalChecked();
+ Local<Value> buffer =
+ req->object()->Get(req->env()->context(),
+ req->env()->buffer_string()).ToLocalChecked();
+
+if (buffer->IsUint8Array()){
+CHECK_LE(req->size(), Buffer::Length(buffer));
+char* buf = Buffer::Data(buffer);
+memcpy(buf, data, req->size());
+ argv[1] = buffer;
+ } else{
+ argv[1] = Buffer::New(req->env(), data, size).ToLocalChecked();
+ }
  }
 }
 
@@ -5559,11 +5584,22 @@ void RandomBytesAfter(uv_work_t* work_req, int status){
 }
 
 
+voidRandomBytesProcessSync(Environment* env,
+ RandomBytesRequest* req,
+ Local<Value> argv[2]){
+ env->PrintSyncTrace();
+RandomBytesWork(req->work_req());
+RandomBytesCheck(req, argv);
+delete req;
+
+if (!argv[0]->IsNull())
+ env->isolate()->ThrowException(argv[0]);
+}
+
+
 voidRandomBytes(const FunctionCallbackInfo<Value>& args){
  Environment* env = Environment::GetCurrent(args);
 
-// maybe allow a buffer to write to? cuts down on object creation
-// when generating random data in a loop
 if (!args[0]->IsUint32()){
 return env->ThrowTypeError("size must be a number >= 0");
  }
@@ -5573,7 +5609,13 @@ void RandomBytes(const FunctionCallbackInfo<Value>& args){
 return env->ThrowRangeError("size is not a valid Smi");
 
  Local<Object> obj = env->NewInternalFieldObject();
- RandomBytesRequest* req = newRandomBytesRequest(env, obj, size);
+char* data = node::Malloc(size);
+ RandomBytesRequest* req =
+newRandomBytesRequest(env,
+ obj,
+ size,
+ data,
+ RandomBytesRequest::FREE_DATA);
 
 if (args[1]->IsFunction()){
  obj->Set(env->ondone_string(), args[1]);
@@ -5586,15 +5628,55 @@ void RandomBytes(const FunctionCallbackInfo<Value>& args){
  RandomBytesAfter);
  args.GetReturnValue().Set(obj);
  } else{
- env->PrintSyncTrace();
  Local<Value> argv[2];
-RandomBytesWork(req->work_req());
-RandomBytesCheck(req, argv);
-delete req;
+RandomBytesProcessSync(env, req, argv);
+if (argv[0]->IsNull())
+ args.GetReturnValue().Set(argv[1]);
+ }
+}
 
-if (!argv[0]->IsNull())
- env->isolate()->ThrowException(argv[0]);
-else
+
+voidRandomBytesBuffer(const FunctionCallbackInfo<Value>& args){
+ Environment* env = Environment::GetCurrent(args);
+
+CHECK(args[0]->IsUint8Array());
+CHECK(args[1]->IsUint32());
+CHECK(args[2]->IsUint32());
+
+int64_t offset = args[1]->IntegerValue();
+int64_t size = args[2]->IntegerValue();
+
+ Local<Object> obj = env->NewInternalFieldObject();
+ obj->Set(env->context(), env->buffer_string(), args[0]).FromJust();
+char* data = Buffer::Data(args[0]);
+ data += offset;
+
+ RandomBytesRequest* req =
+newRandomBytesRequest(env,
+ obj,
+ size,
+ data,
+ RandomBytesRequest::DONT_FREE_DATA);
+if (args[3]->IsFunction()){
+ obj->Set(env->context(),
+FIXED_ONE_BYTE_STRING(args.GetIsolate(), "ondone"),
+ args[3]).FromJust();
+
+if (env->in_domain()){
+ obj->Set(env->context(),
+ env->domain_string(),
+ env->domain_array()->Get(0)).FromJust();
+ }
+
+uv_queue_work(env->event_loop(),
+ req->work_req(),
+ RandomBytesWork,
+ RandomBytesAfter);
+ args.GetReturnValue().Set(obj);
+ } else{
+ Local<Value> argv[2];
+RandomBytesProcessSync(env, req, argv);
+if (argv[0]->IsNull())
  args.GetReturnValue().Set(argv[1]);
  }
 }
@@ -6019,6 +6101,7 @@ void InitCrypto(Local<Object> target,
  env->SetMethod(target, "setFipsCrypto", SetFipsCrypto);
  env->SetMethod(target, "PBKDF2", PBKDF2);
  env->SetMethod(target, "randomBytes", RandomBytes);
+ env->SetMethod(target, "randomFill", RandomBytesBuffer);
  env->SetMethod(target, "timingSafeEqual", TimingSafeEqual);
  env->SetMethod(target, "getSSLCiphers", GetSSLCiphers);
  env->SetMethod(target, "getCiphers", GetCiphers);