Deleted Added
sdiff udiff text old ( 162911 ) new ( 167612 )
full compact
cmll_cbc.c (162911) cmll_cbc.c (167612)
1/* crypto/camellia/camellia_cbc.c -*- mode:C; c-file-style: "eay" -*- */
2/* ====================================================================
3 * Copyright (c) 2006 The OpenSSL Project. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *

--- 53 unchanged lines hidden (view full) ---

62#include "cmll_locl.h"
63
64void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
65 const unsigned long length, const CAMELLIA_KEY *key,
66 unsigned char *ivec, const int enc) {
67
68 unsigned long n;
69 unsigned long len = length;
1/* crypto/camellia/camellia_cbc.c -*- mode:C; c-file-style: "eay" -*- */
2/* ====================================================================
3 * Copyright (c) 2006 The OpenSSL Project. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *

--- 53 unchanged lines hidden (view full) ---

62#include "cmll_locl.h"
63
64void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out,
65 const unsigned long length, const CAMELLIA_KEY *key,
66 unsigned char *ivec, const int enc) {
67
68 unsigned long n;
69 unsigned long len = length;
70 unsigned char tmp[CAMELLIA_BLOCK_SIZE];
71 const unsigned char *iv = ivec;
70 const unsigned char *iv = ivec;
72 uint32_t t32[UNITSIZE];
71 union { u32 t32[CAMELLIA_BLOCK_SIZE/sizeof(u32)];
72 u8 t8 [CAMELLIA_BLOCK_SIZE]; } tmp;
73 const union { long one; char little; } camellia_endian = {1};
73
74
75 assert(in && out && key && ivec);
76 assert((CAMELLIA_ENCRYPT == enc)||(CAMELLIA_DECRYPT == enc));
77
74
75
76 assert(in && out && key && ivec);
77 assert((CAMELLIA_ENCRYPT == enc)||(CAMELLIA_DECRYPT == enc));
78
78 if(((size_t)in) % ALIGN == 0
79 && ((size_t)out) % ALIGN == 0
80 && ((size_t)ivec) % ALIGN == 0)
79 if(((size_t)in|(size_t)out|(size_t)ivec) % sizeof(u32) == 0)
81 {
82 if (CAMELLIA_ENCRYPT == enc)
83 {
84 while (len >= CAMELLIA_BLOCK_SIZE)
85 {
80 {
81 if (CAMELLIA_ENCRYPT == enc)
82 {
83 while (len >= CAMELLIA_BLOCK_SIZE)
84 {
86 XOR4WORD2((uint32_t *)out,
87 (uint32_t *)in, (uint32_t *)iv);
88 key->enc(key->rd_key, (uint32_t *)out);
85 XOR4WORD2((u32 *)out,
86 (u32 *)in, (u32 *)iv);
87 if (camellia_endian.little)
88 SWAP4WORD((u32 *)out);
89 key->enc(key->rd_key, (u32 *)out);
90 if (camellia_endian.little)
91 SWAP4WORD((u32 *)out);
89 iv = out;
90 len -= CAMELLIA_BLOCK_SIZE;
91 in += CAMELLIA_BLOCK_SIZE;
92 out += CAMELLIA_BLOCK_SIZE;
93 }
94 if (len)
95 {
96 for(n=0; n < len; ++n)
97 out[n] = in[n] ^ iv[n];
98 for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n)
99 out[n] = iv[n];
92 iv = out;
93 len -= CAMELLIA_BLOCK_SIZE;
94 in += CAMELLIA_BLOCK_SIZE;
95 out += CAMELLIA_BLOCK_SIZE;
96 }
97 if (len)
98 {
99 for(n=0; n < len; ++n)
100 out[n] = in[n] ^ iv[n];
101 for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n)
102 out[n] = iv[n];
100 key->enc(key->rd_key, (uint32_t *)out);
103 if (camellia_endian.little)
104 SWAP4WORD((u32 *)out);
105 key->enc(key->rd_key, (u32 *)out);
106 if (camellia_endian.little)
107 SWAP4WORD((u32 *)out);
101 iv = out;
102 }
103 memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE);
104 }
105 else if (in != out)
106 {
107 while (len >= CAMELLIA_BLOCK_SIZE)
108 {
109 memcpy(out,in,CAMELLIA_BLOCK_SIZE);
108 iv = out;
109 }
110 memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE);
111 }
112 else if (in != out)
113 {
114 while (len >= CAMELLIA_BLOCK_SIZE)
115 {
116 memcpy(out,in,CAMELLIA_BLOCK_SIZE);
110 key->dec(key->rd_key,(uint32_t *)out);
111 XOR4WORD((uint32_t *)out, (uint32_t *)iv);
117 if (camellia_endian.little)
118 SWAP4WORD((u32 *)out);
119 key->dec(key->rd_key,(u32 *)out);
120 if (camellia_endian.little)
121 SWAP4WORD((u32 *)out);
122 XOR4WORD((u32 *)out, (u32 *)iv);
112 iv = in;
113 len -= CAMELLIA_BLOCK_SIZE;
114 in += CAMELLIA_BLOCK_SIZE;
115 out += CAMELLIA_BLOCK_SIZE;
116 }
117 if (len)
118 {
123 iv = in;
124 len -= CAMELLIA_BLOCK_SIZE;
125 in += CAMELLIA_BLOCK_SIZE;
126 out += CAMELLIA_BLOCK_SIZE;
127 }
128 if (len)
129 {
119 memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
120 key->dec(key->rd_key, (uint32_t *)tmp);
130 memcpy(tmp.t8, in, CAMELLIA_BLOCK_SIZE);
131 if (camellia_endian.little)
132 SWAP4WORD(tmp.t32);
133 key->dec(key->rd_key, tmp.t32);
134 if (camellia_endian.little)
135 SWAP4WORD(tmp.t32);
121 for(n=0; n < len; ++n)
136 for(n=0; n < len; ++n)
122 out[n] = tmp[n] ^ iv[n];
137 out[n] = tmp.t8[n] ^ iv[n];
123 iv = in;
124 }
125 memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE);
126 }
127 else /* in == out */
128 {
129 while (len >= CAMELLIA_BLOCK_SIZE)
130 {
138 iv = in;
139 }
140 memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE);
141 }
142 else /* in == out */
143 {
144 while (len >= CAMELLIA_BLOCK_SIZE)
145 {
131 memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
132 key->dec(key->rd_key, (uint32_t *)out);
133 XOR4WORD((uint32_t *)out, (uint32_t *)ivec);
134 memcpy(ivec, tmp, CAMELLIA_BLOCK_SIZE);
146 memcpy(tmp.t8, in, CAMELLIA_BLOCK_SIZE);
147 if (camellia_endian.little)
148 SWAP4WORD((u32 *)out);
149 key->dec(key->rd_key, (u32 *)out);
150 if (camellia_endian.little)
151 SWAP4WORD((u32 *)out);
152 XOR4WORD((u32 *)out, (u32 *)ivec);
153 memcpy(ivec, tmp.t8, CAMELLIA_BLOCK_SIZE);
135 len -= CAMELLIA_BLOCK_SIZE;
136 in += CAMELLIA_BLOCK_SIZE;
137 out += CAMELLIA_BLOCK_SIZE;
138 }
139 if (len)
140 {
154 len -= CAMELLIA_BLOCK_SIZE;
155 in += CAMELLIA_BLOCK_SIZE;
156 out += CAMELLIA_BLOCK_SIZE;
157 }
158 if (len)
159 {
141 memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
142 key->dec(key->rd_key,(uint32_t *)out);
160 memcpy(tmp.t8, in, CAMELLIA_BLOCK_SIZE);
161 if (camellia_endian.little)
162 SWAP4WORD((u32 *)out);
163 key->dec(key->rd_key,(u32 *)out);
164 if (camellia_endian.little)
165 SWAP4WORD((u32 *)out);
143 for(n=0; n < len; ++n)
144 out[n] ^= ivec[n];
145 for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n)
166 for(n=0; n < len; ++n)
167 out[n] ^= ivec[n];
168 for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n)
146 out[n] = tmp[n];
147 memcpy(ivec, tmp, CAMELLIA_BLOCK_SIZE);
169 out[n] = tmp.t8[n];
170 memcpy(ivec, tmp.t8, CAMELLIA_BLOCK_SIZE);
148 }
149 }
150 }
151 else /* no aligned */
152 {
153 if (CAMELLIA_ENCRYPT == enc)
154 {
155 while (len >= CAMELLIA_BLOCK_SIZE)
156 {
157 for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n)
171 }
172 }
173 }
174 else /* no aligned */
175 {
176 if (CAMELLIA_ENCRYPT == enc)
177 {
178 while (len >= CAMELLIA_BLOCK_SIZE)
179 {
180 for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n)
158 out[n] = in[n] ^ iv[n];
159 memcpy(t32, out, CAMELLIA_BLOCK_SIZE);
160 key->enc(key->rd_key, t32);
161 memcpy(out, t32, CAMELLIA_BLOCK_SIZE);
181 tmp.t8[n] = in[n] ^ iv[n];
182 if (camellia_endian.little)
183 SWAP4WORD(tmp.t32);
184 key->enc(key->rd_key, tmp.t32);
185 if (camellia_endian.little)
186 SWAP4WORD(tmp.t32);
187 memcpy(out, tmp.t8, CAMELLIA_BLOCK_SIZE);
162 iv = out;
163 len -= CAMELLIA_BLOCK_SIZE;
164 in += CAMELLIA_BLOCK_SIZE;
165 out += CAMELLIA_BLOCK_SIZE;
166 }
167 if (len)
168 {
169 for(n=0; n < len; ++n)
188 iv = out;
189 len -= CAMELLIA_BLOCK_SIZE;
190 in += CAMELLIA_BLOCK_SIZE;
191 out += CAMELLIA_BLOCK_SIZE;
192 }
193 if (len)
194 {
195 for(n=0; n < len; ++n)
170 out[n] = in[n] ^ iv[n];
196 tmp.t8[n] = in[n] ^ iv[n];
171 for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n)
197 for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n)
172 out[n] = iv[n];
173 key->enc(key->rd_key, (uint32_t *)out);
198 tmp.t8[n] = iv[n];
199 if (camellia_endian.little)
200 SWAP4WORD(tmp.t32);
201 key->enc(key->rd_key, tmp.t32);
202 if (camellia_endian.little)
203 SWAP4WORD(tmp.t32);
204 memcpy(out, tmp.t8, CAMELLIA_BLOCK_SIZE);
174 iv = out;
175 }
176 memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE);
177 }
178 else if (in != out)
179 {
180 while (len >= CAMELLIA_BLOCK_SIZE)
181 {
205 iv = out;
206 }
207 memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE);
208 }
209 else if (in != out)
210 {
211 while (len >= CAMELLIA_BLOCK_SIZE)
212 {
182 memcpy(t32,in,CAMELLIA_BLOCK_SIZE);
183 key->dec(key->rd_key,t32);
184 memcpy(out,t32,CAMELLIA_BLOCK_SIZE);
213 memcpy(tmp.t8,in,CAMELLIA_BLOCK_SIZE);
214 if (camellia_endian.little)
215 SWAP4WORD(tmp.t32);
216 key->dec(key->rd_key,tmp.t32);
217 if (camellia_endian.little)
218 SWAP4WORD(tmp.t32);
185 for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n)
219 for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n)
186 out[n] ^= iv[n];
220 out[n] = tmp.t8[n] ^ iv[n];
187 iv = in;
188 len -= CAMELLIA_BLOCK_SIZE;
189 in += CAMELLIA_BLOCK_SIZE;
190 out += CAMELLIA_BLOCK_SIZE;
191 }
192 if (len)
193 {
221 iv = in;
222 len -= CAMELLIA_BLOCK_SIZE;
223 in += CAMELLIA_BLOCK_SIZE;
224 out += CAMELLIA_BLOCK_SIZE;
225 }
226 if (len)
227 {
194 memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
195 memcpy(t32, in, CAMELLIA_BLOCK_SIZE);
196 key->dec(key->rd_key, t32);
197 memcpy(out, t32, CAMELLIA_BLOCK_SIZE);
228 memcpy(tmp.t8, in, CAMELLIA_BLOCK_SIZE);
229 if (camellia_endian.little)
230 SWAP4WORD(tmp.t32);
231 key->dec(key->rd_key, tmp.t32);
232 if (camellia_endian.little)
233 SWAP4WORD(tmp.t32);
198 for(n=0; n < len; ++n)
234 for(n=0; n < len; ++n)
199 out[n] = tmp[n] ^ iv[n];
235 out[n] = tmp.t8[n] ^ iv[n];
200 iv = in;
201 }
202 memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE);
203 }
204 else
205 {
206 while (len >= CAMELLIA_BLOCK_SIZE)
207 {
236 iv = in;
237 }
238 memcpy(ivec,iv,CAMELLIA_BLOCK_SIZE);
239 }
240 else
241 {
242 while (len >= CAMELLIA_BLOCK_SIZE)
243 {
208 memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
209 memcpy(t32, in, CAMELLIA_BLOCK_SIZE);
210 key->dec(key->rd_key, t32);
211 memcpy(out, t32, CAMELLIA_BLOCK_SIZE);
244 memcpy(tmp.t8, in, CAMELLIA_BLOCK_SIZE);
245 if (camellia_endian.little)
246 SWAP4WORD(tmp.t32);
247 key->dec(key->rd_key, tmp.t32);
248 if (camellia_endian.little)
249 SWAP4WORD(tmp.t32);
212 for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n)
250 for(n=0; n < CAMELLIA_BLOCK_SIZE; ++n)
213 out[n] ^= ivec[n];
214 memcpy(ivec, tmp, CAMELLIA_BLOCK_SIZE);
251 tmp.t8[n] ^= ivec[n];
252 memcpy(ivec, in, CAMELLIA_BLOCK_SIZE);
253 memcpy(out, tmp.t8, CAMELLIA_BLOCK_SIZE);
215 len -= CAMELLIA_BLOCK_SIZE;
216 in += CAMELLIA_BLOCK_SIZE;
217 out += CAMELLIA_BLOCK_SIZE;
218 }
219 if (len)
220 {
254 len -= CAMELLIA_BLOCK_SIZE;
255 in += CAMELLIA_BLOCK_SIZE;
256 out += CAMELLIA_BLOCK_SIZE;
257 }
258 if (len)
259 {
221 memcpy(tmp, in, CAMELLIA_BLOCK_SIZE);
222 memcpy(t32, in, CAMELLIA_BLOCK_SIZE);
223 key->dec(key->rd_key,t32);
224 memcpy(out, t32, CAMELLIA_BLOCK_SIZE);
260 memcpy(tmp.t8, in, CAMELLIA_BLOCK_SIZE);
261 if (camellia_endian.little)
262 SWAP4WORD(tmp.t32);
263 key->dec(key->rd_key,tmp.t32);
264 if (camellia_endian.little)
265 SWAP4WORD(tmp.t32);
225 for(n=0; n < len; ++n)
266 for(n=0; n < len; ++n)
226 out[n] ^= ivec[n];
227 for(n=len; n < CAMELLIA_BLOCK_SIZE; ++n)
228 out[n] = tmp[n];
229 memcpy(ivec, tmp, CAMELLIA_BLOCK_SIZE);
267 tmp.t8[n] ^= ivec[n];
268 memcpy(ivec, in, CAMELLIA_BLOCK_SIZE);
269 memcpy(out,tmp.t8,len);
230 }
231 }
232 }
233}
270 }
271 }
272 }
273}
234