You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
219 lines
9.6 KiB
219 lines
9.6 KiB
>From cygnus.mincom.oz.au!minbne.mincom.oz.au!bunyip.cc.uq.oz.au!munnari.OZ.AU!comp.vuw.ac.nz!waikato!auckland.ac.nz!news Mon Feb 12 18:48:17 EST 1996 |
|
Article 23601 of sci.crypt: |
|
Path: cygnus.mincom.oz.au!minbne.mincom.oz.au!bunyip.cc.uq.oz.au!munnari.OZ.AU!comp.vuw.ac.nz!waikato!auckland.ac.nz!news |
|
>From: pgut01@cs.auckland.ac.nz (Peter Gutmann) |
|
Newsgroups: sci.crypt |
|
Subject: Specification for Ron Rivests Cipher No.2 |
|
Date: 11 Feb 1996 06:45:03 GMT |
|
Organization: University of Auckland |
|
Lines: 203 |
|
Sender: pgut01@cs.auckland.ac.nz (Peter Gutmann) |
|
Message-ID: <4fk39f$f70@net.auckland.ac.nz> |
|
NNTP-Posting-Host: cs26.cs.auckland.ac.nz |
|
X-Newsreader: NN version 6.5.0 #3 (NOV) |
|
|
|
|
|
|
|
|
|
Ron Rivest's Cipher No.2 |
|
------------------------ |
|
|
|
Ron Rivest's Cipher No.2 (hereafter referred to as RRC.2, other people may |
|
refer to it by other names) is word oriented, operating on a block of 64 bits |
|
divided into four 16-bit words, with a key table of 64 words. All data units |
|
are little-endian. This functional description of the algorithm is based in |
|
the paper "The RC5 Encryption Algorithm" (RC5 is a trademark of RSADSI), using |
|
the same general layout, terminology, and pseudocode style. |
|
|
|
|
|
Notation and RRC.2 Primitive Operations |
|
|
|
RRC.2 uses the following primitive operations: |
|
|
|
1. Two's-complement addition of words, denoted by "+". The inverse operation, |
|
subtraction, is denoted by "-". |
|
2. Bitwise exclusive OR, denoted by "^". |
|
3. Bitwise AND, denoted by "&". |
|
4. Bitwise NOT, denoted by "~". |
|
5. A left-rotation of words; the rotation of word x left by y is denoted |
|
x <<< y. The inverse operation, right-rotation, is denoted x >>> y. |
|
|
|
These operations are directly and efficiently supported by most processors. |
|
|
|
|
|
The RRC.2 Algorithm |
|
|
|
RRC.2 consists of three components, a *key expansion* algorithm, an |
|
*encryption* algorithm, and a *decryption* algorithm. |
|
|
|
|
|
Key Expansion |
|
|
|
The purpose of the key-expansion routine is to expand the user's key K to fill |
|
the expanded key array S, so S resembles an array of random binary words |
|
determined by the user's secret key K. |
|
|
|
Initialising the S-box |
|
|
|
RRC.2 uses a single 256-byte S-box derived from the ciphertext contents of |
|
Beale Cipher No.1 XOR'd with a one-time pad. The Beale Ciphers predate modern |
|
cryptography by enough time that there should be no concerns about trapdoors |
|
hidden in the data. They have been published widely, and the S-box can be |
|
easily recreated from the one-time pad values and the Beale Cipher data taken |
|
from a standard source. To initialise the S-box: |
|
|
|
for i = 0 to 255 do |
|
sBox[ i ] = ( beale[ i ] mod 256 ) ^ pad[ i ] |
|
|
|
The contents of Beale Cipher No.1 and the necessary one-time pad are given as |
|
an appendix at the end of this document. For efficiency, implementors may wish |
|
to skip the Beale Cipher expansion and store the sBox table directly. |
|
|
|
Expanding the Secret Key to 128 Bytes |
|
|
|
The secret key is first expanded to fill 128 bytes (64 words). The expansion |
|
consists of taking the sum of the first and last bytes in the user key, looking |
|
up the sum (modulo 256) in the S-box, and appending the result to the key. The |
|
operation is repeated with the second byte and new last byte of the key until |
|
all 128 bytes have been generated. Note that the following pseudocode treats |
|
the S array as an array of 128 bytes rather than 64 words. |
|
|
|
for j = 0 to length-1 do |
|
S[ j ] = K[ j ] |
|
for j = length to 127 do |
|
s[ j ] = sBox[ ( S[ j-length ] + S[ j-1 ] ) mod 256 ]; |
|
|
|
At this point it is possible to perform a truncation of the effective key |
|
length to ease the creation of espionage-enabled software products. However |
|
since the author cannot conceive why anyone would want to do this, it will not |
|
be considered further. |
|
|
|
The final phase of the key expansion involves replacing the first byte of S |
|
with the entry selected from the S-box: |
|
|
|
S[ 0 ] = sBox[ S[ 0 ] ] |
|
|
|
|
|
Encryption |
|
|
|
The cipher has 16 full rounds, each divided into 4 subrounds. Two of the full |
|
rounds perform an additional transformation on the data. Note that the |
|
following pseudocode treats the S array as an array of 64 words rather than 128 |
|
bytes. |
|
|
|
for i = 0 to 15 do |
|
j = i * 4; |
|
word0 = ( word0 + ( word1 & ~word3 ) + ( word2 & word3 ) + S[ j+0 ] ) <<< 1 |
|
word1 = ( word1 + ( word2 & ~word0 ) + ( word3 & word0 ) + S[ j+1 ] ) <<< 2 |
|
word2 = ( word2 + ( word3 & ~word1 ) + ( word0 & word1 ) + S[ j+2 ] ) <<< 3 |
|
word3 = ( word3 + ( word0 & ~word2 ) + ( word1 & word2 ) + S[ j+3 ] ) <<< 5 |
|
|
|
In addition the fifth and eleventh rounds add the contents of the S-box indexed |
|
by one of the data words to another of the data words following the four |
|
subrounds as follows: |
|
|
|
word0 = word0 + S[ word3 & 63 ]; |
|
word1 = word1 + S[ word0 & 63 ]; |
|
word2 = word2 + S[ word1 & 63 ]; |
|
word3 = word3 + S[ word2 & 63 ]; |
|
|
|
|
|
Decryption |
|
|
|
The decryption operation is simply the inverse of the encryption operation. |
|
Note that the following pseudocode treats the S array as an array of 64 words |
|
rather than 128 bytes. |
|
|
|
for i = 15 downto 0 do |
|
j = i * 4; |
|
word3 = ( word3 >>> 5 ) - ( word0 & ~word2 ) - ( word1 & word2 ) - S[ j+3 ] |
|
word2 = ( word2 >>> 3 ) - ( word3 & ~word1 ) - ( word0 & word1 ) - S[ j+2 ] |
|
word1 = ( word1 >>> 2 ) - ( word2 & ~word0 ) - ( word3 & word0 ) - S[ j+1 ] |
|
word0 = ( word0 >>> 1 ) - ( word1 & ~word3 ) - ( word2 & word3 ) - S[ j+0 ] |
|
|
|
In addition the fifth and eleventh rounds subtract the contents of the S-box |
|
indexed by one of the data words from another one of the data words following |
|
the four subrounds as follows: |
|
|
|
word3 = word3 - S[ word2 & 63 ] |
|
word2 = word2 - S[ word1 & 63 ] |
|
word1 = word1 - S[ word0 & 63 ] |
|
word0 = word0 - S[ word3 & 63 ] |
|
|
|
|
|
Test Vectors |
|
|
|
The following test vectors may be used to test the correctness of an RRC.2 |
|
implementation: |
|
|
|
Key: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
|
Plain: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
|
Cipher: 0x1C, 0x19, 0x8A, 0x83, 0x8D, 0xF0, 0x28, 0xB7 |
|
|
|
Key: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 |
|
Plain: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
|
Cipher: 0x21, 0x82, 0x9C, 0x78, 0xA9, 0xF9, 0xC0, 0x74 |
|
|
|
Key: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
|
Plain: 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF |
|
Cipher: 0x13, 0xDB, 0x35, 0x17, 0xD3, 0x21, 0x86, 0x9E |
|
|
|
Key: 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, |
|
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F |
|
Plain: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
|
Cipher: 0x50, 0xDC, 0x01, 0x62, 0xBD, 0x75, 0x7F, 0x31 |
|
|
|
|
|
Appendix: Beale Cipher No.1, "The Locality of the Vault", and One-time Pad for |
|
Creating the S-Box |
|
|
|
Beale Cipher No.1. |
|
|
|
71, 194, 38,1701, 89, 76, 11, 83,1629, 48, 94, 63, 132, 16, 111, 95, |
|
84, 341, 975, 14, 40, 64, 27, 81, 139, 213, 63, 90,1120, 8, 15, 3, |
|
126,2018, 40, 74, 758, 485, 604, 230, 436, 664, 582, 150, 251, 284, 308, 231, |
|
124, 211, 486, 225, 401, 370, 11, 101, 305, 139, 189, 17, 33, 88, 208, 193, |
|
145, 1, 94, 73, 416, 918, 263, 28, 500, 538, 356, 117, 136, 219, 27, 176, |
|
130, 10, 460, 25, 485, 18, 436, 65, 84, 200, 283, 118, 320, 138, 36, 416, |
|
280, 15, 71, 224, 961, 44, 16, 401, 39, 88, 61, 304, 12, 21, 24, 283, |
|
134, 92, 63, 246, 486, 682, 7, 219, 184, 360, 780, 18, 64, 463, 474, 131, |
|
160, 79, 73, 440, 95, 18, 64, 581, 34, 69, 128, 367, 460, 17, 81, 12, |
|
103, 820, 62, 110, 97, 103, 862, 70, 60,1317, 471, 540, 208, 121, 890, 346, |
|
36, 150, 59, 568, 614, 13, 120, 63, 219, 812,2160,1780, 99, 35, 18, 21, |
|
136, 872, 15, 28, 170, 88, 4, 30, 44, 112, 18, 147, 436, 195, 320, 37, |
|
122, 113, 6, 140, 8, 120, 305, 42, 58, 461, 44, 106, 301, 13, 408, 680, |
|
93, 86, 116, 530, 82, 568, 9, 102, 38, 416, 89, 71, 216, 728, 965, 818, |
|
2, 38, 121, 195, 14, 326, 148, 234, 18, 55, 131, 234, 361, 824, 5, 81, |
|
623, 48, 961, 19, 26, 33, 10,1101, 365, 92, 88, 181, 275, 346, 201, 206 |
|
|
|
One-time Pad. |
|
|
|
158, 186, 223, 97, 64, 145, 190, 190, 117, 217, 163, 70, 206, 176, 183, 194, |
|
146, 43, 248, 141, 3, 54, 72, 223, 233, 153, 91, 210, 36, 131, 244, 161, |
|
105, 120, 113, 191, 113, 86, 19, 245, 213, 221, 43, 27, 242, 157, 73, 213, |
|
193, 92, 166, 10, 23, 197, 112, 110, 193, 30, 156, 51, 125, 51, 158, 67, |
|
197, 215, 59, 218, 110, 246, 181, 0, 135, 76, 164, 97, 47, 87, 234, 108, |
|
144, 127, 6, 6, 222, 172, 80, 144, 22, 245, 207, 70, 227, 182, 146, 134, |
|
119, 176, 73, 58, 135, 69, 23, 198, 0, 170, 32, 171, 176, 129, 91, 24, |
|
126, 77, 248, 0, 118, 69, 57, 60, 190, 171, 217, 61, 136, 169, 196, 84, |
|
168, 167, 163, 102, 223, 64, 174, 178, 166, 239, 242, 195, 249, 92, 59, 38, |
|
241, 46, 236, 31, 59, 114, 23, 50, 119, 186, 7, 66, 212, 97, 222, 182, |
|
230, 118, 122, 86, 105, 92, 179, 243, 255, 189, 223, 164, 194, 215, 98, 44, |
|
17, 20, 53, 153, 137, 224, 176, 100, 208, 114, 36, 200, 145, 150, 215, 20, |
|
87, 44, 252, 20, 235, 242, 163, 132, 63, 18, 5, 122, 74, 97, 34, 97, |
|
142, 86, 146, 221, 179, 166, 161, 74, 69, 182, 88, 120, 128, 58, 76, 155, |
|
15, 30, 77, 216, 165, 117, 107, 90, 169, 127, 143, 181, 208, 137, 200, 127, |
|
170, 195, 26, 84, 255, 132, 150, 58, 103, 250, 120, 221, 237, 37, 8, 99 |
|
|
|
|
|
Implementation |
|
|
|
A non-US based programmer who has never seen any encryption code before will |
|
shortly be implementing RRC.2 based solely on this specification and not on |
|
knowledge of any other encryption algorithms. Stand by. |
|
|
|
|
|
|
|
|