Cracking Codes with Python: An Introduction to Building and Breaking Ciphers

Brief Contents
Contents in Detail
Acknowledgments
Introduction
	Who Should Read This Book?
	What’s in This Book?
	How to Use This Book
		Typing Source Code
		Checking for Typos
		Coding Conventions in This Book
		Online Resources
	Downloading and Installing Python
		Windows Instructions
		macOS Instructions
		Ubuntu Instructions
	Downloading pyperclip.py
	Starting IDLE
	Summary
Chapter 1: Making Paper 
Cryptography Tools
	What Is Cryptography?
	Codes vs. Ciphers
	The Caesar Cipher
		The Cipher Wheel
		Encrypting with the Cipher Wheel
		Decrypting with the Cipher Wheel
		Encrypting and Decrypting with Arithmetic
	Why Double Encryption Doesn’t Work
	Summary
	Practice Questions
Chapter 2: Programming in the Interactive Shell
	Some Simple Math Expressions
		Integers and Floating-Point Values
		Expressions
		Order of Operations
		Evaluating Expressions
	Storing Values with Variables
		Overwriting Variables
		Variable Names
	Summary
	Practice Questions
Chapter 3: Strings and Writing Programs
	Working with Text Using String Values
		String Concatenation with the + Operator
		String Replication with the * Operator
		Getting Characters from Strings Using Indexes
	Printing Values with the print() Function
	Printing Escape Characters
	Quotes and Double Quotes
	Writing Programs in IDLE’s File Editor
	Source Code for the “Hello, World!” Program
	Checking Your Source Code with the Online Diff Tool
	Using IDLE to Access Your Program Later
		Saving Your Program
		Running Your Program
		Opening the Programs You’ve Saved
	How the “Hello, World!” Program Works
		Comments
		Printing Directions to the User
		Taking a User’s Input
		Ending the Program
	Summary
	Practice Questions
Chapter 4: The Reverse Cipher
	Source Code for the Reverse Cipher Program
	Sample Run of the Reverse Cipher Program
	Setting Up Comments and Variables
	Finding the Length of a String
	Introducing the while Loop
		The Boolean Data Type
		Comparison Operators
		Blocks
		The while Loop Statement
		“Growing” a String
	Improving the Program with an input() Prompt
	Summary
	Practice Questions
Chapter 5: The Caesar Cipher
	Source Code for the Caesar Cipher Program
	Sample Run of the Caesar Cipher Program
	Importing Modules and Setting Up Variables
	Constants and Variables
	The for Loop Statement
		An Example for Loop
		A while Loop Equivalent of a for Loop
	The if Statement
		An Example if Statement
		The else Statement
		The elif Statement
	The in and not in Operators
	The find() String Method
	Encrypting and Decrypting Symbols
		Handling Wraparound
		Handling Symbols Outside of the Symbol Set
	Displaying and Copying the Translated String
	Encrypting Other Symbols
	Summary
	Practice Questions
Chapter 6: Hacking the Caesar Cipher with Brute-Force
	Source Code for the Caesar Cipher Hacker Program
	Sample Run of the Caesar Cipher Hacker Program
	Setting Up Variables
	Looping with the range() Function
	Decrypting the Message
	Using String Formatting to Display the Key and Decrypted Messages
	Summary
	Practice Question
Chapter 7: Encrypting with the Transposition Cipher
	How the Transposition Cipher Works
		Encrypting a Message by Hand
		Creating the Encryption Program
	Source Code for the Transposition Cipher Encryption Program
	Sample Run of the Transposition Cipher Encryption Program
	Creating Your Own Functions with def Statements
		Defining a Function that Takes Arguments with Parameters
		Changes to Parameters Only Exist Inside the Function
		Defining the main() Function
	Passing the Key and Message as Arguments
	The List Data Type
		Reassigning the Items in Lists
		Lists of Lists
		Using len() and the in Operator with Lists
		List Concatenation and Replication with the + and * Operators
	The Transposition Encryption Algorithm
	Augmented Assignment Operators
	Moving currentIndex Through the Message
	The join() String Method
	Return Values and return Statements
		A return Statement Example
		Returning the Encrypted Ciphertext
	The __name__ Variable
	Summary
	Practice Questions
Chapter 8: Decrypting with the Transposition Cipher
	How to Decrypt with the Transposition Cipher on Paper
	Source Code for the Transposition Cipher Decryption Program
	Sample Run of the Transposition Cipher Decryption Program
	Importing Modules and Setting Up the main() Function
	Decrypting the Message with the Key
		The round(), math.ceil(), and math.floor() Functions
		The decryptMessage() Function
		Boolean Operators
		Adjusting the column and row Variables
	Calling the main() Function
	Summary
	Practice Questions
Chapter 9: Programming a Program to Test Your Program
	Source Code for the Transposition Cipher Tester Program
	Sample Run of the Transposition Cipher Tester Program
	Importing the Modules
	Creating Pseudorandom Numbers
	Creating a Random String
		Duplicating a String a Random Number of Times
		List Variables Use References
		Passing References
		Using copy.deepcopy() to Duplicate a List
		The random.shuffle() Function
		Randomly Scrambling a String
	Testing Each Message
	Checking Whether the Cipher Worked and Ending the Program
	Calling the main() Function
	Testing the Test Program
	Summary
	Practice Questions
Chapter 10: Encrypting and Decrypting Files
	Plain Text Files
	Source Code for the Transposition File Cipher Program
	Sample Run of the Transposition File Cipher Program
	Working with Files
		Opening Files
		Writing to and Closing Files
		Reading from a File
	Setting Up the main() Function
	Checking Whether a File Exists
		The os.path.exists() Function
		Checking Whether the Input File Exists with the os.path.exists() Function
	Using String Methods to Make User Input More Flexible
		The upper(), lower(), and title() String Methods
		The startswith() and endswith() String Methods
		Using These String Methods in the Program
	Reading the Input File
	Measuring the Time It Took to Encrypt or Decrypt
		The time Module and time.time() Function
		Using the time.time() Function in the Program
	Writing the Output File
	Calling the main() Function
	Summary
	Practice Questions
Chapter 11: Detecting English Programmatically
	How Can a Computer Understand English?
	Source Code for the Detect English Module
	Sample Run of the Detect English Module
	Instructions and Setting Up Constants
	The Dictionary Data Type
		The Difference Between Dictionaries and Lists
		Adding or Changing Items in a Dictionary
		Using the len() Function with Dictionaries
		Using the in Operator with Dictionaries
		Finding Items Is Faster with Dictionaries than with Lists
		Using for Loops with Dictionaries
	Implementing the Dictionary File
		The split() Method
		Splitting the Dictionary File into Individual Words
		Returning the Dictionary Data
	Counting the Number of English Words in message
		Divide-by-Zero Errors
		Counting the English Word Matches
		The float(), int(), and str() Functions and Integer Division
		Finding the Ratio of English Words in the Message
	Removing Non-Letter Characters
		The append() List Method
		Creating a String of Letters
	Detecting English Words
		Using Default Arguments
		Calculating Percentages
	Summary
	Practice Questions
Chapter 12: Hacking the 
Transposition Cipher
	Source Code of the Transposition Cipher Hacker Program
	Sample Run of the Transposition Cipher Hacker Program
	Importing the Modules
	Multiline Strings with Triple Quotes
	Displaying the Results of Hacking the Message
	Getting the Hacked Message
		The strip() String Method
		Applying the strip() String Method
		Failing to Hack the Message
	Calling the main() Function
	Summary
	Practice Questions
Chapter 13: A Modular Arithmetic Module for the Affine Cipher
	Modular Arithmetic
	The Modulo Operator
	Finding Factors to Calculate the Greatest Common Divisor
	Multiple Assignment
	Euclid’s Algorithm for Finding the GCD
	Understanding How the Multiplicative and Affine Ciphers Work
		Choosing Valid Multiplicative Keys
		Encrypting with the Affine Cipher
		Decrypting with the Affine Cipher
		Finding Modular Inverses
		The Integer Division Operator
	Source Code for the Cryptomath Module
	Summary
	Practice Questions
Chapter 14: Programming the Affine Cipher
	Source Code for the Affine Cipher Program
	Sample Run of the Affine Cipher Program
	Setting Up Modules, Constants, and the main() Function
	Calculating and Validating the Keys
		The Tuple Data Type
		Checking for Weak Keys
		How Many Keys Can the Affine Cipher Have?
	Writing the Encryption Function
	Writing the Decryption Function
	Generating Random Keys
	Calling the main() Function
	Summary
	Practice Questions
Chapter 15: Hacking the Affine Cipher
	Source Code for the Affine Cipher Hacker Program
	Sample Run of the Affine Cipher Hacker Program
	Setting Up Modules, Constants, and the main() Function
	The Affine Cipher Hacking Function
		The Exponent Operator
		Calculating the Total Number of Possible Keys
		The continue Statement
		Using continue to Skip Code
	Calling the main() Function
	Summary
	Practice Questions
Chapter 16: Programming the Simple Substitution Cipher
	How the Simple Substitution Cipher Works
	Source Code for the Simple Substitution Cipher Program
	Sample Run of the Simple Substitution Cipher Program
	Setting Up Modules, Constants, and the main() Function
	The sort() List Method
	Wrapper Functions
	The translateMessage() Function
		The isupper() and islower() String Methods
		Preserving Cases with isupper()
	Generating a Random Key
	Calling the main() Function
	Summary
	Practice Questions
Chapter 17: Hacking the Simple Substitution Cipher
	Using Word Patterns to Decrypt
		Finding Word Patterns
		Finding Potential Decryption Letters
	Overview of the Hacking Process
	The Word Pattern Modules
	Source Code for the Simple Substitution Hacking Program
	Sample Run of the Simple Substitution Hacking Program
	Setting Up Modules and Constants
	Finding Characters with Regular Expressions
	Setting Up the main() Function
	Displaying Hacking Results to the User
	Creating a Cipherletter Mapping
		Creating a Blank Mapping
		Adding Letters to a Mapping
		Intersecting Two Mappings
		How the Letter-Mapping Helper Functions Work
		Identifying Solved Letters in Mappings
		Testing the removeSolvedLetterFromMapping() Function
	The hackSimpleSub() Function
		The replace() String Method
		Decrypting the Message
		Decrypting in the Interactive Shell
	Calling the main() Function
	Summary
	Practice Questions
Chapter 18: Programming 
the Vigenère Cipher
	Using Multiple Letter Keys in the Vigenère Cipher
		Longer Vigenère Keys Are More Secure
		Choosing a Key That Prevents Dictionary Attacks
	Source Code for the Vigenère Cipher Program
	Sample Run of the Vigenère Cipher Program
	Setting Up Modules, Constants, and the main() Function
	Building Strings with the List-Append-Join Process
	Encrypting and Decrypting the Message
	Calling the main() Function
	Summary
	Practice Questions
Chapter 19: Frequency Analysis
	Analyzing the Frequency of Letters in Text
	Matching Letter Frequencies
		Calculating the Frequency Match Score for the Simple Substitution Cipher
		Calculating the Frequency Match Score for the Transposition Cipher
		Using Frequency Analysis on the Vigenère Cipher
	Source Code for Matching Letter Frequencies
	Storing the Letters in ETAOIN Order
	Counting the Letters in a Message
	Getting the First Member of a Tuple
	Ordering the Letters in the Message by Frequency
		Counting the Letters with getLetterCount()
		Creating a Dictionary of Frequency Counts and Letter Lists
		Sorting the Letter Lists in Reverse ETAOIN Order
		Sorting the Dictionary Lists by Frequency
		Creating a List of the Sorted Letters
	Calculating the Frequency Match Score of the Message
	Summary
	Practice Questions
Chapter 20: Hacking the Vigenère Cipher
	Using a Dictionary Attack to Brute-Force the Vigenère Cipher
	Source Code for the Vigenère Dictionary Hacker Program
	Sample Run of the Vigenère Dictionary Hacker Program
	About the Vigenère Dictionary Hacker Program
	Using Kasiski Examination to Find the Key’s Length
		Finding Repeated Sequences
		Getting Factors of Spacings
		Getting Every Nth Letters from a String
		Using Frequency Analysis to Break Each Subkey
		Brute-Forcing Through the Possible Keys
	Source Code for the Vigenère Hacking Program
	Sample Run of the Vigenère Hacking Program
	Importing Modules and Setting Up the main() Function
	Finding Repeated Sequences
	Calculating the Factors of the Spacings
		Removing Duplicates with the set() Function
		Removing Duplicate Factors and Sorting the List
		Finding the Most Common Factors
	Finding the Most Likely Key Lengths
		The extend() List Method
		Extending the repeatedSeqSpacings Dictionary
		Getting the Factors from factorsByCount
	Getting Letters Encrypted with the Same Subkey
	Attempting Decryption with a Likely Key Length
		The end Keyword Argument for print()
		Running the Program in Silent Mode or Printing Information to the User
		Finding Possible Combinations of Subkeys
		Printing the Decrypted Text with the Correct Casing
	Returning the Hacked Message
		Breaking Out of the Loop When a Potential Key Is Found
		Brute-Forcing All Other Key Lengths
	Calling the main() Function
	Modifying the Constants of the Hacking Program
	Summary
	Practice Questions
Chapter 21: The One-Time Pad Cipher
	The Unbreakable One-Time Pad Cipher
		Making Key Length Equal Message Length
		Making the Key Truly Random
		Avoiding the Two-Time Pad
		Why the Two-Time Pad Is the Vigenère Cipher
	Summary
	Practice Questions
Chapter 22: Finding and Generating Prime Numbers
	What Is a Prime Number?
	Source Code for the Prime Numbers Module
	Sample Run of the Prime Numbers Module
	How the Trial Division Algorithm Works
	Implementing the Trial Division Algorithm Test
	The Sieve of Eratosthenes
	Generating Prime Numbers with the Sieve of Eratosthenes
	The Rabin-Miller Primality Algorithm
	Finding Large Prime Numbers
	Generating Large Prime Numbers
	Summary
Chapter 23: Generating Keys for the Public Key Cipher
	Public Key Cryptography
	The Problem with Authentication
		Digital Signatures
		Beware the MITM Attack
	Steps for Generating Public and Private Keys
	Source Code for the Public Key Generation Program
	Sample Run of the Public Key Generation Program
	Creating the main() Function
	Generating Keys with the generateKey() Function
		Calculating an e Value
		Calculating a d Value
		Returning the Keys
	Creating Key Files with the makeKeyFiles() Function
	Calling the main() Function
	Hybrid Cryptosystems
	Summary
	Practice Questions
Chapter 24: Programming the Public Key Cipher
	How the Public Key Cipher Works
		Creating Blocks
		Converting a String into a Block
		The Mathematics of Public Key Cipher Encryption and Decryption
		Converting a Block to a String
		Why We Can’t Hack the Public Key Cipher
	Source Code for the Public Key Cipher Program
	Sample Run of the Public Key Cipher Program
	Setting Up the Program
	How the Program Determines Whether to Encrypt or Decrypt
	Converting Strings to Blocks with getBlocksFromText()
		The min() and max() Functions
		Storing Blocks in blockInt
	Using getTextFromBlocks() to Decrypt
		Using the insert() List Method
		Merging the Message List into One String
	Writing the encryptMessage() Function
	Writing the decryptMessage() Function
	Reading in the Public and Private Keys from Their Key Files
	Writing the Encryption to a File
	Decrypting from a File
	Calling the main() Function
	Summary
Appendix: Debugging Python Code
	How the Debugger Works
	Debugging the Reverse Cipher Program
	Setting Breakpoints
	Summary
Index
Resources