31:T481,{ const ogKey = inputKey; const input = inputText; const input2 = input.split("").map((_, i) => ogKey[i%ogKey.length]).join(""); const isplit = input.split("").map((l, i) => ({l, i, z: "plaintext"})); const ksplit = input2.split("").map((l, i) => ({l, i, z: "key"})); const xors = input.split("").map((l, i) => ({l: `${input[i]}^${input2[i]}`, i, z: "xor"})); const hexsplit = input.split("").map((l, i) => ({l: lib.toHex([lib.atoi(input[i])^lib.atoi(input2[i])]), i, z: "cipher"})); const data = [isplit, ksplit, xors, hexsplit].flat(); return Plot.plot({ marginLeft: 50, x: {axis: false, padding: 0.05}, color: { domain: ["plaintext", "key", "xor", "cipher"], range: ["darkgreen", "steelblue", "grey", "orange"], }, y: { domain: ["plaintext", "key", "xor", "cipher"], label: "", padding: 0.2 }, height: 150, // padding: {top: 0}, marks: [ Plot.cell( data, {"x": "i", y: "z", fill: "#fff", stroke: "#aaa"}), Plot.text(data, { x: "i", y: "z", text: "l", fontSize: "10pt", title: "l", // stroke: "#000", fill: "z", }) ], }) }32:T517,{ const ogKey = inputKey; const input = inputText; const input2 = input.split("").map((_, i) => ogKey[i%ogKey.length]).join(""); const isplit = input.split("").map((l, i) => ({l, i, z: "plaintext"})); const ksplit = input2.split("").map((l, i) => ({l, i, z: "key"})); const hexsplit = input.split("").map((l, i) => ({l: lib.toHex([lib.atoi(input[i])^lib.atoi(input2[i])]), i, z: "cipher"})); const xors = input.split("").map((l, i) => ({l: `${hexsplit[i].l}^${input2[i]}`, i, z: "xor"})); const decrypted = hexsplit.map(({l, i}) => ({l: lib.itoa(lib.fromHex(l)^lib.atoi(input2[i])), i, z: "decrypted"})); const data = [decrypted, ksplit, xors, hexsplit].flat(); return Plot.plot({ marginLeft: 60, x: {axis: false, padding: 0.05}, color: { domain: ["plaintext", "key", "xor", "cipher", "decrypted"], range: ["darkgreen", "steelblue", "grey", "orange", "green"], }, y: { domain: ["cipher", "key", "xor", "decrypted"], label: "", padding: 0.2 }, height: 150, // padding: {top: 0}, marks: [ Plot.cell( data, {"x": "i", y: "z", fill: "#fff", stroke: "#aaa"}), Plot.text(data, { x: "i", y: "z", text: "l", fontSize: "10pt", title: "l", // stroke: "#000", fill: "z", }) ], }) }33:T45d,## Brute force vs. Guessing key length To brute force it, I would want to check every possible key length, and then brute force each character at that key length. To brute force a single character, I'd try 0-255 values for each character of the key and see which one produced readable text (see [the chi square test in 1.4](https://observablehq.com/@pcarleton/cryptopals-1-1-through-1-4?collection=@pcarleton/cryptopals)). If I wanted to crack up to a key length of 10 let's say, I would need to try: 1 + 2 + ... + 10 = ${d3.sum([...Array(11).keys()])}. This simplifies to ${tex`\frac{n(n-1)}{2}`}, which means I have a polynomial factor. For each key length, I first need to break the cipher text into chunks of that length, and make a frequency table. The time it takes to do that scales with the length of the cipher text. Then for each character in the key, you check 256 values by XOR'ing them with the frequency table, and then calculating the chi-square of that against the expected frequencies. Let's assume the frequency table is about 60 characters long for upper + lower + some digits and symbols. 34:T4c1,{ const ogKey = inputKey; const input = inputText; const input2 = input.split("").map((_, i) => ogKey[i%ogKey.length]).join(""); const isplit = input.split("").map((l, i) => ({l, i, z: "plaintext"})); const ksplit = input2.split("").map((l, i) => ({l, i, z: "key"})); const xors = input.split("").map((l, i) => ({l: `${input[i]}^${input2[i]}`, i, z: "xor"})); const hexsplit = input.split("").map((l, i) => ({l: lib.toHex([lib.atoi(input[i])^lib.atoi(input2[i])]), i, z: "cipher"})); const data = [isplit, ksplit, xors, hexsplit].flat(); return Plot.plot({ marginLeft: 50, x: {axis: false, padding: 0.05}, color: { domain: ["plaintext", "key", "xor", "cipher"], range: ["darkgreen", "steelblue", "grey", "orange"], }, y: { domain: ["plaintext"], label: "", padding: 0.2 }, height: 100, // padding: {top: 0}, marks: [ Plot.cellX([idx1], {x: d=> d, fill: "#ffa"}), Plot.cellX([idx2], {x: d=> d, fill: "#ddf"}), Plot.cell( data, {"x": "i", y: "z", stroke: "#aaa"}), Plot.text(data, { x: "i", y: "z", text: "l", fontSize: "10pt", title: "l", // stroke: "#000", fill: "z", }) ], }) }35:T4c9,{ const ogKey = inputKey; const input = inputText; const input2 = input.split("").map((_, i) => ogKey[i%ogKey.length]).join(""); const isplit = input.split("").map((l, i) => ({l, i, z: "plaintext"})); const ksplit = input2.split("").map((l, i) => ({l, i, z: "key"})); const xors = input.split("").map((l, i) => ({l: `${input[i]}^${input2[i]}`, i, z: "xor"})); const hexsplit = input.split("").map((l, i) => ({l: lib.toHex([lib.atoi(input[i])^lib.atoi(input2[i])]), i, z: "cipher"})); const data = [isplit, ksplit, xors, hexsplit].flat(); return Plot.plot({ marginLeft: 50, x: {axis: false, padding: 0.05}, color: { domain: ["plaintext", "key", "xor", "cipher"], range: ["darkgreen", "steelblue", "grey", "orange"], }, y: { domain: ["plaintext", "key"], label: "", padding: 0.2 }, height: 150, // padding: {top: 0}, marks: [ Plot.cellX([idx1], {x: d=> d, fill: "#ffa"}), Plot.cellX([idx2], {x: d=> d, fill: "#ddf"}), Plot.cell( data, {"x": "i", y: "z", stroke: "#aaa"}), Plot.text(data, { x: "i", y: "z", text: "l", fontSize: "10pt", title: "l", // stroke: "#000", fill: "z", }) ], }) }36:T8b4,//hams = letters.split("").map(l => hammingDist(lib.atoi(letters[let1]), lib.atoi(l))) { const l1 = inputText[idx1]; const allDists = inputText.split("").map((l, i) => { const cipherXor = hammingDist( lib.atoi(l1)^lib.atoi(inputKey[idx1 % inputKey.length]), lib.atoi(l)^lib.atoi(inputKey[i % inputKey.length]) ); const rawXor = hammingDist( lib.atoi(l1), lib.atoi(l) ); const diff = (rawXor - cipherXor); return { x: i, y: cipherXor, rawXor, diff, diffSign: Math.min(Math.max(diff, -1), 1) }; }); const mean = d3.mean(allDists.filter(d => d.x != idx1).map(d => d.y)); const matchedMean = d3.mean(allDists.filter( d => ((d.x != idx1) && (d.x % inputKey.length == idx1 % inputKey.length))).map(d => d.y)); const unmatchedMean = d3.mean(allDists.filter( d => ((d.x != idx1) && (d.x % inputKey.length != idx1 % inputKey.length))).map(d => d.y)); // return allDists.filter( // d => ((d.x != idx1) && (d.x % inputKey.length == idx1 % inputKey.length))).map(d => d.y); // return allDists.filter( // d => ((d.x != idx1) && (d.x % inputKey.length == idx1 % inputKey.length))); return Plot.plot({ height: 100, legend: true, y: {domain: [0,5]}, x: { // domain: [0, inputText.length-1], // range: inputText.split(""), label: null, tickFormat: d => inputText[d], }, color: { type: "diverging", scheme: "rdylgn", reverse: true, }, marks: [ Plot.barY(allDists,{x: "x", y: "y", fill: "#888"}), Plot.tickY(allDists,{x: "x", y: "rawXor", stroke: "diffSign", strokeWidth: 2}), Plot.barY([idx1],{x: d => d, y1: 0, y2: 5, stroke: "#ffa", strokeWidth: 3}), Plot.barY([idx2],{x: d => d, y1: 0, y2: 5, stroke: "#ddf", strokeWidth: 3}), //Plot.ruleY([mean], {stroke: "#999"}), //Plot.text([mean], {x: idx1, y: 5, fill: "#999", dy: -5}), // Plot.text([matchedMean], {x: idx1, y: 5, fill: "#ada", dy: 15}), // Plot.text([unmatchedMean], {x: idx1, y: 5, fill: "orange", dy: 30}), Plot.text(allDists, {x: "x", y: 0, text: "y", dy: -5, fill: "#fff"}), ] }); } 37:T736,{ const ogKey = inputKey; const input = inputText; const input2 = input.split("").map((_, i) => ogKey[i%ogKey.length]).join(""); const isplit = input.split("").map((l, i) => ({l, i, z: "plaintext"})); const ksplit = input2.split("").map((l, i) => ({l, i, z: "key"})); const xors = input.split("").map((l, i) => ({l: `${input[i]}^${input2[i]}`, i, z: "xor"})); const hexsplit = input.split("").map((l, i) => ({l: lib.toHex([lib.atoi(input[i])^lib.atoi(input2[i])]), i, z: "cipher"})); const matched = isplit.filter(d => (d.i !== idx1) && ((d.i % inputKey.length) == (idx1 % inputKey.length))).map(d => ({...d, z: "same_key"})); const unmatched = isplit.filter(d => (d.i !== idx1) && ((d.i % inputKey.length) != (idx1 % inputKey.length))).map(d => ({...d, z: "diff_key"})); const data = [isplit, ksplit, matched, unmatched].flat(); return Plot.plot({ marginLeft: 80, x: {axis: false, padding: 0.05}, color: { scheme: "warm", // opacity: 0.2, }, // color: { // domain: ["plaintext", "key", "xor", "cipher"], // range: ["darkgreen", "steelblue", "grey", "orange"], // }, y: { domain: ["plaintext", "key", "same_key", "diff_key"], label: "", padding: 0.2 }, height: 150, // padding: {top: 0}, marks: [ //Plot.cellX([idx1], {x: d=> d, fill: "#ffa"}), //Plot.cellX([idx2], {x: d=> d, fill: "#ddf"}), Plot.cell( data, {"x": "i", y: "z", stroke: "#aaa", //alpha: 0.2, opacity: 0.4, fill: d => { // if (d.z === "plaintext") { return "#fff"} return d.i % inputKey.length; } }), Plot.text(data, { x: "i", y: "z", text: "l", fontSize: "10pt", title: "l", // stroke: "#000", // fill: (d) => ((d.z == "key") ? "steelblue" : "darkgreen"), }) ], }) }38:T49a,//hams = letters.split("").map(l => hammingDist(lib.atoi(letters[let1]), lib.atoi(l))) { return Plot.plot({ height: 100, y: {domain: [0,5]}, color: { domain: ["same_key", "diff_key"], range: ["green", "orange"], legend: true, }, x: { // domain: [0, inputText.length-1], // range: inputText.split(""), label: null, tickFormat: d => inputText[d], }, marks: [ Plot.tickY(groupedDists.flat, {x: "i", y: "mean", stroke: "match"}), // Plot.barY(allDists,{x: "x", y: "y", fill: "#888"}), // Plot.barY([idx1],{x: d => d, y1: 0, y2: 5, stroke: "#ffa", strokeWidth: 3}), // Plot.barY([idx2],{x: d => d, y1: 0, y2: 5, stroke: "#ddf", strokeWidth: 3}), // Plot.ruleY([mean], {stroke: "#999"}), // Plot.text([mean], {x: idx1, y: 5, fill: "#999", dy: -5}), Plot.text([groupedDists.flat[idx1*2], groupedDists.flat[idx1*2+ 1]], {x: idx1, y: "mean", fill: "match", text: "mean"}), //Plot.text([unmatchedMean], {x: idx1, y: 5, fill: "orange", dy: 30}), //Plot.text(allDists, {x: "i", y: "mean", text: "mean", dy: d => (d.match) ? -5 : -20}), ] }); } 39:T83f,//hams = letters.split("").map(l => hammingDist(lib.atoi(letters[let1]), lib.atoi(l))) { let mm = d3.mean(groupedDists.grouped.map(d => d.matchMean)); let umm = d3.mean(groupedDists.grouped.map(d => d.notMatchMean)); let overall = { matchMean: mm, notMatchMean: umm, }; return Plot.plot({ height: 200, y: {domain: [0,5]}, color: { type: "diverging", scheme: "rdylgn", reverse: true, }, x: { domain: ["diff_key", "same_key"] }, facet: {}, // x: { // // domain: [0, inputText.length-1], // // range: inputText.split(""), // label: null, // tickFormat: d => inputText[d], // }, marks: [ Plot.dot([groupedDists.grouped[idx1]], { x: () => "same_key", y: "matchMean", fill: d => d.matchMean - d.notMatchMean, }), Plot.dot([groupedDists.grouped[idx1]], { x: () => "diff_key", y: "notMatchMean", fill: d => d.matchMean - d.notMatchMean, }), Plot.link(groupedDists.grouped, { x1: () => "diff_key", x2: () => "same_key", y1: "notMatchMean", y2: "matchMean", stroke: d => d.matchMean - d.notMatchMean, opacity: 0.5, }), Plot.link([overall], { x1: () => "diff_key", x2: () => "same_key", y1: "notMatchMean", y2: "matchMean", stroke: d => d.matchMean - d.notMatchMean, strokeWidth: 4, markerEnd: "arrow" }), // Plot.barY(allDists,{x: "x", y: "y", fill: "#888"}), // Plot.barY([idx1],{x: d => d, y1: 0, y2: 5, stroke: "#ffa", strokeWidth: 3}), // Plot.barY([idx2],{x: d => d, y1: 0, y2: 5, stroke: "#ddf", strokeWidth: 3}), // Plot.ruleY([mean], {stroke: "#999"}), // Plot.text([mean], {x: idx1, y: 5, fill: "#999", dy: -5}), //Plot.text([matchedMean], {x: idx1, y: 5, fill: "#ada", dy: 15}), //Plot.text([unmatchedMean], {x: idx1, y: 5, fill: "orange", dy: 30}), //Plot.text(allDists, {x: "i", y: "mean", text: "mean", dy: d => (d.match) ? -5 : -20}), ] }); } 3a:T463,exText1 = "Call me Ishmael. Some years ago--never mind how long precisely--having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world. It is a way I have of driving off the spleen, and regulating the circulation. Whenever I find myself growing grim about the mouth; whenever it is a damp, drizzly November in my soul; whenever I find myself involuntarily pausing before coffin warehouses, and bringing up the rear of every funeral I meet; and especially whenever my hypos get such an upper hand of me, that it requires a strong moral principle to prevent me from deliberately stepping into the street, and methodically knocking people's hats off--then, I account it high time to get to sea as soon as I can. This is my substitute for pistol and ball. With a philosophical flourish Cato throws himself upon his sword; I quietly take to the ship. There is nothing surprising in this. If they but knew it, almost all men in their degree, some time or other, cherish very nearly the same feelings towards the ocean with me."3b:T463,cipher2 = "Call me Ishmael. Some years ago--never mind how long precisely--having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world. It is a way I have of driving off the spleen, and regulating the circulation. Whenever I find myself growing grim about the mouth; whenever it is a damp, drizzly November in my soul; whenever I find myself involuntarily pausing before coffin warehouses, and bringing up the rear of every funeral I meet; and especially whenever my hypos get such an upper hand of me, that it requires a strong moral principle to prevent me from deliberately stepping into the street, and methodically knocking people's hats off--then, I account it high time to get to sea as soon as I can. This is my substitute for pistol and ball. With a philosophical flourish Cato throws himself upon his sword; I quietly take to the ship. There is nothing surprising in this. If they but knew it, almost all men in their degree, some time or other, cherish very nearly the same feelings towards the ocean with me."3c:T59f,hamsCross = { const alpha = lower; let l1 = alpha[lo1]; let l2 = alpha[lo2]; // let k1 = alpha[lok1]; // let k2 = alpha[lok1]; const gridSize = alpha.length; let r = []; for (let i = 0; i < gridSize; i += 1) { for (let j = 0; j < gridSize; j += 1) { let k1 = alpha[i]; let k2 = alpha[j]; let sum = 0; for (let li = 0; li < gridSize; li += 1) { let lc = alpha[li]; sum += hammingDist(lib.atoi(l1)^lib.atoi(k1), lib.atoi(lc)^lib.atoi(k2)); } let avg = sum/gridSize; let sum2 = 0; for (let let1 = 0; let1 < gridSize; let1 += 1) { let lc1 = alpha[let1]; let sum1 = 0; for (let let2 = 0; let2 < gridSize; let2 += 1) { let lc2 = alpha[let2]; sum1 += hammingDist(lib.atoi(lc1)^lib.atoi(k1), lib.atoi(lc2)^lib.atoi(k2)); } sum2 += sum1/gridSize; } let avg2 = sum2/gridSize; r.push({ x: k1, y: k2, ham: hammingDist(lib.atoi(k1), lib.atoi(k2)), l2: hammingDist(lib.atoi(l1)^lib.atoi(k1), lib.atoi(l2)^lib.atoi(k2)), l1avg: avg, lstaravg: avg2, }); } } // let r = []; // for (let i = start; i <= end; i += 1) { // r.push(hammingDist(97, i)); // } return r; // } // return alpha.split("").map(k2 => {return {k2, score: hammingDist(lib.atoi(l1) ^ lib.atoi(k1), lib.atoi(l2) ^ lib.atoi(k2))}}) }3d:T72a,{ const ogKey = inputKey; const input = inputText; const input2 = input.split("").map((_, i) => ogKey[i%ogKey.length]); const height = 150; const rectWidth = 30; // const const r = []; for (let i = 0; i < input.length; i++) { r.push({txt: input[i], x: i, y: 0, color: 'green'}); } for (let i = 0; i < input2.length; i++) { r.push({txt: input2[i], x: i, y: 1, color: 'steelblue'}); } for (let i = 0; i < input2.length; i++) { r.push({txt: `${input[i]}^${input2[i]}`, x: i, y: 2, color: 'gray'}); } const toHex = (x) => { let hex = x.toString(16); if (hex.length == 1) { hex = "0" + hex;} return hex } for (let i = 0; i < input2.length; i++) { r.push({txt: toHex(atoi(input[i]) ^ atoi(input2[i])), x: i, y: 3, color: 'orange'}); } const svg = d3.create("svg") .attr("viewBox", [0, 0, width, height]); const x = d3.scaleLinear() .domain([0, input.length]) .range([0, input.length*(rectWidth)]); // const x = d3.scaleBand() // .domain([0, input.length]) // .rangeRound([margin.left, width - margin.right]) // .padding(0.1) const y = d3.scaleLinear() .domain([0, 4]) .range([margin.top, margin.top + rectWidth*5]) svg.append("g") .selectAll("rect") .data(r) .join("rect") .attr("x", d => x(d.x)) .attr("width", rectWidth) .attr("y", d => y(d.y) - (rectWidth/2)) .attr("height", rectWidth) .attr('fill','none') .attr('stroke', '#aaa') svg.append("g") .selectAll("text") .data(r) .join('text') .text(d => d.txt) .attr('font-size', d => ((d.y == 2) ? "10pt": undefined)) .attr('fill', d => d.color) .attr("x", d => x(d.x) + 5) .attr("y", d => y(d.y)+(rectWidth*.25)) ; return svg.node() }3e:[] 2f:{"title":"Breaking repeated XOR: Determining key length","cells":[{"id":0,"value":"md`# Breaking repeated XOR: Determining key length\n\n\n\n\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":797,"value":"md`This problem comes from 1.6 of Cryptopals: https://cryptopals.com/sets/1`","pinned":false,"hidden":false,"mode":"ojs"},{"id":758,"value":"md`\n## What is repeated XOR?\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1094,"value":"viewof inputText = Inputs.text({maxlength: 16, value: \"Yellow submarine\", label: \"input\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1093,"value":"viewof inputKey = Inputs.text({minlength: 1, maxlength: 8, value: \"key\", label: \"key\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1439,"value":"binders = {\n return {\n plaintext: () => {\n return Inputs.bind(Inputs.text({maxlength: 16, value: \"Yellow submarine\", label: \"input\"}), viewof inputText); \n },\n key: () => {\n return Inputs.bind(Inputs.text({minLenght: 1, maxlength: 8, value: \"key\", label: \"key\"}), viewof inputKey) \n },\n idx1: () => {\n return Inputs.bind(Inputs.range([0, inputText.length - 1], {label: \"index1\", step: 1}), viewof idx1)\n }\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1107,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":787,"value":"md`\nThe first line in green is the text we want to encrypt. Our key in this case is literally \\`${inputKey}\\`. We repeat our key as many times as we need, and we XOR each character of the cipher with the corresponding character in the repeated key string.\n\nThen to decrypt, we XOR it again, and we get the value back.\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1196,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":1214,"value":"$33","pinned":false,"hidden":false,"mode":"md"},{"id":1260,"value":"n*\\vert\\vert cipher \\vert\\vert*\\sum_{k=1}^{n} k*256*60\n\n\\\\\n\nn*\\vert\\vert cipher \\vert\\vert* \\frac{n(n-1)}{2}*256*60","pinned":false,"hidden":false,"mode":"tex"},{"id":1246,"value":"The method described in the challenge reduces the number of key lengths to try to about 4. However it requires some work for XORing, but on the order of the number of blocks you try XORing which is about 3.","pinned":false,"hidden":false,"mode":"md"},{"id":1296,"value":"n*3n + 4*\\vert\\vert cipher \\vert\\vert* 4*256*60","pinned":false,"hidden":false,"mode":"tex"},{"id":1313,"value":"operationsNeeded = {\n const cipherLen = 3000;\n const maxN = 50;\n const bytesToTry = 256;\n const freqMag = 60;\n \n let brute = [...Array(maxN).keys()].map(i => ({\n ops: i*cipherLen*bytesToTry*freqMag*(i*(i-1)/2),\n strategy: \"brute\",\n maxKeyLength: i,\n })).slice(2);\n \n let withKeyLen = [...Array(maxN).keys()].map(i => ({\n ops: (i*i*3 + 4*4*cipherLen*bytesToTry*freqMag),\n strategy: \"withKeyLen\",\n maxKeyLength: i,\n })).slice(2);\n \n\n return brute.concat(withKeyLen);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1380,"value":"The graphs below make it clear that the operations required are _substantially_ less if we can get the key length.","pinned":false,"hidden":false,"mode":"md"},{"id":1220,"value":"{\n return Plot.plot({\n height: 200,\n y: {tickFormat: \"3,s\", label: \"operations required to brute force\"},\n x: {label: \"maximum key length explored\"},\n marks: [\n Plot.lineY(operationsNeeded, {x: 'maxKeyLength', y: 'ops', stroke: \"strategy\"}), \n ],\n title: \"operations required vs. key kength explored\"\n });\n\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1325,"value":"{\n return Plot.plot({\n height: 200,\n y: {tickFormat: \"3,s\", label: \"operations required to brute force\"},\n x: {label: \"maximum key length explored\"},\n // facet: {data: operationsNeeded, y: \"strategy\"},\n marks: [\n Plot.lineY(operationsNeeded.filter(d => d.strategy == \"withKeyLen\"), {x: 'maxKeyLength', y: 'ops', stroke: \"orange\"}), \n ]\n });\n\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1375,"value":"## How do we guess the key length?\n\nThat's great it would save us time, but how do we actually go about it?\n\nThe challenge suggests checking different lengths and sorting based on the average Hamming distance between a few chunks of that size (let's say 3 chunks). What does that look like?\n\nFirst we'll look at the hamming distance between two characters.","pinned":false,"hidden":false,"mode":"md"},{"id":1427,"value":"Inputs.bind(Inputs.text({maxlength: 16, value: \"Yellow submarine\", label: \"input\"}), viewof inputText)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1431,"value":"Inputs.bind(Inputs.text({minLenght: 1, maxlength: 8, value: \"key\", label: \"key\"}), viewof inputKey) ","pinned":false,"hidden":false,"mode":"ojs"},{"id":1399,"value":"viewof idx1 = Inputs.range([0, inputText.length - 1], {label: \"index\", step: 1, value: 0})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1456,"value":"viewof idx2 = Inputs.range([0, inputText.length - 1], {label: \"index2\", step: 1})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1402,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"},{"id":859,"value":"{\n let c1 = inputText[idx1];\n let c2 = inputText[idx2];\n\n let i1 = lib.atoi(c1);\n let i2 = lib.atoi(c2);\n \n let arr1 = toBinArr(lib.atoi(c1));\n let arr2 = toBinArr(lib.atoi(c2));\n\n let xor = i1 ^ i2;\n\n let xArr = toBinArr(xor);\n\n let ham = hammingDist(i1, i2);\n\n let bitColor = (b, i) => (xArr[i] == 1) ? 'black' : 'lightgray';\n\n let makeSpan = (arr) => arr.map((bit, i) => `${bit}`).join(\"\");\n \n\n let l1 = makeSpan(arr1);\n let l2 = makeSpan(arr2);\n\n return html`\n

\n${c1}: ${l1}
\n${c2}: ${l2}\n\n

\n
\nHamming distance: ${ham}\n\n`\n \n\n\n \n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1702,"value":"In the next chart, you can see the graph of the hamming distance between the first character, and every other character in the plaintext input, with the average as a line to highlight whether each character is above or below average. The selected characters are highlighted.","pinned":false,"hidden":false,"mode":"md"},{"id":1487,"value":"//hams = letters.split(\"\").map(l => hammingDist(lib.atoi(letters[let1]), lib.atoi(l)))\n{ \n const l1 = inputText[idx1];\n const allDists = inputText.split(\"\").map((l, i) => ({x: i, y: hammingDist(lib.atoi(l1), lib.atoi(l))}));\n\n const mean = d3.mean(allDists.map(d => d.y));\n\n return Plot.plot({\n height: 100,\n y: {domain: [0,5]},\n x: {\n // domain: [0, inputText.length-1],\n // range: inputText.split(\"\"),\n label: null,\n tickFormat: d => inputText[d],\n },\n marks: [\n\n\n\n Plot.barY(allDists,{x: \"x\", y: \"y\", fill: \"#888\"}),\n Plot.barY([idx1],{x: d => d, y1: 0, y2: 5, stroke: \"#ffa\", strokeWidth: 3}),\n Plot.barY([idx2],{x: d => d, y1: 0, y2: 5, stroke: \"#ddf\", strokeWidth: 3}),\n\n Plot.ruleY([mean], {stroke: \"#999\"}),\n Plot.text([mean], {x: idx1, y: d => d, fill: \"#999\", dy: -5}),\n\n\n Plot.text(allDists, {x: \"x\", y: 0, text: \"y\", dy: -5, fill: \"#fff\"})\n\n ]\n });\n\n}\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":1436,"value":"Next, we'll consider the encrypted text. Below we have the plaintext lined up with the corresponding key character it is XOR'd with in the cipher text. And then just below that is the binary version of the cipher text at the first index and the second index along with the differing bits highlighted and the corresponding hamming distance.","pinned":false,"hidden":false,"mode":"md"},{"id":1454,"value":"$35","pinned":false,"hidden":false,"mode":"ojs"},{"id":972,"value":"{\n let c1 = inputText[idx1];\n let c2 = inputKey[idx1 % inputKey.length];\n\n let c3 = inputText[idx2];\n let c4 = inputKey[idx2 % inputKey.length];\n\n let i1 = lib.atoi(c1) ^ lib.atoi(c2);\n let i2 = lib.atoi(c3) ^ lib.atoi(c4);\n \n let arr1 = toBinArr(i1);\n let arr2 = toBinArr(i2);\n\n let xor = i1 ^ i2;\n\n let xArr = toBinArr(xor);\n\n let ham = hammingDist(i1, i2);\n\n let bitColor = (b, i) => (xArr[i] == 1) ? 'black' : 'lightgray';\n\n let makeSpan = (arr) => arr.map((bit, i) => `${bit}`).join(\"\");\n \n\n let l1 = makeSpan(arr1);\n let l2 = makeSpan(arr2);\n\n return html`\n

\n${c1}^${c2}: ${l1}
\n${c3}^${c4}: ${l2}\n\n\n

\n
\nHamming distance: ${ham}\n\n`\n \n\n\n \n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1714,"value":"This next chart again shows the hamming distances between the ciphertext at the first index and each other character in the ciphertext. There's also a line indicating what the plaintext hamming distance was. If the hamming distance increased from plaintext to ciphertext, the line is green. If the hamming distance decreased when comparing the ciphertext, it's colored red.\n\n","pinned":false,"hidden":false,"mode":"md"},{"id":1545,"value":"$36","pinned":false,"hidden":false,"mode":"ojs"},{"id":1827,"value":"Now trying to use the method described in the challenge, we take chunks of a certain keySize, get the hamming distance between it and the next chunk of that size. The key size that has the minimum hamming distance is the best guess for our key size.\n\nHowever, when we try with short keys, this doesn't work! For example, if we use `key`, on the original text of `Yellow submarine`, the correct key size is 3, but it's second to last in our ranking based on this method. Try out some different keys to see for yourself. (The bars are sorted to the \"best guess\" is the furthest left).","pinned":false,"hidden":false,"mode":"md"},{"id":1772,"value":"Plot.plot({\n height: 200,\n padding: 0.25,\n // x: {domain:[0,5]},\n marks: [\n Plot.barY(keyLenGuess, {x: \"keySize\", y: \"avgHam\", sort: {x: \"y\"}, fill: (d) => (\n (d.keySize == inputKey.length) ? \"#afa\" : \"#888\") \n }),\n // Plot.ruleY([0])\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2664,"value":"binders.plaintext()","pinned":false,"hidden":false,"mode":"ojs"},{"id":1821,"value":"binders.key()","pinned":false,"hidden":false,"mode":"ojs"},{"id":1716,"value":"## Comparing by key length\n\nTo see why this doesn't work, we can compare the average hamming distances between ciphertext characters that had the same key character vs. those that were XOR'd with a different key character.\n\nThe technique we're using relies on the hamming distance when you look at matching key characters to be less than when there's a key mismatch. The intuition is that when you have matching key characters, the key character \"drops out\". That means that you're getting the hamming distance between the corresponding plaintext characters, which in theory should be less than the hamming distance where the key character doesn't \"drop out\".","pinned":false,"hidden":false,"mode":"md"},{"id":1626,"value":"Inputs.bind(Inputs.text({minLenght: 1, maxlength: 8, value: \"key\", label: \"key\"}), viewof inputKey) ","pinned":false,"hidden":false,"mode":"ojs"},{"id":1646,"value":"binders.idx1()","pinned":false,"hidden":false,"mode":"ojs"},{"id":1598,"value":"$37","pinned":false,"hidden":false,"mode":"ojs"},{"id":1631,"value":"$38","pinned":false,"hidden":false,"mode":"ojs"},{"id":1831,"value":"In the graph below, we check for each ciphertext character whether it gains or loses hamming distance on average based on whether it matches up with a character that had the same key. The overall average is represented with an arrow. Red lines have a greater hamming distance when they have the same key, green lines have a lower hamming distance when they have the same key.\n\nIf the cipher text and the key text are the same \"character set\", i.e. you use a lot of lower case ascii characters in both, you'll end up with not a very consistent lowering. However, if you use a some symbols, you'll end up with a better result.\n\nHowever, even so, you might not get the keysize guess right.","pinned":false,"hidden":false,"mode":"md"},{"id":1666,"value":"$39","pinned":false,"hidden":false,"mode":"ojs"},{"id":1844,"value":"binders.plaintext()","pinned":false,"hidden":false,"mode":"ojs"},{"id":1837,"value":"binders.key()","pinned":false,"hidden":false,"mode":"ojs"},{"id":1841,"value":"Plot.plot({\n height: 100,\n padding: 0.25,\n // x: {domain:[0,5]},\n marks: [\n Plot.barY(keyLenGuess, {x: \"keySize\", y: \"avgHam\", sort: {x: \"y\"}, fill: (d) => (\n (d.keySize == inputKey.length) ? \"#afa\" : \"#888\") \n }),\n // Plot.ruleY([0])\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1849,"value":"Below, I'm looking at longer cipher texts and longer keys with more blocks. I've taken an excerpt from Moby Dick as the plaintext. To create a key of arbitrary length, I take text off the back end of the excerpt.\n\nYou can see that for longer key lengths, the technique works well, and for shorter keys not so well. The super interesting ones are actually when you're looking at 5 blocks, you get a weird upticks around 44 characters. You can bump it up to 7 blocks and it tapers off (although 24 is still really up there for some reason).","pinned":false,"hidden":false,"mode":"md"},{"id":1877,"value":"viewof keyLength = Inputs.range([3, 80], {label: \"key length\", step: 1, value: 3})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1918,"value":"viewof numBlocks = Inputs.range([1, 10], {label: \"num blocks\", step: 1, value: 3})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1861,"value":"$3a","pinned":false,"hidden":false,"mode":"ojs"},{"id":1886,"value":"exKey1 = {\n const offset = -20 - keyLength;\n const startIdx = exText1.length + offset;\n\n return exText1.slice(startIdx, startIdx + keyLength)\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1906,"value":"Plot.plot({\n height: 100,\n x: { axis: false},\n // x: {domain:[0,5]},\n marks: [\n Plot.barY(keyLenGuessEx2, {x: \"keySize\", y: \"avgHam\", sort: {x: \"y\"}, fill: (d) => (\n (d.keySize == exKey1.length) ? \"#afa\" : \"#888\") \n }),\n // Plot.ruleY([0])\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1950,"value":"Plot.plot({\n width: width,\n height: 100,\n x: { \n // type: \"log\",\n ticks: 20,\n // tickFormat: \",s\"\n },\n // x: { axis: false},\n // x: {domain:[0,5]},\n marks: [\n Plot.dotY(keyRanks, {x: \"keySize\", y: \"correctRank\"}),\n // Plot.ruleY([0])\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":360,"value":"md` \n## Hand picking keys\n\nWe can try two key strategies beyond ascii text\n1. Hand selected 3 byte key for maximum hamming distance between key characters\n2. Randomly generated byte key\n\nFor each key strategy, there's a graph below that shows how the key picking does well.\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":611,"value":"$3b","pinned":false,"hidden":false,"mode":"ojs"},{"id":674,"value":"md`\n### Hand picked key\n\nThis key is hand picked to have a lot of hamming distance between its characters. It's distance between its first 3 characters are: ${hamDistKeys(key1).join(',')}\n\nWe can see in the graph that 3 shows up fairly low, but it's multiples of 3 that really highlitht it with 9 being the lowest. This would be okay for our purposes, since a key of length 9 would just be our length-3 key repeated 3 times. It would just result in smaller \"samples\" when we split up the text for anaylsis (since with length 3 we'd have 3 buckets and length 9 we'd have 9 buckets).\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":393,"value":"hamDistKeys = (arr) => {\n return [\n hammingDist(arr[0], arr[1]),\n hammingDist(arr[0], arr[2]),\n hammingDist(arr[1], arr[2]),\n ]\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":363,"value":"key1 = [ \n 0b11100000,\n 0b00011100,\n 0b00000011,\n]","pinned":true,"hidden":false,"mode":"ojs"},{"id":567,"value":"Plot.plot({\n // color: {\n // type: \"diverging\",\n // scheme: \"viridis\"\n // },\n marks: [\n Plot.barX(k1KeySizeGuesses,\n {x: \"avgHam\", y: \"keySize\", \n fill: (d) => {\n if (d.keySize == key1.length) {\n return \"#3a3\";\n }\n\n if (d.keySize % key1.length === 0) {\n return \"#ddd\";\n }\n \n return \"#99d\";\n },\n })\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":691,"value":"md`\n### Random bytes as a key\n\nIn this example, we select random bytes as a key to help show how things change as we shift the key length up and down. Our algorithm does pretty well regardless of keysize here.\n`\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":660,"value":"viewof n = Inputs.range([1, 19], {label: \"keySize\", step: 1, value: 8})","pinned":false,"hidden":false,"mode":"ojs"},{"id":623,"value":"key3 = {\n // const n = 12;\n let r = [];\n for (let i = 0; i < n; i++) {\n r.push(Math.round(Math.random()*255))\n }\n return r;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":632,"value":"Plot.plot({\n // color: {\n // type: \"diverging\",\n // scheme: \"viridis\"\n // },\n color: {\n domain: [\"match\", \"notmatch\"],\n range: [\"darkgreen\", \"gray\"]\n },\n marks: [\n // Plot.barX(k3KeySizeGuesses, {x: \"avgHam\", y: \"keySize\", fill: d => d.avgHam}),\n Plot.barX(k3KeySizeGuesses, {x: \"avgHam\", y: \"keySize\",\n // fill: d => d.avgHam,\n fill: (d) => {\n return ((d.keySize % key3.length) == 0) ? 'match' : 'notmatch';\n }\n })\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":539,"value":"k1KeySizeGuesses = manyChunkedHams(encryptRaw(cipher2, key1))","pinned":false,"hidden":false,"mode":"ojs"},{"id":629,"value":"k3KeySizeGuesses = manyChunkedHams(encryptRaw(cipher2, key3))","pinned":false,"hidden":false,"mode":"ojs"},{"id":1851,"value":"# Why does it work at all with ascii characters?\n\nRandom bytes showed how this worked well, but I had this confusion around why it even worked at all on ascii characters.\n\nBelow I restricted the problem to lowercase letters. I then started with, what's the hamming distance of every letter against every other letter. My goal was to understand does the \"key drop out\" reliably?","pinned":false,"hidden":false,"mode":"md"},{"id":975,"value":"letters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":998,"value":"lower = \"abcdefghijklmnopqrstuvwxyz\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":2632,"value":"Plot.plot({\n width: 260,\n height: 240,\n x: {label: null},\n y: {label: null},\n color: {\n legend: true,\n type: \"linear\",\n scheme: \"burd\",\n // domain: [2.4, 3.5],\n },\n marks: [\n Plot.cell(hamsCross, {x: \"x\", y: \"y\", fill: \"ham\"})\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":2654,"value":"Next, we pick a specific letter, and do the hamming distance of the X letter with letter2^(every other letter).\n\nLooking at the top left corner, with letter2=a, you get 0 (i.e. a^a^a is all 0's). Then if you shift it to b, you get: a^a^b has 1 bit difference, and so on.","pinned":false,"hidden":false,"mode":"md"},{"id":1016,"value":"viewof lo2 = Inputs.range([0, lower.length - 1], {label: \"letter2\", step: 1, value: 0})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2641,"value":"Plot.plot({\n width: 260,\n height: 240,\n x: {label: null},\n y: {label: null},\n color: {\n legend: true,\n type: \"linear\",\n scheme: \"burd\",\n // domain: [2.4, 3.5],\n },\n marks: [\n Plot.cell(hamsCross, {x: \"x\", y: \"y\", fill: \"l2\"})\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":1087,"value":"$3c","pinned":false,"hidden":false,"mode":"ojs"},{"id":2658,"value":"This next one let's us pick 4 letters $x^letter1 vs. $y^{all letters} and gives you the average over all letters in the cell. This tells you that if one of your keys is a, the top left -> bottom right diagonal is when the \"key drops out\" and that's the average hamming distance you'll get when you compare. This shows that the key dropping out works better for some letters than others (and really badly for z!).","pinned":false,"hidden":false,"mode":"md"},{"id":1013,"value":"viewof lo1 = Inputs.range([0, lower.length - 1], {label: \"letter1\", step: 1, value: 0})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1387,"value":"Plot.plot({\n width: 260,\n height: 240,\n x: {label: null},\n y: {label: null},\n color: {\n legend: true,\n type: \"linear\",\n scheme: \"burd\",\n // domain: [2.4, 3.5],\n },\n marks: [\n Plot.cell(hamsCross, {x: \"x\", y: \"y\", fill: \"l1avg\"})\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":2661,"value":"This final one averages all the cells you can explore in the previous one. You can see how the bands narrow here significantly. We're ranging from 2.47 to 2.53 here, so not a huge difference. However, there is a difference, and along that diagonal, you will, on average, get a lower hamming distance. That means even in the all lower ascii character case, you can expect to the hamming distance strategy to work okay with big enough blocks and cipher text length.\n\nThis doesn't take into account the actual distribution of characters (i.e. ETOIAINSHRDLU), and there will be degenerate cases, but this was enough for me to convince myself that I understood why it was working.","pinned":false,"hidden":false,"mode":"md"},{"id":1083,"value":"Plot.plot({\n width: 260,\n height: 240,\n x: {label: null},\n y: {label: null},\n color: {\n legend: true,\n type: \"linear\",\n scheme: \"burd\",\n // domain: [2.4, 3.5],\n },\n marks: [\n Plot.cell(hamsCross, {x: \"x\", y: \"y\", fill: \"lstaravg\"})\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":822,"value":"## Breaking the provided example\n\nSee the 1.6 Example for a briefer dive into getting the key length for the actual problem:\nhttps://observablehq.com/@pcarleton/cryptopals-1-6?collection=@pcarleton/cryptopals","pinned":false,"hidden":false,"mode":"md"},{"id":855,"value":"## Appendix","pinned":false,"hidden":false,"mode":"md"},{"id":1749,"value":"keyLenGuess= manyChunkedHams2(encrypt(inputText, inputKey), 8)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1662,"value":"groupedDists = {\n\n const byD = [];\n const allDists = inputText.split(\"\").map((l1, i) => {\n const singleDists = inputText.split(\"\").map((l2, j) => {\n if (i == j) {\n return undefined;\n };\n return {\n match: (i % inputKey.length) == (j % inputKey.length),\n hd: hammingDist(\n lib.atoi(l1)^lib.atoi(inputKey[i % inputKey.length]),\n lib.atoi(l2)^lib.atoi(inputKey[j % inputKey.length])\n ) \n }\n }).filter(d => d !== undefined);\n\n let notMatchMean = d3.mean(singleDists.filter(d => !d.match).map(d => d.hd));\n let matchMean = d3.mean(singleDists.filter(d => d.match).map(d => d.hd));\n\n let ki = i % inputKey.length;\n byD.push({i, ki, matchMean, notMatchMean});\n\n return [\n {i, ki, mean: notMatchMean, match: \"diff_key\"},\n {i, ki, mean: matchMean, match: \"same_key\"},\n ]\n\n }).flat();\n\n return {flat: allDists, grouped: byD};\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1932,"value":"getKey = (keylen) => {\n const offset = -20 - keylen;\n const startIdx = exText1.length + offset;\n\n return exText1.slice(startIdx, startIdx + keylen)\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1899,"value":"exCipher1 = encrypt(exText1, exKey1);","pinned":false,"hidden":false,"mode":"ojs"},{"id":1873,"value":"keyLenGuessEx2 = {\n return manyChunkedHams3(exCipher1, 100, numBlocks).sort((a, b) => a.avgHam - b.avgHam)\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1925,"value":"keyRanks = {\n const result = [];\n\n for (let i = 3; i < 80; i += 1) {\n const tempKey = getKey(i);\n const tempCipher = encrypt(exText1, tempKey);\n const guesses = manyChunkedHams3(tempCipher, 100, numBlocks).sort((a, b) => a.avgHam - b.avgHam);\n let found;\n guesses.map((d, j) => {\n if (d.keySize == i) {\n result.push({\n keySize: i,\n correctRank: j,\n });\n }\n })\n \n }\n\n return result;\n\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1909,"value":"manyChunkedHams3 = (bs, maxKey, numBlocks) => {\n let hams = [];\n \n for (let i = 1; i < maxKey; i += 1) {\n hams.push({keySize: i, avgHam: avgHamBySize(bs, i, numBlocks)});\n }\n \n return hams\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1912,"value":"avgHamBySize = (bs, chunkSize, numChunkPairs) => {\n \n let chunks = chunkArr(bs, chunkSize);\n\n let sum = 0;\n for (let i = 0; i < numChunkPairs; i += 1) {\n sum += chunkHam(chunks[i], chunks[i+1]);\n }\n\n return sum / numChunkPairs;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1755,"value":"manyChunkedHams2 = (bs, maxKey) => {\n let hams = [];\n \n for (let i = 1; i < maxKey; i += 1) {\n hams.push({keySize: i, avgHam: ham1Chunk(bs, i)});\n }\n \n return hams\n}\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":1764,"value":"ham1Chunk = (bs, chunkSize) => {\n \n let chunks = chunkArr(bs, chunkSize);\n \n let r1 = chunkHam(chunks[0], chunks[1]);\n \n return r1;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":281,"value":"avgHam = (bs, chunkSize) => {\n \n let chunks = chunkArr(bs, chunkSize);\n \n let r1 = chunkHam(chunks[0], chunks[1]);\n let r2 = chunkHam(chunks[2], chunks[3]);\n let r3 = chunkHam(chunks[4], chunks[5]);\n \n return (r1 + r2 + r3) / 3;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":252,"value":"manyChunkedHams = (bs) => {\n let hams = [];\n \n for (let i = 1; i < Math.min(bs.length / 3, 20); i += 1) {\n hams.push({keySize: i, avgHam: avgHam(bs, i)});\n }\n \n return hams\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":727,"value":"chunkHam = (c1, c2) => {\n let r = 0;\n for (let i = 0; i < c2.length; i += 1) {\n r += hammingDist(c1[i], c2[i]);\n }\n return r/c2.length;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":420,"value":"margin = ({top: 20, right: 20, bottom: 30, left: 40})","pinned":false,"hidden":false,"mode":"ojs"},{"id":37,"value":"charToBinArr = (s) => {\n if (s.length > 1) {\n throw 'must be string of length 1';\n }\n \n return toBinArr(s.charCodeAt(0))\n}\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":7,"value":"toBinArr = (c) => { \n if (c > 255) {\n throw 'must be 8 bit byte';\n }\n \n let result = [];\n \n result[7] = (c & 1) > 0 ? 1 : 0; \n result[6] = (c & 2) > 0 ? 1 : 0; \n result[5] = (c & 4) > 0 ? 1 : 0; \n result[4] = (c & 8) > 0 ? 1 : 0; \n result[3] = (c & 16) > 0 ? 1 : 0; \n result[2] = (c & 32) > 0 ? 1 : 0; \n result[1] = (c & 64) > 0 ? 1 : 0; \n result[0] = (c & 128) > 0 ? 1 : 0; \n \n return result;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":26,"value":"fromBinArr = (x) => {\n let result = 0;\n \n for (let i = 0; i < 8; i += 1) {\n result |= x[7 - i] << i\n }\n \n return result;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":42,"value":"charFromBinArr = (a) => {\n return String.fromCharCode(fromBinArr(a));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":54,"value":"count1s = (x) => {\n return toBinArr(x).reduce((acc, x) => acc + x, 0);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":71,"value":"chr = (x) => String.fromCharCode(x)","pinned":false,"hidden":false,"mode":"ojs"},{"id":67,"value":"hammingDist = (a, b) => {\n return count1s(a ^ b);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":193,"value":"chunkString = (str, len) => {\n return str.match(new RegExp('.{1,' + len + '}', 'g'))\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":234,"value":"chunkArr = (arr, chunkSize) => {\n let chunks = [];\n \n for (let i = 0; i < arr.length; i += chunkSize) {\n chunks.push(arr.slice(i, i+chunkSize));\n }\n \n return chunks;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":239,"value":"strToArr = (s) => {\n let r = [];\n for (let i = 0; i < s.length; i += 1) {\n r.push(s.charCodeAt(i));\n }\n return r\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":242,"value":"arrToStr = (arr) => arr.map(chr).join(\"\")","pinned":true,"hidden":false,"mode":"ojs"},{"id":208,"value":"encrypt = (s, k) => {\n return encryptRaw(s, [...k].map(atoi))\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":524,"value":"encryptRaw = (s, k) => {\n let chunks = chunkString(s, k.length);\n \n let r = [];\n for (let ch of chunks) {\n for (let i = 0; i < ch.length; i += 1) {\n r.push(atoi(ch[i]) ^ k[i]);\n }\n }\n\n return r\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":215,"value":"decrypt = (arr, k) => {\n let r = [];\n for (let i =0; i < arr.length; i += k.length) {\n for (let j = 0; j < k.length; j += 1) {\n if ((i + j) >= arr.length) {\n break;\n }\n r.push(arr[i + j] ^ atoi(k[j]));\n }\n }\n \n return r\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":526,"value":"decryptRaw = (arr, k) => {\n let r = [];\n for (let i =0; i < arr.length; i += k.length) {\n for (let j = 0; j < k.length; j += 1) {\n if ((i + j) >= arr.length) {\n break;\n }\n r.push(arr[i + j] ^ k[j]);\n }\n }\n \n return r\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":862,"value":"import {lib} from \"@pcarleton/cryptopals-helpers\"","pinned":true,"hidden":false,"mode":"ojs"},{"id":130,"value":"atoi('a')","pinned":true,"hidden":false,"mode":"ojs"},{"id":121,"value":"atoi = (a) => a.charCodeAt(0)","pinned":false,"hidden":false,"mode":"ojs"},{"id":9,"value":"charFromBinArr(charToBinArr('a'))","pinned":false,"hidden":false,"mode":"ojs"},{"id":4,"value":"md`\n# Resources\n\n* [Cryptopals Problem 1.6](https://cryptopals.com/sets/1/challenges/6)\n* [Cryptography FAQ 8.2](http://www.faqs.org/faqs/cryptography-faq/part8/)\n* [Cryptanalysis A Study of Ciphers and their Solutions](https://archive.org/details/1956Cryptanalysis-AStudyOfCiphersAndTheirSolution/page/n1/mode/2up) by Helen Fouche Gaines (1944)\n* [Elementary Cryptanalysis](https://archive.org/details/elementarycrypta0000sink/page/n7/mode/2up) Sinkov 1966\n\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1177,"value":"My original implementation before I got more familiar with `Plot.cell`","pinned":false,"hidden":false,"mode":"md"},{"id":409,"value":"$3d","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W3e","stdlib":"1","titling":"auto"}