react-native-aes-lite 1.0.1-0.rc → 1.0.1-1.rc

package/dist/AES.js

@@ -2,7 +2,7 @@
 import { randomBytes } from "./randomBytes";
 
 /* ============================================================
-   UTF-8 Encoder / Decoder (Hermes-safe)
+   UTF-8 Encode / Decode (Hermes-safe)
 ============================================================ */
 function utf8Encode(str) {
   const out = [];
@@ -25,9 +25,8 @@ function utf8Decode(bytes) {
   let s = "";
   for (let i = 0; i < bytes.length; ) {
     const c = bytes[i++];
-    if (c < 0x80) {
-      s += String.fromCharCode(c);
-    } else if (c < 0xe0) {
+    if (c < 0x80) s += String.fromCharCode(c);
+    else if (c < 0xe0) {
       const c2 = bytes[i++];
       s += String.fromCharCode(((c & 0x1f) << 6) | (c2 & 0x3f));
     } else {
@@ -85,7 +84,7 @@ class AES {
   }
 
   /* ============================================================
-       UTILITY FUNCTIONS
+       UTILITY
   ============================================================= */
   hexToBytes(h) {
     return Uint8Array.from(h.match(/../g).map((x) => parseInt(x, 16)));
@@ -94,25 +93,40 @@ class AES {
     return [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
   }
 
-  parseKey(hex) {
-    const b = this.hexToBytes(hex);
-    if (![16, 24, 32].includes(b.length))
-      throw new Error("Invalid AES key length");
-    return [...b];
-  }
+  /* ============================================================
+       parseKey — supports ASCII + HEX
+  ============================================================= */
+  parseKey(key) {
+    // HEX
+    if (/^[0-9a-fA-F]+$/.test(key)) {
+      if ([32, 48, 64].includes(key.length)) {
+        return key.match(/../g).map((b) => parseInt(b, 16));
+      }
+      throw new Error("Hex key must be 32, 48, or 64 chars");
+    }
 
-  pkcs7Pad(arr) {
-    const pad = 16 - (arr.length % 16);
-    return [...arr, ...Array(pad).fill(pad)];
+    // ASCII
+    if ([16, 24, 32].includes(key.length)) {
+      return key.split("").map((c) => c.charCodeAt(0));
+    }
+
+    throw new Error("Key must be 32/48/64 hex OR 16/24/32 ASCII");
   }
 
-  pkcs7Unpad(arr) {
-    const pad = arr[arr.length - 1];
-    return arr.slice(0, -pad);
+  /* ============================================================
+       PKCS7
+  ============================================================= */
+  pkcs7Pad(a) {
+    const pad = 16 - (a.length % 16);
+    return [...a, ...Array(pad).fill(pad)];
+  }
+  pkcs7Unpad(a) {
+    const pad = a[a.length - 1];
+    return a.slice(0, -pad);
   }
 
   /* ============================================================
-       AES KEY EXPANSION
+       KEY EXPANSION
   ============================================================= */
   keyExpansion(key) {
     const Nk = key.length / 4;
@@ -124,24 +138,24 @@ class AES {
     }
 
     for (let i = Nk; i < w.length; i++) {
-      let t = [...w[i - 1]];
+      let temp = [...w[i - 1]];
 
       if (i % Nk === 0) {
-        t.push(t.shift());
-        t = t.map((b) => this.SBOX[b]);
-        t[0] ^= this.RCON[i / Nk];
+        temp.push(temp.shift());
+        temp = temp.map((x) => this.SBOX[x]);
+        temp[0] ^= this.RCON[i / Nk];
       } else if (Nk > 6 && i % Nk === 4) {
-        t = t.map((b) => this.SBOX[b]);
+        temp = temp.map((x) => this.SBOX[x]);
       }
 
-      w[i] = w[i - Nk].map((b, j) => b ^ t[j]);
+      w[i] = w[i - Nk].map((b, j) => b ^ temp[j]);
     }
 
     return { w, Nr };
   }
 
   /* ============================================================
-       AES ROUND FUNCTIONS
+       ROUND FUNCTIONS
   ============================================================= */
   subBytes(s) {
     for (let r = 0; r < 4; r++)
@@ -186,15 +200,15 @@ class AES {
 
   invMixColumns(s) {
     const mul = (a, b) => {
-      let res = 0;
+      let r = 0;
       for (let i = 0; i < 8; i++) {
-        if (b & 1) res ^= a;
+        if (b & 1) r ^= a;
         const hi = a & 0x80;
         a = (a << 1) & 0xff;
         if (hi) a ^= 0x1b;
         b >>= 1;
       }
-      return res;
+      return r;
     };
 
     for (let c = 0; c < 4; c++) {
@@ -219,7 +233,7 @@ class AES {
   }
 
   /* ============================================================
-       CIPHER (ENCRYPT ONE BLOCK)
+       CIPHER
   ============================================================= */
   cipher(input, w, Nr) {
     let s = [[], [], [], []];
@@ -229,11 +243,11 @@ class AES {
 
     s = this.addRoundKey(s, w, 0);
 
-    for (let round = 1; round < Nr; round++) {
+    for (let r = 1; r < Nr; r++) {
       s = this.subBytes(s);
       s = this.shiftRows(s);
       s = this.mixColumns(s);
-      s = this.addRoundKey(s, w, round);
+      s = this.addRoundKey(s, w, r);
     }
 
     s = this.subBytes(s);
@@ -241,28 +255,21 @@ class AES {
     s = this.addRoundKey(s, w, Nr);
 
     const out = new Array(16);
-    for (let i = 0; i < 16; i++) {
-      out[i] = s[i % 4][(i / 4) | 0];
-    }
-    return out;
+    for (let i = 0; i < 16; i++) out[i] = s[i % 4][(i / 4) | 0];
+    return Uint8Array.from(out);
   }
 
-  /* ============================================================
-       INVERSE CIPHER (DECRYPT ONE BLOCK)
-  ============================================================= */
   invCipher(input, w, Nr) {
     let s = [[], [], [], []];
 
-    for (let i = 0; i < 16; i++) {
-      s[i % 4][(i / 4) | 0] = input[i];
-    }
+    for (let i = 0; i < 16; i++) s[i % 4][(i / 4) | 0] = input[i];
 
     s = this.addRoundKey(s, w, Nr);
 
-    for (let round = Nr - 1; round >= 1; round--) {
+    for (let r = Nr - 1; r >= 1; r--) {
       s = this.invShiftRows(s);
       s = this.invSubBytes(s);
-      s = this.addRoundKey(s, w, round);
+      s = this.addRoundKey(s, w, r);
       s = this.invMixColumns(s);
     }
 
@@ -271,10 +278,8 @@ class AES {
     s = this.addRoundKey(s, w, 0);
 
     const out = new Array(16);
-    for (let i = 0; i < 16; i++) {
-      out[i] = s[i % 4][(i / 4) | 0];
-    }
-    return out;
+    for (let i = 0; i < 16; i++) out[i] = s[i % 4][(i / 4) | 0];
+    return Uint8Array.from(out);
   }
 
   /* ============================================================
@@ -290,36 +295,37 @@ class AES {
     const padded = this.pkcs7Pad(pt);
 
     let out = [];
-    let prev = iv;
+    let prev = Uint8Array.from(iv);
 
     for (let i = 0; i < padded.length; i += 16) {
       const block = padded.slice(i, i + 16);
-      const xored = block.map((b, j) => b ^ prev[j]);
-      const enc = this.cipher(xored, w, Nr);
+      const x = block.map((b, j) => b ^ prev[j]);
+      const enc = this.cipher(x, w, Nr);
       out.push(...enc);
-      prev = enc;
+      prev = Uint8Array.from(enc);
     }
 
-    return this.bytesToHex(iv) + ":" + this.bytesToHex(out);
+    return this.bytesToHex(iv) + ":" + this.bytesToHex(Uint8Array.from(out));
   }
 
   decrypt(input, keyHex) {
     const [ivHex, dataHex] = input.split(":");
+
     const key = this.parseKey(keyHex);
     const { w, Nr } = this.keyExpansion(key);
 
-    const iv = [...this.hexToBytes(ivHex)];
-    const data = [...this.hexToBytes(dataHex)];
+    const iv = this.hexToBytes(ivHex);
+    const data = this.hexToBytes(dataHex);
 
     let out = [];
-    let prev = iv;
+    let prev = Uint8Array.from(iv);
 
     for (let i = 0; i < data.length; i += 16) {
       const block = data.slice(i, i + 16);
       const dec = this.invCipher(block, w, Nr);
       const x = dec.map((b, j) => b ^ prev[j]);
       out.push(...x);
-      prev = block;
+      prev = Uint8Array.from(block);
     }
 
     return this.decode(this.pkcs7Unpad(out));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-aes-lite",
-  "version": "1.0.10.rc",
+  "version": "1.0.11.rc",
   "description": "AES encryption for React Native + Expo Web",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",