react-native-aes-lite 1.0.3 → 1.0.5

package/package.json

@@ -1,32 +1,21 @@
 {
   "name": "react-native-aes-lite",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "AES encryption for React Native + Expo Web",
   "main": "dist/index.js",
   "module": "dist/index.js",
-  "react-native": "src/index.js",
-  "browser": "dist/index.js",
-
+  "react-native": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
-
   "keywords": [
     "aes",
     "encryption",
     "react-native",
     "expo",
-    "web",
-    "key",
-    "crypto",
-    "aes128",
-    "aes256"
+    "web"
   ],
   "author": "Ammachi",
-  "license": "MIT",
-  
-  "scripts": {
-    "build": "mkdir -p dist && cp src/*.js dist/"
-  }
+  "license": "MIT"
 }

package/src/AES.js

@@ -1,296 +0,0 @@
-class AES {
-  constructor() {
-    this.SBOX = [
-      0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
-      0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
-      0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,
-      0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
-      0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
-      0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
-      0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed,
-      0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
-      0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
-      0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
-      0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec,
-      0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
-      0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
-      0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
-      0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,
-      0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
-      0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
-      0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
-      0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,
-      0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
-      0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
-      0xb0, 0x54, 0xbb, 0x16,
-    ];
-    this.INV_SBOX = new Array(256);
-    for (let i = 0; i < 256; i++) this.INV_SBOX[this.SBOX[i]] = i;
-    this.RCON = [
-      0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36,
-    ];
-  }
-
-  xtime(x) {
-    x &= 0xff;
-    return ((x << 1) ^ (((x >> 7) & 1) * 0x1b)) & 0xff;
-  }
-
-  parseKey(keyString) {
-    if (keyString.length === 32) {
-      // Assume hex
-      const bytes = [];
-      for (let i = 0; i < 32; i += 2) {
-        bytes.push(parseInt(keyString.substr(i, 2), 16));
-      }
-      if (bytes.some(isNaN)) throw new Error("Invalid hex key");
-      return bytes;
-    } else if (keyString.length === 16) {
-      // ASCII
-      return keyString.split("").map((c) => c.charCodeAt(0));
-    } else {
-      throw new Error("Key must be 16 ASCII chars or 32 hex chars");
-    }
-  }
-
-  keyExpansion(key) {
-    const w = new Array(44); // 4 * (10 + 1)
-    for (let i = 0; i < 4; i++) {
-      w[i] = [key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]];
-    }
-    for (let i = 4; i < 44; i++) {
-      let temp = w[i - 1].slice();
-      if (i % 4 === 0) {
-        // RotWord
-        const t = temp[0];
-        temp[0] = temp[1];
-        temp[1] = temp[2];
-        temp[2] = temp[3];
-        temp[3] = t;
-        // SubWord
-        for (let j = 0; j < 4; j++) {
-          temp[j] = this.SBOX[temp[j]];
-        }
-        // Rcon
-        temp[0] ^= this.RCON[i / 4];
-      }
-      w[i] = [
-        w[i - 4][0] ^ temp[0],
-        w[i - 4][1] ^ temp[1],
-        w[i - 4][2] ^ temp[2],
-        w[i - 4][3] ^ temp[3],
-      ];
-    }
-    return w;
-  }
-
-  cipher(input, w) {
-    let state = [
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-    ];
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) state[r][c] = input[r + 4 * c];
-
-    state = this.addRoundKey(state, w, 0);
-
-    for (let round = 1; round < 10; round++) {
-      state = this.subBytes(state);
-      state = this.shiftRows(state);
-      state = this.mixColumns(state);
-      state = this.addRoundKey(state, w, round);
-    }
-
-    state = this.subBytes(state);
-    state = this.shiftRows(state);
-    state = this.addRoundKey(state, w, 10);
-
-    const output = new Array(16);
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) output[r + 4 * c] = state[r][c];
-    return output;
-  }
-
-  invCipher(input, w) {
-    let state = [
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-    ];
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) state[r][c] = input[r + 4 * c];
-
-    state = this.addRoundKey(state, w, 10);
-
-    for (let round = 9; round >= 1; round--) {
-      state = this.invShiftRows(state);
-      state = this.invSubBytes(state);
-      state = this.addRoundKey(state, w, round);
-      state = this.invMixColumns(state);
-    }
-
-    state = this.invShiftRows(state);
-    state = this.invSubBytes(state);
-    state = this.addRoundKey(state, w, 0);
-
-    const output = new Array(16);
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) output[r + 4 * c] = state[r][c];
-    return output;
-  }
-
-  subBytes(s) {
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) s[r][c] = this.SBOX[s[r][c]];
-    return s;
-  }
-
-  invSubBytes(s) {
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) s[r][c] = this.INV_SBOX[s[r][c]];
-    return s;
-  }
-
-  shiftRows(s) {
-    const t = s.map((r) => [...r]);
-    s[1][0] = t[1][1];
-    s[1][1] = t[1][2];
-    s[1][2] = t[1][3];
-    s[1][3] = t[1][0];
-    s[2][0] = t[2][2];
-    s[2][1] = t[2][3];
-    s[2][2] = t[2][0];
-    s[2][3] = t[2][1];
-    s[3][0] = t[3][3];
-    s[3][1] = t[3][0];
-    s[3][2] = t[3][1];
-    s[3][3] = t[3][2];
-    return s;
-  }
-
-  invShiftRows(s) {
-    const t = s.map((r) => [...r]);
-    s[1][0] = t[1][3];
-    s[1][1] = t[1][0];
-    s[1][2] = t[1][1];
-    s[1][3] = t[1][2];
-    s[2][0] = t[2][2];
-    s[2][1] = t[2][3];
-    s[2][2] = t[2][0];
-    s[2][3] = t[2][1];
-    s[3][0] = t[3][1];
-    s[3][1] = t[3][2];
-    s[3][2] = t[3][3];
-    s[3][3] = t[3][0];
-    return s;
-  }
-
-  mixColumns(s) {
-    for (let c = 0; c < 4; c++) {
-      const a0 = s[0][c],
-        a1 = s[1][c],
-        a2 = s[2][c],
-        a3 = s[3][c];
-      s[0][c] = this.xtime(a0) ^ this.xtime(a1) ^ a1 ^ a2 ^ a3;
-      s[1][c] = a0 ^ this.xtime(a1) ^ this.xtime(a2) ^ a2 ^ a3;
-      s[2][c] = a0 ^ a1 ^ this.xtime(a2) ^ this.xtime(a3) ^ a3;
-      s[3][c] = this.xtime(a0) ^ a0 ^ a1 ^ a2 ^ this.xtime(a3);
-    }
-    return s;
-  }
-
-  invMixColumns(s) {
-    for (let c = 0; c < 4; c++) {
-      const a = [s[0][c], s[1][c], s[2][c], s[3][c]];
-      const xtime2 = (v) => this.xtime(v);
-      const xtime4 = (v) => this.xtime(xtime2(v));
-      const xtime8 = (v) => this.xtime(xtime4(v));
-      const mul = (v, b) => {
-        let res = 0;
-        if (b & 1) res ^= v;
-        if (b & 2) res ^= xtime2(v);
-        if (b & 4) res ^= xtime4(v);
-        if (b & 8) res ^= xtime8(v);
-        return res & 0xff;
-      };
-      s[0][c] =
-        mul(a[0], 0x0e) ^ mul(a[1], 0x0b) ^ mul(a[2], 0x0d) ^ mul(a[3], 0x09);
-      s[1][c] =
-        mul(a[0], 0x09) ^ mul(a[1], 0x0e) ^ mul(a[2], 0x0b) ^ mul(a[3], 0x0d);
-      s[2][c] =
-        mul(a[0], 0x0d) ^ mul(a[1], 0x09) ^ mul(a[2], 0x0e) ^ mul(a[3], 0x0b);
-      s[3][c] =
-        mul(a[0], 0x0b) ^ mul(a[1], 0x0d) ^ mul(a[2], 0x09) ^ mul(a[3], 0x0e);
-    }
-    return s;
-  }
-
-  addRoundKey(s, w, round) {
-    for (let c = 0; c < 4; c++) {
-      const word = w[round * 4 + c];
-      s[0][c] ^= word[0];
-      s[1][c] ^= word[1];
-      s[2][c] ^= word[2];
-      s[3][c] ^= word[3];
-    }
-    return s;
-  }
-
-  pkcs7Pad(bytes) {
-    const padding = 16 - (bytes.length % 16);
-    const result = bytes.slice();
-    for (let i = 0; i < padding; i++) result.push(padding);
-    return result;
-  }
-
-  pkcs7Unpad(bytes) {
-    const padding = bytes[bytes.length - 1];
-    if (padding < 1 || padding > 16 || bytes.length < padding) {
-      throw new Error("Invalid PKCS#7 padding");
-    }
-    for (let i = 1; i <= padding; i++) {
-      if (bytes[bytes.length - i] !== padding) {
-        throw new Error("Corrupted PKCS#7 padding");
-      }
-    }
-    return bytes.slice(0, -padding);
-  }
-
-  encrypt(text, keyString) {
-    const key = this.parseKey(keyString);
-    const w = this.keyExpansion(key);
-    let inputBytes = text.split("").map((c) => c.charCodeAt(0));
-    inputBytes = this.pkcs7Pad(inputBytes);
-    let outputBytes = [];
-    for (let i = 0; i < inputBytes.length; i += 16) {
-      outputBytes.push(...this.cipher(inputBytes.slice(i, i + 16), w));
-    }
-    return outputBytes.map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-
-  decrypt(hexString, keyString) {
-    if (hexString.length % 2 !== 0)
-      throw new Error("Hex string must have even length");
-    const key = this.parseKey(keyString);
-    const w = this.keyExpansion(key);
-    let inputBytes = [];
-    for (let i = 0; i < hexString.length; i += 2) {
-      inputBytes.push(parseInt(hexString.substr(i, 2), 16));
-    }
-    if (inputBytes.length % 16 !== 0)
-      throw new Error("Ciphertext length must be multiple of 16");
-    let decryptedBytes = [];
-    for (let i = 0; i < inputBytes.length; i += 16) {
-      decryptedBytes.push(...this.invCipher(inputBytes.slice(i, i + 16), w));
-    }
-    decryptedBytes = this.pkcs7Unpad(decryptedBytes);
-    return String.fromCharCode.apply(null, decryptedBytes);
-  }
-}
-export default AES;
-
-// Export singleton
-// export default new AES();

package/src/index.d.ts

@@ -1,4 +0,0 @@
-export class AES {
-  encrypt(text: string, key: string): string;
-  decrypt(hex: string, key: string): string;
-}

package/src/index.js

@@ -1,4 +0,0 @@
-import AES from "./AES";
-import generateKey from "./keygen";
-
-export { AES, generateKey };

package/src/keygen.js

@@ -1,49 +0,0 @@
-function generateKey(format = "hex", options = {}) {
-  const { length = 16, readable = false } = options;
-
-  if (![16, 24, 32].includes(length)) {
-    throw new Error("Key length must be 16, 24, or 32 bytes (AES-128/192/256)");
-  }
-
-  const bytes = new Uint8Array(length);
-
-  // RN + Expo + Node secure RNG
-  if (globalThis.crypto?.getRandomValues) {
-    crypto.getRandomValues(bytes);
-  } else {
-    // very old RN fallback using Math.random (not cryptographically strong)
-    for (let i = 0; i < length; i++) {
-      bytes[i] = Math.floor(Math.random() * 256);
-    }
-  }
-
-  const toHex = (buf) =>
-    Array.from(buf, (b) => b.toString(16).padStart(2, "0")).join("");
-
-  const toBase64 = (buf) => {
-    if (typeof Buffer !== "undefined") {
-      return Buffer.from(buf).toString("base64");
-    }
-    return btoa(String.fromCharCode(...buf));
-  };
-
-  const toReadable = (buf) => {
-    const chars =
-      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=";
-    return Array.from(buf, (b) => chars[b % chars.length]).join("");
-  };
-
-  switch (format.toLowerCase()) {
-    case "hex":
-      return toHex(bytes);
-    case "base64":
-      return toBase64(bytes);
-    case "ascii":
-    case "string":
-      return readable ? toReadable(bytes) : String.fromCharCode(...bytes);
-    default:
-      throw new Error("Format must be 'hex', 'base64', or 'ascii'");
-  }
-}
-
-export default generateKey;