cas-typescript-sdk 1.0.16 → 1.0.18

package/README.md

@@ -1,6 +1,8 @@
 # cas-typescript-sdk
 
-Ever wanted all of your most useful cryptograpihc operations in one module and not have to surf documentation for various packages? 
+[![image](https://img.shields.io/badge/Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/7bXXCQj45q)
+
+Ever wanted all of your most useful cryptographic operations in one module and not have to surf documentation for various packages? 
 CAS is here to provide a unified development experience as an abstract layer to the RustCrypto and Dalek-Cryptography suite of algorithms.
 The official NPM page can be found [here](https://www.npmjs.com/package/cas-typescript-sdk).
 

package/index.d.ts

@@ -29,12 +29,14 @@ export function encryptPlaintextRsa(publicKey: string, plaintext: Array<number>)
 export function decryptCiphertextRsa(privateKey: string, ciphertext: Array<number>): Array<number>
 export function signRsa(privateKey: string, hash: Array<number>): Array<number>
 export function verifyRsa(publicKey: string, hash: Array<number>, signature: Array<number>): boolean
-export function sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CasrsaDigitalSignatureResult
+export function sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): RsaDigitalSignatureResult
 export function sha512RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
-export function sha256RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CasrsaDigitalSignatureResult
+export function sha256RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): RsaDigitalSignatureResult
 export function sha256RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
-export function sha512Ed25519DigitalSignature(dataToSign: Array<number>): Casshaed25519DalekDigitalSignatureResult
+export function sha512Ed25519DigitalSignature(dataToSign: Array<number>): Shaed25519DalekDigitalSignatureResult
 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 type x25519SecretPublicKeyResult = X25519SecretPublicKeyResult
 export class X25519SecretPublicKeyResult {
   publicKey: Array<number>
@@ -52,15 +54,15 @@ export class RsaKeyPairResult {
   publicKey: string
   constructor(privateKey: string, publicKey: string)
 }
-export type CASRSADigitalSignatureResult = CasrsaDigitalSignatureResult
-export class CasrsaDigitalSignatureResult {
+export type RSADigitalSignatureResult = RsaDigitalSignatureResult
+export class RsaDigitalSignatureResult {
   publicKey: string
   privateKey: string
   signature: Array<number>
   constructor(publicKey: string, privateKey: string, signature: Array<number>)
 }
-export type CASSHAED25519DalekDigitalSignatureResult = Casshaed25519DalekDigitalSignatureResult
-export class Casshaed25519DalekDigitalSignatureResult {
+export type SHAED25519DalekDigitalSignatureResult = Shaed25519DalekDigitalSignatureResult
+export class Shaed25519DalekDigitalSignatureResult {
   publicKey: Array<number>
   signature: Array<number>
   constructor(publicKey: Array<number>, signature: Array<number>)

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

@@ -1,6 +1,8 @@
-import { CasrsaDigitalSignatureResult } from "../../index";
+import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 export declare class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
-    createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult;
+    createED25519(dataToSign: number[]): SHAED25519DalekDigitalSignatureResult;
+    verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean;
+    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult;
     verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean;
 }

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

@@ -3,6 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigitalSignatureSHA512Wrapper = void 0;
 const index_1 = require("../../index");
 class DigitalSignatureSHA512Wrapper {
+    createED25519(dataToSign) {
+        if (dataToSign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return (0, index_1.sha512Ed25519DigitalSignature)(dataToSign);
+    }
+    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);
+    }
     createRsa(rsa_key_size, data_to_sign) {
         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.");

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

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

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

@@ -1,6 +1,8 @@
-import { CasrsaDigitalSignatureResult } from "../../index";
+import { RsaDigitalSignatureResult, Shaed25519DalekDigitalSignatureResult } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 export declare class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
-    createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult;
+    createED25519(dataToSign: number[]): Shaed25519DalekDigitalSignatureResult;
+    verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean;
+    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult;
     verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean;
 }

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

@@ -3,6 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigitalSignatureSHA256Wrapper = void 0;
 const index_1 = require("../../index");
 class DigitalSignatureSHA256Wrapper {
+    createED25519(dataToSign) {
+        if (dataToSign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return (0, index_1.sha256Ed25519DigitalSignature)(dataToSign);
+    }
+    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);
+    }
     createRsa(rsa_key_size, data_to_sign) {
         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.");

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

@@ -1,4 +1,5 @@
-export declare enum DigitalSignatureType {
-    SHA512 = 1,
-    SHA256 = 2
-}
+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/lib/digital-signature/index.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DigitalSignatureType = void 0;
-var DigitalSignatureType;
-(function (DigitalSignatureType) {
-    DigitalSignatureType[DigitalSignatureType["SHA512"] = 1] = "SHA512";
-    DigitalSignatureType[DigitalSignatureType["SHA256"] = 2] = "SHA256";
-})(DigitalSignatureType || (exports.DigitalSignatureType = DigitalSignatureType = {}));
+exports.DigitalSignatureType = exports.DigitalSignatureSHA512Wrapper = exports.DigitalSignatureSHA256Wrapper = exports.DigitalSignatureFactory = void 0;
+const digital_signature_factory_1 = require("./digital-signature-factory");
+Object.defineProperty(exports, "DigitalSignatureType", { enumerable: true, get: function () { return digital_signature_factory_1.DigitalSignatureType; } });
+const digital_signature_factory_2 = require("./digital-signature-factory");
+Object.defineProperty(exports, "DigitalSignatureFactory", { enumerable: true, get: function () { return digital_signature_factory_2.DigitalSignatureFactory; } });
+const digital_signaturte_sha_256_1 = require("./digital-signaturte-sha-256");
+Object.defineProperty(exports, "DigitalSignatureSHA256Wrapper", { enumerable: true, get: function () { return digital_signaturte_sha_256_1.DigitalSignatureSHA256Wrapper; } });
+const digital_siganture_sha_512_1 = require("./digital-siganture-sha-512");
+Object.defineProperty(exports, "DigitalSignatureSHA512Wrapper", { enumerable: true, get: function () { return digital_siganture_sha_512_1.DigitalSignatureSHA512Wrapper; } });

package/lib/hashers/hasher-base.d.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;
+    hash512(dataToHash: number[]): number[];
+    verify512(dataToHash: number[], dataToVerify: number[]): boolean;
+    hash256(dataToHash: number[]): number[];
+    verify256(dataToHash: number[], dataToVerify: number[]): boolean;
 }

package/lib/hashers/sha-wrapper.d.ts

@@ -1,7 +1,7 @@
 import { IHasherBase } from "./hasher-base";
 export declare class SHAWrapper implements 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;
+    hash512(dataToHash: number[]): number[];
+    verify512(dataToHash: number[], dataToVerify: number[]): boolean;
+    hash256(dataToHash: number[]): number[];
+    verify256(dataToHash: number[], dataToVerify: number[]): boolean;
 }

package/lib/hashers/sha-wrapper.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SHAWrapper = void 0;
 const index_1 = require("../../index");
 class SHAWrapper {
-    hash_512(dataToHash) {
+    hash512(dataToHash) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return (0, index_1.sha512)(dataToHash);
     }
-    verify_512(dataToHash, dataToVerify) {
+    verify512(dataToHash, dataToVerify) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
@@ -18,13 +18,13 @@ class SHAWrapper {
         }
         return (0, index_1.sha512Verify)(dataToHash, dataToVerify);
     }
-    hash_256(dataToHash) {
+    hash256(dataToHash) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return (0, index_1.sha256)(dataToHash);
     }
-    verify_256(dataToHash, dataToVerify) {
+    verify256(dataToHash, dataToVerify) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }

package/lib/hybrid/types/aes-rsa-hybrid-initializer.js

@@ -15,7 +15,7 @@ class AESRSAHybridInitializer {
         this.aesType = aesType;
         let aesWrapper = new symmetric_1.AESWrapper();
         this.aesKey = (aesType === 128) ? aesWrapper.aes128Key() : aesWrapper.aes256Key();
-        this.aesNonce = aesWrapper.aesNonce();
+        this.aesNonce = aesWrapper.generateAESNonce();
         if (rsaSize !== 1028 && rsaSize !== 2048 && rsaSize !== 4096) {
             throw new Error("You must provide an appropriate RSA Key pair size to generate a hybrid initalizer");
         }

package/lib/index.d.ts

@@ -4,4 +4,5 @@ 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 { 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/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.RSAWrapper = exports.RsaKeyPairResult = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HybridEncryptionWrapper = exports.HasherType = exports.HasherFactory = exports.BCryptWrapper = exports.Argon2Wrapper = exports.AESWrapper = exports.AESRSAHybridInitializer = exports.AesRsaHybridEncryptResult = void 0;
+exports.DigitalSignatureType = exports.DigitalSignatureSHA512Wrapper = exports.DigitalSignatureSHA256Wrapper = exports.DigitalSignatureFactory = exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.RSAWrapper = exports.RsaKeyPairResult = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HybridEncryptionWrapper = exports.HasherType = exports.HasherFactory = exports.BCryptWrapper = exports.Argon2Wrapper = exports.AESWrapper = exports.AESRSAHybridInitializer = exports.AesRsaHybridEncryptResult = void 0;
 const index_1 = require("./password-hashers/index");
 Object.defineProperty(exports, "Argon2Wrapper", { enumerable: true, get: function () { return index_1.Argon2Wrapper; } });
 Object.defineProperty(exports, "BCryptWrapper", { enumerable: true, get: function () { return index_1.BCryptWrapper; } });
@@ -22,3 +22,8 @@ const index_6 = require("./hybrid/index");
 Object.defineProperty(exports, "AesRsaHybridEncryptResult", { enumerable: true, get: function () { return index_6.AesRsaHybridEncryptResult; } });
 Object.defineProperty(exports, "AESRSAHybridInitializer", { enumerable: true, get: function () { return index_6.AESRSAHybridInitializer; } });
 Object.defineProperty(exports, "HybridEncryptionWrapper", { enumerable: true, get: function () { return index_6.HybridEncryptionWrapper; } });
+const digital_signature_1 = require("./digital-signature");
+Object.defineProperty(exports, "DigitalSignatureFactory", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureFactory; } });
+Object.defineProperty(exports, "DigitalSignatureSHA256Wrapper", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureSHA256Wrapper; } });
+Object.defineProperty(exports, "DigitalSignatureSHA512Wrapper", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureSHA512Wrapper; } });
+Object.defineProperty(exports, "DigitalSignatureType", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureType; } });

package/lib/key_exchange/x25519.d.ts

@@ -1,5 +1,5 @@
 import { X25519SecretPublicKeyResult } from "../../index";
 export declare class X25519Wrapper {
     generateSecretAndPublicKey(): X25519SecretPublicKeyResult;
-    diffieHellman(secretKey: Array<number>, publicKey: Array<number>): number[];
+    generateSharedSecret(secretKey: Array<number>, publicKey: Array<number>): number[];
 }

package/lib/key_exchange/x25519.js

@@ -6,7 +6,7 @@ class X25519Wrapper {
     generateSecretAndPublicKey() {
         return (0, index_1.x25519GenerateSecretAndPublicKey)();
     }
-    diffieHellman(secretKey, publicKey) {
+    generateSharedSecret(secretKey, publicKey) {
         return (0, index_1.x25519DiffieHellman)(secretKey, publicKey);
     }
 }

package/lib/password-hashers/argon2-wrapper.d.ts

@@ -1,5 +1,5 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class Argon2Wrapper implements IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/lib/password-hashers/argon2-wrapper.js

@@ -9,7 +9,7 @@ class Argon2Wrapper {
         }
         return (0, index_1.argon2Hash)(password);
     }
-    verifyPassword(hashedPassword, passwordToVerify) {
+    verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
         }

package/lib/password-hashers/bcrypt-wrapper.d.ts

@@ -1,5 +1,5 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class BCryptWrapper implements IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/lib/password-hashers/bcrypt-wrapper.js

@@ -9,7 +9,7 @@ class BCryptWrapper {
         }
         return (0, index_1.bcryptHash)(password);
     }
-    verifyPassword(hashedPassword, passwordToVerify) {
+    verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
         }

package/lib/password-hashers/password-hasher-base.d.ts

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

package/lib/password-hashers/scrypt-wrapper.d.ts

@@ -1,5 +1,5 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class ScryptWrapper implements IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/lib/password-hashers/scrypt-wrapper.js

@@ -9,7 +9,7 @@ class ScryptWrapper {
         }
         return (0, index_1.scryptHash)(password);
     }
-    verifyPassword(hashedPassword, passwordToVerify) {
+    verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Scrypt");
         }

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

@@ -2,11 +2,11 @@ import { AesKeyFromX25519SharedSecret } from "../../index";
 export declare class AESWrapper {
     aes128Key(): Array<number>;
     aes256Key(): Array<number>;
-    aesNonce(): Array<number>;
+    generateAESNonce(): Array<number>;
     aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
     aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
     aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
     aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
-    aes256KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
-    aes128KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
+    aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
+    aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
 }

package/lib/symmetric/aes-wrapper.js

@@ -9,7 +9,7 @@ class AESWrapper {
     aes256Key() {
         return (0, index_1.aes256Key)();
     }
-    aesNonce() {
+    generateAESNonce() {
         return (0, index_1.aesNonce)();
     }
     aes128Encrypt(aesKey, nonce, plaintext) {
@@ -24,10 +24,10 @@ class AESWrapper {
     aes256Decrypt(aesKey, nonce, ciphertext) {
         return (0, index_1.aes256Decrypt)(aesKey, nonce, ciphertext);
     }
-    aes256KeyFromX25519SharedSecret(shared_secret) {
+    aes256KeyNonceX25519DiffieHellman(shared_secret) {
         return (0, index_1.aes256KeyFromX25519SharedSecret)(shared_secret);
     }
-    aes128KeyFromX25519SharedSecret(shared_secret) {
+    aes128KeyNonceX25519DiffieHellman(shared_secret) {
         return (0, index_1.aes128KeyFromX25519SharedSecret)(shared_secret);
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/digital_signature/cas_digital_signature_rsa.rs

@@ -1,27 +1,27 @@
 use napi_derive::napi;
 
 #[napi(constructor)]
-pub struct CASRSADigitalSignatureResult {
+pub struct RSADigitalSignatureResult {
     pub public_key: String,
     pub private_key: String,
     pub signature: Vec<u8>,
 }
 
 #[napi(constructor)]
-pub struct CASSHAED25519DalekDigitalSignatureResult {
+pub struct SHAED25519DalekDigitalSignatureResult {
     pub public_key: Vec<u8>,
     pub signature: Vec<u8>
 }
 
-pub trait CASRSADigitalSignature {
+pub trait RSADigitalSignature {
     fn digital_signature_rsa(
         rsa_key_size: u32,
         data_to_sign: Vec<u8>,
-    ) -> CASRSADigitalSignatureResult;
+    ) -> RSADigitalSignatureResult;
     fn verify_rsa(public_key: String, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool;
 }
 
-pub trait CASED25519DigitalSignature {
-    fn digital_signature_ed25519(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult;
+pub trait ED25519DigitalSignature {
+    fn digital_signature_ed25519(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult;
     fn digital_signature_ed25519_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool;
 }

package/src/digital_signature/sha_256_ed25519.rs

@@ -0,0 +1,69 @@
+use ed25519_dalek::{Keypair, Signature, Signer, Verifier};
+use napi_derive::napi;
+use sha3::{Digest, Sha3_256};
+
+use super::cas_digital_signature_rsa::{
+    ED25519DigitalSignature, SHAED25519DalekDigitalSignatureResult,
+};
+
+pub struct SHA256ED25519DigitalSignature;
+
+impl ED25519DigitalSignature for SHA256ED25519DigitalSignature {
+    fn digital_signature_ed25519(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult {
+        let mut hasher = Sha3_256::new();
+        hasher.update(data_to_sign);
+        let sha_hasher_result = hasher.finalize();
+        let mut csprng = rand_07::rngs::OsRng {};
+        let keypair = ed25519_dalek::Keypair::generate(&mut csprng);
+
+        let signature = keypair.sign(&sha_hasher_result);
+        let signature_bytes = signature.to_bytes();
+        let public_keypair_bytes = keypair.public.to_bytes();
+        let result = SHAED25519DalekDigitalSignatureResult {
+            public_key: public_keypair_bytes.to_vec(),
+            signature: signature_bytes.to_vec(),
+        };
+        result
+    }
+
+    fn digital_signature_ed25519_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
+        let mut hasher = Sha3_256::new();
+        hasher.update(data_to_verify);
+        let sha_hasher_result = hasher.finalize();
+
+        let public_key_parsed = ed25519_dalek::PublicKey::from_bytes(&public_key).unwrap();
+        let signature_parsed = Signature::from_bytes(&signature).unwrap();
+        return public_key_parsed
+            .verify(&sha_hasher_result, &signature_parsed)
+            .is_ok();
+    }
+}
+
+#[napi]
+pub fn sha_256_ed25519_digital_signature(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult {
+    return SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign);
+}
+
+#[napi]
+pub fn sha_256_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
+    return 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: SHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    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: SHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    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_256_rsa.rs

@@ -8,15 +8,15 @@ use rsa::{
 use sha3::{Digest, Sha3_256};
 
 
-use super::cas_digital_signature_rsa::{CASRSADigitalSignatureResult, CASRSADigitalSignature};
+use super::cas_digital_signature_rsa::{RSADigitalSignatureResult, RSADigitalSignature};
 
 pub struct SHA256RSADigitalSignature;
 
-impl CASRSADigitalSignature for SHA256RSADigitalSignature {
+impl RSADigitalSignature for SHA256RSADigitalSignature {
     fn digital_signature_rsa(
         rsa_key_size: u32,
         data_to_sign: Vec<u8>,
-    ) -> CASRSADigitalSignatureResult {
+    ) -> RSADigitalSignatureResult {
         let mut hasher = Sha3_256::new();
         hasher.update(data_to_sign);
         let sha_hasher_result = hasher.finalize();
@@ -27,7 +27,7 @@ impl CASRSADigitalSignature for SHA256RSADigitalSignature {
         let mut signed_data = private_key
             .sign(Pkcs1v15Sign::new_unprefixed(), &sha_hasher_result)
             .unwrap();
-        let result = CASRSADigitalSignatureResult {
+        let result = RSADigitalSignatureResult {
             private_key: private_key
                 .to_pkcs8_pem(rsa::pkcs8::LineEnding::LF)
                 .unwrap()
@@ -63,7 +63,7 @@ impl CASRSADigitalSignature for SHA256RSADigitalSignature {
 pub fn sha_256_rsa_digital_signature(
     rsa_key_size: u32,
     data_to_sign: Vec<u8>,
-) -> CASRSADigitalSignatureResult {
+) -> RSADigitalSignatureResult {
     return SHA256RSADigitalSignature::digital_signature_rsa(rsa_key_size, data_to_sign);
 }
 
@@ -80,7 +80,7 @@ pub fn sha_256_rsa_verify_digital_signature(
 fn sha_256_rsa_digital_signature_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = SHA256RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: RSADigitalSignatureResult = SHA256RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
     let is_verified: bool = SHA256RSADigitalSignature::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
@@ -89,7 +89,7 @@ fn sha_256_rsa_digital_signature_test() {
 fn sha_256_rsa_digital_signature_fail_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = SHA256RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: RSADigitalSignatureResult = SHA256RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
     let new_data = b"NOtTheOriginalData".to_vec();
     let is_verified: bool = SHA256RSADigitalSignature::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
     assert_eq!(is_verified, false);

package/src/digital_signature/sha_512_ed25519.rs

@@ -3,15 +3,15 @@ use napi_derive::napi;
 use sha3::{Digest, Sha3_512};
 
 use super::cas_digital_signature_rsa::{
-    CASED25519DigitalSignature, CASSHAED25519DalekDigitalSignatureResult,
+    ED25519DigitalSignature, SHAED25519DalekDigitalSignatureResult,
 };
 
 pub struct SHA512ED25519DigitalSignature;
 
-impl CASED25519DigitalSignature for SHA512ED25519DigitalSignature {
+impl ED25519DigitalSignature for SHA512ED25519DigitalSignature {
     fn digital_signature_ed25519(
         data_to_sign: Vec<u8>,
-    ) -> CASSHAED25519DalekDigitalSignatureResult {
+    ) -> SHAED25519DalekDigitalSignatureResult {
         let mut hasher = Sha3_512::new();
         hasher.update(data_to_sign);
         let sha_hasher_result = hasher.finalize();
@@ -21,7 +21,7 @@ impl CASED25519DigitalSignature for SHA512ED25519DigitalSignature {
         let signature = keypair.sign(&sha_hasher_result);
         let signature_bytes = signature.to_bytes();
         let public_keypair_bytes = keypair.public.to_bytes();
-        let result = CASSHAED25519DalekDigitalSignatureResult {
+        let result = SHAED25519DalekDigitalSignatureResult {
             public_key: public_keypair_bytes.to_vec(),
             signature: signature_bytes.to_vec(),
         };
@@ -46,7 +46,7 @@ impl CASED25519DigitalSignature for SHA512ED25519DigitalSignature {
 }
 
 #[napi]
-pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
+pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult {
     return SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign);
 }
 
@@ -59,7 +59,7 @@ pub fn sha_512_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_ver
 fn sha_512_ed25519_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    let signature_result: SHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::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);
 }
@@ -68,7 +68,7 @@ fn sha_512_ed25519_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::digital_signature_ed25519(data_to_sign.clone());
+    let signature_result: SHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
     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);