mojic

root / lib / CipherEngine.js

CipherEngine.js (16906B)

---

 import crypto from 'crypto';
 import { Transform } from 'stream';
 import { StringDecoder } from 'string_decoder';
 
 /**
  * MOJIC v2.1.5 CIPHER ENGINE
  * * Security Upgrades:
  * - KDF: Upgraded from PBKDF2 to Scrypt (Memory-Hard, GPU-Resistant)
  * - PRNG: Upgraded from Xoshiro256** to AES-256-CTR (Cryptographically Secure)
  * - Auth: Extended Key material for higher entropy
  * * Fixes:
  * - Polymorphic Data: Added XOR Whitening to raw data chunks to hide patterns (e.g., repeating whitespace).
  * - RNG Buffering: Fixed potential byte loss in AES-CTR buffer refill.
  */
 
 // --- EMOJI UNIVERSE GENERATION ---
 const HEADER_ALPHABET = ['🌑', '🌒', '🌓', '🌔', '🌕', '🌖', '🌗', '🌘', '🕐', '🕑', '🕒', '🕓', '🕔', '🕕', '🕖', '🕗'];
 
 const generateUniverse = () => {
     const universe = [];
     const ranges = [
         [0x1F600, 0x1F64F], // Emoticons
         [0x1F300, 0x1F5FF], // Misc Symbols (Contains modifiers)
         [0x1F680, 0x1F6FF], // Transport
         [0x1F900, 0x1F9FF]  // Supplemental
     ];
 
     const headerSet = new Set(HEADER_ALPHABET);
 
     for (const [start, end] of ranges) {
         for (let code = start; code <= end; code++) {
             const char = String.fromCodePoint(code);
             if (!headerSet.has(char)) {
                 universe.push(char);
             }
         }
     }
     return universe; 
 };
 
 const RAW_UNIVERSE = generateUniverse();
 
 if (RAW_UNIVERSE.length < 1080) {
     throw new Error("Critical: Emoji Universe generation failed to produce enough tokens.");
 }
 
 const C_KEYWORDS = [
     'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do',
     'double', 'else', 'enum', 'extern', 'float', 'for', 'goto', 'if',
     'int', 'long', 'register', 'return', 'short', 'signed', 'sizeof', 'static',
     'struct', 'switch', 'typedef', 'union', 'unsigned', 'void', 'volatile', 'while',
     'include', 'define', 'main', 'printf', 'NULL', '#include', '#define'
 ];
 
 // --- PRNG: AES-256-CTR (CSPRNG) ---
 // Replaces Xoshiro with a cryptographically secure stream
 class AesCounterRNG {
     constructor(key, iv) {
         if (key.length !== 32 || iv.length !== 16) throw new Error("Invalid seed length for AES-RNG");
         this.cipher = crypto.createCipheriv('aes-256-ctr', key, iv);
         this.buffer = Buffer.alloc(0);
         
         // Encrypt an initial block of zeros to start the keystream
         this._refill();
     }
 
     _refill() {
         // Generate 1KB of random keystream at a time
         const zeros = Buffer.alloc(1024); 
         const newBytes = this.cipher.update(zeros);
         // Correctly concatenate new bytes to existing buffer to prevent data loss
         this.buffer = Buffer.concat([this.buffer, newBytes]);
     }
 
     next() {
         if (this.buffer.length < 8) this._refill();
         
         // Read 64 bits (BigInt) to match previous interface
         const val = this.buffer.readBigUInt64BE(0);
         this.buffer = this.buffer.subarray(8);
         return val;
     }
 
     nextBytes(length) {
         if (this.buffer.length < length) this._refill();
         
         // Return a Buffer of requested length
         const bytes = this.buffer.subarray(0, length);
         this.buffer = this.buffer.subarray(length);
         return bytes;
     }
 
     nextFloat() {
         // Convert uint64 to double [0, 1)
         // We take upper 53 bits for standard double precision
         const val = Number(this.next() >> 11n);
         return val * (2 ** -53); 
     }
 }
 
 export class CipherEngine {
     constructor(password) {
         this.password = password;
         this.keywordMap = new Map(); 
         this.keywordReverseMap = new Map(); 
         this.dataAlphabet = []; 
         this.dataReverseMap = new Map(); 
         this.isReady = false;
         this.hmac = null; 
         this.lineLength = 0;
     }
 
     async init(existingSaltHex = null, expectedAuthCheck = null) {
         this.salt = existingSaltHex 
             ? Buffer.from(existingSaltHex, 'hex') 
             : crypto.randomBytes(32); // Increased salt size to 32 bytes
 
         // SECURITY UPGRADE: Scrypt instead of PBKDF2
         // N=16384, r=8, p=1 are standard secure defaults
         const derivedKey = await new Promise((resolve, reject) => {
             crypto.scrypt(this.password, this.salt, 80, { N: 16384, r: 8, p: 1 }, (err, key) => {
                 if (err) reject(err); else resolve(key);
             });
         });
 
         // Split 80 bytes of key material:
         // 0-32:   AES Key (32 bytes)
         // 32-48:  AES IV (16 bytes)
         // 48-80:  HMAC Auth Key (32 bytes)
         
         const rngKey = derivedKey.subarray(0, 32);
         const rngIv = derivedKey.subarray(32, 48);
         this.authKey = derivedKey.subarray(48, 80);
         
         if (expectedAuthCheck) {
             const calculatedAuthCheck = this.authKey.subarray(0, 4).toString('hex');
             const calcAuthBuffer = Buffer.from(calculatedAuthCheck, 'hex');
             const expectedAuthBuffer = Buffer.from(expectedAuthCheck, 'hex');
             if (calcAuthBuffer.length !== expectedAuthBuffer.length || !crypto.timingSafeEqual(calcAuthBuffer, expectedAuthBuffer)) {
                 throw new Error("WRONG_PASSWORD");
             }
         }
 
         // Initialize CSPRNG
         this.rng = new AesCounterRNG(rngKey, rngIv);
 
         const shuffled = this._shuffleArray([...RAW_UNIVERSE]);
 
         let ptr = 0;
         this.keywordEmojis = [];
         for (const kw of C_KEYWORDS) {
             const emo = shuffled[ptr++];
             this.keywordEmojis.push(emo); 
             this.keywordMap.set(kw, emo); 
             this.keywordReverseMap.set(emo, kw);
         }
 
         this.dataAlphabet = shuffled.slice(ptr, ptr + 1024);
         if (this.dataAlphabet.length < 1024) throw new Error("Not enough emojis for Base-1024");
         
         this.dataAlphabet.forEach((emo, idx) => {
             this.dataReverseMap.set(emo, idx);
         });
 
         this.hmac = crypto.createHmac('sha256', this.authKey);
         this.isReady = true;
     }
 
     _shuffleArray(array) {
         // Fisher-Yates shuffle using CSPRNG
         for (let i = array.length - 1; i > 0; i--) {
             const j = Math.floor(this.rng.nextFloat() * (i + 1));
             [array[i], array[j]] = [array[j], array[i]];
         }
         return array;
     }
 
     _encodeHeader() {
         const saltHex = this.salt.toString('hex');
         const authCheck = this.authKey.subarray(0, 4).toString('hex'); 
         
         let headerStr = '';
         for (const char of (saltHex + authCheck)) {
             const val = parseInt(char, 16);
             headerStr += HEADER_ALPHABET[val];
         }
         return headerStr + '\n';
     }
 
     static decodeHeader(headerStr) {
         let hexString = '';
         const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
         const segments = segmenter.segment(headerStr.trim());
 
         for (const { segment } of segments) {
             const index = HEADER_ALPHABET.indexOf(segment);
             if (index === -1) throw new Error("Invalid Header format.");
             hexString += index.toString(16);
         }
         
         // Salt is now variable length (usually 32 bytes = 64 hex chars), 
         // AuthCheck is always last 4 bytes (8 hex chars)
         const totalLen = hexString.length;
         if (totalLen < 8) throw new Error("Header too short");
 
         const authStart = totalLen - 8;
         
         return { 
             saltHex: hexString.substring(0, authStart),
             authCheckHex: hexString.substring(authStart)
         };
     }
 
     // --- STREAMING ENCRYPTION ---
 
     getEncryptStream() {
         if (!this.isReady) throw new Error("Engine not initialized");
         const engine = this;
         let buffer = Buffer.alloc(0); 
         
         return new Transform({
             transform(chunk, encoding, callback) {
                 const str = chunk.toString('utf8');
                 
                 const alphaKeywords = C_KEYWORDS.filter(k => /^\w+$/.test(k)).sort((a,b)=>b.length-a.length).join('|');
                 const symKeywords = C_KEYWORDS.filter(k => !/^\w+$/.test(k)).map(k => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
                 
                 const regex = new RegExp(`(\\b(?:${alphaKeywords})\\b|(?:${symKeywords}))`, 'g');
                 
                 const parts = str.split(regex); 
                 
                 for (const part of parts) {
                     if (!part) continue;
 
                     if (C_KEYWORDS.includes(part)) {
                         if (buffer.length > 0) {
                             this.push(engine._flushDataBuffer(buffer));
                             buffer = Buffer.alloc(0);
                         }
 
                         const baseIdx = engine.keywordEmojis.indexOf(engine.keywordMap.get(part));
                         const shift = Number(engine.rng.next() % BigInt(engine.keywordEmojis.length));
                         const newIdx = (baseIdx + shift) % engine.keywordEmojis.length;
                         const polyEmoji = engine.keywordEmojis[newIdx];
                         
                         const outBuf = Buffer.from(polyEmoji);
                         engine.hmac.update(outBuf);
                         this.push(engine._wrapOutput(outBuf));
 
                     } else {
                         buffer = Buffer.concat([buffer, Buffer.from(part, 'utf8')]);
                         
                         while (buffer.length >= 5) {
                             const chunk = buffer.subarray(0, 5);
                             buffer = buffer.subarray(5);
                             
                             // XOR Whitening: Hide patterns (like spaces) by XORing with RNG stream
                             const mask = engine.rng.nextBytes(5);
                             const maskedChunk = Buffer.alloc(5);
                             for(let i=0; i<5; i++) maskedChunk[i] = chunk[i] ^ mask[i];
 
                             const enc = engine._encodeBase1024(maskedChunk);
                             engine.hmac.update(enc);
                             this.push(engine._wrapOutput(enc));
                         }
                     }
                 }
                 callback();
             },
             
             flush(callback) {
                 if (buffer.length > 0) {
                     const padded = Buffer.alloc(5);
                     buffer.copy(padded);
                     
                     // XOR Whitening for final block
                     const mask = engine.rng.nextBytes(5);
                     const maskedChunk = Buffer.alloc(5);
                     for(let i=0; i<5; i++) maskedChunk[i] = padded[i] ^ mask[i];
 
                     const enc = engine._encodeBase1024(maskedChunk);
                     engine.hmac.update(enc);
                     this.push(engine._wrapOutput(enc));
                 }
 
                 const digest = engine.hmac.digest(); 
                 let footerStr = '';
                 for (const byte of digest) {
                     const hex = byte.toString(16).padStart(2, '0');
                     for (const char of hex) {
                         const val = parseInt(char, 16);
                         footerStr += HEADER_ALPHABET[val];
                     }
                 }
                 this.push(Buffer.from('\n' + footerStr));
                 callback();
             }
         });
     }
 
     _wrapOutput(bufferChunk) {
         this.lineLength += bufferChunk.length;
         if (this.lineLength > 300) { 
             this.lineLength = 0;
             return Buffer.concat([bufferChunk, Buffer.from('\n')]);
         }
         return bufferChunk;
     }
 
     _encodeBase1024(buffer5) {
         let val = 0n;
         for (let i = 0; i < 5; i++) {
             val += BigInt(buffer5[i]) * (256n ** BigInt(i));
         }
         
         let output = '';
         for (let i = 0; i < 4; i++) {
             const idx = Number(val % 1024n);
             val = val / 1024n;
             output += this.dataAlphabet[idx];
         }
         return Buffer.from(output);
     }
 
     _flushDataBuffer(buf) {
         if (buf.length === 0) return Buffer.alloc(0);
         const padded = Buffer.alloc(5);
         buf.copy(padded);
 
         // XOR Whitening
         const mask = this.rng.nextBytes(5);
         const maskedChunk = Buffer.alloc(5);
         for(let i=0; i<5; i++) maskedChunk[i] = padded[i] ^ mask[i];
 
         const enc = this._encodeBase1024(maskedChunk);
         this.hmac.update(enc);
         return this._wrapOutput(enc);
     }
 
     // --- STREAMING DECRYPTION ---
 
     getDecryptStream() {
         if (!this.isReady) throw new Error("Engine not initialized");
         const engine = this;
         const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
         
         const FOOTER_LEN = 64; 
         let emojiBuffer = []; 
 
         return new Transform({
             transform(chunk, encoding, callback) {
                 const str = chunk.toString('utf8');
                 const segments = [...segmenter.segment(str)];
                 
                 for (const { segment } of segments) {
                     if (segment.match(/\s/)) continue; 
 
                     const atoms = [...segment];
 
                     for (const atom of atoms) {
                         emojiBuffer.push(atom);
                         
                         if (emojiBuffer.length > FOOTER_LEN) {
                             const emo = emojiBuffer.shift();
                             engine._processDecryptToken(emo, this);
                             engine.hmac.update(Buffer.from(emo));
                         }
                     }
                 }
                 callback();
             },
             
             flush(callback) {
                 if (emojiBuffer.length !== FOOTER_LEN) {
                     this.emit('error', new Error("File corrupted or truncated (No Footer)"));
                     return;
                 }
 
                 const footerStr = emojiBuffer.join('');
                 const calcDigest = engine.hmac.digest('hex'); 
                 
                 let footerHex = '';
                 try {
                     for (const char of footerStr) {
                         const idx = HEADER_ALPHABET.indexOf(char);
                         if (idx === -1) throw new Error();
                         footerHex += idx.toString(16);
                     }
                 } catch (e) {
                     this.emit('error', new Error("Invalid Integrity Seal"));
                     return;
                 }
 
                 const footerBuffer = Buffer.from(footerHex, 'hex');
                 const calcBuffer = Buffer.from(calcDigest, 'hex');
 
                 if (footerBuffer.length !== calcBuffer.length || !crypto.timingSafeEqual(footerBuffer, calcBuffer)) {
                     this.emit('error', new Error("FILE_TAMPERED"));
                     return;
                 }
                 callback();
             }
         });
     }
 
     decodeDataBuf = []; 
 
     _processDecryptToken(emo, stream) {
         if (this.keywordReverseMap.has(emo)) {
             const currentR = Number(this.rng.next() % BigInt(this.keywordEmojis.length));
             const emoIdx = this.keywordEmojis.indexOf(emo);
             
             let baseIdx = (emoIdx - currentR) % this.keywordEmojis.length;
             if (baseIdx < 0) baseIdx += this.keywordEmojis.length;
             
             const originalEmo = this.keywordEmojis[baseIdx];
             const keyword = this.keywordReverseMap.get(originalEmo);
             
             if (this.decodeDataBuf.length > 0) {
                 this.decodeDataBuf = [];
             }
             
             stream.push(keyword);
 
         } else if (this.dataReverseMap.has(emo)) {
             this.decodeDataBuf.push(this.dataReverseMap.get(emo));
             if (this.decodeDataBuf.length === 4) {
                 // We have a full encoded chunk (4 emojis)
                 const maskedChunk = this._decodeBase1024(this.decodeDataBuf);
                 this.decodeDataBuf = [];
                 
                 // Get mask from RNG (Synchronized with encryption)
                 const mask = this.rng.nextBytes(5);
                 const chunk = Buffer.alloc(5);
                 
                 // XOR Back to get plaintext
                 for(let i=0; i<5; i++) chunk[i] = maskedChunk[i] ^ mask[i];
 
                 const cleanChunk = chunk.filter(b => b !== 0x00);
                 stream.push(cleanChunk);
             }
         }
     }
 
     _decodeBase1024(indices) {
         let val = 0n;
         for (let i = 3; i >= 0; i--) {
             val = (val * 1024n) + BigInt(indices[i]);
         }
         
         const buf = Buffer.alloc(5);
         for (let i = 0; i < 5; i++) {
             buf[i] = Number(val % 256n);
             val = val / 256n;
         }
         return buf;
     }
 }

© notamitgamer • Site Built: 2026-09-05 01:53:16 UTC • git-mirror commit: c170d72 [view raw info]
Originally created with stagit • modified by notamitgamer
Forked from github.com/notamitgamer/git-mirror