refactor

Author: SSbit01

README.md

@@ -14,12 +14,12 @@ AES-GCM is extremely fast on modern CPUs, which have dedicated hardware accelera
 Using `bun`:
 
 ```shell
-bun add singlecrypt
+bun add singlecrypt-text
 ```
 
 ## Methods
 
-#### `createSymmetricCryptoKey`
+#### `createSymmetricKeyWithText`
 
 Creates a symmetric `CryptoKey` object to be used in the following methods. This method also converts your value key to a SHA-256 hash. It takes two parameters:
 
@@ -30,24 +30,24 @@ Returns a `Promise<CryptoKey>` containing a SHA-256 hash used to encrypt and dec
 
 A `TypeError` may be thrown if there are problems with the string key.
 
-### `encryptSymmetrically`
+### `encryptSymmetricallyText`
 
 Encrypts a value with a symmetric `CryptoKey` previously generated. It takes three parameters:
 
 1. A string value to be encrypted.
-2. The symmetric key generated with `createSymmetricCryptoKey`.
+2. The symmetric key generated with `createSymmetricKeyWithText`.
 3. A `TextEncoder` instance, if you want to reuse it (optional).
 
 Returns a `Promise<string>` containing the encrypted value.
 
 A `DOMException` may be thrown if the key is invalid or if the operation failed (e.g., AES-GCM plaintext longer than 2^39−256 bytes).
 
-### `decryptSymmetrically`
+### `decryptSymmetricallyText`
 
 Decrypts a value with a symmetric `CryptoKey` previously generated. It takes three parameters:
 
 1. A string value to be decrypted.
-2. The symmetric key generated with `createSymmetricCryptoKey`.
+2. The symmetric key generated with `createSymmetricKeyWithText`.
 3. A `TextDecoder` instance, if you want to reuse it (optional).
 
 Returns a `Promise<string>` containing the decrypted value.
@@ -66,26 +66,26 @@ Let's say you have a user ID in a server and you want the server to encrypt and
 
 ```typescript
 import {
-  createSymmetricCryptoKey,
-  encryptSymmetrically,
-  decryptSymmetrically
+  createSymmetricKeyWithText,
+  encryptSymmetricallyText,
+  decryptSymmetricallyText
 } from "singlecrypt";
 
 
-const userCryptoKey = await createSymmetricCryptoKey(
+const userCryptoKey = await createSymmetricKeyWithText(
   process.env.KEY_USER
 );
 
 
 export async function encryptUserId(value: string) {
-  return await encryptSymmetrically(
+  return await encryptSymmetricallyText(
     value,
     userCryptoKey
   );
 }
 
 export async function decryptUserId(value: string) {
-  return await decryptSymmetrically(
+  return await decryptSymmetricallyText(
     value,
     userCryptoKey
   );
@@ -96,31 +96,31 @@ Or you can reuse `TextEncoder` and `TextDecoder` instances for slightly better p
 
 ```typescript
 import {
-  createSymmetricCryptoKey,
-  encryptSymmetrically,
-  decryptSymmetrically
+  createSymmetricKeyWithText,
+  encryptSymmetricallyText,
+  decryptSymmetricallyText
 } from "singlecrypt";
 
 
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
 
-const userCryptoKey = await createSymmetricCryptoKey(
+const userCryptoKey = await createSymmetricKeyWithText(
   process.env.KEY_USER,
   textEncoder
 );
 
 
 export async function encryptUserId(value: string) {
-  return await encryptSymmetrically(
+  return await encryptSymmetricallyText(
     value,
     userCryptoKey,
     textEncoder
   );
 }
 
 export async function decryptUserId(value: string) {
-  return await decryptSymmetrically(
+  return await decryptSymmetricallyText(
     value,
     userCryptoKey,
     textDecoder

index.d.ts

@@ -1,29 +1,29 @@
 /**
  * Before encrypting and decrypting values, a symmetric `CryptoKey` must be created.
+ * This method also converts your value key to a SHA-256 hash.
  *
- * @param   {string}             value         - String key to be hashed. A 32-byte random string is recommended.
+ * @param   {string}             data          - String key to be hashed. A 32-byte high entropy string is recommended.
  * @param   {TextEncoder}        [textEncoder] - If you have an instance of a `TextEncoder`, you can reuse it.
- * @returns {Promise<CryptoKey>} A `CryptoKey` used to encrypt and decrypt strings.
+ * @returns {Promise<CryptoKey>} A `CryptoKey` containing a SHA-256 hash used to encrypt and decrypt strings.
  * @throws  {TypeError}          Thrown if `value` is invalid.
  */
-export function createSymmetricCryptoKey(value: string, textEncoder?: TextEncoder): Promise<CryptoKey>;
+export function createSymmetricKeyWithText(data: string, textEncoder?: TextEncoder): Promise<CryptoKey>;
 /**
- * Encrypts a value with a `CryptoKey` previously generated with `createSymmetricCryptoKey`.
+ * Encrypts a value with a `CryptoKey` previously generated with `createSymmetricKeyWithText`.
  *
- * @param   {string}          value         - Value to be encrypted.
- * @param   {CryptoKey}       key           - The symmetric key generated with `createSymmetricCryptoKey`.
- * @param   {TextEncoder}     [textEncoder] - If you have an instance of a `TextEncoder`, you can reuse it.
+ * @param   {string}          value - String value to be encrypted.
+ * @param   {CryptoKey}       key   - Symmetric key generated with `createSymmetricKeyWithText`.
  * @returns {Promise<string>} The value encrypted and encoded as a Base64 string.
  * @throws  {DOMException}    Raised when:
  * - The provided key is not valid.
  * - The operation failed (e.g., AES-GCM plaintext longer than 2^39−256 bytes).
  */
-export function encryptSymmetrically(value: string, key: CryptoKey, textEncoder?: TextEncoder): Promise<string>;
+export function encryptSymmetricallyText(value: string, key: CryptoKey, textEncoder?: TextEncoder): Promise<string>;
 /**
- * Decrypts a value with a `CryptoKey` previously generated with `createSymmetricCryptoKey`.
+ * Decrypts a value with a `CryptoKey` previously generated with `createSymmetricKeyWithText`.
  *
  * @param   {string}          value         - Encrypted value to be decrypted.
- * @param   {CryptoKey}       key           - The symmetric key used to encrypt the value.
+ * @param   {CryptoKey}       key           - Symmetric key used to encrypt the value.
  * @param   {TextDecoder}     [textDecoder] - If you have an instance of a `TextDecoder`, you can reuse it.
  * @returns {Promise<string>} The value decrypted.
  * @throws  {TypeError}       Thrown if `value` is not a string.
@@ -32,4 +32,4 @@ export function encryptSymmetrically(value: string, key: CryptoKey, textEncoder?
  * - The provided key is not valid.
  * - The operation failed.
  */
-export function decryptSymmetrically(value: string, key: CryptoKey, textDecoder?: TextDecoder): Promise<string>;
+export function decryptSymmetricallyText(value: string, key: CryptoKey, textDecoder?: TextDecoder): Promise<string>;

index.js

@@ -9,20 +9,20 @@ const keyUsages = ["encrypt", "decrypt"]
  * Before encrypting and decrypting values, a symmetric `CryptoKey` must be created.
  * This method also converts your value key to a SHA-256 hash.
  * 
- * @param   {string}             value         - String key to be hashed. A 32-byte random string is recommended.
+ * @param   {string}             data          - String key to be hashed. A 32-byte high entropy string is recommended.
  * @param   {TextEncoder}        [textEncoder] - If you have an instance of a `TextEncoder`, you can reuse it.
  * @returns {Promise<CryptoKey>} A `CryptoKey` containing a SHA-256 hash used to encrypt and decrypt strings.
  * @throws  {TypeError}          Thrown if `value` is invalid.
  */
-export async function createSymmetricCryptoKey(
-  value,
+export async function createSymmetricKeyWithText(
+  data,
   textEncoder = new TextEncoder()
 ) {
 
   return (
     await crypto.subtle.importKey(
       "raw",
-      await crypto.subtle.digest("SHA-256", textEncoder.encode(value)),
+      await crypto.subtle.digest("SHA-256", textEncoder.encode(data)),
       encryptionAlgorithm,
       false,
       keyUsages
@@ -33,17 +33,16 @@ export async function createSymmetricCryptoKey(
 
 
 /**
- * Encrypts a value with a `CryptoKey` previously generated with `createSymmetricCryptoKey`.
+ * Encrypts a value with a `CryptoKey` previously generated with `createSymmetricKeyWithText`.
  * 
- * @param   {string}          value         - Value to be encrypted.
- * @param   {CryptoKey}       key           - The symmetric key generated with `createSymmetricCryptoKey`.
- * @param   {TextEncoder}     [textEncoder] - If you have an instance of a `TextEncoder`, you can reuse it.
+ * @param   {string}          value - String value to be encrypted.
+ * @param   {CryptoKey}       key   - Symmetric key generated with `createSymmetricKeyWithText`.
  * @returns {Promise<string>} The value encrypted and encoded as a Base64 string.
  * @throws  {DOMException}    Raised when:
  * - The provided key is not valid.
  * - The operation failed (e.g., AES-GCM plaintext longer than 2^39−256 bytes).
  */
-export async function encryptSymmetrically(
+export async function encryptSymmetricallyText(
   value,
   key,
   textEncoder = new TextEncoder()
@@ -66,10 +65,10 @@ export async function encryptSymmetrically(
 
 
 /**
- * Decrypts a value with a `CryptoKey` previously generated with `createSymmetricCryptoKey`.
+ * Decrypts a value with a `CryptoKey` previously generated with `createSymmetricKeyWithText`.
  * 
  * @param   {string}          value         - Encrypted value to be decrypted.
- * @param   {CryptoKey}       key           - The symmetric key used to encrypt the value.
+ * @param   {CryptoKey}       key           - Symmetric key used to encrypt the value.
  * @param   {TextDecoder}     [textDecoder] - If you have an instance of a `TextDecoder`, you can reuse it.
  * @returns {Promise<string>} The value decrypted.
  * @throws  {TypeError}       Thrown if `value` is not a string.
@@ -78,7 +77,7 @@ export async function encryptSymmetrically(
  * - The provided key is not valid.
  * - The operation failed.
  */
-export async function decryptSymmetrically(
+export async function decryptSymmetricallyText(
   value,
   key,
   textDecoder = new TextDecoder()

index.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test"
-import { createSymmetricCryptoKey, encryptSymmetrically, decryptSymmetrically } from "."
+import { createSymmetricKeyWithText, encryptSymmetricallyText, decryptSymmetricallyText } from "."
 
 
 function randomString(length = 32) {
@@ -9,21 +9,40 @@ function randomString(length = 32) {
 
 
 test("Generate a random symmetric CryptoKey", async() => {
-  const key = await createSymmetricCryptoKey(randomString())
+  const key = await createSymmetricKeyWithText(randomString())
   expect(key).toBeDefined()
 })
 
 
 test("Encrypt a random value", async() => {
-  const key = await createSymmetricCryptoKey(randomString())
-  expect(await encryptSymmetrically(randomString(), key)).toBeString()
+  const key = await createSymmetricKeyWithText(randomString())
+  expect(await encryptSymmetricallyText(randomString(), key)).toBeString()
 })
 
 
 test("Decrypt a random value", async() => {
-  const symCryptoKey = await createSymmetricCryptoKey(randomString())
+  const symCryptoKey = await createSymmetricKeyWithText(randomString())
   const randomValue = randomString()
-  const encrypted = await encryptSymmetrically(randomValue, symCryptoKey)
-  const decrypted = await decryptSymmetrically(encrypted, symCryptoKey)
+  const encrypted = await encryptSymmetricallyText(randomValue, symCryptoKey)
+  const decrypted = await decryptSymmetricallyText(encrypted, symCryptoKey)
   expect(randomValue === decrypted).toBeTrue()
+})
+
+
+test("Decrypt a random value with two different CryptoKey objects", async() => {
+  const randomKeyString = randomString()
+  const symCryptoKey = await createSymmetricKeyWithText(randomKeyString)
+  const symCryptoKey2 = await createSymmetricKeyWithText(randomKeyString)
+  const randomValue = randomString()
+  const encrypted = await encryptSymmetricallyText(randomValue, symCryptoKey)
+  const decrypted = await decryptSymmetricallyText(encrypted, symCryptoKey2)
+  expect(randomValue === decrypted).toBeTrue()
+})
+
+test("Check if encrypting and decrypting with different CryptoKey objects returns an error", async() => {
+  const symCryptoKey = await createSymmetricKeyWithText(randomString())
+  const symCryptoKey2 = await createSymmetricKeyWithText(randomString())
+  const randomValue = randomString()
+  const encrypted = await encryptSymmetricallyText(randomValue, symCryptoKey)
+  expect(async() => await decryptSymmetricallyText(encrypted, symCryptoKey2)).toThrowError()
 })

package.json

@@ -1,11 +1,11 @@
 {
-  "name": "singlecrypt",
+  "name": "singlecrypt-text",
   "version": "1.0.0",
   "author": "Stefan Samson <ss42701@outlook.com> (https://ssbit01.github.io/)",
-  "repository": "github:SSbit01/singlecrypt",
+  "repository": "github:SSbit01/singlecrypt-text",
   "main": "index.js",
   "bugs": {
-    "url": "https://github.com/SSbit01/singlecrypt/issues"
+    "url": "https://github.com/SSbit01/singlecrypt-text/issues"
   },
   "description": "A simple, secure and fast symmetric encryption library that makes use of AES-GCM.",
   "engines": {
@@ -15,7 +15,7 @@
     "index.js",
     "index.d.ts"
   ],
-  "homepage": "https://github.com/SSbit01/singlecrypt#readme",
+  "homepage": "https://github.com/SSbit01/singlecrypt-text#readme",
   "keywords": [
     "aes",
     "browser",