cas-typescript-sdk 1.0.14 → 1.0.16

package/src-ts/digital-signature/index.ts

@@ -0,0 +1,4 @@
+export enum DigitalSignatureType {
+    SHA512 = 1,
+    SHA256 = 2
+}

package/src-ts/global.d.ts

@@ -1,2 +1,2 @@
-declare var pathToWindowsDll: string;
+declare var pathToWindowsDll: string;
 declare var pathToLinuxSO: string;

package/src-ts/hashers/hasher-base.ts

@@ -1,6 +1,6 @@
-export interface IHasherBase {
-    hash_512(dataToHash: number[]): number[];
-    verify_512(dataToHash: number[], dataToVerify: number[]): boolean;
-    hash_256(dataToHash: number[]): number[];
-    verify_256(dataToHash: number[], dataToVerify: number[]): boolean;
+export interface IHasherBase {
+    hash_512(dataToHash: number[]): number[];
+    verify_512(dataToHash: number[], dataToVerify: number[]): boolean;
+    hash_256(dataToHash: number[]): number[];
+    verify_256(dataToHash: number[], dataToVerify: number[]): boolean;
 }

package/src-ts/hashers/hasher-factory.ts

@@ -1,12 +1,12 @@
-import { HasherType } from "./hasher-type";
-import { SHAWrapper } from "./sha-wrapper";
-
-export class HasherFactory {
-    getHasher(type: HasherType): any {
-        let result: SHAWrapper = new SHAWrapper();
-        switch(type) {
-
-        }
-        return result;
-    }
+import { HasherType } from "./hasher-type";
+import { SHAWrapper } from "./sha-wrapper";
+
+export class HasherFactory {
+    getHasher(type: HasherType): any {
+        let result: SHAWrapper = new SHAWrapper();
+        switch(type) {
+
+        }
+        return result;
+    }
 }

package/src-ts/hashers/hasher-type.ts

@@ -1,3 +1,3 @@
-export enum HasherType {
-    SHA = 1
+export enum HasherType {
+    SHA = 1
 }

package/src-ts/hashers/index.ts

@@ -1,5 +1,5 @@
-import { HasherFactory } from "./hasher-factory";
-import { HasherType } from "./hasher-type";
-import { SHAWrapper } from "./sha-wrapper";
-
-export { SHAWrapper, HasherFactory, HasherType };
+import { HasherFactory } from "./hasher-factory";
+import { HasherType } from "./hasher-type";
+import { SHAWrapper } from "./sha-wrapper";
+
+export { SHAWrapper, HasherFactory, HasherType };

package/src-ts/hashers/sha-wrapper.ts

@@ -1,38 +1,38 @@
-import { sha256, sha256Verify, sha512, sha512Verify } from "../../index";
-import { IHasherBase } from "./hasher-base";
-
-export class SHAWrapper implements IHasherBase {
-    hash_512(dataToHash: number[]): number[] {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        return sha512(dataToHash);
-    }
-
-    verify_512(dataToHash: number[], dataToVerify: number[]): boolean {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        if (!dataToVerify || dataToVerify.length === 0) {
-            throw new Error("You must provide an allocated array of data to verify");
-        }
-        return sha512Verify(dataToHash, dataToVerify);
-    }
-
-    hash_256(dataToHash: number[]): number[] {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        return sha256(dataToHash);
-    }
-
-    verify_256(dataToHash: number[], dataToVerify: number[]): boolean {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        if (!dataToVerify || dataToVerify.length === 0) {
-            throw new Error("You must provide an allocated array of data to verify");
-        }
-        return sha256Verify(dataToHash, dataToVerify);
-    }
+import { sha256, sha256Verify, sha512, sha512Verify } from "../../index";
+import { IHasherBase } from "./hasher-base";
+
+export class SHAWrapper implements IHasherBase {
+    hash_512(dataToHash: number[]): number[] {
+        if (!dataToHash || dataToHash.length === 0) {
+            throw new Error("You must provide an allocated array of data");
+        }
+        return sha512(dataToHash);
+    }
+
+    verify_512(dataToHash: number[], dataToVerify: number[]): boolean {
+        if (!dataToHash || dataToHash.length === 0) {
+            throw new Error("You must provide an allocated array of data");
+        }
+        if (!dataToVerify || dataToVerify.length === 0) {
+            throw new Error("You must provide an allocated array of data to verify");
+        }
+        return sha512Verify(dataToHash, dataToVerify);
+    }
+
+    hash_256(dataToHash: number[]): number[] {
+        if (!dataToHash || dataToHash.length === 0) {
+            throw new Error("You must provide an allocated array of data");
+        }
+        return sha256(dataToHash);
+    }
+
+    verify_256(dataToHash: number[], dataToVerify: number[]): boolean {
+        if (!dataToHash || dataToHash.length === 0) {
+            throw new Error("You must provide an allocated array of data");
+        }
+        if (!dataToVerify || dataToVerify.length === 0) {
+            throw new Error("You must provide an allocated array of data to verify");
+        }
+        return sha256Verify(dataToHash, dataToVerify);
+    }
 }

package/src-ts/helpers/nonce-generator.ts

@@ -1,9 +1,9 @@
-import * as crypto from "crypto";
-
-export class NonceGenerator {
-
-    public generateNonce(): string {
-        const nonceBytes = crypto.randomBytes(12);
-        return nonceBytes.toString('hex').substring(0, 12);
-    }
+import * as crypto from "crypto";
+
+export class NonceGenerator {
+
+    public generateNonce(): string {
+        const nonceBytes = crypto.randomBytes(12);
+        return nonceBytes.toString('hex').substring(0, 12);
+    }
 }

package/src-ts/hybrid/hybrid-encryption-wrapper.ts

@@ -0,0 +1,64 @@
+import { RSAWrapper } from "../asymmetric";
+import { AESWrapper } from "../symmetric";
+import { AesRsaHybridEncryptResult } from "./types/aes-rsa-hybird-encrypt-result";
+import { AESRSAHybridInitializer } from "./types/aes-rsa-hybrid-initializer";
+
+export class HybridEncryptionWrapper {
+  private aesWrapper: AESWrapper;
+  private rsaWrapper: RSAWrapper;
+
+  constructor() {
+    this.aesWrapper = new AESWrapper();
+    this.rsaWrapper = new RSAWrapper();
+  }
+
+  public encrypt(
+    dataToEncrypt: Array<number>,
+    initalizer: AESRSAHybridInitializer,
+  ): AesRsaHybridEncryptResult {
+    let encryptedData: Array<number> = (initalizer.aesType === 128)
+      ? this.aesWrapper.aes128Encrypt(
+        initalizer.aesKey,
+        initalizer.aesNonce,
+        dataToEncrypt,
+      )
+      : this.aesWrapper.aes256Encrypt(
+        initalizer.aesKey,
+        initalizer.aesNonce,
+        dataToEncrypt,
+      );
+    let encryptedAesKey: Array<number> = this.rsaWrapper.encrypt(
+      initalizer.rsaKeyPair.publicKey,
+      initalizer.aesKey,
+    );
+    let result: AesRsaHybridEncryptResult = new AesRsaHybridEncryptResult(
+      encryptedData,
+      encryptedAesKey,
+      initalizer.aesType,
+      initalizer.aesNonce,
+    );
+    return result;
+  }
+
+  public decrypt(
+    privateKey: string,
+    encryptResult: AesRsaHybridEncryptResult,
+  ): Array<number> {
+    let plaintextAesKey = this.rsaWrapper.decrypt(
+      privateKey,
+      encryptResult.encryptedAesKey,
+    );
+    let plaintext = (encryptResult.aesType === 128)
+      ? this.aesWrapper.aes128Decrypt(
+        plaintextAesKey,
+        encryptResult.aesNonce,
+        encryptResult.ciphertext,
+      )
+      : this.aesWrapper.aes256Decrypt(
+        plaintextAesKey,
+        encryptResult.aesNonce,
+        encryptResult.ciphertext,
+      );
+      return plaintext;
+  }
+}

package/src-ts/hybrid/index.ts

@@ -0,0 +1,9 @@
+import { HybridEncryptionWrapper } from "./hybrid-encryption-wrapper";
+import { AesRsaHybridEncryptResult } from "./types/aes-rsa-hybird-encrypt-result";
+import { AESRSAHybridInitializer } from "./types/aes-rsa-hybrid-initializer";
+
+export {
+  AesRsaHybridEncryptResult,
+  AESRSAHybridInitializer,
+  HybridEncryptionWrapper,
+};

package/src-ts/hybrid/types/aes-rsa-hybird-encrypt-result.ts

@@ -0,0 +1,13 @@
+export class AesRsaHybridEncryptResult {
+    ciphertext: Array<number>;
+    encryptedAesKey: Array<number>;
+    aesType: number;
+    aesNonce: Array<number>;
+
+    constructor(cipherText: Array<number>, encryptAesKey: Array<number>, aesType: number, aesNonce: Array<number>) {
+        this.ciphertext = cipherText;
+        this.encryptedAesKey = encryptAesKey;
+        this.aesType = aesType;
+        this.aesNonce = aesNonce;
+    }
+}

package/src-ts/hybrid/types/aes-rsa-hybrid-initializer.ts

@@ -0,0 +1,24 @@
+import { RsaKeyPairResult } from "../../..";
+import { RSAWrapper } from "../../asymmetric";
+import { AESWrapper } from "../../symmetric";
+
+export class AESRSAHybridInitializer {
+    public aesType: number;
+    public aesKey: Array<number>;
+    public aesNonce: Array<number>;
+    public rsaKeyPair: RsaKeyPairResult;
+
+    constructor(aesType: number, rsaSize: number) {
+        if (aesType !== 128 && aesType !== 256) {
+            throw new Error("Need an appropriate AES size to generate a hybrid initalizer");
+        }
+        this.aesType = aesType;
+        let aesWrapper = new AESWrapper();
+        this.aesKey = (aesType === 128) ? aesWrapper.aes128Key() : aesWrapper.aes256Key();
+        this.aesNonce = aesWrapper.aesNonce();
+        if (rsaSize !== 1028 && rsaSize !== 2048 && rsaSize !== 4096) {
+            throw new Error("You must provide an appropriate RSA Key pair size to generate a hybrid initalizer");
+        }
+        this.rsaKeyPair = new RSAWrapper().generateKeys(rsaSize); 
+    }
+}

package/src-ts/index.ts

@@ -1,26 +1,34 @@
-import {
-  Argon2Wrapper,
-  BCryptWrapper,
-  PasswordHasherFactory,
-  PasswordHasherType,
-  ScryptWrapper,
-} from "./password-hashers/index";
-import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
-import { X25519Wrapper } from "./key_exchange/index";
-import { AESWrapper } from "./symmetric/index";
-import { RSAWrapper, RsaKeyPairResult } from "./asymmetric";
-
-export {
-  Argon2Wrapper,
-  BCryptWrapper,
-  HasherFactory,
-  HasherType,
-  PasswordHasherFactory,
-  PasswordHasherType,
-  ScryptWrapper,
-  SHAWrapper,
-  X25519Wrapper,
-  AESWrapper,
-  RSAWrapper,
-  RsaKeyPairResult
-};
+import {
+  Argon2Wrapper,
+  BCryptWrapper,
+  PasswordHasherFactory,
+  PasswordHasherType,
+  ScryptWrapper,
+} from "./password-hashers/index";
+import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
+import { X25519Wrapper } from "./key_exchange/index";
+import { AESWrapper } from "./symmetric/index";
+import { RsaKeyPairResult, RSAWrapper } from "./asymmetric/index";
+import {
+  AesRsaHybridEncryptResult,
+  AESRSAHybridInitializer,
+  HybridEncryptionWrapper,
+} from "./hybrid/index";
+
+export {
+  AesRsaHybridEncryptResult,
+  AESRSAHybridInitializer,
+  AESWrapper,
+  Argon2Wrapper,
+  BCryptWrapper,
+  HasherFactory,
+  HasherType,
+  HybridEncryptionWrapper,
+  PasswordHasherFactory,
+  PasswordHasherType,
+  RsaKeyPairResult,
+  RSAWrapper,
+  ScryptWrapper,
+  SHAWrapper,
+  X25519Wrapper,
+};

package/src-ts/key_exchange/index.ts

@@ -1,3 +1,3 @@
-import { X25519Wrapper } from "./x25519";
-
-export { X25519Wrapper };
+import { X25519Wrapper } from "./x25519";
+
+export { X25519Wrapper };

package/src-ts/key_exchange/x25519.ts

@@ -1,11 +1,11 @@
-import { x25519DiffieHellman, x25519GenerateSecretAndPublicKey, X25519SecretPublicKeyResult } from "../../index"
-
-export class X25519Wrapper {
-    public generateSecretAndPublicKey(): X25519SecretPublicKeyResult {
-        return x25519GenerateSecretAndPublicKey();
-    }
-
-    public diffieHellman(secretKey: Array<number>, publicKey: Array<number>) {
-        return x25519DiffieHellman(secretKey, publicKey);
-    }
+import { x25519DiffieHellman, x25519GenerateSecretAndPublicKey, X25519SecretPublicKeyResult } from "../../index"
+
+export class X25519Wrapper {
+    public generateSecretAndPublicKey(): X25519SecretPublicKeyResult {
+        return x25519GenerateSecretAndPublicKey();
+    }
+
+    public diffieHellman(secretKey: Array<number>, publicKey: Array<number>) {
+        return x25519DiffieHellman(secretKey, publicKey);
+    }
 }

package/src-ts/password-hashers/argon2-wrapper.ts

@@ -1,18 +1,18 @@
-import {argon2Hash, argon2Verify} from "./../../index";
-import { IPasswordHasherBase} from "./password-hasher-base";
-
-export class Argon2Wrapper implements IPasswordHasherBase {
-  public hashPassword(password: string): string {
-    if (!password){
-      throw new Error("You must provide a password to hash with Argon2");
-    }
-    return argon2Hash(password);
-  }
-
-  public verifyPassword(hashedPassword: string, passwordToVerify: string): boolean {
-    if (!hashedPassword || !passwordToVerify) {
-      throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
-    }
-    return argon2Verify(hashedPassword, passwordToVerify);
-  }
-}
+import {argon2Hash, argon2Verify} from "./../../index";
+import { IPasswordHasherBase} from "./password-hasher-base";
+
+export class Argon2Wrapper implements IPasswordHasherBase {
+  public hashPassword(password: string): string {
+    if (!password){
+      throw new Error("You must provide a password to hash with Argon2");
+    }
+    return argon2Hash(password);
+  }
+
+  public verifyPassword(hashedPassword: string, passwordToVerify: string): boolean {
+    if (!hashedPassword || !passwordToVerify) {
+      throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
+    }
+    return argon2Verify(hashedPassword, passwordToVerify);
+  }
+}

package/src-ts/password-hashers/bcrypt-wrapper.ts

@@ -1,23 +1,23 @@
-import { IPasswordHasherBase } from "./password-hasher-base";
-import { bcryptHash, bcryptVerify } from "./../../index";
-
-export class BCryptWrapper implements IPasswordHasherBase {
-  public hashPassword(password: string): string {
-    if (!password) {
-      throw new Error("You must provide a password to hash with Argon2");
-    }
-    return bcryptHash(password);
-  }
-
-  public verifyPassword(
-    hashedPassword: string,
-    passwordToVerify: string,
-  ): boolean {
-    if (!hashedPassword || !passwordToVerify) {
-      throw new Error(
-        "You must provide a hashed password and a plaintext password to verify with Argon2",
-      );
-    }
-    return bcryptVerify(hashedPassword, passwordToVerify);
-  }
-}
+import { IPasswordHasherBase } from "./password-hasher-base";
+import { bcryptHash, bcryptVerify } from "./../../index";
+
+export class BCryptWrapper implements IPasswordHasherBase {
+  public hashPassword(password: string): string {
+    if (!password) {
+      throw new Error("You must provide a password to hash with Argon2");
+    }
+    return bcryptHash(password);
+  }
+
+  public verifyPassword(
+    hashedPassword: string,
+    passwordToVerify: string,
+  ): boolean {
+    if (!hashedPassword || !passwordToVerify) {
+      throw new Error(
+        "You must provide a hashed password and a plaintext password to verify with Argon2",
+      );
+    }
+    return bcryptVerify(hashedPassword, passwordToVerify);
+  }
+}

package/src-ts/password-hashers/index.ts

@@ -1,14 +1,14 @@
-import { Argon2Wrapper } from "./argon2-wrapper";
-import { BCryptWrapper } from "./bcrypt-wrapper";
-import { ScryptWrapper } from "./scrypt-wrapper";
-
-import { PasswordHasherType } from "./password-hasher-type";
-import { PasswordHasherFactory } from "./password-hasher-factory";
-
-export {
-  Argon2Wrapper,
-  BCryptWrapper,
-  PasswordHasherFactory,
-  PasswordHasherType,
-  ScryptWrapper,
-};
+import { Argon2Wrapper } from "./argon2-wrapper";
+import { BCryptWrapper } from "./bcrypt-wrapper";
+import { ScryptWrapper } from "./scrypt-wrapper";
+
+import { PasswordHasherType } from "./password-hasher-type";
+import { PasswordHasherFactory } from "./password-hasher-factory";
+
+export {
+  Argon2Wrapper,
+  BCryptWrapper,
+  PasswordHasherFactory,
+  PasswordHasherType,
+  ScryptWrapper,
+};

package/src-ts/password-hashers/password-hasher-base.ts

@@ -1,4 +1,4 @@
-export interface IPasswordHasherBase {
-    hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+export interface IPasswordHasherBase {
+    hashPassword(password: string): string;
+    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/src-ts/password-hashers/password-hasher-factory.ts

@@ -1,20 +1,20 @@
-import { Argon2Wrapper } from "./argon2-wrapper";
-import { BCryptWrapper } from "./bcrypt-wrapper";
-import { PasswordHasherType } from "./password-hasher-type";
-import { ScryptWrapper } from "./scrypt-wrapper";
-
-export class PasswordHasherFactory {
-  static getHasher(type: PasswordHasherType): any {
-    // Argon2 by default
-    let hasher = new Argon2Wrapper();
-    switch (type) {
-      case PasswordHasherType.Bcrypt:
-        hasher = new BCryptWrapper();
-        break;
-      case PasswordHasherType.Scrypt:
-        hasher = new ScryptWrapper();
-        break;
-    }
-    return hasher;
-  }
-}
+import { Argon2Wrapper } from "./argon2-wrapper";
+import { BCryptWrapper } from "./bcrypt-wrapper";
+import { PasswordHasherType } from "./password-hasher-type";
+import { ScryptWrapper } from "./scrypt-wrapper";
+
+export class PasswordHasherFactory {
+  static getHasher(type: PasswordHasherType): any {
+    // Argon2 by default
+    let hasher = new Argon2Wrapper();
+    switch (type) {
+      case PasswordHasherType.Bcrypt:
+        hasher = new BCryptWrapper();
+        break;
+      case PasswordHasherType.Scrypt:
+        hasher = new ScryptWrapper();
+        break;
+    }
+    return hasher;
+  }
+}

package/src-ts/password-hashers/password-hasher-type.ts

@@ -1,5 +1,5 @@
-export enum PasswordHasherType {
-    Bcrypt = 1,
-    Scrypt = 2,
-    Argon2 = 3
+export enum PasswordHasherType {
+    Bcrypt = 1,
+    Scrypt = 2,
+    Argon2 = 3
 }

package/src-ts/password-hashers/scrypt-wrapper.ts

@@ -1,20 +1,20 @@
-import { scryptHash, scryptVerify } from "../../index";
-import { IPasswordHasherBase } from "./password-hasher-base";
-
-export class ScryptWrapper implements IPasswordHasherBase {
-
-    public hashPassword(password: string): string {
-        if (!password){
-          throw new Error("You must provide a password to hash with Scrypt");
-        }
-        return scryptHash(password);
-      }
-    
-      public verifyPassword(hashedPassword: string, passwordToVerify: string): boolean {
-        if (!hashedPassword || !passwordToVerify) {
-          throw new Error("You must provide a hashed password and a plaintext password to verify with Scrypt");
-        }
-        return scryptVerify(hashedPassword, passwordToVerify);
-      }
-
+import { scryptHash, scryptVerify } from "../../index";
+import { IPasswordHasherBase } from "./password-hasher-base";
+
+export class ScryptWrapper implements IPasswordHasherBase {
+
+    public hashPassword(password: string): string {
+        if (!password){
+          throw new Error("You must provide a password to hash with Scrypt");
+        }
+        return scryptHash(password);
+      }
+    
+      public verifyPassword(hashedPassword: string, passwordToVerify: string): boolean {
+        if (!hashedPassword || !passwordToVerify) {
+          throw new Error("You must provide a hashed password and a plaintext password to verify with Scrypt");
+        }
+        return scryptVerify(hashedPassword, passwordToVerify);
+      }
+
 }