serpent

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (July 2008)

Serpent

Serpent's linear mixing stage
General
Designers	Ross Anderson, Eli Biham, Lars Knudsen
First published	1998-08-21
Derived from	Square
Certification	AES finalist
Cipher detail
Key sizes	128, 192 or 256 bits
Block sizes	128 bits
Structure	Substitution-permutation network
Rounds	32
Best public cryptanalysis
All known attacks are computationally infeasible. A 2011 attack breaks 11 round Serpent (all key sizes) with 2116 known plaintexts, 2107.5 time and 2104 memory (as described in [1]). The same paper also describes two attacks which break 12 rounds of Serpent-256. The first requires 2118 known plaintexts, 2228.8 time and 2228 memory. The other attack requires 2116 known plaintexts and 2121 memory but also requires 2237.5 time.

Serpent is a symmetric key block cipher which was a finalist in the Advanced Encryption Standard (AES) contest, where it came second to Rijndael. Serpent was designed by Ross Anderson, Eli Biham, and Lars Knudsen.

Like other AES submissions, Serpent has a block size of 128 bits and supports a key size of 128, 192 or 256 bits.^[2] The cipher is a 32-round substitution-permutation network operating on a block of four 32-bit words. Each round applies one of eight 4-bit to 4-bit S-boxes 32 times in parallel. Serpent was designed so that all operations can be executed in parallel, using 32 1-bit slices. This maximizes parallelism, but also allows use of the extensive cryptanalysis work performed on DES.

Serpent was widely viewed as taking a more conservative approach to security than the other AES finalists, opting for a larger security margin: the designers deemed 16 rounds to be sufficient against known types of attack, but specified 32 rounds as insurance against future discoveries in cryptanalysis.

The Serpent cipher is in the public domain and has not been patented. There are no restrictions or encumbrances whatsoever regarding its use. As a result, anyone is free to incorporate Serpent in their software (or hardware implementations) without paying license fees.

Rijndael vs. Serpent

Rijndael is a substitution-linear transformation network with ten, twelve, or fourteen rounds, depending on the key size, and with block sizes of 128 bits, 192 bits, or 256 bits, independently specified. Serpent is a substitution-permutation network which has thirty-two rounds, plus an initial and a final permutation to simplify an optimized implementation. The round function in Rijndael consists of three parts: a nonlinear layer, a linear mixing layer, and a key-mixing XOR layer. The round function in Serpent consists of key-mixing XOR, thirty-two parallel applications of the same 4×4 S-box, and a linear transformation, except in the last round, wherein another key-mixing XOR replaces the linear transformation. The nonlinear layer in Rijndael uses an 8×8 S-box whereas Serpent uses eight different 4×4 S-boxes. The 32 rounds means that Serpent has a higher security margin than Rijndael; however, Rijndael with 10 rounds is faster and easier to implement for small blocks.^{[citation needed]} Hence, Rijndael was selected as the winner in the AES competition.

Serpent-0 vs Serpent-1

The original Serpent, Serpent-0, was presented at the 5th workshop on Fast Software Encryption, but a somewhat tweaked version, Serpent-1, was submitted to the AES competition. The AES submission paper discuss the changes, which include key scheduling differences.

Security

The XSL attack, if effective, would weaken Serpent (though not as much as it would weaken Rijndael, which became AES). However, many cryptanalysts believe that once implementation considerations are taken into account the XSL attack would be more expensive than a brute force attack.^{[citation needed]}

In 2000, a paper by Kohno et al. presents a meet-in-the-middle attack against 6 of 32 rounds of Serpent and an amplified boomerang attack against 9 of 32 rounds in Serpent.^[3]

A 2001 attack by Eli Biham, Orr Dunkelman and Nathan Keller presents a linear cryptanalysis attack that breaks 10 of 32 rounds of Serpent-128 with 2¹¹⁸ known plaintexts and 2⁸⁹ time, and 11 rounds of Serpent-192/256 with 2¹¹⁸ known plaintexts and 2¹⁸⁷ time.^[4]

A 2011 attack by Hongjun Wu, Huaxiong Wang and Phong Ha Nguyen, also using linear cryptanalysis, breaks 11 rounds of Serpent-128 with 2¹¹⁶ known plaintexts, 2^107.5 time and 2¹⁰⁴ memory ^[1]).

The same paper also describes two attacks which break 12 rounds of Serpent-256. The first requires 2¹¹⁸ known plaintexts, 2^228.8 time and 2²²⁸ memory. The other attack requires 2¹¹⁶ known plaintexts and 2¹²¹ memory but also requires 2^237.5 time.

See also

• Tiger - hash function by the same authors.

Footnotes

External links

• Serpent homepage
• Reference (AES submission) implementation
• Reference implementation
• SCAN's entry for Serpent
• In Pellicano Case, Lessons in Wiretapping Skills - NYTimes May 5, 2008
• Eli Biham's Serpent page with test vectors