cas-typescript-sdk 1.0.15 → 1.0.17

package/src-ts/digital-signature/digital-signaturte-sha-256.ts

@@ -0,0 +1,48 @@
+import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult, Shaed25519DalekDigitalSignatureResult, sha256Ed25519DigitalSignature, sha256Ed25519DigitalSignatureVerify, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature, sha512Ed25519DigitalSignature } from "../../index";
+import { IDigitalSignature } from "./digital-signature-base";
+
+export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
+    
+    createED25519(dataToSign: number[]): Shaed25519DalekDigitalSignatureResult {
+        if (dataToSign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return sha256Ed25519DigitalSignature(dataToSign);
+    }
+
+    verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean {
+        if (!publicKey) {
+            throw new Error("You must provide a public key for verify with ED25519");
+        }
+        if (dataToVerify?.length === 0) {
+            throw new Error("Must provide allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide allocated signature to verify");
+        }
+        return sha256Ed25519DigitalSignatureVerify(publicKey, dataToVerify, signature);
+    }
+
+    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult {
+        if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {
+            throw new Error("You need to provide an appropriate RSA key size.");
+        }
+        if (data_to_sign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return sha256RsaDigitalSignature(rsa_key_size, data_to_sign);
+    }
+    
+    verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean {
+        if (!public_key) {
+            throw new Error("Must provide a public key");
+        }
+        if (data_to_verify?.length === 0) {
+            throw new Error("Must provide an allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide an allocated signature");
+        }
+        return sha256RsaVerifyDigitalSignature(public_key, data_to_verify, signature);
+    }
+}

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

@@ -0,0 +1,11 @@
+import { DigitalSignatureType } from "./digital-signature-factory";
+import { DigitalSignatureFactory } from "./digital-signature-factory";
+import { DigitalSignatureSHA256Wrapper } from "./digital-signaturte-sha-256";
+import { DigitalSignatureSHA512Wrapper } from "./digital-siganture-sha-512";
+
+export {
+  DigitalSignatureFactory,
+  DigitalSignatureSHA256Wrapper,
+  DigitalSignatureSHA512Wrapper,
+  DigitalSignatureType
+};

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

@@ -1,64 +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;
-  }
-}
+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

@@ -1,9 +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,
-};
+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

@@ -1,13 +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;
-    }
+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

@@ -1,24 +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); 
-    }
+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,34 +1,44 @@
-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,
-};
+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";
+import {
+  DigitalSignatureFactory,
+  DigitalSignatureSHA256Wrapper,
+  DigitalSignatureSHA512Wrapper,
+  DigitalSignatureType,
+} from "./digital-signature";
+
+export {
+  AesRsaHybridEncryptResult,
+  AESRSAHybridInitializer,
+  AESWrapper,
+  Argon2Wrapper,
+  BCryptWrapper,
+  HasherFactory,
+  HasherType,
+  HybridEncryptionWrapper,
+  PasswordHasherFactory,
+  PasswordHasherType,
+  RsaKeyPairResult,
+  RSAWrapper,
+  ScryptWrapper,
+  SHAWrapper,
+  X25519Wrapper,
+  DigitalSignatureFactory,
+  DigitalSignatureSHA256Wrapper,
+  DigitalSignatureSHA512Wrapper,
+  DigitalSignatureType,
+};

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);
+  }
+}