4 <title>Breaking keyword ciphers
</title>
5 <meta http-equiv=
"Content-Type" content=
"text/html; charset=UTF-8"/>
6 <style type=
"text/css">
15 h1 { font-size:
3em; }
16 h2 { font-size:
2em; }
17 h3 { font-size:
1.6em; }
19 text-decoration: none;
22 -moz-border-radius:
5px;
23 -web-border-radius:
5px;
31 text-shadow:
0 0 20px #
333;
37 text-shadow:
0 0 20px #
333;
46 <textarea id=
"source">
48 # Breaking keyword ciphers
50 a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z
51 --|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|--
52 k | e | y | w | o | r | d | a | b | c | f | g | h | i | j | l | m | n | p | q | s | t | u | v | x | z
56 # Duplicate and extend your `affine_break()` function
58 * How to cycle through all the keys? What _are_ all the keys?
66 * `
2013/
4a.ciphertext`
67 * `
2013/
4b.ciphertext`
69 This will take a while. Fire up a system monitor. What's wrong?
73 # Python, threads, and the GIL
75 Thread-safe shared-memory code is hard.
77 Python's Global Interpreter Lock prevents shooting yourself in the foot.
79 Where you want true parallelism, need different threads (Python processes).
81 * Thread-safe shared-memory code is hard.
83 The `multiprocessing` library makes this easier.
85 But before we get there, a couple of diversions...
91 A common task is to apply a function to each item in a sequence, returning a sequence of the results.
97 >>> map(double, [
1,
2,
3])
101 * `map()` is a higher-order function: its first argument is the function that's applied.
103 How can we use this for keyword cipher breaking?
107 # Mapping keyword decipherings
109 Define a function that takes a possible key (keyword and cipher type) and returns the key and its fitness.
111 * (Also pass in the message and the fitness function)
113 Use `map()` and `max()` to find the best key
119 How many arguments does this take?
121 How do you write a function that takes this many arguments?
127 ## Positional, keyword
129 * Common or garden parameters, as you're used to.
130 * `def keyword_encipher(message, keyword, Keyword_wrap_alphabet.from_a):`
133 * `def mean(x, *xs):`
135 First number goes in `x`, remaining go in the tuple `xs`
139 * `def myfunc(arg1=
0, **kwargs):`
141 `kwargs` will be a Dict of the remaining keywords (not `arg1`)
145 # Back to `multiprocessing`
147 What does `Pool.starmap()` do?
152 from multiprocessing import Pool
154 def keyword_break_mp(message, wordlist=keywords, fitness=Pletters, chunksize=
500):
155 helper_args = [??? for word in wordlist] # One tuple for each possible key
157 breaks = pool.starmap(keyword_break_worker, helper_args, chunksize)
158 return max(breaks, key=lambda k: k[
1])
160 def keyword_break_worker(???):
162 return (key, fitness)
165 * Gotcha: the function in `Pool.starmap()` must be defined at the top level
166 * This is definitely a
"feature"
170 # Performance and chunksize
172 Try the multiprocessing keyword break. Is it using all the resources?
174 Setting `chunksize` is an art.
176 ## Map-reduce as a general pattern for multiprocessing
179 <script src=
"http://gnab.github.io/remark/downloads/remark-0.6.0.min.js" type=
"text/javascript">
182 <script type=
"text/javascript"
183 src=
"http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML&delayStartupUntil=configured"></script>
185 <script type=
"text/javascript">
186 var slideshow = remark.create({ ratio:
"16:9" });
191 skipTags: ['script', 'noscript', 'style', 'textarea', 'pre']
194 MathJax.Hub.Queue(function() {
195 $(MathJax.Hub.getAllJax()).map(function(index, elem) {
196 return(elem.SourceElement());
197 }).parent().addClass('has-jax');
199 MathJax.Hub.Configured();