(#11) Updated decrypt method to work with different algorithms

Author: Simon Hofmann

lib/decrypt.function.spec.ts

@@ -1,3 +1,4 @@
+import {Algorithm} from "./algorithm.enum";
 import {decrypt} from "./decrypt.function";
 
 describe("secret", () => {
@@ -8,7 +9,7 @@ describe("secret", () => {
         const expected = "Can you keep a secret?";
 
         // THEN
-        expect(decrypt(input, key)).resolves.toBe(expected);
+        expect(decrypt(input, key, Algorithm.AES128CBC)).resolves.toBe(expected);
     });
 
     it("should throw an error when IV size is invalid", async () => {
@@ -17,6 +18,7 @@ describe("secret", () => {
         const input = "Zm9vCg==";
 
         // THEN
-        expect(decrypt(input, key)).rejects.toThrowError("Invalid IV size. Size of 16 byte required.");
+        expect(decrypt(input, key, Algorithm.AES128CBC))
+            .rejects.toThrowError("Invalid IV size. Size of 16 byte required.");
     });
 });

lib/decrypt.function.ts

@@ -1,24 +1,49 @@
 import * as crypto from "crypto";
+import {Algorithm} from "./algorithm.enum";
 import {base64EncodedBufferFromString} from "./buffer.function";
-import {getAlgorithm} from "./get-algorithm.function";
+import {CipherSpec, getCipherSpec} from "./get-cipher-spec.function";
 
-export const decrypt = async (encrypted: string, secret: string) => {
-    const cipherSpec = getAlgorithm(secret);
+interface DecryptInput {
+    iv: Buffer;
+    content: Buffer;
+}
+
+const sliceInput = (plainInput: Buffer, cipherSpec: CipherSpec): DecryptInput => {
+    const iv = plainInput.slice(0, cipherSpec.blockSize);
+    const content = plainInput.slice(cipherSpec.blockSize);
+
+    return ({
+        content,
+        iv
+    });
+};
+
+export const decrypt = async (encrypted: string, secret: string, algorithm: Algorithm, useIV: boolean = true) => {
+    const cipherSpec = getCipherSpec(algorithm);
     const key = base64EncodedBufferFromString(secret);
     const plainInput = base64EncodedBufferFromString(encrypted);
 
-    if (plainInput.length < cipherSpec.blockSize) {
+    if (useIV && plainInput.length < cipherSpec.blockSize) {
         throw new Error(`Invalid IV size. Size of ${cipherSpec.blockSize} byte required.`);
     }
 
-    const iv = plainInput.slice(0, cipherSpec.blockSize);
-    const content = plainInput.slice(cipherSpec.blockSize);
+    let decipher: crypto.Decipher;
+    let data: DecryptInput;
+    if (useIV) {
+        data = sliceInput(plainInput, cipherSpec);
 
-    const decipher = crypto.createDecipheriv(
-        cipherSpec.cipher,
-        key,
-        iv
-    );
-    const part = decipher.update(content).toString("utf8");
+        decipher = crypto.createDecipheriv(
+            algorithm,
+            key,
+            data.iv
+        );
+    } else {
+        data = {iv: Buffer.alloc(0), content: plainInput};
+        decipher = crypto.createDecipher(
+            algorithm,
+            key
+        );
+    }
+    const part = decipher.update(data.content).toString("utf8");
     return part + decipher.final("utf8");
 };