mirror of
https://github.com/oxen-io/session-android.git
synced 2024-12-21 07:27:30 +00:00
220 lines
9.6 KiB
Plaintext
220 lines
9.6 KiB
Plaintext
>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.
|
|
|
|
|
|
|