feat(NODE-7315): Use BSON ByteUtils instead of Nodejs Buffer (#4840)

Co-authored-by: Anna Henningsen <github@addaleax.net>

Author: PavelSafronov

.eslintrc.json

@@ -286,6 +286,13 @@
               }
             ]
           }
+        ],
+        "no-restricted-globals": [
+          "error",
+          {
+            "name": "Buffer",
+            "message": "Use Uint8Array instead"
+          }
         ]
       }
     },

package-lock.json

@@ -26,7 +26,7 @@
   },
   "dependencies": {
     "@mongodb-js/saslprep": "^1.3.0",
-    "bson": "^7.1.1",
+    "bson": "^7.2.0",
     "mongodb-connection-string-url": "^7.0.0"
   },
   "peerDependencies": {

package.json

@@ -1,5 +1,5 @@
 /* eslint-disable no-restricted-imports */
-import { BSON, type DeserializeOptions, type SerializeOptions } from 'bson';
+import { BSON, type DeserializeOptions, NumberUtils, type SerializeOptions } from 'bson';
 
 export {
   Binary,
@@ -8,6 +8,7 @@ export {
   BSONRegExp,
   BSONSymbol,
   BSONType,
+  ByteUtils,
   calculateObjectSize,
   Code,
   DBRef,
@@ -38,10 +39,32 @@ export function parseToElementsToArray(bytes: Uint8Array, offset?: number): BSON
   return Array.isArray(res) ? res : [...res];
 }
 
-export const getInt32LE = BSON.onDemand.NumberUtils.getInt32LE;
-export const getFloat64LE = BSON.onDemand.NumberUtils.getFloat64LE;
-export const getBigInt64LE = BSON.onDemand.NumberUtils.getBigInt64LE;
-export const toUTF8 = BSON.onDemand.ByteUtils.toUTF8;
+// validates buffer inputs, used for read operations
+const validateBufferInputs = (buffer: Uint8Array, offset: number, length: number) => {
+  if (offset < 0 || offset + length > buffer.length) {
+    throw new RangeError(
+      `Attempt to access memory outside buffer bounds: buffer length: ${buffer.length}, offset: ${offset}, length: ${length}`
+    );
+  }
+};
+
+// readInt32LE, reads a 32-bit integer from buffer at given offset
+// throws if offset is out of bounds
+export const readInt32LE = (buffer: Uint8Array, offset: number): number => {
+  validateBufferInputs(buffer, offset, 4);
+  return NumberUtils.getInt32LE(buffer, offset);
+};
+
+export const setUint32LE = (destination: Uint8Array, offset: number, value: number): 4 => {
+  destination[offset] = value;
+  value >>>= 8;
+  destination[offset + 1] = value;
+  value >>>= 8;
+  destination[offset + 2] = value;
+  value >>>= 8;
+  destination[offset + 3] = value;
+  return 4;
+};
 
 /**
  * BSON Serialization options.

src/bson.ts

@@ -1,7 +1,7 @@
 import { type MongoCrypt, type MongoCryptOptions } from 'mongodb-client-encryption';
 import * as net from 'net';
 
-import { deserialize, type Document, serialize } from '../bson';
+import { ByteUtils, deserialize, type Document, serialize } from '../bson';
 import { type CommandOptions, type ProxyOptions } from '../cmap/connection';
 import { kDecorateResult } from '../constants';
 import { getMongoDBClientEncryption } from '../deps';
@@ -256,20 +256,26 @@ export class AutoEncrypter {
       errorWrapper: defaultErrorWrapper
     };
     if (options.schemaMap) {
-      mongoCryptOptions.schemaMap = Buffer.isBuffer(options.schemaMap)
-        ? options.schemaMap
-        : (serialize(options.schemaMap) as Buffer);
+      if (ByteUtils.isUint8Array(options.schemaMap)) {
+        mongoCryptOptions.schemaMap = options.schemaMap;
+      } else {
+        mongoCryptOptions.schemaMap = serialize(options.schemaMap);
+      }
     }
 
     if (options.encryptedFieldsMap) {
-      mongoCryptOptions.encryptedFieldsMap = Buffer.isBuffer(options.encryptedFieldsMap)
-        ? options.encryptedFieldsMap
-        : (serialize(options.encryptedFieldsMap) as Buffer);
+      if (ByteUtils.isUint8Array(options.encryptedFieldsMap)) {
+        mongoCryptOptions.encryptedFieldsMap = options.encryptedFieldsMap;
+      } else {
+        mongoCryptOptions.encryptedFieldsMap = serialize(options.encryptedFieldsMap);
+      }
     }
 
-    mongoCryptOptions.kmsProviders = !Buffer.isBuffer(this._kmsProviders)
-      ? (serialize(this._kmsProviders) as Buffer)
-      : this._kmsProviders;
+    if (ByteUtils.isUint8Array(this._kmsProviders)) {
+      mongoCryptOptions.kmsProviders = this._kmsProviders;
+    } else {
+      mongoCryptOptions.kmsProviders = serialize(this._kmsProviders);
+    }
 
     if (options.options?.logger) {
       mongoCryptOptions.logger = options.options.logger;
@@ -396,7 +402,7 @@ export class AutoEncrypter {
       return cmd;
     }
 
-    const commandBuffer = Buffer.isBuffer(cmd) ? cmd : serialize(cmd, options);
+    const commandBuffer: Uint8Array = serialize(cmd, options);
     const context = this._mongocrypt.makeEncryptionContext(
       MongoDBCollectionNamespace.fromString(ns).db,
       commandBuffer

src/client-side-encryption/auto_encrypter.ts

@@ -143,9 +143,7 @@ export class ClientEncryption {
 
     const mongoCryptOptions: MongoCryptOptions = {
       ...options,
-      kmsProviders: !Buffer.isBuffer(this._kmsProviders)
-        ? (serialize(this._kmsProviders) as Buffer)
-        : this._kmsProviders,
+      kmsProviders: serialize(this._kmsProviders),
       errorWrapper: defaultErrorWrapper
     };
 

src/client-side-encryption/client_encryption.ts

@@ -21,7 +21,7 @@ export class AuthContext {
   /** A response from an initial auth attempt, only some mechanisms use this (e.g, SCRAM) */
   response?: Document;
   /** A random nonce generated for use in an authentication conversation */
-  nonce?: Buffer;
+  nonce?: Uint8Array;
 
   constructor(
     connection: Connection,

src/cmap/auth/auth_provider.ts

@@ -1,4 +1,4 @@
-import { BSON } from '../../bson';
+import { ByteUtils } from '../../bson';
 import { type AWSCredentials } from '../../deps';
 
 export type AwsSigv4Options = {
@@ -31,7 +31,7 @@ export type SignedHeaders = {
 const getHexSha256 = async (str: string): Promise<string> => {
   const data = stringToBuffer(str);
   const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-  const hashHex = BSON.onDemand.ByteUtils.toHex(new Uint8Array(hashBuffer));
+  const hashHex = ByteUtils.toHex(new Uint8Array(hashBuffer));
   return hashHex;
 };
 
@@ -81,8 +81,8 @@ const convertHeaderValue = (value: string | number) => {
  * @returns Uint8Array containing the UTF-8 encoded string.
  */
 function stringToBuffer(str: string): Uint8Array {
-  const data = new Uint8Array(BSON.onDemand.ByteUtils.utf8ByteLength(str));
-  BSON.onDemand.ByteUtils.encodeUTF8Into(data, str, 0);
+  const data = new Uint8Array(ByteUtils.utf8ByteLength(str));
+  ByteUtils.encodeUTF8Into(data, str, 0);
   return data;
 }
 
@@ -189,7 +189,7 @@ export async function aws4Sign(
 
   // 5. Calculate the signature
   const signatureBuffer = await getHmacSha256(signingKey, stringToSign);
-  const signature = BSON.onDemand.ByteUtils.toHex(signatureBuffer);
+  const signature = ByteUtils.toHex(signatureBuffer);
 
   // 6. Add the signature to the request
   // Calculate the Authorization header

src/cmap/auth/aws4.ts

@@ -1,11 +1,11 @@
-import type { Binary, BSONSerializeOptions } from '../../bson';
+import { type Binary, type BSONSerializeOptions, ByteUtils } from '../../bson';
 import * as BSON from '../../bson';
 import {
   MongoCompatibilityError,
   MongoMissingCredentialsError,
   MongoRuntimeError
 } from '../../error';
-import { ByteUtils, maxWireVersion, ns, randomBytes } from '../../utils';
+import { maxWireVersion, ns, randomBytes } from '../../utils';
 import { type AuthContext, AuthProvider } from './auth_provider';
 import {
   type AWSCredentialProvider,

src/cmap/auth/mongodb_aws.ts

@@ -1,4 +1,4 @@
-import { Binary } from '../../bson';
+import { Binary, ByteUtils } from '../../bson';
 import { MongoMissingCredentialsError } from '../../error';
 import { ns } from '../../utils';
 import { type AuthContext, AuthProvider } from './auth_provider';
@@ -12,7 +12,7 @@ export class Plain extends AuthProvider {
 
     const { username, password } = credentials;
 
-    const payload = new Binary(Buffer.from(`\x00${username}\x00${password}`));
+    const payload = new Binary(ByteUtils.fromUTF8(`\x00${username}\x00${password}`));
     const command = {
       saslStart: 1,
       mechanism: 'PLAIN',