2f:Td72,lib = { const exports = {}; exports.ByteArray = exports.fromb64 = exports.tob64 = exports.fromBitArr = exports.toBitArr = exports.btos = exports.stob = exports.atoi = exports.itoa = exports.fromHex = exports.toHex = exports.toHex1 = exports.fromByteStr = exports.toByteStr = exports.chunkArr = void 0; function chunkArr(arr, chunkSize) { let chunks = []; for (let i = 0; i < arr.length; i += chunkSize) { chunks.push(arr.slice(i, i + chunkSize)); } return chunks; } exports.chunkArr = chunkArr; const hexAlphabet = "0123456789abcdef"; const toByteStr = (a) => String.fromCharCode(...a); exports.toByteStr = toByteStr; const fromByteStr = (s) => s.split("").map((c) => c.charCodeAt(0)); exports.fromByteStr = fromByteStr; const toHex1 = (x) => { let hex = x.toString(16); if (hex.length == 1) { hex = "0" + hex; } return hex; }; exports.toHex1 = toHex1; const toHex = (s) => s.map(toHex1).join(""); exports.toHex = toHex; const fromHex = (s) => { if ((s.length % 2) !== 0) { throw 'hex string must have length divisible by 2'; } let ints = []; for (let i = 0; i < s.length; i += 2) { let c1 = s[i]; let c2 = s[i + 1]; let b = hexAlphabet.indexOf(c2) + (hexAlphabet.indexOf(c1) << 4); ints.push(b); } return ints; }; exports.fromHex = fromHex; // Binary etc. const itoa = (i) => String.fromCharCode(i); exports.itoa = itoa; const atoi = (a) => a.charCodeAt(0); exports.atoi = atoi; const stob = (s) => s.split("").map(atoi); exports.stob = stob; const btos = (arr) => arr.map(itoa).join(""); exports.btos = btos; // Bit array const toBitArr = (c) => { if (c > 255) { throw 'must be 8 bit byte'; } let result = [0, 0, 0, 0, 0, 0, 0, 0]; result[7] = (c & 1) > 0 ? 1 : 0; result[6] = (c & 2) > 0 ? 1 : 0; result[5] = (c & 4) > 0 ? 1 : 0; result[4] = (c & 8) > 0 ? 1 : 0; result[3] = (c & 16) > 0 ? 1 : 0; result[2] = (c & 32) > 0 ? 1 : 0; result[1] = (c & 64) > 0 ? 1 : 0; result[0] = (c & 128) > 0 ? 1 : 0; return result; }; exports.toBitArr = toBitArr; const fromBitArr = (x) => { let result = 0; for (let i = 0; i < 8; i += 1) { result |= x[7 - i] << i; } return result; }; exports.fromBitArr = fromBitArr; // Base64 const tob64 = (arr) => btoa(toByteStr(arr)); exports.tob64 = tob64; const fromb64 = (s) => fromByteStr(atob(s)); exports.fromb64 = fromb64; class ByteArray { constructor(bytes) { this.bytes = bytes; } static fromb64(b64) { return new ByteArray(fromb64(b64)); } static fromBytes(x) { return new ByteArray(x); } static fromString(x) { return new ByteArray(stob(x)); } static fromHex(x) { return new ByteArray(fromHex(x)); } static fromWordArray(x) { return new ByteArray(fromHex(x.toString())); } toWordArray() { return CryptoJS.enc.Hex.parse(this.toHex()); } toString() { return btos(this.bytes); } tob64() { return tob64(this.bytes); } toHex() { return toHex(this.bytes); } concatRaw(bs) { return new ByteArray(this.bytes.concat(bs)); } concat(bs) { return new ByteArray(this.bytes.concat(bs.bytes)); } slice(start, end) { return new ByteArray(this.bytes.slice(start, end)); } } exports.ByteArray = ByteArray; return exports; } 30:T1185,aes = { let exports = {}; exports.decryptAes128Cbc = exports.encryptAes128Cbc = exports.padBlock = exports.encryptAes128EcbStr = exports.encryptAes128Ecb = exports.decryptAes128EcbStr = exports.decryptAes128Ecb = void 0; const BLOCK_SIZE = 16; const decryptAes128EcbStr = (cipher, key) => { const encKey = CryptoJS.enc.Utf8.parse(key); // The challenge input includes newlines, but we want to ignore them. // It's a PEM like encoding const fixedCipher = cipher.replaceAll("\n", ""); return CryptoJS.AES.decrypt(fixedCipher, encKey, { mode: CryptoJS.mode.ECB }).toString(CryptoJS.enc.Utf8); }; exports.decryptAes128EcbStr = decryptAes128EcbStr; const decryptAes128Ecb = (cipher, key) => { const words = CryptoJS.AES.decrypt(cipher.tob64(), key.toWordArray(), { mode: CryptoJS.mode.ECB }); return lib.ByteArray.fromWordArray(words); }; exports.decryptAes128Ecb = decryptAes128Ecb; const encryptAes128EcbStr = (plaintext, key) => { const encKey = CryptoJS.enc.Utf8.parse(key); return CryptoJS.enc.Base64.stringify(CryptoJS.AES.encrypt(plaintext, encKey, { mode: CryptoJS.mode.ECB }).ciphertext); }; exports.encryptAes128EcbStr = encryptAes128EcbStr; const encryptAes128Ecb = (plaintext, key) => { return lib.ByteArray.fromWordArray(CryptoJS.AES.encrypt(plaintext.toString(), key.toWordArray(), { mode: CryptoJS.mode.ECB }).ciphertext); }; exports.encryptAes128Ecb = encryptAes128Ecb; const padBlock = (arr, targetLen) => { const diff = targetLen - (arr.length % targetLen); const extraBytes = Array(diff).fill(0).map(() => diff); return arr.concat(extraBytes); }; exports.padBlock = padBlock; const dePad = (arr, size) => { const lastIdx = arr.length - 1; const last = arr[lastIdx]; if (last > size || arr.length < size) { return arr; } for (let i = 1; i < last; i += 1) { if (arr[lastIdx - i] != last) { return arr; } } // If we've gotten through that, we know we have a padded block, so we can truncate it. return arr.slice(0, arr.length - last); }; const xorZip = (a1, a2) => { return lib.ByteArray.fromBytes(a1.bytes.map((d, i) => d ^ a2.bytes[i])); }; const encryptAes128Cbc = (plaintext, iv, key) => { // first start with IV, XOR it with cipher text // Pad it const padded = padBlock(plaintext.bytes, BLOCK_SIZE); // Split it into blocks const blocks = lib.chunkArr(padded, BLOCK_SIZE).map(lib.ByteArray.fromBytes); let lastBlock = iv; let results = []; for (let i = 0; i < blocks.length; i += 1) { let prepped = xorZip(blocks[i], lastBlock); let words = prepped.toWordArray(); let cipher = CryptoJS.AES.encrypt(words, key.toWordArray(), { mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.NoPadding, }).ciphertext; let cipherBs = lib.ByteArray.fromWordArray(cipher); results.push(cipherBs.bytes); lastBlock = cipherBs; } // count IV as "block -1" // XOR block against block -1, then encrypt it. // concat the blocks together again // return byte array return new lib.ByteArray(results.flat()); }; exports.encryptAes128Cbc = encryptAes128Cbc; const decryptAes128Cbc = (cipher, iv, key) => { // first start with IV, XOR it with cipher text // Split it into blocks const blocks = lib.chunkArr(cipher.bytes, BLOCK_SIZE).map(lib.ByteArray.fromBytes); const keyWA = key.toWordArray(); let lastBlock = iv; let results = []; for (let i = 0; i < blocks.length; i += 1) { //let words = CryptoJS.lib.WordArray.init(blocks[i]); //return words; //let prepped64 = lib.tob64(prepped); // I'm doing some real janky extra base64ing here let plainText = CryptoJS.AES.decrypt(blocks[i].tob64(), keyWA, { mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.NoPadding }); // this is weird, I don't know what's happening plainText = new CryptoJS.lib.WordArray.init(plainText.words); let ptArr = lib.ByteArray.fromWordArray(plainText); //return words; let dexord = xorZip(ptArr, lastBlock); results.push(dexord.bytes); lastBlock = blocks[i]; } // count IV as "block -1" // XOR block against block -1, then encrypt it. // concat the blocks together again // return base64 encoded return new lib.ByteArray(dePad(results.flat(), 16)); }; exports.decryptAes128Cbc = decryptAes128Cbc; return exports } 31:[] 2d:{"title":"2.12 Byte-at-a-time ECB decryption (Simple)","cells":[{"id":0,"value":"# 2.12 Byte-at-a-time ECB decryption (Simple)\n\nhttps://cryptopals.com/sets/2/challenges/12\n\nThe problem description is a little strange here. Essentially we're assuming we have access to some function that works like this:\n\n```\nencrypt()\n```\n\nAnd it gives back some encrypted bytes. In this scenario, I know there are some additional bytes appended to yours in the ciphertext, and I want to determine what they are, but all I have access to is the `encrypt` function.\n\nThe first thing it suggests is to determine the block size. Because then if my input is exactly the block size, I can start building up a \"dictionary\" (i.e. input X maps to output Y, since ECB is deterministic). So I would get:\n\n```\nencrypt()\n|--block1--|-2-|-3-|\n```\n\nAnd because I totally control block 1, I can start to choose inputs that are helpful. So assuming we have the block size figured out, the way to attack the first byte is to \"bring it in\" to the block in control.\n","pinned":false,"hidden":false,"mode":"md"},{"id":269,"value":"","pinned":false,"hidden":false,"mode":"md"},{"id":11,"value":"challengeText = \"Um9sbGluJyBpbiBteSA1LjAKV2l0aCBteSByYWctdG9wIGRvd24gc28gbXkgaGFpciBjYW4gYmxvdwpUaGUgZ2lybGllcyBvbiBzdGFuZGJ5IHdhdmluZyBqdXN0IHRvIHNheSBoaQpEaWQgeW91IHN0b3A/IE5vLCBJIGp1c3QgZHJvdmUgYnkK\"\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":31,"value":"CryptoJS = require('https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js')","pinned":true,"hidden":false,"mode":"ojs"},{"id":13,"value":"$2f","pinned":false,"hidden":false,"mode":"ojs"},{"id":21,"value":"$30","pinned":false,"hidden":false,"mode":"ojs"},{"id":25,"value":"cba = lib.ByteArray.fromb64(challengeText)","pinned":true,"hidden":false,"mode":"ojs"},{"id":27,"value":"myBa = lib.ByteArray.fromBytes((new Array(16)).fill(lib.atoi(\"A\")))","pinned":true,"hidden":false,"mode":"ojs"},{"id":29,"value":"key = lib.ByteArray.fromWordArray(CryptoJS.lib.WordArray.random(16));","pinned":true,"hidden":false,"mode":"ojs"},{"id":33,"value":"prependBs = (ba) => {\n return lib.ByteArray.fromBytes(ba.bytes.concat(cba.bytes))\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":35,"value":"aes.encryptAes128Ecb(prependBs(myBa), key)","pinned":true,"hidden":false,"mode":"ojs"},{"id":56,"value":"fillLen = (len) => {\n return lib.ByteArray.fromBytes((new Array(len)).fill(lib.atoi(\"A\")))\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":63,"value":"fillLast = (arr) => {\n const rs = [];\n for (let i = 0; i < 256; i++) {\n rs.push(lib.ByteArray.fromBytes(arr.bytes.concat([i])))\n }\n return rs\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":122,"value":"lib.toHex(aes.encryptAes128Ecb(prependBs(fillLen(15)), key).bytes.slice(0, 16))\n","pinned":true,"hidden":false,"mode":"ojs"},{"id":73,"value":"getByte0 = () => {\n const b0 = lib.toHex(aes.encryptAes128Ecb(prependBs(fillLen(15)), key).bytes.slice(0, 16))\n \n const cands = fillLast(fillLen(15));\n\n const lut = {}\n const checked = cands.map((c, i) => {\n const encrypted = aes.encryptAes128Ecb(prependBs(c), key)\n const hexBlock = lib.toHex(encrypted.bytes.slice(0, 16))\n lut[hexBlock] = i;\n });\n\n return lut[b0];\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":116,"value":"lib.btos(lib.fromb64(challengeText)).slice(0,4)","pinned":true,"hidden":false,"mode":"ojs"},{"id":79,"value":"pt0 = getByte0()","pinned":true,"hidden":false,"mode":"ojs"},{"id":118,"value":"debug1 = {\n const prefix = fillLen(14).concatRaw(pt0);\n const b1 = lib.toHex(aes.encryptAes128Ecb(prependBs(prefix), key).bytes.slice(0, 16))\n const cands = fillLast(prefix);\n\n return {b1, prefix, cands};\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":132,"value":"debug1.cands[82]","pinned":true,"hidden":false,"mode":"ojs"},{"id":104,"value":"getByte1 = (pt0) => {\n const prefix = fillLen(14).concatRaw(pt0);\n\n // return prefix;\n \n const b1 = lib.toHex(aes.encryptAes128Ecb(prependBs(fillLen(14)), key).bytes.slice(0, 16))\n \n const cands = fillLast(prefix);\n //return cands;\n\n const lut = {}\n const checked = cands.map((c, i) => {\n const encrypted = aes.encryptAes128Ecb(prependBs(c), key)\n const hexBlock = lib.toHex(encrypted.bytes.slice(0, 16))\n lut[hexBlock] = i;\n });\n\n return lut[b1];\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":88,"value":"pt1 = getByte1(pt0)","pinned":true,"hidden":false,"mode":"ojs"},{"id":157,"value":"findMatch = (prefix, b) => {\n const cands = fillLast(prefix);\n const lut = {}\n const checked = cands.map((c, i) => {\n const encrypted = aes.encryptAes128Ecb(prependBs(c), key)\n const hexBlock = lib.toHex(encrypted.bytes.slice(0, 16))\n lut[hexBlock] = i;\n });\n\n return lut[b];\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":141,"value":"getByte2 = (pt0, pt1) => {\n const prefix = fillLen(13).concatRaw([pt0, pt1]);\n const b = lib.toHex(aes.encryptAes128Ecb(prependBs(fillLen(13)), key).bytes.slice(0, 16))\n \n return findMatch(prefix, b)\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":149,"value":"lib.itoa(getByte2(pt0, pt1))","pinned":true,"hidden":false,"mode":"ojs"},{"id":162,"value":"getNextByte = (bs) => {\n const prepad = 15 - bs.length;\n const prefix = fillLen(prepad).concatRaw(bs);\n const b = lib.toHex(aes.encryptAes128Ecb(prependBs(fillLen(prepad)), key).bytes.slice(0, 16))\n \n return findMatch(prefix, b)\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":170,"value":"getNextByte([82, 111])","pinned":true,"hidden":false,"mode":"ojs"},{"id":191,"value":"attempt1[16].map(lib.itoa).join(\"\")","pinned":true,"hidden":false,"mode":"ojs"},{"id":164,"value":"attempt1 = {\n let results = [[]];\n\n for (let i = 0; i < 16; i += 1) {\n const nb = getNextByte(results[i]);\n results.push(results[i].concat([nb]));\n }\n\n\n return results\n \n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":199,"value":"first16 = attempt1[16]","pinned":true,"hidden":false,"mode":"ojs"},{"id":209,"value":"first16.slice(first16.length - 15, first16.length)","pinned":true,"hidden":false,"mode":"ojs"},{"id":214,"value":"getNextByte2([82])","pinned":true,"hidden":false,"mode":"ojs"},{"id":201,"value":"getNextByte2 = (bs) => { \n const prepad = 15 - (bs.length % 16); \n const prefix = fillLen(prepad).concatRaw(bs);\n\n const blockNum = bs.length / 16;\n const encrypted = aes.encryptAes128Ecb(prependBs(fillLen(prepad)), key);\n const blocks = lib.chunkArr(encrypted.bytes, 16);\n const b = lib.toHex(blocks[blockNum])\n \n return findMatch(lib.ByteArray.fromBytes(bs.slice(bs.length - 15, bs.length)), b)\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":203,"value":"lib.itoa(getNextByte2(first16))","pinned":true,"hidden":false,"mode":"ojs"},{"id":217,"value":"getNextByte3 = (bs) => { \n const prepad = 15 - (bs.length % 16); \n const prefix = fillLen(prepad).concatRaw(bs);\n\n const blockNum = Math.floor(bs.length / 16);\n const encrypted = aes.encryptAes128Ecb(prependBs(fillLen(prepad)), key);\n const blocks = lib.chunkArr(encrypted.bytes, 16);\n\n const b = lib.toHex(blocks[blockNum])\n\n let holder = lib.ByteArray.fromBytes(bs.slice(Math.max(bs.length - 15, 0), bs.length));\n if (holder.bytes.length < 15) {\n holder = fillLen(15 - holder.bytes.length).concat(holder)\n }\n //return {b, blocks, blockNum, encrypted, prefix, prepad, holder, hl: 15 - holder.length};\n\n \n return findMatch(holder, b);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":219,"value":"getNextByte3(first16)","pinned":true,"hidden":false,"mode":"ojs"},{"id":241,"value":"attempt2 = {\n let results = [[]];\n\n for (let i = 0; i < cba.bytes.length; i += 1) {\n const nb = getNextByte3(results[i]);\n results.push(results[i].concat([nb]));\n }\n\n return results\n\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":261,"value":"attempt2[attempt2.length -1].map(lib.itoa).join(\"\")","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W31","stdlib":"1","titling":"auto"}