An Interview with John Fletcher

   Two counters, C0 and C1, are both initialized to zero.  
   All sums are performed modulo 255 (i.e., ones-complement).  

   As each byte B of a packet of 8-bit bytes is transmitted, 
   the counters are updated as follows:

        C0 = C0 + B
        C1 = C1 + C0

   When the packet is complete, the sender appends two check bytes 
   as follows, using the then current values C0 and C1:

        First check byte = -C0 - C1

   This byte is then incorporated into C0 and C1 as were all preceding 
   bytes (which, as is easily seen, reduces C1 to zero).

        Second check byte = -C0

   Incorporating this byte into C0 and C1 also reduces C0 to zero.

   The receiver simply computes the checksum for all received bytes. 

   An error is detected if either C0 or C1 is non-zero (modulo 255) 
   after the second checkbyte is received.

   There are seven forms of password, as follows:

      1. 6 letters (e. g., "qwerty").

      2. 5 consonants alternating with 4 vowels (e. g., "domifasol"),  
         where a consonant is b, d, f, g, j, k, l, m, n, p, r, s t, v, 
         or z and a vowel is a, e, i, o, or u.

      3. 3 nonsense syllables (e. g., "non sen sil"), where a nonsense  
         syllable is 2 consonants separated by 1 vowel.

      4. 2 nonsense syllables followed by 3 digits (e. g., "non sen 854").

      5. 1 nonsense syllable followed by 6 digits (e. g., "sil 917 632").

      6. 9 digits (e. g., "013 267 548").

      7. enough (almost always 2) English words from a dictionary of  
         18,823 words, each of up to 7 letters, so as to total at least 
         8 characters including separating spaces (e. g., "two word").

   A best effort was applied to purge the dictionary of offensive words; 
   however, it is impossible to foresee all subjective attitudes. Also, 
   the random processes may by chance generate offensive words or sequences 
   of words. A user obtaining a password regarded as offensive should 
   request another one and accept the authenticator's tacit apology.
   Some forms of password are generated with embedded spaces to foster 
   readability; these need not be included when the password is used, 
   and in fact additional spaces (as well as control characters) may be 
   inserted so long as the total characters do not exceed 16.
 
   The C subroutine used to generate passwords:

   static void pwgen (pwd, fmt)   /* Subr to generate password */
    unsigned char *pwd;           /*  ptr to password */
    unsigned char fmt; {          /*  format of password */
   #define Lpwd 16                /* max password length */
   #define Lpwdict 18823          /* length of dictionary */
    static char *pwdict;          /* ptr to dictionary */
    static unsigned char map [6][11] = {
      {1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
      {2, 3, 2, 3, 2, 3, 2, 3, 2, 0, 0},
      {2, 3, 2, 5, 2, 3, 2, 5, 2, 3, 2},
      {2, 3, 2, 5, 2, 3, 2, 5, 4, 4, 4},
      {2, 3, 2, 5, 4, 4, 4, 5, 4, 4, 4},
      {4, 4, 4, 5, 4, 4, 4, 5, 4, 4, 4} };
                                  /* password format maps */
    static unsigned char conson[15] =
      {'b', 'd', 'f', 'g', 'j', 'k', 'l', 'm', 'n', 'p',
        'r', 's', 't', 'v', 'z'}; /* consonant list */
    static unsigned char vowel[5] =
      {'a', 'e', 'i', 'o', 'u'};  /* vowel list */
    unsigned int random = Time(); /* random # */
    int i;                        /* loop index */
    char *w;                      /* ptr to dictionary word */

    for (i = 0; i < Lpwd/(sizeof(unsigned int)); i++)
                                  /* loop thru previous password */
     random += ((unsigned int *) pwd)[i];
                                  /* include it in random # */

    if (fmt >= 6)                 /* if dictionary to be used */
     for (i = 0; ; ) {            /* loop thru chars of password */
      for (w = pwdict[(random % Lpwdict)*8], random /= Lpwdict;
        *w > ' ' && i < Lpwd; )   /* loop thru dictionary word  */
       pwd[i++] = *w++;           /* include word in password */
      if (i >= Lpwd/2) break;     /* end password if long enough */
      pwd[i++] = ' '; }           /* get space */

    else for (i = 0; i < 11; i++) { /* loop thru chars of password */
     switch (map[fmt][i]) {       /* select char according to fmt */
     case 1:                      /* letter */
      pwd[i] = 'a' + random % 26,
          random /= 26;           /* get random letter */
      continue;
     case 2:                      /* consonant */
      pwd[i] = conson[random % 15],
          random /= 15;           /* get random consonant */
      continue;
     case 3:                      /* vowel */
      pwd[i] = vowel[random % 5],
          random /= 5;            /* get random vowel */
      continue;
     case 4:                      /* digit */
      pwd[i] = '0' + random % 10,
          random /= 10;           /* get random digit */
      continue;
     case 5:                      /* space */
      pwd[i] = ' ';               /* get space */
      continue; }
     break; }                     /* end password in other cases */
    (void) memset(pwd + i, 0, Lpwd - i);
                                  /* pad end of password */
    return; }