Adventures in Cryptography: From Playing Cards to Blockchain

I have always been fascinated by new methods of communication. There's something interesting about finding an encoded piece of information and using tools at my disposal to translate it into something that makes sense, whether they be online codebreakers or simply hashing it out on a piece of paper. Some of my favorite examples include the Sebald Code, the Cipher Hunt ARG, and most recently Cipher, the online riddle,

This curiosity naturally carried over to my studies. As a security-minded student in college, I enrolled in a cryptography course to learn more about the systems and means by which information is kept secure. As we covered the section of zero-knowledge proofs, we performed an exercise that opened my eyes not only to breaking ciphers, but also how to engineer them from the ground up.

This exercise uses five playing cards, three red and two black, each with identical backs. The two parties, traditionally named Alice and Bob, each draw one red and one black card, leaving the extra red card face-up on a table. They will encode their private bits (1 or 0) by the choice of which color is placed nearer that center card, then jointly obscure the arrangement through secret rotations.

1. Bob looks away. Alice chooses bit 1 by placing her red card closest to the center card (or bit 0 by using black), then flips her two cards face-down and turns away.
2. After Alice turns away, Bob repeats: he selects red near center for 1 (black for 0), then places his cards face-down and turns away.
3. Alice turns to view the five face-down cards in a line, rearranges them into a circle, and secretly rotates the circle by a random 0-4 positions clockwise.
4. Alice looks away, and Bob applies his own secret 0-4 position clockwise rotation.
5. Both flip all cards face-up. If the three red cards now appear consecutively, then Alice and Bob's bits were both 1. Otherwise, at least one bit is 0.

This simple experiment is a recreation of Bert den Boer's Five Card Trick, first published in 1989. This experiment is a clever physical demonstration of Zero-Knowledge Proofs (ZKPs), a cryptographic technique that allows one party to convince the other that a statement is true without revealing any additional information. While not foundational in the development of ZKPs, it serves as a launchpad for educational tools and further exploration into using tangible items like playing cards for privacy-preserving logical computations.

ZKPs and secure multiparty computation are advanced cryptographic techniques that enhance privacy and security in modern technologies, such as cryptocurrency and blockchain. In the Adventures in Cryptography series, I will explore some of the technologies surrounding this experiment and related topics in cryptography. These topics include:

• First, we will cover Blockchain, where I will emulate blockchain logic through a voting system hosted on Railway.
• Next, we will look at Quantum cryptography, where I will demonstrate some popular crytographic techniques using Jupyter notebooks.
• Finally, we will dive into Cryptanalysis, where I will showcase how to break certain ciphers and cryptographic techniques using a web app hosted on Railway.

I thought a practical example of how to demonstrate blockchain technology would be in the form of a voting system, which simulates the logic of blockchain protocols in a fun and interactive manner. I will walk through how the voting system was put together and provide links to access the prototype and my GitHub repository where you can replicate the example on your local machine.

The first task is to plan what the system can do and how users will be able to interact with it. Here is a general rundown:

• The app should be able to record exactly one vote from each user.
• Voting should be kept anonymous.
• Votes are stored on the blockchain, where each vote equals one transaction.
• A final tally can be computed from the chain.

With this in mind we can hash out the basic blockchain components:

• The block will hold vote transactions.
• The chain consists of a list of blocks linked via cryptographic hashes.
• The proof of work will be simplified, but it will still serve its purpose as an integral part of the solution.
• For ease of simulation we will stick to one node and skip the consensus step.

The basic block structure is pictured below.

Now that the backend has been assembled, I needed a UI to put everything together. I settled on native React, which interfaces seamlessly with the backend Flask API. Key features of the React frontend include:

• Definition of global constants for candidate images and background colors.
• Inclusion of useState hooks to track error and success messages.
• A method to retrieve the voter ID from local storage, which generates a new ID using a combination of the current date and a random number as a fallback. Note that in production a more robust UUID library would be used to avoid collisions.
• A method to cast a vote, which calls on the /vote and /mine routes to add a block to the chain, mine a new block, and effectively cast a vote.
• A primary modal to display the frontend and allow users to vote in the poll.

Later in development, the following features were added:

• A leaderboard to show which candidate is leading in the poll. This required a new backend method, Flask API route, and an accessor/mutator in the frontend.
• The use of useEffect + setInterval to constantly refresh the leaderboard, which is helpful when the poll is highly active and many votes are being cast.
• Axios, a promise-based HTTP client used to interface with the backend and provide runtime flexibility.
• A persistent datastore to save the results of the poll and easily reset the votes when a new topic is chosen
• Rate limiting with flask-limiter to mitigate DoS and keep the datastore in check

An early version of the voting modal is shown below.

In my next article in the Adventures in Cryptography series, I will cover some experiments in quantum cryptography and the creation of a cryptanalysis engine to encode text, decode ciphers, and take a guess at which cipher a given text is encoded in. There's plenty more content to explore in the world of cryptography!

OpenAI: header image

Springer.com: "More Efficient Match-Making and Satisfiability: The Five Card Trick, Bert den Boer, 1989.