kripoint 1.0.0

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "kripoint",
+  "version": "1.0.0",
+  "description": "AES-256-CBC axios interceptor + .NET middleware pair for encrypted HTTP payloads",
+  "type": "module",
+  "main": "./src/index.js",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "types": "./src/index.d.ts"
+    }
+  },
+  "files": ["src/"],
+  "peerDependencies": {
+    "axios": ">=1.0.0"
+  },
+  "keywords": ["kripoint", "axios", "interceptor", "encryption", "aes", "security", "enterprise"],
+  "license": "MIT",
+  "engines": { "node": ">=18.0.0" }
+}

package/src/axiosInterceptor.js

@@ -0,0 +1,79 @@
+import { encrypt, decrypt } from "./crypto.js";
+
+export function attachKriPointInterceptor(axiosInstance, options = {}) {
+  const {
+    key,
+    decryptResponse = false,
+    excludePaths = [],
+    onEncryptError = null,
+    onDecryptError = null,
+  } = options;
+
+  if (!key) {
+    throw new Error("[KriPoint] attachKriPointInterceptor: `key` option is required.");
+  }
+
+  const requestId = axiosInstance.interceptors.request.use(
+    async (config) => {
+      const method = (config.method || "get").toLowerCase();
+      const hasBody = ["post", "put", "patch", "delete"].includes(method);
+      const isExcluded = excludePaths.some((p) => (config.url || "").includes(p));
+
+      if (!hasBody || isExcluded || config.data === undefined || config.data === null) {
+        return config;
+      }
+
+      try {
+        const value =
+          typeof config.data === "string" ? JSON.parse(config.data) : config.data;
+
+        const encrypted = await encrypt(value, key);
+
+        config.data = encrypted;
+        config.headers["Content-Type"] = "application/json";
+        config.headers["X-KriPoint"] = "1";
+      } catch (err) {
+        if (onEncryptError) {
+          onEncryptError(err);
+        } else {
+          throw err;
+        }
+      }
+
+      return config;
+    },
+    (error) => Promise.reject(error)
+  );
+
+  const responseId = axiosInstance.interceptors.response.use(
+    async (response) => {
+      if (!decryptResponse) return response;
+
+      const data = response.data;
+      if (data && typeof data.payload === "string" && typeof data.iv === "string") {
+        try {
+          response.data = await decrypt(data.payload, data.iv, key);
+        } catch (err) {
+          if (onDecryptError) onDecryptError(err);
+        }
+      }
+
+      return response;
+    },
+    (error) => Promise.reject(error)
+  );
+
+  return {
+    detach() {
+      axiosInstance.interceptors.request.eject(requestId);
+      axiosInstance.interceptors.response.eject(responseId);
+    },
+  };
+}
+
+export async function createKriPointAxios(axiosConfig = {}, interceptorOptions = {}) {
+  const axios = (await import("axios")).default;
+  const instance = axios.create(axiosConfig);
+  attachKriPointInterceptor(instance, interceptorOptions);
+  return instance;
+}

package/src/crypto.js

@@ -0,0 +1,55 @@
+const ALGO = "AES-CBC";
+
+function toBase64(buffer) {
+  return btoa(String.fromCharCode(...new Uint8Array(buffer)));
+}
+
+function fromBase64(b64) {
+  return Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+}
+
+async function importKey(base64Key) {
+  return crypto.subtle.importKey(
+    "raw",
+    fromBase64(base64Key),
+    { name: ALGO },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+
+export async function encrypt(value, base64Key) {
+  const key = await importKey(base64Key);
+  const iv = crypto.getRandomValues(new Uint8Array(16));
+  const plain = new TextEncoder().encode(JSON.stringify(value));
+  const cipher = await crypto.subtle.encrypt({ name: ALGO, iv }, key, plain);
+  return { payload: toBase64(cipher), iv: toBase64(iv) };
+}
+
+export async function decrypt(payload, iv, base64Key) {
+  const key = await importKey(base64Key);
+  const plain = await crypto.subtle.decrypt(
+    { name: ALGO, iv: fromBase64(iv) },
+    key,
+    fromBase64(payload)
+  );
+  return JSON.parse(new TextDecoder().decode(plain));
+}
+
+export async function generateBase64Key() {
+  const key = await crypto.subtle.generateKey(
+    { name: ALGO, length: 256 },
+    true,
+    ["encrypt", "decrypt"]
+  );
+  const raw = await crypto.subtle.exportKey("raw", key);
+  return toBase64(raw);
+}
+
+export function isValidKey(base64Key) {
+  try {
+    return fromBase64(base64Key).length === 32;
+  } catch {
+    return false;
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,33 @@
+import type { AxiosInstance, CreateAxiosDefaults } from "axios";
+
+export interface KriPointPayload {
+  payload: string;
+  iv: string;
+}
+
+export interface KriPointInterceptorOptions {
+  key: string;
+  decryptResponse?: boolean;
+  excludePaths?: string[];
+  onEncryptError?: (error: Error) => void;
+  onDecryptError?: (error: Error) => void;
+}
+
+export interface KriPointDetachHandle {
+  detach(): void;
+}
+
+export declare function attachKriPointInterceptor(
+  axiosInstance: AxiosInstance,
+  options: KriPointInterceptorOptions
+): KriPointDetachHandle;
+
+export declare function createKriPointAxios(
+  axiosConfig?: CreateAxiosDefaults,
+  interceptorOptions?: KriPointInterceptorOptions
+): Promise<AxiosInstance>;
+
+export declare function encrypt(value: unknown, base64Key: string): Promise<KriPointPayload>;
+export declare function decrypt(payload: string, iv: string, base64Key: string): Promise<unknown>;
+export declare function generateBase64Key(): Promise<string>;
+export declare function isValidKey(base64Key: string): boolean;

package/src/index.js

@@ -0,0 +1,2 @@
+export { attachKriPointInterceptor, createKriPointAxios } from "./axiosInterceptor.js";
+export { encrypt, decrypt, generateBase64Key, isValidKey } from "./crypto.js";