cas-typescript-sdk 1.0.19 → 1.0.21

package/docs/EXAMPLES.md

@@ -11,6 +11,105 @@ 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

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

@@ -1,6 +1,26 @@
 import { AesKeyFromX25519SharedSecret } from "../../index";
+/**
+ * @description A wrapper class that contains methods to construct keys, nonces, and methods to encrypt and decrypt with AES-128-GCM and AES-256-GCM
+ *
+ * @example
+ * ```ts
+ * const nonce = aesWrapper.generateAESNonce();
+const key = aesWrapper.aes128Key();
+const textEncoder = new TextEncoder();
+const array = Array.from(textEncoder.encode("Hello World"));
+const encrypted = aesWrapper.aes128Encrypt(key, nonce, array);
+ * ```
+ */
 export declare class AESWrapper {
+    /**
+     * @description Generates a 128 bit AES key
+     * @returns returns a 128 bit AES key
+     */
     aes128Key(): Array<number>;
+    /**
+     * @description Generates a 256 bit AES key
+     * @returns returns a 256 bit AES key
+     */
     aes256Key(): Array<number>;
     generateAESNonce(): Array<number>;
     aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;

package/lib/symmetric/aes-wrapper.js

@@ -2,10 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AESWrapper = void 0;
 const index_1 = require("../../index");
+/**
+ * @description A wrapper class that contains methods to construct keys, nonces, and methods to encrypt and decrypt with AES-128-GCM and AES-256-GCM
+ *
+ * @example
+ * ```ts
+ * const nonce = aesWrapper.generateAESNonce();
+const key = aesWrapper.aes128Key();
+const textEncoder = new TextEncoder();
+const array = Array.from(textEncoder.encode("Hello World"));
+const encrypted = aesWrapper.aes128Encrypt(key, nonce, array);
+ * ```
+ */
 class AESWrapper {
+    /**
+     * @description Generates a 128 bit AES key
+     * @returns returns a 128 bit AES key
+     */
     aes128Key() {
         return (0, index_1.aes128Key)();
     }
+    /**
+     * @description Generates a 256 bit AES key
+     * @returns returns a 256 bit AES key
+     */
     aes256Key() {
         return (0, index_1.aes256Key)();
     }

package/package.json

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

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

@@ -11,11 +11,32 @@ import {
   aesNonce,
 } from "../../index";
 
+/**
+ * @description A wrapper class that contains methods to construct keys, nonces, and methods to encrypt and decrypt with AES-128-GCM and AES-256-GCM
+ * 
+ * @example
+ * ```ts
+ * const nonce = aesWrapper.generateAESNonce();
+const key = aesWrapper.aes128Key();
+const textEncoder = new TextEncoder();
+const array = Array.from(textEncoder.encode("Hello World"));
+const encrypted = aesWrapper.aes128Encrypt(key, nonce, array);
+ * ```
+ */
 export class AESWrapper {
+
+    /**
+     * @description Generates a 128 bit AES key
+     * @returns returns a 128 bit AES key
+     */
     public aes128Key(): Array<number> {
         return aes128Key();
     }
 
+    /**
+     * @description Generates a 256 bit AES key
+     * @returns returns a 256 bit AES key
+     */
     public aes256Key(): Array<number> {
         return aes256Key();
     }