generic-library/openssl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Camellia portability fixes.

Browse Source 
Submitted by: Masashi Fujita, NTT
This commit is contained in:
Andy Polyakov 2006-12-02 10:38:40 +00:00
parent ae93dc13ab
commit 20da8b8f90
4 changed files with 126 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
crypto/camellia/camellia.c
View File

@ -76,12 +76,7 @@
#include "camellia.h" #include "camellia.h"
#include "cmll_locl.h" #include "cmll_locl.h"
/*
* must be defined uint32_t
*/
/* key constants */ /* key constants */
#define CAMELLIA_SIGMA1L (0xA09E667FL) #define CAMELLIA_SIGMA1L (0xA09E667FL)
#define CAMELLIA_SIGMA1R (0x3BCC908BL) #define CAMELLIA_SIGMA1R (0x3BCC908BL)
#define CAMELLIA_SIGMA2L (0xB67AE858L) #define CAMELLIA_SIGMA2L (0xB67AE858L)
@ -100,18 +95,9 @@
*/ */
/* e is pointer of subkey */ /* e is pointer of subkey */
#ifdef L_ENDIAN
#define CamelliaSubkeyL(INDEX) (subkey[(INDEX)*2 + 1])
#define CamelliaSubkeyR(INDEX) (subkey[(INDEX)*2])
#else /* big endian */
#define CamelliaSubkeyL(INDEX) (subkey[(INDEX)*2]) #define CamelliaSubkeyL(INDEX) (subkey[(INDEX)*2])
#define CamelliaSubkeyR(INDEX) (subkey[(INDEX)*2 + 1]) #define CamelliaSubkeyR(INDEX) (subkey[(INDEX)*2 + 1])
#endif /* IS_LITTLE_ENDIAN */
/* rotation right shift 1byte */ /* rotation right shift 1byte */
#define CAMELLIA_RR8(x) (((x) >> 8) + ((x) << 24)) #define CAMELLIA_RR8(x) (((x) >> 8) + ((x) << 24))
/* rotation left shift 1bit */ /* rotation left shift 1bit */
@ -170,44 +156,6 @@ do \
* for speed up * for speed up
* *
*/ */
#if !defined(_MSC_VER)
#define CAMELLIA_FLS(ll, lr, rl, rr, kll, klr, krl, krr, t0, t1, t2, t3) \
do \
{ \
t0 = kll; \
t2 = krr; \
t0 &= ll; \
t2 |= rr; \
rl ^= t2; \
lr ^= CAMELLIA_RL1(t0); \
t3 = krl; \
t1 = klr; \
t3 &= rl; \
t1 |= lr; \
ll ^= t1; \
rr ^= CAMELLIA_RL1(t3); \
} while(0)
#define CAMELLIA_ROUNDSM(xl, xr, kl, kr, yl, yr, il, ir, t0, t1) \
do \
{ \
ir = CAMELLIA_SP1110(xr & 0xff); \
il = CAMELLIA_SP1110((xl>>24) & 0xff); \
ir ^= CAMELLIA_SP0222((xr>>24) & 0xff); \
il ^= CAMELLIA_SP0222((xl>>16) & 0xff); \
ir ^= CAMELLIA_SP3033((xr>>16) & 0xff); \
il ^= CAMELLIA_SP3033((xl>>8) & 0xff); \
ir ^= CAMELLIA_SP4404((xr>>8) & 0xff); \
il ^= CAMELLIA_SP4404(xl & 0xff); \
il ^= kl; \
ir ^= il ^ kr; \
yl ^= ir; \
yr ^= CAMELLIA_RR8(il) ^ ir; \
} while(0)
#else /* for MS-VC */
#define CAMELLIA_FLS(ll, lr, rl, rr, kll, klr, krl, krr, t0, t1, t2, t3) \ #define CAMELLIA_FLS(ll, lr, rl, rr, kll, klr, krl, krr, t0, t1, t2, t3) \
do \ do \
{ \ { \
@ -249,9 +197,8 @@ do \
yl ^= ir; \ yl ^= ir; \
yr ^= il; \ yr ^= il; \
} while(0) } while(0)
#endif
static const uint32_t camellia_sp1110[256] = static const u32 camellia_sp1110[256] =
{ {
0x70707000,0x82828200,0x2c2c2c00,0xececec00, 0x70707000,0x82828200,0x2c2c2c00,0xececec00,
0xb3b3b300,0x27272700,0xc0c0c000,0xe5e5e500, 0xb3b3b300,0x27272700,0xc0c0c000,0xe5e5e500,
@ -319,7 +266,7 @@ static const uint32_t camellia_sp1110[256] =
0x77777700,0xc7c7c700,0x80808000,0x9e9e9e00, 0x77777700,0xc7c7c700,0x80808000,0x9e9e9e00,
}; };
static const uint32_t camellia_sp0222[256] = static const u32 camellia_sp0222[256] =
{ {
0x00e0e0e0,0x00050505,0x00585858,0x00d9d9d9, 0x00e0e0e0,0x00050505,0x00585858,0x00d9d9d9,
0x00676767,0x004e4e4e,0x00818181,0x00cbcbcb, 0x00676767,0x004e4e4e,0x00818181,0x00cbcbcb,
@ -387,7 +334,7 @@ static const uint32_t camellia_sp0222[256] =
0x00eeeeee,0x008f8f8f,0x00010101,0x003d3d3d, 0x00eeeeee,0x008f8f8f,0x00010101,0x003d3d3d,
}; };
static const uint32_t camellia_sp3033[256] = static const u32 camellia_sp3033[256] =
{ {
0x38003838,0x41004141,0x16001616,0x76007676, 0x38003838,0x41004141,0x16001616,0x76007676,
0xd900d9d9,0x93009393,0x60006060,0xf200f2f2, 0xd900d9d9,0x93009393,0x60006060,0xf200f2f2,
@ -455,7 +402,7 @@ static const uint32_t camellia_sp3033[256] =
0xbb00bbbb,0xe300e3e3,0x40004040,0x4f004f4f, 0xbb00bbbb,0xe300e3e3,0x40004040,0x4f004f4f,
}; };
static const uint32_t camellia_sp4404[256] = static const u32 camellia_sp4404[256] =
{ {
0x70700070,0x2c2c002c,0xb3b300b3,0xc0c000c0, 0x70700070,0x2c2c002c,0xb3b300b3,0xc0c000c0,
0xe4e400e4,0x57570057,0xeaea00ea,0xaeae00ae, 0xe4e400e4,0x57570057,0xeaea00ea,0xaeae00ae,
@ -523,20 +470,19 @@ static const uint32_t camellia_sp4404[256] =
0xe3e300e3,0xf4f400f4,0xc7c700c7,0x9e9e009e, 0xe3e300e3,0xf4f400f4,0xc7c700c7,0x9e9e009e,
}; };
/** /**
* Stuff related to the Camellia key schedule * Stuff related to the Camellia key schedule
*/ */
#define subl(x) subL[(x)] #define subl(x) subL[(x)]
#define subr(x) subR[(x)] #define subr(x) subR[(x)]
void camellia_setup128(const unsigned char *key, uint32_t *subkey) void camellia_setup128(const u8 *key, u32 *subkey)
{ {
uint32_t kll, klr, krl, krr; u32 kll, klr, krl, krr;
uint32_t il, ir, t0, t1, w0, w1; u32 il, ir, t0, t1, w0, w1;
uint32_t kw4l, kw4r, dw, tl, tr; u32 kw4l, kw4r, dw, tl, tr;
uint32_t subL[26]; u32 subL[26];
uint32_t subR[26]; u32 subR[26];
/** /**
* k == kll || klr || krl || krr (|| is concatination) * k == kll || klr || krl || krr (|| is concatination)
@ -833,14 +779,14 @@ void camellia_setup128(const unsigned char *key, uint32_t *subkey)
return; return;
} }
void camellia_setup256(const unsigned char *key, uint32_t *subkey) void camellia_setup256(const u8 *key, u32 *subkey)
{ {
uint32_t kll,klr,krl,krr; /* left half of key */ u32 kll,klr,krl,krr; /* left half of key */
uint32_t krll,krlr,krrl,krrr; /* right half of key */ u32 krll,krlr,krrl,krrr; /* right half of key */
uint32_t il, ir, t0, t1, w0, w1; /* temporary variables */ u32 il, ir, t0, t1, w0, w1; /* temporary variables */
uint32_t kw4l, kw4r, dw, tl, tr; u32 kw4l, kw4r, dw, tl, tr;
uint32_t subL[34]; u32 subL[34];
uint32_t subR[34]; u32 subR[34];
/** /**
* key = (kll || klr || krl || krr || krll || krlr || krrl || krrr) * key = (kll || klr || krl || krr || krll || krlr || krrl || krrr)
@ -1245,18 +1191,18 @@ void camellia_setup256(const unsigned char *key, uint32_t *subkey)
return; return;
} }
void camellia_setup192(const unsigned char *key, uint32_t *subkey) void camellia_setup192(const u8 *key, u32 *subkey)
{ {
unsigned char kk[32]; u8 kk[32];
uint32_t krll, krlr, krrl,krrr; u32 krll, krlr, krrl,krrr;
memcpy(kk, key, 24); memcpy(kk, key, 24);
memcpy((unsigned char *)&krll, key+16,4); memcpy((u8 *)&krll, key+16,4);
memcpy((unsigned char *)&krlr, key+20,4); memcpy((u8 *)&krlr, key+20,4);
krrl = ~krll; krrl = ~krll;
krrr = ~krlr; krrr = ~krlr;
memcpy(kk+24, (unsigned char *)&krrl, 4); memcpy(kk+24, (u8 *)&krrl, 4);
memcpy(kk+28, (unsigned char *)&krrr, 4); memcpy(kk+28, (u8 *)&krrr, 4);
camellia_setup256(kk, subkey); camellia_setup256(kk, subkey);
return; return;
} }
@ -1265,11 +1211,10 @@ void camellia_setup192(const unsigned char *key, uint32_t *subkey)
/** /**
* Stuff related to camellia encryption/decryption * Stuff related to camellia encryption/decryption
*/ */
void camellia_encrypt128(const uint32_t *subkey, uint32_t *io) void camellia_encrypt128(const u32 *subkey, u32 *io)
{ {
uint32_t il, ir, t0, t1; u32 il, ir, t0, t1;
SWAP4WORD(io);
/* pre whitening but absorb kw2*/ /* pre whitening but absorb kw2*/
io[0] ^= CamelliaSubkeyL(0); io[0] ^= CamelliaSubkeyL(0);
io[1] ^= CamelliaSubkeyR(0); io[1] ^= CamelliaSubkeyR(0);
@ -1352,16 +1297,13 @@ void camellia_encrypt128(const uint32_t *subkey, uint32_t *io)
io[1] = io[3]; io[1] = io[3];
io[2] = t0; io[2] = t0;
io[3] = t1; io[3] = t1;
SWAP4WORD(io);
return; return;
} }
void camellia_decrypt128(const uint32_t *subkey, uint32_t *io) void camellia_decrypt128(const u32 *subkey, u32 *io)
{ {
uint32_t il,ir,t0,t1; /* temporary valiables */ u32 il,ir,t0,t1; /* temporary valiables */
SWAP4WORD(io);
/* pre whitening but absorb kw2*/ /* pre whitening but absorb kw2*/
io[0] ^= CamelliaSubkeyL(24); io[0] ^= CamelliaSubkeyL(24);
@ -1445,7 +1387,6 @@ void camellia_decrypt128(const uint32_t *subkey, uint32_t *io)
io[1] = io[3]; io[1] = io[3];
io[2] = t0; io[2] = t0;
io[3] = t1; io[3] = t1;
SWAP4WORD(io);
return; return;
} }
@ -1453,11 +1394,9 @@ void camellia_decrypt128(const uint32_t *subkey, uint32_t *io)
/** /**
* stuff for 192 and 256bit encryption/decryption * stuff for 192 and 256bit encryption/decryption
*/ */
void camellia_encrypt256(const uint32_t *subkey, uint32_t *io) void camellia_encrypt256(const u32 *subkey, u32 *io)
{ {
uint32_t il,ir,t0,t1; /* temporary valiables */ u32 il,ir,t0,t1; /* temporary valiables */
SWAP4WORD(io);
/* pre whitening but absorb kw2*/ /* pre whitening but absorb kw2*/
io[0] ^= CamelliaSubkeyL(0); io[0] ^= CamelliaSubkeyL(0);
@ -1565,16 +1504,14 @@ void camellia_encrypt256(const uint32_t *subkey, uint32_t *io)
io[1] = io[3]; io[1] = io[3];
io[2] = t0; io[2] = t0;
io[3] = t1; io[3] = t1;
SWAP4WORD(io);
return; return;
} }
void camellia_decrypt256(const uint32_t *subkey, uint32_t *io) void camellia_decrypt256(const u32 *subkey, u32 *io)
{ {
uint32_t il,ir,t0,t1; /* temporary valiables */ u32 il,ir,t0,t1; /* temporary valiables */
SWAP4WORD(io);
/* pre whitening but absorb kw2*/ /* pre whitening but absorb kw2*/
io[0] ^= CamelliaSubkeyL(32); io[0] ^= CamelliaSubkeyL(32);
io[1] ^= CamelliaSubkeyR(32); io[1] ^= CamelliaSubkeyR(32);
@ -1681,7 +1618,6 @@ void camellia_decrypt256(const uint32_t *subkey, uint32_t *io)
io[1] = io[3]; io[1] = io[3];
io[2] = t0; io[2] = t0;
io[3] = t1; io[3] = t1;
SWAP4WORD(io);
return; return;
} }

73
crypto/camellia/cmll_cbc.c
View File

@ -69,7 +69,8 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
unsigned long len = length; unsigned long len = length;
unsigned char tmp[CAMELLIA_BLOCK_SIZE]; unsigned char tmp[CAMELLIA_BLOCK_SIZE];
const unsigned char *iv = ivec; const unsigned char *iv = ivec;
uint32_t t32[UNITSIZE]; u32 t32[UNITSIZE];
const union { long one; char little; } camellia_endian = {1};
assert(in && out && key && ivec); assert(in && out && key && ivec);
@ -83,9 +84,13 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
{ {
while (len >= CAMELLIA_BLOCK_SIZE) while (len >= CAMELLIA_BLOCK_SIZE)
{ {
XOR4WORD2((uint32_t *)out, XOR4WORD2((u32 *)out,
(uint32_t *)in, (uint32_t *)iv); (u32 *)in, (u32 *)iv);
key->enc(key->rd_key, (uint32_t *)out); if (camellia_endian.little)
SWAP4WORD((u32 *)out);
key->enc(key->rd_key, (u32 *)out);
if (camellia_endian.little)
SWAP4WORD((u32 *)out);
iv = out; iv = out;
len -= CAMELLIA_BLOCK_SIZE; len -= CAMELLIA_BLOCK_SIZE;
in += CAMELLIA_BLOCK_SIZE; in += CAMELLIA_BLOCK_SIZE;
@ -97,7 +102,11 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
out[n] = in[n] ^ iv[n]; out[n] = in[n] ^ iv[n];
for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n) for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n)
out[n] = iv[n]; out[n] = iv[n];
key->enc(key->rd_key, (uint32_t *)out); if (camellia_endian.little)
SWAP4WORD((u32 *)out);
key->enc(key->rd_key, (u32 *)out);
if (camellia_endian.little)
SWAP4WORD((u32 *)out);
iv = out; iv = out;
} }
memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE); memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE);
@ -107,8 +116,12 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
while (len >= CAMELLIA_BLOCK_SIZE) while (len >= CAMELLIA_BLOCK_SIZE)
{ {
memcpy(out,in,CAMELLIA_BLOCK_SIZE); memcpy(out,in,CAMELLIA_BLOCK_SIZE);
key->dec(key->rd_key,(uint32_t *)out); if (camellia_endian.little)
XOR4WORD((uint32_t *)out, (uint32_t *)iv); SWAP4WORD((u32 *)out);
key->dec(key->rd_key,(u32 *)out);
if (camellia_endian.little)
SWAP4WORD((u32 *)out);
XOR4WORD((u32 *)out, (u32 *)iv);
iv = in; iv = in;
len -= CAMELLIA_BLOCK_SIZE; len -= CAMELLIA_BLOCK_SIZE;
in += CAMELLIA_BLOCK_SIZE; in += CAMELLIA_BLOCK_SIZE;
@ -117,7 +130,11 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
if (len) if (len)
{ {
memcpy(tmp, in, CAMELLIA_BLOCK_SIZE); memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
key->dec(key->rd_key, (uint32_t *)tmp); if (camellia_endian.little)
SWAP4WORD((u32 *)tmp);
key->dec(key->rd_key, (u32 *)tmp);
if (camellia_endian.little)
SWAP4WORD((u32 *)tmp);
for(n=0; n < len; ++n) for(n=0; n < len; ++n)
out[n] = tmp[n] ^ iv[n]; out[n] = tmp[n] ^ iv[n];
iv = in; iv = in;
@ -129,8 +146,12 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
while (len >= CAMELLIA_BLOCK_SIZE) while (len >= CAMELLIA_BLOCK_SIZE)
{ {
memcpy(tmp, in, CAMELLIA_BLOCK_SIZE); memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
key->dec(key->rd_key, (uint32_t *)out); if (camellia_endian.little)
XOR4WORD((uint32_t *)out, (uint32_t *)ivec); SWAP4WORD((u32 *)out);
key->dec(key->rd_key, (u32 *)out);
if (camellia_endian.little)
SWAP4WORD((u32 *)out);
XOR4WORD((u32 *)out, (u32 *)ivec);
memcpy(ivec, tmp, CAMELLIA_BLOCK_SIZE); memcpy(ivec, tmp, CAMELLIA_BLOCK_SIZE);
len -= CAMELLIA_BLOCK_SIZE; len -= CAMELLIA_BLOCK_SIZE;
in += CAMELLIA_BLOCK_SIZE; in += CAMELLIA_BLOCK_SIZE;
@ -139,7 +160,11 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
if (len) if (len)
{ {
memcpy(tmp, in, CAMELLIA_BLOCK_SIZE); memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
key->dec(key->rd_key,(uint32_t *)out); if (camellia_endian.little)
SWAP4WORD((u32 *)out);
key->dec(key->rd_key,(u32 *)out);
if (camellia_endian.little)
SWAP4WORD((u32 *)out);
for(n=0; n < len; ++n) for(n=0; n < len; ++n)
out[n] ^= ivec[n]; out[n] ^= ivec[n];
for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n) for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n)
@ -157,7 +182,11 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n) for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n)
out[n] = in[n] ^ iv[n]; out[n] = in[n] ^ iv[n];
memcpy(t32, out, CAMELLIA_BLOCK_SIZE); memcpy(t32, out, CAMELLIA_BLOCK_SIZE);
if (camellia_endian.little)
SWAP4WORD(t32);
key->enc(key->rd_key, t32); key->enc(key->rd_key, t32);
if (camellia_endian.little)
SWAP4WORD(t32);
memcpy(out, t32, CAMELLIA_BLOCK_SIZE); memcpy(out, t32, CAMELLIA_BLOCK_SIZE);
iv = out; iv = out;
len -= CAMELLIA_BLOCK_SIZE; len -= CAMELLIA_BLOCK_SIZE;
@ -170,7 +199,11 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
out[n] = in[n] ^ iv[n]; out[n] = in[n] ^ iv[n];
for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n) for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n)
out[n] = iv[n]; out[n] = iv[n];
key->enc(key->rd_key, (uint32_t *)out); if (camellia_endian.little)
SWAP4WORD((u32 *)out);
key->enc(key->rd_key, (u32 *)out);
if (camellia_endian.little)
SWAP4WORD((u32 *)out);
iv = out; iv = out;
} }
memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE); memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE);
@ -180,7 +213,11 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
while (len >= CAMELLIA_BLOCK_SIZE) while (len >= CAMELLIA_BLOCK_SIZE)
{ {
memcpy(t32,in,CAMELLIA_BLOCK_SIZE); memcpy(t32,in,CAMELLIA_BLOCK_SIZE);
if (camellia_endian.little)
SWAP4WORD(t32);
key->dec(key->rd_key,t32); key->dec(key->rd_key,t32);
if (camellia_endian.little)
SWAP4WORD(t32);
memcpy(out,t32,CAMELLIA_BLOCK_SIZE); memcpy(out,t32,CAMELLIA_BLOCK_SIZE);
for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n) for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n)
out[n] ^= iv[n]; out[n] ^= iv[n];
@ -193,7 +230,11 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
{ {
memcpy(tmp, in, CAMELLIA_BLOCK_SIZE); memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
memcpy(t32, in, CAMELLIA_BLOCK_SIZE); memcpy(t32, in, CAMELLIA_BLOCK_SIZE);
if (camellia_endian.little)
SWAP4WORD(t32);
key->dec(key->rd_key, t32); key->dec(key->rd_key, t32);
if (camellia_endian.little)
SWAP4WORD(t32);
memcpy(out, t32, CAMELLIA_BLOCK_SIZE); memcpy(out, t32, CAMELLIA_BLOCK_SIZE);
for(n=0; n < len; ++n) for(n=0; n < len; ++n)
out[n] = tmp[n] ^ iv[n]; out[n] = tmp[n] ^ iv[n];
@ -207,7 +248,11 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
{ {
memcpy(tmp, in, CAMELLIA_BLOCK_SIZE); memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
memcpy(t32, in, CAMELLIA_BLOCK_SIZE); memcpy(t32, in, CAMELLIA_BLOCK_SIZE);
if (camellia_endian.little)
SWAP4WORD(t32);
key->dec(key->rd_key, t32); key->dec(key->rd_key, t32);
if (camellia_endian.little)
SWAP4WORD(t32);
memcpy(out, t32, CAMELLIA_BLOCK_SIZE); memcpy(out, t32, CAMELLIA_BLOCK_SIZE);
for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n) for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n)
out[n] ^= ivec[n]; out[n] ^= ivec[n];
@ -220,7 +265,11 @@ void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
{ {
memcpy(tmp, in, CAMELLIA_BLOCK_SIZE); memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
memcpy(t32, in, CAMELLIA_BLOCK_SIZE); memcpy(t32, in, CAMELLIA_BLOCK_SIZE);
if (camellia_endian.little)
SWAP4WORD(t32);
key->dec(key->rd_key,t32); key->dec(key->rd_key,t32);
if (camellia_endian.little)
SWAP4WORD(t32);
memcpy(out, t32, CAMELLIA_BLOCK_SIZE); memcpy(out, t32, CAMELLIA_BLOCK_SIZE);
for(n=0; n < len; ++n) for(n=0; n < len; ++n)
out[n] ^= ivec[n]; out[n] ^= ivec[n];

58
crypto/camellia/cmll_locl.h
View File

@ -73,13 +73,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#if defined(_MSC_VER) typedef unsigned char u8;
typedef unsigned char uint8_t; typedef unsigned int u32;
typedef unsigned int uint32_t;
typedef unsigned __int64 uint64_t;
#else
#include <inttypes.h>
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -90,38 +85,33 @@ extern "C" {
#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_AMD64) || defined(_M_X64)) #if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_AMD64) || defined(_M_X64))
# define SWAP(x) ( _lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00 ) # define SWAP(x) ( _lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00 )
# define GETU32(p) SWAP(*((uint32_t *)(p))) # define GETU32(p) SWAP(*((u32 *)(p)))
# define PUTU32(ct, st) { *((uint32_t *)(ct)) = SWAP((st)); } # define PUTU32(ct, st) { *((u32 *)(ct)) = SWAP((st)); }
# define CAMELLIA_SWAP4(x) (x = ( _lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00) ) # define CAMELLIA_SWAP4(x) (x = ( _lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00) )
#else /* not windows */ #else /* not windows */
# define GETU32(pt) (((uint32_t)(pt)[0] << 24) \ # define GETU32(pt) (((u32)(pt)[0] << 24) \
^ ((uint32_t)(pt)[1] << 16) \ ^ ((u32)(pt)[1] << 16) \
^ ((uint32_t)(pt)[2] << 8) \ ^ ((u32)(pt)[2] << 8) \
^ ((uint32_t)(pt)[3])) ^ ((u32)(pt)[3]))
# define PUTU32(ct, st) { (ct)[0] = (uint8_t)((st) >> 24); \ # define PUTU32(ct, st) { (ct)[0] = (u8)((st) >> 24); \
(ct)[1] = (uint8_t)((st) >> 16); \ (ct)[1] = (u8)((st) >> 16); \
(ct)[2] = (uint8_t)((st) >> 8); \ (ct)[2] = (u8)((st) >> 8); \
(ct)[3] = (uint8_t)(st); } (ct)[3] = (u8)(st); }
#ifdef L_ENDIAN #if (defined (__GNUC__) && (defined(__x86_64__) || defined(__x86_64)))
#if (defined (__GNUC__) && !defined(i386))
#define CAMELLIA_SWAP4(x) \ #define CAMELLIA_SWAP4(x) \
do{\ do{\
asm("bswap %1" : "+r" (x));\ asm("bswap %1" : "+r" (x));\
}while(0) }while(0)
#else /* not gcc */ #else
#define CAMELLIA_SWAP4(x) \ #define CAMELLIA_SWAP4(x) \
do{\ do{\
x = ((uint32_t)x << 16) + ((uint32_t)x >> 16);\ x = ((u32)x << 16) + ((u32)x >> 16);\
x = (((uint32_t)x & 0xff00ff) << 8) + (((uint32_t)x >> 8) & 0xff00ff);\ x = (((u32)x & 0xff00ff) << 8) + (((u32)x >> 8) & 0xff00ff);\
} while(0) } while(0)
#endif /* not gcc */ #endif
#else /* big endian */
#define CAMELLIA_SWAP4(x)
#endif /* L_ENDIAN */
#endif #endif
#define COPY4WORD(dst, src) \ #define COPY4WORD(dst, src) \
@ -161,14 +151,14 @@ extern "C" {
}while(0) }while(0)
void camellia_setup128(const unsigned char *key, uint32_t *subkey); void camellia_setup128(const u8 *key, u32 *subkey);
void camellia_setup192(const unsigned char *key, uint32_t *subkey); void camellia_setup192(const u8 *key, u32 *subkey);
void camellia_setup256(const unsigned char *key, uint32_t *subkey); void camellia_setup256(const u8 *key, u32 *subkey);
void camellia_encrypt128(const uint32_t *subkey, uint32_t *io); void camellia_encrypt128(const u32 *subkey, u32 *io);
void camellia_decrypt128(const uint32_t *subkey, uint32_t *io); void camellia_decrypt128(const u32 *subkey, u32 *io);
void camellia_encrypt256(const uint32_t *subkey, uint32_t *io); void camellia_encrypt256(const u32 *subkey, u32 *io);
void camellia_decrypt256(const uint32_t *subkey, uint32_t *io); void camellia_decrypt256(const u32 *subkey, u32 *io);
#ifdef __cplusplus #ifdef __cplusplus
} }

10
crypto/camellia/cmll_misc.c
View File

@ -91,20 +91,26 @@ int Camellia_set_key(const unsigned char *userKey, const int bits,
void Camellia_encrypt(const unsigned char *in, unsigned char *out, void Camellia_encrypt(const unsigned char *in, unsigned char *out,
const CAMELLIA_KEY *key) const CAMELLIA_KEY *key)
{ {
uint32_t tmp[UNITSIZE]; u32 tmp[UNITSIZE];
const union { long one; char little; } camellia_endian = {1};
memcpy(tmp, in, CAMELLIA_BLOCK_SIZE); memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
if (camellia_endian.little) SWAP4WORD(tmp);
key->enc(key->rd_key, tmp); key->enc(key->rd_key, tmp);
if (camellia_endian.little) SWAP4WORD(tmp);
memcpy(out, tmp, CAMELLIA_BLOCK_SIZE); memcpy(out, tmp, CAMELLIA_BLOCK_SIZE);
} }
void Camellia_decrypt(const unsigned char *in, unsigned char *out, void Camellia_decrypt(const unsigned char *in, unsigned char *out,
const CAMELLIA_KEY *key) const CAMELLIA_KEY *key)
{ {
uint32_t tmp[UNITSIZE]; u32 tmp[UNITSIZE];
const union { long one; char little; } camellia_endian = {1};
memcpy(tmp, in, CAMELLIA_BLOCK_SIZE); memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
if (camellia_endian.little) SWAP4WORD(tmp);
key->dec(key->rd_key, tmp); key->dec(key->rd_key, tmp);
if (camellia_endian.little) SWAP4WORD(tmp);
memcpy(out, tmp, CAMELLIA_BLOCK_SIZE); memcpy(out, tmp, CAMELLIA_BLOCK_SIZE);
} }