exploit the possibilities
Home Files News &[SERVICES_TAB]About Contact Add New

IceKey.C

IceKey.C
Posted Dec 21, 1999

IceKey.C

tags | java, encryption, steganography
SHA-256 | d3eae8cbde1117b17fadcd67c5f8f1659f64804d3dbda1d24c8a6d91eadd7df5

IceKey.C

Change Mirror Download
/*
* C++ implementation of the ICE encryption algorithm.
*
* Written by Matthew Kwan - July 1996
*/

#include "IceKey.H"


/* 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 int
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.
*/

unsigned char *
IceKey::encrypt (
const unsigned char *ptext,
unsigned char *ctext
) const
{
register int i;
register unsigned long l, r;

l = (((unsigned long) ptext[0]) << 24) | (ptext[1] << 16)
| (ptext[2] << 8) | ptext[3];
r = (((unsigned long) ptext[4]) << 24) | (ptext[5] << 16)
| (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;
}

return (ctext);
}


/*
* Decrypt a block of 8 bytes of data with the given ICE key.
*/

unsigned char *
IceKey::decrypt (
const unsigned char *ctext,
unsigned char *ptext
) const
{
register int i;
register unsigned long l, r;

l = (((unsigned long) ctext[0]) << 24) | (ctext[1] << 16)
| (ctext[2] << 8) | ctext[3];
r = (((unsigned long) ctext[4]) << 24) | (ctext[5] << 16)
| (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;
}

return (ptext);
}


/*
* 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);
}
Login or Register to add favorites

File Archive:

March 2024

  • Su
  • Mo
  • Tu
  • We
  • Th
  • Fr
  • Sa
  • 1
    Mar 1st
    16 Files
  • 2
    Mar 2nd
    0 Files
  • 3
    Mar 3rd
    0 Files
  • 4
    Mar 4th
    32 Files
  • 5
    Mar 5th
    28 Files
  • 6
    Mar 6th
    42 Files
  • 7
    Mar 7th
    17 Files
  • 8
    Mar 8th
    13 Files
  • 9
    Mar 9th
    0 Files
  • 10
    Mar 10th
    0 Files
  • 11
    Mar 11th
    15 Files
  • 12
    Mar 12th
    19 Files
  • 13
    Mar 13th
    21 Files
  • 14
    Mar 14th
    38 Files
  • 15
    Mar 15th
    15 Files
  • 16
    Mar 16th
    0 Files
  • 17
    Mar 17th
    0 Files
  • 18
    Mar 18th
    10 Files
  • 19
    Mar 19th
    32 Files
  • 20
    Mar 20th
    46 Files
  • 21
    Mar 21st
    16 Files
  • 22
    Mar 22nd
    13 Files
  • 23
    Mar 23rd
    0 Files
  • 24
    Mar 24th
    0 Files
  • 25
    Mar 25th
    12 Files
  • 26
    Mar 26th
    31 Files
  • 27
    Mar 27th
    19 Files
  • 28
    Mar 28th
    0 Files
  • 29
    Mar 29th
    0 Files
  • 30
    Mar 30th
    0 Files
  • 31
    Mar 31st
    0 Files

Top Authors In Last 30 Days

File Tags

Systems

packet storm

© 2022 Packet Storm. All rights reserved.

Services
Security Services
Hosting By
Rokasec
close