This page uses content from Wikipedia and is licensed under CC BY-SA.

General | |
---|---|

Designers | Richard Schroeppel |

First published | June 1998 |

Cipher detail | |

Key sizes | Variable |

Block sizes | Variable |

The **Hasty Pudding Cipher** (**HPC**) is a variable-block-size block cipher designed by Richard Schroeppel, which was an unsuccessful candidate in the competition for selecting the U.S. Advanced Encryption Standard (AES). It has a number of unusual properties for a block cipher: its input block size and key length are variable, and it includes an additional input parameter called the "spice" for use as a secondary, non-secret key. The Hasty Pudding cipher was the only AES candidate designed exclusively by U.S. cryptographers.^{[1]}^{[2]}

The Hasty Pudding cipher is in the public domain.^{[3]}

The Hasty Pudding cipher consists of 5 different sub-ciphers:^{[4]}

HPC-Tiny | 0–35 bits |

HPC-Short | 36–64 bits |

HPC-Medium | 65-128 bits |

HPC-Long | 129–512 bits |

HPC-Extended | 513+ bits |

The Hasty Pudding cipher algorithms all use 64-bit words internally. The cipher is designed to run on 64-bit machines, which can easily perform simple operations on 64-bit words.

The Hasty Pudding cipher can take a key of any number of bits for any one of the five subciphers. The cipher itself uses a *key table* of 16,384 bits (256 64-bit words). To derive the key table from the key, the key expansion function uses the following algorithm:^{[4]}

- The first three words,
*KX*[0],*KX*[1],*KX*[2] are set based on constants, the sub-cipher, and the length of the key.*KX*[1] is computed with a multiplication; the other operations involved are an addition and a bit shift. - Each successive word,
*KX*[*i*] is determined from the three previous words by an efficient recursive formula. - The key bits are XORed into the bits of the key table, starting at
*KX*[0], until all the key bits are used. (Keys longer than 8,192 bits use a more complicated procedure.) - Several passes over the key table are made. Each time, a "stirring function" is applied to each word of the key table, in sequence. The stirring function uses eight internal variables, and uses 14 logical bit operations, 5 bit shifts, and 14 additions / subtractions. Each use of the stirring function modifies one word in the key table, based on its previous value, the values of certain other words, and the internal variables of the stirring function. (3 total passes is the default.)

Each of the subciphers uses a different algorithm, but there are certain similarities. Three inputs are used to determine the ciphertext: the plaintext (in several 64-bit words plus one "fragment"), the spice (eight 64-bit words, with default value 0), and the key table. The operations within the cipher consist of *stirring*, which combines internal variables in various ways with values from the key table and spice at regular intervals. HPC-Short uses two fixed permutations in addition, and HPC-Tiny consists of many special sub-cases.

Decryption involves undoing the steps of encryption one by one. Many operations are easily undone (e.g. *s*0 = *s*0 + *s*1 is undone by computing *s*0 = *s*0 − *s*1). Other operations are more complex to undo. Some of the ideas involved include:

- An operation like
*x*=*x*(*x*>> 17) is undone by a two-step process: (1)*x*=*x*(*x*>> 17), followed by (2)*x*=*x*(*x*>> 34). - The cipher uses value-dependent lookups into the key table. These can be undone, since the lookup depends only on the last 8 bits of a variable, and when it becomes necessary to look up the value from the key table in decryption, the last 8 bits of the value at a certain earlier point in the computation are predictable, even when those operations cannot all be undone without the key table value. For instance, if the lookup of
*k*is based on the last 8 bits of*x*, then when we want to undo a step like*x*=*x*(*k*<< 8), we can look up*k*by noting that the last 8 bits of*x*are unchanged by this operation.

The Hasty Pudding cipher can also be used to encrypt values in a range that do not translate to strings with an integral number of bits; for instance, it can encrypt a number from 0 to N by producing another number from 0 to *N*. It does this by using the smallest subcipher that can handle the input as a bit string, and applying it to the input as a bit string, repeatedly, until the output is in the proper range.^{[4]}

Schroeppel claimed that the Hasty Pudding cipher was the fastest AES candidate on a 64-bit architecture;^{[5]} Schroeppel claimed that it was twice as fast as its nearest competitor, DFC, and three times as fast as the other candidates, and that its performance on a 32-bit machine was adequate.^{[5]} Comments from others did not support this view; for instance, Schneier et al.'s analysis ranked the Hasty Pudding cipher 4th best (376 cycles) on a 64-bit machine, although for Rijndael and Twofish, the performance was only estimated.^{[6]} On a 32-bit Pentium, Hasty Pudding encryption was rated by Schneier et al. at 1600 clock cycles, 10th best out of the 15 candidates.^{[6]} Schneier et al., and Schroeppel, noted that the speed of the cipher would be significantly impacted on a 32-bit machine because of its heavy use of 64-bit operations, particularly bit shifts.^{[3]}^{[6]}

The Hasty Pudding cipher's key setup was rated as relatively slow; 120000 cycles on a Pentium.^{[6]}

The cipher was criticized for its performance on smartcards. Specifically, some comments pointed out the difficulty of keeping over 2KB of RAM for the key table.^{[7]}

There have been relatively few results on attacking the Hasty Pudding cipher. Early in the AES process, David Wagner noted that relatively large classes of Hasty Pudding keys were equivalent in that they led to the same key table.^{[8]} This was expanded upon by D'Halluin et al., who noted that for 128-bit keys, approximately 2^{120} keys are *weak keys* that each have 2^{30} equivalent keys each.^{[9]} In response to this attack, Schroeppel modified the key expansion algorithm to include one additional step.^{[4]}

Despite the relative lack of cryptanalysis, the Hasty Pudding cipher was criticized for its hard-to-understand design and its lack of grounding in research results.^{[8]}^{[10]} Schroeppel has offered a bottle of Dom Pérignon champagne to the best paper presenting progress on the Hasty Pudding cipher.^{[3]} It did not make the second round of consideration for AES.^{[11]}

The Hasty Pudding cipher is considered the first tweakable block cipher.^{[12]}

**^**Eli Biham,*A Note on Comparing the AES Candidates*, April 1999, public comment on AES.**^**Susan Landau,*Communications Security for the Twenty-first Century: The Advanced Encryption Standard*, Notices of the AMS, vol. 47, number 4, 2000.- ^
^{a}^{b}^{c}Rich Schroeppel and Hilarie Orman,*An Overview of the Hasty Pudding Cipher,*July 1998. - ^
^{a}^{b}^{c}^{d}Schroeppel, Rich (June 1998),*Hasty Pudding Cipher Specification*(revised May 1999 ed.), retrieved 2009-06-10 - ^
^{a}^{b}Rich Schroeppel,*The Hasty Pudding Cipher: One Year Later*, accessed 9-01-2008 - ^
^{a}^{b}^{c}^{d}Bruce Schneier, John Kelsey, Doug Whiting, David Wagner, Chris Hall, and Niels Ferguson,*Performance Comparison of the AES Submissions*, The Second AES Candidate Conference, 1999. **^**Emanoil Daneliuc, Public comment on AES candidates, February 1999.- ^
^{a}^{b}David Wagner,*Equivalent keys for HPC*, rump session talk at the 2nd AES Conference, Rome, March 1999. **^**Carl D'Halluin, Gert Bijnens, Bart Preneel, and Vincent Rijmen,*Equivalent Keys of HPC*, Advances in Cryptology — Proceedings of ASIACRYPT 1999, 1999.**^**Olivier Baudron, Henri Gilbert, Louis Granboulan, Helena Handschuh, Antoine Joux, Phong Nguyen, Fabrice Noilhan, David Pointcheval, Thomas Pornin, Guillaume Poupard, Jacques Stern, and Serge Vaudenay,*Report on the AES Candidates*, Second AES Conference, March 1999.**^**James Nechvatal, Elaine Barker, Lawrence Bassham, William Burr, Morris Dworkin, James Foti, and Edward Roback,*Report on the Development of the Advanced Encryption Standard (AES)*, NIST official release, October 2, 2000.**^**Moses Liskov, Ronald Rivest, and David Wagner,*Tweakable Block Ciphers*, in Advances in Cryptology — Proceedings of CRYPTO '02, 2002.