2f:Ta43,drawByteArray = (ba, control, blocksize) => { const provided = (i) => i < control.length; const data = [ //dp1.bytes.map((v, i) => {return {v: i, i, z: "idx", block: Math.floor(i/16)}}), ba.map((v, i) => {return {v: lib.toHex1(v), i, z: "hex", block: Math.floor(i/blocksize), attacker: provided(i)}}), ba.map((v, i) => {return {v: control[i] || "?", i, z: "str", block: Math.floor(i/blocksize), attacker: provided(i)}}) ].flat() const domain = ["str", "hex"]; const blockNums = Array.from(Array(Math.floor(ba.length/blocksize)).keys(i => i)); const makePlot = (d, brange) => { const fd = d.filter(d => (d.i >= brange[0]) && (d.i < brange[1])) return Plot.plot({ marginLeft: 30, x: {axis: "top", type: "band", align: 0, label: null, padding: 0, domain: d3.range(...brange)}, //color: {domain: d3.range(0, 10).concat(["red", "black"]), scheme: "dark2"}, // color: { // domain: ["plaintext", "key", "xor", "cipher"], // range: ["darkgreen", "steelblue", "grey", "orange"], // }, y: { domain: domain, label: "", padding: 0.1 }, height: Math.max(45*domain.length, 80), // padding: {top: 0}, marks: [ // Plot.rectX(blockNums, // {x1: d => 4*d, x2: d => 4*(d+1), width: 4, fill: d => d, opacity: 0.2, dx: -10} // ), // Plot.cellX([idx1], {x: d=> d, fill: "#ffa"}), // Plot.cellX([idx2], {x: d=> d, fill: "#ddf"}), // Plot.ruleY( // [{x1: 0, x2: controlled1.length - 1, y: "hex"}], // { // x1: "x1", x2: "x2", y: "y", // dy: 10, // stroke: "red" // } // ), // Plot.ruleY( // [{x1: controlled1.length - 1, x2: ba.length - 1, y: "hex"}], // { // x1: "x1", x2: "x2", y: "y", // dy: 10, // stroke: "black" // } // ), Plot.cell( fd, {"x": "i", y: "z", stroke: "#aaa", fill: d => (d.block % 2) ? "#ddd" : "#666", //fill: d => d.attacker ? "red" : "black", fillOpacity: 0.2 }), Plot.text( fd, { x: "i", y: "z", text: "v", fontSize: "8pt", title: "v", // stroke: "#000", fill: d => d.attacker ? "darkred" : "black", //fill: "black", }) ], }) }; return makePlot(data, [0, 32]); //const plot2 = makePlot(data, [32, 64]); //return html`${plot1}${plot2}` } 30:Taac,drawByteArrayStep = (ba, control, blocksize) => { const controlStr = control.toString() const provided = (i) => i < control.length; const data = [ //dp1.bytes.map((v, i) => {return {v: i, i, z: "idx", block: Math.floor(i/16)}}), ba.map((v, i) => {return {v: lib.toHex1(v), i, z: "hex", block: Math.floor(i/blocksize), attacker: provided(i)}}), ba.map((v, i) => {return {v: controlStr[i] || "?", i, z: "str", block: Math.floor(i/blocksize), attacker: provided(i)}}) ].flat() const domain = ["str", "hex"]; const blockNums = Array.from(Array(Math.floor(ba.length/blocksize)).keys(i => i)); const makePlot = (d, brange) => { const fd = d.filter(d => (d.i >= brange[0]) && (d.i < brange[1])) return Plot.plot({ marginLeft: 30, x: {axis: "top", type: "band", align: 0, label: null, padding: 0, domain: d3.range(...brange)}, //color: {domain: d3.range(0, 10).concat(["red", "black"]), scheme: "dark2"}, // color: { // domain: ["plaintext", "key", "xor", "cipher"], // range: ["darkgreen", "steelblue", "grey", "orange"], // }, y: { domain: domain, label: "", padding: 0.1 }, height: Math.max(45*domain.length, 80), // padding: {top: 0}, marks: [ // Plot.rectX(blockNums, // {x1: d => 4*d, x2: d => 4*(d+1), width: 4, fill: d => d, opacity: 0.2, dx: -10} // ), // Plot.cellX([idx1], {x: d=> d, fill: "#ffa"}), // Plot.cellX([idx2], {x: d=> d, fill: "#ddf"}), // Plot.ruleY( // [{x1: 0, x2: controlled1.length - 1, y: "hex"}], // { // x1: "x1", x2: "x2", y: "y", // dy: 10, // stroke: "red" // } // ), // Plot.ruleY( // [{x1: controlled1.length - 1, x2: ba.length - 1, y: "hex"}], // { // x1: "x1", x2: "x2", y: "y", // dy: 10, // stroke: "black" // } // ), Plot.cell( fd, {"x": "i", y: "z", stroke: "#aaa", fill: d => (d.block % 2) ? "#ddd" : "#666", //fill: d => d.attacker ? "red" : "black", fillOpacity: 0.2 }), Plot.text( fd, { x: "i", y: "z", text: "v", fontSize: "8pt", title: "v", // stroke: "#000", fill: d => d.attacker ? "darkred" : "black", //fill: "black", }) ], }) }; const plot1 = makePlot(data, [0, 32]); const plot2 = makePlot(data, [32, 64]); const plot3 = makePlot(data, [64, 96]); return html`${plot1}${plot2}${plot3}` } 31: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; } 32: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 } 33:[] 2d:{"title":"2.12 Byte-at-a-time ECB decryption (Simple) ... Explained","cells":[{"id":0,"value":"# 2.12 Byte-at-a-time ECB decryption (Simple) ... Explained\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":274,"value":"lib2 = import('https://cdn.skypack.dev/cryptopals-pcarleton@0.0.7?min')","pinned":false,"hidden":false,"mode":"ojs"},{"id":283,"value":"BA = lib2.ByteArray","pinned":false,"hidden":false,"mode":"ojs"},{"id":269,"value":"## Determining block size.\n\nTo simplify things, I first want to pretend like our block size is 4, and our encryption function is [repeated xor](https://observablehq.com/@pcarleton/breaking-repeated-xor-determining-key-length?collection=@pcarleton/cryptopals), meaning our key size is 4. That's set up below, and we can see the resulting cipher text in hex after we \"encrypt\" it. The encrypted input bytes are in red.","pinned":false,"hidden":false,"mode":"md"},{"id":277,"value":"key1 = BA.from([0, 1, 2, 3])","pinned":false,"hidden":false,"mode":"ojs"},{"id":286,"value":"secret1 = \"super_secret\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":289,"value":"viewof controlled1 = Inputs.text({label: \"input\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":311,"value":"drawByteArray(cipher1, controlled1, 4)","pinned":false,"hidden":false,"mode":"ojs"},{"id":309,"value":"$2f","pinned":false,"hidden":false,"mode":"ojs"},{"id":439,"value":"encryptFn1 = (plain) => {\n if (typeof plain === \"string\") {\n plain = BA.fromString(plain)\n }\n return BA.from(lib2.repeatedXor(plain.concat(BA.fromString(secret1)), key1))\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":296,"value":"cipher1 = {\n return encryptFn1(controlled1)\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":433,"value":"By playing around with the input, we can see that if our input is all 1 character, and our input is 2x the block size, our cipher has 2 repeated blocks. So, to determine block size, we can keep increasing our key length until we see a repeated string half the size of our input.","pinned":false,"hidden":false,"mode":"md"},{"id":447,"value":"determineBlockSize = (fn) => {\n for (let i = 2; i < 64; i+=1) {\n let msg = Array(i).fill(\"A\").join(\"\");\n let cipher = fn(msg);\n let blocks = lib2.chunkArr(cipher, i/2);\n if (blocks[0].toString() === blocks[1].toString()) {\n return i/2;\n }\n }\n return \"uh oh\"\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":445,"value":"blockSize1 = {\n return determineBlockSize(encryptFn1)\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":456,"value":"## Attacking the first byte\n\nNow, we want to find what the first byte is. We can \"pull\" in just the first byte the first block now, so we know what \"AAA?\" encrypts to. To figure out what `?` is, we then just put in \"AAA\\0\" through \"AAA\\255\" and see which matches.","pinned":false,"hidden":false,"mode":"md"},{"id":462,"value":"{\n const controlled2 = \"AAA\";\n const cipher2 = encryptFn1(controlled2);\n return drawByteArray(cipher2, controlled2, 4);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":529,"value":"byte0search = encryptFn1(\"AAA\").toHex().slice(0, 8)","pinned":true,"hidden":false,"mode":"ojs"},{"id":478,"value":"We see in that case the cipher is `0x${encryptFn1(\"AAA\").toHex().slice(0, 8)}`. We can then put in a bunch of other values for the 4th byte of our input.","pinned":false,"hidden":false,"mode":"md"},{"id":491,"value":"alpha = alphabet.map(i => [i.letter, i.letter.toLowerCase()]).flat().sort()\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":503,"value":"viewof l1 = Inputs.range([0, 51], {step: 1, value: 0})","pinned":false,"hidden":false,"mode":"ojs"},{"id":514,"value":"{\n const controlled2 = `AAA${alpha[l1]}`;\n const cipher2 = encryptFn1(controlled2);\n return drawByteArray(cipher2, controlled2, 4);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":484,"value":"mapping = {\n const m = [];\n for (let l of alpha) {\n m.push([encryptFn1(`AAA${l}`).slice(0, 4).toHex(), l]);\n }\n return Object.fromEntries(m)\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":525,"value":"decryptedByte0 = mapping[byte0search]","pinned":false,"hidden":false,"mode":"ojs"},{"id":534,"value":"We can tell then that the first byte is `s` because when we put in `AAA${decryptedByte0}` we got `0x${byte0search}` as the first block. We can now use that to fish for the 2nd byte, like this. First pull the 2nd byte in like we did initially. Then put in input strings that include our now discovered 1st byte.","pinned":false,"hidden":false,"mode":"md"},{"id":543,"value":"{\n const controlled2 = \"AA\";\n const cipher2 = encryptFn1(controlled2);\n return drawByteArray(cipher2, controlled2, 4);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":545,"value":"byte1search = encryptFn1(\"AA\").toHex().slice(0, 8)","pinned":false,"hidden":false,"mode":"ojs"},{"id":552,"value":"viewof l2 = Inputs.range([0, 51], {step: 1, value: 0})","pinned":true,"hidden":false,"mode":"ojs"},{"id":574,"value":"lib.itoa(buildLut(BA.fromString(\"AAA\"), 4, encryptFn1)[byte0search]) == 's'","pinned":true,"hidden":false,"mode":"ojs"},{"id":666,"value":"getNextByte_test([], 4, encryptFn1)","pinned":true,"hidden":false,"mode":"ojs"},{"id":668,"value":"byte1search","pinned":true,"hidden":false,"mode":"ojs"},{"id":611,"value":"getNextByte_test([115], 4, encryptFn1)","pinned":true,"hidden":false,"mode":"ojs"},{"id":616,"value":"fillLen_test = (len) => {\n return BA.from((new Array(len)).fill(lib.atoi(\"A\")))\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":580,"value":"fillLast_test = (arr) => {\n const rs = [];\n for (let i = 0; i < 256; i++) {\n rs.push(arr.concat([i]))\n }\n return rs\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":563,"value":"buildLut = (prefix, blocksize, encrFn) => {\n const cands = fillLast_test(prefix);\n // return cands;\n const lut = {}\n const checked = cands.map((c, byte) => {\n const encrypted = encrFn(c)\n const hexBlock = lib2.toHex(encrypted.slice(0, blocksize))\n lut[hexBlock] = {byte, input: c.toString(), hexBlock, c: lib2.itoa(byte)};\n return hexBlock;\n });\n\n //return lut;\n\n return lut;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":549,"value":"getNextByte_test = (bs, blocksize, encrFn) => { \n const prepad = (blocksize - 1) - (bs.length % blocksize); \n const prefix = fillLen_test(prepad).concat(bs);\n\n //return fillLen_test(prepad);\n\n const blockNum = Math.floor(bs.length / blocksize);\n const encrypted = encrFn(fillLen_test(prepad));\n const blocks = lib2.chunkArr(encrypted, blocksize);\n\n const b = blocks[blockNum];\n\n let holder = BA.from(bs.slice(Math.max(bs.length - (blocksize-1), 0), bs.length));\n if (holder.length < (blocksize - 1)) {\n holder = fillLen_test((blocksize-1) - holder.length).concat(holder)\n }\n \n const lut = buildLut(holder, blocksize, encrFn);\n\n const answer = lut[b.toHex()];\n \n return {\n known: bs,\n prefix,\n encrypted,\n search: b.toHex(),\n lut,\n answer,\n newKnown: bs.concat(answer.byte)\n };\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":643,"value":"soln1 = decryptText(encryptFn1, 12)","pinned":true,"hidden":false,"mode":"ojs"},{"id":770,"value":"viewof step1 = Inputs.range([0, soln1[1].length - 1], {step: 1});","pinned":true,"hidden":false,"mode":"ojs"},{"id":783,"value":"curStep1 = soln1[1][step1];\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":757,"value":"{\n return drawByteArray(curStep1.encrypted, curStep1.prefix.toString(), 4);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":777,"value":"Target byte index is `${curStep1.prefix.length + 1}`, and the block we're looking to match is ${curStep1.search}. By trying all possible values, we find the input byte is `${curStep1.answer.c}`.","pinned":false,"hidden":false,"mode":"md"},{"id":645,"value":"decryptText = (fn, stopAt) => {\n const lencheck = fn(\"\").length;\n const blocksize = determineBlockSize(fn);\n\n //return blocksize;\n\n let known = [];\n let tracking = [];\n for (let i = 0; i < lencheck; i += 1) {\n if (stopAt !== undefined && i >= stopAt) {\n return [BA.from(known).toString(), tracking]\n }\n let soln = getNextByte_test(known, blocksize, fn);\n known = soln.newKnown;\n tracking.push(soln);\n\n\n }\n\n return [BA.from(known).toString(), tracking];\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":704,"value":"## Applying to the challenge\n\n","pinned":false,"hidden":false,"mode":"md"},{"id":11,"value":"challengeText = \"Um9sbGluJyBpbiBteSA1LjAKV2l0aCBteSByYWctdG9wIGRvd24gc28gbXkgaGFpciBjYW4gYmxvdwpUaGUgZ2lybGllcyBvbiBzdGFuZGJ5IHdhdmluZyBqdXN0IHRvIHNheSBoaQpEaWQgeW91IHN0b3A/IE5vLCBJIGp1c3QgZHJvdmUgYnkK\"\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":713,"value":"challengeArr = BA.fromb64(challengeText)","pinned":false,"hidden":false,"mode":"ojs"},{"id":708,"value":"encryptFn2 = (inputBa) => {\n const fullInput = inputBa.concat(challengeArr)\n return lib2.aes.encryptAes128Ecb(fullInput, key)\n \n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":717,"value":"soln2 = decryptText(encryptFn2, 138)","pinned":true,"hidden":false,"mode":"ojs"},{"id":799,"value":"viewof step2 = Inputs.range([0, soln2[1].length - 1], {step: 1, value: 2});","pinned":true,"hidden":false,"mode":"ojs"},{"id":817,"value":"Target byte index is `${curStep2.prefix.length}`, and the block we're looking to match is ${curStep2.search}. By trying all possible values, we find the input byte is `${curStep2.answer.c}`.","pinned":false,"hidden":false,"mode":"md"},{"id":810,"value":"{\n const targetByte = curStep2.targetByte;\n return drawByteArrayStep(curStep2.encrypted, curStep2.prefix, 16);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":820,"value":"viewof stepL2 = Inputs.range([0, 255], {step: 1, value: 2});","pinned":true,"hidden":false,"mode":"ojs"},{"id":835,"value":"newPrefix = curStep2.prefix.concat(stepL2);\n","pinned":true,"hidden":false,"mode":"ojs"},{"id":862,"value":"lib.atoi(\"¥\")","pinned":true,"hidden":false,"mode":"ojs"},{"id":864,"value":"Very confusing thing: the last byte, when it's over 128 stops affecting the first block, and instead starts affecting future blocks. It doesn't matter for this problem since that's beyond the ASCII range, but it doesn't make any sense to me. It would mean that the highest bit in the last block matters some how.\n\n\n(this turned out to be an encoding issue in my underlying library! see: https://observablehq.com/d/230663f465280aa2)","pinned":false,"hidden":false,"mode":"md"},{"id":827,"value":"{\n const newPrefix = curStep2.prefix.concat(stepL2);\n const encrypted = encryptFn2(newPrefix);\n return drawByteArrayStep(encrypted, newPrefix, 16);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":850,"value":"key.toHex()","pinned":true,"hidden":false,"mode":"ojs"},{"id":844,"value":"newPrefix.concat(challengeArr)","pinned":true,"hidden":false,"mode":"ojs"},{"id":839,"value":"lib2.aes.encryptAes128Ecb(newPrefix.concat(challengeArr), key).slice(0,16).toHex()","pinned":true,"hidden":false,"mode":"ojs"},{"id":848,"value":"lib2.aes.encryptAes128Ecb(newPrefix.concat(challengeArr), key).slice(16,32).toHex()","pinned":true,"hidden":false,"mode":"ojs"},{"id":852,"value":"lib2.aes.encryptAes128Ecb(BA.fromString(\"AAAAAAAAAAAAAAAA\"), key).toHex()","pinned":true,"hidden":false,"mode":"ojs"},{"id":866,"value":"lib2.aes.encryptAes128Ecb(BA.fromString(\"AAAAAAAAAAAAAAAB\"), key).toHex()","pinned":true,"hidden":false,"mode":"ojs"},{"id":868,"value":"lib2.aes.encryptAes128Ecb(BA.fromString(\"AAAAAAAAAAAAAAA€\"), key).toHex()","pinned":true,"hidden":false,"mode":"ojs"},{"id":870,"value":"lib2.aes.decryptAes128Ecb(BA.fromHex(\"7b39d656557289b398f579d76a2cbe49\"), key)","pinned":true,"hidden":false,"mode":"ojs"},{"id":886,"value":"BA.fromString(\"7b39d656557289b398f579d76a2cbe49\")","pinned":true,"hidden":false,"mode":"ojs"},{"id":873,"value":"lib2.aes.decryptAes128Ecb(BA.fromString(\"9a4e3fcf4e5a1910830a5f8bc669d0e\"), key)","pinned":true,"hidden":false,"mode":"ojs"},{"id":875,"value":"BA.fromWordArray(CryptoJS.AES.decrypt(BA.fromHex(\"7b39d656557289b398f579d76a2cbe49\").tob64(), key.toWordArray(), {mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.NoPadding,\n })).toHex()","pinned":true,"hidden":false,"mode":"ojs"},{"id":902,"value":"{\n\n\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":899,"value":"BA.fromWordArray(CryptoJS.AES.decrypt(BA.fromHex(\"2999ee9243fefd95a9b3214cec97e13f\").tob64(), BA.fromHex(\"deadbeefdeadbeefdeadbeefdeadbeef\").toWordArray(), {mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.NoPadding,\n })).toHex()","pinned":true,"hidden":false,"mode":"ojs"},{"id":896,"value":"BA.fromWordArray(CryptoJS.AES.decrypt(BA.fromHex(\"79a4e3fcf4e5a1910830a5f8bc669d0e\").tob64(), key.toWordArray(), {mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.NoPadding,\n }))","pinned":true,"hidden":false,"mode":"ojs"},{"id":855,"value":"BA.fromWordArray(CryptoJS.AES.encrypt(\"AAAAAAAAAAAAAAAA\", key.toWordArray(), {mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.NoPadding,\n }).ciphertext).tob64()","pinned":true,"hidden":false,"mode":"ojs"},{"id":768,"value":"$30","pinned":false,"hidden":false,"mode":"ojs"},{"id":803,"value":"curStep2 = soln2[1][step2];\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":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":21,"value":"$32","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":"$W33","stdlib":"1","titling":"auto"}