diff --git a/index.d.ts b/index.d.ts index 172c743..e51bce5 100644 --- a/index.d.ts +++ b/index.d.ts @@ -29,12 +29,14 @@ export function encryptPlaintextRsa(publicKey: string, plaintext: Array) export function decryptCiphertextRsa(privateKey: string, ciphertext: Array): Array export function signRsa(privateKey: string, hash: Array): Array export function verifyRsa(publicKey: string, hash: Array, signature: Array): boolean -export function sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array): CasrsaDigitalSignatureResult +export function sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array): RsaDigitalSignatureResult export function sha512RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array, signature: Array): boolean -export function sha256RsaDigitalSignature(rsaKeySize: number, dataToSign: Array): CasrsaDigitalSignatureResult +export function sha256RsaDigitalSignature(rsaKeySize: number, dataToSign: Array): RsaDigitalSignatureResult export function sha256RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array, signature: Array): boolean -export function sha512Ed25519DigitalSignature(dataToSign: Array): Casshaed25519DalekDigitalSignatureResult +export function sha512Ed25519DigitalSignature(dataToSign: Array): Shaed25519DalekDigitalSignatureResult export function sha512Ed25519DigitalSignatureVerify(publicKey: Array, dataToVerify: Array, signature: Array): boolean +export function sha256Ed25519DigitalSignature(dataToSign: Array): Shaed25519DalekDigitalSignatureResult +export function sha256Ed25519DigitalSignatureVerify(publicKey: Array, dataToVerify: Array, signature: Array): boolean export type x25519SecretPublicKeyResult = X25519SecretPublicKeyResult export class X25519SecretPublicKeyResult { publicKey: Array @@ -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 constructor(publicKey: string, privateKey: string, signature: Array) } -export type CASSHAED25519DalekDigitalSignatureResult = Casshaed25519DalekDigitalSignatureResult -export class Casshaed25519DalekDigitalSignatureResult { +export type SHAED25519DalekDigitalSignatureResult = Shaed25519DalekDigitalSignatureResult +export class Shaed25519DalekDigitalSignatureResult { publicKey: Array signature: Array constructor(publicKey: Array, signature: Array) diff --git a/index.node b/index.node index 55988d7..bffaf48 100644 Binary files a/index.node and b/index.node differ diff --git a/src-ts/digital-signature/digital-siganture-sha-512.ts b/src-ts/digital-signature/digital-siganture-sha-512.ts index 2faf7fd..b2e43c4 100644 --- a/src-ts/digital-signature/digital-siganture-sha-512.ts +++ b/src-ts/digital-signature/digital-siganture-sha-512.ts @@ -1,9 +1,29 @@ -import { CasrsaDigitalSignatureResult, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index"; +import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult, sha512Ed25519DigitalSignature, sha512Ed25519DigitalSignatureVerify, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index"; import { IDigitalSignature } from "./digital-signature-base"; export class DigitalSignatureSHA512Wrapper implements IDigitalSignature { - createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult { + createED25519(dataToSign: number[]): SHAED25519DalekDigitalSignatureResult { + if (dataToSign?.length === 0) { + throw new Error("Must provide allocated data to sign"); + } + return sha512Ed25519DigitalSignature(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 sha512Ed25519DigitalSignatureVerify(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."); } diff --git a/src-ts/digital-signature/digital-signature-base.ts b/src-ts/digital-signature/digital-signature-base.ts index 15d87b0..034744f 100644 --- a/src-ts/digital-signature/digital-signature-base.ts +++ b/src-ts/digital-signature/digital-signature-base.ts @@ -1,6 +1,8 @@ -import { CASRSADigitalSignatureResult } from "../../index"; +import { RSADigitalSignatureResult, SHAED25519DalekDigitalSignatureResult } from "../../index"; export interface IDigitalSignature { - createRsa(rsa_key_size: number, data_to_sign: Array): CASRSADigitalSignatureResult; + createRsa(rsa_key_size: number, data_to_sign: Array): RSADigitalSignatureResult; verifyRSa(public_key: string, data_to_verify: Array, signature: Array): boolean; + createED25519(dataToSign: Array): SHAED25519DalekDigitalSignatureResult; + verifyED25519(publicKey: Array, dataToVerify: Array, signature: Array): boolean; } \ No newline at end of file diff --git a/src-ts/digital-signature/digital-signaturte-sha-256.ts b/src-ts/digital-signature/digital-signaturte-sha-256.ts index 6c02d6c..3d9e48b 100644 --- a/src-ts/digital-signature/digital-signaturte-sha-256.ts +++ b/src-ts/digital-signature/digital-signaturte-sha-256.ts @@ -1,9 +1,29 @@ -import { CasrsaDigitalSignatureResult, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature } from "../../index"; +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[]): CasrsaDigitalSignatureResult { + 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."); } diff --git a/src-ts/digital-signature/index.ts b/src-ts/digital-signature/index.ts index 900104d..456f2eb 100644 --- a/src-ts/digital-signature/index.ts +++ b/src-ts/digital-signature/index.ts @@ -1,4 +1,11 @@ -export enum DigitalSignatureType { - SHA512 = 1, - SHA256 = 2 -} \ No newline at end of file +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 +}; diff --git a/src-ts/index.ts b/src-ts/index.ts index d04347d..1263453 100644 --- a/src-ts/index.ts +++ b/src-ts/index.ts @@ -14,6 +14,12 @@ import { AESRSAHybridInitializer, HybridEncryptionWrapper, } from "./hybrid/index"; +import { + DigitalSignatureFactory, + DigitalSignatureSHA256Wrapper, + DigitalSignatureSHA512Wrapper, + DigitalSignatureType, +} from "./digital-signature"; export { AesRsaHybridEncryptResult, @@ -31,4 +37,8 @@ export { ScryptWrapper, SHAWrapper, X25519Wrapper, + DigitalSignatureFactory, + DigitalSignatureSHA256Wrapper, + DigitalSignatureSHA512Wrapper, + DigitalSignatureType, }; diff --git a/src/digital_signature/cas_digital_signature_rsa.rs b/src/digital_signature/cas_digital_signature_rsa.rs index 031ac23..22b945f 100644 --- a/src/digital_signature/cas_digital_signature_rsa.rs +++ b/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, } #[napi(constructor)] -pub struct CASSHAED25519DalekDigitalSignatureResult { +pub struct SHAED25519DalekDigitalSignatureResult { pub public_key: Vec, pub signature: Vec } -pub trait CASRSADigitalSignature { +pub trait RSADigitalSignature { fn digital_signature_rsa( rsa_key_size: u32, data_to_sign: Vec, - ) -> CASRSADigitalSignatureResult; + ) -> RSADigitalSignatureResult; fn verify_rsa(public_key: String, data_to_verify: Vec, signature: Vec) -> bool; } -pub trait CASED25519DigitalSignature { - fn digital_signature_ed25519(data_to_sign: Vec) -> CASSHAED25519DalekDigitalSignatureResult; +pub trait ED25519DigitalSignature { + fn digital_signature_ed25519(data_to_sign: Vec) -> SHAED25519DalekDigitalSignatureResult; fn digital_signature_ed25519_verify(public_key: Vec, data_to_verify: Vec, signature: Vec) -> bool; } \ No newline at end of file diff --git a/src/digital_signature/sha_256_ed25519.rs b/src/digital_signature/sha_256_ed25519.rs new file mode 100644 index 0000000..29cd4c3 --- /dev/null +++ b/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) -> 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, data_to_verify: Vec, signature: Vec) -> 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) -> SHAED25519DalekDigitalSignatureResult { + return SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign); +} + +#[napi] +pub fn sha_256_ed25519_digital_signature_verify(public_key: Vec, data_to_verify: Vec, signature: Vec) -> 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); +} \ No newline at end of file diff --git a/src/digital_signature/sha_256_rsa.rs b/src/digital_signature/sha_256_rsa.rs index 1d519fd..1a1e710 100644 --- a/src/digital_signature/sha_256_rsa.rs +++ b/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, - ) -> 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, -) -> 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); diff --git a/src/digital_signature/sha_512_ed25519.rs b/src/digital_signature/sha_512_ed25519.rs index 978e95c..22352d3 100644 --- a/src/digital_signature/sha_512_ed25519.rs +++ b/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, - ) -> 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) -> CASSHAED25519DalekDigitalSignatureResult { +pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec) -> SHAED25519DalekDigitalSignatureResult { return SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign); } @@ -59,7 +59,7 @@ pub fn sha_512_ed25519_digital_signature_verify(public_key: Vec, 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); diff --git a/src/digital_signature/sha_512_rsa.rs b/src/digital_signature/sha_512_rsa.rs index 014efe0..fa79518 100644 --- a/src/digital_signature/sha_512_rsa.rs +++ b/src/digital_signature/sha_512_rsa.rs @@ -6,14 +6,14 @@ use rsa::{ Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey, }; use sha3::{Digest, Sha3_512}; -use super::cas_digital_signature_rsa::{CASRSADigitalSignatureResult, CASRSADigitalSignature}; +use super::cas_digital_signature_rsa::{RSADigitalSignatureResult, RSADigitalSignature}; pub struct SHA512RSADigitalSignature; -impl CASRSADigitalSignature for SHA512RSADigitalSignature { +impl RSADigitalSignature for SHA512RSADigitalSignature { fn digital_signature_rsa( rsa_key_size: u32, data_to_sign: Vec, - ) -> CASRSADigitalSignatureResult { + ) -> RSADigitalSignatureResult { let mut hasher = Sha3_512::new(); hasher.update(data_to_sign); let sha_hasher_result = hasher.finalize(); @@ -24,7 +24,7 @@ impl CASRSADigitalSignature for SHA512RSADigitalSignature { 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() @@ -60,7 +60,7 @@ impl CASRSADigitalSignature for SHA512RSADigitalSignature { pub fn sha_512_rsa_digital_signature( rsa_key_size: u32, data_to_sign: Vec, -) -> CASRSADigitalSignatureResult { +) -> RSADigitalSignatureResult { return SHA512RSADigitalSignature::digital_signature_rsa(rsa_key_size, data_to_sign); } @@ -77,7 +77,7 @@ pub fn sha_512_rsa_verify_digital_signature( fn sha_512_rsa_digital_signature_test() { let key_size: u32 = 1024; let data_to_sign = b"GetTheseBytes".to_vec(); - let signature_result: CASRSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone()); + let signature_result: RSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone()); let is_verified: bool = SHA512RSADigitalSignature::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature); assert_eq!(is_verified, true); } @@ -86,7 +86,7 @@ fn sha_512_rsa_digital_signature_test() { fn sha_512_rsa_digital_signature_fail_test() { let key_size: u32 = 1024; let data_to_sign = b"GetTheseBytes".to_vec(); - let signature_result: CASRSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone()); + let signature_result: RSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone()); let new_data = b"NOtTheOriginalData".to_vec(); let is_verified: bool = SHA512RSADigitalSignature::verify_rsa(signature_result.public_key, new_data, signature_result.signature); assert_eq!(is_verified, false); diff --git a/src/lib.rs b/src/lib.rs index 3dbf544..c0241a0 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -31,4 +31,5 @@ mod digital_signature { pub mod sha_512_rsa; pub mod sha_256_rsa; pub mod sha_512_ed25519; + pub mod sha_256_ed25519; } diff --git a/test-ts/digital-signature.test.spec.ts b/test-ts/digital-signature.test.spec.ts index 60e0939..ebee53c 100644 --- a/test-ts/digital-signature.test.spec.ts +++ b/test-ts/digital-signature.test.spec.ts @@ -1,6 +1,6 @@ import { assert } from "chai"; import { DigitalSignatureFactory, DigitalSignatureType } from "../src-ts/digital-signature/digital-signature-factory"; -import { CASRSADigitalSignatureResult } from "../index"; +import { RSADigitalSignatureResult } from "../index"; describe("Digital Signature", () => { it("SHA 512 RSA pass", () => { @@ -8,7 +8,7 @@ describe("Digital Signature", () => { const tohashed: string = "This is my array to encrypt"; const encoder = new TextEncoder(); const tohashBytes: Array = Array.from(encoder.encode(tohashed)); - const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes); + const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes); const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature); assert.equal(verify, true); }); @@ -20,7 +20,7 @@ describe("Digital Signature", () => { const encoder = new TextEncoder(); const tohashBytes: Array = Array.from(encoder.encode(tohashed)); const badBytes: Array = Array.from(encoder.encode(notOriginal)); - const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes); + const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes); const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature); assert.equal(verify, false); }); @@ -30,7 +30,7 @@ describe("Digital Signature", () => { const tohashed: string = "This is my array to encrypt"; const encoder = new TextEncoder(); const tohashBytes: Array = Array.from(encoder.encode(tohashed)); - const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes); + const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes); const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature); assert.equal(verify, true); }); @@ -42,8 +42,52 @@ describe("Digital Signature", () => { const encoder = new TextEncoder(); const tohashBytes: Array = Array.from(encoder.encode(tohashed)); const badBytes: Array = Array.from(encoder.encode(notOriginal)); - const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes); + const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes); const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.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 = 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 = Array.from(encoder.encode(toHash)); + const badBytes: Array = Array.from(encoder.encode(notOriginal)); + const dsResult = shaDsWrapper.createED25519(toHashBytes); + const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, badBytes, dsResult.signature); + assert.equal(verify, false); + }); + + 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 = 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 = Array.from(encoder.encode(toHash)); + const badBytes: Array = Array.from(encoder.encode(notOriginal)); + const dsResult = shaDsWrapper.createED25519(toHashBytes); + const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, badBytes, dsResult.signature); + assert.equal(verify, false); + }); }); \ No newline at end of file