Building a Solitaire Cipher in Java: Linked Lists & Stream Ciphers for Secure Messaging

Introduction: The Challenge of Secure Student Communication

Picture this: It's May 2026, and you're an ECSE 250 student at McGill. Reading week is approaching, and you want to send private messages to friends scattered across the globe. But how do you ensure that no one intercepts your plans? Enter the Solitaire cipher—a stream cipher invented by Bruce Schneier that uses a standard deck of cards to generate a key stream. In this assignment, you'll implement Solitaire in Java, combining linked list data structures with cryptography concepts. This tutorial will guide you through the key components: building a circular doubly linked list deck, performing the Solitaire algorithm steps, and encrypting/decrypting messages. By the end, you'll have a working stream cipher that's both educational and fun.

Understanding the Solitaire Cipher Algorithm

The Solitaire cipher (also called Pontifex) is a stream cipher that uses a deck of 54 cards (including two jokers) to generate a pseudo-random key stream. Each key value is a number from 1 to 26, which is then added to the plaintext letter to produce ciphertext. The algorithm involves several steps: keying the deck, generating output, and performing operations like moving jokers and cutting the deck. For this assignment, you'll focus on the core operations using a circular doubly linked list.

Why Linked Lists?

Linked lists are ideal for this task because the Solitaire algorithm requires frequent insertion, deletion, and moving of nodes. A circular doubly linked list allows efficient traversal in both directions and makes operations like moving a joker down by one position trivial. Compared to arrays, linked lists avoid the overhead of shifting elements, making them perfect for deck manipulation.

Implementing the Deck as a Circular Doubly Linked List

Your first task is to complete the Deck.java file. The deck is represented as a circular doubly linked list where each node holds a card (an integer from 1 to 54). You'll need to implement methods for:

• Creating the deck: Initialize the list with cards in a known order (e.g., 1 to 54).
• Finding a card: Search the list for a specific card value.
• Moving a card down: Move a card one position down (toward the tail) in the list.
• Cutting the deck: Perform a triple cut or count cut as per the algorithm.

Here's a snippet to get you started:

public class Deck {
    private Node head;
    private int size;

    private class Node {
        int card;
        Node prev;
        Node next;
        Node(int card) { this.card = card; }
    }

    // Find a card and return its node
    public Node findCard(int value) {
        Node current = head;
        do {
            if (current.card == value) return current;
            current = current.next;
        } while (current != head);
        return null;
    }
}

Remember to maintain the circular nature: the tail's next points to head, and head's prev points to tail.

Generating the Key Stream with SolitaireCipher

Once your deck is ready, you'll implement the SolitaireCipher.java class. This class uses the deck to generate a stream of key values (1-26). The main steps are:

1. Move the jokers: Find the A joker (value 53) and move it down one card. Then find the B joker (value 54) and move it down two cards.
2. Triple cut: Swap the cards above the first joker with the cards below the second joker.
3. Count cut: Look at the bottom card, count that many cards from the top, and move that block to the bottom (just above the last card).
4. Output card: Look at the top card, count that many cards down, and the next card becomes the output. Convert its value to a number 1-26 (e.g., 1-52 map to 1-26, with 53 and 54 ignored).

Repeat steps 1-4 for each key value needed. The output values are combined with the plaintext using modular addition (like a one-time pad).

Connecting to Real-World Trends: AI and Secure Messaging

In 2026, secure communication is more relevant than ever. With the rise of AI-powered chatbots and end-to-end encryption apps like Signal and WhatsApp, understanding how stream ciphers work gives you a competitive edge. The Solitaire cipher, though obsolete for real-world use, teaches the fundamentals of key generation and pseudo-randomness. It's also a great example of how data structures like linked lists enable algorithms that would be inefficient with arrays.

Testing and Debugging Your Implementation

Don't wait until the end to test! Use unit tests for each method. For example, test that moving a joker correctly updates the list order. Print the deck after each step to verify. Common pitfalls include:

• Breaking the circular link when moving nodes.
• Off-by-one errors in counting cards.
• Forgetting to handle jokers (cards 53 and 54) specially.

Use the provided tester files to validate your output against known test vectors. If you get stuck, post on Ed with specific details about the bug and what you've tried.

Efficiency Considerations

While linked lists are efficient for insertions, they have O(n) lookup time. To improve performance, you could store a map from card value to node reference, but the assignment likely prohibits additional imports. Instead, focus on writing clean, correct code. The deck size is small (54 cards), so linear searches are acceptable.

Conclusion: From Classroom to Real-World Security

By completing this assignment, you'll gain hands-on experience with linked list implementation, stream cipher design, and algorithm efficiency. These skills are directly applicable to careers in cybersecurity, software engineering, and data science. Whether you're building a secure chat app or analyzing network traffic, understanding how ciphers work is invaluable. So grab your deck of cards (virtual or physical), and start coding!

“The only way to keep your secret is to never tell anyone.” – But with Solitaire, you can share secrets safely.