Merge branch 'main' of github.com:Cryptographic-API-Services/cas-typescript-sdk

Author: WingZer0o

Cargo.toml

@@ -21,6 +21,7 @@ scrypt = "0.11.0"
 sha3 = "0.10.8"
 x25519-dalek = {version = "2.0.0", features = ["static_secrets"]}
 rand_07 = { package = "rand", version = "0.7.0" }
+ascon-aead = "0.4.2"
 
 [profile.dev.package.num-bigint-dig]
 opt-level = 3

index.d.ts

@@ -37,6 +37,10 @@ export function sha512Ed25519DigitalSignature(dataToSign: Array<number>): Shaed2
 export function sha512Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
 export function sha256Ed25519DigitalSignature(dataToSign: Array<number>): Shaed25519DalekDigitalSignatureResult
 export function sha256Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
+export function ascon128KeyGenerate(): Array<number>
+export function ascon128NonceGenerate(): Array<number>
+export function ascon128Encrypt(key: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
+export function ascon128Decrypt(key: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
 export type x25519SecretPublicKeyResult = X25519SecretPublicKeyResult
 export class X25519SecretPublicKeyResult {
   publicKey: Array<number>

index.node

@@ -20,13 +20,19 @@ import {
   DigitalSignatureSHA512Wrapper,
   DigitalSignatureType,
 } from "./digital-signature";
+import { AsconWrapper } from "./sponges/index";
 
 export {
   AesRsaHybridEncryptResult,
   AESRSAHybridInitializer,
   AESWrapper,
   Argon2Wrapper,
+  AsconWrapper,
   BCryptWrapper,
+  DigitalSignatureFactory,
+  DigitalSignatureSHA256Wrapper,
+  DigitalSignatureSHA512Wrapper,
+  DigitalSignatureType,
   HasherFactory,
   HasherType,
   HybridEncryptionWrapper,
@@ -37,8 +43,4 @@ export {
   ScryptWrapper,
   SHAWrapper,
   X25519Wrapper,
-  DigitalSignatureFactory,
-  DigitalSignatureSHA256Wrapper,
-  DigitalSignatureSHA512Wrapper,
-  DigitalSignatureType,
 };

src-ts/index.ts

@@ -0,0 +1,50 @@
+import {
+  ascon128Decrypt,
+  ascon128Encrypt,
+  ascon128KeyGenerate,
+  ascon128NonceGenerate,
+} from "../../index";
+
+export class AsconWrapper {
+  ascon128Key(): Array<number> {
+    return ascon128KeyGenerate();
+  }
+
+  ascon128Nonce(): Array<number> {
+    return ascon128NonceGenerate();
+  }
+
+  ascon128Encrypt(
+    key: Array<number>,
+    nonce: Array<number>,
+    plaintext: Array<number>,
+  ): Array<number> {
+    if (!key || key.length === 0) {
+      throw new Error("Key is required");
+    }
+    if (!nonce || nonce.length === 0) {
+      throw new Error("Nonce is required");
+    }
+    if (!plaintext || plaintext.length === 0) {
+      throw new Error("Plaintext is required");
+    }
+    return ascon128Encrypt(key, nonce, plaintext);
+  }
+
+  ascon128Decrypt(
+    key: Array<number>,
+    nonce: Array<number>,
+    ciphertext: Array<number>,
+  ): Array<number> {
+    if (!key || key.length === 0) {
+      throw new Error("Key is required");
+    }
+    if (!nonce || nonce.length === 0) {
+      throw new Error("Nonce is required");
+    }
+    if (!ciphertext || ciphertext.length === 0) {
+      throw new Error("Ciphertext is required");
+    }
+    return ascon128Decrypt(key, nonce, ciphertext);
+  }
+}

src-ts/sponges/ascon-wrapper.ts

@@ -0,0 +1,3 @@
+import { AsconWrapper } from "./ascon-wrapper";
+
+export {AsconWrapper}

src-ts/sponges/index.ts

@@ -33,3 +33,8 @@ mod digital_signature {
     pub mod sha_512_ed25519;
     pub mod sha_256_ed25519;
 }
+
+mod sponges {
+    pub mod cas_ascon_aead;
+    pub mod ascon_aead;
+}

src/lib.rs

@@ -0,0 +1,84 @@
+
+use aes_gcm::AeadCore;
+use ascon_aead::{aead::{generic_array::GenericArray, Aead, KeyInit, OsRng}, Ascon128};
+use napi_derive::napi;
+
+use super::cas_ascon_aead::{CASAsconAead};
+pub struct AsconAead;
+
+impl CASAsconAead for AsconAead {
+    fn encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
+        let key_generic_array = GenericArray::from_slice(&key);
+        let nonce_generic_array = GenericArray::from_slice(&nonce);
+        let cipher = Ascon128::new(key_generic_array);
+        let ciphertext = cipher.encrypt(&nonce_generic_array, plaintext.as_ref()).unwrap();
+        ciphertext
+    }
+
+    fn decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
+        let key_generic_array = GenericArray::from_slice(&key);
+        let nonce_generic_array = GenericArray::from_slice(&nonce);
+        let cipher = Ascon128::new(key_generic_array);
+        let plaintext = cipher.decrypt(&nonce_generic_array, ciphertext.as_ref()).unwrap();
+        plaintext
+    }
+    
+    fn generate_key() -> Vec<u8> {
+        return Ascon128::generate_key(&mut OsRng).to_vec();
+    }
+    
+    fn generate_nonce() -> Vec<u8> {
+        return Ascon128::generate_nonce(&mut OsRng).to_vec();
+    }
+}
+
+#[napi]
+pub fn ascon128_key_generate() -> Vec<u8> {
+    return AsconAead::generate_key();
+}
+
+#[test]
+fn test_ascon128_key_generate() {
+    let key = ascon128_key_generate();
+    assert_eq!(key.len(), 16);
+}
+
+#[napi]
+pub fn ascon128_nonce_generate() -> Vec<u8> {
+    return AsconAead::generate_nonce();
+}
+
+#[test]
+pub fn test_ascon128_nonce_generate() {
+    let nonce = ascon128_nonce_generate();
+    assert_eq!(nonce.len(), 16);
+}
+
+#[napi]
+pub fn ascon128_encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
+    return AsconAead::encrypt(key, nonce, plaintext);
+}
+
+#[test]
+pub fn test_ascon128_encrypt() {
+    let key = AsconAead::generate_key();
+    let nonce = AsconAead::generate_nonce();
+    let plaintext = b"Hello, World!".to_vec();
+    let ciphertext = ascon128_encrypt(key.clone(), nonce.clone(), plaintext.clone());
+    assert_ne!(ciphertext, plaintext);
+}
+
+#[napi]
+pub fn ascon128_decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
+    return AsconAead::decrypt(key, nonce, ciphertext);
+}
+
+#[test]
+pub fn test_ascon128_decrypt() {
+    let key = AsconAead::generate_key();
+    let nonce = AsconAead::generate_nonce();
+    let plaintext = b"Hello, World!".to_vec();
+    let ciphertext = ascon128_encrypt(key.clone(), nonce.clone(), plaintext.clone());
+    let decrypted = ascon128_decrypt(key.clone(), nonce.clone(), ciphertext.clone());
+    assert_eq!(decrypted, plaintext);
+}

src/sponges/ascon_aead.rs

@@ -0,0 +1,6 @@
+pub trait CASAsconAead {
+    fn generate_key() -> Vec<u8>;
+    fn generate_nonce() -> Vec<u8>;
+    fn encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8>;
+    fn decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8>;
+}

src/sponges/cas_ascon_aead.rs

@@ -4,7 +4,7 @@ import { ScryptWrapper } from "../src-ts/password-hashers/index";
 import {
   PasswordHasherFactory,
   PasswordHasherType,
-} from "../src-ts/password-hashers/";
+} from "../src-ts/password-hashers";
 
 describe("Bcrypt Tests", () => {
   it("hash", () => {

test-ts/key-exchange-test.spec.ts renamed to test-ts/key-exchange.test.spec.ts

@@ -0,0 +1,28 @@
+import { AsconWrapper } from "../src-ts/sponges/ascon-wrapper";
+import { assert } from "chai";
+import { areEqual } from "./helpers/array";
+
+describe("Sponges Tests", () => {
+    it("Ascon 128 Encrypt", () => {
+        const wrapper: AsconWrapper = new AsconWrapper();
+        const key: Array<number> = wrapper.ascon128Key();
+        const nonce: Array<number> = wrapper.ascon128Nonce();
+        const tohashed: string = "This is my array to encrypt";
+        const encoder = new TextEncoder();
+        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
+        const ciphertext = wrapper.ascon128Encrypt(key, nonce, tohashBytes);
+        assert.isNotTrue(areEqual(tohashBytes, ciphertext));
+    });
+
+    it ("Ascon 128 Decrypt", () => {
+        const wrapper: AsconWrapper = new AsconWrapper();
+        const key: Array<number> = wrapper.ascon128Key();
+        const nonce: Array<number> = wrapper.ascon128Nonce();
+        const tohashed: string = "This is my array to encrypt";
+        const encoder = new TextEncoder();
+        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
+        const ciphertext = wrapper.ascon128Encrypt(key, nonce, tohashBytes);
+        const plaintext = wrapper.ascon128Decrypt(key, nonce, ciphertext);
+        assert.equal(areEqual(plaintext, tohashBytes), true);
+    });
+});