-
Notifications
You must be signed in to change notification settings - Fork 15
The New Turing Omnibus Chapter 37 Public Key Cryptography
Murray kindly volunteered to shepherd this meeting so we began by discussing "The Big Picture" and talking through his notes on the chapter.
We briefly discussed the history of cryptography prior to Public Key Cryptography; in particular, the use of frequency analysis to break substitution ciphers, recommending Simon Singh's "The Code Book" and the historic vulnerability of key exchange.
We then decided to tackle the first problem in the chapter, working through encrypting and decrypting the letter S
with a given private key.
We first derived a public key from the private key and values for w
and m
using the algorithm provided in the book. We then used only this public key to encrypt our message (the single letter S
in ASCII).
We then decrypted this message using the private key but immediately hit a problem in the algorithm: how do we calculate the modular multiplicative inverse of w
(for that is what w^-1
represents)?
Thankfully, Tom knew an algorithm to derive this from w
known as the Extended Euclidean algorithm and so he heroically took to the whiteboard to work through it for our given value of w
:
(Note the look of distant triumph.)
With this in place, we could now perform the decryption algorithm and decode our ciphertext back into the letter S
:
This involved solving a particularly easy subset-sum problem and we discussed how the particular structure of our private key (as a sequence of numbers, each one greater than the sum of all preceding it) made this easy for us to calculate. This also gave us some intuition why this particular type of subset-sum problem was proven vulnerable to an attack.
With our text decrypted, we walked through the proof that explained how we were able to derive the plain text message using our private key in terms of our public key:
Chris demonstrated his subset-sum solver written in his programming language Sentient. He discussed some of his design goals with Sentient and his progress so far.
- We raised concerns that this was a very maths-heavy chapter and that people got lost along the way;
- We suggested mixing up the chapters so that people don't get intimidated by the maths but also reiterated the importance of speaking out when stuck or confused;
- It was suggested that it would be nice if there was more collaboration outside the meetings but also discussed the trade-off that increased commitment put members off joining in the past.
Thanks to Leo and Geckoboard for hosting, Murray for shepherding, Tom for working through the Extended Euclidean algorithm on the whiteboard, Chris for his subset-sum solver and all those who contributed snacks.
- Home
- Documentation
- Choosing a Topic
- Shows & Tells
- Miscellaneous
- Opt Art
- Reinforcement Learning: An Introduction
- 10 Technical Papers Every Programmer Should Read (At Least Twice)
- 7 More Languages in 7 Weeks
- Lua, Day 1: The Call to Adventure
- Lua, Day 2: Tables All the Way Down
- Lua, Day 3
- Factor, Day 1: Stack On, Stack Off
- Factor, Day 2: Painting the Fence
- Factor, Day 3: Balancing on a Boat
- Elm, Day 1: Handling the Basics
- Elm, Day 2: The Elm Architecture
- Elm, Day 3: The Elm Architecture
- Elixir, Day 1: Laying a Great Foundation
- Elixir, Day 2: Controlling Mutations
- Elixir, Day 3: Spawning and Respawning
- Julia, Day 1: Resistance Is Futile
- Julia, Day 2: Getting Assimilated
- Julia, Day 3: Become One With Julia
- Minikanren, Days 1-3
- Minikanren, Einstein's Puzzle
- Idris Days 1-2
- Types and Programming Languages
- Chapter 1: Introduction
- Chapter 2: Mathematical Preliminaries
- Chapter 3: Untyped Arithmetic Expressions
- Chapter 4: An ML Implementation of Arithmetic Expressions
- Chapter 5: The Untyped Lambda-Calculus
- Chapters 6 & 7: De Bruijn Indices and an ML Implementation of the Lambda-Calculus
- Chapter 8: Typed Arithmetic Expressions
- Chapter 9: The Simply-Typed Lambda Calculus
- Chapter 10: An ML Implementation of Simple Types
- Chapter 11: Simple Extensions
- Chapter 11 Redux: Simple Extensions
- Chapter 13: References
- Chapter 14: Exceptions
- Chapter 15: Subtyping – Part 1
- Chapter 15: Subtyping – Part 2
- Chapter 16: The Metatheory of Subtyping
- Chapter 16: Implementation
- Chapter 18: Case Study: Imperative Objects
- Chapter 19: Case Study: Featherweight Java
- The New Turing Omnibus
- Errata
- Chapter 11: Search Trees
- Chapter 8: Random Numbers
- Chapter 35: Sequential Sorting
- Chapter 58: Predicate Calculus
- Chapter 27: Perceptrons
- Chapter 9: Mathematical Research
- Chapter 16: Genetic Algorithms
- Chapter 37: Public Key Cryptography
- Chapter 6: Game Trees
- Chapter 5: Gödel's Theorem
- Chapter 34: Satisfiability (also featuring: Sentient)
- Chapter 44: Cellular Automata
- Chapter 47: Storing Images
- Chapter 12: Error-Correcting Codes
- Chapter 32: The Fast Fourier Transform
- Chapter 36: Neural Networks That Learn
- Chapter 41: NP-Completeness
- Chapter 55: Iteration and Recursion
- Chapter 19: Computer Vision
- Chapter 61: Searching Strings
- Chapter 66: Church's Thesis
- Chapter 52: Text Compression
- Chapter 22: Minimum spanning tree
- Chapter 64: Logic Programming
- Chapter 60: Computer Viruses
- Show & Tell
- Elements of Computing Systems
- Archived pages