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