SECURITY and CRYPTOGRAPHY 15-827                   1 NOV 01
             Lecture #13                                 M.B.
                                                      4615 Wean


Have students time me on a particular INSTANCE (#80) of my most recent
PhonOID CLASS.

"If seven maids with seven mops swept it for half a year"
 29 39224 12833 4229 39224 8350 39541 41 448 3131 3 1435

Notice that I am treating this as 12 individual single-word challenges
rather than as a single long challenge, which would lead to the mostly
different response:

"If seven maids with seven mops swept it for half a year"
 29 41149 56175 3412 14080 8350 22270 70 448 5685 6 0854   
..   

Explain the general CLASS of PhonOIDS, of which the above are EXAMPLES of
JUST one instance of the class.



ASK THE STUDENTS TO CRITIQUE THIS *CLASS* OF PHONOIDS !!!



THE CLASS of PHONOIDS DEFINED:

CHALLENGE = A single English dictionary word <a1,...,ak> consisting of k
letters chosen from the alphabetic characters A,..,Z only. 

RESPONSE = a k-digit number <x1,...,xk>

The ALGORITHM CLASS assumes that the human USER has memorized a PRIVATE
RANDOM function 
		f:{A,...,Z} -> {0,...,9},
and a PRIVATE RANDOM permutation 
		g:{0,...,9} -> {0,...,9}.

The USER supplies a PRIVATE rule for generating the first response digit,
x1, from the challenge. Possible examples of such a rule include:

1. x1 <- f(a1) + f(a2) mod 10.   In words,
   x1 <- sum mod 10 of the first two characters. 

2. x1 <- sum mod 10 of the first two consonants.

3. x1 <- f(ai), where i = a1. In words, ai is the character pointed to by
a1.  For example, if the challenge is JUSTICE and f:J -> 7, then J points
to the 7th character E, so x1 = f(E) = 3.

4. x1 <- g(f(ak)). For challenge JUSTICE, x1 = g(f(E)) = 8.

A great many more such sample rules can easily be given.  A program is
required to guide the user away from rules that are easily broken  (like x1
<- f(a1))  or rules that take too long to perform.

The USER supplies a PRIVATE rule for REORDERING the letters of the
CHALLENGE <a1,...,ak> to get a new string <b1,...,bk>.  The rule must be so
simple that the user can instantly in his head read off the reordered word
from any given challenge.

For example, the rule might be:

1. Let <b1,...,bk> = <a2,...,ak,a1> In words, read the challenge starting
at the 2nd letter and wraparound.

2. Let <b1,...,bk> be got from <a1,...,ak> by enumerating the consonants
(as they appear in the challenge) first, and the vowels second. For
example, reorder the challenge JUSTICE as JSTCUIE.

3. Let <b1,...,bk> = <ak,...,a1>. In words, read the challenge backwards.

4. Let b1 = ai where i = f(a1). Then continue reading to the right using
wraparound. For example, with f(J)=7, the challenge JUSTICE becomes
EJUSTIC. With f(C)=6, CREATIVITY becomes IVITYCREAT.

5. Partition all uppercase characters into two equivalence classes: those
characters that are made up of straight-line segments 
		{A,E,F,H,I,K,L,M,N,T,V,W,X,Y,Z}, 
and those that not
		{B,C,D,G,J,O,P,Q,R,S,U}
Let <b1,...,bk> be got from <a1,...,ak> by enumerating the
straight-line-only characters first, and the remainder second.
For example, with f(J)=7 and f(C)=6, the challenge JUSTICE becomes TIEJUSC.
CREATIVITY becomes EATIVITYCR.

A great many more such sample rules can easily be given.  A program is
required to guide the user away from rules that are easily broken  (like bi
<- f(ai) for i=1..k)  or rules that take too long to perform.


The RESPONSE <x1,...,xk> is produced as follows:
x2 = g( x1 + f(b2) ).
x3 = g( x2 + f(b3) ).
   :
xk = g(    + f(bk) ).



Get students to suggest CAPTCHAS, and analyze them.


Discuss the 1/P pseudo-random generator.  What's good about it; what's bad
about it. This should get us talking about continued fractions.