~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/crypto/aria_generic.c

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /crypto/aria_generic.c (Version linux-6.12-rc7) and /crypto/aria_generic.c (Version linux-5.10.228)


** Warning: Cannot open xref database.

  1 // SPDX-License-Identifier: GPL-2.0-or-later        1 
  2 /*                                                
  3  * Cryptographic API.                             
  4  *                                                
  5  * ARIA Cipher Algorithm.                         
  6  *                                                
  7  * Documentation of ARIA can be found in RFC 5    
  8  * Copyright (c) 2022 Taehee Yoo <ap420073@gma    
  9  *                                                
 10  * Information for ARIA                           
 11  *     http://210.104.33.10/ARIA/index-e.html     
 12  *     http://seed.kisa.or.kr/ (Korean)           
 13  *                                                
 14  * Public domain version is distributed above.    
 15  */                                               
 16                                                   
 17 #include <crypto/aria.h>                          
 18                                                   
 19 static const u32 key_rc[20] = {                   
 20         0x517cc1b7, 0x27220a94, 0xfe13abe8, 0x    
 21         0x6db14acc, 0x9e21c820, 0xff28b1d5, 0x    
 22         0xdb92371d, 0x2126e970, 0x03249775, 0x    
 23         0x517cc1b7, 0x27220a94, 0xfe13abe8, 0x    
 24         0x6db14acc, 0x9e21c820, 0xff28b1d5, 0x    
 25 };                                                
 26                                                   
 27 static void aria_set_encrypt_key(struct aria_c    
 28                                  unsigned int     
 29 {                                                 
 30         const __be32 *key = (const __be32 *)in    
 31         u32 w0[4], w1[4], w2[4], w3[4];           
 32         u32 reg0, reg1, reg2, reg3;               
 33         const u32 *ck;                            
 34         int rkidx = 0;                            
 35                                                   
 36         ck = &key_rc[(key_len - 16) / 2];         
 37                                                   
 38         w0[0] = be32_to_cpu(key[0]);              
 39         w0[1] = be32_to_cpu(key[1]);              
 40         w0[2] = be32_to_cpu(key[2]);              
 41         w0[3] = be32_to_cpu(key[3]);              
 42                                                   
 43         reg0 = w0[0] ^ ck[0];                     
 44         reg1 = w0[1] ^ ck[1];                     
 45         reg2 = w0[2] ^ ck[2];                     
 46         reg3 = w0[3] ^ ck[3];                     
 47                                                   
 48         aria_subst_diff_odd(&reg0, &reg1, &reg    
 49                                                   
 50         if (key_len > 16) {                       
 51                 w1[0] = be32_to_cpu(key[4]);      
 52                 w1[1] = be32_to_cpu(key[5]);      
 53                 if (key_len > 24) {               
 54                         w1[2] = be32_to_cpu(ke    
 55                         w1[3] = be32_to_cpu(ke    
 56                 } else {                          
 57                         w1[2] = 0;                
 58                         w1[3] = 0;                
 59                 }                                 
 60         } else {                                  
 61                 w1[0] = 0;                        
 62                 w1[1] = 0;                        
 63                 w1[2] = 0;                        
 64                 w1[3] = 0;                        
 65         }                                         
 66                                                   
 67         w1[0] ^= reg0;                            
 68         w1[1] ^= reg1;                            
 69         w1[2] ^= reg2;                            
 70         w1[3] ^= reg3;                            
 71                                                   
 72         reg0 = w1[0];                             
 73         reg1 = w1[1];                             
 74         reg2 = w1[2];                             
 75         reg3 = w1[3];                             
 76                                                   
 77         reg0 ^= ck[4];                            
 78         reg1 ^= ck[5];                            
 79         reg2 ^= ck[6];                            
 80         reg3 ^= ck[7];                            
 81                                                   
 82         aria_subst_diff_even(&reg0, &reg1, &re    
 83                                                   
 84         reg0 ^= w0[0];                            
 85         reg1 ^= w0[1];                            
 86         reg2 ^= w0[2];                            
 87         reg3 ^= w0[3];                            
 88                                                   
 89         w2[0] = reg0;                             
 90         w2[1] = reg1;                             
 91         w2[2] = reg2;                             
 92         w2[3] = reg3;                             
 93                                                   
 94         reg0 ^= ck[8];                            
 95         reg1 ^= ck[9];                            
 96         reg2 ^= ck[10];                           
 97         reg3 ^= ck[11];                           
 98                                                   
 99         aria_subst_diff_odd(&reg0, &reg1, &reg    
100                                                   
101         w3[0] = reg0 ^ w1[0];                     
102         w3[1] = reg1 ^ w1[1];                     
103         w3[2] = reg2 ^ w1[2];                     
104         w3[3] = reg3 ^ w1[3];                     
105                                                   
106         aria_gsrk(ctx->enc_key[rkidx], w0, w1,    
107         rkidx++;                                  
108         aria_gsrk(ctx->enc_key[rkidx], w1, w2,    
109         rkidx++;                                  
110         aria_gsrk(ctx->enc_key[rkidx], w2, w3,    
111         rkidx++;                                  
112         aria_gsrk(ctx->enc_key[rkidx], w3, w0,    
113                                                   
114         rkidx++;                                  
115         aria_gsrk(ctx->enc_key[rkidx], w0, w1,    
116         rkidx++;                                  
117         aria_gsrk(ctx->enc_key[rkidx], w1, w2,    
118         rkidx++;                                  
119         aria_gsrk(ctx->enc_key[rkidx], w2, w3,    
120         rkidx++;                                  
121         aria_gsrk(ctx->enc_key[rkidx], w3, w0,    
122                                                   
123         rkidx++;                                  
124         aria_gsrk(ctx->enc_key[rkidx], w0, w1,    
125         rkidx++;                                  
126         aria_gsrk(ctx->enc_key[rkidx], w1, w2,    
127         rkidx++;                                  
128         aria_gsrk(ctx->enc_key[rkidx], w2, w3,    
129         rkidx++;                                  
130         aria_gsrk(ctx->enc_key[rkidx], w3, w0,    
131                                                   
132         rkidx++;                                  
133         aria_gsrk(ctx->enc_key[rkidx], w0, w1,    
134         if (key_len > 16) {                       
135                 rkidx++;                          
136                 aria_gsrk(ctx->enc_key[rkidx],    
137                 rkidx++;                          
138                 aria_gsrk(ctx->enc_key[rkidx],    
139                                                   
140                 if (key_len > 24) {               
141                         rkidx++;                  
142                         aria_gsrk(ctx->enc_key    
143                                                   
144                         rkidx++;                  
145                         aria_gsrk(ctx->enc_key    
146                 }                                 
147         }                                         
148 }                                                 
149                                                   
150 static void aria_set_decrypt_key(struct aria_c    
151 {                                                 
152         int i;                                    
153                                                   
154         for (i = 0; i < 4; i++) {                 
155                 ctx->dec_key[0][i] = ctx->enc_    
156                 ctx->dec_key[ctx->rounds][i] =    
157         }                                         
158                                                   
159         for (i = 1; i < ctx->rounds; i++) {       
160                 ctx->dec_key[i][0] = aria_m(ct    
161                 ctx->dec_key[i][1] = aria_m(ct    
162                 ctx->dec_key[i][2] = aria_m(ct    
163                 ctx->dec_key[i][3] = aria_m(ct    
164                                                   
165                 aria_diff_word(&ctx->dec_key[i    
166                                &ctx->dec_key[i    
167                 aria_diff_byte(&ctx->dec_key[i    
168                                &ctx->dec_key[i    
169                 aria_diff_word(&ctx->dec_key[i    
170                                &ctx->dec_key[i    
171         }                                         
172 }                                                 
173                                                   
174 int aria_set_key(struct crypto_tfm *tfm, const    
175 {                                                 
176         struct aria_ctx *ctx = crypto_tfm_ctx(    
177                                                   
178         if (key_len != 16 && key_len != 24 &&     
179                 return -EINVAL;                   
180                                                   
181         BUILD_BUG_ON(sizeof(ctx->enc_key) != 2    
182         BUILD_BUG_ON(sizeof(ctx->dec_key) != 2    
183         BUILD_BUG_ON(sizeof(int) != sizeof(ctx    
184                                                   
185         ctx->key_length = key_len;                
186         ctx->rounds = (key_len + 32) / 4;         
187                                                   
188         aria_set_encrypt_key(ctx, in_key, key_    
189         aria_set_decrypt_key(ctx);                
190                                                   
191         return 0;                                 
192 }                                                 
193 EXPORT_SYMBOL_GPL(aria_set_key);                  
194                                                   
195 static void __aria_crypt(struct aria_ctx *ctx,    
196                          u32 key[][ARIA_RD_KEY    
197 {                                                 
198         const __be32 *src = (const __be32 *)in    
199         __be32 *dst = (__be32 *)out;              
200         u32 reg0, reg1, reg2, reg3;               
201         int rounds, rkidx = 0;                    
202                                                   
203         rounds = ctx->rounds;                     
204                                                   
205         reg0 = be32_to_cpu(src[0]);               
206         reg1 = be32_to_cpu(src[1]);               
207         reg2 = be32_to_cpu(src[2]);               
208         reg3 = be32_to_cpu(src[3]);               
209                                                   
210         aria_add_round_key(key[rkidx], &reg0,     
211         rkidx++;                                  
212                                                   
213         aria_subst_diff_odd(&reg0, &reg1, &reg    
214         aria_add_round_key(key[rkidx], &reg0,     
215         rkidx++;                                  
216                                                   
217         while ((rounds -= 2) > 0) {               
218                 aria_subst_diff_even(&reg0, &r    
219                 aria_add_round_key(key[rkidx],    
220                 rkidx++;                          
221                                                   
222                 aria_subst_diff_odd(&reg0, &re    
223                 aria_add_round_key(key[rkidx],    
224                 rkidx++;                          
225         }                                         
226                                                   
227         reg0 = key[rkidx][0] ^ make_u32((u8)(x    
228                                         (u8)(x    
229                                         (u8)(s    
230                                         (u8)(s    
231         reg1 = key[rkidx][1] ^ make_u32((u8)(x    
232                                         (u8)(x    
233                                         (u8)(s    
234                                         (u8)(s    
235         reg2 = key[rkidx][2] ^ make_u32((u8)(x    
236                                         (u8)(x    
237                                         (u8)(s    
238                                         (u8)(s    
239         reg3 = key[rkidx][3] ^ make_u32((u8)(x    
240                                         (u8)(x    
241                                         (u8)(s    
242                                         (u8)(s    
243                                                   
244         dst[0] = cpu_to_be32(reg0);               
245         dst[1] = cpu_to_be32(reg1);               
246         dst[2] = cpu_to_be32(reg2);               
247         dst[3] = cpu_to_be32(reg3);               
248 }                                                 
249                                                   
250 void aria_encrypt(void *_ctx, u8 *out, const u    
251 {                                                 
252         struct aria_ctx *ctx = (struct aria_ct    
253                                                   
254         __aria_crypt(ctx, out, in, ctx->enc_ke    
255 }                                                 
256 EXPORT_SYMBOL_GPL(aria_encrypt);                  
257                                                   
258 void aria_decrypt(void *_ctx, u8 *out, const u    
259 {                                                 
260         struct aria_ctx *ctx = (struct aria_ct    
261                                                   
262         __aria_crypt(ctx, out, in, ctx->dec_ke    
263 }                                                 
264 EXPORT_SYMBOL_GPL(aria_decrypt);                  
265                                                   
266 static void __aria_encrypt(struct crypto_tfm *    
267 {                                                 
268         struct aria_ctx *ctx = crypto_tfm_ctx(    
269                                                   
270         __aria_crypt(ctx, out, in, ctx->enc_ke    
271 }                                                 
272                                                   
273 static void __aria_decrypt(struct crypto_tfm *    
274 {                                                 
275         struct aria_ctx *ctx = crypto_tfm_ctx(    
276                                                   
277         __aria_crypt(ctx, out, in, ctx->dec_ke    
278 }                                                 
279                                                   
280 static struct crypto_alg aria_alg = {             
281         .cra_name               =       "aria"    
282         .cra_driver_name        =       "aria-    
283         .cra_priority           =       100,      
284         .cra_flags              =       CRYPTO    
285         .cra_blocksize          =       ARIA_B    
286         .cra_ctxsize            =       sizeof    
287         .cra_alignmask          =       3,        
288         .cra_module             =       THIS_M    
289         .cra_u                  =       {         
290                 .cipher = {                       
291                         .cia_min_keysize          
292                         .cia_max_keysize          
293                         .cia_setkey               
294                         .cia_encrypt              
295                         .cia_decrypt              
296                 }                                 
297         }                                         
298 };                                                
299                                                   
300 static int __init aria_init(void)                 
301 {                                                 
302         return crypto_register_alg(&aria_alg);    
303 }                                                 
304                                                   
305 static void __exit aria_fini(void)                
306 {                                                 
307         crypto_unregister_alg(&aria_alg);         
308 }                                                 
309                                                   
310 subsys_initcall(aria_init);                       
311 module_exit(aria_fini);                           
312                                                   
313 MODULE_DESCRIPTION("ARIA Cipher Algorithm");      
314 MODULE_LICENSE("GPL");                            
315 MODULE_AUTHOR("Taehee Yoo <ap420073@gmail.com>    
316 MODULE_ALIAS_CRYPTO("aria");                      
317 MODULE_ALIAS_CRYPTO("aria-generic");              
318                                                   

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php