Pass 2

Author: dgarske

README.md

@@ -25,5 +25,5 @@ Use npm to install and build:
 ```
 npm i
 npm run build
-node app.js
+npm run tsrun
 ```

WolfSSLDecryptor.js

@@ -0,0 +1,63 @@
+"use strict";
+exports.__esModule = true;
+exports.WolfSSLDecryptor = void 0;
+var wolfcrypt = require('./build/Release/wolfcrypt');
+//export class WolfSSLDecryptor implements Decryptor {
+var WolfSSLDecryptor = /** @class */ (function () {
+    /**
+     * Initializes a new instance of the WolfSSLDecryptor class.
+     *
+     * @param cipher The cipher name to use.
+     * @param key    The decryption key to use.
+     * @param iv     The initialization vector.
+     *
+     * @throws {Error} If cipher is not available or unknown.
+     * @throws {Error} If the creation of the Decryption object failed.
+     */
+    function WolfSSLDecryptor(cipher, key, iv) {
+        //this.enableFips();
+        this.evp = Buffer.alloc(wolfcrypt.sizeof_EVP_CIPHER_CTX());
+        this.totalInputLength = 0;
+        wolfcrypt.EVP_CipherInit(this.evp, cipher, key, iv);
+    }
+    /**
+     * Updates the internal state with data for decryption.
+     *
+     * @param data The data that will be added for decryption.
+     *
+     * @returns The decrypted data if possible.
+     *
+     * @throws {Error} If the decryption fails.
+     *
+     * @remarks This function should be called multiple times.
+     */
+    WolfSSLDecryptor.prototype.update = function (data) {
+        this.totalInputLength += data.length;
+        var outBuffer = Buffer.alloc(this.totalInputLength);
+        var ret = wolfcrypt.EVP_CipherUpdate(this.evp, outBuffer, data, data.length);
+        if (ret > 0) {
+            return outBuffer;
+        }
+        return Buffer.alloc(0);
+    };
+    /**
+     * Finalize the decryption process.
+     *
+     * @returns The last block of decrypted data.
+     *
+     * @throws {Error} If the decryption fails.
+     *
+     * @remarks This function should be called once to finalize the decryption
+     * process.
+     */
+    WolfSSLDecryptor.prototype.finalize = function () {
+        var outBuffer = Buffer.alloc(this.totalInputLength);
+        var ret = wolfcrypt.EVP_CipherFinal(this.evp, outBuffer);
+        if (ret > 0) {
+            return outBuffer;
+        }
+        return Buffer.alloc(0);
+    };
+    return WolfSSLDecryptor;
+}());
+exports.WolfSSLDecryptor = WolfSSLDecryptor;

WolfSSLDecryptor.ts

@@ -0,0 +1,84 @@
+const wolfcrypt = require('./build/Release/wolfcrypt');
+
+//export class WolfSSLDecryptor implements Decryptor {
+export class WolfSSLDecryptor {
+  private evp: Buffer
+  private totalInputLength: number
+
+  /**
+   * Initializes a new instance of the WolfSSLDecryptor class.
+   *
+   * @param cipher The cipher name to use.
+   * @param key    The decryption key to use.
+   * @param iv     The initialization vector.
+   *
+   * @throws {Error} If cipher is not available or unknown.
+   * @throws {Error} If the creation of the Decryption object failed.
+   */
+  public constructor(cipher: string, key: Buffer, iv: Buffer) {
+    //this.enableFips();
+    this.evp = Buffer.alloc( wolfcrypt.sizeof_EVP_CIPHER_CTX() )
+    this.totalInputLength = 0
+    wolfcrypt.EVP_CipherInit( this.evp, cipher, key, iv )
+  }
+
+  /**
+   * Updates the internal state with data for decryption.
+   *
+   * @param data The data that will be added for decryption.
+   *
+   * @returns The decrypted data if possible.
+   *
+   * @throws {Error} If the decryption fails.
+   *
+   * @remarks This function should be called multiple times.
+   */
+  public update(data: Buffer): Buffer {
+    this.totalInputLength += data.length
+
+    let outBuffer = Buffer.alloc( this.totalInputLength )
+
+    let ret = wolfcrypt.EVP_CipherUpdate( this.evp, outBuffer, data, data.length )
+
+    if ( ret > 0 )
+    {
+      return outBuffer
+    }
+
+    return Buffer.alloc( 0 )
+  }
+
+  /**
+   * Finalize the decryption process.
+   *
+   * @returns The last block of decrypted data.
+   *
+   * @throws {Error} If the decryption fails.
+   *
+   * @remarks This function should be called once to finalize the decryption
+   * process.
+   */
+  public finalize(): Buffer {
+    let outBuffer = Buffer.alloc( this.totalInputLength )
+
+    let ret = wolfcrypt.EVP_CipherFinal( this.evp, outBuffer )
+
+    if ( ret > 0 )
+    {
+      return outBuffer
+    }
+
+    return Buffer.alloc( 0 )
+  }
+
+  /**
+   * Enables the FIPS mode.
+   */
+  /*
+  private enableFips(): void {
+    if (!wolfssl.isFipsEnabled() && !wolfssl.enableFips()) {
+      logger.logWarning('FIPS mode not available.');
+    }
+  }
+  */
+}

app.js

@@ -1,24 +1,77 @@
-const wolfcrypt = require('./build/Release/wolfcrypt');
+//const wolfcrypt = require('./build/Release/wolfcrypt');
+const { WolfSSLDecryptor } = require( './WolfSSLDecryptor.ts' )
 
-let aes = Buffer.alloc( 300 )
+/*
+let aes = Buffer.alloc( 1152 )
 let key = Buffer.from( '12345678901234567890123456789012' )
 let iv = Buffer.from( '1234567890123456' )
 let plainText = Buffer.from( 'testtesttesttest' )
 let cipherText = Buffer.alloc( 16 )
 let plainAgain = Buffer.alloc( 16 )
+let length = 16
 
 let ret = wolfcrypt.MakeAes( aes, key, iv )
 
 if ( ret == 0 )
+  ret = wolfcrypt.Encrypt( aes, cipherText, plainText, length )
+
+if ( ret == 0 )
+  ret = wolfcrypt.Decrypt( aes, plainAgain, cipherText, length )
+
+console.log( plainText.toString() )
+console.log( cipherText.toString( 'hex' ) )
+console.log( plainAgain.toString() )
+*/
+/*
+let length = 0
+let finalOutput = []
+const key = Buffer.from('12345678901234567890123456789012')
+const iv = Buffer.from('1234567890123456');
+
+console.log( wolfcrypt.GetDecryptionSize() )
+
+let decryption = Buffer.alloc( wolfcrypt.GetDecryptionSize() )
+wolfcrypt.NewDecryption( decryption, 'AES-256-CBC', key, iv )
+
+let outBuf = Buffer.alloc( 8 )
+length = wolfcrypt.UpdateCipher( decryption, outBuf, Buffer.from('24d31b1e41fc8c40', 'hex'), 8 )
+console.log( length )
+
+if ( length > 0 )
 {
-  ret = wolfcrypt.Encrypt( aes, cipherText, plainText, 16 )
+  finalOutput.push( outBuf )
 }
 
-if ( ret == 0 )
+outBuf = Buffer.alloc( 8 )
+length = wolfcrypt.UpdateCipher( decryption, outBuf, Buffer.from('e521531d67c72c20', 'hex'), 8 )
+console.log( length )
+
+if ( length > 0 )
+{
+  finalOutput.push( outBuf )
+}
+
+outBuf = Buffer.alloc( 16 )
+length = wolfcrypt.FinalizeCipher( decryption, outBuf )
+console.log( length )
+
+if ( length > 0 )
 {
-  ret = wolfcrypt.Decrypt( aes, plainAgain, cipherText, 16 )
+  finalOutput.push( outBuf )
 }
 
-console.log( plainText.toString() );
-console.log( cipherText.toString( 'hex' ) );
-console.log( plainAgain.toString() );
+console.log( Buffer.concat( finalOutput ).toString() )
+*/
+
+const key = Buffer.from('12345678901234567890123456789012');
+const iv = Buffer.from('1234567890123456');
+const decrypt = new WolfSSLDecryptor('AES-256-CBC', key, iv);
+const expected = 'test';
+
+const actual = Buffer.concat([
+  decrypt.update(Buffer.from('24d31b1e41fc8c40', 'hex')),
+  decrypt.update(Buffer.from('e521531d67c72c20', 'hex')),
+  decrypt.finalize()
+]);
+
+console.log( actual.toString() )

main.js

@@ -0,0 +1,18 @@
+"use strict";
+exports.__esModule = true;
+var WolfSSLDecryptor_1 = require("./WolfSSLDecryptor");
+var key = Buffer.from('12345678901234567890123456789012');
+var iv = Buffer.from('1234567890123456');
+var decrypt = new WolfSSLDecryptor_1.WolfSSLDecryptor('AES-256-CBC', key, iv);
+var expected = 'test';
+var actual = Buffer.concat([
+    decrypt.update(Buffer.from('24d31b1e41fc8c40', 'hex')),
+    decrypt.update(Buffer.from('e521531d67c72c20', 'hex')),
+    decrypt.finalize()
+]).toString();
+if (actual == expected) {
+    console.log('PASS');
+}
+else {
+    console.log('FAIL', expected, expected.length, actual, actual.length);
+}

main.ts

@@ -0,0 +1,21 @@
+import { WolfSSLDecryptor } from './WolfSSLDecryptor'
+
+const key = Buffer.from('12345678901234567890123456789012')
+const iv = Buffer.from('1234567890123456')
+const decrypt = new WolfSSLDecryptor('AES-256-CBC', key, iv)
+const expected = 'test'
+
+const actual = Buffer.concat([
+  decrypt.update(Buffer.from('24d31b1e41fc8c40', 'hex')),
+  decrypt.update(Buffer.from('e521531d67c72c20', 'hex')),
+  decrypt.finalize()
+]).toString()
+
+if ( actual == expected )
+{
+  console.log( 'PASS' )
+}
+else
+{
+  console.log( 'FAIL', expected, expected.length, actual, actual.length )
+}

package.json

@@ -6,13 +6,16 @@
   "gypfile": true,
   "scripts": {
     "run": "node app.js",
+    "tsrun": "npx tsc main.ts && node main.js",
     "build": "node-gyp rebuild",
     "clean": "node-gyp clean"
   },
   "author": "John Bland",
   "license": "GPL-2.0",
   "devDependencies": {
-    "node-gyp": "^9.1.0"
+    "@types/node": "^18.0.6",
+    "node-gyp": "^9.1.0",
+    "typescript": "^4.7.4"
   },
   "dependencies": {
     "node-addon-api": "^5.0.0"