6
votes
$\begingroup$

I'm holding a cryptography workshop for teenagers (around 16 years old) at our university. As part of the workshop, I'm planning to run a crypto competition with prizes: there will be different tasks, each one will yield points, and the winners will get sweets.

However, for the amount of time I'm planning to kill with this game, I still need one or two more challenges. So far, what I have is:

  • Scytale: one band with letters on it and four potential objects - find out which is the right object so you can read the message and obtain the solution.

  • Caesar Cipher: Find out by how much the letters have been shifted to get the solution.

  • A transposition cipher (one where you write the text in a rectangle and then read the columns).

  • One with frequency analysis (they get the frequency table for the letters and a longer text which I chose to be pretty close to at least the most frequent values).

As you can see, these are all pretty basic stuff that can be done by hand. I don't really want to do anything that would require the kids to do any programming, although I suppose I could do something like install Cryptool2 on an old computer and have that as one station, if anyone has a nice idea that requires computer assistance.

I'm hoping that, among the community of crypto experts and enthusiasts here, some of you may have experience with running such competitions for kids and teenagers, and may be able to suggest some good challenges. If you've organized something like this before, and know some suitable challenges that I haven't already thought of, please share them!

$\endgroup$
5
votes
$\begingroup$

Perhaps you could do something with Visual Cryptography. Maybe something like:

  • Gather a few low-resolution images (symbols or short text phrases), perhaps a few more images than you have kids
  • Use visual cryptography to split each image into 2 random-looking images, and print each random-looking image on its own piece of transparency paper
  • Shuffle the pile of transparency papers
  • somehow let the kids find matching pairs of transparencies that show the original symbol or phrase.

Is there some way to let kids produce Visual Cryptography image-pairs "by hand", without a computer?

Links and further reading:

$\endgroup$
  • 1
    $\begingroup$ Sure you can do visual crypto without a computer. Just get some semitransparent graph paper and color in the squares. The resolution won't be too great, but you should be able to make some recognizable images. $\endgroup$ – Ilmari Karonen Aug 28 '14 at 20:11
4
votes
$\begingroup$

You could challenge them to devise low-tech, physical zero-knowledge proofs (of knowledge) for games like "Where's Waldo?" and Sudoku, then show them some methods that really work and why. I've done this before with high school CS students and they seemed to really like it.

For "Where's Waldo?" one can prepare a large sheet of paper (at least twice as big as the puzzle page in each dimension) with the shape of Waldo cut out of it. The "prover" puts the sheet over the puzzle so that only Waldo is showing through, without revealing exactly how the puzzle is aligned under the sheet. The "verifier" observes that Waldo is showing through, and concludes that the prover knows where Waldo is -- but learns nothing more, e.g., about Waldo's position on the page (other than the fact that Waldo is actually present). This and another solution come from "Applied Kid Cryptography:" http://www.wisdom.weizmann.ac.il/~naor/PUZZLES/waldo_sol.html

For Sudoku, here is a simple "cut and choose" method.

  • The prover and verifier agree on the puzzle that is to be solved (with some numbers already occupying certain squares), and the prover knows a solution.
  • The prover chooses a random permutation $\pi$ of the digits $\{1,\ldots,9\}$, and privately fills in a fresh blank grid with the "permuted" solution (i.e., it replaces each occurrence of $i \in \{1,\ldots,9\}$ with $\pi(i)$). The prover covers each square of the grid with an opaque chip, so that the numbers are hidden.
  • The verifier then chooses randomly between two possible challenges: either (0) ask the prover to reveal $\pi$ and to remove the chips corresponding to the occupied squares of the original puzzle, or (1) ask the prover to remove the chips corresponding to a single randomly chosen row, column, or 3-by-3 block.
    • In case (0), the verifier checks that $\pi$ indeed maps the number in each occupied square of the original puzzle to the number in the corresponding revealed square.
    • In case (1), the verifier checks that each number in $\{1,\ldots,9\}$ appears exactly once in the row/column/block.

The protocol is complete: clearly, a prover who knows a solution and acts as described above will always convince the verifier, no matter what challenge it issues.

The protocol is sound: if there is no solution to the original puzzle, then by definition it is impossible for the prover to prepare a grid so that all of the verifier's possible challenges can be answered satisfactorily: either some row/column/block will not have all 9 digits appearing exactly once, or the values in the occupied squares will be inconsistent with the original puzzle. Therefore, the verifier has at least a $1/(2 \cdot 27)$ probability of catching the prover. By repeating the protocol many times with fresh permutations and grids, this probability of catching the prover can be brought extremely close to 1.

Finally, the protocol is zero knowledge: when the protocol is run on a solvable puzzle, in case (0) the verifier just sees a uniformly random permutation of the original numbers, and in case (1) the verifier just sees a uniformly random permutation of $\{1,\ldots,9\}$ in the revealed row/column/block. In particular, in neither case does the verifier learn anything new about what values actually belong in any of the unoccupied squares of the original puzzle.

$\endgroup$
-2
votes
$\begingroup$

Give every kid a deck of cards (2 decks of cards?) and a short (unique) text message on paper. Each kid encodes the message -- by arranging the cards in some order; writing on the cards is cheating. Then every kid decodes a deck of cards (arranged by some other kid) and write the message on paper.

Challenge the kids to come up with a better algorithm for encoding text that (a) is more robust against small, common errors, such as accidentally losing the first card, or (b) can encode a longer text message into a deck of cards, or (c) is faster to encode, or (d) better in some other way.

$\endgroup$

Not the answer you're looking for? Browse other questions tagged or ask your own question.