chomot 1.0.0

package/dist/config/crypto.d.ts

@@ -0,0 +1,7 @@
+interface CryptoConfig {
+    privateKeyFilePath: string;
+    publicKeyFilePath: string;
+}
+export declare function setCryptoConfig(newConfig: CryptoConfig): void;
+export declare function getCryptoConfig(): CryptoConfig;
+export {};

package/dist/config/crypto.js

@@ -0,0 +1,13 @@
+// Step 1: Make it `let` to allow reassignment
+let cryptoConfig = {
+    privateKeyFilePath: "./crypto/private.crypto",
+    publicKeyFilePath: "./crypto/public.crypto",
+};
+// Step 2: Function to update it
+export function setCryptoConfig(newConfig) {
+    cryptoConfig = { ...newConfig };
+}
+// Optional: Function to get it
+export function getCryptoConfig() {
+    return cryptoConfig;
+}

package/dist/config/index.d.ts

@@ -0,0 +1 @@
+export * from "./crypto";

package/dist/config/index.js

@@ -0,0 +1 @@
+export * from "./crypto";

package/dist/crypto/crypto.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/crypto/crypto.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { decrypt, encrypt } from "../crypto/operations";
+describe("encryption", () => {
+    it("can encrypt symetrically", async () => {
+        const plain = "secret";
+        const encryptedText = await encrypt(plain);
+        const decryptedText = await decrypt(encryptedText);
+        expect(plain).not.toEqual(encryptedText);
+        expect(decryptedText).toEqual(plain);
+    });
+    it("can encrypt asymetrically", async () => {
+        const plain = "secret";
+        const encryptedText = await encrypt(plain, "Asymetric");
+        const decryptedText = await decrypt(encryptedText, "Asymetric");
+        expect(plain).not.toEqual(encryptedText);
+        expect(decryptedText).toEqual(plain);
+    });
+});

package/dist/crypto/genkey.d.ts

@@ -0,0 +1,10 @@
+export declare const appCryptography: {
+    publicKey?: Uint8Array;
+    privateKey?: Uint8Array;
+    symetricKey?: Uint8Array;
+    salt?: Uint8Array;
+};
+export declare function getPrivateKey(): Promise<Uint8Array<ArrayBufferLike>>;
+export declare function getPublicKey(): Promise<Uint8Array<ArrayBufferLike>>;
+export declare function getSymetricKey(): Promise<Uint8Array<ArrayBufferLike>>;
+export default function run(): Promise<void>;

package/dist/crypto/genkey.js

@@ -0,0 +1,59 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getCryptoConfig } from "../config/crypto";
+import { getSodium } from "../crypto/sodium";
+const cryptoConfig = getCryptoConfig();
+export const appCryptography = {};
+function loadCryptoKey(path) {
+    if (!existsSync(path)) {
+        throw new Error("Encryption key is not found");
+    }
+    return readFileSync(path);
+}
+export async function getPrivateKey() {
+    if (!appCryptography.privateKey) {
+        appCryptography.privateKey = loadCryptoKey(cryptoConfig.privateKeyFilePath);
+    }
+    return appCryptography.privateKey;
+}
+export async function getPublicKey() {
+    if (!appCryptography.publicKey) {
+        appCryptography.publicKey = loadCryptoKey(cryptoConfig.publicKeyFilePath);
+    }
+    return appCryptography.publicKey;
+}
+async function getSalt() {
+    if (!appCryptography.salt) {
+        const sodium = await getSodium();
+        appCryptography.salt = sodium.randombytes_buf(sodium.crypto_pwhash_SALTBYTES);
+    }
+    return appCryptography.salt;
+}
+export async function getSymetricKey() {
+    if (!appCryptography.symetricKey) {
+        const sodium = await getSodium();
+        const privateKey = await getPrivateKey();
+        const salt = await getSalt();
+        appCryptography.symetricKey = sodium.crypto_pwhash(sodium.crypto_secretbox_KEYBYTES, // 32 byte output
+        privateKey, salt, sodium.crypto_pwhash_OPSLIMIT_MODERATE, sodium.crypto_pwhash_MEMLIMIT_MODERATE, sodium.crypto_pwhash_ALG_DEFAULT);
+    }
+    return appCryptography.symetricKey;
+}
+export default async function run() {
+    const sodium = await getSodium();
+    const { publicKey, privateKey } = sodium.crypto_box_keypair();
+    const rootDir = process.cwd();
+    const certDir = join(rootDir, "crypto");
+    // Buat folder 'crypto' jika belum ada
+    mkdirSync(certDir, { recursive: true });
+    const privateKeyPath = join(certDir, "private.crypto");
+    const publicKeyPath = join(certDir, "public.crypto");
+    writeFileSync(privateKeyPath, privateKey);
+    writeFileSync(publicKeyPath, publicKey);
+    console.log("✅ Key pair berhasil dibuat di folder /cert:");
+    console.log(`🔐 ${privateKeyPath}`);
+    console.log(`🔓 ${publicKeyPath}`);
+}
+if (import.meta.main) {
+    run();
+}

package/dist/crypto/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./genkey";
+export * from "./operations";

package/dist/crypto/index.js

@@ -0,0 +1,2 @@
+export * from "./genkey";
+export * from "./operations";

package/dist/crypto/operations.d.ts

@@ -0,0 +1,3 @@
+export type EncryptionType = "Symetric" | "Asymetric";
+export declare function decrypt(encrypted: string, type?: EncryptionType): Promise<string>;
+export declare function encrypt(plain: string, type?: EncryptionType): Promise<string>;

package/dist/crypto/operations.js

@@ -0,0 +1,41 @@
+import { getSodium } from "../crypto/sodium";
+import { getPrivateKey, getPublicKey, getSymetricKey } from "./genkey";
+export async function decrypt(encrypted, type = "Symetric") {
+    const sodium = await getSodium();
+    const publicKey = await getPublicKey();
+    const privateKey = await getPrivateKey();
+    if (type === "Asymetric") {
+        return sodium.to_string(sodium.crypto_box_seal_open(sodium.from_base64(encrypted, sodium.base64_variants.ORIGINAL), publicKey, privateKey));
+    }
+    else {
+        const symetricKey = await getSymetricKey();
+        if (!symetricKey)
+            throw new Error("Key not initialized, call deriveKeyFromPassword() first");
+        const combined = sodium.from_base64(encrypted);
+        const nonce = combined.slice(0, sodium.crypto_secretbox_NONCEBYTES);
+        const ciphertext = combined.slice(sodium.crypto_secretbox_NONCEBYTES);
+        const decrypted = sodium.crypto_secretbox_open_easy(ciphertext, nonce, symetricKey);
+        if (!decrypted)
+            throw new Error("Decryption failed");
+        return sodium.to_string(decrypted);
+    }
+}
+export async function encrypt(plain, type = "Symetric") {
+    const sodium = await getSodium();
+    const publicKey = await getPublicKey();
+    if (type === "Asymetric") {
+        // transmit base64
+        return sodium.to_base64(sodium.crypto_box_seal(sodium.from_string(plain), publicKey), sodium.base64_variants.ORIGINAL);
+    }
+    else {
+        const symetricKey = await getSymetricKey();
+        if (!symetricKey)
+            throw new Error("Key not initialized, call deriveKeyFromPassword() first");
+        const nonce = sodium.randombytes_buf(sodium.crypto_secretbox_NONCEBYTES);
+        const ciphertext = sodium.crypto_secretbox_easy(sodium.from_string(plain), nonce, symetricKey);
+        const combined = new Uint8Array(nonce.length + ciphertext.length);
+        combined.set(nonce);
+        combined.set(ciphertext, nonce.length);
+        return sodium.to_base64(combined);
+    }
+}

package/dist/crypto/sodium.d.ts

@@ -0,0 +1,2 @@
+import _sodium from "libsodium-wrappers-sumo";
+export declare function getSodium(): Promise<typeof _sodium>;

package/dist/crypto/sodium.js

@@ -0,0 +1,9 @@
+import _sodium from "libsodium-wrappers-sumo";
+let sodium;
+export async function getSodium() {
+    if (!sodium) {
+        await _sodium.ready;
+        sodium = _sodium;
+    }
+    return sodium;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "chomot",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "vitest"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [],
+  "author": "smwgn1331",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/libsodium-wrappers-sumo": "^0.7.8",
+    "@types/node": "^24.7.2",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "libsodium-wrappers-sumo": "^0.7.15"
+  }
+}