react-native-aes-lite 1.0.0

package/README.md

@@ -0,0 +1,18 @@
+
+# react-native-aes-lite
+
+## Install
+
+## npm i react-native-aes-lite
+
+
+## Usage
+```js
+import { AES, generateKey } from "react-native-aes-lite";
+
+const aes = new AES();
+const key = generateKey("hex", { length: 16 });
+const encrypted = aes.encrypt("hello", key);
+const decrypted = aes.decrypt(encrypted, key);
+
+

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "react-native-aes-lite",
+  "version": "1.0.0",
+  "description": "AES encryption for React Native",
+  "main": "src/index.js",
+
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "types": "src/index.d.ts",
+  "keywords": ["aes", "encryption", "react-native"],
+  "author": "Ammachi",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3"
+  }
+}

package/src/AES.js

@@ -0,0 +1,296 @@
+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

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

package/src/index.js

@@ -0,0 +1,4 @@
+const AES = require("./AES");
+const generateKey = require("./keygen");
+
+module.exports = { AES, generateKey };

package/src/keygen.js

@@ -0,0 +1,39 @@
+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");
+  }
+
+  const bytes = new Uint8Array(length);
+
+  if (global.crypto?.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    throw new Error("Secure random generator not available");
+  }
+
+  const toHex = (buf) =>
+    Array.from(buf, (b) => b.toString(16).padStart(2, "0")).join("");
+
+  const toBase64 = (buf) => Buffer.from(buf).toString("base64");
+
+  const toReadable = (buf) => {
+    const chars =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=";
+    return Array.from(buf, (b) => chars[b % chars.length]).join("");
+  };
+
+  switch (format) {
+    case "hex":
+      return toHex(bytes);
+    case "base64":
+      return toBase64(bytes);
+    case "ascii":
+      return readable ? toReadable(bytes) : String.fromCharCode(...bytes);
+    default:
+      throw new Error("Invalid format");
+  }
+}
+
+module.exports = generateKey;