Annotation of embedaddon/strongswan/src/libstrongswan/plugins/rc2/rc2_crypter.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2013 Tobias Brunner
! 3: * HSR Hochschule fuer Technik Rapperswil
! 4: *
! 5: * This program is free software; you can redistribute it and/or modify it
! 6: * under the terms of the GNU General Public License as published by the
! 7: * Free Software Foundation; either version 2 of the License, or (at your
! 8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
! 9: *
! 10: * This program is distributed in the hope that it will be useful, but
! 11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
! 13: * for more details.
! 14: */
! 15:
! 16: #include "rc2_crypter.h"
! 17:
! 18: typedef struct private_rc2_crypter_t private_rc2_crypter_t;
! 19:
! 20: #define RC2_BLOCK_SIZE 8
! 21:
! 22: #define ROL16(x, k) ({ uint16_t _x = (x); (_x << (k)) | (_x >> (16 - (k))); })
! 23: #define ROR16(x, k) ({ uint16_t _x = (x); (_x >> (k)) | (_x << (16 - (k))); })
! 24:
! 25: #define GET16(x) ({ u_char *_x = (x); (uint16_t)_x[0] | ((uint16_t)_x[1] << 8); })
! 26: #define PUT16(x, v) ({ u_char *_x = (x); uint16_t _v = (v); _x[0] = _v, _x[1] = _v >> 8; })
! 27:
! 28: /**
! 29: * Private data of rc2_crypter_t
! 30: */
! 31: struct private_rc2_crypter_t {
! 32:
! 33: /**
! 34: * Public interface
! 35: */
! 36: rc2_crypter_t public;
! 37:
! 38: /**
! 39: * The expanded key in 16-bit words
! 40: */
! 41: uint16_t K[64];
! 42:
! 43: /**
! 44: * Key size in bytes
! 45: */
! 46: size_t T;
! 47:
! 48: /**
! 49: * Effective key size in bits
! 50: */
! 51: size_t T1;
! 52: };
! 53:
! 54: /**
! 55: * PITABLE
! 56: */
! 57: static const u_char PITABLE[256] =
! 58: {
! 59: 0xd9, 0x78, 0xf9, 0xc4, 0x19, 0xdd, 0xb5, 0xed,
! 60: 0x28, 0xe9, 0xfd, 0x79, 0x4a, 0xa0, 0xd8, 0x9d,
! 61: 0xc6, 0x7e, 0x37, 0x83, 0x2b, 0x76, 0x53, 0x8e,
! 62: 0x62, 0x4c, 0x64, 0x88, 0x44, 0x8b, 0xfb, 0xa2,
! 63: 0x17, 0x9a, 0x59, 0xf5, 0x87, 0xb3, 0x4f, 0x13,
! 64: 0x61, 0x45, 0x6d, 0x8d, 0x09, 0x81, 0x7d, 0x32,
! 65: 0xbd, 0x8f, 0x40, 0xeb, 0x86, 0xb7, 0x7b, 0x0b,
! 66: 0xf0, 0x95, 0x21, 0x22, 0x5c, 0x6b, 0x4e, 0x82,
! 67: 0x54, 0xd6, 0x65, 0x93, 0xce, 0x60, 0xb2, 0x1c,
! 68: 0x73, 0x56, 0xc0, 0x14, 0xa7, 0x8c, 0xf1, 0xdc,
! 69: 0x12, 0x75, 0xca, 0x1f, 0x3b, 0xbe, 0xe4, 0xd1,
! 70: 0x42, 0x3d, 0xd4, 0x30, 0xa3, 0x3c, 0xb6, 0x26,
! 71: 0x6f, 0xbf, 0x0e, 0xda, 0x46, 0x69, 0x07, 0x57,
! 72: 0x27, 0xf2, 0x1d, 0x9b, 0xbc, 0x94, 0x43, 0x03,
! 73: 0xf8, 0x11, 0xc7, 0xf6, 0x90, 0xef, 0x3e, 0xe7,
! 74: 0x06, 0xc3, 0xd5, 0x2f, 0xc8, 0x66, 0x1e, 0xd7,
! 75: 0x08, 0xe8, 0xea, 0xde, 0x80, 0x52, 0xee, 0xf7,
! 76: 0x84, 0xaa, 0x72, 0xac, 0x35, 0x4d, 0x6a, 0x2a,
! 77: 0x96, 0x1a, 0xd2, 0x71, 0x5a, 0x15, 0x49, 0x74,
! 78: 0x4b, 0x9f, 0xd0, 0x5e, 0x04, 0x18, 0xa4, 0xec,
! 79: 0xc2, 0xe0, 0x41, 0x6e, 0x0f, 0x51, 0xcb, 0xcc,
! 80: 0x24, 0x91, 0xaf, 0x50, 0xa1, 0xf4, 0x70, 0x39,
! 81: 0x99, 0x7c, 0x3a, 0x85, 0x23, 0xb8, 0xb4, 0x7a,
! 82: 0xfc, 0x02, 0x36, 0x5b, 0x25, 0x55, 0x97, 0x31,
! 83: 0x2d, 0x5d, 0xfa, 0x98, 0xe3, 0x8a, 0x92, 0xae,
! 84: 0x05, 0xdf, 0x29, 0x10, 0x67, 0x6c, 0xba, 0xc9,
! 85: 0xd3, 0x00, 0xe6, 0xcf, 0xe1, 0x9e, 0xa8, 0x2c,
! 86: 0x63, 0x16, 0x01, 0x3f, 0x58, 0xe2, 0x89, 0xa9,
! 87: 0x0d, 0x38, 0x34, 0x1b, 0xab, 0x33, 0xff, 0xb0,
! 88: 0xbb, 0x48, 0x0c, 0x5f, 0xb9, 0xb1, 0xcd, 0x2e,
! 89: 0xc5, 0xf3, 0xdb, 0x47, 0xe5, 0xa5, 0x9c, 0x77,
! 90: 0x0a, 0xa6, 0x20, 0x68, 0xfe, 0x7f, 0xc1, 0xad,
! 91: };
! 92:
! 93: /**
! 94: * Encrypt a single block of data
! 95: */
! 96: static void encrypt_block(private_rc2_crypter_t *this, u_char R[])
! 97: {
! 98: register uint16_t R0, R1, R2, R3, *Kj;
! 99: int rounds = 3, mix = 5;
! 100:
! 101: R0 = GET16(R);
! 102: R1 = GET16(R + 2);
! 103: R2 = GET16(R + 4);
! 104: R3 = GET16(R + 6);
! 105: Kj = &this->K[0];
! 106:
! 107: /* 5 mix, mash, 6 mix, mash, 5 mix */
! 108: while (TRUE)
! 109: {
! 110: /* mix */
! 111: R0 = ROL16(R0 + *(Kj++) + (R3 & R2) + (~R3 & R1), 1);
! 112: R1 = ROL16(R1 + *(Kj++) + (R0 & R3) + (~R0 & R2), 2);
! 113: R2 = ROL16(R2 + *(Kj++) + (R1 & R0) + (~R1 & R3), 3);
! 114: R3 = ROL16(R3 + *(Kj++) + (R2 & R1) + (~R2 & R0), 5);
! 115:
! 116: if (--mix == 0)
! 117: {
! 118: if (--rounds == 0)
! 119: {
! 120: break;
! 121: }
! 122: mix = (rounds == 2) ? 6 : 5;
! 123: /* mash */
! 124: R0 += this->K[R3 & 63];
! 125: R1 += this->K[R0 & 63];
! 126: R2 += this->K[R1 & 63];
! 127: R3 += this->K[R2 & 63];
! 128: }
! 129: }
! 130:
! 131: PUT16(R, R0);
! 132: PUT16(R + 2, R1);
! 133: PUT16(R + 4, R2);
! 134: PUT16(R + 6, R3);
! 135: }
! 136:
! 137: /**
! 138: * Decrypt a single block of data.
! 139: */
! 140: static void decrypt_block(private_rc2_crypter_t *this, u_char R[])
! 141: {
! 142: register uint16_t R0, R1, R2, R3, *Kj;
! 143: int rounds = 3, mix = 5;
! 144:
! 145: R0 = GET16(R);
! 146: R1 = GET16(R + 2);
! 147: R2 = GET16(R + 4);
! 148: R3 = GET16(R + 6);
! 149: Kj = &this->K[63];
! 150:
! 151: /* 5 r-mix, r-mash, 6 r-mix, r-mash, 5 r-mix */
! 152: while (TRUE)
! 153: {
! 154: /* r-mix */
! 155: R3 = ROR16(R3, 5);
! 156: R3 = R3 - *(Kj--) - (R2 & R1) - (~R2 & R0);
! 157: R2 = ROR16(R2, 3);
! 158: R2 = R2 - *(Kj--) - (R1 & R0) - (~R1 & R3);
! 159: R1 = ROR16(R1, 2);
! 160: R1 = R1 - *(Kj--) - (R0 & R3) - (~R0 & R2);
! 161: R0 = ROR16(R0, 1);
! 162: R0 = R0 - *(Kj--) - (R3 & R2) - (~R3 & R1);
! 163:
! 164: if (--mix == 0)
! 165: {
! 166: if (--rounds == 0)
! 167: {
! 168: break;
! 169: }
! 170: mix = (rounds == 2) ? 6 : 5;
! 171: /* r-mash */
! 172: R3 -= this->K[R2 & 63];
! 173: R2 -= this->K[R1 & 63];
! 174: R1 -= this->K[R0 & 63];
! 175: R0 -= this->K[R3 & 63];
! 176: }
! 177: }
! 178:
! 179: PUT16(R, R0);
! 180: PUT16(R + 2, R1);
! 181: PUT16(R + 4, R2);
! 182: PUT16(R + 6, R3);
! 183: }
! 184:
! 185: METHOD(crypter_t, decrypt, bool,
! 186: private_rc2_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *decrypted)
! 187: {
! 188: uint8_t *in, *out, *prev;
! 189:
! 190: if (data.len % RC2_BLOCK_SIZE || iv.len != RC2_BLOCK_SIZE)
! 191: {
! 192: return FALSE;
! 193: }
! 194:
! 195: in = data.ptr + data.len - RC2_BLOCK_SIZE;
! 196: out = data.ptr;
! 197: if (decrypted)
! 198: {
! 199: *decrypted = chunk_alloc(data.len);
! 200: out = decrypted->ptr;
! 201: }
! 202: out += data.len - RC2_BLOCK_SIZE;
! 203:
! 204: prev = in;
! 205: for (; in >= data.ptr; in -= RC2_BLOCK_SIZE, out -= RC2_BLOCK_SIZE)
! 206: {
! 207: if (decrypted)
! 208: {
! 209: memcpy(out, in, RC2_BLOCK_SIZE);
! 210: }
! 211: decrypt_block(this, out);
! 212: prev -= RC2_BLOCK_SIZE;
! 213: if (prev < data.ptr)
! 214: {
! 215: prev = iv.ptr;
! 216: }
! 217: memxor(out, prev, RC2_BLOCK_SIZE);
! 218: }
! 219: return TRUE;
! 220: }
! 221:
! 222: METHOD(crypter_t, encrypt, bool,
! 223: private_rc2_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *encrypted)
! 224: {
! 225: uint8_t *in, *out, *end, *prev;
! 226:
! 227: if (data.len % RC2_BLOCK_SIZE || iv.len != RC2_BLOCK_SIZE)
! 228: {
! 229: return FALSE;
! 230: }
! 231:
! 232: in = data.ptr;
! 233: end = data.ptr + data.len;
! 234: out = data.ptr;
! 235: if (encrypted)
! 236: {
! 237: *encrypted = chunk_alloc(data.len);
! 238: out = encrypted->ptr;
! 239: }
! 240:
! 241: prev = iv.ptr;
! 242: for (; in < end; in += RC2_BLOCK_SIZE, out += RC2_BLOCK_SIZE)
! 243: {
! 244: if (encrypted)
! 245: {
! 246: memcpy(out, in, RC2_BLOCK_SIZE);
! 247: }
! 248: memxor(out, prev, RC2_BLOCK_SIZE);
! 249: encrypt_block(this, out);
! 250: prev = out;
! 251: }
! 252: return TRUE;
! 253: }
! 254:
! 255: METHOD(crypter_t, get_block_size, size_t,
! 256: private_rc2_crypter_t *this)
! 257: {
! 258: return RC2_BLOCK_SIZE;
! 259: }
! 260:
! 261: METHOD(crypter_t, get_iv_size, size_t,
! 262: private_rc2_crypter_t *this)
! 263: {
! 264: return RC2_BLOCK_SIZE;
! 265: }
! 266:
! 267: METHOD(crypter_t, get_key_size, size_t,
! 268: private_rc2_crypter_t *this)
! 269: {
! 270: return this->T;
! 271: }
! 272:
! 273: METHOD(crypter_t, set_key, bool,
! 274: private_rc2_crypter_t *this, chunk_t key)
! 275: {
! 276: uint8_t L[128], T8, TM, idx;
! 277: int i;
! 278:
! 279: if (key.len != this->T)
! 280: {
! 281: return FALSE;
! 282: }
! 283: for (i = 0; i < key.len; i++)
! 284: {
! 285: L[i] = key.ptr[i];
! 286: }
! 287: for (; i < 128; i++)
! 288: {
! 289: idx = L[i-1] + L[i-key.len];
! 290: L[i] = PITABLE[idx];
! 291: }
! 292: T8 = (this->T1 + 7) / 8;
! 293: TM = ~(0xff << (8 - (8*T8 - this->T1)));
! 294: L[128-T8] = PITABLE[L[128-T8] & TM];
! 295: for (i = 127-T8; i >= 0; i--)
! 296: {
! 297: idx = L[i+1] ^ L[i+T8];
! 298: L[i] = PITABLE[idx];
! 299: }
! 300: for (i = 0; i < 64; i++)
! 301: {
! 302: this->K[i] = GET16(&L[i << 1]);
! 303: }
! 304: memwipe(L, sizeof(L));
! 305: return TRUE;
! 306: }
! 307:
! 308: METHOD(crypter_t, destroy, void,
! 309: private_rc2_crypter_t *this)
! 310: {
! 311: memwipe(this->K, sizeof(this->K));
! 312: free(this);
! 313: }
! 314:
! 315: /*
! 316: * Described in header
! 317: */
! 318: rc2_crypter_t *rc2_crypter_create(encryption_algorithm_t algo, size_t key_size)
! 319: {
! 320: private_rc2_crypter_t *this;
! 321: size_t effective;
! 322:
! 323: if (algo != ENCR_RC2_CBC)
! 324: {
! 325: return NULL;
! 326: }
! 327: key_size = max(1, key_size);
! 328: effective = RC2_EFFECTIVE_KEY_LEN(key_size);
! 329: key_size = min(128, RC2_KEY_LEN(key_size));
! 330: effective = max(1, min(1024, effective ?: key_size * 8));
! 331:
! 332: INIT(this,
! 333: .public = {
! 334: .crypter = {
! 335: .encrypt = _encrypt,
! 336: .decrypt = _decrypt,
! 337: .get_block_size = _get_block_size,
! 338: .get_iv_size = _get_iv_size,
! 339: .get_key_size = _get_key_size,
! 340: .set_key = _set_key,
! 341: .destroy = _destroy,
! 342: },
! 343: },
! 344: .T = key_size,
! 345: .T1 = effective,
! 346: );
! 347:
! 348: return &this->public;
! 349: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rc2_crypter.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / plugins / rc2