1 /* crypto/camellia/camellia_cbc.c -*- mode:C; c-file-style: "eay" -*- */
2 /* ====================================================================
3 * Copyright (c) 2006 The OpenSSL Project. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
17 * 3. All advertising materials mentioning features or use of this
18 * software must display the following acknowledgment:
19 * "This product includes software developed by the OpenSSL Project
20 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
22 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
23 * endorse or promote products derived from this software without
24 * prior written permission. For written permission, please contact
25 * openssl-core@openssl.org.
27 * 5. Products derived from this software may not be called "OpenSSL"
28 * nor may "OpenSSL" appear in their names without prior written
29 * permission of the OpenSSL Project.
31 * 6. Redistributions of any form whatsoever must retain the following
33 * "This product includes software developed by the OpenSSL Project
34 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
36 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
37 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
39 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
40 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
42 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
43 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
45 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
46 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
47 * OF THE POSSIBILITY OF SUCH DAMAGE.
48 * ====================================================================
52 #ifndef CAMELLIA_DEBUG
61 #include <openssl/camellia.h>
62 #include "cmll_locl.h"
64 void 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
) {
69 unsigned long len
= length
;
70 unsigned char tmp
[CAMELLIA_BLOCK_SIZE
];
71 const unsigned char *iv
= ivec
;
72 uint32_t t32
[UNITSIZE
];
75 assert(in
&& out
&& key
&& ivec
);
76 assert((CAMELLIA_ENCRYPT
== enc
)||(CAMELLIA_DECRYPT
== enc
));
78 if(((size_t)in
) % ALIGN
== 0
79 && ((size_t)out
) % ALIGN
== 0
80 && ((size_t)ivec
) % ALIGN
== 0)
82 if (CAMELLIA_ENCRYPT
== enc
)
84 while (len
>= CAMELLIA_BLOCK_SIZE
)
86 XOR4WORD2((uint32_t *)out
,
87 (uint32_t *)in
, (uint32_t *)iv
);
88 key
->enc(key
->rd_key
, (uint32_t *)out
);
90 len
-= CAMELLIA_BLOCK_SIZE
;
91 in
+= CAMELLIA_BLOCK_SIZE
;
92 out
+= CAMELLIA_BLOCK_SIZE
;
96 for(n
=0; n
< len
; ++n
)
97 out
[n
] = in
[n
] ^ iv
[n
];
98 for(n
=len
; n
< CAMELLIA_BLOCK_SIZE
; ++n
)
100 key
->enc(key
->rd_key
, (uint32_t *)out
);
103 memcpy(ivec
,iv
,CAMELLIA_BLOCK_SIZE
);
107 while (len
>= CAMELLIA_BLOCK_SIZE
)
109 memcpy(out
,in
,CAMELLIA_BLOCK_SIZE
);
110 key
->dec(key
->rd_key
,(uint32_t *)out
);
111 XOR4WORD((uint32_t *)out
, (uint32_t *)iv
);
113 len
-= CAMELLIA_BLOCK_SIZE
;
114 in
+= CAMELLIA_BLOCK_SIZE
;
115 out
+= CAMELLIA_BLOCK_SIZE
;
119 memcpy(tmp
, in
, CAMELLIA_BLOCK_SIZE
);
120 key
->dec(key
->rd_key
, (uint32_t *)tmp
);
121 for(n
=0; n
< len
; ++n
)
122 out
[n
] = tmp
[n
] ^ iv
[n
];
125 memcpy(ivec
,iv
,CAMELLIA_BLOCK_SIZE
);
129 while (len
>= CAMELLIA_BLOCK_SIZE
)
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
);
135 len
-= CAMELLIA_BLOCK_SIZE
;
136 in
+= CAMELLIA_BLOCK_SIZE
;
137 out
+= CAMELLIA_BLOCK_SIZE
;
141 memcpy(tmp
, in
, CAMELLIA_BLOCK_SIZE
);
142 key
->dec(key
->rd_key
,(uint32_t *)out
);
143 for(n
=0; n
< len
; ++n
)
145 for(n
=len
; n
< CAMELLIA_BLOCK_SIZE
; ++n
)
147 memcpy(ivec
, tmp
, CAMELLIA_BLOCK_SIZE
);
151 else /* no aligned */
153 if (CAMELLIA_ENCRYPT
== enc
)
155 while (len
>= CAMELLIA_BLOCK_SIZE
)
157 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
);
163 len
-= CAMELLIA_BLOCK_SIZE
;
164 in
+= CAMELLIA_BLOCK_SIZE
;
165 out
+= CAMELLIA_BLOCK_SIZE
;
169 for(n
=0; n
< len
; ++n
)
170 out
[n
] = in
[n
] ^ iv
[n
];
171 for(n
=len
; n
< CAMELLIA_BLOCK_SIZE
; ++n
)
173 key
->enc(key
->rd_key
, (uint32_t *)out
);
176 memcpy(ivec
,iv
,CAMELLIA_BLOCK_SIZE
);
180 while (len
>= CAMELLIA_BLOCK_SIZE
)
182 memcpy(t32
,in
,CAMELLIA_BLOCK_SIZE
);
183 key
->dec(key
->rd_key
,t32
);
184 memcpy(out
,t32
,CAMELLIA_BLOCK_SIZE
);
185 for(n
=0; n
< CAMELLIA_BLOCK_SIZE
; ++n
)
188 len
-= CAMELLIA_BLOCK_SIZE
;
189 in
+= CAMELLIA_BLOCK_SIZE
;
190 out
+= CAMELLIA_BLOCK_SIZE
;
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
);
198 for(n
=0; n
< len
; ++n
)
199 out
[n
] = tmp
[n
] ^ iv
[n
];
202 memcpy(ivec
,iv
,CAMELLIA_BLOCK_SIZE
);
206 while (len
>= CAMELLIA_BLOCK_SIZE
)
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
);
212 for(n
=0; n
< CAMELLIA_BLOCK_SIZE
; ++n
)
214 memcpy(ivec
, tmp
, CAMELLIA_BLOCK_SIZE
);
215 len
-= CAMELLIA_BLOCK_SIZE
;
216 in
+= CAMELLIA_BLOCK_SIZE
;
217 out
+= CAMELLIA_BLOCK_SIZE
;
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
);
225 for(n
=0; n
< len
; ++n
)
227 for(n
=len
; n
< CAMELLIA_BLOCK_SIZE
; ++n
)
229 memcpy(ivec
, tmp
, CAMELLIA_BLOCK_SIZE
);