chore: column encryption parsing support

src/token/feature-ext-ack-parser.ts

@@ -16,13 +16,14 @@ const FEATURE_ID = {
 function featureExtAckParser(buf: Buffer, offset: number, _options: ParserOptions): Result<FeatureExtAckToken> {
   let fedAuth: Buffer | undefined;
   let utf8Support: boolean | undefined;
+  let columnEncryption: boolean | undefined;
 
   while (true) {
     let featureId;
     ({ value: featureId, offset } = readUInt8(buf, offset));
 
     if (featureId === FEATURE_ID.TERMINATOR) {
-      return new Result(new FeatureExtAckToken(fedAuth, utf8Support), offset);
+      return new Result(new FeatureExtAckToken(fedAuth, utf8Support, columnEncryption), offset);
     }
 
     let featureAckDataLen;
@@ -32,7 +33,7 @@ function featureExtAckParser(buf: Buffer, offset: number, _options: ParserOption
       throw new NotEnoughDataError(offset + featureAckDataLen);
     }
 
-    const featureData = buf.slice(offset, offset + featureAckDataLen);
+    const featureData = buf.subarray(offset, offset + featureAckDataLen);
     offset += featureAckDataLen;
 
     switch (featureId) {
@@ -42,6 +43,19 @@ function featureExtAckParser(buf: Buffer, offset: number, _options: ParserOption
       case FEATURE_ID.UTF8_SUPPORT:
         utf8Support = !!featureData[0];
         break;
+      case FEATURE_ID.COLUMNENCRYPTION:
+        if (1 > featureData.length) {
+          throw new Error(`Unsupported featureDataLength ${featureData.length} for feature type ${featureId}`);
+        }
+        // TODO: may need to look into support enclave computations version support:
+        // supportedCryptographicVersion === 0x02
+        // supportedCryptographicVersion === 0x03
+        const supportedCryptographicVersion = featureData[0];
+        if (0 === supportedCryptographicVersion || supportedCryptographicVersion > 0x01) {
+          throw new Error(`Unsupported supported cryptographic protocol version: ${supportedCryptographicVersion}`);
+        }
+        columnEncryption = true;
+        break;
     }
   }
 }

src/token/token.ts

@@ -332,11 +332,14 @@ export class FeatureExtAckToken extends Token {
    * undefined when UTF8_SUPPORT not included in token. */
   declare utf8Support: boolean | undefined;
 
-  constructor(fedAuth: Buffer | undefined, utf8Support: boolean | undefined) {
+  declare columnEncryption: boolean | undefined;
+
+  constructor(fedAuth: Buffer | undefined, utf8Support: boolean | undefined, columnEncryption: boolean | undefined) {
     super('FEATUREEXTACK', 'onFeatureExtAck');
 
     this.fedAuth = fedAuth;
     this.utf8Support = utf8Support;
+    this.columnEncryption = columnEncryption;
   }
 }
 

test/unit/token/feature-ext-parser-test.js

@@ -51,4 +51,45 @@ describe('Feature Ext Parser', () => {
 
     assert.isTrue((await parser.next()).done);
   });
+
+  it('should parse column encryption token', async () => {
+    const buffer = new WritableTrackingBuffer(8);
+
+    buffer.writeUInt8(0xAE); // FEATUREEXTACK token header
+    buffer.writeUInt8(0x04); // COLUMNENCRYPTION feature id
+    buffer.writeUInt32LE(0x00_00_00_01); // datalen
+    buffer.writeUInt8(0x01); // supported
+
+    buffer.writeUInt8(0xFF); // TERMINATOR
+
+    const parser = StreamParser.parseTokens([buffer.data], {}, {});
+    const result = await parser.next();
+    assert.isFalse(result.done);
+
+    const token = result.value;
+    assert.strictEqual(token.columnEncryption, true); // feature ext ack for COLUMNENCRYPTION was positive
+    assert.isUndefined(token.fedAuth); // fed auth not ack'd
+
+    assert.isTrue((await parser.next()).done);
+  });
+
+  it('should return error for non support cryptographic protocol version', async () => {
+    const buffer = new WritableTrackingBuffer(8);
+
+    buffer.writeUInt8(0xAE); // FEATUREEXTACK token header
+    buffer.writeUInt8(0x04); // COLUMNENCRYPTION feature id
+    buffer.writeUInt32LE(0x00_00_00_01); // datalen
+    buffer.writeUInt8(0x02); // supported
+
+    buffer.writeUInt8(0xFF); // TERMINATOR
+    let error;
+    try {
+      const parser = StreamParser.parseTokens([buffer.data], {}, {});
+      await parser.next();
+    } catch (err) {
+      error = err;
+    }
+    assert.instanceOf(error, Error);
+    assert.include(error.message, 'Unsupported supported cryptographic protocol version');
+  });
 });