buffer: add Buffer.harden() method

Author: ChALkeR

lib/buffer.js

@@ -63,6 +63,7 @@ const {
 
 const {
   codes: {
+    ERR_ASSERTION,
     ERR_BUFFER_OUT_OF_BOUNDS,
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_ARG_VALUE,
@@ -109,8 +110,13 @@ let poolSize, poolOffset, allocPool;
 // do not own the ArrayBuffer allocator.  Zero fill is always on in that case.
 const zeroFill = bindingZeroFill || [0];
 
+// Hardening Buffer enables Buffer constructor runtime deprecation,
+// disables pooling, and enables mandratory zero-fill. This is more secure, but
+// has potential performance impact, depending on the usecase.
+let hardened = false;
+
 function createUnsafeBuffer(size) {
-  zeroFill[0] = 0;
+  zeroFill[0] = hardened ? 1 : 0;
   try {
     return new FastBuffer(size);
   } finally {
@@ -140,6 +146,15 @@ const bufferWarning = 'Buffer() is deprecated due to security and usability ' +
                       'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
 
 function showFlaggedDeprecation() {
+  if (hardened) {
+    if (bufferWarningAlreadyEmitted) return;
+    process.emitWarning(
+      bufferWarning + ' Buffer() will soon throw in hardened mode.',
+      'DeprecationWarning', 'DEP0XXX');
+    bufferWarningAlreadyEmitted = true;
+    return;
+  }
+
   if (bufferWarningAlreadyEmitted ||
       ++nodeModulesCheckCounter > 10000 ||
       (!require('internal/options').getOptionValue('--pending-deprecation') &&
@@ -157,6 +172,26 @@ function showFlaggedDeprecation() {
   bufferWarningAlreadyEmitted = true;
 }
 
+// Calling this method does not affect existing buffers, only new ones.
+Buffer.harden = function() {
+  if (hardened) return;
+  if (isInsideNodeModules()) {
+    throw new ERR_ASSERTION(
+      'Buffer.harden() should be called only from the top-level module. ' +
+      'Calling Buffer.harden() from dependencies is not supported.'
+    );
+  }
+  hardened = true;
+  Object.defineProperty(Buffer, 'poolSize', {
+    enumerable: true,
+    get: () => 0,
+    set: () => {},
+  });
+  Object.freeze(Buffer);
+  Object.freeze(Buffer.prototype);
+  Object.freeze(module.exports);
+};
+
 function toInteger(n, defaultVal) {
   n = +n;
   if (!Number.isNaN(n) &&
@@ -365,7 +400,7 @@ function allocate(size) {
   if (size <= 0) {
     return new FastBuffer();
   }
-  if (size < (Buffer.poolSize >>> 1)) {
+  if (size < (Buffer.poolSize >>> 1) && !hardened) {
     if (size > (poolSize - poolOffset))
       createPool();
     const b = new FastBuffer(allocPool, poolOffset, size);