luna - wolfssl/wolfcrypt/src/camellia.c

   1/* camellia.c ver 1.2.0
   2 *
   3 * Copyright (c) 2006,2007
   4 * NTT (Nippon Telegraph and Telephone Corporation) . All rights reserved.
   5 *
   6 * Redistribution and use in source and binary forms, with or without
   7 * modification, are permitted provided that the following conditions
   8 * are met:
   9 * 1. Redistributions of source code must retain the above copyright
  10 *   notice, this list of conditions and the following disclaimer as
  11 *   the first lines of this file unmodified.
  12 * 2. Redistributions in binary form must reproduce the above copyright
  13 *   notice, this list of conditions and the following disclaimer in the
  14 *   documentation and/or other materials provided with the distribution.
  15 *
  16 * THIS SOFTWARE IS PROVIDED BY NTT ``AS IS'' AND ANY EXPRESS OR
  17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19 * IN NO EVENT SHALL NTT BE LIABLE FOR ANY DIRECT, INDIRECT,
  20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27
  28/* camellia.c
  29 *
  30 * Copyright (C) 2006-2026 wolfSSL Inc.
  31 *
  32 * This file is part of wolfSSL.
  33 *
  34 * wolfSSL is free software; you can redistribute it and/or modify
  35 * it under the terms of the GNU General Public License as published by
  36 * the Free Software Foundation; either version 3 of the License, or
  37 * (at your option) any later version.
  38 *
  39 * wolfSSL is distributed in the hope that it will be useful,
  40 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  41 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  42 * GNU General Public License for more details.
  43 *
  44 * You should have received a copy of the GNU General Public License
  45 * along with this program; if not, write to the Free Software
  46 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  47 */
  48
  49
  50/*
  51 * Algorithm Specification
  52 *  http://info.isl.ntt.co.jp/crypt/eng/camellia/specifications.html
  53 */
  54
  55#include <wolfssl/wolfcrypt/libwolfssl_sources.h>
  56
  57#ifdef HAVE_CAMELLIA
  58
  59#include <wolfssl/wolfcrypt/camellia.h>
  60#ifdef NO_INLINE
  61    #include <wolfssl/wolfcrypt/misc.h>
  62#else
  63    #define WOLFSSL_MISC_INCLUDED
  64    #include <wolfcrypt/src/misc.c>
  65#endif
  66
  67typedef word32 u32;
  68typedef unsigned char u8;
  69
  70/* key constants */
  71
  72#define CAMELLIA_SIGMA1L ((u32)0xA09E667FL)
  73#define CAMELLIA_SIGMA1R ((u32)0x3BCC908BL)
  74#define CAMELLIA_SIGMA2L ((u32)0xB67AE858L)
  75#define CAMELLIA_SIGMA2R ((u32)0x4CAA73B2L)
  76#define CAMELLIA_SIGMA3L ((u32)0xC6EF372FL)
  77#define CAMELLIA_SIGMA3R ((u32)0xE94F82BEL)
  78#define CAMELLIA_SIGMA4L ((u32)0x54FF53A5L)
  79#define CAMELLIA_SIGMA4R ((u32)0xF1D36F1CL)
  80#define CAMELLIA_SIGMA5L ((u32)0x10E527FAL)
  81#define CAMELLIA_SIGMA5R ((u32)0xDE682D1DL)
  82#define CAMELLIA_SIGMA6L ((u32)0xB05688C2L)
  83#define CAMELLIA_SIGMA6R ((u32)0xB3E6C1FDL)
  84
  85/*
  86 *  macros
  87 */
  88
  89
  90#if defined(_MSC_VER)
  91
  92# define SWAP(x) (_lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00)
  93# define GETU32(p) SWAP(*((u32 *)(p)))
  94# define PUTU32(ct, st) {*((u32 *)(ct)) = SWAP((st));}
  95
  96#else /* not MS-VC */
  97
  98# define GETU32(pt)                             \
  99    (((u32)(pt)[0] << 24)                       \
 100     ^ ((u32)(pt)[1] << 16)                     \
 101     ^ ((u32)(pt)[2] <<  8)                     \
 102     ^ ((u32)(pt)[3]))
 103
 104# define PUTU32(ct, st)  {                      \
 105        (ct)[0] = (u8)((st) >> 24);             \
 106        (ct)[1] = (u8)((st) >> 16);             \
 107        (ct)[2] = (u8)((st) >>  8);             \
 108        (ct)[3] = (u8)(st); }
 109
 110#endif
 111
 112#define CamelliaSubkeyL(INDEX) (subkey[(INDEX)*2])
 113#define CamelliaSubkeyR(INDEX) (subkey[(INDEX)*2 + 1])
 114
 115/* rotation right shift 1byte */
 116#define CAMELLIA_RR8(x) (((x) >> 8) + ((x) << 24))
 117/* rotation left shift 1bit */
 118#define CAMELLIA_RL1(x) (((x) << 1) + ((x) >> 31))
 119/* rotation left shift 1byte */
 120#define CAMELLIA_RL8(x) (((x) << 8) + ((x) >> 24))
 121
 122#define CAMELLIA_ROLDQ(ll, lr, rl, rr, w0, w1, bits)              \
 123    do {                                                          \
 124        (w0) = (ll);                                              \
 125        (ll) = ((ll) << (bits)) + ((lr) >> (32 - (bits)));        \
 126        (lr) = ((lr) << (bits)) + ((rl) >> (32 - (bits)));        \
 127        (rl) = ((rl) << (bits)) + ((rr) >> (32 - (bits)));        \
 128        (rr) = ((rr) << (bits)) + ((w0) >> (32 - (bits)));        \
 129    } while(0)
 130
 131#define CAMELLIA_ROLDQo32(ll, lr, rl, rr, w0, w1, bits)           \
 132    do {                                                          \
 133        (w0) = (ll);                                              \
 134        (w1) = (lr);                                              \
 135        (ll) = ((lr) << ((bits) - 32)) + ((rl) >> (64 - (bits))); \
 136        (lr) = ((rl) << ((bits) - 32)) + ((rr) >> (64 - (bits))); \
 137        (rl) = ((rr) << ((bits) - 32)) + ((w0) >> (64 - (bits))); \
 138        (rr) = ((w0) << ((bits) - 32)) + ((w1) >> (64 - (bits))); \
 139    } while(0)
 140
 141#define CAMELLIA_SP1110(INDEX) (camellia_sp1110[(INDEX)])
 142#define CAMELLIA_SP0222(INDEX) (camellia_sp0222[(INDEX)])
 143#define CAMELLIA_SP3033(INDEX) (camellia_sp3033[(INDEX)])
 144#define CAMELLIA_SP4404(INDEX) (camellia_sp4404[(INDEX)])
 145
 146#define CAMELLIA_F(xl, xr, kl, kr, yl, yr, il, ir, t0, t1)        \
 147    do {                                                          \
 148        (il) = (xl) ^ (kl);                                       \
 149        (ir) = (xr) ^ (kr);                                       \
 150        (t0) = (il) >> 16;                                        \
 151        (t1) = (ir) >> 16;                                        \
 152        (yl) = CAMELLIA_SP1110((ir) & 0xff)                       \
 153            ^ CAMELLIA_SP0222(((t1) >> 8) & 0xff)                 \
 154            ^ CAMELLIA_SP3033((t1) & 0xff)                        \
 155            ^ CAMELLIA_SP4404(((ir) >> 8) & 0xff);                \
 156        (yr) = CAMELLIA_SP1110(((t0) >> 8) & 0xff)                \
 157            ^ CAMELLIA_SP0222((t0) & 0xff)                        \
 158            ^ CAMELLIA_SP3033(((il) >> 8) & 0xff)                 \
 159            ^ CAMELLIA_SP4404((il) & 0xff);                       \
 160        (yl) ^= (yr);                                             \
 161        (yr) = CAMELLIA_RR8(yr);                                  \
 162        (yr) ^= (yl);                                             \
 163    } while(0)
 164
 165
 166/*
 167 * for speed up
 168 *
 169 */
 170#define CAMELLIA_FLS(ll, lr, rl, rr, kll, klr, krl, krr, t0, t1, t2, t3) \
 171    do {                                                                 \
 172        (t0) = (kll);                                                    \
 173        (t0) &= (ll);                                                    \
 174        (lr) ^= CAMELLIA_RL1(t0);                                        \
 175        (t1) = (klr);                                                    \
 176        (t1) |= (lr);                                                    \
 177        (ll) ^= (t1);                                                    \
 178                                                                         \
 179        (t2) = (krr);                                                    \
 180        (t2) |= (rr);                                                    \
 181        (rl) ^= (t2);                                                    \
 182        (t3) = (krl);                                                    \
 183        (t3) &= (rl);                                                    \
 184        (rr) ^= CAMELLIA_RL1(t3);                                        \
 185    } while(0)
 186
 187#define CAMELLIA_ROUNDSM(xl, xr, kl, kr, yl, yr, il, ir, t0, t1)         \
 188    do {                                                                 \
 189        (ir) = CAMELLIA_SP1110((xr) & 0xff)                              \
 190            ^ CAMELLIA_SP0222(((xr) >> 24) & 0xff)                       \
 191            ^ CAMELLIA_SP3033(((xr) >> 16) & 0xff)                       \
 192            ^ CAMELLIA_SP4404(((xr) >> 8) & 0xff);                       \
 193        (il) = CAMELLIA_SP1110(((xl) >> 24) & 0xff)                      \
 194            ^ CAMELLIA_SP0222(((xl) >> 16) & 0xff)                       \
 195            ^ CAMELLIA_SP3033(((xl) >> 8) & 0xff)                        \
 196            ^ CAMELLIA_SP4404((xl) & 0xff);                              \
 197        (il) ^= (kl);                                                    \
 198        (ir) ^= (kr);                                                    \
 199        (ir) ^= (il);                                                    \
 200        (il) = CAMELLIA_RR8(il);                                         \
 201        (il) ^= (ir);                                                    \
 202        (yl) ^= (ir);                                                    \
 203        (yr) ^= (il);                                                    \
 204    } while(0)
 205
 206
 207static const u32 camellia_sp1110[256] = {
 208    0x70707000,0x82828200,0x2c2c2c00,0xececec00,
 209    0xb3b3b300,0x27272700,0xc0c0c000,0xe5e5e500,
 210    0xe4e4e400,0x85858500,0x57575700,0x35353500,
 211    0xeaeaea00,0x0c0c0c00,0xaeaeae00,0x41414100,
 212    0x23232300,0xefefef00,0x6b6b6b00,0x93939300,
 213    0x45454500,0x19191900,0xa5a5a500,0x21212100,
 214    0xededed00,0x0e0e0e00,0x4f4f4f00,0x4e4e4e00,
 215    0x1d1d1d00,0x65656500,0x92929200,0xbdbdbd00,
 216    0x86868600,0xb8b8b800,0xafafaf00,0x8f8f8f00,
 217    0x7c7c7c00,0xebebeb00,0x1f1f1f00,0xcecece00,
 218    0x3e3e3e00,0x30303000,0xdcdcdc00,0x5f5f5f00,
 219    0x5e5e5e00,0xc5c5c500,0x0b0b0b00,0x1a1a1a00,
 220    0xa6a6a600,0xe1e1e100,0x39393900,0xcacaca00,
 221    0xd5d5d500,0x47474700,0x5d5d5d00,0x3d3d3d00,
 222    0xd9d9d900,0x01010100,0x5a5a5a00,0xd6d6d600,
 223    0x51515100,0x56565600,0x6c6c6c00,0x4d4d4d00,
 224    0x8b8b8b00,0x0d0d0d00,0x9a9a9a00,0x66666600,
 225    0xfbfbfb00,0xcccccc00,0xb0b0b000,0x2d2d2d00,
 226    0x74747400,0x12121200,0x2b2b2b00,0x20202000,
 227    0xf0f0f000,0xb1b1b100,0x84848400,0x99999900,
 228    0xdfdfdf00,0x4c4c4c00,0xcbcbcb00,0xc2c2c200,
 229    0x34343400,0x7e7e7e00,0x76767600,0x05050500,
 230    0x6d6d6d00,0xb7b7b700,0xa9a9a900,0x31313100,
 231    0xd1d1d100,0x17171700,0x04040400,0xd7d7d700,
 232    0x14141400,0x58585800,0x3a3a3a00,0x61616100,
 233    0xdedede00,0x1b1b1b00,0x11111100,0x1c1c1c00,
 234    0x32323200,0x0f0f0f00,0x9c9c9c00,0x16161600,
 235    0x53535300,0x18181800,0xf2f2f200,0x22222200,
 236    0xfefefe00,0x44444400,0xcfcfcf00,0xb2b2b200,
 237    0xc3c3c300,0xb5b5b500,0x7a7a7a00,0x91919100,
 238    0x24242400,0x08080800,0xe8e8e800,0xa8a8a800,
 239    0x60606000,0xfcfcfc00,0x69696900,0x50505000,
 240    0xaaaaaa00,0xd0d0d000,0xa0a0a000,0x7d7d7d00,
 241    0xa1a1a100,0x89898900,0x62626200,0x97979700,
 242    0x54545400,0x5b5b5b00,0x1e1e1e00,0x95959500,
 243    0xe0e0e000,0xffffff00,0x64646400,0xd2d2d200,
 244    0x10101000,0xc4c4c400,0x00000000,0x48484800,
 245    0xa3a3a300,0xf7f7f700,0x75757500,0xdbdbdb00,
 246    0x8a8a8a00,0x03030300,0xe6e6e600,0xdadada00,
 247    0x09090900,0x3f3f3f00,0xdddddd00,0x94949400,
 248    0x87878700,0x5c5c5c00,0x83838300,0x02020200,
 249    0xcdcdcd00,0x4a4a4a00,0x90909000,0x33333300,
 250    0x73737300,0x67676700,0xf6f6f600,0xf3f3f300,
 251    0x9d9d9d00,0x7f7f7f00,0xbfbfbf00,0xe2e2e200,
 252    0x52525200,0x9b9b9b00,0xd8d8d800,0x26262600,
 253    0xc8c8c800,0x37373700,0xc6c6c600,0x3b3b3b00,
 254    0x81818100,0x96969600,0x6f6f6f00,0x4b4b4b00,
 255    0x13131300,0xbebebe00,0x63636300,0x2e2e2e00,
 256    0xe9e9e900,0x79797900,0xa7a7a700,0x8c8c8c00,
 257    0x9f9f9f00,0x6e6e6e00,0xbcbcbc00,0x8e8e8e00,
 258    0x29292900,0xf5f5f500,0xf9f9f900,0xb6b6b600,
 259    0x2f2f2f00,0xfdfdfd00,0xb4b4b400,0x59595900,
 260    0x78787800,0x98989800,0x06060600,0x6a6a6a00,
 261    0xe7e7e700,0x46464600,0x71717100,0xbababa00,
 262    0xd4d4d400,0x25252500,0xababab00,0x42424200,
 263    0x88888800,0xa2a2a200,0x8d8d8d00,0xfafafa00,
 264    0x72727200,0x07070700,0xb9b9b900,0x55555500,
 265    0xf8f8f800,0xeeeeee00,0xacacac00,0x0a0a0a00,
 266    0x36363600,0x49494900,0x2a2a2a00,0x68686800,
 267    0x3c3c3c00,0x38383800,0xf1f1f100,0xa4a4a400,
 268    0x40404000,0x28282800,0xd3d3d300,0x7b7b7b00,
 269    0xbbbbbb00,0xc9c9c900,0x43434300,0xc1c1c100,
 270    0x15151500,0xe3e3e300,0xadadad00,0xf4f4f400,
 271    0x77777700,0xc7c7c700,0x80808000,0x9e9e9e00,
 272};
 273
 274static const u32 camellia_sp0222[256] = {
 275    0x00e0e0e0,0x00050505,0x00585858,0x00d9d9d9,
 276    0x00676767,0x004e4e4e,0x00818181,0x00cbcbcb,
 277    0x00c9c9c9,0x000b0b0b,0x00aeaeae,0x006a6a6a,
 278    0x00d5d5d5,0x00181818,0x005d5d5d,0x00828282,
 279    0x00464646,0x00dfdfdf,0x00d6d6d6,0x00272727,
 280    0x008a8a8a,0x00323232,0x004b4b4b,0x00424242,
 281    0x00dbdbdb,0x001c1c1c,0x009e9e9e,0x009c9c9c,
 282    0x003a3a3a,0x00cacaca,0x00252525,0x007b7b7b,
 283    0x000d0d0d,0x00717171,0x005f5f5f,0x001f1f1f,
 284    0x00f8f8f8,0x00d7d7d7,0x003e3e3e,0x009d9d9d,
 285    0x007c7c7c,0x00606060,0x00b9b9b9,0x00bebebe,
 286    0x00bcbcbc,0x008b8b8b,0x00161616,0x00343434,
 287    0x004d4d4d,0x00c3c3c3,0x00727272,0x00959595,
 288    0x00ababab,0x008e8e8e,0x00bababa,0x007a7a7a,
 289    0x00b3b3b3,0x00020202,0x00b4b4b4,0x00adadad,
 290    0x00a2a2a2,0x00acacac,0x00d8d8d8,0x009a9a9a,
 291    0x00171717,0x001a1a1a,0x00353535,0x00cccccc,
 292    0x00f7f7f7,0x00999999,0x00616161,0x005a5a5a,
 293    0x00e8e8e8,0x00242424,0x00565656,0x00404040,
 294    0x00e1e1e1,0x00636363,0x00090909,0x00333333,
 295    0x00bfbfbf,0x00989898,0x00979797,0x00858585,
 296    0x00686868,0x00fcfcfc,0x00ececec,0x000a0a0a,
 297    0x00dadada,0x006f6f6f,0x00535353,0x00626262,
 298    0x00a3a3a3,0x002e2e2e,0x00080808,0x00afafaf,
 299    0x00282828,0x00b0b0b0,0x00747474,0x00c2c2c2,
 300    0x00bdbdbd,0x00363636,0x00222222,0x00383838,
 301    0x00646464,0x001e1e1e,0x00393939,0x002c2c2c,
 302    0x00a6a6a6,0x00303030,0x00e5e5e5,0x00444444,
 303    0x00fdfdfd,0x00888888,0x009f9f9f,0x00656565,
 304    0x00878787,0x006b6b6b,0x00f4f4f4,0x00232323,
 305    0x00484848,0x00101010,0x00d1d1d1,0x00515151,
 306    0x00c0c0c0,0x00f9f9f9,0x00d2d2d2,0x00a0a0a0,
 307    0x00555555,0x00a1a1a1,0x00414141,0x00fafafa,
 308    0x00434343,0x00131313,0x00c4c4c4,0x002f2f2f,
 309    0x00a8a8a8,0x00b6b6b6,0x003c3c3c,0x002b2b2b,
 310    0x00c1c1c1,0x00ffffff,0x00c8c8c8,0x00a5a5a5,
 311    0x00202020,0x00898989,0x00000000,0x00909090,
 312    0x00474747,0x00efefef,0x00eaeaea,0x00b7b7b7,
 313    0x00151515,0x00060606,0x00cdcdcd,0x00b5b5b5,
 314    0x00121212,0x007e7e7e,0x00bbbbbb,0x00292929,
 315    0x000f0f0f,0x00b8b8b8,0x00070707,0x00040404,
 316    0x009b9b9b,0x00949494,0x00212121,0x00666666,
 317    0x00e6e6e6,0x00cecece,0x00ededed,0x00e7e7e7,
 318    0x003b3b3b,0x00fefefe,0x007f7f7f,0x00c5c5c5,
 319    0x00a4a4a4,0x00373737,0x00b1b1b1,0x004c4c4c,
 320    0x00919191,0x006e6e6e,0x008d8d8d,0x00767676,
 321    0x00030303,0x002d2d2d,0x00dedede,0x00969696,
 322    0x00262626,0x007d7d7d,0x00c6c6c6,0x005c5c5c,
 323    0x00d3d3d3,0x00f2f2f2,0x004f4f4f,0x00191919,
 324    0x003f3f3f,0x00dcdcdc,0x00797979,0x001d1d1d,
 325    0x00525252,0x00ebebeb,0x00f3f3f3,0x006d6d6d,
 326    0x005e5e5e,0x00fbfbfb,0x00696969,0x00b2b2b2,
 327    0x00f0f0f0,0x00313131,0x000c0c0c,0x00d4d4d4,
 328    0x00cfcfcf,0x008c8c8c,0x00e2e2e2,0x00757575,
 329    0x00a9a9a9,0x004a4a4a,0x00575757,0x00848484,
 330    0x00111111,0x00454545,0x001b1b1b,0x00f5f5f5,
 331    0x00e4e4e4,0x000e0e0e,0x00737373,0x00aaaaaa,
 332    0x00f1f1f1,0x00dddddd,0x00595959,0x00141414,
 333    0x006c6c6c,0x00929292,0x00545454,0x00d0d0d0,
 334    0x00787878,0x00707070,0x00e3e3e3,0x00494949,
 335    0x00808080,0x00505050,0x00a7a7a7,0x00f6f6f6,
 336    0x00777777,0x00939393,0x00868686,0x00838383,
 337    0x002a2a2a,0x00c7c7c7,0x005b5b5b,0x00e9e9e9,
 338    0x00eeeeee,0x008f8f8f,0x00010101,0x003d3d3d,
 339};
 340
 341static const u32 camellia_sp3033[256] = {
 342    0x38003838,0x41004141,0x16001616,0x76007676,
 343    0xd900d9d9,0x93009393,0x60006060,0xf200f2f2,
 344    0x72007272,0xc200c2c2,0xab00abab,0x9a009a9a,
 345    0x75007575,0x06000606,0x57005757,0xa000a0a0,
 346    0x91009191,0xf700f7f7,0xb500b5b5,0xc900c9c9,
 347    0xa200a2a2,0x8c008c8c,0xd200d2d2,0x90009090,
 348    0xf600f6f6,0x07000707,0xa700a7a7,0x27002727,
 349    0x8e008e8e,0xb200b2b2,0x49004949,0xde00dede,
 350    0x43004343,0x5c005c5c,0xd700d7d7,0xc700c7c7,
 351    0x3e003e3e,0xf500f5f5,0x8f008f8f,0x67006767,
 352    0x1f001f1f,0x18001818,0x6e006e6e,0xaf00afaf,
 353    0x2f002f2f,0xe200e2e2,0x85008585,0x0d000d0d,
 354    0x53005353,0xf000f0f0,0x9c009c9c,0x65006565,
 355    0xea00eaea,0xa300a3a3,0xae00aeae,0x9e009e9e,
 356    0xec00ecec,0x80008080,0x2d002d2d,0x6b006b6b,
 357    0xa800a8a8,0x2b002b2b,0x36003636,0xa600a6a6,
 358    0xc500c5c5,0x86008686,0x4d004d4d,0x33003333,
 359    0xfd00fdfd,0x66006666,0x58005858,0x96009696,
 360    0x3a003a3a,0x09000909,0x95009595,0x10001010,
 361    0x78007878,0xd800d8d8,0x42004242,0xcc00cccc,
 362    0xef00efef,0x26002626,0xe500e5e5,0x61006161,
 363    0x1a001a1a,0x3f003f3f,0x3b003b3b,0x82008282,
 364    0xb600b6b6,0xdb00dbdb,0xd400d4d4,0x98009898,
 365    0xe800e8e8,0x8b008b8b,0x02000202,0xeb00ebeb,
 366    0x0a000a0a,0x2c002c2c,0x1d001d1d,0xb000b0b0,
 367    0x6f006f6f,0x8d008d8d,0x88008888,0x0e000e0e,
 368    0x19001919,0x87008787,0x4e004e4e,0x0b000b0b,
 369    0xa900a9a9,0x0c000c0c,0x79007979,0x11001111,
 370    0x7f007f7f,0x22002222,0xe700e7e7,0x59005959,
 371    0xe100e1e1,0xda00dada,0x3d003d3d,0xc800c8c8,
 372    0x12001212,0x04000404,0x74007474,0x54005454,
 373    0x30003030,0x7e007e7e,0xb400b4b4,0x28002828,
 374    0x55005555,0x68006868,0x50005050,0xbe00bebe,
 375    0xd000d0d0,0xc400c4c4,0x31003131,0xcb00cbcb,
 376    0x2a002a2a,0xad00adad,0x0f000f0f,0xca00caca,
 377    0x70007070,0xff00ffff,0x32003232,0x69006969,
 378    0x08000808,0x62006262,0x00000000,0x24002424,
 379    0xd100d1d1,0xfb00fbfb,0xba00baba,0xed00eded,
 380    0x45004545,0x81008181,0x73007373,0x6d006d6d,
 381    0x84008484,0x9f009f9f,0xee00eeee,0x4a004a4a,
 382    0xc300c3c3,0x2e002e2e,0xc100c1c1,0x01000101,
 383    0xe600e6e6,0x25002525,0x48004848,0x99009999,
 384    0xb900b9b9,0xb300b3b3,0x7b007b7b,0xf900f9f9,
 385    0xce00cece,0xbf00bfbf,0xdf00dfdf,0x71007171,
 386    0x29002929,0xcd00cdcd,0x6c006c6c,0x13001313,
 387    0x64006464,0x9b009b9b,0x63006363,0x9d009d9d,
 388    0xc000c0c0,0x4b004b4b,0xb700b7b7,0xa500a5a5,
 389    0x89008989,0x5f005f5f,0xb100b1b1,0x17001717,
 390    0xf400f4f4,0xbc00bcbc,0xd300d3d3,0x46004646,
 391    0xcf00cfcf,0x37003737,0x5e005e5e,0x47004747,
 392    0x94009494,0xfa00fafa,0xfc00fcfc,0x5b005b5b,
 393    0x97009797,0xfe00fefe,0x5a005a5a,0xac00acac,
 394    0x3c003c3c,0x4c004c4c,0x03000303,0x35003535,
 395    0xf300f3f3,0x23002323,0xb800b8b8,0x5d005d5d,
 396    0x6a006a6a,0x92009292,0xd500d5d5,0x21002121,
 397    0x44004444,0x51005151,0xc600c6c6,0x7d007d7d,
 398    0x39003939,0x83008383,0xdc00dcdc,0xaa00aaaa,
 399    0x7c007c7c,0x77007777,0x56005656,0x05000505,
 400    0x1b001b1b,0xa400a4a4,0x15001515,0x34003434,
 401    0x1e001e1e,0x1c001c1c,0xf800f8f8,0x52005252,
 402    0x20002020,0x14001414,0xe900e9e9,0xbd00bdbd,
 403    0xdd00dddd,0xe400e4e4,0xa100a1a1,0xe000e0e0,
 404    0x8a008a8a,0xf100f1f1,0xd600d6d6,0x7a007a7a,
 405    0xbb00bbbb,0xe300e3e3,0x40004040,0x4f004f4f,
 406};
 407
 408static const u32 camellia_sp4404[256] = {
 409    0x70700070,0x2c2c002c,0xb3b300b3,0xc0c000c0,
 410    0xe4e400e4,0x57570057,0xeaea00ea,0xaeae00ae,
 411    0x23230023,0x6b6b006b,0x45450045,0xa5a500a5,
 412    0xeded00ed,0x4f4f004f,0x1d1d001d,0x92920092,
 413    0x86860086,0xafaf00af,0x7c7c007c,0x1f1f001f,
 414    0x3e3e003e,0xdcdc00dc,0x5e5e005e,0x0b0b000b,
 415    0xa6a600a6,0x39390039,0xd5d500d5,0x5d5d005d,
 416    0xd9d900d9,0x5a5a005a,0x51510051,0x6c6c006c,
 417    0x8b8b008b,0x9a9a009a,0xfbfb00fb,0xb0b000b0,
 418    0x74740074,0x2b2b002b,0xf0f000f0,0x84840084,
 419    0xdfdf00df,0xcbcb00cb,0x34340034,0x76760076,
 420    0x6d6d006d,0xa9a900a9,0xd1d100d1,0x04040004,
 421    0x14140014,0x3a3a003a,0xdede00de,0x11110011,
 422    0x32320032,0x9c9c009c,0x53530053,0xf2f200f2,
 423    0xfefe00fe,0xcfcf00cf,0xc3c300c3,0x7a7a007a,
 424    0x24240024,0xe8e800e8,0x60600060,0x69690069,
 425    0xaaaa00aa,0xa0a000a0,0xa1a100a1,0x62620062,
 426    0x54540054,0x1e1e001e,0xe0e000e0,0x64640064,
 427    0x10100010,0x00000000,0xa3a300a3,0x75750075,
 428    0x8a8a008a,0xe6e600e6,0x09090009,0xdddd00dd,
 429    0x87870087,0x83830083,0xcdcd00cd,0x90900090,
 430    0x73730073,0xf6f600f6,0x9d9d009d,0xbfbf00bf,
 431    0x52520052,0xd8d800d8,0xc8c800c8,0xc6c600c6,
 432    0x81810081,0x6f6f006f,0x13130013,0x63630063,
 433    0xe9e900e9,0xa7a700a7,0x9f9f009f,0xbcbc00bc,
 434    0x29290029,0xf9f900f9,0x2f2f002f,0xb4b400b4,
 435    0x78780078,0x06060006,0xe7e700e7,0x71710071,
 436    0xd4d400d4,0xabab00ab,0x88880088,0x8d8d008d,
 437    0x72720072,0xb9b900b9,0xf8f800f8,0xacac00ac,
 438    0x36360036,0x2a2a002a,0x3c3c003c,0xf1f100f1,
 439    0x40400040,0xd3d300d3,0xbbbb00bb,0x43430043,
 440    0x15150015,0xadad00ad,0x77770077,0x80800080,
 441    0x82820082,0xecec00ec,0x27270027,0xe5e500e5,
 442    0x85850085,0x35350035,0x0c0c000c,0x41410041,
 443    0xefef00ef,0x93930093,0x19190019,0x21210021,
 444    0x0e0e000e,0x4e4e004e,0x65650065,0xbdbd00bd,
 445    0xb8b800b8,0x8f8f008f,0xebeb00eb,0xcece00ce,
 446    0x30300030,0x5f5f005f,0xc5c500c5,0x1a1a001a,
 447    0xe1e100e1,0xcaca00ca,0x47470047,0x3d3d003d,
 448    0x01010001,0xd6d600d6,0x56560056,0x4d4d004d,
 449    0x0d0d000d,0x66660066,0xcccc00cc,0x2d2d002d,
 450    0x12120012,0x20200020,0xb1b100b1,0x99990099,
 451    0x4c4c004c,0xc2c200c2,0x7e7e007e,0x05050005,
 452    0xb7b700b7,0x31310031,0x17170017,0xd7d700d7,
 453    0x58580058,0x61610061,0x1b1b001b,0x1c1c001c,
 454    0x0f0f000f,0x16160016,0x18180018,0x22220022,
 455    0x44440044,0xb2b200b2,0xb5b500b5,0x91910091,
 456    0x08080008,0xa8a800a8,0xfcfc00fc,0x50500050,
 457    0xd0d000d0,0x7d7d007d,0x89890089,0x97970097,
 458    0x5b5b005b,0x95950095,0xffff00ff,0xd2d200d2,
 459    0xc4c400c4,0x48480048,0xf7f700f7,0xdbdb00db,
 460    0x03030003,0xdada00da,0x3f3f003f,0x94940094,
 461    0x5c5c005c,0x02020002,0x4a4a004a,0x33330033,
 462    0x67670067,0xf3f300f3,0x7f7f007f,0xe2e200e2,
 463    0x9b9b009b,0x26260026,0x37370037,0x3b3b003b,
 464    0x96960096,0x4b4b004b,0xbebe00be,0x2e2e002e,
 465    0x79790079,0x8c8c008c,0x6e6e006e,0x8e8e008e,
 466    0xf5f500f5,0xb6b600b6,0xfdfd00fd,0x59590059,
 467    0x98980098,0x6a6a006a,0x46460046,0xbaba00ba,
 468    0x25250025,0x42420042,0xa2a200a2,0xfafa00fa,
 469    0x07070007,0x55550055,0xeeee00ee,0x0a0a000a,
 470    0x49490049,0x68680068,0x38380038,0xa4a400a4,
 471    0x28280028,0x7b7b007b,0xc9c900c9,0xc1c100c1,
 472    0xe3e300e3,0xf4f400f4,0xc7c700c7,0x9e9e009e,
 473};
 474
 475
 476/**
 477 * Stuff related to the Camellia key schedule
 478 */
 479#define subl(x) subL[(x)]
 480#define subr(x) subR[(x)]
 481
 482static int camellia_setup128(const unsigned char *key, u32 *subkey)
 483{
 484    u32 kll, klr, krl, krr;
 485    u32 il, ir, t0, t1, w0, w1;
 486    u32 kw4l, kw4r, dw, tl, tr;
 487
 488#ifdef WOLFSSL_SMALL_STACK
 489    u32* subL;
 490    u32* subR;
 491
 492    subL = (u32*) XMALLOC(sizeof(u32) * 26, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 493    if (subL == NULL)
 494        return MEMORY_E;
 495
 496    subR = (u32*) XMALLOC(sizeof(u32) * 26, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 497    if (subR == NULL) {
 498        XFREE(subL, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 499        return MEMORY_E;
 500    }
 501#else
 502    u32 subL[26];
 503    u32 subR[26];
 504#endif
 505
 506    /**
 507     *  k == kll || klr || krl || krr (|| is concatenation)
 508     */
 509    kll = GETU32(key     );
 510    klr = GETU32(key +  4);
 511    krl = GETU32(key +  8);
 512    krr = GETU32(key + 12);
 513    /**
 514     * generate KL dependent subkeys
 515     */
 516    subl(0) = kll; subr(0) = klr;
 517    subl(1) = krl; subr(1) = krr;
 518    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 15);
 519    subl(4) = kll; subr(4) = klr;
 520    subl(5) = krl; subr(5) = krr;
 521    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 30);
 522    subl(10) = kll; subr(10) = klr;
 523    subl(11) = krl; subr(11) = krr;
 524    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 15);
 525    subl(13) = krl; subr(13) = krr;
 526    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 17);
 527    subl(16) = kll; subr(16) = klr;
 528    subl(17) = krl; subr(17) = krr;
 529    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 17);
 530    subl(18) = kll; subr(18) = klr;
 531    subl(19) = krl; subr(19) = krr;
 532    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 17);
 533    subl(22) = kll; subr(22) = klr;
 534    subl(23) = krl; subr(23) = krr;
 535
 536    /* generate KA */
 537    kll = subl(0); klr = subr(0);
 538    krl = subl(1); krr = subr(1);
 539    CAMELLIA_F(kll, klr,
 540               CAMELLIA_SIGMA1L, CAMELLIA_SIGMA1R,
 541               w0, w1, il, ir, t0, t1);
 542    krl ^= w0; krr ^= w1;
 543    CAMELLIA_F(krl, krr,
 544               CAMELLIA_SIGMA2L, CAMELLIA_SIGMA2R,
 545               kll, klr, il, ir, t0, t1);
 546    CAMELLIA_F(kll, klr,
 547               CAMELLIA_SIGMA3L, CAMELLIA_SIGMA3R,
 548               krl, krr, il, ir, t0, t1);
 549    krl ^= w0; krr ^= w1;
 550    CAMELLIA_F(krl, krr,
 551               CAMELLIA_SIGMA4L, CAMELLIA_SIGMA4R,
 552               w0, w1, il, ir, t0, t1);
 553    kll ^= w0; klr ^= w1;
 554
 555    /* generate KA dependent subkeys */
 556    subl(2) = kll; subr(2) = klr;
 557    subl(3) = krl; subr(3) = krr;
 558    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 15);
 559    subl(6) = kll; subr(6) = klr;
 560    subl(7) = krl; subr(7) = krr;
 561    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 15);
 562    subl(8) = kll; subr(8) = klr;
 563    subl(9) = krl; subr(9) = krr;
 564    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 15);
 565    subl(12) = kll; subr(12) = klr;
 566    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 15);
 567    subl(14) = kll; subr(14) = klr;
 568    subl(15) = krl; subr(15) = krr;
 569    CAMELLIA_ROLDQo32(kll, klr, krl, krr, w0, w1, 34);
 570    subl(20) = kll; subr(20) = klr;
 571    subl(21) = krl; subr(21) = krr;
 572    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 17);
 573    subl(24) = kll; subr(24) = klr;
 574    subl(25) = krl; subr(25) = krr;
 575
 576
 577    /* absorb kw2 to other subkeys */
 578    subl(3) ^= subl(1); subr(3) ^= subr(1);
 579    subl(5) ^= subl(1); subr(5) ^= subr(1);
 580    subl(7) ^= subl(1); subr(7) ^= subr(1);
 581    subl(1) ^= subr(1) & ~subr(9);
 582    dw = subl(1) & subl(9), subr(1) ^= CAMELLIA_RL1(dw);
 583    subl(11) ^= subl(1); subr(11) ^= subr(1);
 584    subl(13) ^= subl(1); subr(13) ^= subr(1);
 585    subl(15) ^= subl(1); subr(15) ^= subr(1);
 586    subl(1) ^= subr(1) & ~subr(17);
 587    dw = subl(1) & subl(17), subr(1) ^= CAMELLIA_RL1(dw);
 588    subl(19) ^= subl(1); subr(19) ^= subr(1);
 589    subl(21) ^= subl(1); subr(21) ^= subr(1);
 590    subl(23) ^= subl(1); subr(23) ^= subr(1);
 591    subl(24) ^= subl(1); subr(24) ^= subr(1);
 592
 593    /* absorb kw4 to other subkeys */
 594    kw4l = subl(25); kw4r = subr(25);
 595    subl(22) ^= kw4l; subr(22) ^= kw4r;
 596    subl(20) ^= kw4l; subr(20) ^= kw4r;
 597    subl(18) ^= kw4l; subr(18) ^= kw4r;
 598    kw4l ^= kw4r & ~subr(16);
 599    dw = kw4l & subl(16), kw4r ^= CAMELLIA_RL1(dw);
 600    subl(14) ^= kw4l; subr(14) ^= kw4r;
 601    subl(12) ^= kw4l; subr(12) ^= kw4r;
 602    subl(10) ^= kw4l; subr(10) ^= kw4r;
 603    kw4l ^= kw4r & ~subr(8);
 604    dw = kw4l & subl(8), kw4r ^= CAMELLIA_RL1(dw);
 605    subl(6) ^= kw4l; subr(6) ^= kw4r;
 606    subl(4) ^= kw4l; subr(4) ^= kw4r;
 607    subl(2) ^= kw4l; subr(2) ^= kw4r;
 608    subl(0) ^= kw4l; subr(0) ^= kw4r;
 609
 610    /* key XOR is end of F-function */
 611    CamelliaSubkeyL(0) = subl(0) ^ subl(2);
 612    CamelliaSubkeyR(0) = subr(0) ^ subr(2);
 613    CamelliaSubkeyL(2) = subl(3);
 614    CamelliaSubkeyR(2) = subr(3);
 615    CamelliaSubkeyL(3) = subl(2) ^ subl(4);
 616    CamelliaSubkeyR(3) = subr(2) ^ subr(4);
 617    CamelliaSubkeyL(4) = subl(3) ^ subl(5);
 618    CamelliaSubkeyR(4) = subr(3) ^ subr(5);
 619    CamelliaSubkeyL(5) = subl(4) ^ subl(6);
 620    CamelliaSubkeyR(5) = subr(4) ^ subr(6);
 621    CamelliaSubkeyL(6) = subl(5) ^ subl(7);
 622    CamelliaSubkeyR(6) = subr(5) ^ subr(7);
 623    tl = subl(10) ^ (subr(10) & ~subr(8));
 624    dw = tl & subl(8), tr = subr(10) ^ CAMELLIA_RL1(dw);
 625    CamelliaSubkeyL(7) = subl(6) ^ tl;
 626    CamelliaSubkeyR(7) = subr(6) ^ tr;
 627    CamelliaSubkeyL(8) = subl(8);
 628    CamelliaSubkeyR(8) = subr(8);
 629    CamelliaSubkeyL(9) = subl(9);
 630    CamelliaSubkeyR(9) = subr(9);
 631    tl = subl(7) ^ (subr(7) & ~subr(9));
 632    dw = tl & subl(9), tr = subr(7) ^ CAMELLIA_RL1(dw);
 633    CamelliaSubkeyL(10) = tl ^ subl(11);
 634    CamelliaSubkeyR(10) = tr ^ subr(11);
 635    CamelliaSubkeyL(11) = subl(10) ^ subl(12);
 636    CamelliaSubkeyR(11) = subr(10) ^ subr(12);
 637    CamelliaSubkeyL(12) = subl(11) ^ subl(13);
 638    CamelliaSubkeyR(12) = subr(11) ^ subr(13);
 639    CamelliaSubkeyL(13) = subl(12) ^ subl(14);
 640    CamelliaSubkeyR(13) = subr(12) ^ subr(14);
 641    CamelliaSubkeyL(14) = subl(13) ^ subl(15);
 642    CamelliaSubkeyR(14) = subr(13) ^ subr(15);
 643    tl = subl(18) ^ (subr(18) & ~subr(16));
 644    dw = tl & subl(16), tr = subr(18) ^ CAMELLIA_RL1(dw);
 645    CamelliaSubkeyL(15) = subl(14) ^ tl;
 646    CamelliaSubkeyR(15) = subr(14) ^ tr;
 647    CamelliaSubkeyL(16) = subl(16);
 648    CamelliaSubkeyR(16) = subr(16);
 649    CamelliaSubkeyL(17) = subl(17);
 650    CamelliaSubkeyR(17) = subr(17);
 651    tl = subl(15) ^ (subr(15) & ~subr(17));
 652    dw = tl & subl(17), tr = subr(15) ^ CAMELLIA_RL1(dw);
 653    CamelliaSubkeyL(18) = tl ^ subl(19);
 654    CamelliaSubkeyR(18) = tr ^ subr(19);
 655    CamelliaSubkeyL(19) = subl(18) ^ subl(20);
 656    CamelliaSubkeyR(19) = subr(18) ^ subr(20);
 657    CamelliaSubkeyL(20) = subl(19) ^ subl(21);
 658    CamelliaSubkeyR(20) = subr(19) ^ subr(21);
 659    CamelliaSubkeyL(21) = subl(20) ^ subl(22);
 660    CamelliaSubkeyR(21) = subr(20) ^ subr(22);
 661    CamelliaSubkeyL(22) = subl(21) ^ subl(23);
 662    CamelliaSubkeyR(22) = subr(21) ^ subr(23);
 663    CamelliaSubkeyL(23) = subl(22);
 664    CamelliaSubkeyR(23) = subr(22);
 665    CamelliaSubkeyL(24) = subl(24) ^ subl(23);
 666    CamelliaSubkeyR(24) = subr(24) ^ subr(23);
 667
 668    /* apply the inverse of the last half of P-function */
 669    dw = CamelliaSubkeyL(2) ^ CamelliaSubkeyR(2), dw = CAMELLIA_RL8(dw);
 670    CamelliaSubkeyR(2) = CamelliaSubkeyL(2) ^ dw, CamelliaSubkeyL(2) = dw;
 671    dw = CamelliaSubkeyL(3) ^ CamelliaSubkeyR(3), dw = CAMELLIA_RL8(dw);
 672    CamelliaSubkeyR(3) = CamelliaSubkeyL(3) ^ dw, CamelliaSubkeyL(3) = dw;
 673    dw = CamelliaSubkeyL(4) ^ CamelliaSubkeyR(4), dw = CAMELLIA_RL8(dw);
 674    CamelliaSubkeyR(4) = CamelliaSubkeyL(4) ^ dw, CamelliaSubkeyL(4) = dw;
 675    dw = CamelliaSubkeyL(5) ^ CamelliaSubkeyR(5), dw = CAMELLIA_RL8(dw);
 676    CamelliaSubkeyR(5) = CamelliaSubkeyL(5) ^ dw, CamelliaSubkeyL(5) = dw;
 677    dw = CamelliaSubkeyL(6) ^ CamelliaSubkeyR(6), dw = CAMELLIA_RL8(dw);
 678    CamelliaSubkeyR(6) = CamelliaSubkeyL(6) ^ dw, CamelliaSubkeyL(6) = dw;
 679    dw = CamelliaSubkeyL(7) ^ CamelliaSubkeyR(7), dw = CAMELLIA_RL8(dw);
 680    CamelliaSubkeyR(7) = CamelliaSubkeyL(7) ^ dw, CamelliaSubkeyL(7) = dw;
 681    dw = CamelliaSubkeyL(10) ^ CamelliaSubkeyR(10), dw = CAMELLIA_RL8(dw);
 682    CamelliaSubkeyR(10) = CamelliaSubkeyL(10) ^ dw, CamelliaSubkeyL(10) = dw;
 683    dw = CamelliaSubkeyL(11) ^ CamelliaSubkeyR(11), dw = CAMELLIA_RL8(dw);
 684    CamelliaSubkeyR(11) = CamelliaSubkeyL(11) ^ dw, CamelliaSubkeyL(11) = dw;
 685    dw = CamelliaSubkeyL(12) ^ CamelliaSubkeyR(12), dw = CAMELLIA_RL8(dw);
 686    CamelliaSubkeyR(12) = CamelliaSubkeyL(12) ^ dw, CamelliaSubkeyL(12) = dw;
 687    dw = CamelliaSubkeyL(13) ^ CamelliaSubkeyR(13), dw = CAMELLIA_RL8(dw);
 688    CamelliaSubkeyR(13) = CamelliaSubkeyL(13) ^ dw, CamelliaSubkeyL(13) = dw;
 689    dw = CamelliaSubkeyL(14) ^ CamelliaSubkeyR(14), dw = CAMELLIA_RL8(dw);
 690    CamelliaSubkeyR(14) = CamelliaSubkeyL(14) ^ dw, CamelliaSubkeyL(14) = dw;
 691    dw = CamelliaSubkeyL(15) ^ CamelliaSubkeyR(15), dw = CAMELLIA_RL8(dw);
 692    CamelliaSubkeyR(15) = CamelliaSubkeyL(15) ^ dw, CamelliaSubkeyL(15) = dw;
 693    dw = CamelliaSubkeyL(18) ^ CamelliaSubkeyR(18), dw = CAMELLIA_RL8(dw);
 694    CamelliaSubkeyR(18) = CamelliaSubkeyL(18) ^ dw, CamelliaSubkeyL(18) = dw;
 695    dw = CamelliaSubkeyL(19) ^ CamelliaSubkeyR(19), dw = CAMELLIA_RL8(dw);
 696    CamelliaSubkeyR(19) = CamelliaSubkeyL(19) ^ dw, CamelliaSubkeyL(19) = dw;
 697    dw = CamelliaSubkeyL(20) ^ CamelliaSubkeyR(20), dw = CAMELLIA_RL8(dw);
 698    CamelliaSubkeyR(20) = CamelliaSubkeyL(20) ^ dw, CamelliaSubkeyL(20) = dw;
 699    dw = CamelliaSubkeyL(21) ^ CamelliaSubkeyR(21), dw = CAMELLIA_RL8(dw);
 700    CamelliaSubkeyR(21) = CamelliaSubkeyL(21) ^ dw, CamelliaSubkeyL(21) = dw;
 701    dw = CamelliaSubkeyL(22) ^ CamelliaSubkeyR(22), dw = CAMELLIA_RL8(dw);
 702    CamelliaSubkeyR(22) = CamelliaSubkeyL(22) ^ dw, CamelliaSubkeyL(22) = dw;
 703    dw = CamelliaSubkeyL(23) ^ CamelliaSubkeyR(23), dw = CAMELLIA_RL8(dw);
 704    CamelliaSubkeyR(23) = CamelliaSubkeyL(23) ^ dw, CamelliaSubkeyL(23) = dw;
 705
 706    WC_FREE_VAR_EX(subL, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 707    WC_FREE_VAR_EX(subR, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 708
 709    return 0;
 710}
 711
 712static int camellia_setup256(const unsigned char *key, u32 *subkey)
 713{
 714    u32 kll,klr,krl,krr;           /* left half of key */
 715    u32 krll,krlr,krrl,krrr;       /* right half of key */
 716    u32 il, ir, t0, t1, w0, w1;    /* temporary variables */
 717    u32 kw4l, kw4r, dw, tl, tr;
 718
 719#ifdef WOLFSSL_SMALL_STACK
 720    u32* subL;
 721    u32* subR;
 722
 723    subL = (u32*) XMALLOC(sizeof(u32) * 34, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 724    if (subL == NULL)
 725        return MEMORY_E;
 726
 727    subR = (u32*) XMALLOC(sizeof(u32) * 34, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 728    if (subR == NULL) {
 729        XFREE(subL, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 730        return MEMORY_E;
 731    }
 732#else
 733    u32 subL[34];
 734    u32 subR[34];
 735#endif
 736
 737    /**
 738     *  key = (kll || klr || krl || krr || krll || krlr || krrl || krrr)
 739     *  (|| is concatenation)
 740     */
 741
 742    kll  = GETU32(key     );
 743    klr  = GETU32(key +  4);
 744    krl  = GETU32(key +  8);
 745    krr  = GETU32(key + 12);
 746    krll = GETU32(key + 16);
 747    krlr = GETU32(key + 20);
 748    krrl = GETU32(key + 24);
 749    krrr = GETU32(key + 28);
 750
 751    /* generate KL dependent subkeys */
 752    subl(0) = kll; subr(0) = klr;
 753    subl(1) = krl; subr(1) = krr;
 754    CAMELLIA_ROLDQo32(kll, klr, krl, krr, w0, w1, 45);
 755    subl(12) = kll; subr(12) = klr;
 756    subl(13) = krl; subr(13) = krr;
 757    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 15);
 758    subl(16) = kll; subr(16) = klr;
 759    subl(17) = krl; subr(17) = krr;
 760    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 17);
 761    subl(22) = kll; subr(22) = klr;
 762    subl(23) = krl; subr(23) = krr;
 763    CAMELLIA_ROLDQo32(kll, klr, krl, krr, w0, w1, 34);
 764    subl(30) = kll; subr(30) = klr;
 765    subl(31) = krl; subr(31) = krr;
 766
 767    /* generate KR dependent subkeys */
 768    CAMELLIA_ROLDQ(krll, krlr, krrl, krrr, w0, w1, 15);
 769    subl(4) = krll; subr(4) = krlr;
 770    subl(5) = krrl; subr(5) = krrr;
 771    CAMELLIA_ROLDQ(krll, krlr, krrl, krrr, w0, w1, 15);
 772    subl(8) = krll; subr(8) = krlr;
 773    subl(9) = krrl; subr(9) = krrr;
 774    CAMELLIA_ROLDQ(krll, krlr, krrl, krrr, w0, w1, 30);
 775    subl(18) = krll; subr(18) = krlr;
 776    subl(19) = krrl; subr(19) = krrr;
 777    CAMELLIA_ROLDQo32(krll, krlr, krrl, krrr, w0, w1, 34);
 778    subl(26) = krll; subr(26) = krlr;
 779    subl(27) = krrl; subr(27) = krrr;
 780    CAMELLIA_ROLDQo32(krll, krlr, krrl, krrr, w0, w1, 34);
 781
 782    /* generate KA */
 783    kll = subl(0) ^ krll; klr = subr(0) ^ krlr;
 784    krl = subl(1) ^ krrl; krr = subr(1) ^ krrr;
 785    CAMELLIA_F(kll, klr,
 786               CAMELLIA_SIGMA1L, CAMELLIA_SIGMA1R,
 787               w0, w1, il, ir, t0, t1);
 788    krl ^= w0; krr ^= w1;
 789    CAMELLIA_F(krl, krr,
 790               CAMELLIA_SIGMA2L, CAMELLIA_SIGMA2R,
 791               kll, klr, il, ir, t0, t1);
 792    kll ^= krll; klr ^= krlr;
 793    CAMELLIA_F(kll, klr,
 794               CAMELLIA_SIGMA3L, CAMELLIA_SIGMA3R,
 795               krl, krr, il, ir, t0, t1);
 796    krl ^= w0 ^ krrl; krr ^= w1 ^ krrr;
 797    CAMELLIA_F(krl, krr,
 798               CAMELLIA_SIGMA4L, CAMELLIA_SIGMA4R,
 799               w0, w1, il, ir, t0, t1);
 800    kll ^= w0; klr ^= w1;
 801
 802    /* generate KB */
 803    krll ^= kll; krlr ^= klr;
 804    krrl ^= krl; krrr ^= krr;
 805    CAMELLIA_F(krll, krlr,
 806               CAMELLIA_SIGMA5L, CAMELLIA_SIGMA5R,
 807               w0, w1, il, ir, t0, t1);
 808    krrl ^= w0; krrr ^= w1;
 809    CAMELLIA_F(krrl, krrr,
 810               CAMELLIA_SIGMA6L, CAMELLIA_SIGMA6R,
 811               w0, w1, il, ir, t0, t1);
 812    krll ^= w0; krlr ^= w1;
 813
 814    /* generate KA dependent subkeys */
 815    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 15);
 816    subl(6) = kll; subr(6) = klr;
 817    subl(7) = krl; subr(7) = krr;
 818    CAMELLIA_ROLDQ(kll, klr, krl, krr, w0, w1, 30);
 819    subl(14) = kll; subr(14) = klr;
 820    subl(15) = krl; subr(15) = krr;
 821    subl(24) = klr; subr(24) = krl;
 822    subl(25) = krr; subr(25) = kll;
 823    CAMELLIA_ROLDQo32(kll, klr, krl, krr, w0, w1, 49);
 824    subl(28) = kll; subr(28) = klr;
 825    subl(29) = krl; subr(29) = krr;
 826
 827    /* generate KB dependent subkeys */
 828    subl(2) = krll; subr(2) = krlr;
 829    subl(3) = krrl; subr(3) = krrr;
 830    CAMELLIA_ROLDQ(krll, krlr, krrl, krrr, w0, w1, 30);
 831    subl(10) = krll; subr(10) = krlr;
 832    subl(11) = krrl; subr(11) = krrr;
 833    CAMELLIA_ROLDQ(krll, krlr, krrl, krrr, w0, w1, 30);
 834    subl(20) = krll; subr(20) = krlr;
 835    subl(21) = krrl; subr(21) = krrr;
 836    CAMELLIA_ROLDQo32(krll, krlr, krrl, krrr, w0, w1, 51);
 837    subl(32) = krll; subr(32) = krlr;
 838    subl(33) = krrl; subr(33) = krrr;
 839
 840    /* absorb kw2 to other subkeys */
 841    subl(3) ^= subl(1); subr(3) ^= subr(1);
 842    subl(5) ^= subl(1); subr(5) ^= subr(1);
 843    subl(7) ^= subl(1); subr(7) ^= subr(1);
 844    subl(1) ^= subr(1) & ~subr(9);
 845    dw = subl(1) & subl(9), subr(1) ^= CAMELLIA_RL1(dw);
 846    subl(11) ^= subl(1); subr(11) ^= subr(1);
 847    subl(13) ^= subl(1); subr(13) ^= subr(1);
 848    subl(15) ^= subl(1); subr(15) ^= subr(1);
 849    subl(1) ^= subr(1) & ~subr(17);
 850    dw = subl(1) & subl(17), subr(1) ^= CAMELLIA_RL1(dw);
 851    subl(19) ^= subl(1); subr(19) ^= subr(1);
 852    subl(21) ^= subl(1); subr(21) ^= subr(1);
 853    subl(23) ^= subl(1); subr(23) ^= subr(1);
 854    subl(1) ^= subr(1) & ~subr(25);
 855    dw = subl(1) & subl(25), subr(1) ^= CAMELLIA_RL1(dw);
 856    subl(27) ^= subl(1); subr(27) ^= subr(1);
 857    subl(29) ^= subl(1); subr(29) ^= subr(1);
 858    subl(31) ^= subl(1); subr(31) ^= subr(1);
 859    subl(32) ^= subl(1); subr(32) ^= subr(1);
 860
 861    /* absorb kw4 to other subkeys */
 862    kw4l = subl(33); kw4r = subr(33);
 863    subl(30) ^= kw4l; subr(30) ^= kw4r;
 864    subl(28) ^= kw4l; subr(28) ^= kw4r;
 865    subl(26) ^= kw4l; subr(26) ^= kw4r;
 866    kw4l ^= kw4r & ~subr(24);
 867    dw = kw4l & subl(24), kw4r ^= CAMELLIA_RL1(dw);
 868    subl(22) ^= kw4l; subr(22) ^= kw4r;
 869    subl(20) ^= kw4l; subr(20) ^= kw4r;
 870    subl(18) ^= kw4l; subr(18) ^= kw4r;
 871    kw4l ^= kw4r & ~subr(16);
 872    dw = kw4l & subl(16), kw4r ^= CAMELLIA_RL1(dw);
 873    subl(14) ^= kw4l; subr(14) ^= kw4r;
 874    subl(12) ^= kw4l; subr(12) ^= kw4r;
 875    subl(10) ^= kw4l; subr(10) ^= kw4r;
 876    kw4l ^= kw4r & ~subr(8);
 877    dw = kw4l & subl(8), kw4r ^= CAMELLIA_RL1(dw);
 878    subl(6) ^= kw4l; subr(6) ^= kw4r;
 879    subl(4) ^= kw4l; subr(4) ^= kw4r;
 880    subl(2) ^= kw4l; subr(2) ^= kw4r;
 881    subl(0) ^= kw4l; subr(0) ^= kw4r;
 882
 883    /* key XOR is end of F-function */
 884    CamelliaSubkeyL(0) = subl(0) ^ subl(2);
 885    CamelliaSubkeyR(0) = subr(0) ^ subr(2);
 886    CamelliaSubkeyL(2) = subl(3);
 887    CamelliaSubkeyR(2) = subr(3);
 888    CamelliaSubkeyL(3) = subl(2) ^ subl(4);
 889    CamelliaSubkeyR(3) = subr(2) ^ subr(4);
 890    CamelliaSubkeyL(4) = subl(3) ^ subl(5);
 891    CamelliaSubkeyR(4) = subr(3) ^ subr(5);
 892    CamelliaSubkeyL(5) = subl(4) ^ subl(6);
 893    CamelliaSubkeyR(5) = subr(4) ^ subr(6);
 894    CamelliaSubkeyL(6) = subl(5) ^ subl(7);
 895    CamelliaSubkeyR(6) = subr(5) ^ subr(7);
 896    tl = subl(10) ^ (subr(10) & ~subr(8));
 897    dw = tl & subl(8), tr = subr(10) ^ CAMELLIA_RL1(dw);
 898    CamelliaSubkeyL(7) = subl(6) ^ tl;
 899    CamelliaSubkeyR(7) = subr(6) ^ tr;
 900    CamelliaSubkeyL(8) = subl(8);
 901    CamelliaSubkeyR(8) = subr(8);
 902    CamelliaSubkeyL(9) = subl(9);
 903    CamelliaSubkeyR(9) = subr(9);
 904    tl = subl(7) ^ (subr(7) & ~subr(9));
 905    dw = tl & subl(9), tr = subr(7) ^ CAMELLIA_RL1(dw);
 906    CamelliaSubkeyL(10) = tl ^ subl(11);
 907    CamelliaSubkeyR(10) = tr ^ subr(11);
 908    CamelliaSubkeyL(11) = subl(10) ^ subl(12);
 909    CamelliaSubkeyR(11) = subr(10) ^ subr(12);
 910    CamelliaSubkeyL(12) = subl(11) ^ subl(13);
 911    CamelliaSubkeyR(12) = subr(11) ^ subr(13);
 912    CamelliaSubkeyL(13) = subl(12) ^ subl(14);
 913    CamelliaSubkeyR(13) = subr(12) ^ subr(14);
 914    CamelliaSubkeyL(14) = subl(13) ^ subl(15);
 915    CamelliaSubkeyR(14) = subr(13) ^ subr(15);
 916    tl = subl(18) ^ (subr(18) & ~subr(16));
 917    dw = tl & subl(16), tr = subr(18) ^ CAMELLIA_RL1(dw);
 918    CamelliaSubkeyL(15) = subl(14) ^ tl;
 919    CamelliaSubkeyR(15) = subr(14) ^ tr;
 920    CamelliaSubkeyL(16) = subl(16);
 921    CamelliaSubkeyR(16) = subr(16);
 922    CamelliaSubkeyL(17) = subl(17);
 923    CamelliaSubkeyR(17) = subr(17);
 924    tl = subl(15) ^ (subr(15) & ~subr(17));
 925    dw = tl & subl(17), tr = subr(15) ^ CAMELLIA_RL1(dw);
 926    CamelliaSubkeyL(18) = tl ^ subl(19);
 927    CamelliaSubkeyR(18) = tr ^ subr(19);
 928    CamelliaSubkeyL(19) = subl(18) ^ subl(20);
 929    CamelliaSubkeyR(19) = subr(18) ^ subr(20);
 930    CamelliaSubkeyL(20) = subl(19) ^ subl(21);
 931    CamelliaSubkeyR(20) = subr(19) ^ subr(21);
 932    CamelliaSubkeyL(21) = subl(20) ^ subl(22);
 933    CamelliaSubkeyR(21) = subr(20) ^ subr(22);
 934    CamelliaSubkeyL(22) = subl(21) ^ subl(23);
 935    CamelliaSubkeyR(22) = subr(21) ^ subr(23);
 936    tl = subl(26) ^ (subr(26) & ~subr(24));
 937    dw = tl & subl(24), tr = subr(26) ^ CAMELLIA_RL1(dw);
 938    CamelliaSubkeyL(23) = subl(22) ^ tl;
 939    CamelliaSubkeyR(23) = subr(22) ^ tr;
 940    CamelliaSubkeyL(24) = subl(24);
 941    CamelliaSubkeyR(24) = subr(24);
 942    CamelliaSubkeyL(25) = subl(25);
 943    CamelliaSubkeyR(25) = subr(25);
 944    tl = subl(23) ^ (subr(23) &  ~subr(25));
 945    dw = tl & subl(25), tr = subr(23) ^ CAMELLIA_RL1(dw);
 946    CamelliaSubkeyL(26) = tl ^ subl(27);
 947    CamelliaSubkeyR(26) = tr ^ subr(27);
 948    CamelliaSubkeyL(27) = subl(26) ^ subl(28);
 949    CamelliaSubkeyR(27) = subr(26) ^ subr(28);
 950    CamelliaSubkeyL(28) = subl(27) ^ subl(29);
 951    CamelliaSubkeyR(28) = subr(27) ^ subr(29);
 952    CamelliaSubkeyL(29) = subl(28) ^ subl(30);
 953    CamelliaSubkeyR(29) = subr(28) ^ subr(30);
 954    CamelliaSubkeyL(30) = subl(29) ^ subl(31);
 955    CamelliaSubkeyR(30) = subr(29) ^ subr(31);
 956    CamelliaSubkeyL(31) = subl(30);
 957    CamelliaSubkeyR(31) = subr(30);
 958    CamelliaSubkeyL(32) = subl(32) ^ subl(31);
 959    CamelliaSubkeyR(32) = subr(32) ^ subr(31);
 960
 961    /* apply the inverse of the last half of P-function */
 962    dw = CamelliaSubkeyL(2) ^ CamelliaSubkeyR(2), dw = CAMELLIA_RL8(dw);
 963    CamelliaSubkeyR(2) = CamelliaSubkeyL(2) ^ dw, CamelliaSubkeyL(2) = dw;
 964    dw = CamelliaSubkeyL(3) ^ CamelliaSubkeyR(3), dw = CAMELLIA_RL8(dw);
 965    CamelliaSubkeyR(3) = CamelliaSubkeyL(3) ^ dw, CamelliaSubkeyL(3) = dw;
 966    dw = CamelliaSubkeyL(4) ^ CamelliaSubkeyR(4), dw = CAMELLIA_RL8(dw);
 967    CamelliaSubkeyR(4) = CamelliaSubkeyL(4) ^ dw, CamelliaSubkeyL(4) = dw;
 968    dw = CamelliaSubkeyL(5) ^ CamelliaSubkeyR(5), dw = CAMELLIA_RL8(dw);
 969    CamelliaSubkeyR(5) = CamelliaSubkeyL(5) ^ dw, CamelliaSubkeyL(5) = dw;
 970    dw = CamelliaSubkeyL(6) ^ CamelliaSubkeyR(6), dw = CAMELLIA_RL8(dw);
 971    CamelliaSubkeyR(6) = CamelliaSubkeyL(6) ^ dw, CamelliaSubkeyL(6) = dw;
 972    dw = CamelliaSubkeyL(7) ^ CamelliaSubkeyR(7), dw = CAMELLIA_RL8(dw);
 973    CamelliaSubkeyR(7) = CamelliaSubkeyL(7) ^ dw, CamelliaSubkeyL(7) = dw;
 974    dw = CamelliaSubkeyL(10) ^ CamelliaSubkeyR(10), dw = CAMELLIA_RL8(dw);
 975    CamelliaSubkeyR(10) = CamelliaSubkeyL(10) ^ dw, CamelliaSubkeyL(10) = dw;
 976    dw = CamelliaSubkeyL(11) ^ CamelliaSubkeyR(11), dw = CAMELLIA_RL8(dw);
 977    CamelliaSubkeyR(11) = CamelliaSubkeyL(11) ^ dw, CamelliaSubkeyL(11) = dw;
 978    dw = CamelliaSubkeyL(12) ^ CamelliaSubkeyR(12), dw = CAMELLIA_RL8(dw);
 979    CamelliaSubkeyR(12) = CamelliaSubkeyL(12) ^ dw, CamelliaSubkeyL(12) = dw;
 980    dw = CamelliaSubkeyL(13) ^ CamelliaSubkeyR(13), dw = CAMELLIA_RL8(dw);
 981    CamelliaSubkeyR(13) = CamelliaSubkeyL(13) ^ dw, CamelliaSubkeyL(13) = dw;
 982    dw = CamelliaSubkeyL(14) ^ CamelliaSubkeyR(14), dw = CAMELLIA_RL8(dw);
 983    CamelliaSubkeyR(14) = CamelliaSubkeyL(14) ^ dw, CamelliaSubkeyL(14) = dw;
 984    dw = CamelliaSubkeyL(15) ^ CamelliaSubkeyR(15), dw = CAMELLIA_RL8(dw);
 985    CamelliaSubkeyR(15) = CamelliaSubkeyL(15) ^ dw, CamelliaSubkeyL(15) = dw;
 986    dw = CamelliaSubkeyL(18) ^ CamelliaSubkeyR(18), dw = CAMELLIA_RL8(dw);
 987    CamelliaSubkeyR(18) = CamelliaSubkeyL(18) ^ dw, CamelliaSubkeyL(18) = dw;
 988    dw = CamelliaSubkeyL(19) ^ CamelliaSubkeyR(19), dw = CAMELLIA_RL8(dw);
 989    CamelliaSubkeyR(19) = CamelliaSubkeyL(19) ^ dw, CamelliaSubkeyL(19) = dw;
 990    dw = CamelliaSubkeyL(20) ^ CamelliaSubkeyR(20), dw = CAMELLIA_RL8(dw);
 991    CamelliaSubkeyR(20) = CamelliaSubkeyL(20) ^ dw, CamelliaSubkeyL(20) = dw;
 992    dw = CamelliaSubkeyL(21) ^ CamelliaSubkeyR(21), dw = CAMELLIA_RL8(dw);
 993    CamelliaSubkeyR(21) = CamelliaSubkeyL(21) ^ dw, CamelliaSubkeyL(21) = dw;
 994    dw = CamelliaSubkeyL(22) ^ CamelliaSubkeyR(22), dw = CAMELLIA_RL8(dw);
 995    CamelliaSubkeyR(22) = CamelliaSubkeyL(22) ^ dw, CamelliaSubkeyL(22) = dw;
 996    dw = CamelliaSubkeyL(23) ^ CamelliaSubkeyR(23), dw = CAMELLIA_RL8(dw);
 997    CamelliaSubkeyR(23) = CamelliaSubkeyL(23) ^ dw, CamelliaSubkeyL(23) = dw;
 998    dw = CamelliaSubkeyL(26) ^ CamelliaSubkeyR(26), dw = CAMELLIA_RL8(dw);
 999    CamelliaSubkeyR(26) = CamelliaSubkeyL(26) ^ dw, CamelliaSubkeyL(26) = dw;
1000    dw = CamelliaSubkeyL(27) ^ CamelliaSubkeyR(27), dw = CAMELLIA_RL8(dw);
1001    CamelliaSubkeyR(27) = CamelliaSubkeyL(27) ^ dw, CamelliaSubkeyL(27) = dw;
1002    dw = CamelliaSubkeyL(28) ^ CamelliaSubkeyR(28), dw = CAMELLIA_RL8(dw);
1003    CamelliaSubkeyR(28) = CamelliaSubkeyL(28) ^ dw, CamelliaSubkeyL(28) = dw;
1004    dw = CamelliaSubkeyL(29) ^ CamelliaSubkeyR(29), dw = CAMELLIA_RL8(dw);
1005    CamelliaSubkeyR(29) = CamelliaSubkeyL(29) ^ dw, CamelliaSubkeyL(29) = dw;
1006    dw = CamelliaSubkeyL(30) ^ CamelliaSubkeyR(30), dw = CAMELLIA_RL8(dw);
1007    CamelliaSubkeyR(30) = CamelliaSubkeyL(30) ^ dw, CamelliaSubkeyL(30) = dw;
1008    dw = CamelliaSubkeyL(31) ^ CamelliaSubkeyR(31), dw = CAMELLIA_RL8(dw);
1009    CamelliaSubkeyR(31) = CamelliaSubkeyL(31) ^ dw,CamelliaSubkeyL(31) = dw;
1010
1011    WC_FREE_VAR_EX(subL, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1012    WC_FREE_VAR_EX(subR, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1013
1014    return 0;
1015}
1016
1017static int camellia_setup192(const unsigned char *key, u32 *subkey)
1018{
1019    unsigned char kk[32];
1020    u32 krll = 0, krlr = 0, krrl = 0, krrr = 0;
1021
1022    XMEMCPY(kk, key, 24);
1023    XMEMCPY((unsigned char *)&krll, key+16,4);
1024    XMEMCPY((unsigned char *)&krlr, key+20,4);
1025    krrl = ~krll;
1026    krrr = ~krlr;
1027    XMEMCPY(kk+24, (unsigned char *)&krrl, 4);
1028    XMEMCPY(kk+28, (unsigned char *)&krrr, 4);
1029
1030    return camellia_setup256(kk, subkey);
1031}
1032
1033
1034/**
1035 * Stuff related to camellia encryption/decryption
1036 *
1037 * "io" must be 4byte aligned and big-endian data.
1038 */
1039static void camellia_encrypt128(const u32 *subkey, u32 *io)
1040{
1041    u32 il, ir, t0, t1;
1042
1043    /* pre whitening but absorb kw2*/
1044    io[0] ^= CamelliaSubkeyL(0);
1045    io[1] ^= CamelliaSubkeyR(0);
1046    /* main iteration */
1047
1048    CAMELLIA_ROUNDSM(io[0],io[1],
1049                     CamelliaSubkeyL(2),CamelliaSubkeyR(2),
1050                     io[2],io[3],il,ir,t0,t1);
1051    CAMELLIA_ROUNDSM(io[2],io[3],
1052                     CamelliaSubkeyL(3),CamelliaSubkeyR(3),
1053                     io[0],io[1],il,ir,t0,t1);
1054    CAMELLIA_ROUNDSM(io[0],io[1],
1055                     CamelliaSubkeyL(4),CamelliaSubkeyR(4),
1056                     io[2],io[3],il,ir,t0,t1);
1057    CAMELLIA_ROUNDSM(io[2],io[3],
1058                     CamelliaSubkeyL(5),CamelliaSubkeyR(5),
1059                     io[0],io[1],il,ir,t0,t1);
1060    CAMELLIA_ROUNDSM(io[0],io[1],
1061                     CamelliaSubkeyL(6),CamelliaSubkeyR(6),
1062                     io[2],io[3],il,ir,t0,t1);
1063    CAMELLIA_ROUNDSM(io[2],io[3],
1064                     CamelliaSubkeyL(7),CamelliaSubkeyR(7),
1065                     io[0],io[1],il,ir,t0,t1);
1066
1067    CAMELLIA_FLS(io[0],io[1],io[2],io[3],
1068                 CamelliaSubkeyL(8),CamelliaSubkeyR(8),
1069                 CamelliaSubkeyL(9),CamelliaSubkeyR(9),
1070                 t0,t1,il,ir);
1071
1072    CAMELLIA_ROUNDSM(io[0],io[1],
1073                     CamelliaSubkeyL(10),CamelliaSubkeyR(10),
1074                     io[2],io[3],il,ir,t0,t1);
1075    CAMELLIA_ROUNDSM(io[2],io[3],
1076                     CamelliaSubkeyL(11),CamelliaSubkeyR(11),
1077                     io[0],io[1],il,ir,t0,t1);
1078    CAMELLIA_ROUNDSM(io[0],io[1],
1079                     CamelliaSubkeyL(12),CamelliaSubkeyR(12),
1080                     io[2],io[3],il,ir,t0,t1);
1081    CAMELLIA_ROUNDSM(io[2],io[3],
1082                     CamelliaSubkeyL(13),CamelliaSubkeyR(13),
1083                     io[0],io[1],il,ir,t0,t1);
1084    CAMELLIA_ROUNDSM(io[0],io[1],
1085                     CamelliaSubkeyL(14),CamelliaSubkeyR(14),
1086                     io[2],io[3],il,ir,t0,t1);
1087    CAMELLIA_ROUNDSM(io[2],io[3],
1088                     CamelliaSubkeyL(15),CamelliaSubkeyR(15),
1089                     io[0],io[1],il,ir,t0,t1);
1090
1091    CAMELLIA_FLS(io[0],io[1],io[2],io[3],
1092                 CamelliaSubkeyL(16),CamelliaSubkeyR(16),
1093                 CamelliaSubkeyL(17),CamelliaSubkeyR(17),
1094                 t0,t1,il,ir);
1095
1096    CAMELLIA_ROUNDSM(io[0],io[1],
1097                     CamelliaSubkeyL(18),CamelliaSubkeyR(18),
1098                     io[2],io[3],il,ir,t0,t1);
1099    CAMELLIA_ROUNDSM(io[2],io[3],
1100                     CamelliaSubkeyL(19),CamelliaSubkeyR(19),
1101                     io[0],io[1],il,ir,t0,t1);
1102    CAMELLIA_ROUNDSM(io[0],io[1],
1103                     CamelliaSubkeyL(20),CamelliaSubkeyR(20),
1104                     io[2],io[3],il,ir,t0,t1);
1105    CAMELLIA_ROUNDSM(io[2],io[3],
1106                     CamelliaSubkeyL(21),CamelliaSubkeyR(21),
1107                     io[0],io[1],il,ir,t0,t1);
1108    CAMELLIA_ROUNDSM(io[0],io[1],
1109                     CamelliaSubkeyL(22),CamelliaSubkeyR(22),
1110                     io[2],io[3],il,ir,t0,t1);
1111    CAMELLIA_ROUNDSM(io[2],io[3],
1112                     CamelliaSubkeyL(23),CamelliaSubkeyR(23),
1113                     io[0],io[1],il,ir,t0,t1);
1114
1115    /* post whitening but kw4 */
1116    io[2] ^= CamelliaSubkeyL(24);
1117    io[3] ^= CamelliaSubkeyR(24);
1118
1119    t0 = io[0];
1120    t1 = io[1];
1121    io[0] = io[2];
1122    io[1] = io[3];
1123    io[2] = t0;
1124    io[3] = t1;
1125
1126    return;
1127}
1128
1129static void camellia_decrypt128(const u32 *subkey, u32 *io)
1130{
1131    u32 il,ir,t0,t1;               /* temporary variables */
1132
1133    /* pre whitening but absorb kw2*/
1134    io[0] ^= CamelliaSubkeyL(24);
1135    io[1] ^= CamelliaSubkeyR(24);
1136
1137    /* main iteration */
1138    CAMELLIA_ROUNDSM(io[0],io[1],
1139                     CamelliaSubkeyL(23),CamelliaSubkeyR(23),
1140                     io[2],io[3],il,ir,t0,t1);
1141    CAMELLIA_ROUNDSM(io[2],io[3],
1142                     CamelliaSubkeyL(22),CamelliaSubkeyR(22),
1143                     io[0],io[1],il,ir,t0,t1);
1144    CAMELLIA_ROUNDSM(io[0],io[1],
1145                     CamelliaSubkeyL(21),CamelliaSubkeyR(21),
1146                     io[2],io[3],il,ir,t0,t1);
1147    CAMELLIA_ROUNDSM(io[2],io[3],
1148                     CamelliaSubkeyL(20),CamelliaSubkeyR(20),
1149                     io[0],io[1],il,ir,t0,t1);
1150    CAMELLIA_ROUNDSM(io[0],io[1],
1151                     CamelliaSubkeyL(19),CamelliaSubkeyR(19),
1152                     io[2],io[3],il,ir,t0,t1);
1153    CAMELLIA_ROUNDSM(io[2],io[3],
1154                     CamelliaSubkeyL(18),CamelliaSubkeyR(18),
1155                     io[0],io[1],il,ir,t0,t1);
1156
1157    CAMELLIA_FLS(io[0],io[1],io[2],io[3],
1158                 CamelliaSubkeyL(17),CamelliaSubkeyR(17),
1159                 CamelliaSubkeyL(16),CamelliaSubkeyR(16),
1160                 t0,t1,il,ir);
1161
1162    CAMELLIA_ROUNDSM(io[0],io[1],
1163                     CamelliaSubkeyL(15),CamelliaSubkeyR(15),
1164                     io[2],io[3],il,ir,t0,t1);
1165    CAMELLIA_ROUNDSM(io[2],io[3],
1166                     CamelliaSubkeyL(14),CamelliaSubkeyR(14),
1167                     io[0],io[1],il,ir,t0,t1);
1168    CAMELLIA_ROUNDSM(io[0],io[1],
1169                     CamelliaSubkeyL(13),CamelliaSubkeyR(13),
1170                     io[2],io[3],il,ir,t0,t1);
1171    CAMELLIA_ROUNDSM(io[2],io[3],
1172                     CamelliaSubkeyL(12),CamelliaSubkeyR(12),
1173                     io[0],io[1],il,ir,t0,t1);
1174    CAMELLIA_ROUNDSM(io[0],io[1],
1175                     CamelliaSubkeyL(11),CamelliaSubkeyR(11),
1176                     io[2],io[3],il,ir,t0,t1);
1177    CAMELLIA_ROUNDSM(io[2],io[3],
1178                     CamelliaSubkeyL(10),CamelliaSubkeyR(10),
1179                     io[0],io[1],il,ir,t0,t1);
1180
1181    CAMELLIA_FLS(io[0],io[1],io[2],io[3],
1182                 CamelliaSubkeyL(9),CamelliaSubkeyR(9),
1183                 CamelliaSubkeyL(8),CamelliaSubkeyR(8),
1184                 t0,t1,il,ir);
1185
1186    CAMELLIA_ROUNDSM(io[0],io[1],
1187                     CamelliaSubkeyL(7),CamelliaSubkeyR(7),
1188                     io[2],io[3],il,ir,t0,t1);
1189    CAMELLIA_ROUNDSM(io[2],io[3],
1190                     CamelliaSubkeyL(6),CamelliaSubkeyR(6),
1191                     io[0],io[1],il,ir,t0,t1);
1192    CAMELLIA_ROUNDSM(io[0],io[1],
1193                     CamelliaSubkeyL(5),CamelliaSubkeyR(5),
1194                     io[2],io[3],il,ir,t0,t1);
1195    CAMELLIA_ROUNDSM(io[2],io[3],
1196                     CamelliaSubkeyL(4),CamelliaSubkeyR(4),
1197                     io[0],io[1],il,ir,t0,t1);
1198    CAMELLIA_ROUNDSM(io[0],io[1],
1199                     CamelliaSubkeyL(3),CamelliaSubkeyR(3),
1200                     io[2],io[3],il,ir,t0,t1);
1201    CAMELLIA_ROUNDSM(io[2],io[3],
1202                     CamelliaSubkeyL(2),CamelliaSubkeyR(2),
1203                     io[0],io[1],il,ir,t0,t1);
1204
1205    /* post whitening but kw4 */
1206    io[2] ^= CamelliaSubkeyL(0);
1207    io[3] ^= CamelliaSubkeyR(0);
1208
1209    t0 = io[0];
1210    t1 = io[1];
1211    io[0] = io[2];
1212    io[1] = io[3];
1213    io[2] = t0;
1214    io[3] = t1;
1215
1216    return;
1217}
1218
1219/**
1220 * stuff for 192 and 256bit encryption/decryption
1221 */
1222static void camellia_encrypt256(const u32 *subkey, u32 *io)
1223{
1224    u32 il,ir,t0,t1;           /* temporary variables */
1225
1226    /* pre whitening but absorb kw2*/
1227    io[0] ^= CamelliaSubkeyL(0);
1228    io[1] ^= CamelliaSubkeyR(0);
1229
1230    /* main iteration */
1231    CAMELLIA_ROUNDSM(io[0],io[1],
1232                     CamelliaSubkeyL(2),CamelliaSubkeyR(2),
1233                     io[2],io[3],il,ir,t0,t1);
1234    CAMELLIA_ROUNDSM(io[2],io[3],
1235                     CamelliaSubkeyL(3),CamelliaSubkeyR(3),
1236                     io[0],io[1],il,ir,t0,t1);
1237    CAMELLIA_ROUNDSM(io[0],io[1],
1238                     CamelliaSubkeyL(4),CamelliaSubkeyR(4),
1239                     io[2],io[3],il,ir,t0,t1);
1240    CAMELLIA_ROUNDSM(io[2],io[3],
1241                     CamelliaSubkeyL(5),CamelliaSubkeyR(5),
1242                     io[0],io[1],il,ir,t0,t1);
1243    CAMELLIA_ROUNDSM(io[0],io[1],
1244                     CamelliaSubkeyL(6),CamelliaSubkeyR(6),
1245                     io[2],io[3],il,ir,t0,t1);
1246    CAMELLIA_ROUNDSM(io[2],io[3],
1247                     CamelliaSubkeyL(7),CamelliaSubkeyR(7),
1248                     io[0],io[1],il,ir,t0,t1);
1249
1250    CAMELLIA_FLS(io[0],io[1],io[2],io[3],
1251                 CamelliaSubkeyL(8),CamelliaSubkeyR(8),
1252                 CamelliaSubkeyL(9),CamelliaSubkeyR(9),
1253                 t0,t1,il,ir);
1254
1255    CAMELLIA_ROUNDSM(io[0],io[1],
1256                     CamelliaSubkeyL(10),CamelliaSubkeyR(10),
1257                     io[2],io[3],il,ir,t0,t1);
1258    CAMELLIA_ROUNDSM(io[2],io[3],
1259                     CamelliaSubkeyL(11),CamelliaSubkeyR(11),
1260                     io[0],io[1],il,ir,t0,t1);
1261    CAMELLIA_ROUNDSM(io[0],io[1],
1262                     CamelliaSubkeyL(12),CamelliaSubkeyR(12),
1263                     io[2],io[3],il,ir,t0,t1);
1264    CAMELLIA_ROUNDSM(io[2],io[3],
1265                     CamelliaSubkeyL(13),CamelliaSubkeyR(13),
1266                     io[0],io[1],il,ir,t0,t1);
1267    CAMELLIA_ROUNDSM(io[0],io[1],
1268                     CamelliaSubkeyL(14),CamelliaSubkeyR(14),
1269                     io[2],io[3],il,ir,t0,t1);
1270    CAMELLIA_ROUNDSM(io[2],io[3],
1271                     CamelliaSubkeyL(15),CamelliaSubkeyR(15),
1272                     io[0],io[1],il,ir,t0,t1);
1273
1274    CAMELLIA_FLS(io[0],io[1],io[2],io[3],
1275                 CamelliaSubkeyL(16),CamelliaSubkeyR(16),
1276                 CamelliaSubkeyL(17),CamelliaSubkeyR(17),
1277                 t0,t1,il,ir);
1278
1279    CAMELLIA_ROUNDSM(io[0],io[1],
1280                     CamelliaSubkeyL(18),CamelliaSubkeyR(18),
1281                     io[2],io[3],il,ir,t0,t1);
1282    CAMELLIA_ROUNDSM(io[2],io[3],
1283                     CamelliaSubkeyL(19),CamelliaSubkeyR(19),
1284                     io[0],io[1],il,ir,t0,t1);
1285    CAMELLIA_ROUNDSM(io[0],io[1],
1286                     CamelliaSubkeyL(20),CamelliaSubkeyR(20),
1287                     io[2],io[3],il,ir,t0,t1);
1288    CAMELLIA_ROUNDSM(io[2],io[3],
1289                     CamelliaSubkeyL(21),CamelliaSubkeyR(21),
1290                     io[0],io[1],il,ir,t0,t1);
1291    CAMELLIA_ROUNDSM(io[0],io[1],
1292                     CamelliaSubkeyL(22),CamelliaSubkeyR(22),
1293                     io[2],io[3],il,ir,t0,t1);
1294    CAMELLIA_ROUNDSM(io[2],io[3],
1295                     CamelliaSubkeyL(23),CamelliaSubkeyR(23),
1296                     io[0],io[1],il,ir,t0,t1);
1297
1298    CAMELLIA_FLS(io[0],io[1],io[2],io[3],
1299                 CamelliaSubkeyL(24),CamelliaSubkeyR(24),
1300                 CamelliaSubkeyL(25),CamelliaSubkeyR(25),
1301                 t0,t1,il,ir);
1302
1303    CAMELLIA_ROUNDSM(io[0],io[1],
1304                     CamelliaSubkeyL(26),CamelliaSubkeyR(26),
1305                     io[2],io[3],il,ir,t0,t1);
1306    CAMELLIA_ROUNDSM(io[2],io[3],
1307                     CamelliaSubkeyL(27),CamelliaSubkeyR(27),
1308                     io[0],io[1],il,ir,t0,t1);
1309    CAMELLIA_ROUNDSM(io[0],io[1],
1310                     CamelliaSubkeyL(28),CamelliaSubkeyR(28),
1311                     io[2],io[3],il,ir,t0,t1);
1312    CAMELLIA_ROUNDSM(io[2],io[3],
1313                     CamelliaSubkeyL(29),CamelliaSubkeyR(29),
1314                     io[0],io[1],il,ir,t0,t1);
1315    CAMELLIA_ROUNDSM(io[0],io[1],
1316                     CamelliaSubkeyL(30),CamelliaSubkeyR(30),
1317                     io[2],io[3],il,ir,t0,t1);
1318    CAMELLIA_ROUNDSM(io[2],io[3],
1319                     CamelliaSubkeyL(31),CamelliaSubkeyR(31),
1320                     io[0],io[1],il,ir,t0,t1);
1321
1322    /* post whitening but kw4 */
1323    io[2] ^= CamelliaSubkeyL(32);
1324    io[3] ^= CamelliaSubkeyR(32);
1325
1326    t0 = io[0];
1327    t1 = io[1];
1328    io[0] = io[2];
1329    io[1] = io[3];
1330    io[2] = t0;
1331    io[3] = t1;
1332
1333    return;
1334}
1335
1336static void camellia_decrypt256(const u32 *subkey, u32 *io)
1337{
1338    u32 il,ir,t0,t1;           /* temporary variables */
1339
1340    /* pre whitening but absorb kw2*/
1341    io[0] ^= CamelliaSubkeyL(32);
1342    io[1] ^= CamelliaSubkeyR(32);
1343
1344    /* main iteration */
1345    CAMELLIA_ROUNDSM(io[0],io[1],
1346                     CamelliaSubkeyL(31),CamelliaSubkeyR(31),
1347                     io[2],io[3],il,ir,t0,t1);
1348    CAMELLIA_ROUNDSM(io[2],io[3],
1349                     CamelliaSubkeyL(30),CamelliaSubkeyR(30),
1350                     io[0],io[1],il,ir,t0,t1);
1351    CAMELLIA_ROUNDSM(io[0],io[1],
1352                     CamelliaSubkeyL(29),CamelliaSubkeyR(29),
1353                     io[2],io[3],il,ir,t0,t1);
1354    CAMELLIA_ROUNDSM(io[2],io[3],
1355                     CamelliaSubkeyL(28),CamelliaSubkeyR(28),
1356                     io[0],io[1],il,ir,t0,t1);
1357    CAMELLIA_ROUNDSM(io[0],io[1],
1358                     CamelliaSubkeyL(27),CamelliaSubkeyR(27),
1359                     io[2],io[3],il,ir,t0,t1);
1360    CAMELLIA_ROUNDSM(io[2],io[3],
1361                     CamelliaSubkeyL(26),CamelliaSubkeyR(26),
1362                     io[0],io[1],il,ir,t0,t1);
1363
1364    CAMELLIA_FLS(io[0],io[1],io[2],io[3],
1365                 CamelliaSubkeyL(25),CamelliaSubkeyR(25),
1366                 CamelliaSubkeyL(24),CamelliaSubkeyR(24),
1367                 t0,t1,il,ir);
1368
1369    CAMELLIA_ROUNDSM(io[0],io[1],
1370                     CamelliaSubkeyL(23),CamelliaSubkeyR(23),
1371                     io[2],io[3],il,ir,t0,t1);
1372    CAMELLIA_ROUNDSM(io[2],io[3],
1373                     CamelliaSubkeyL(22),CamelliaSubkeyR(22),
1374                     io[0],io[1],il,ir,t0,t1);
1375    CAMELLIA_ROUNDSM(io[0],io[1],
1376                     CamelliaSubkeyL(21),CamelliaSubkeyR(21),
1377                     io[2],io[3],il,ir,t0,t1);
1378    CAMELLIA_ROUNDSM(io[2],io[3],
1379                     CamelliaSubkeyL(20),CamelliaSubkeyR(20),
1380                     io[0],io[1],il,ir,t0,t1);
1381    CAMELLIA_ROUNDSM(io[0],io[1],
1382                     CamelliaSubkeyL(19),CamelliaSubkeyR(19),
1383                     io[2],io[3],il,ir,t0,t1);
1384    CAMELLIA_ROUNDSM(io[2],io[3],
1385                     CamelliaSubkeyL(18),CamelliaSubkeyR(18),
1386                     io[0],io[1],il,ir,t0,t1);
1387
1388    CAMELLIA_FLS(io[0],io[1],io[2],io[3],
1389                 CamelliaSubkeyL(17),CamelliaSubkeyR(17),
1390                 CamelliaSubkeyL(16),CamelliaSubkeyR(16),
1391                 t0,t1,il,ir);
1392
1393    CAMELLIA_ROUNDSM(io[0],io[1],
1394                     CamelliaSubkeyL(15),CamelliaSubkeyR(15),
1395                     io[2],io[3],il,ir,t0,t1);
1396    CAMELLIA_ROUNDSM(io[2],io[3],
1397                     CamelliaSubkeyL(14),CamelliaSubkeyR(14),
1398                     io[0],io[1],il,ir,t0,t1);
1399    CAMELLIA_ROUNDSM(io[0],io[1],
1400                     CamelliaSubkeyL(13),CamelliaSubkeyR(13),
1401                     io[2],io[3],il,ir,t0,t1);
1402    CAMELLIA_ROUNDSM(io[2],io[3],
1403                     CamelliaSubkeyL(12),CamelliaSubkeyR(12),
1404                     io[0],io[1],il,ir,t0,t1);
1405    CAMELLIA_ROUNDSM(io[0],io[1],
1406                     CamelliaSubkeyL(11),CamelliaSubkeyR(11),
1407                     io[2],io[3],il,ir,t0,t1);
1408    CAMELLIA_ROUNDSM(io[2],io[3],
1409                     CamelliaSubkeyL(10),CamelliaSubkeyR(10),
1410                     io[0],io[1],il,ir,t0,t1);
1411
1412    CAMELLIA_FLS(io[0],io[1],io[2],io[3],
1413                 CamelliaSubkeyL(9),CamelliaSubkeyR(9),
1414                 CamelliaSubkeyL(8),CamelliaSubkeyR(8),
1415                 t0,t1,il,ir);
1416
1417    CAMELLIA_ROUNDSM(io[0],io[1],
1418                     CamelliaSubkeyL(7),CamelliaSubkeyR(7),
1419                     io[2],io[3],il,ir,t0,t1);
1420    CAMELLIA_ROUNDSM(io[2],io[3],
1421                     CamelliaSubkeyL(6),CamelliaSubkeyR(6),
1422                     io[0],io[1],il,ir,t0,t1);
1423    CAMELLIA_ROUNDSM(io[0],io[1],
1424                     CamelliaSubkeyL(5),CamelliaSubkeyR(5),
1425                     io[2],io[3],il,ir,t0,t1);
1426    CAMELLIA_ROUNDSM(io[2],io[3],
1427                     CamelliaSubkeyL(4),CamelliaSubkeyR(4),
1428                     io[0],io[1],il,ir,t0,t1);
1429    CAMELLIA_ROUNDSM(io[0],io[1],
1430                     CamelliaSubkeyL(3),CamelliaSubkeyR(3),
1431                     io[2],io[3],il,ir,t0,t1);
1432    CAMELLIA_ROUNDSM(io[2],io[3],
1433                     CamelliaSubkeyL(2),CamelliaSubkeyR(2),
1434                     io[0],io[1],il,ir,t0,t1);
1435
1436    /* post whitening but kw4 */
1437    io[2] ^= CamelliaSubkeyL(0);
1438    io[3] ^= CamelliaSubkeyR(0);
1439
1440    t0 = io[0];
1441    t1 = io[1];
1442    io[0] = io[2];
1443    io[1] = io[3];
1444    io[2] = t0;
1445    io[3] = t1;
1446
1447    return;
1448}
1449
1450/***
1451 *
1452 * API for compatibility
1453 */
1454
1455static void Camellia_EncryptBlock(const word32 keyBitLength,
1456                           const unsigned char *plaintext,
1457                           const WC_CAMELLIA_KEY_TABLE_TYPE keyTable,
1458                           unsigned char *ciphertext)
1459{
1460    u32 tmp[4];
1461
1462    tmp[0] = GETU32(plaintext);
1463    tmp[1] = GETU32(plaintext + 4);
1464    tmp[2] = GETU32(plaintext + 8);
1465    tmp[3] = GETU32(plaintext + 12);
1466
1467    switch (keyBitLength) {
1468    case 128:
1469        camellia_encrypt128(keyTable, tmp);
1470        break;
1471    case 192:
1472        /* fall through */
1473    case 256:
1474        camellia_encrypt256(keyTable, tmp);
1475        break;
1476    default:
1477        break;
1478    }
1479
1480    PUTU32(ciphertext, tmp[0]);
1481    PUTU32(ciphertext + 4, tmp[1]);
1482    PUTU32(ciphertext + 8, tmp[2]);
1483    PUTU32(ciphertext + 12, tmp[3]);
1484}
1485
1486static void Camellia_DecryptBlock(const word32 keyBitLength,
1487                           const unsigned char *ciphertext,
1488                           const WC_CAMELLIA_KEY_TABLE_TYPE keyTable,
1489                           unsigned char *plaintext)
1490{
1491    u32 tmp[4];
1492
1493    tmp[0] = GETU32(ciphertext);
1494    tmp[1] = GETU32(ciphertext + 4);
1495    tmp[2] = GETU32(ciphertext + 8);
1496    tmp[3] = GETU32(ciphertext + 12);
1497
1498    switch (keyBitLength) {
1499    case 128:
1500        camellia_decrypt128(keyTable, tmp);
1501        break;
1502    case 192:
1503        /* fall through */
1504    case 256:
1505        camellia_decrypt256(keyTable, tmp);
1506        break;
1507    default:
1508        break;
1509    }
1510    PUTU32(plaintext, tmp[0]);
1511    PUTU32(plaintext + 4, tmp[1]);
1512    PUTU32(plaintext + 8, tmp[2]);
1513    PUTU32(plaintext + 12, tmp[3]);
1514}
1515
1516
1517
1518/* wolfCrypt wrappers to the Camellia code */
1519
1520int wc_CamelliaSetKey(wc_Camellia* cam, const byte* key, word32 len, const byte* iv)
1521{
1522    int ret = 0;
1523
1524    if (cam == NULL || key == NULL) return BAD_FUNC_ARG;
1525
1526    XMEMSET(cam->key, 0, WC_CAMELLIA_TABLE_BYTE_LEN);
1527
1528    switch (len) {
1529        case 16:
1530                ret = camellia_setup128(key, cam->key);
1531            break;
1532        case 24:
1533                ret = camellia_setup192(key, cam->key);
1534            break;
1535        case 32:
1536            ret = camellia_setup256(key, cam->key);
1537            break;
1538        default:
1539            ret = BAD_FUNC_ARG;
1540    }
1541
1542    if (ret != 0)
1543        return ret;
1544
1545    cam->keySz = len * 8;
1546
1547    return wc_CamelliaSetIV(cam, iv);
1548}
1549
1550
1551int wc_CamelliaSetIV(wc_Camellia* cam, const byte* iv)
1552{
1553    if (cam == NULL)
1554        return BAD_FUNC_ARG;
1555
1556    if (iv)
1557        XMEMCPY(cam->reg, iv, WC_CAMELLIA_BLOCK_SIZE);
1558    else
1559        XMEMSET(cam->reg,  0, WC_CAMELLIA_BLOCK_SIZE);
1560
1561    return 0;
1562}
1563
1564
1565int wc_CamelliaEncryptDirect(wc_Camellia* cam, byte* out, const byte* in)
1566{
1567    if (cam == NULL || out == NULL || in == NULL) {
1568        return BAD_FUNC_ARG;
1569    }
1570    Camellia_EncryptBlock(cam->keySz, in, cam->key, out);
1571
1572    return 0;
1573}
1574
1575
1576int wc_CamelliaDecryptDirect(wc_Camellia* cam, byte* out, const byte* in)
1577{
1578    if (cam == NULL || out == NULL || in == NULL) {
1579        return BAD_FUNC_ARG;
1580    }
1581    Camellia_DecryptBlock(cam->keySz, in, cam->key, out);
1582
1583    return 0;
1584}
1585
1586
1587int wc_CamelliaCbcEncrypt(wc_Camellia* cam, byte* out, const byte* in, word32 sz)
1588{
1589    word32 blocks;
1590    if (cam == NULL || out == NULL || in == NULL) {
1591        return BAD_FUNC_ARG;
1592    }
1593    if (sz % WC_CAMELLIA_BLOCK_SIZE != 0) {
1594        return BAD_LENGTH_E;
1595    }
1596    blocks = sz / WC_CAMELLIA_BLOCK_SIZE;
1597
1598    while (blocks--) {
1599        xorbuf((byte*)cam->reg, in, WC_CAMELLIA_BLOCK_SIZE);
1600        Camellia_EncryptBlock(cam->keySz, (byte*)cam->reg,
1601                                                     cam->key, (byte*)cam->reg);
1602        XMEMCPY(out, cam->reg, WC_CAMELLIA_BLOCK_SIZE);
1603
1604        out += WC_CAMELLIA_BLOCK_SIZE;
1605        in  += WC_CAMELLIA_BLOCK_SIZE;
1606    }
1607
1608    return 0;
1609}
1610
1611
1612int wc_CamelliaCbcDecrypt(wc_Camellia* cam, byte* out, const byte* in, word32 sz)
1613{
1614    word32 blocks;
1615    if (cam == NULL || out == NULL || in == NULL) {
1616        return BAD_FUNC_ARG;
1617    }
1618    if (sz % WC_CAMELLIA_BLOCK_SIZE != 0) {
1619        return BAD_LENGTH_E;
1620    }
1621    blocks = sz / WC_CAMELLIA_BLOCK_SIZE;
1622
1623    while (blocks--) {
1624        XMEMCPY(cam->tmp, in, WC_CAMELLIA_BLOCK_SIZE);
1625        Camellia_DecryptBlock(cam->keySz, (byte*)cam->tmp, cam->key, out);
1626        xorbuf(out, (byte*)cam->reg, WC_CAMELLIA_BLOCK_SIZE);
1627        XMEMCPY(cam->reg, cam->tmp, WC_CAMELLIA_BLOCK_SIZE);
1628
1629        out += WC_CAMELLIA_BLOCK_SIZE;
1630        in  += WC_CAMELLIA_BLOCK_SIZE;
1631    }
1632
1633    return 0;
1634}
1635
1636
1637void wc_CamelliaFree(wc_Camellia* cam)
1638{
1639    if (cam == NULL)
1640        return;
1641    ForceZero(cam, sizeof(wc_Camellia));
1642}
1643
1644
1645#endif /* HAVE_CAMELLIA */
1646