xref: /openbmc/linux/crypto/camellia_generic.c (revision 79e790ff) 
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2006
4  * NTT (Nippon Telegraph and Telephone Corporation).
5  */
6 
7 /*
8  * Algorithm Specification
9  *  https://info.isl.ntt.co.jp/crypt/eng/camellia/specifications.html
10  */
11 
12 #include <linux/crypto.h>
13 #include <linux/errno.h>
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/bitops.h>
18 #include <asm/unaligned.h>
19 
20 static const u32 camellia_sp1110[256] = {
21 	0x70707000, 0x82828200, 0x2c2c2c00, 0xececec00,
22 	0xb3b3b300, 0x27272700, 0xc0c0c000, 0xe5e5e500,
23 	0xe4e4e400, 0x85858500, 0x57575700, 0x35353500,
24 	0xeaeaea00, 0x0c0c0c00, 0xaeaeae00, 0x41414100,
25 	0x23232300, 0xefefef00, 0x6b6b6b00, 0x93939300,
26 	0x45454500, 0x19191900, 0xa5a5a500, 0x21212100,
27 	0xededed00, 0x0e0e0e00, 0x4f4f4f00, 0x4e4e4e00,
28 	0x1d1d1d00, 0x65656500, 0x92929200, 0xbdbdbd00,
29 	0x86868600, 0xb8b8b800, 0xafafaf00, 0x8f8f8f00,
30 	0x7c7c7c00, 0xebebeb00, 0x1f1f1f00, 0xcecece00,
31 	0x3e3e3e00, 0x30303000, 0xdcdcdc00, 0x5f5f5f00,
32 	0x5e5e5e00, 0xc5c5c500, 0x0b0b0b00, 0x1a1a1a00,
33 	0xa6a6a600, 0xe1e1e100, 0x39393900, 0xcacaca00,
34 	0xd5d5d500, 0x47474700, 0x5d5d5d00, 0x3d3d3d00,
35 	0xd9d9d900, 0x01010100, 0x5a5a5a00, 0xd6d6d600,
36 	0x51515100, 0x56565600, 0x6c6c6c00, 0x4d4d4d00,
37 	0x8b8b8b00, 0x0d0d0d00, 0x9a9a9a00, 0x66666600,
38 	0xfbfbfb00, 0xcccccc00, 0xb0b0b000, 0x2d2d2d00,
39 	0x74747400, 0x12121200, 0x2b2b2b00, 0x20202000,
40 	0xf0f0f000, 0xb1b1b100, 0x84848400, 0x99999900,
41 	0xdfdfdf00, 0x4c4c4c00, 0xcbcbcb00, 0xc2c2c200,
42 	0x34343400, 0x7e7e7e00, 0x76767600, 0x05050500,
43 	0x6d6d6d00, 0xb7b7b700, 0xa9a9a900, 0x31313100,
44 	0xd1d1d100, 0x17171700, 0x04040400, 0xd7d7d700,
45 	0x14141400, 0x58585800, 0x3a3a3a00, 0x61616100,
46 	0xdedede00, 0x1b1b1b00, 0x11111100, 0x1c1c1c00,
47 	0x32323200, 0x0f0f0f00, 0x9c9c9c00, 0x16161600,
48 	0x53535300, 0x18181800, 0xf2f2f200, 0x22222200,
49 	0xfefefe00, 0x44444400, 0xcfcfcf00, 0xb2b2b200,
50 	0xc3c3c300, 0xb5b5b500, 0x7a7a7a00, 0x91919100,
51 	0x24242400, 0x08080800, 0xe8e8e800, 0xa8a8a800,
52 	0x60606000, 0xfcfcfc00, 0x69696900, 0x50505000,
53 	0xaaaaaa00, 0xd0d0d000, 0xa0a0a000, 0x7d7d7d00,
54 	0xa1a1a100, 0x89898900, 0x62626200, 0x97979700,
55 	0x54545400, 0x5b5b5b00, 0x1e1e1e00, 0x95959500,
56 	0xe0e0e000, 0xffffff00, 0x64646400, 0xd2d2d200,
57 	0x10101000, 0xc4c4c400, 0x00000000, 0x48484800,
58 	0xa3a3a300, 0xf7f7f700, 0x75757500, 0xdbdbdb00,
59 	0x8a8a8a00, 0x03030300, 0xe6e6e600, 0xdadada00,
60 	0x09090900, 0x3f3f3f00, 0xdddddd00, 0x94949400,
61 	0x87878700, 0x5c5c5c00, 0x83838300, 0x02020200,
62 	0xcdcdcd00, 0x4a4a4a00, 0x90909000, 0x33333300,
63 	0x73737300, 0x67676700, 0xf6f6f600, 0xf3f3f300,
64 	0x9d9d9d00, 0x7f7f7f00, 0xbfbfbf00, 0xe2e2e200,
65 	0x52525200, 0x9b9b9b00, 0xd8d8d800, 0x26262600,
66 	0xc8c8c800, 0x37373700, 0xc6c6c600, 0x3b3b3b00,
67 	0x81818100, 0x96969600, 0x6f6f6f00, 0x4b4b4b00,
68 	0x13131300, 0xbebebe00, 0x63636300, 0x2e2e2e00,
69 	0xe9e9e900, 0x79797900, 0xa7a7a700, 0x8c8c8c00,
70 	0x9f9f9f00, 0x6e6e6e00, 0xbcbcbc00, 0x8e8e8e00,
71 	0x29292900, 0xf5f5f500, 0xf9f9f900, 0xb6b6b600,
72 	0x2f2f2f00, 0xfdfdfd00, 0xb4b4b400, 0x59595900,
73 	0x78787800, 0x98989800, 0x06060600, 0x6a6a6a00,
74 	0xe7e7e700, 0x46464600, 0x71717100, 0xbababa00,
75 	0xd4d4d400, 0x25252500, 0xababab00, 0x42424200,
76 	0x88888800, 0xa2a2a200, 0x8d8d8d00, 0xfafafa00,
77 	0x72727200, 0x07070700, 0xb9b9b900, 0x55555500,
78 	0xf8f8f800, 0xeeeeee00, 0xacacac00, 0x0a0a0a00,
79 	0x36363600, 0x49494900, 0x2a2a2a00, 0x68686800,
80 	0x3c3c3c00, 0x38383800, 0xf1f1f100, 0xa4a4a400,
81 	0x40404000, 0x28282800, 0xd3d3d300, 0x7b7b7b00,
82 	0xbbbbbb00, 0xc9c9c900, 0x43434300, 0xc1c1c100,
83 	0x15151500, 0xe3e3e300, 0xadadad00, 0xf4f4f400,
84 	0x77777700, 0xc7c7c700, 0x80808000, 0x9e9e9e00,
85 };
86 
87 static const u32 camellia_sp0222[256] = {
88 	0x00e0e0e0, 0x00050505, 0x00585858, 0x00d9d9d9,
89 	0x00676767, 0x004e4e4e, 0x00818181, 0x00cbcbcb,
90 	0x00c9c9c9, 0x000b0b0b, 0x00aeaeae, 0x006a6a6a,
91 	0x00d5d5d5, 0x00181818, 0x005d5d5d, 0x00828282,
92 	0x00464646, 0x00dfdfdf, 0x00d6d6d6, 0x00272727,
93 	0x008a8a8a, 0x00323232, 0x004b4b4b, 0x00424242,
94 	0x00dbdbdb, 0x001c1c1c, 0x009e9e9e, 0x009c9c9c,
95 	0x003a3a3a, 0x00cacaca, 0x00252525, 0x007b7b7b,
96 	0x000d0d0d, 0x00717171, 0x005f5f5f, 0x001f1f1f,
97 	0x00f8f8f8, 0x00d7d7d7, 0x003e3e3e, 0x009d9d9d,
98 	0x007c7c7c, 0x00606060, 0x00b9b9b9, 0x00bebebe,
99 	0x00bcbcbc, 0x008b8b8b, 0x00161616, 0x00343434,
100 	0x004d4d4d, 0x00c3c3c3, 0x00727272, 0x00959595,
101 	0x00ababab, 0x008e8e8e, 0x00bababa, 0x007a7a7a,
102 	0x00b3b3b3, 0x00020202, 0x00b4b4b4, 0x00adadad,
103 	0x00a2a2a2, 0x00acacac, 0x00d8d8d8, 0x009a9a9a,
104 	0x00171717, 0x001a1a1a, 0x00353535, 0x00cccccc,
105 	0x00f7f7f7, 0x00999999, 0x00616161, 0x005a5a5a,
106 	0x00e8e8e8, 0x00242424, 0x00565656, 0x00404040,
107 	0x00e1e1e1, 0x00636363, 0x00090909, 0x00333333,
108 	0x00bfbfbf, 0x00989898, 0x00979797, 0x00858585,
109 	0x00686868, 0x00fcfcfc, 0x00ececec, 0x000a0a0a,
110 	0x00dadada, 0x006f6f6f, 0x00535353, 0x00626262,
111 	0x00a3a3a3, 0x002e2e2e, 0x00080808, 0x00afafaf,
112 	0x00282828, 0x00b0b0b0, 0x00747474, 0x00c2c2c2,
113 	0x00bdbdbd, 0x00363636, 0x00222222, 0x00383838,
114 	0x00646464, 0x001e1e1e, 0x00393939, 0x002c2c2c,
115 	0x00a6a6a6, 0x00303030, 0x00e5e5e5, 0x00444444,
116 	0x00fdfdfd, 0x00888888, 0x009f9f9f, 0x00656565,
117 	0x00878787, 0x006b6b6b, 0x00f4f4f4, 0x00232323,
118 	0x00484848, 0x00101010, 0x00d1d1d1, 0x00515151,
119 	0x00c0c0c0, 0x00f9f9f9, 0x00d2d2d2, 0x00a0a0a0,
120 	0x00555555, 0x00a1a1a1, 0x00414141, 0x00fafafa,
121 	0x00434343, 0x00131313, 0x00c4c4c4, 0x002f2f2f,
122 	0x00a8a8a8, 0x00b6b6b6, 0x003c3c3c, 0x002b2b2b,
123 	0x00c1c1c1, 0x00ffffff, 0x00c8c8c8, 0x00a5a5a5,
124 	0x00202020, 0x00898989, 0x00000000, 0x00909090,
125 	0x00474747, 0x00efefef, 0x00eaeaea, 0x00b7b7b7,
126 	0x00151515, 0x00060606, 0x00cdcdcd, 0x00b5b5b5,
127 	0x00121212, 0x007e7e7e, 0x00bbbbbb, 0x00292929,
128 	0x000f0f0f, 0x00b8b8b8, 0x00070707, 0x00040404,
129 	0x009b9b9b, 0x00949494, 0x00212121, 0x00666666,
130 	0x00e6e6e6, 0x00cecece, 0x00ededed, 0x00e7e7e7,
131 	0x003b3b3b, 0x00fefefe, 0x007f7f7f, 0x00c5c5c5,
132 	0x00a4a4a4, 0x00373737, 0x00b1b1b1, 0x004c4c4c,
133 	0x00919191, 0x006e6e6e, 0x008d8d8d, 0x00767676,
134 	0x00030303, 0x002d2d2d, 0x00dedede, 0x00969696,
135 	0x00262626, 0x007d7d7d, 0x00c6c6c6, 0x005c5c5c,
136 	0x00d3d3d3, 0x00f2f2f2, 0x004f4f4f, 0x00191919,
137 	0x003f3f3f, 0x00dcdcdc, 0x00797979, 0x001d1d1d,
138 	0x00525252, 0x00ebebeb, 0x00f3f3f3, 0x006d6d6d,
139 	0x005e5e5e, 0x00fbfbfb, 0x00696969, 0x00b2b2b2,
140 	0x00f0f0f0, 0x00313131, 0x000c0c0c, 0x00d4d4d4,
141 	0x00cfcfcf, 0x008c8c8c, 0x00e2e2e2, 0x00757575,
142 	0x00a9a9a9, 0x004a4a4a, 0x00575757, 0x00848484,
143 	0x00111111, 0x00454545, 0x001b1b1b, 0x00f5f5f5,
144 	0x00e4e4e4, 0x000e0e0e, 0x00737373, 0x00aaaaaa,
145 	0x00f1f1f1, 0x00dddddd, 0x00595959, 0x00141414,
146 	0x006c6c6c, 0x00929292, 0x00545454, 0x00d0d0d0,
147 	0x00787878, 0x00707070, 0x00e3e3e3, 0x00494949,
148 	0x00808080, 0x00505050, 0x00a7a7a7, 0x00f6f6f6,
149 	0x00777777, 0x00939393, 0x00868686, 0x00838383,
150 	0x002a2a2a, 0x00c7c7c7, 0x005b5b5b, 0x00e9e9e9,
151 	0x00eeeeee, 0x008f8f8f, 0x00010101, 0x003d3d3d,
152 };
153 
154 static const u32 camellia_sp3033[256] = {
155 	0x38003838, 0x41004141, 0x16001616, 0x76007676,
156 	0xd900d9d9, 0x93009393, 0x60006060, 0xf200f2f2,
157 	0x72007272, 0xc200c2c2, 0xab00abab, 0x9a009a9a,
158 	0x75007575, 0x06000606, 0x57005757, 0xa000a0a0,
159 	0x91009191, 0xf700f7f7, 0xb500b5b5, 0xc900c9c9,
160 	0xa200a2a2, 0x8c008c8c, 0xd200d2d2, 0x90009090,
161 	0xf600f6f6, 0x07000707, 0xa700a7a7, 0x27002727,
162 	0x8e008e8e, 0xb200b2b2, 0x49004949, 0xde00dede,
163 	0x43004343, 0x5c005c5c, 0xd700d7d7, 0xc700c7c7,
164 	0x3e003e3e, 0xf500f5f5, 0x8f008f8f, 0x67006767,
165 	0x1f001f1f, 0x18001818, 0x6e006e6e, 0xaf00afaf,
166 	0x2f002f2f, 0xe200e2e2, 0x85008585, 0x0d000d0d,
167 	0x53005353, 0xf000f0f0, 0x9c009c9c, 0x65006565,
168 	0xea00eaea, 0xa300a3a3, 0xae00aeae, 0x9e009e9e,
169 	0xec00ecec, 0x80008080, 0x2d002d2d, 0x6b006b6b,
170 	0xa800a8a8, 0x2b002b2b, 0x36003636, 0xa600a6a6,
171 	0xc500c5c5, 0x86008686, 0x4d004d4d, 0x33003333,
172 	0xfd00fdfd, 0x66006666, 0x58005858, 0x96009696,
173 	0x3a003a3a, 0x09000909, 0x95009595, 0x10001010,
174 	0x78007878, 0xd800d8d8, 0x42004242, 0xcc00cccc,
175 	0xef00efef, 0x26002626, 0xe500e5e5, 0x61006161,
176 	0x1a001a1a, 0x3f003f3f, 0x3b003b3b, 0x82008282,
177 	0xb600b6b6, 0xdb00dbdb, 0xd400d4d4, 0x98009898,
178 	0xe800e8e8, 0x8b008b8b, 0x02000202, 0xeb00ebeb,
179 	0x0a000a0a, 0x2c002c2c, 0x1d001d1d, 0xb000b0b0,
180 	0x6f006f6f, 0x8d008d8d, 0x88008888, 0x0e000e0e,
181 	0x19001919, 0x87008787, 0x4e004e4e, 0x0b000b0b,
182 	0xa900a9a9, 0x0c000c0c, 0x79007979, 0x11001111,
183 	0x7f007f7f, 0x22002222, 0xe700e7e7, 0x59005959,
184 	0xe100e1e1, 0xda00dada, 0x3d003d3d, 0xc800c8c8,
185 	0x12001212, 0x04000404, 0x74007474, 0x54005454,
186 	0x30003030, 0x7e007e7e, 0xb400b4b4, 0x28002828,
187 	0x55005555, 0x68006868, 0x50005050, 0xbe00bebe,
188 	0xd000d0d0, 0xc400c4c4, 0x31003131, 0xcb00cbcb,
189 	0x2a002a2a, 0xad00adad, 0x0f000f0f, 0xca00caca,
190 	0x70007070, 0xff00ffff, 0x32003232, 0x69006969,
191 	0x08000808, 0x62006262, 0x00000000, 0x24002424,
192 	0xd100d1d1, 0xfb00fbfb, 0xba00baba, 0xed00eded,
193 	0x45004545, 0x81008181, 0x73007373, 0x6d006d6d,
194 	0x84008484, 0x9f009f9f, 0xee00eeee, 0x4a004a4a,
195 	0xc300c3c3, 0x2e002e2e, 0xc100c1c1, 0x01000101,
196 	0xe600e6e6, 0x25002525, 0x48004848, 0x99009999,
197 	0xb900b9b9, 0xb300b3b3, 0x7b007b7b, 0xf900f9f9,
198 	0xce00cece, 0xbf00bfbf, 0xdf00dfdf, 0x71007171,
199 	0x29002929, 0xcd00cdcd, 0x6c006c6c, 0x13001313,
200 	0x64006464, 0x9b009b9b, 0x63006363, 0x9d009d9d,
201 	0xc000c0c0, 0x4b004b4b, 0xb700b7b7, 0xa500a5a5,
202 	0x89008989, 0x5f005f5f, 0xb100b1b1, 0x17001717,
203 	0xf400f4f4, 0xbc00bcbc, 0xd300d3d3, 0x46004646,
204 	0xcf00cfcf, 0x37003737, 0x5e005e5e, 0x47004747,
205 	0x94009494, 0xfa00fafa, 0xfc00fcfc, 0x5b005b5b,
206 	0x97009797, 0xfe00fefe, 0x5a005a5a, 0xac00acac,
207 	0x3c003c3c, 0x4c004c4c, 0x03000303, 0x35003535,
208 	0xf300f3f3, 0x23002323, 0xb800b8b8, 0x5d005d5d,
209 	0x6a006a6a, 0x92009292, 0xd500d5d5, 0x21002121,
210 	0x44004444, 0x51005151, 0xc600c6c6, 0x7d007d7d,
211 	0x39003939, 0x83008383, 0xdc00dcdc, 0xaa00aaaa,
212 	0x7c007c7c, 0x77007777, 0x56005656, 0x05000505,
213 	0x1b001b1b, 0xa400a4a4, 0x15001515, 0x34003434,
214 	0x1e001e1e, 0x1c001c1c, 0xf800f8f8, 0x52005252,
215 	0x20002020, 0x14001414, 0xe900e9e9, 0xbd00bdbd,
216 	0xdd00dddd, 0xe400e4e4, 0xa100a1a1, 0xe000e0e0,
217 	0x8a008a8a, 0xf100f1f1, 0xd600d6d6, 0x7a007a7a,
218 	0xbb00bbbb, 0xe300e3e3, 0x40004040, 0x4f004f4f,
219 };
220 
221 static const u32 camellia_sp4404[256] = {
222 	0x70700070, 0x2c2c002c, 0xb3b300b3, 0xc0c000c0,
223 	0xe4e400e4, 0x57570057, 0xeaea00ea, 0xaeae00ae,
224 	0x23230023, 0x6b6b006b, 0x45450045, 0xa5a500a5,
225 	0xeded00ed, 0x4f4f004f, 0x1d1d001d, 0x92920092,
226 	0x86860086, 0xafaf00af, 0x7c7c007c, 0x1f1f001f,
227 	0x3e3e003e, 0xdcdc00dc, 0x5e5e005e, 0x0b0b000b,
228 	0xa6a600a6, 0x39390039, 0xd5d500d5, 0x5d5d005d,
229 	0xd9d900d9, 0x5a5a005a, 0x51510051, 0x6c6c006c,
230 	0x8b8b008b, 0x9a9a009a, 0xfbfb00fb, 0xb0b000b0,
231 	0x74740074, 0x2b2b002b, 0xf0f000f0, 0x84840084,
232 	0xdfdf00df, 0xcbcb00cb, 0x34340034, 0x76760076,
233 	0x6d6d006d, 0xa9a900a9, 0xd1d100d1, 0x04040004,
234 	0x14140014, 0x3a3a003a, 0xdede00de, 0x11110011,
235 	0x32320032, 0x9c9c009c, 0x53530053, 0xf2f200f2,
236 	0xfefe00fe, 0xcfcf00cf, 0xc3c300c3, 0x7a7a007a,
237 	0x24240024, 0xe8e800e8, 0x60600060, 0x69690069,
238 	0xaaaa00aa, 0xa0a000a0, 0xa1a100a1, 0x62620062,
239 	0x54540054, 0x1e1e001e, 0xe0e000e0, 0x64640064,
240 	0x10100010, 0x00000000, 0xa3a300a3, 0x75750075,
241 	0x8a8a008a, 0xe6e600e6, 0x09090009, 0xdddd00dd,
242 	0x87870087, 0x83830083, 0xcdcd00cd, 0x90900090,
243 	0x73730073, 0xf6f600f6, 0x9d9d009d, 0xbfbf00bf,
244 	0x52520052, 0xd8d800d8, 0xc8c800c8, 0xc6c600c6,
245 	0x81810081, 0x6f6f006f, 0x13130013, 0x63630063,
246 	0xe9e900e9, 0xa7a700a7, 0x9f9f009f, 0xbcbc00bc,
247 	0x29290029, 0xf9f900f9, 0x2f2f002f, 0xb4b400b4,
248 	0x78780078, 0x06060006, 0xe7e700e7, 0x71710071,
249 	0xd4d400d4, 0xabab00ab, 0x88880088, 0x8d8d008d,
250 	0x72720072, 0xb9b900b9, 0xf8f800f8, 0xacac00ac,
251 	0x36360036, 0x2a2a002a, 0x3c3c003c, 0xf1f100f1,
252 	0x40400040, 0xd3d300d3, 0xbbbb00bb, 0x43430043,
253 	0x15150015, 0xadad00ad, 0x77770077, 0x80800080,
254 	0x82820082, 0xecec00ec, 0x27270027, 0xe5e500e5,
255 	0x85850085, 0x35350035, 0x0c0c000c, 0x41410041,
256 	0xefef00ef, 0x93930093, 0x19190019, 0x21210021,
257 	0x0e0e000e, 0x4e4e004e, 0x65650065, 0xbdbd00bd,
258 	0xb8b800b8, 0x8f8f008f, 0xebeb00eb, 0xcece00ce,
259 	0x30300030, 0x5f5f005f, 0xc5c500c5, 0x1a1a001a,
260 	0xe1e100e1, 0xcaca00ca, 0x47470047, 0x3d3d003d,
261 	0x01010001, 0xd6d600d6, 0x56560056, 0x4d4d004d,
262 	0x0d0d000d, 0x66660066, 0xcccc00cc, 0x2d2d002d,
263 	0x12120012, 0x20200020, 0xb1b100b1, 0x99990099,
264 	0x4c4c004c, 0xc2c200c2, 0x7e7e007e, 0x05050005,
265 	0xb7b700b7, 0x31310031, 0x17170017, 0xd7d700d7,
266 	0x58580058, 0x61610061, 0x1b1b001b, 0x1c1c001c,
267 	0x0f0f000f, 0x16160016, 0x18180018, 0x22220022,
268 	0x44440044, 0xb2b200b2, 0xb5b500b5, 0x91910091,
269 	0x08080008, 0xa8a800a8, 0xfcfc00fc, 0x50500050,
270 	0xd0d000d0, 0x7d7d007d, 0x89890089, 0x97970097,
271 	0x5b5b005b, 0x95950095, 0xffff00ff, 0xd2d200d2,
272 	0xc4c400c4, 0x48480048, 0xf7f700f7, 0xdbdb00db,
273 	0x03030003, 0xdada00da, 0x3f3f003f, 0x94940094,
274 	0x5c5c005c, 0x02020002, 0x4a4a004a, 0x33330033,
275 	0x67670067, 0xf3f300f3, 0x7f7f007f, 0xe2e200e2,
276 	0x9b9b009b, 0x26260026, 0x37370037, 0x3b3b003b,
277 	0x96960096, 0x4b4b004b, 0xbebe00be, 0x2e2e002e,
278 	0x79790079, 0x8c8c008c, 0x6e6e006e, 0x8e8e008e,
279 	0xf5f500f5, 0xb6b600b6, 0xfdfd00fd, 0x59590059,
280 	0x98980098, 0x6a6a006a, 0x46460046, 0xbaba00ba,
281 	0x25250025, 0x42420042, 0xa2a200a2, 0xfafa00fa,
282 	0x07070007, 0x55550055, 0xeeee00ee, 0x0a0a000a,
283 	0x49490049, 0x68680068, 0x38380038, 0xa4a400a4,
284 	0x28280028, 0x7b7b007b, 0xc9c900c9, 0xc1c100c1,
285 	0xe3e300e3, 0xf4f400f4, 0xc7c700c7, 0x9e9e009e,
286 };
287 
288 
289 #define CAMELLIA_MIN_KEY_SIZE        16
290 #define CAMELLIA_MAX_KEY_SIZE        32
291 #define CAMELLIA_BLOCK_SIZE          16
292 #define CAMELLIA_TABLE_BYTE_LEN     272
293 
294 /*
295  * NB: L and R below stand for 'left' and 'right' as in written numbers.
296  * That is, in (xxxL,xxxR) pair xxxL holds most significant digits,
297  * _not_ least significant ones!
298  */
299 
300 
301 /* key constants */
302 
303 #define CAMELLIA_SIGMA1L (0xA09E667FL)
304 #define CAMELLIA_SIGMA1R (0x3BCC908BL)
305 #define CAMELLIA_SIGMA2L (0xB67AE858L)
306 #define CAMELLIA_SIGMA2R (0x4CAA73B2L)
307 #define CAMELLIA_SIGMA3L (0xC6EF372FL)
308 #define CAMELLIA_SIGMA3R (0xE94F82BEL)
309 #define CAMELLIA_SIGMA4L (0x54FF53A5L)
310 #define CAMELLIA_SIGMA4R (0xF1D36F1CL)
311 #define CAMELLIA_SIGMA5L (0x10E527FAL)
312 #define CAMELLIA_SIGMA5R (0xDE682D1DL)
313 #define CAMELLIA_SIGMA6L (0xB05688C2L)
314 #define CAMELLIA_SIGMA6R (0xB3E6C1FDL)
315 
316 /*
317  *  macros
318  */
319 #define ROLDQ(ll, lr, rl, rr, w0, w1, bits) ({		\
320 	w0 = ll;					\
321 	ll = (ll << bits) + (lr >> (32 - bits));	\
322 	lr = (lr << bits) + (rl >> (32 - bits));	\
323 	rl = (rl << bits) + (rr >> (32 - bits));	\
324 	rr = (rr << bits) + (w0 >> (32 - bits));	\
325 })
326 
327 #define ROLDQo32(ll, lr, rl, rr, w0, w1, bits) ({	\
328 	w0 = ll;					\
329 	w1 = lr;					\
330 	ll = (lr << (bits - 32)) + (rl >> (64 - bits));	\
331 	lr = (rl << (bits - 32)) + (rr >> (64 - bits));	\
332 	rl = (rr << (bits - 32)) + (w0 >> (64 - bits));	\
333 	rr = (w0 << (bits - 32)) + (w1 >> (64 - bits));	\
334 })
335 
336 #define CAMELLIA_F(xl, xr, kl, kr, yl, yr, il, ir, t0, t1) ({	\
337 	il = xl ^ kl;						\
338 	ir = xr ^ kr;						\
339 	t0 = il >> 16;						\
340 	t1 = ir >> 16;						\
341 	yl = camellia_sp1110[(u8)(ir)]				\
342 	   ^ camellia_sp0222[(u8)(t1 >> 8)]			\
343 	   ^ camellia_sp3033[(u8)(t1)]				\
344 	   ^ camellia_sp4404[(u8)(ir >> 8)];			\
345 	yr = camellia_sp1110[(u8)(t0 >> 8)]			\
346 	   ^ camellia_sp0222[(u8)(t0)]				\
347 	   ^ camellia_sp3033[(u8)(il >> 8)]			\
348 	   ^ camellia_sp4404[(u8)(il)];				\
349 	yl ^= yr;						\
350 	yr = ror32(yr, 8);					\
351 	yr ^= yl;						\
352 })
353 
354 #define SUBKEY_L(INDEX) (subkey[(INDEX)*2])
355 #define SUBKEY_R(INDEX) (subkey[(INDEX)*2 + 1])
356 
357 static void camellia_setup_tail(u32 *subkey, u32 *subL, u32 *subR, int max)
358 {
359 	u32 dw, tl, tr;
360 	u32 kw4l, kw4r;
361 
362 	/* absorb kw2 to other subkeys */
363 	/* round 2 */
364 	subL[3] ^= subL[1]; subR[3] ^= subR[1];
365 	/* round 4 */
366 	subL[5] ^= subL[1]; subR[5] ^= subR[1];
367 	/* round 6 */
368 	subL[7] ^= subL[1]; subR[7] ^= subR[1];
369 	subL[1] ^= subR[1] & ~subR[9];
370 	dw = subL[1] & subL[9];
371 	subR[1] ^= rol32(dw, 1); /* modified for FLinv(kl2) */
372 	/* round 8 */
373 	subL[11] ^= subL[1]; subR[11] ^= subR[1];
374 	/* round 10 */
375 	subL[13] ^= subL[1]; subR[13] ^= subR[1];
376 	/* round 12 */
377 	subL[15] ^= subL[1]; subR[15] ^= subR[1];
378 	subL[1] ^= subR[1] & ~subR[17];
379 	dw = subL[1] & subL[17];
380 	subR[1] ^= rol32(dw, 1); /* modified for FLinv(kl4) */
381 	/* round 14 */
382 	subL[19] ^= subL[1]; subR[19] ^= subR[1];
383 	/* round 16 */
384 	subL[21] ^= subL[1]; subR[21] ^= subR[1];
385 	/* round 18 */
386 	subL[23] ^= subL[1]; subR[23] ^= subR[1];
387 	if (max == 24) {
388 		/* kw3 */
389 		subL[24] ^= subL[1]; subR[24] ^= subR[1];
390 
391 	/* absorb kw4 to other subkeys */
392 		kw4l = subL[25]; kw4r = subR[25];
393 	} else {
394 		subL[1] ^= subR[1] & ~subR[25];
395 		dw = subL[1] & subL[25];
396 		subR[1] ^= rol32(dw, 1); /* modified for FLinv(kl6) */
397 		/* round 20 */
398 		subL[27] ^= subL[1]; subR[27] ^= subR[1];
399 		/* round 22 */
400 		subL[29] ^= subL[1]; subR[29] ^= subR[1];
401 		/* round 24 */
402 		subL[31] ^= subL[1]; subR[31] ^= subR[1];
403 		/* kw3 */
404 		subL[32] ^= subL[1]; subR[32] ^= subR[1];
405 
406 	/* absorb kw4 to other subkeys */
407 		kw4l = subL[33]; kw4r = subR[33];
408 		/* round 23 */
409 		subL[30] ^= kw4l; subR[30] ^= kw4r;
410 		/* round 21 */
411 		subL[28] ^= kw4l; subR[28] ^= kw4r;
412 		/* round 19 */
413 		subL[26] ^= kw4l; subR[26] ^= kw4r;
414 		kw4l ^= kw4r & ~subR[24];
415 		dw = kw4l & subL[24];
416 		kw4r ^= rol32(dw, 1); /* modified for FL(kl5) */
417 	}
418 	/* round 17 */
419 	subL[22] ^= kw4l; subR[22] ^= kw4r;
420 	/* round 15 */
421 	subL[20] ^= kw4l; subR[20] ^= kw4r;
422 	/* round 13 */
423 	subL[18] ^= kw4l; subR[18] ^= kw4r;
424 	kw4l ^= kw4r & ~subR[16];
425 	dw = kw4l & subL[16];
426 	kw4r ^= rol32(dw, 1); /* modified for FL(kl3) */
427 	/* round 11 */
428 	subL[14] ^= kw4l; subR[14] ^= kw4r;
429 	/* round 9 */
430 	subL[12] ^= kw4l; subR[12] ^= kw4r;
431 	/* round 7 */
432 	subL[10] ^= kw4l; subR[10] ^= kw4r;
433 	kw4l ^= kw4r & ~subR[8];
434 	dw = kw4l & subL[8];
435 	kw4r ^= rol32(dw, 1); /* modified for FL(kl1) */
436 	/* round 5 */
437 	subL[6] ^= kw4l; subR[6] ^= kw4r;
438 	/* round 3 */
439 	subL[4] ^= kw4l; subR[4] ^= kw4r;
440 	/* round 1 */
441 	subL[2] ^= kw4l; subR[2] ^= kw4r;
442 	/* kw1 */
443 	subL[0] ^= kw4l; subR[0] ^= kw4r;
444 
445 	/* key XOR is end of F-function */
446 	SUBKEY_L(0) = subL[0] ^ subL[2];/* kw1 */
447 	SUBKEY_R(0) = subR[0] ^ subR[2];
448 	SUBKEY_L(2) = subL[3];       /* round 1 */
449 	SUBKEY_R(2) = subR[3];
450 	SUBKEY_L(3) = subL[2] ^ subL[4]; /* round 2 */
451 	SUBKEY_R(3) = subR[2] ^ subR[4];
452 	SUBKEY_L(4) = subL[3] ^ subL[5]; /* round 3 */
453 	SUBKEY_R(4) = subR[3] ^ subR[5];
454 	SUBKEY_L(5) = subL[4] ^ subL[6]; /* round 4 */
455 	SUBKEY_R(5) = subR[4] ^ subR[6];
456 	SUBKEY_L(6) = subL[5] ^ subL[7]; /* round 5 */
457 	SUBKEY_R(6) = subR[5] ^ subR[7];
458 	tl = subL[10] ^ (subR[10] & ~subR[8]);
459 	dw = tl & subL[8];  /* FL(kl1) */
460 	tr = subR[10] ^ rol32(dw, 1);
461 	SUBKEY_L(7) = subL[6] ^ tl; /* round 6 */
462 	SUBKEY_R(7) = subR[6] ^ tr;
463 	SUBKEY_L(8) = subL[8];       /* FL(kl1) */
464 	SUBKEY_R(8) = subR[8];
465 	SUBKEY_L(9) = subL[9];       /* FLinv(kl2) */
466 	SUBKEY_R(9) = subR[9];
467 	tl = subL[7] ^ (subR[7] & ~subR[9]);
468 	dw = tl & subL[9];  /* FLinv(kl2) */
469 	tr = subR[7] ^ rol32(dw, 1);
470 	SUBKEY_L(10) = tl ^ subL[11]; /* round 7 */
471 	SUBKEY_R(10) = tr ^ subR[11];
472 	SUBKEY_L(11) = subL[10] ^ subL[12]; /* round 8 */
473 	SUBKEY_R(11) = subR[10] ^ subR[12];
474 	SUBKEY_L(12) = subL[11] ^ subL[13]; /* round 9 */
475 	SUBKEY_R(12) = subR[11] ^ subR[13];
476 	SUBKEY_L(13) = subL[12] ^ subL[14]; /* round 10 */
477 	SUBKEY_R(13) = subR[12] ^ subR[14];
478 	SUBKEY_L(14) = subL[13] ^ subL[15]; /* round 11 */
479 	SUBKEY_R(14) = subR[13] ^ subR[15];
480 	tl = subL[18] ^ (subR[18] & ~subR[16]);
481 	dw = tl & subL[16]; /* FL(kl3) */
482 	tr = subR[18] ^ rol32(dw, 1);
483 	SUBKEY_L(15) = subL[14] ^ tl; /* round 12 */
484 	SUBKEY_R(15) = subR[14] ^ tr;
485 	SUBKEY_L(16) = subL[16];     /* FL(kl3) */
486 	SUBKEY_R(16) = subR[16];
487 	SUBKEY_L(17) = subL[17];     /* FLinv(kl4) */
488 	SUBKEY_R(17) = subR[17];
489 	tl = subL[15] ^ (subR[15] & ~subR[17]);
490 	dw = tl & subL[17]; /* FLinv(kl4) */
491 	tr = subR[15] ^ rol32(dw, 1);
492 	SUBKEY_L(18) = tl ^ subL[19]; /* round 13 */
493 	SUBKEY_R(18) = tr ^ subR[19];
494 	SUBKEY_L(19) = subL[18] ^ subL[20]; /* round 14 */
495 	SUBKEY_R(19) = subR[18] ^ subR[20];
496 	SUBKEY_L(20) = subL[19] ^ subL[21]; /* round 15 */
497 	SUBKEY_R(20) = subR[19] ^ subR[21];
498 	SUBKEY_L(21) = subL[20] ^ subL[22]; /* round 16 */
499 	SUBKEY_R(21) = subR[20] ^ subR[22];
500 	SUBKEY_L(22) = subL[21] ^ subL[23]; /* round 17 */
501 	SUBKEY_R(22) = subR[21] ^ subR[23];
502 	if (max == 24) {
503 		SUBKEY_L(23) = subL[22];     /* round 18 */
504 		SUBKEY_R(23) = subR[22];
505 		SUBKEY_L(24) = subL[24] ^ subL[23]; /* kw3 */
506 		SUBKEY_R(24) = subR[24] ^ subR[23];
507 	} else {
508 		tl = subL[26] ^ (subR[26] & ~subR[24]);
509 		dw = tl & subL[24]; /* FL(kl5) */
510 		tr = subR[26] ^ rol32(dw, 1);
511 		SUBKEY_L(23) = subL[22] ^ tl; /* round 18 */
512 		SUBKEY_R(23) = subR[22] ^ tr;
513 		SUBKEY_L(24) = subL[24];     /* FL(kl5) */
514 		SUBKEY_R(24) = subR[24];
515 		SUBKEY_L(25) = subL[25];     /* FLinv(kl6) */
516 		SUBKEY_R(25) = subR[25];
517 		tl = subL[23] ^ (subR[23] & ~subR[25]);
518 		dw = tl & subL[25]; /* FLinv(kl6) */
519 		tr = subR[23] ^ rol32(dw, 1);
520 		SUBKEY_L(26) = tl ^ subL[27]; /* round 19 */
521 		SUBKEY_R(26) = tr ^ subR[27];
522 		SUBKEY_L(27) = subL[26] ^ subL[28]; /* round 20 */
523 		SUBKEY_R(27) = subR[26] ^ subR[28];
524 		SUBKEY_L(28) = subL[27] ^ subL[29]; /* round 21 */
525 		SUBKEY_R(28) = subR[27] ^ subR[29];
526 		SUBKEY_L(29) = subL[28] ^ subL[30]; /* round 22 */
527 		SUBKEY_R(29) = subR[28] ^ subR[30];
528 		SUBKEY_L(30) = subL[29] ^ subL[31]; /* round 23 */
529 		SUBKEY_R(30) = subR[29] ^ subR[31];
530 		SUBKEY_L(31) = subL[30];     /* round 24 */
531 		SUBKEY_R(31) = subR[30];
532 		SUBKEY_L(32) = subL[32] ^ subL[31]; /* kw3 */
533 		SUBKEY_R(32) = subR[32] ^ subR[31];
534 	}
535 }
536 
537 static void camellia_setup128(const unsigned char *key, u32 *subkey)
538 {
539 	u32 kll, klr, krl, krr;
540 	u32 il, ir, t0, t1, w0, w1;
541 	u32 subL[26];
542 	u32 subR[26];
543 
544 	/**
545 	 *  k == kll || klr || krl || krr (|| is concatenation)
546 	 */
547 	kll = get_unaligned_be32(key);
548 	klr = get_unaligned_be32(key + 4);
549 	krl = get_unaligned_be32(key + 8);
550 	krr = get_unaligned_be32(key + 12);
551 
552 	/* generate KL dependent subkeys */
553 	/* kw1 */
554 	subL[0] = kll; subR[0] = klr;
555 	/* kw2 */
556 	subL[1] = krl; subR[1] = krr;
557 	/* rotation left shift 15bit */
558 	ROLDQ(kll, klr, krl, krr, w0, w1, 15);
559 	/* k3 */
560 	subL[4] = kll; subR[4] = klr;
561 	/* k4 */
562 	subL[5] = krl; subR[5] = krr;
563 	/* rotation left shift 15+30bit */
564 	ROLDQ(kll, klr, krl, krr, w0, w1, 30);
565 	/* k7 */
566 	subL[10] = kll; subR[10] = klr;
567 	/* k8 */
568 	subL[11] = krl; subR[11] = krr;
569 	/* rotation left shift 15+30+15bit */
570 	ROLDQ(kll, klr, krl, krr, w0, w1, 15);
571 	/* k10 */
572 	subL[13] = krl; subR[13] = krr;
573 	/* rotation left shift 15+30+15+17 bit */
574 	ROLDQ(kll, klr, krl, krr, w0, w1, 17);
575 	/* kl3 */
576 	subL[16] = kll; subR[16] = klr;
577 	/* kl4 */
578 	subL[17] = krl; subR[17] = krr;
579 	/* rotation left shift 15+30+15+17+17 bit */
580 	ROLDQ(kll, klr, krl, krr, w0, w1, 17);
581 	/* k13 */
582 	subL[18] = kll; subR[18] = klr;
583 	/* k14 */
584 	subL[19] = krl; subR[19] = krr;
585 	/* rotation left shift 15+30+15+17+17+17 bit */
586 	ROLDQ(kll, klr, krl, krr, w0, w1, 17);
587 	/* k17 */
588 	subL[22] = kll; subR[22] = klr;
589 	/* k18 */
590 	subL[23] = krl; subR[23] = krr;
591 
592 	/* generate KA */
593 	kll = subL[0]; klr = subR[0];
594 	krl = subL[1]; krr = subR[1];
595 	CAMELLIA_F(kll, klr,
596 		   CAMELLIA_SIGMA1L, CAMELLIA_SIGMA1R,
597 		   w0, w1, il, ir, t0, t1);
598 	krl ^= w0; krr ^= w1;
599 	CAMELLIA_F(krl, krr,
600 		   CAMELLIA_SIGMA2L, CAMELLIA_SIGMA2R,
601 		   kll, klr, il, ir, t0, t1);
602 	/* current status == (kll, klr, w0, w1) */
603 	CAMELLIA_F(kll, klr,
604 		   CAMELLIA_SIGMA3L, CAMELLIA_SIGMA3R,
605 		   krl, krr, il, ir, t0, t1);
606 	krl ^= w0; krr ^= w1;
607 	CAMELLIA_F(krl, krr,
608 		   CAMELLIA_SIGMA4L, CAMELLIA_SIGMA4R,
609 		   w0, w1, il, ir, t0, t1);
610 	kll ^= w0; klr ^= w1;
611 
612 	/* generate KA dependent subkeys */
613 	/* k1, k2 */
614 	subL[2] = kll; subR[2] = klr;
615 	subL[3] = krl; subR[3] = krr;
616 	ROLDQ(kll, klr, krl, krr, w0, w1, 15);
617 	/* k5,k6 */
618 	subL[6] = kll; subR[6] = klr;
619 	subL[7] = krl; subR[7] = krr;
620 	ROLDQ(kll, klr, krl, krr, w0, w1, 15);
621 	/* kl1, kl2 */
622 	subL[8] = kll; subR[8] = klr;
623 	subL[9] = krl; subR[9] = krr;
624 	ROLDQ(kll, klr, krl, krr, w0, w1, 15);
625 	/* k9 */
626 	subL[12] = kll; subR[12] = klr;
627 	ROLDQ(kll, klr, krl, krr, w0, w1, 15);
628 	/* k11, k12 */
629 	subL[14] = kll; subR[14] = klr;
630 	subL[15] = krl; subR[15] = krr;
631 	ROLDQo32(kll, klr, krl, krr, w0, w1, 34);
632 	/* k15, k16 */
633 	subL[20] = kll; subR[20] = klr;
634 	subL[21] = krl; subR[21] = krr;
635 	ROLDQ(kll, klr, krl, krr, w0, w1, 17);
636 	/* kw3, kw4 */
637 	subL[24] = kll; subR[24] = klr;
638 	subL[25] = krl; subR[25] = krr;
639 
640 	camellia_setup_tail(subkey, subL, subR, 24);
641 }
642 
643 static void camellia_setup256(const unsigned char *key, u32 *subkey)
644 {
645 	u32 kll, klr, krl, krr;        /* left half of key */
646 	u32 krll, krlr, krrl, krrr;    /* right half of key */
647 	u32 il, ir, t0, t1, w0, w1;    /* temporary variables */
648 	u32 subL[34];
649 	u32 subR[34];
650 
651 	/**
652 	 *  key = (kll || klr || krl || krr || krll || krlr || krrl || krrr)
653 	 *  (|| is concatenation)
654 	 */
655 	kll = get_unaligned_be32(key);
656 	klr = get_unaligned_be32(key + 4);
657 	krl = get_unaligned_be32(key + 8);
658 	krr = get_unaligned_be32(key + 12);
659 	krll = get_unaligned_be32(key + 16);
660 	krlr = get_unaligned_be32(key + 20);
661 	krrl = get_unaligned_be32(key + 24);
662 	krrr = get_unaligned_be32(key + 28);
663 
664 	/* generate KL dependent subkeys */
665 	/* kw1 */
666 	subL[0] = kll; subR[0] = klr;
667 	/* kw2 */
668 	subL[1] = krl; subR[1] = krr;
669 	ROLDQo32(kll, klr, krl, krr, w0, w1, 45);
670 	/* k9 */
671 	subL[12] = kll; subR[12] = klr;
672 	/* k10 */
673 	subL[13] = krl; subR[13] = krr;
674 	ROLDQ(kll, klr, krl, krr, w0, w1, 15);
675 	/* kl3 */
676 	subL[16] = kll; subR[16] = klr;
677 	/* kl4 */
678 	subL[17] = krl; subR[17] = krr;
679 	ROLDQ(kll, klr, krl, krr, w0, w1, 17);
680 	/* k17 */
681 	subL[22] = kll; subR[22] = klr;
682 	/* k18 */
683 	subL[23] = krl; subR[23] = krr;
684 	ROLDQo32(kll, klr, krl, krr, w0, w1, 34);
685 	/* k23 */
686 	subL[30] = kll; subR[30] = klr;
687 	/* k24 */
688 	subL[31] = krl; subR[31] = krr;
689 
690 	/* generate KR dependent subkeys */
691 	ROLDQ(krll, krlr, krrl, krrr, w0, w1, 15);
692 	/* k3 */
693 	subL[4] = krll; subR[4] = krlr;
694 	/* k4 */
695 	subL[5] = krrl; subR[5] = krrr;
696 	ROLDQ(krll, krlr, krrl, krrr, w0, w1, 15);
697 	/* kl1 */
698 	subL[8] = krll; subR[8] = krlr;
699 	/* kl2 */
700 	subL[9] = krrl; subR[9] = krrr;
701 	ROLDQ(krll, krlr, krrl, krrr, w0, w1, 30);
702 	/* k13 */
703 	subL[18] = krll; subR[18] = krlr;
704 	/* k14 */
705 	subL[19] = krrl; subR[19] = krrr;
706 	ROLDQo32(krll, krlr, krrl, krrr, w0, w1, 34);
707 	/* k19 */
708 	subL[26] = krll; subR[26] = krlr;
709 	/* k20 */
710 	subL[27] = krrl; subR[27] = krrr;
711 	ROLDQo32(krll, krlr, krrl, krrr, w0, w1, 34);
712 
713 	/* generate KA */
714 	kll = subL[0] ^ krll; klr = subR[0] ^ krlr;
715 	krl = subL[1] ^ krrl; krr = subR[1] ^ krrr;
716 	CAMELLIA_F(kll, klr,
717 		   CAMELLIA_SIGMA1L, CAMELLIA_SIGMA1R,
718 		   w0, w1, il, ir, t0, t1);
719 	krl ^= w0; krr ^= w1;
720 	CAMELLIA_F(krl, krr,
721 		   CAMELLIA_SIGMA2L, CAMELLIA_SIGMA2R,
722 		   kll, klr, il, ir, t0, t1);
723 	kll ^= krll; klr ^= krlr;
724 	CAMELLIA_F(kll, klr,
725 		   CAMELLIA_SIGMA3L, CAMELLIA_SIGMA3R,
726 		   krl, krr, il, ir, t0, t1);
727 	krl ^= w0 ^ krrl; krr ^= w1 ^ krrr;
728 	CAMELLIA_F(krl, krr,
729 		   CAMELLIA_SIGMA4L, CAMELLIA_SIGMA4R,
730 		   w0, w1, il, ir, t0, t1);
731 	kll ^= w0; klr ^= w1;
732 
733 	/* generate KB */
734 	krll ^= kll; krlr ^= klr;
735 	krrl ^= krl; krrr ^= krr;
736 	CAMELLIA_F(krll, krlr,
737 		   CAMELLIA_SIGMA5L, CAMELLIA_SIGMA5R,
738 		   w0, w1, il, ir, t0, t1);
739 	krrl ^= w0; krrr ^= w1;
740 	CAMELLIA_F(krrl, krrr,
741 		   CAMELLIA_SIGMA6L, CAMELLIA_SIGMA6R,
742 		   w0, w1, il, ir, t0, t1);
743 	krll ^= w0; krlr ^= w1;
744 
745 	/* generate KA dependent subkeys */
746 	ROLDQ(kll, klr, krl, krr, w0, w1, 15);
747 	/* k5 */
748 	subL[6] = kll; subR[6] = klr;
749 	/* k6 */
750 	subL[7] = krl; subR[7] = krr;
751 	ROLDQ(kll, klr, krl, krr, w0, w1, 30);
752 	/* k11 */
753 	subL[14] = kll; subR[14] = klr;
754 	/* k12 */
755 	subL[15] = krl; subR[15] = krr;
756 	/* rotation left shift 32bit */
757 	/* kl5 */
758 	subL[24] = klr; subR[24] = krl;
759 	/* kl6 */
760 	subL[25] = krr; subR[25] = kll;
761 	/* rotation left shift 49 from k11,k12 -> k21,k22 */
762 	ROLDQo32(kll, klr, krl, krr, w0, w1, 49);
763 	/* k21 */
764 	subL[28] = kll; subR[28] = klr;
765 	/* k22 */
766 	subL[29] = krl; subR[29] = krr;
767 
768 	/* generate KB dependent subkeys */
769 	/* k1 */
770 	subL[2] = krll; subR[2] = krlr;
771 	/* k2 */
772 	subL[3] = krrl; subR[3] = krrr;
773 	ROLDQ(krll, krlr, krrl, krrr, w0, w1, 30);
774 	/* k7 */
775 	subL[10] = krll; subR[10] = krlr;
776 	/* k8 */
777 	subL[11] = krrl; subR[11] = krrr;
778 	ROLDQ(krll, krlr, krrl, krrr, w0, w1, 30);
779 	/* k15 */
780 	subL[20] = krll; subR[20] = krlr;
781 	/* k16 */
782 	subL[21] = krrl; subR[21] = krrr;
783 	ROLDQo32(krll, krlr, krrl, krrr, w0, w1, 51);
784 	/* kw3 */
785 	subL[32] = krll; subR[32] = krlr;
786 	/* kw4 */
787 	subL[33] = krrl; subR[33] = krrr;
788 
789 	camellia_setup_tail(subkey, subL, subR, 32);
790 }
791 
792 static void camellia_setup192(const unsigned char *key, u32 *subkey)
793 {
794 	unsigned char kk[32];
795 	u32 krll, krlr, krrl, krrr;
796 
797 	memcpy(kk, key, 24);
798 	memcpy((unsigned char *)&krll, key+16, 4);
799 	memcpy((unsigned char *)&krlr, key+20, 4);
800 	krrl = ~krll;
801 	krrr = ~krlr;
802 	memcpy(kk+24, (unsigned char *)&krrl, 4);
803 	memcpy(kk+28, (unsigned char *)&krrr, 4);
804 	camellia_setup256(kk, subkey);
805 }
806 
807 
808 /*
809  * Encrypt/decrypt
810  */
811 #define CAMELLIA_FLS(ll, lr, rl, rr, kll, klr, krl, krr, t0, t1, t2, t3) ({ \
812 	t0 = kll;							\
813 	t2 = krr;							\
814 	t0 &= ll;							\
815 	t2 |= rr;							\
816 	rl ^= t2;							\
817 	lr ^= rol32(t0, 1);						\
818 	t3 = krl;							\
819 	t1 = klr;							\
820 	t3 &= rl;							\
821 	t1 |= lr;							\
822 	ll ^= t1;							\
823 	rr ^= rol32(t3, 1);						\
824 })
825 
826 #define CAMELLIA_ROUNDSM(xl, xr, kl, kr, yl, yr, il, ir) ({		\
827 	yl ^= kl;							\
828 	yr ^= kr;							\
829 	ir =  camellia_sp1110[(u8)xr];					\
830 	il =  camellia_sp1110[(u8)(xl >> 24)];				\
831 	ir ^= camellia_sp0222[(u8)(xr >> 24)];				\
832 	il ^= camellia_sp0222[(u8)(xl >> 16)];				\
833 	ir ^= camellia_sp3033[(u8)(xr >> 16)];				\
834 	il ^= camellia_sp3033[(u8)(xl >> 8)];				\
835 	ir ^= camellia_sp4404[(u8)(xr >> 8)];				\
836 	il ^= camellia_sp4404[(u8)xl];					\
837 	ir ^= il;							\
838 	yl ^= ir;							\
839 	yr ^= ror32(il, 8) ^ ir;					\
840 })
841 
842 /* max = 24: 128bit encrypt, max = 32: 256bit encrypt */
843 static void camellia_do_encrypt(const u32 *subkey, u32 *io, unsigned max)
844 {
845 	u32 il, ir, t0, t1;            /* temporary variables */
846 
847 	/* pre whitening but absorb kw2 */
848 	io[0] ^= SUBKEY_L(0);
849 	io[1] ^= SUBKEY_R(0);
850 
851 	/* main iteration */
852 #define ROUNDS(i) ({ \
853 	CAMELLIA_ROUNDSM(io[0], io[1], \
854 			 SUBKEY_L(i + 2), SUBKEY_R(i + 2), \
855 			 io[2], io[3], il, ir); \
856 	CAMELLIA_ROUNDSM(io[2], io[3], \
857 			 SUBKEY_L(i + 3), SUBKEY_R(i + 3), \
858 			 io[0], io[1], il, ir); \
859 	CAMELLIA_ROUNDSM(io[0], io[1], \
860 			 SUBKEY_L(i + 4), SUBKEY_R(i + 4), \
861 			 io[2], io[3], il, ir); \
862 	CAMELLIA_ROUNDSM(io[2], io[3], \
863 			 SUBKEY_L(i + 5), SUBKEY_R(i + 5), \
864 			 io[0], io[1], il, ir); \
865 	CAMELLIA_ROUNDSM(io[0], io[1], \
866 			 SUBKEY_L(i + 6), SUBKEY_R(i + 6), \
867 			 io[2], io[3], il, ir); \
868 	CAMELLIA_ROUNDSM(io[2], io[3], \
869 			 SUBKEY_L(i + 7), SUBKEY_R(i + 7), \
870 			 io[0], io[1], il, ir); \
871 })
872 #define FLS(i) ({ \
873 	CAMELLIA_FLS(io[0], io[1], io[2], io[3], \
874 		     SUBKEY_L(i + 0), SUBKEY_R(i + 0), \
875 		     SUBKEY_L(i + 1), SUBKEY_R(i + 1), \
876 		     t0, t1, il, ir); \
877 })
878 
879 	ROUNDS(0);
880 	FLS(8);
881 	ROUNDS(8);
882 	FLS(16);
883 	ROUNDS(16);
884 	if (max == 32) {
885 		FLS(24);
886 		ROUNDS(24);
887 	}
888 
889 #undef ROUNDS
890 #undef FLS
891 
892 	/* post whitening but kw4 */
893 	io[2] ^= SUBKEY_L(max);
894 	io[3] ^= SUBKEY_R(max);
895 	/* NB: io[0],[1] should be swapped with [2],[3] by caller! */
896 }
897 
898 static void camellia_do_decrypt(const u32 *subkey, u32 *io, unsigned i)
899 {
900 	u32 il, ir, t0, t1;            /* temporary variables */
901 
902 	/* pre whitening but absorb kw2 */
903 	io[0] ^= SUBKEY_L(i);
904 	io[1] ^= SUBKEY_R(i);
905 
906 	/* main iteration */
907 #define ROUNDS(i) ({ \
908 	CAMELLIA_ROUNDSM(io[0], io[1], \
909 			 SUBKEY_L(i + 7), SUBKEY_R(i + 7), \
910 			 io[2], io[3], il, ir); \
911 	CAMELLIA_ROUNDSM(io[2], io[3], \
912 			 SUBKEY_L(i + 6), SUBKEY_R(i + 6), \
913 			 io[0], io[1], il, ir); \
914 	CAMELLIA_ROUNDSM(io[0], io[1], \
915 			 SUBKEY_L(i + 5), SUBKEY_R(i + 5), \
916 			 io[2], io[3], il, ir); \
917 	CAMELLIA_ROUNDSM(io[2], io[3], \
918 			 SUBKEY_L(i + 4), SUBKEY_R(i + 4), \
919 			 io[0], io[1], il, ir); \
920 	CAMELLIA_ROUNDSM(io[0], io[1], \
921 			 SUBKEY_L(i + 3), SUBKEY_R(i + 3), \
922 			 io[2], io[3], il, ir); \
923 	CAMELLIA_ROUNDSM(io[2], io[3], \
924 			 SUBKEY_L(i + 2), SUBKEY_R(i + 2), \
925 			 io[0], io[1], il, ir); \
926 })
927 #define FLS(i) ({ \
928 	CAMELLIA_FLS(io[0], io[1], io[2], io[3], \
929 		     SUBKEY_L(i + 1), SUBKEY_R(i + 1), \
930 		     SUBKEY_L(i + 0), SUBKEY_R(i + 0), \
931 		     t0, t1, il, ir); \
932 })
933 
934 	if (i == 32) {
935 		ROUNDS(24);
936 		FLS(24);
937 	}
938 	ROUNDS(16);
939 	FLS(16);
940 	ROUNDS(8);
941 	FLS(8);
942 	ROUNDS(0);
943 
944 #undef ROUNDS
945 #undef FLS
946 
947 	/* post whitening but kw4 */
948 	io[2] ^= SUBKEY_L(0);
949 	io[3] ^= SUBKEY_R(0);
950 	/* NB: 0,1 should be swapped with 2,3 by caller! */
951 }
952 
953 
954 struct camellia_ctx {
955 	int key_length;
956 	u32 key_table[CAMELLIA_TABLE_BYTE_LEN / sizeof(u32)];
957 };
958 
959 static int
960 camellia_set_key(struct crypto_tfm *tfm, const u8 *in_key,
961 		 unsigned int key_len)
962 {
963 	struct camellia_ctx *cctx = crypto_tfm_ctx(tfm);
964 	const unsigned char *key = (const unsigned char *)in_key;
965 
966 	if (key_len != 16 && key_len != 24 && key_len != 32)
967 		return -EINVAL;
968 
969 	cctx->key_length = key_len;
970 
971 	switch (key_len) {
972 	case 16:
973 		camellia_setup128(key, cctx->key_table);
974 		break;
975 	case 24:
976 		camellia_setup192(key, cctx->key_table);
977 		break;
978 	case 32:
979 		camellia_setup256(key, cctx->key_table);
980 		break;
981 	}
982 
983 	return 0;
984 }
985 
986 static void camellia_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
987 {
988 	const struct camellia_ctx *cctx = crypto_tfm_ctx(tfm);
989 	unsigned int max;
990 
991 	u32 tmp[4];
992 
993 	tmp[0] = get_unaligned_be32(in);
994 	tmp[1] = get_unaligned_be32(in + 4);
995 	tmp[2] = get_unaligned_be32(in + 8);
996 	tmp[3] = get_unaligned_be32(in + 12);
997 
998 	if (cctx->key_length == 16)
999 		max = 24;
1000 	else
1001 		max = 32; /* for key lengths of 24 and 32 */
1002 
1003 	camellia_do_encrypt(cctx->key_table, tmp, max);
1004 
1005 	/* do_encrypt returns 0,1 swapped with 2,3 */
1006 	put_unaligned_be32(tmp[2], out);
1007 	put_unaligned_be32(tmp[3], out + 4);
1008 	put_unaligned_be32(tmp[0], out + 8);
1009 	put_unaligned_be32(tmp[1], out + 12);
1010 }
1011 
1012 static void camellia_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
1013 {
1014 	const struct camellia_ctx *cctx = crypto_tfm_ctx(tfm);
1015 	unsigned int max;
1016 
1017 	u32 tmp[4];
1018 
1019 	tmp[0] = get_unaligned_be32(in);
1020 	tmp[1] = get_unaligned_be32(in + 4);
1021 	tmp[2] = get_unaligned_be32(in + 8);
1022 	tmp[3] = get_unaligned_be32(in + 12);
1023 
1024 	if (cctx->key_length == 16)
1025 		max = 24;
1026 	else
1027 		max = 32; /* for key lengths of 24 and 32 */
1028 
1029 	camellia_do_decrypt(cctx->key_table, tmp, max);
1030 
1031 	/* do_decrypt returns 0,1 swapped with 2,3 */
1032 	put_unaligned_be32(tmp[2], out);
1033 	put_unaligned_be32(tmp[3], out + 4);
1034 	put_unaligned_be32(tmp[0], out + 8);
1035 	put_unaligned_be32(tmp[1], out + 12);
1036 }
1037 
1038 static struct crypto_alg camellia_alg = {
1039 	.cra_name		=	"camellia",
1040 	.cra_driver_name	=	"camellia-generic",
1041 	.cra_priority		=	100,
1042 	.cra_flags		=	CRYPTO_ALG_TYPE_CIPHER,
1043 	.cra_blocksize		=	CAMELLIA_BLOCK_SIZE,
1044 	.cra_ctxsize		=	sizeof(struct camellia_ctx),
1045 	.cra_module		=	THIS_MODULE,
1046 	.cra_u			=	{
1047 		.cipher = {
1048 			.cia_min_keysize	=	CAMELLIA_MIN_KEY_SIZE,
1049 			.cia_max_keysize	=	CAMELLIA_MAX_KEY_SIZE,
1050 			.cia_setkey		=	camellia_set_key,
1051 			.cia_encrypt		=	camellia_encrypt,
1052 			.cia_decrypt		=	camellia_decrypt
1053 		}
1054 	}
1055 };
1056 
1057 static int __init camellia_init(void)
1058 {
1059 	return crypto_register_alg(&camellia_alg);
1060 }
1061 
1062 static void __exit camellia_fini(void)
1063 {
1064 	crypto_unregister_alg(&camellia_alg);
1065 }
1066 
1067 subsys_initcall(camellia_init);
1068 module_exit(camellia_fini);
1069 
1070 MODULE_DESCRIPTION("Camellia Cipher Algorithm");
1071 MODULE_LICENSE("GPL");
1072 MODULE_ALIAS_CRYPTO("camellia");
1073 MODULE_ALIAS_CRYPTO("camellia-generic");
1074