codepi-package 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,38 @@
-# Temporary Holding Version
+# Code[{π*}]
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Secure encryption toolkit using AES-256-GCM.
+
+## Install
+
+```bash
+npm install -g codepi
+
+## Encrypt
+
+codepi encrypt "Hello" "1234"
+
+## Decrypt
+
+codepi decrypt "[{...}]" "1234"
+
+## Validate
+
+codepi validate "[{...}]"
+
+## Features
+
+- AES-256-GCM
+- Random nonce
+- Password authentication
+- [{...}] format
+- .Codepack[{}] validation
+- Browser encryption
+- No code execution during validation
+
+## License
+
+MIT
+
+## GitHub
+
+https://github.com/ScriptsSoftware/codepi

package/bin/codepi.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+const {encrypt}=require('../lib/encrypt');
+const {decrypt}=require('../lib/decrypt');
+const {validateCodepack}=require('../lib/codepack');
+
+const [,,cmd,...a]=process.argv;
+const VERSION='1.0.0';
+
+try{
+if(cmd==='--version'||cmd==='-v'){console.log(`Code[{π*}] v${VERSION}`);process.exit(0)}
+if(cmd==='encrypt'){
+if(!a[0]||!a[1])throw Error('Usage: codepi encrypt "message" "password"');
+console.log(encrypt(a[0],a[1]));
+}else if(cmd==='decrypt'){
+if(!a[0]||!a[1])throw Error('Usage: codepi decrypt "[{...}]" "password"');
+console.log(decrypt(a[0],a[1]));
+}else if(cmd==='validate'){
+if(!a[0])throw Error('Usage: codepi validate "[{...}]"');
+console.log(validateCodepack(a[0]));
+}else{
+console.log('Code[{π*}]');
+console.log('codepi encrypt "message" "password"');
+console.log('codepi decrypt "[{...}]" "password"');
+console.log('codepi validate "[{...}]"');
+}
+}catch(error){
+console.error('Error:',error.message);
+process.exit(1);
+}

package/lib/codepack.js

@@ -0,0 +1,36 @@
+const FORMAT = '[{...}]';
+
+function isCodepack(value) {
+    if (typeof value !== 'string') return false;
+    if (!value.startsWith('[{') || !value.endsWith('}]')) return false;
+
+    const data = value.slice(2, -2);
+
+    if (!data || !/^[A-Za-z0-9_-]+$/.test(data)) {
+        return false;
+    }
+
+    return true;
+}
+
+function validateCodepack(value) {
+    if (!isCodepack(value)) {
+        return {
+            valid: false,
+            safe: false,
+            status: 'INVALID'
+        };
+    }
+
+    return {
+        valid: true,
+        safe: true,
+        status: 'VALID'
+    };
+}
+
+module.exports = {
+    FORMAT,
+    isCodepack,
+    validateCodepack
+};

package/lib/decrypt.js

@@ -0,0 +1,67 @@
+const crypto = require('crypto');
+
+const PI = '3.14159265358979323846264338327950288419716939937510';
+const FORMAT = `π+[${PI}]{}\/`;
+
+function deriveKey(password) {
+    return crypto
+        .createHash('sha256')
+        .update(FORMAT + password, 'utf8')
+        .digest();
+}
+
+function decrypt(packet, password) {
+    if (typeof packet !== 'string') {
+        throw new TypeError('Codepack must be a string');
+    }
+
+    if (!packet.startsWith('[{') || !packet.endsWith('}]')) {
+        throw new Error('Invalid Codepack format');
+    }
+
+    if (typeof password !== 'string' || password.length === 0) {
+        throw new Error('Password is required');
+    }
+
+    const encoded = packet.slice(2, -2);
+
+    let data;
+    try {
+        data = Buffer.from(encoded, 'base64url');
+    } catch {
+        throw new Error('Invalid Codepack data');
+    }
+
+    // 12-byte nonce + 16-byte authentication tag + ciphertext
+    if (data.length < 28) {
+        throw new Error('Invalid Codepack data');
+    }
+
+    const nonce = data.subarray(0, 12);
+    const authTag = data.subarray(12, 28);
+    const encrypted = data.subarray(28);
+
+    const key = deriveKey(password);
+
+    try {
+        const decipher = crypto.createDecipheriv(
+            'aes-256-gcm',
+            key,
+            nonce
+        );
+
+        decipher.setAAD(Buffer.from(FORMAT, 'utf8'));
+        decipher.setAuthTag(authTag);
+
+        return Buffer.concat([
+            decipher.update(encrypted),
+            decipher.final()
+        ]).toString('utf8');
+    } catch {
+        throw new Error('Authentication failed');
+    }
+}
+
+module.exports = {
+    decrypt
+};

package/lib/encrypt.js

@@ -0,0 +1,54 @@
+const crypto = require('crypto');
+
+const PI = '3.14159265358979323846264338327950288419716939937510';
+const FORMAT = `π+[${PI}]{}\/`;
+
+function deriveKey(password) {
+    return crypto
+        .createHash('sha256')
+        .update(FORMAT + password, 'utf8')
+        .digest();
+}
+
+function encrypt(message, password) {
+    if (typeof message !== 'string') {
+        throw new TypeError('Message must be a string');
+    }
+
+    if (typeof password !== 'string' || password.length === 0) {
+        throw new Error('Password is required');
+    }
+
+    const key = deriveKey(password);
+
+    // Random 96-bit nonce
+    const nonce = crypto.randomBytes(12);
+
+    const cipher = crypto.createCipheriv(
+        'aes-256-gcm',
+        key,
+        nonce
+    );
+
+    cipher.setAAD(Buffer.from(FORMAT, 'utf8'));
+
+    const encrypted = Buffer.concat([
+        cipher.update(message, 'utf8'),
+        cipher.final()
+    ]);
+
+    const authTag = cipher.getAuthTag();
+
+    // nonce + authentication tag + encrypted data
+    const packet = Buffer.concat([
+        nonce,
+        authTag,
+        encrypted
+    ]);
+
+    return `[{${packet.toString('base64url')}}]`;
+}
+
+module.exports = {
+    encrypt
+};

package/package.json

@@ -1,6 +1,23 @@
 {
   "name": "codepi-package",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Secure encryption toolkit with the .Codepack[{}] format",
+  "main": "lib/codepack.js",
+  "bin": {
+    "codepi": "bin/codepi.js"
+  },
+  "scripts": {
+    "test": "node --check bin/codepi.js && node --check lib/encrypt.js && node --check lib/decrypt.js && node --check lib/codepack.js"
+  },
+  "keywords": [
+    "encryption",
+    "aes-256-gcm",
+    "codepack",
+    "security",
+    "termux"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/web/index.html

@@ -0,0 +1,91 @@
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Code[{π*}]</title>
+<style>
+*{box-sizing:border-box}
+body{margin:0;background:#0b0d12;color:#eee;font:15px Arial}
+main{max-width:700px;margin:auto;padding:35px 18px}
+header{text-align:center;margin-bottom:30px}
+h1{font-size:34px;margin:0}
+header p{color:#888}
+.card{background:#13161d;border:1px solid #252a35;border-radius:14px;padding:18px;margin:15px 0}
+h2{margin-top:0}
+textarea,input,button{width:100%;padding:12px;margin:6px 0;border-radius:9px;border:1px solid #303642;background:#0d1016;color:#fff}
+textarea{min-height:110px;resize:vertical}
+button{cursor:pointer;font-weight:bold;background:#eee;color:#111}
+.status{color:#888;font-size:13px}
+</style>
+</head>
+<body>
+<main>
+<header>
+<h1>Code[{π*}]</h1>
+<p>Secure encryption toolkit</p>
+</header>
+
+<section class="card">
+<h2>Encrypt</h2>
+<textarea id="m" placeholder="Enter your message"></textarea>
+<input id="ep" type="password" placeholder="Password">
+<button onclick="encrypt()">Encrypt</button>
+<textarea id="out" readonly placeholder="[{...}]"></textarea>
+</section>
+
+<section class="card">
+<h2>Decrypt</h2>
+<textarea id="in" placeholder="Paste [{...}]"></textarea>
+<input id="dp" type="password" placeholder="Password">
+<button onclick="decrypt()">Decrypt</button>
+<textarea id="result" readonly placeholder="Decrypted message"></textarea>
+</section>
+
+<p class="status">AES-256-GCM · Local browser encryption</p>
+<script>
+const F="π+[3.14159265358979323846264338327950288419716939937510]{}/";
+const E=new TextEncoder(),D=new TextDecoder();
+
+async function key(p){
+ const h=await crypto.subtle.digest("SHA-256",E.encode(F+p));
+ return crypto.subtle.importKey("raw",h,{name:"AES-GCM"},false,["encrypt","decrypt"]);
+}
+
+function b64(a){
+ return btoa(String.fromCharCode(...a))
+ .replace(/\+/g,"-").replace(/\//g,"_").replace(/=/g,"");
+}
+
+function unb64(s){
+ s=s.replace(/-/g,"+").replace(/_/g,"/");
+ while(s.length%4)s+="=";
+ return Uint8Array.from(atob(s),x=>x.charCodeAt(0));
+}
+
+async function encrypt(){
+ const n=crypto.getRandomValues(new Uint8Array(12));
+ const c=new Uint8Array(await crypto.subtle.encrypt(
+  {name:"AES-GCM",iv:n,additionalData:E.encode(F)},
+  await key(ep.value),E.encode(m.value)
+ ));
+ const a=new Uint8Array(12+c.length);
+ a.set(n);a.set(c,12);
+ out.value="[{"+b64(a)+"}]";
+}
+
+async function decrypt(){
+ try{
+  const a=unb64(in.value.slice(2,-2));
+  result.value=D.decode(await crypto.subtle.decrypt(
+   {name:"AES-GCM",iv:a.slice(0,12),additionalData:E.encode(F)},
+   await key(dp.value),a.slice(12)
+  ));
+ }catch{
+  result.value="Authentication failed.";
+ }
+}
+</script>
+</main>
+</body>
+</html>