From f56bb35301836e56582a575a75864392a0177875 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B8rgen=20P=2E=20Tjern=C3=B8?= Date: Mon, 2 Dec 2013 19:31:46 -0800 Subject: Fix line endings. WHAMMY. --- sp/src/mathlib/IceKey.cpp | 786 +++++++++++++++++++++++----------------------- 1 file changed, 393 insertions(+), 393 deletions(-) (limited to 'sp/src/mathlib/IceKey.cpp') diff --git a/sp/src/mathlib/IceKey.cpp b/sp/src/mathlib/IceKey.cpp index b5f910b7..e739ce6f 100644 --- a/sp/src/mathlib/IceKey.cpp +++ b/sp/src/mathlib/IceKey.cpp @@ -1,393 +1,393 @@ -// Purpose: C++ implementation of the ICE encryption algorithm. -// Taken from public domain code, as written by Matthew Kwan - July 1996 -// http://www.darkside.com.au/ice/ - -#if !defined(_STATIC_LINKED) || defined(_SHARED_LIB) - -#include "mathlib/IceKey.H" -#include "tier0/memdbgon.h" -#pragma warning(disable: 4244) - - - /* Structure of a single round subkey */ -class IceSubkey { - public: - unsigned long val[3]; -}; - - - /* The S-boxes */ -static unsigned long ice_sbox[4][1024]; -static int ice_sboxes_initialised = 0; - - - /* Modulo values for the S-boxes */ -static const int ice_smod[4][4] = { - {333, 313, 505, 369}, - {379, 375, 319, 391}, - {361, 445, 451, 397}, - {397, 425, 395, 505}}; - - /* XOR values for the S-boxes */ -static const int ice_sxor[4][4] = { - {0x83, 0x85, 0x9b, 0xcd}, - {0xcc, 0xa7, 0xad, 0x41}, - {0x4b, 0x2e, 0xd4, 0x33}, - {0xea, 0xcb, 0x2e, 0x04}}; - - /* Permutation values for the P-box */ -static const unsigned long ice_pbox[32] = { - 0x00000001, 0x00000080, 0x00000400, 0x00002000, - 0x00080000, 0x00200000, 0x01000000, 0x40000000, - 0x00000008, 0x00000020, 0x00000100, 0x00004000, - 0x00010000, 0x00800000, 0x04000000, 0x20000000, - 0x00000004, 0x00000010, 0x00000200, 0x00008000, - 0x00020000, 0x00400000, 0x08000000, 0x10000000, - 0x00000002, 0x00000040, 0x00000800, 0x00001000, - 0x00040000, 0x00100000, 0x02000000, 0x80000000}; - - /* The key rotation schedule */ -static const int ice_keyrot[16] = { - 0, 1, 2, 3, 2, 1, 3, 0, - 1, 3, 2, 0, 3, 1, 0, 2}; - - -/* - * 8-bit Galois Field multiplication of a by b, modulo m. - * Just like arithmetic multiplication, except that additions and - * subtractions are replaced by XOR. - */ - -static unsigned int -gf_mult ( - register unsigned int a, - register unsigned int b, - register unsigned int m -) { - register unsigned int res = 0; - - while (b) { - if (b & 1) - res ^= a; - - a <<= 1; - b >>= 1; - - if (a >= 256) - a ^= m; - } - - return (res); -} - - -/* - * Galois Field exponentiation. - * Raise the base to the power of 7, modulo m. - */ - -static unsigned long -gf_exp7 ( - register unsigned int b, - unsigned int m -) { - register unsigned int x; - - if (b == 0) - return (0); - - x = gf_mult (b, b, m); - x = gf_mult (b, x, m); - x = gf_mult (x, x, m); - return (gf_mult (b, x, m)); -} - - -/* - * Carry out the ICE 32-bit P-box permutation. - */ - -static unsigned long -ice_perm32 ( - register unsigned long x -) { - register unsigned long res = 0; - register const unsigned long *pbox = ice_pbox; - - while (x) { - if (x & 1) - res |= *pbox; - pbox++; - x >>= 1; - } - - return (res); -} - - -/* - * Initialise the ICE S-boxes. - * This only has to be done once. - */ - -static void -ice_sboxes_init (void) -{ - register int i; - - for (i=0; i<1024; i++) { - int col = (i >> 1) & 0xff; - int row = (i & 0x1) | ((i & 0x200) >> 8); - unsigned long x; - - x = gf_exp7 (col ^ ice_sxor[0][row], ice_smod[0][row]) << 24; - ice_sbox[0][i] = ice_perm32 (x); - - x = gf_exp7 (col ^ ice_sxor[1][row], ice_smod[1][row]) << 16; - ice_sbox[1][i] = ice_perm32 (x); - - x = gf_exp7 (col ^ ice_sxor[2][row], ice_smod[2][row]) << 8; - ice_sbox[2][i] = ice_perm32 (x); - - x = gf_exp7 (col ^ ice_sxor[3][row], ice_smod[3][row]); - ice_sbox[3][i] = ice_perm32 (x); - } -} - - -/* - * Create a new ICE key. - */ - -IceKey::IceKey (int n) -{ - if (!ice_sboxes_initialised) { - ice_sboxes_init (); - ice_sboxes_initialised = 1; - } - - if (n < 1) { - _size = 1; - _rounds = 8; - } else { - _size = n; - _rounds = n * 16; - } - - _keysched = new IceSubkey[_rounds]; -} - - -/* - * Destroy an ICE key. - */ - -IceKey::~IceKey () -{ - int i, j; - - for (i=0; i<_rounds; i++) - for (j=0; j<3; j++) - _keysched[i].val[j] = 0; - - _rounds = _size = 0; - - delete[] _keysched; -} - - -/* - * The single round ICE f function. - */ - -static unsigned long -ice_f ( - register unsigned long p, - const IceSubkey *sk -) { - unsigned long tl, tr; /* Expanded 40-bit values */ - unsigned long al, ar; /* Salted expanded 40-bit values */ - - /* Left half expansion */ - tl = ((p >> 16) & 0x3ff) | (((p >> 14) | (p << 18)) & 0xffc00); - - /* Right half expansion */ - tr = (p & 0x3ff) | ((p << 2) & 0xffc00); - - /* Perform the salt permutation */ - // al = (tr & sk->val[2]) | (tl & ~sk->val[2]); - // ar = (tl & sk->val[2]) | (tr & ~sk->val[2]); - al = sk->val[2] & (tl ^ tr); - ar = al ^ tr; - al ^= tl; - - al ^= sk->val[0]; /* XOR with the subkey */ - ar ^= sk->val[1]; - - /* S-box lookup and permutation */ - return (ice_sbox[0][al >> 10] | ice_sbox[1][al & 0x3ff] - | ice_sbox[2][ar >> 10] | ice_sbox[3][ar & 0x3ff]); -} - - -/* - * Encrypt a block of 8 bytes of data with the given ICE key. - */ - -void -IceKey::encrypt ( - const unsigned char *ptext, - unsigned char *ctext -) const -{ - register int i; - register unsigned long l, r; - - l = (((unsigned long) ptext[0]) << 24) - | (((unsigned long) ptext[1]) << 16) - | (((unsigned long) ptext[2]) << 8) | ptext[3]; - r = (((unsigned long) ptext[4]) << 24) - | (((unsigned long) ptext[5]) << 16) - | (((unsigned long) ptext[6]) << 8) | ptext[7]; - - for (i = 0; i < _rounds; i += 2) { - l ^= ice_f (r, &_keysched[i]); - r ^= ice_f (l, &_keysched[i + 1]); - } - - for (i = 0; i < 4; i++) { - ctext[3 - i] = r & 0xff; - ctext[7 - i] = l & 0xff; - - r >>= 8; - l >>= 8; - } -} - - -/* - * Decrypt a block of 8 bytes of data with the given ICE key. - */ - -void -IceKey::decrypt ( - const unsigned char *ctext, - unsigned char *ptext -) const -{ - register int i; - register unsigned long l, r; - - l = (((unsigned long) ctext[0]) << 24) - | (((unsigned long) ctext[1]) << 16) - | (((unsigned long) ctext[2]) << 8) | ctext[3]; - r = (((unsigned long) ctext[4]) << 24) - | (((unsigned long) ctext[5]) << 16) - | (((unsigned long) ctext[6]) << 8) | ctext[7]; - - for (i = _rounds - 1; i > 0; i -= 2) { - l ^= ice_f (r, &_keysched[i]); - r ^= ice_f (l, &_keysched[i - 1]); - } - - for (i = 0; i < 4; i++) { - ptext[3 - i] = r & 0xff; - ptext[7 - i] = l & 0xff; - - r >>= 8; - l >>= 8; - } -} - - -/* - * Set 8 rounds [n, n+7] of the key schedule of an ICE key. - */ - -void -IceKey::scheduleBuild ( - unsigned short *kb, - int n, - const int *keyrot -) { - int i; - - for (i=0; i<8; i++) { - register int j; - register int kr = keyrot[i]; - IceSubkey *isk = &_keysched[n + i]; - - for (j=0; j<3; j++) - isk->val[j] = 0; - - for (j=0; j<15; j++) { - register int k; - unsigned long *curr_sk = &isk->val[j % 3]; - - for (k=0; k<4; k++) { - unsigned short *curr_kb = &kb[(kr + k) & 3]; - register int bit = *curr_kb & 1; - - *curr_sk = (*curr_sk << 1) | bit; - *curr_kb = (*curr_kb >> 1) | ((bit ^ 1) << 15); - } - } - } -} - - -/* - * Set the key schedule of an ICE key. - */ - -void -IceKey::set ( - const unsigned char *key -) { - int i; - - if (_rounds == 8) { - unsigned short kb[4]; - - for (i=0; i<4; i++) - kb[3 - i] = (key[i*2] << 8) | key[i*2 + 1]; - - scheduleBuild (kb, 0, ice_keyrot); - return; - } - - for (i=0; i<_size; i++) { - int j; - unsigned short kb[4]; - - for (j=0; j<4; j++) - kb[3 - j] = (key[i*8 + j*2] << 8) | key[i*8 + j*2 + 1]; - - scheduleBuild (kb, i*8, ice_keyrot); - scheduleBuild (kb, _rounds - 8 - i*8, &ice_keyrot[8]); - } -} - - -/* - * Return the key size, in bytes. - */ - -int -IceKey::keySize () const -{ - return (_size * 8); -} - - -/* - * Return the block size, in bytes. - */ - -int -IceKey::blockSize () const -{ - return (8); -} - -#endif // !_STATIC_LINKED || _SHARED_LIB +// Purpose: C++ implementation of the ICE encryption algorithm. +// Taken from public domain code, as written by Matthew Kwan - July 1996 +// http://www.darkside.com.au/ice/ + +#if !defined(_STATIC_LINKED) || defined(_SHARED_LIB) + +#include "mathlib/IceKey.H" +#include "tier0/memdbgon.h" +#pragma warning(disable: 4244) + + + /* Structure of a single round subkey */ +class IceSubkey { + public: + unsigned long val[3]; +}; + + + /* The S-boxes */ +static unsigned long ice_sbox[4][1024]; +static int ice_sboxes_initialised = 0; + + + /* Modulo values for the S-boxes */ +static const int ice_smod[4][4] = { + {333, 313, 505, 369}, + {379, 375, 319, 391}, + {361, 445, 451, 397}, + {397, 425, 395, 505}}; + + /* XOR values for the S-boxes */ +static const int ice_sxor[4][4] = { + {0x83, 0x85, 0x9b, 0xcd}, + {0xcc, 0xa7, 0xad, 0x41}, + {0x4b, 0x2e, 0xd4, 0x33}, + {0xea, 0xcb, 0x2e, 0x04}}; + + /* Permutation values for the P-box */ +static const unsigned long ice_pbox[32] = { + 0x00000001, 0x00000080, 0x00000400, 0x00002000, + 0x00080000, 0x00200000, 0x01000000, 0x40000000, + 0x00000008, 0x00000020, 0x00000100, 0x00004000, + 0x00010000, 0x00800000, 0x04000000, 0x20000000, + 0x00000004, 0x00000010, 0x00000200, 0x00008000, + 0x00020000, 0x00400000, 0x08000000, 0x10000000, + 0x00000002, 0x00000040, 0x00000800, 0x00001000, + 0x00040000, 0x00100000, 0x02000000, 0x80000000}; + + /* The key rotation schedule */ +static const int ice_keyrot[16] = { + 0, 1, 2, 3, 2, 1, 3, 0, + 1, 3, 2, 0, 3, 1, 0, 2}; + + +/* + * 8-bit Galois Field multiplication of a by b, modulo m. + * Just like arithmetic multiplication, except that additions and + * subtractions are replaced by XOR. + */ + +static unsigned int +gf_mult ( + register unsigned int a, + register unsigned int b, + register unsigned int m +) { + register unsigned int res = 0; + + while (b) { + if (b & 1) + res ^= a; + + a <<= 1; + b >>= 1; + + if (a >= 256) + a ^= m; + } + + return (res); +} + + +/* + * Galois Field exponentiation. + * Raise the base to the power of 7, modulo m. + */ + +static unsigned long +gf_exp7 ( + register unsigned int b, + unsigned int m +) { + register unsigned int x; + + if (b == 0) + return (0); + + x = gf_mult (b, b, m); + x = gf_mult (b, x, m); + x = gf_mult (x, x, m); + return (gf_mult (b, x, m)); +} + + +/* + * Carry out the ICE 32-bit P-box permutation. + */ + +static unsigned long +ice_perm32 ( + register unsigned long x +) { + register unsigned long res = 0; + register const unsigned long *pbox = ice_pbox; + + while (x) { + if (x & 1) + res |= *pbox; + pbox++; + x >>= 1; + } + + return (res); +} + + +/* + * Initialise the ICE S-boxes. + * This only has to be done once. + */ + +static void +ice_sboxes_init (void) +{ + register int i; + + for (i=0; i<1024; i++) { + int col = (i >> 1) & 0xff; + int row = (i & 0x1) | ((i & 0x200) >> 8); + unsigned long x; + + x = gf_exp7 (col ^ ice_sxor[0][row], ice_smod[0][row]) << 24; + ice_sbox[0][i] = ice_perm32 (x); + + x = gf_exp7 (col ^ ice_sxor[1][row], ice_smod[1][row]) << 16; + ice_sbox[1][i] = ice_perm32 (x); + + x = gf_exp7 (col ^ ice_sxor[2][row], ice_smod[2][row]) << 8; + ice_sbox[2][i] = ice_perm32 (x); + + x = gf_exp7 (col ^ ice_sxor[3][row], ice_smod[3][row]); + ice_sbox[3][i] = ice_perm32 (x); + } +} + + +/* + * Create a new ICE key. + */ + +IceKey::IceKey (int n) +{ + if (!ice_sboxes_initialised) { + ice_sboxes_init (); + ice_sboxes_initialised = 1; + } + + if (n < 1) { + _size = 1; + _rounds = 8; + } else { + _size = n; + _rounds = n * 16; + } + + _keysched = new IceSubkey[_rounds]; +} + + +/* + * Destroy an ICE key. + */ + +IceKey::~IceKey () +{ + int i, j; + + for (i=0; i<_rounds; i++) + for (j=0; j<3; j++) + _keysched[i].val[j] = 0; + + _rounds = _size = 0; + + delete[] _keysched; +} + + +/* + * The single round ICE f function. + */ + +static unsigned long +ice_f ( + register unsigned long p, + const IceSubkey *sk +) { + unsigned long tl, tr; /* Expanded 40-bit values */ + unsigned long al, ar; /* Salted expanded 40-bit values */ + + /* Left half expansion */ + tl = ((p >> 16) & 0x3ff) | (((p >> 14) | (p << 18)) & 0xffc00); + + /* Right half expansion */ + tr = (p & 0x3ff) | ((p << 2) & 0xffc00); + + /* Perform the salt permutation */ + // al = (tr & sk->val[2]) | (tl & ~sk->val[2]); + // ar = (tl & sk->val[2]) | (tr & ~sk->val[2]); + al = sk->val[2] & (tl ^ tr); + ar = al ^ tr; + al ^= tl; + + al ^= sk->val[0]; /* XOR with the subkey */ + ar ^= sk->val[1]; + + /* S-box lookup and permutation */ + return (ice_sbox[0][al >> 10] | ice_sbox[1][al & 0x3ff] + | ice_sbox[2][ar >> 10] | ice_sbox[3][ar & 0x3ff]); +} + + +/* + * Encrypt a block of 8 bytes of data with the given ICE key. + */ + +void +IceKey::encrypt ( + const unsigned char *ptext, + unsigned char *ctext +) const +{ + register int i; + register unsigned long l, r; + + l = (((unsigned long) ptext[0]) << 24) + | (((unsigned long) ptext[1]) << 16) + | (((unsigned long) ptext[2]) << 8) | ptext[3]; + r = (((unsigned long) ptext[4]) << 24) + | (((unsigned long) ptext[5]) << 16) + | (((unsigned long) ptext[6]) << 8) | ptext[7]; + + for (i = 0; i < _rounds; i += 2) { + l ^= ice_f (r, &_keysched[i]); + r ^= ice_f (l, &_keysched[i + 1]); + } + + for (i = 0; i < 4; i++) { + ctext[3 - i] = r & 0xff; + ctext[7 - i] = l & 0xff; + + r >>= 8; + l >>= 8; + } +} + + +/* + * Decrypt a block of 8 bytes of data with the given ICE key. + */ + +void +IceKey::decrypt ( + const unsigned char *ctext, + unsigned char *ptext +) const +{ + register int i; + register unsigned long l, r; + + l = (((unsigned long) ctext[0]) << 24) + | (((unsigned long) ctext[1]) << 16) + | (((unsigned long) ctext[2]) << 8) | ctext[3]; + r = (((unsigned long) ctext[4]) << 24) + | (((unsigned long) ctext[5]) << 16) + | (((unsigned long) ctext[6]) << 8) | ctext[7]; + + for (i = _rounds - 1; i > 0; i -= 2) { + l ^= ice_f (r, &_keysched[i]); + r ^= ice_f (l, &_keysched[i - 1]); + } + + for (i = 0; i < 4; i++) { + ptext[3 - i] = r & 0xff; + ptext[7 - i] = l & 0xff; + + r >>= 8; + l >>= 8; + } +} + + +/* + * Set 8 rounds [n, n+7] of the key schedule of an ICE key. + */ + +void +IceKey::scheduleBuild ( + unsigned short *kb, + int n, + const int *keyrot +) { + int i; + + for (i=0; i<8; i++) { + register int j; + register int kr = keyrot[i]; + IceSubkey *isk = &_keysched[n + i]; + + for (j=0; j<3; j++) + isk->val[j] = 0; + + for (j=0; j<15; j++) { + register int k; + unsigned long *curr_sk = &isk->val[j % 3]; + + for (k=0; k<4; k++) { + unsigned short *curr_kb = &kb[(kr + k) & 3]; + register int bit = *curr_kb & 1; + + *curr_sk = (*curr_sk << 1) | bit; + *curr_kb = (*curr_kb >> 1) | ((bit ^ 1) << 15); + } + } + } +} + + +/* + * Set the key schedule of an ICE key. + */ + +void +IceKey::set ( + const unsigned char *key +) { + int i; + + if (_rounds == 8) { + unsigned short kb[4]; + + for (i=0; i<4; i++) + kb[3 - i] = (key[i*2] << 8) | key[i*2 + 1]; + + scheduleBuild (kb, 0, ice_keyrot); + return; + } + + for (i=0; i<_size; i++) { + int j; + unsigned short kb[4]; + + for (j=0; j<4; j++) + kb[3 - j] = (key[i*8 + j*2] << 8) | key[i*8 + j*2 + 1]; + + scheduleBuild (kb, i*8, ice_keyrot); + scheduleBuild (kb, _rounds - 8 - i*8, &ice_keyrot[8]); + } +} + + +/* + * Return the key size, in bytes. + */ + +int +IceKey::keySize () const +{ + return (_size * 8); +} + + +/* + * Return the block size, in bytes. + */ + +int +IceKey::blockSize () const +{ + return (8); +} + +#endif // !_STATIC_LINKED || _SHARED_LIB -- cgit v1.2.3