cas-typescript-sdk 1.0.39 → 1.0.42

package/Cargo.toml

@@ -11,7 +11,7 @@ crate-type = ["cdylib"]
 napi = "2.16.17"
 napi-derive = "2.16.13"
 csbindgen = "1.9.3"
-cas-lib = { version = "=0.2.58" }
+cas-lib = { version = "=0.2.65" }
 zeroize = "1.8.1"
 zeroizing-alloc = "0.1.0"
 

package/index.d.ts

@@ -26,19 +26,18 @@ export declare function aes128Encrypt(aesKey: Array<number>, nonce: Array<number
 export declare function aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
 export declare function aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
 export declare function aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
-export declare function aes256KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
-export declare function aes128KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
+export declare function aes256KeyFromX25519SharedSecret(sharedSecret: Array<number>): Array<number>
+export declare function aes128KeyFromX25519SharedSecret(sharedSecret: Array<number>): Array<number>
 export declare function generateRsaKeys(keySize: number): CasrsaKeyPairResult
 export declare function signRsa(privateKey: string, hash: Array<number>): Array<number>
 export declare function verifyRsa(publicKey: string, hash: Array<number>, signature: Array<number>): boolean
+export declare function generateEd25519Keys(): Cased25519KeyPairResult
+export declare function signEd25519(privateKey: Array<number>, message: Array<number>): Array<number>
+export declare function verifyEd25519(publicKey: Array<number>, message: Array<number>, signature: Array<number>): boolean
 export declare function sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CASRSADigitalSignatureResult
 export declare function sha512RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
 export declare function sha256RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CASRSADigitalSignatureResult
 export declare function sha256RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
-export declare function sha512Ed25519DigitalSignature(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult
-export declare function sha512Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
-export declare function sha256Ed25519DigitalSignature(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult
-export declare function sha256Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
 export declare function ascon128KeyGenerate(): Array<number>
 export declare function ascon128NonceGenerate(): Array<number>
 export declare function ascon128Encrypt(key: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
@@ -51,18 +50,18 @@ export declare class CaSx25519SecretPublicKeyResult {
   secretKey: Array<number>
   constructor(publicKey: Array<number>, secretKey: Array<number>)
 }
-export type CASAesKeyFromX25519SharedSecret = CasAesKeyFromX25519SharedSecret
-export declare class CasAesKeyFromX25519SharedSecret {
-  aesKey: Array<number>
-  aesNonce: Array<number>
-  constructor(aesKey: Array<number>, aesNonce: Array<number>)
-}
 export type CASRSAKeyPairResult = CasrsaKeyPairResult
 export declare class CasrsaKeyPairResult {
   privateKey: string
   publicKey: string
   constructor(privateKey: string, publicKey: string)
 }
+export type CASED25519KeyPairResult = Cased25519KeyPairResult
+export declare class Cased25519KeyPairResult {
+  privateKey: Array<number>
+  publicKey: Array<number>
+  constructor(privateKey: Array<number>, publicKey: Array<number>)
+}
 export type CASSHAED25519DalekDigitalSignatureResult = Casshaed25519DalekDigitalSignatureResult
 export declare class Casshaed25519DalekDigitalSignatureResult {
   publicKey: Array<number>

package/lib/digital-signature/digital-siganture-sha-512.d.ts

@@ -1,20 +1,6 @@
-import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
+import { CASRSADigitalSignatureResult } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 export declare class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
-    /**
-     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
-     * @param dataToSign
-     * @returns CASSHAED25519DalekDigitalSignatureResult
-     */
-    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult;
-    /**
-     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
-     * @param publicKey
-     * @param dataToVerify
-     * @param signature
-     * @returns boolean
-     */
-    verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean;
     /**
      * Generates and RSA digital signature with SHA3-512
      * @param rsa_key_size

package/lib/digital-signature/digital-siganture-sha-512.js

@@ -3,36 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigitalSignatureSHA512Wrapper = void 0;
 const index_1 = require("../../index");
 class DigitalSignatureSHA512Wrapper {
-    /**
-     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
-     * @param dataToSign
-     * @returns CASSHAED25519DalekDigitalSignatureResult
-     */
-    createED25519(dataToSign) {
-        if (dataToSign?.length === 0) {
-            throw new Error("Must provide allocated data to sign");
-        }
-        return (0, index_1.sha512Ed25519DigitalSignature)(dataToSign);
-    }
-    /**
-     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
-     * @param publicKey
-     * @param dataToVerify
-     * @param signature
-     * @returns boolean
-     */
-    verifyED25519(publicKey, dataToVerify, signature) {
-        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 (0, index_1.sha512Ed25519DigitalSignatureVerify)(publicKey, dataToVerify, signature);
-    }
     /**
      * Generates and RSA digital signature with SHA3-512
      * @param rsa_key_size

package/lib/digital-signature/digital-signature-base.d.ts

@@ -1,7 +1,5 @@
-import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
+import { CASRSADigitalSignatureResult } from "../../index";
 export interface IDigitalSignature {
     createRsa(rsa_key_size: number, data_to_sign: Array<number>): CASRSADigitalSignatureResult;
     verifyRSa(public_key: string, data_to_verify: Array<number>, signature: Array<number>): boolean;
-    createED25519(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult;
-    verifyED25519(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean;
 }

package/lib/digital-signature/digital-signaturte-sha-256.d.ts

@@ -1,20 +1,6 @@
-import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
+import { CASRSADigitalSignatureResult } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 export declare class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
-    /**
-     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
-     * @param dataToSign
-     * @returns SHAED25519DalekDigitalSignatureResult
-     */
-    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult;
-    /**
-     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
-     * @param publicKey
-     * @param dataToVerify
-     * @param signature
-     * @returns boolean
-     */
-    verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean;
     /**
      * Generates and RSA digital signature with SHA3-512
      * @param rsa_key_size

package/lib/digital-signature/digital-signaturte-sha-256.js

@@ -3,36 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigitalSignatureSHA256Wrapper = void 0;
 const index_1 = require("../../index");
 class DigitalSignatureSHA256Wrapper {
-    /**
-     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
-     * @param dataToSign
-     * @returns SHAED25519DalekDigitalSignatureResult
-     */
-    createED25519(dataToSign) {
-        if (dataToSign?.length === 0) {
-            throw new Error("Must provide allocated data to sign");
-        }
-        return (0, index_1.sha256Ed25519DigitalSignature)(dataToSign);
-    }
-    /**
-     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
-     * @param publicKey
-     * @param dataToVerify
-     * @param signature
-     * @returns boolean
-     */
-    verifyED25519(publicKey, dataToVerify, signature) {
-        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 (0, index_1.sha256Ed25519DigitalSignatureVerify)(publicKey, dataToVerify, signature);
-    }
     /**
      * Generates and RSA digital signature with SHA3-512
      * @param rsa_key_size

package/lib/index.d.ts

@@ -6,3 +6,4 @@ export * from "./asymmetric/index";
 export * from "./digital-signature";
 export * from "./sponges/index";
 export * from "./message/index";
+export * from "./signature/index";

package/lib/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./asymmetric/index"), exports);
 __exportStar(require("./digital-signature"), exports);
 __exportStar(require("./sponges/index"), exports);
 __exportStar(require("./message/index"), exports);
+__exportStar(require("./signature/index"), exports);

package/lib/signature/ed25519-wrapper.d.ts

@@ -0,0 +1,22 @@
+import { Cased25519KeyPairResult } from "../../index";
+export declare class Ed25519Wrapper {
+    /**
+     * Generates a new Ed25519 key pair
+     */
+    getKeyPair(): Cased25519KeyPairResult;
+    /**
+     * Signs a message with the given Ed25519 private key
+     * @param privateKey The private key to sign the message with
+     * @param message The message to sign
+     * @returns The signature
+     */
+    signMessage(privateKey: number[], message: number[]): number[];
+    /**
+     * Verifies a signature for a message with the given Ed25519 public key
+     * @param publicKey The public key to verify the signature with
+     * @param message The signed message
+     * @param signature The signature to verify
+     * @returns True if the signature is valid, false otherwise
+     */
+    verifyMessage(publicKey: number[], message: number[], signature: number[]): boolean;
+}

package/lib/signature/ed25519-wrapper.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ed25519Wrapper = void 0;
+const index_1 = require("../../index");
+class Ed25519Wrapper {
+    /**
+     * Generates a new Ed25519 key pair
+     */
+    getKeyPair() {
+        return (0, index_1.generateEd25519Keys)();
+    }
+    /**
+     * Signs a message with the given Ed25519 private key
+     * @param privateKey The private key to sign the message with
+     * @param message The message to sign
+     * @returns The signature
+     */
+    signMessage(privateKey, message) {
+        return (0, index_1.signEd25519)(privateKey, message);
+    }
+    /**
+     * Verifies a signature for a message with the given Ed25519 public key
+     * @param publicKey The public key to verify the signature with
+     * @param message The signed message
+     * @param signature The signature to verify
+     * @returns True if the signature is valid, false otherwise
+     */
+    verifyMessage(publicKey, message, signature) {
+        return (0, index_1.verifyEd25519)(publicKey, message, signature);
+    }
+}
+exports.Ed25519Wrapper = Ed25519Wrapper;

package/lib/signature/index.d.ts

@@ -0,0 +1,2 @@
+import { Ed25519Wrapper } from "./ed25519-wrapper";
+export { Ed25519Wrapper };

package/lib/signature/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ed25519Wrapper = void 0;
+const ed25519_wrapper_1 = require("./ed25519-wrapper");
+Object.defineProperty(exports, "Ed25519Wrapper", { enumerable: true, get: function () { return ed25519_wrapper_1.Ed25519Wrapper; } });

package/lib/symmetric/aes-wrapper.d.ts

@@ -1,4 +1,3 @@
-import { CASAesKeyFromX25519SharedSecret } from "../../index";
 export declare class AESWrapper {
     /**
      * @description Generates a 128 bit AES key
@@ -52,11 +51,11 @@ export declare class AESWrapper {
      * @param shared_secret
      * @returns
      */
-    aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret;
+    aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): number[];
     /**
      * Derives an AES-128 key from a X25519 Diffie Hellman shared secret.
      * @param shared_secret
      * @returns
      */
-    aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret;
+    aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): number[];
 }

package/lib/symmetric/index.d.ts

@@ -1,3 +1,2 @@
-import { CASAesKeyFromX25519SharedSecret } from "../../index";
 import { AESWrapper } from "./aes-wrapper";
-export { AESWrapper, CASAesKeyFromX25519SharedSecret };
+export { AESWrapper };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.39",
+  "version": "1.0.42",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -29,7 +29,8 @@
   },
   "dependencies": {
     "@napi-rs/cli": "^2.18.4",
-    "rimraf": "^6.0.1"
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3"
   },
   "devDependencies": {
     "@types/chai": "^4.3.20",
@@ -37,7 +38,6 @@
     "@types/node-fetch": "^2.6.12",
     "chai": "^4.5.0",
     "mocha": "^10.8.2",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
+    "ts-node": "^10.9.2"
   }
 }

package/src/asymmetric/cas_ed25519.rs

@@ -0,0 +1,35 @@
+
+use cas_lib::signatures::cas_ed25519::{Ed25519ByteKeyPair, Ed25519ByteSignature};
+use cas_lib::signatures::ed25519::{get_ed25519_key_pair, ed25519_sign_with_key_pair, ed25519_verify_with_public_key};
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct CASED25519KeyPairResult {
+    pub private_key: Vec<u8>,
+    pub public_key: Vec<u8>,
+}
+
+impl From<Ed25519ByteKeyPair> for CASED25519KeyPairResult {
+    fn from(result: Ed25519ByteKeyPair) -> Self {
+        CASED25519KeyPairResult {
+            private_key: result.key_pair,
+            public_key: result.public_key
+        }
+    }
+}
+
+#[napi]
+pub fn generate_ed25519_keys() -> CASED25519KeyPairResult {
+    return get_ed25519_key_pair().into();
+}
+
+#[napi]
+pub fn sign_ed25519(private_key: Vec<u8>, message: Vec<u8>) -> Vec<u8> {
+    let signature = ed25519_sign_with_key_pair(private_key, message);
+    signature.signature // assuming Ed25519ByteSignature has a field named `signature: Vec<u8>`
+}
+
+#[napi]
+pub fn verify_ed25519(public_key: Vec<u8>, message: Vec<u8>, signature: Vec<u8>) -> bool {
+    return ed25519_verify_with_public_key(public_key, signature, message);
+}

package/src/lib.rs

@@ -20,18 +20,16 @@ mod key_exchange {
 
 mod symmetric {
     pub mod aes;
-    mod types;
 }
 
 mod asymmetric {
     pub mod cas_rsa;
+    pub mod cas_ed25519;
 }
 
 mod digital_signature {
     pub mod sha_512_rsa;
     pub mod sha_256_rsa;
-    pub mod sha_512_ed25519;
-    pub mod sha_256_ed25519;
     mod types;
 }
 

package/src/symmetric/aes.rs

@@ -1,8 +1,6 @@
 use cas_lib::symmetric::{aes::{CASAES128, CASAES256}, cas_symmetric_encryption::{CASAES128Encryption, CASAES256Encryption}};
 use napi_derive::napi;
 
-use super::types::CASAesKeyFromX25519SharedSecret;
-
 #[napi]
 pub fn aes_nonce() -> Vec<u8> {
     return <CASAES256 as CASAES256Encryption>::generate_nonce().to_vec();
@@ -41,14 +39,14 @@ pub fn aes256_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) ->
 #[napi]
 pub fn aes_256_key_from_x25519_shared_secret(
     shared_secret: Vec<u8>,
-) -> CASAesKeyFromX25519SharedSecret {
+) -> Vec<u8> {
     return <CASAES256 as CASAES256Encryption>::key_from_x25519_shared_secret(shared_secret).into();
 }
 
 #[napi]
 pub fn aes_128_key_from_x25519_shared_secret(
     shared_secret: Vec<u8>,
-) -> CASAesKeyFromX25519SharedSecret {
+) -> Vec<u8> {
     return <CASAES128 as CASAES128Encryption>::key_from_x25519_shared_secret(shared_secret).into();
 }
 

package/src-ts/digital-signature/digital-siganture-sha-512.ts

@@ -1,40 +1,7 @@
-import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult, sha512Ed25519DigitalSignature, sha512Ed25519DigitalSignatureVerify, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 
 export class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
-
-    /**
-     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
-     * @param dataToSign 
-     * @returns CASSHAED25519DalekDigitalSignatureResult
-     */
-    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult {
-        if (dataToSign?.length === 0) {
-            throw new Error("Must provide allocated data to sign");
-        }
-        return sha512Ed25519DigitalSignature(dataToSign);
-    }
-
-    /**
-     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
-     * @param publicKey 
-     * @param dataToVerify 
-     * @param signature 
-     * @returns boolean
-     */
-    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 sha512Ed25519DigitalSignatureVerify(publicKey, dataToVerify, signature);
-    }
-
     /**
      * Generates and RSA digital signature with SHA3-512
      * @param rsa_key_size 

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

@@ -3,6 +3,4 @@ import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult
 export interface IDigitalSignature {
     createRsa(rsa_key_size: number, data_to_sign: Array<number>): CASRSADigitalSignatureResult;
     verifyRSa(public_key: string, data_to_verify: Array<number>, signature: Array<number>): boolean;
-    createED25519(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult;
-    verifyED25519(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean;
 }

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

@@ -1,39 +1,7 @@
-import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult, sha256Ed25519DigitalSignature, sha256Ed25519DigitalSignatureVerify, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature, sha512Ed25519DigitalSignature } from "../../index";
+import { CASRSADigitalSignatureResult, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 
 export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
-    
-    /**
-     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
-     * @param dataToSign 
-     * @returns SHAED25519DalekDigitalSignatureResult
-     */
-    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult {
-        if (dataToSign?.length === 0) {
-            throw new Error("Must provide allocated data to sign");
-        }
-        return sha256Ed25519DigitalSignature(dataToSign);
-    }
-
-    /**
-     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
-     * @param publicKey 
-     * @param dataToVerify 
-     * @param signature 
-     * @returns boolean
-     */
-    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);
-    }
 
     /**
      * Generates and RSA digital signature with SHA3-512

package/src-ts/index.ts

@@ -5,4 +5,5 @@ export * from "./symmetric/index";
 export * from "./asymmetric/index";
 export * from "./digital-signature";
 export * from "./sponges/index";
-export * from "./message/index";
+export * from "./message/index";
+export * from "./signature/index";

package/src-ts/signature/ed25519-wrapper.ts

@@ -0,0 +1,36 @@
+import {
+  Cased25519KeyPairResult,
+  generateEd25519Keys,
+  signEd25519,
+  verifyEd25519,
+} from "../../index";
+
+export class Ed25519Wrapper {
+  /**
+   * Generates a new Ed25519 key pair
+   */
+  public getKeyPair(): Cased25519KeyPairResult {
+    return generateEd25519Keys();
+  }
+
+  /**
+   * Signs a message with the given Ed25519 private key
+   * @param privateKey The private key to sign the message with
+   * @param message The message to sign
+   * @returns The signature
+   */
+  public signMessage(privateKey: number[], message: number[]): number[] {
+    return signEd25519(privateKey, message);
+  }
+
+  /**
+   * Verifies a signature for a message with the given Ed25519 public key
+   * @param publicKey The public key to verify the signature with
+   * @param message The signed message
+   * @param signature The signature to verify
+   * @returns True if the signature is valid, false otherwise
+   */
+  public verifyMessage(publicKey: number[], message: number[], signature: number[]): boolean {
+    return verifyEd25519(publicKey, message, signature);
+  }
+}

package/src-ts/signature/index.ts

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

package/src-ts/symmetric/aes-wrapper.ts

@@ -1,5 +1,4 @@
 import {
-  CASAesKeyFromX25519SharedSecret,
   aes128Decrypt,
   aes128Encrypt,
   aes128Key,
@@ -87,7 +86,7 @@ export class AESWrapper {
      * @param shared_secret 
      * @returns 
      */
-    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret {
+    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): number[] {
          return aes256KeyFromX25519SharedSecret(shared_secret);
     }
 
@@ -96,7 +95,7 @@ export class AESWrapper {
      * @param shared_secret 
      * @returns 
      */
-    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret {
+    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): number[] {
         return aes128KeyFromX25519SharedSecret(shared_secret);
    }
 }

package/src-ts/symmetric/index.ts

@@ -1,4 +1,3 @@
-import { CASAesKeyFromX25519SharedSecret } from "../../index";
 import { AESWrapper } from "./aes-wrapper";
 
-export { AESWrapper, CASAesKeyFromX25519SharedSecret };
+export { AESWrapper };

package/test-ts/digital-signature.test.spec.ts

@@ -1,6 +1,7 @@
 import { assert } from "chai";
 import { DigitalSignatureFactory, DigitalSignatureType } from "../src-ts/digital-signature/digital-signature-factory";
 import { CASRSADigitalSignatureResult } from "../index";
+import { Ed25519Wrapper } from "../src-ts/signature/ed25519-wrapper";
 
 describe("Digital Signature", () => {
     it("SHA 512 RSA pass", () => {
@@ -47,47 +48,23 @@ describe("Digital Signature", () => {
         assert.equal(verify, false);
     });
 
-    it("SHA 512 ED25519 pass", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
-        const toHash: string = "This is my array to encrypt";
-        const encoder = new TextEncoder();
-        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
-        const dsResult = shaDsWrapper.createED25519(toHashBytes);
-        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, toHashBytes, dsResult.signature);
-        assert.equal(verify, true);
-    });
 
-    it("SHA 512 ED25519 fails", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
-        const toHash: string = "This is my array to encrypt";
-        const notOriginal: string = "This is not a fun time";
-        const encoder = new TextEncoder();
-        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
-        const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-        const dsResult = shaDsWrapper.createED25519(toHashBytes);
-        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, badBytes, dsResult.signature);
-        assert.equal(verify, false);
+    it("ED25519 Sign and Verify", () => {
+        const ed25519 = new Ed25519Wrapper();
+        const keyPair = ed25519.getKeyPair();
+        const message = Array.from(new TextEncoder().encode("This is a test message"));
+        const signature = ed25519.signMessage(keyPair.privateKey, message);
+        const isValid = ed25519.verifyMessage(keyPair.publicKey, message, signature);
+        assert.equal(isValid, true);
     });
 
-    it("SHA 256 ED25519 pass", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA256)
-        const toHash: string = "This is my array to encrypt";
-        const encoder = new TextEncoder();
-        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
-        const dsResult = shaDsWrapper.createED25519(toHashBytes);
-        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, toHashBytes, dsResult.signature);
-        assert.equal(verify, true);
-    });
-
-    it("SHA 256 ED25519 fails", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA256)
-        const toHash: string = "This is my array to encrypt";
-        const notOriginal: string = "This is not a fun time";
-        const encoder = new TextEncoder();
-        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
-        const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-        const dsResult = shaDsWrapper.createED25519(toHashBytes);
-        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, badBytes, dsResult.signature);
-        assert.equal(verify, false);
+    it("ED25519 Verify Fails with Wrong Message", () => {
+        const ed25519 = new Ed25519Wrapper();
+        const keyPair = ed25519.getKeyPair();
+        const message = Array.from(new TextEncoder().encode("This is a test message"));
+        const wrongMessage = Array.from(new TextEncoder().encode("This is a different message"));
+        const signature = ed25519.signMessage(keyPair.privateKey, message);
+        const isValid = ed25519.verifyMessage(keyPair.publicKey, wrongMessage, signature);
+        assert.equal(isValid, false);
     });
 });

package/test-ts/insecure-channel.test.spec.ts

@@ -21,8 +21,10 @@ describe("Insecure Channel Tests", () => {
       const encoder = new TextEncoder();
       const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
 
-      const encrypted = aesWrapper.aes256Encrypt(alice_aes_key?.aesKey, alice_aes_key?.aesNonce, toEncrypt);
-      const decrypted = aesWrapper.aes256Decrypt(bob_aes_key?.aesKey, bob_aes_key?.aesNonce, encrypted);
+      const nonce = aesWrapper.generateAESNonce();
+
+      const encrypted = aesWrapper.aes256Encrypt(alice_aes_key, nonce, toEncrypt);
+      const decrypted = aesWrapper.aes256Decrypt(bob_aes_key, nonce, encrypted);
       let result = areEqual(decrypted, toEncrypt);
       assert.isTrue(result);
     });
@@ -43,8 +45,10 @@ describe("Insecure Channel Tests", () => {
       const encoder = new TextEncoder();
       const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
 
-      const encrypted = aesWrapper.aes128Encrypt(alice_aes_key?.aesKey, alice_aes_key?.aesNonce, toEncrypt);
-      const decrypted = aesWrapper.aes128Decrypt(bob_aes_key?.aesKey, bob_aes_key?.aesNonce, encrypted);
+      const nonce = aesWrapper.generateAESNonce();
+
+      const encrypted = aesWrapper.aes128Encrypt(alice_aes_key, nonce, toEncrypt);
+      const decrypted = aesWrapper.aes128Decrypt(bob_aes_key, nonce, encrypted);
       let result = areEqual(decrypted, toEncrypt);
       assert.isTrue(result);
     });

package/test-ts/symmetric.test.spec.ts

@@ -42,12 +42,14 @@ describe("Symmetric Tests", () => {
     const aliceAesKey = aesWrapper.aes256KeyNonceX25519DiffieHellman(aliceSharedSecret);
     const bobAesKey = aesWrapper.aes256KeyNonceX25519DiffieHellman(bobSharedSecret);
 
+    const nonce = aesWrapper.generateAESNonce();
+
     const tohashed: string = "This is my array to encrypt";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
 
-    const aliceCiphertext = aesWrapper.aes256Encrypt(aliceAesKey.aesKey, aliceAesKey.aesNonce, tohashBytes);
-    const bobPlaintext = aesWrapper.aes256Decrypt(bobAesKey.aesKey, aliceAesKey.aesNonce, aliceCiphertext);
+    const aliceCiphertext = aesWrapper.aes256Encrypt(aliceAesKey, nonce, tohashBytes);
+    const bobPlaintext = aesWrapper.aes256Decrypt(bobAesKey, nonce, aliceCiphertext);
 
     var result = areEqual(bobPlaintext, tohashBytes);
     assert.isTrue(result);
@@ -69,8 +71,10 @@ describe("Symmetric Tests", () => {
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
 
-    const aliceCiphertext = aesWrapper.aes128Encrypt(aliceAesKey.aesKey, aliceAesKey.aesNonce, tohashBytes);
-    const bobPlaintext = aesWrapper.aes128Decrypt(bobAesKey.aesKey, aliceAesKey.aesNonce, aliceCiphertext);
+    const nonce = aesWrapper.generateAESNonce();
+
+    const aliceCiphertext = aesWrapper.aes128Encrypt(aliceAesKey, nonce, tohashBytes);
+    const bobPlaintext = aesWrapper.aes128Decrypt(bobAesKey, nonce, aliceCiphertext);
 
     var result = areEqual(bobPlaintext, tohashBytes);
     assert.isTrue(result);

package/src/digital_signature/sha_256_ed25519.rs

@@ -1,37 +0,0 @@
-use cas_lib::digital_signature::{cas_digital_signature_rsa::ED25519DigitalSignature, sha_256_ed25519::SHA256ED25519DigitalSignature};
-use napi_derive::napi;
-
-use super::types::CASSHAED25519DalekDigitalSignatureResult;
-
-#[napi]
-pub fn sha_256_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
-    return <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign).into();
-}
-
-#[napi]
-pub fn sha_256_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
-    if public_key.len() != 32 || signature.len() != 64 {
-        return false;
-    }
-    SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(public_key, data_to_verify, signature)
-}
-
-
-#[test]
-fn sha_256_ed25519_test() {
-    let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone()).into();
-    let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
-    assert_eq!(is_verified, true);
-}
-
-#[test]
-fn sha_512_ed25519_test_fail() {
-    let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone()).into();
-    let not_original_data = b"NOtTHoseBytes".to_vec();
-    let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, not_original_data, signature_result.signature);
-    assert_eq!(is_verified, false);
-}

package/src/digital_signature/sha_512_ed25519.rs

@@ -1,43 +0,0 @@
-use cas_lib::digital_signature::{cas_digital_signature_rsa::{ED25519DigitalSignature, SHAED25519DalekDigitalSignatureResult}, sha_512_ed25519::SHA512ED25519DigitalSignature};
-
-use napi_derive::napi;
-
-use super::types::CASSHAED25519DalekDigitalSignatureResult;
-
-
-#[napi]
-pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
-    return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign).into();
-}
-
-#[napi]
-pub fn sha_512_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
-    return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify(
-        public_key,
-        data_to_verify,
-        signature,
-    );
-}
-
-#[test]
-fn sha_512_ed25519_test() {
-    let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: SHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign.clone());
-    let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
-    assert_eq!(is_verified, true);
-}
-
-#[test]
-fn sha_512_ed25519_test_fail() {
-    let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign.clone()).into();
-    let not_original_data = b"NOtTHoseBytes".to_vec();
-    let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(
-        signature_result.public_key,
-        not_original_data,
-        signature_result.signature,
-    );
-    assert_eq!(is_verified, false);
-}

package/src/symmetric/types.rs

@@ -1,27 +0,0 @@
-
-use cas_lib::symmetric::cas_symmetric_encryption::{Aes128KeyFromX25519SharedSecret, Aes256KeyFromX25519SharedSecret};
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct CASAesKeyFromX25519SharedSecret {
-    pub aes_key: Vec<u8>,
-    pub aes_nonce: Vec<u8>,
-}
-
-impl From<Aes128KeyFromX25519SharedSecret> for CASAesKeyFromX25519SharedSecret {
-    fn from(value: Aes128KeyFromX25519SharedSecret) -> Self {
-        CASAesKeyFromX25519SharedSecret {
-            aes_key: value.aes_key.to_vec(),
-            aes_nonce: value.aes_nonce.to_vec()
-        }
-    }
-}
-
-impl From<Aes256KeyFromX25519SharedSecret> for CASAesKeyFromX25519SharedSecret {
-    fn from(value: Aes256KeyFromX25519SharedSecret) -> Self {
-        CASAesKeyFromX25519SharedSecret {
-            aes_key: value.aes_key.to_vec(),
-            aes_nonce: value.aes_nonce.to_vec()
-        }
-    }
-}