cas-typescript-sdk 1.0.46 → 1.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -8,9 +8,9 @@
     "test": "npm run rust:test && npm run build && npm run node:test",
     "node:test": "mocha -r ts-node/register ./test-ts/**/*.test.spec.ts --timeout 20000 --recursive",
     "rust:test": "cargo test --release",
-    "build": "npm run build:rust && rimraf lib && tsc",
-    "build:rust": "napi build --release",
-    "postinstall": "npm run build"
+    "build:ts": "rimraf lib && tsc",
+    "build:rust": "napi build --release --platform",
+    "build": "npm run build:rust && npm run build:ts"
   },
   "repository": {
     "type": "git",
@@ -23,6 +23,13 @@
     "url": "https://github.com/Cryptographic-API-Services/cas-typescript-sdk/issues"
   },
   "homepage": "https://github.com/Cryptographic-API-Services/cas-typescript-sdk#readme",
+  "files": [
+    "lib",
+    "index.js",
+    "index.d.ts",
+    "*.node",
+    "README.md"
+  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/.github/workflows/main-pr-linux.yml

@@ -1,28 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Linux Build / Test
-
-on:
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [24.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v3
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm ci
-    - run: npm test

package/.github/workflows/main-pr-windows.yml

@@ -1,28 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Windows Build / Test 
-
-on:
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-
-    runs-on: windows-latest
-
-    strategy:
-      matrix:
-        node-version: [24.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v3
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm ci
-    - run: npm test

package/.github/workflows/main-publish.yml

@@ -1,32 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ "main" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [24.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v3
-      with:
-        node-version: ${{ matrix.node-version }}
-        registry-url: 'https://registry.npmjs.org'
-        cache: 'npm'
-    - run: npm ci
-    - run: npm test
-    - run: npm publish
-      env:
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "cas-typescript-sdk-napi"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-path = "src/lib.rs"
-crate-type = ["cdylib"]
-
-[dependencies]
-napi = "3"
-napi-derive = "3"
-csbindgen = "1.9.3"
-cas-lib = { version = "=0.2.65" }
-zeroize = "1.8.1"
-zeroizing-alloc = "0.1.0"
-
-[build-dependencies]
-napi-build = "1"

package/build.rs

@@ -1,5 +0,0 @@
-extern crate napi_build;
-
-fn main() {
-    napi_build::setup();
-}

package/docs/EXAMPLES.md

@@ -1,138 +0,0 @@
-### Symmetric
-- AES 256
-```typescript
-const aesWrapper: AESWrapper = new AESWrapper();
-const aesKey = aesWrapper.aes128Key();
-const aesNonce = aesWrapper.aesNonce();
-const toEncrypt: string = "This is my array to encrypt";
-const encoder = new TextEncoder();
-const tohashBytes: Array<number> = Array.from(encoder.encode(toEncrypt));
-const ciphertext = aesWrapper.aes128Encrypt(aesKey, aesNonce, tohashBytes);
-const plaintxt = aesWrapper.aes128Decrypt(aesKey, aesNonce, ciphertext);
-```
-
-### Asymmetric 
--RSA
-```typescript
-const rsaWrapper: RSAWrapper = new RSAWrapper();
-const keys: RsaKeyPairResult = rsaWrapper.generateKeys(4096);
-const tohashed: string = "This is my array to encrypt";
-const encoder = new TextEncoder();
-const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-const ciphertext = rsaWrapper.encrypt(keys.publicKey, tohashBytes);
-const plaintext = rsaWrapper.decrypt(keys.privateKey, ciphertext);
-```
-
-
-### Digital Signature
--ED25519 SHA
-```typescript
-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);
-```
-
--RSA SHA
-```typescript
-const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
-const tohashed: 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(tohashed));
-const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
-const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature);
-```
-
-
-### Hashers 
--SHA3 512
-```typescript
-const wrapper = new SHAWrapper();
-const tohashed: string = "This is my array to hash";
-const encoder = new TextEncoder();
-const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-const hashed = wrapper.hash512(tohashBytes);
-```
-
--SHA3 256
-```typescript
-const wrapper = new SHAWrapper();
-const tohashed: string = "This is my array to hash";
-const encoder = new TextEncoder();
-const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-const hashed = wrapper.hash256(tohashBytes);
-```
-
-### Hybrid Encryption
--AES/RSA Encryption
-```typescript
-const hybridWrapper = new HybridEncryptionWrapper();
-let initalizer = new AESRSAHybridInitializer(128, 4096);
-const tohashed: string = "This is my encrypt text for rsa hybrid";
-const encoder = new TextEncoder();
-const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
-let result: AesRsaHybridEncryptResult = hybridWrapper.encrypt(toEncrypt, initalizer);
-let plaintext: Array<number> = hybridWrapper.decrypt(initalizer.rsaKeyPair.privateKey, result);
-```
-
-### Key Exchange 
--X25519 
-```typescript
-const wrapper = new X25519Wrapper();
-const alice = wrapper.generateSecretAndPublicKey();
-const bob = wrapper.generateSecretAndPublicKey();
-
-const alice_shared_secret = wrapper.generateSharedSecret(
-      alice.secretKey,
-      bob.publicKey,
-    );
-const bob_shared_secret = wrapper.generateSharedSecret(
-      bob.secretKey,
-      alice.publicKey,
-    );
-
-var result = areEqual(alice_shared_secret, bob_shared_secret);
-```
-
-### Sponges
--Ascon 128
-```typescript
-const wrapper: AsconWrapper = new AsconWrapper();
-const key: Array<number> = wrapper.ascon128Key();
-const nonce: Array<number> = wrapper.ascon128Nonce();
-const tohashed: string = "This is my array to encrypt";
-const encoder = new TextEncoder();
-const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-const ciphertext = wrapper.ascon128Encrypt(key, nonce, tohashBytes);
-const plaintext = wrapper.ascon128Decrypt(key, nonce, ciphertext);
-```
-
-### Passwords
-- BCrypt
-```typescript
-const hasher: BCryptWrapper = new BCryptWrapper();
-const password: string = "ThisOneBadPassword!@";
-const hashedPassword: string = hasher.hashPassword(password);
-```
-
-- SCrypt
-```typescript
-const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
-      PasswordHasherType.Scrypt,
-    );
-const password: string = "ScryptRocks";
-const hashed: string = hasher.hashPassword(password);
-```
-
-- Argon2
-```typescript
-    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
-      PasswordHasherType.Argon2,
-    );
-    const password: string = "ScryptRocks";
-    const hashed: string = hasher.hashPassword(password);
-```

package/src/asymmetric/cas_ed25519.rs

@@ -1,35 +0,0 @@
-
-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/asymmetric/cas_rsa.rs

@@ -1,32 +0,0 @@
-use cas_lib::asymmetric::{cas_rsa::CASRSA, types::{CASRSAEncryption, RSAKeyPairResult}};
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct CASRSAKeyPairResult {
-    pub private_key: String,
-    pub public_key: String,
-}
-
-impl From<RSAKeyPairResult> for CASRSAKeyPairResult {
-    fn from(result: RSAKeyPairResult) -> Self {
-        CASRSAKeyPairResult {
-            private_key: result.private_key,
-            public_key: result.public_key,
-        }
-    }
-}
-
-#[napi]
-pub fn generate_rsa_keys(key_size: u32) -> CASRSAKeyPairResult {
-    return CASRSA::generate_rsa_keys(key_size as usize).into();
-}
-
-#[napi]
-pub fn sign_rsa(private_key: String, hash: Vec<u8>) -> Vec<u8> {
-    return CASRSA::sign(private_key, hash);
-}
-
-#[napi]
-pub fn verify_rsa(public_key: String, hash: Vec<u8>, signature: Vec<u8>) -> bool {
-    return CASRSA::verify(public_key, hash, signature);
-}

package/src/digital_signature/sha_256_rsa.rs

@@ -1,40 +0,0 @@
-use cas_lib::digital_signature::{cas_digital_signature_rsa::RSADigitalSignature, sha_256_rsa::SHA256RSADigitalSignature};
-use napi_derive::napi;
-
-use super::types::CASRSADigitalSignatureResult;
-
-#[napi]
-pub fn sha_256_rsa_digital_signature(
-    rsa_key_size: u32,
-    data_to_sign: Vec<u8>,
-) -> CASRSADigitalSignatureResult {
-    return <SHA256RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa(rsa_key_size, data_to_sign).into();
-}
-
-#[napi]
-pub fn sha_256_rsa_verify_digital_signature(
-    public_key: String,
-    data_to_verify: Vec<u8>,
-    signature: Vec<u8>,
-) -> bool {
-    return <SHA256RSADigitalSignature as RSADigitalSignature>::verify_rsa(public_key, data_to_verify, signature);
-}
-
-#[test]
-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 as RSADigitalSignature>::digital_signature_rsa(key_size, data_to_sign.clone()).into();
-    let is_verified: bool = SHA256RSADigitalSignature::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
-    assert_eq!(is_verified, true);
-}
-
-#[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 as RSADigitalSignature>::digital_signature_rsa(key_size, data_to_sign.clone()).into();
-    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_rsa.rs

@@ -1,40 +0,0 @@
-use cas_lib::digital_signature::{cas_digital_signature_rsa::RSADigitalSignature, sha_512_rsa::SHA512RSADigitalSignature};
-use napi_derive::napi;
-
-use super::types::CASRSADigitalSignatureResult;
-
-#[napi]
-pub fn sha_512_rsa_digital_signature(
-    rsa_key_size: u32,
-    data_to_sign: Vec<u8>,
-) -> CASRSADigitalSignatureResult {
-    return <SHA512RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa(rsa_key_size, data_to_sign).into();
-}
-
-#[napi]
-pub fn sha_512_rsa_verify_digital_signature(
-    public_key: String,
-    data_to_verify: Vec<u8>,
-    signature: Vec<u8>,
-) -> bool {
-    return <SHA512RSADigitalSignature as RSADigitalSignature>::verify_rsa(public_key, data_to_verify, signature);
-}
-
-#[test]
-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()).into();
-    let is_verified: bool = <SHA512RSADigitalSignature as RSADigitalSignature>::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
-    assert_eq!(is_verified, true);
-}
-
-#[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()).into();
-    let new_data = b"NOtTheOriginalData".to_vec();
-    let is_verified: bool = <SHA512RSADigitalSignature as RSADigitalSignature>::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
-    assert_eq!(is_verified, false);
-}

package/src/digital_signature/types.rs

@@ -1,34 +0,0 @@
-use cas_lib::digital_signature::cas_digital_signature_rsa::{RSADigitalSignatureResult, SHAED25519DalekDigitalSignatureResult};
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct CASSHAED25519DalekDigitalSignatureResult {
-    pub public_key: Vec<u8>,
-    pub signature: Vec<u8>
-}
-
-impl From<SHAED25519DalekDigitalSignatureResult> for CASSHAED25519DalekDigitalSignatureResult {
-    fn from(value: SHAED25519DalekDigitalSignatureResult) -> Self {
-        CASSHAED25519DalekDigitalSignatureResult {
-            public_key: value.public_key.to_vec(),
-            signature: value.signature.to_vec()
-        }
-    }
-}
-
-#[napi(constructor)]
-pub struct CASRSADigitalSignatureResult {
-    pub public_key: String,
-    pub private_key: String,
-    pub signature: Vec<u8>,
-}
-
-impl From<RSADigitalSignatureResult> for CASRSADigitalSignatureResult {
-    fn from(value: RSADigitalSignatureResult) -> Self {
-        CASRSADigitalSignatureResult {
-            public_key: value.public_key,
-            private_key: value.private_key,
-            signature: value.signature
-        }
-    }
-}

package/src/hashers/blake2.rs

@@ -1,60 +0,0 @@
-use cas_lib::hashers::{blake2::CASBlake2, cas_hasher::CASHasher};
-use napi_derive::napi;
-
-#[napi]
-pub fn blake2_sha_512(data_to_hash: Vec<u8>) -> Vec<u8> {
-    return CASBlake2::hash_512(data_to_hash);
-}
-
-#[napi]
-pub fn blake2_sha_512_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-    return CASBlake2::verify_512(data_to_hash, data_to_verify);
-}
-
-#[napi]
-pub fn blake2_sha_256(data_to_hash: Vec<u8>) -> Vec<u8> {
-    return CASBlake2::hash_256(data_to_hash);
-}
-
-#[napi]
-pub fn blake2_sha_256_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-    return CASBlake2::verify_256(data_to_hash, data_to_verify);
-}
-
-#[test]
-pub fn blake2_sha_512_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = blake2_sha_512(data_to_hash.clone());
-    assert_ne!(true, hashed_data.eq(&data_to_hash));
-}
-
-#[test]
-pub fn blake2_sha_512_verify_fail_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = blake2_sha_512(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
-    assert_ne!(true, blake2_sha_512_verify(data_to_hash, data_to_verify));
-}
-
-#[test]
-pub fn blake2_sha_256_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = blake2_sha_256(data_to_hash.clone());
-    assert_ne!(true, hashed_data.eq(&data_to_hash));
-}
-
-#[test]
-pub fn blake2_sha_256_verify_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = blake2_sha_256(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
-    assert_ne!(true, blake2_sha_256_verify(data_to_hash, data_to_verify));
-}
-
-#[test]
-pub fn blake2_sha_256_verify_fail_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = blake2_sha_256(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
-    assert_ne!(true, blake2_sha_256_verify(data_to_hash, data_to_verify));
-}

package/src/hashers/sha.rs

@@ -1,68 +0,0 @@
-use cas_lib::hashers::{cas_hasher::CASHasher, sha::CASSHA};
-use napi_derive::napi;
-
-#[napi]
-pub fn sha_512(data_to_hash: Vec<u8>) -> Vec<u8> {
-    return <CASSHA as CASHasher>::hash_512(data_to_hash);
-}
-
-#[napi]
-pub fn sha_512_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-    return <CASSHA as CASHasher>::verify_512(data_to_hash, data_to_verify);
-}
-
-#[napi]
-pub fn sha_256(data_to_hash: Vec<u8>) -> Vec<u8> {
-    return <CASSHA as CASHasher>::hash_256(data_to_hash);
-}
-
-#[napi]
-pub fn sha_256_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-    return <CASSHA as CASHasher>::verify_256(data_to_hash, data_to_verify);
-}
-
-#[test]
-pub fn sha_512_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = sha_512(data_to_hash.clone());
-    assert_ne!(true, hashed_data.eq(&data_to_hash));
-}
-
-#[test]
-pub fn sha_512_verify_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = sha_512(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
-    assert_ne!(true, sha_512_verify(data_to_hash, data_to_verify));
-}
-
-#[test]
-pub fn sha_512_verify_fail_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = sha_512(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
-    assert_ne!(true, sha_512_verify(data_to_hash, data_to_verify));
-}
-
-#[test]
-pub fn sha_256_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = sha_256(data_to_hash.clone());
-    assert_ne!(true, hashed_data.eq(&data_to_hash));
-}
-
-#[test]
-pub fn sha_256_verify_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = sha_256(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
-    assert_ne!(true, sha_256_verify(data_to_hash, data_to_verify));
-}
-
-#[test]
-pub fn sha_256_verify_fail_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = sha_256(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
-    assert_ne!(true, sha_256_verify(data_to_hash, data_to_verify));
-}

package/src/hybrid/hpke.rs

@@ -1,63 +0,0 @@
-use crate::hybrid::types::{HpkeEncryptResult, HpkeKeyResult};
-use cas_lib::hybrid::{cas_hybrid::CASHybrid, hpke::CASHPKE};
-use napi_derive::napi;
-
-#[napi]
-pub fn hpke_generate_keypair() -> HpkeKeyResult {
-    let (secret_key, public_key, info_str) = <CASHPKE as CASHybrid>::generate_key_pair();
-    HpkeKeyResult {
-        public_key: public_key,
-        secret_key: secret_key,
-        info_str: info_str
-    }
-}
-
-#[napi]
-pub fn generate_info_str() -> Vec<u8> {
-    return <CASHPKE as CASHybrid>::generate_info_str();
-}
-
-#[napi]
-pub fn hpke_encrypt(
-    plaintext: Vec<u8>,
-    public_key: Vec<u8>,
-    info_str: Vec<u8>,
-) -> HpkeEncryptResult {
-    let encrypt_result: (Vec<u8>, Vec<u8>, Vec<u8>) =
-        <CASHPKE as CASHybrid>::encrypt(plaintext, public_key, info_str);
-    return HpkeEncryptResult {
-        tag: encrypt_result.2,
-        ciphertext: encrypt_result.1,
-        encapsulated_key: encrypt_result.0,
-    }
-}
-
-#[napi]
-pub fn hpke_decrypt(
-    ciphertext: Vec<u8>,
-    private_key: Vec<u8>,
-    encapped_key: Vec<u8>,
-    tag: Vec<u8>,
-    info_str: Vec<u8>,
-) -> Vec<u8> {
-    return <CASHPKE as CASHybrid>::decrypt(ciphertext, private_key, encapped_key, tag, info_str);
-}
-
-#[test]
-pub fn hpke_encrypt_decrypt_test() {
-    let hpke_keypair = hpke_generate_keypair();
-    let plaintext = "This is a secret message".as_bytes().to_vec();
-    let encrypt_result = hpke_encrypt(
-        plaintext.clone(),
-        hpke_keypair.public_key,
-        hpke_keypair.info_str.clone(),
-    );
-    let decrypted_plaintext = hpke_decrypt(
-        encrypt_result.ciphertext,
-        hpke_keypair.secret_key,
-        encrypt_result.encapsulated_key,
-        encrypt_result.tag,
-        hpke_keypair.info_str,
-    );
-    assert_eq!(plaintext, decrypted_plaintext);
-}