Hold private lock while handling digits
[asterisk/asterisk.git] / aeskey.c
1 /*
2  ---------------------------------------------------------------------------
3  Copyright (c) 2003, Dr Brian Gladman <brg@gladman.me.uk>, Worcester, UK.
4  All rights reserved.
5
6  LICENSE TERMS
7
8  The free distribution and use of this software in both source and binary
9  form is allowed (with or without changes) provided that:
10
11    1. distributions of this source code include the above copyright
12       notice, this list of conditions and the following disclaimer;
13
14    2. distributions in binary form include the above copyright
15       notice, this list of conditions and the following disclaimer
16       in the documentation and/or other associated materials;
17
18    3. the copyright holder's name is not used to endorse products
19       built using this software without specific written permission.
20
21  ALTERNATIVELY, provided that this notice is retained in full, this product
22  may be distributed under the terms of the GNU General Public License (GPL),
23  in which case the provisions of the GPL apply INSTEAD OF those given above.
24
25  DISCLAIMER
26
27  This software is provided 'as is' with no explicit or implied warranties
28  in respect of its properties, including, but not limited to, correctness
29  and/or fitness for purpose.
30  ---------------------------------------------------------------------------
31  Issue Date: 26/08/2003
32
33  This file contains the code for implementing the key schedule for AES
34  (Rijndael) for block and key sizes of 16, 24, and 32 bytes. See aesopt.h
35  for further details including optimisation.
36 */
37
38 #include "aesopt.h"
39
40 #if defined(__cplusplus)
41 extern "C"
42 {
43 #endif
44
45 /* Initialise the key schedule from the user supplied key. The key
46    length can be specified in bytes, with legal values of 16, 24
47    and 32, or in bits, with legal values of 128, 192 and 256. These
48    values correspond with Nk values of 4, 6 and 8 respectively.
49
50    The following macros implement a single cycle in the key
51    schedule generation process. The number of cycles needed
52    for each cx->n_col and nk value is:
53
54     nk =             4  5  6  7  8
55     ------------------------------
56     cx->n_col = 4   10  9  8  7  7
57     cx->n_col = 5   14 11 10  9  9
58     cx->n_col = 6   19 15 12 11 11
59     cx->n_col = 7   21 19 16 13 14
60     cx->n_col = 8   29 23 19 17 14
61 */
62
63 #define ke4(k,i) \
64 {   k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+5] = ss[1] ^= ss[0]; \
65     k[4*(i)+6] = ss[2] ^= ss[1]; k[4*(i)+7] = ss[3] ^= ss[2]; \
66 }
67 #define kel4(k,i) \
68 {   k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+5] = ss[1] ^= ss[0]; \
69     k[4*(i)+6] = ss[2] ^= ss[1]; k[4*(i)+7] = ss[3] ^= ss[2]; \
70 }
71
72 #define ke6(k,i) \
73 {   k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 7] = ss[1] ^= ss[0]; \
74     k[6*(i)+ 8] = ss[2] ^= ss[1]; k[6*(i)+ 9] = ss[3] ^= ss[2]; \
75     k[6*(i)+10] = ss[4] ^= ss[3]; k[6*(i)+11] = ss[5] ^= ss[4]; \
76 }
77 #define kel6(k,i) \
78 {   k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 7] = ss[1] ^= ss[0]; \
79     k[6*(i)+ 8] = ss[2] ^= ss[1]; k[6*(i)+ 9] = ss[3] ^= ss[2]; \
80 }
81
82 #define ke8(k,i) \
83 {   k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 9] = ss[1] ^= ss[0]; \
84     k[8*(i)+10] = ss[2] ^= ss[1]; k[8*(i)+11] = ss[3] ^= ss[2]; \
85     k[8*(i)+12] = ss[4] ^= ls_box(ss[3],0); k[8*(i)+13] = ss[5] ^= ss[4]; \
86     k[8*(i)+14] = ss[6] ^= ss[5]; k[8*(i)+15] = ss[7] ^= ss[6]; \
87 }
88 #define kel8(k,i) \
89 {   k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 9] = ss[1] ^= ss[0]; \
90     k[8*(i)+10] = ss[2] ^= ss[1]; k[8*(i)+11] = ss[3] ^= ss[2]; \
91 }
92
93 #if defined(ENCRYPTION_KEY_SCHEDULE)
94
95 #if defined(AES_128) || defined(AES_VAR)
96
97 aes_rval aes_encrypt_key128(const void *in_key, aes_encrypt_ctx cx[1])
98 {   aes_32t    ss[4];
99
100     cx->ks[0] = ss[0] = word_in(in_key, 0);
101     cx->ks[1] = ss[1] = word_in(in_key, 1);
102     cx->ks[2] = ss[2] = word_in(in_key, 2);
103     cx->ks[3] = ss[3] = word_in(in_key, 3);
104
105 #if ENC_UNROLL == NONE
106     {   aes_32t i;
107
108         for(i = 0; i < ((11 * N_COLS - 1) / 4); ++i)
109             ke4(cx->ks, i);
110     }
111 #else
112     ke4(cx->ks, 0);  ke4(cx->ks, 1);
113     ke4(cx->ks, 2);  ke4(cx->ks, 3);
114     ke4(cx->ks, 4);  ke4(cx->ks, 5);
115     ke4(cx->ks, 6);  ke4(cx->ks, 7);
116     ke4(cx->ks, 8); kel4(cx->ks, 9);
117 #endif
118
119     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
120     /* key and must be non-zero for 128 and 192 bits keys   */
121     cx->ks[53] = cx->ks[45] = 0;
122     cx->ks[52] = 10;
123 #ifdef AES_ERR_CHK
124     return aes_good;
125 #endif
126 }
127
128 #endif
129
130 #if defined(AES_192) || defined(AES_VAR)
131
132 aes_rval aes_encrypt_key192(const void *in_key, aes_encrypt_ctx cx[1])
133 {   aes_32t    ss[6];
134
135     cx->ks[0] = ss[0] = word_in(in_key, 0);
136     cx->ks[1] = ss[1] = word_in(in_key, 1);
137     cx->ks[2] = ss[2] = word_in(in_key, 2);
138     cx->ks[3] = ss[3] = word_in(in_key, 3);
139     cx->ks[4] = ss[4] = word_in(in_key, 4);
140     cx->ks[5] = ss[5] = word_in(in_key, 5);
141
142 #if ENC_UNROLL == NONE
143     {   aes_32t i;
144
145         for(i = 0; i < (13 * N_COLS - 1) / 6; ++i)
146             ke6(cx->ks, i);
147     }
148 #else
149     ke6(cx->ks, 0);  ke6(cx->ks, 1);
150     ke6(cx->ks, 2);  ke6(cx->ks, 3);
151     ke6(cx->ks, 4);  ke6(cx->ks, 5);
152     ke6(cx->ks, 6); kel6(cx->ks, 7);
153 #endif
154
155     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
156     /* key and must be non-zero for 128 and 192 bits keys   */
157     cx->ks[53] = cx->ks[45];
158     cx->ks[52] = 12;
159 #ifdef AES_ERR_CHK
160     return aes_good;
161 #endif
162 }
163
164 #endif
165
166 #if defined(AES_256) || defined(AES_VAR)
167
168 aes_rval aes_encrypt_key256(const void *in_key, aes_encrypt_ctx cx[1])
169 {   aes_32t    ss[8];
170
171     cx->ks[0] = ss[0] = word_in(in_key, 0);
172     cx->ks[1] = ss[1] = word_in(in_key, 1);
173     cx->ks[2] = ss[2] = word_in(in_key, 2);
174     cx->ks[3] = ss[3] = word_in(in_key, 3);
175     cx->ks[4] = ss[4] = word_in(in_key, 4);
176     cx->ks[5] = ss[5] = word_in(in_key, 5);
177     cx->ks[6] = ss[6] = word_in(in_key, 6);
178     cx->ks[7] = ss[7] = word_in(in_key, 7);
179
180 #if ENC_UNROLL == NONE
181     {   aes_32t i;
182
183         for(i = 0; i < (15 * N_COLS - 1) / 8; ++i)
184             ke8(cx->ks,  i);
185     }
186 #else
187     ke8(cx->ks, 0); ke8(cx->ks, 1);
188     ke8(cx->ks, 2); ke8(cx->ks, 3);
189     ke8(cx->ks, 4); ke8(cx->ks, 5);
190     kel8(cx->ks, 6);
191 #endif
192 #ifdef AES_ERR_CHK
193     return aes_good;
194 #endif
195 }
196
197 #endif
198
199 #if defined(AES_VAR)
200
201 aes_rval aes_encrypt_key(const void *in_key, int key_len, aes_encrypt_ctx cx[1])
202 {
203     switch(key_len)
204     {
205 #ifdef AES_ERR_CHK
206     case 16: case 128: return aes_encrypt_key128(in_key, cx);
207     case 24: case 192: return aes_encrypt_key192(in_key, cx);
208     case 32: case 256: return aes_encrypt_key256(in_key, cx);
209     default: return aes_error;
210 #else
211     case 16: case 128: aes_encrypt_key128(in_key, cx); return;
212     case 24: case 192: aes_encrypt_key192(in_key, cx); return;
213     case 32: case 256: aes_encrypt_key256(in_key, cx); return;
214 #endif
215     }
216 }
217
218 #endif
219
220 #endif
221
222 #if defined(DECRYPTION_KEY_SCHEDULE)
223
224 #if DEC_ROUND == NO_TABLES
225 #define ff(x)   (x)
226 #else
227 #define ff(x)   inv_mcol(x)
228 #ifdef  dec_imvars
229 #define d_vars  dec_imvars
230 #endif
231 #endif
232
233 #if 1
234 #define kdf4(k,i) \
235 {   ss[0] = ss[0] ^ ss[2] ^ ss[1] ^ ss[3]; ss[1] = ss[1] ^ ss[3]; ss[2] = ss[2] ^ ss[3]; ss[3] = ss[3]; \
236     ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; \
237     ss[4] ^= k[4*(i)];   k[4*(i)+4] = ff(ss[4]); ss[4] ^= k[4*(i)+1]; k[4*(i)+5] = ff(ss[4]); \
238     ss[4] ^= k[4*(i)+2]; k[4*(i)+6] = ff(ss[4]); ss[4] ^= k[4*(i)+3]; k[4*(i)+7] = ff(ss[4]); \
239 }
240 #define kd4(k,i) \
241 {   ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; ss[4] = ff(ss[4]); \
242     k[4*(i)+4] = ss[4] ^= k[4*(i)]; k[4*(i)+5] = ss[4] ^= k[4*(i)+1]; \
243     k[4*(i)+6] = ss[4] ^= k[4*(i)+2]; k[4*(i)+7] = ss[4] ^= k[4*(i)+3]; \
244 }
245 #define kdl4(k,i) \
246 {   ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; \
247     k[4*(i)+4] = (ss[0] ^= ss[1]) ^ ss[2] ^ ss[3]; k[4*(i)+5] = ss[1] ^ ss[3]; \
248     k[4*(i)+6] = ss[0]; k[4*(i)+7] = ss[1]; \
249 }
250 #else
251 #define kdf4(k,i) \
252 {   ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+ 4] = ff(ss[0]); ss[1] ^= ss[0]; k[4*(i)+ 5] = ff(ss[1]); \
253     ss[2] ^= ss[1]; k[4*(i)+ 6] = ff(ss[2]); ss[3] ^= ss[2]; k[4*(i)+ 7] = ff(ss[3]); \
254 }
255 #define kd4(k,i) \
256 {   ss[4] = ls_box(ss[3],3) ^ t_use(r,c)[i]; \
257     ss[0] ^= ss[4]; ss[4] = ff(ss[4]); k[4*(i)+ 4] = ss[4] ^= k[4*(i)]; \
258     ss[1] ^= ss[0]; k[4*(i)+ 5] = ss[4] ^= k[4*(i)+ 1]; \
259     ss[2] ^= ss[1]; k[4*(i)+ 6] = ss[4] ^= k[4*(i)+ 2]; \
260     ss[3] ^= ss[2]; k[4*(i)+ 7] = ss[4] ^= k[4*(i)+ 3]; \
261 }
262 #define kdl4(k,i) \
263 {   ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+ 4] = ss[0]; ss[1] ^= ss[0]; k[4*(i)+ 5] = ss[1]; \
264     ss[2] ^= ss[1]; k[4*(i)+ 6] = ss[2]; ss[3] ^= ss[2]; k[4*(i)+ 7] = ss[3]; \
265 }
266 #endif
267
268 #define kdf6(k,i) \
269 {   ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 6] = ff(ss[0]); ss[1] ^= ss[0]; k[6*(i)+ 7] = ff(ss[1]); \
270     ss[2] ^= ss[1]; k[6*(i)+ 8] = ff(ss[2]); ss[3] ^= ss[2]; k[6*(i)+ 9] = ff(ss[3]); \
271     ss[4] ^= ss[3]; k[6*(i)+10] = ff(ss[4]); ss[5] ^= ss[4]; k[6*(i)+11] = ff(ss[5]); \
272 }
273 #define kd6(k,i) \
274 {   ss[6] = ls_box(ss[5],3) ^ t_use(r,c)[i]; \
275     ss[0] ^= ss[6]; ss[6] = ff(ss[6]); k[6*(i)+ 6] = ss[6] ^= k[6*(i)]; \
276     ss[1] ^= ss[0]; k[6*(i)+ 7] = ss[6] ^= k[6*(i)+ 1]; \
277     ss[2] ^= ss[1]; k[6*(i)+ 8] = ss[6] ^= k[6*(i)+ 2]; \
278     ss[3] ^= ss[2]; k[6*(i)+ 9] = ss[6] ^= k[6*(i)+ 3]; \
279     ss[4] ^= ss[3]; k[6*(i)+10] = ss[6] ^= k[6*(i)+ 4]; \
280     ss[5] ^= ss[4]; k[6*(i)+11] = ss[6] ^= k[6*(i)+ 5]; \
281 }
282 #define kdl6(k,i) \
283 {   ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 6] = ss[0]; ss[1] ^= ss[0]; k[6*(i)+ 7] = ss[1]; \
284     ss[2] ^= ss[1]; k[6*(i)+ 8] = ss[2]; ss[3] ^= ss[2]; k[6*(i)+ 9] = ss[3]; \
285 }
286
287 #define kdf8(k,i) \
288 {   ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 8] = ff(ss[0]); ss[1] ^= ss[0]; k[8*(i)+ 9] = ff(ss[1]); \
289     ss[2] ^= ss[1]; k[8*(i)+10] = ff(ss[2]); ss[3] ^= ss[2]; k[8*(i)+11] = ff(ss[3]); \
290     ss[4] ^= ls_box(ss[3],0); k[8*(i)+12] = ff(ss[4]); ss[5] ^= ss[4]; k[8*(i)+13] = ff(ss[5]); \
291     ss[6] ^= ss[5]; k[8*(i)+14] = ff(ss[6]); ss[7] ^= ss[6]; k[8*(i)+15] = ff(ss[7]); \
292 }
293 #define kd8(k,i) \
294 {   aes_32t g = ls_box(ss[7],3) ^ t_use(r,c)[i]; \
295     ss[0] ^= g; g = ff(g); k[8*(i)+ 8] = g ^= k[8*(i)]; \
296     ss[1] ^= ss[0]; k[8*(i)+ 9] = g ^= k[8*(i)+ 1]; \
297     ss[2] ^= ss[1]; k[8*(i)+10] = g ^= k[8*(i)+ 2]; \
298     ss[3] ^= ss[2]; k[8*(i)+11] = g ^= k[8*(i)+ 3]; \
299     g = ls_box(ss[3],0); \
300     ss[4] ^= g; g = ff(g); k[8*(i)+12] = g ^= k[8*(i)+ 4]; \
301     ss[5] ^= ss[4]; k[8*(i)+13] = g ^= k[8*(i)+ 5]; \
302     ss[6] ^= ss[5]; k[8*(i)+14] = g ^= k[8*(i)+ 6]; \
303     ss[7] ^= ss[6]; k[8*(i)+15] = g ^= k[8*(i)+ 7]; \
304 }
305 #define kdl8(k,i) \
306 {   ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 8] = ss[0]; ss[1] ^= ss[0]; k[8*(i)+ 9] = ss[1]; \
307     ss[2] ^= ss[1]; k[8*(i)+10] = ss[2]; ss[3] ^= ss[2]; k[8*(i)+11] = ss[3]; \
308 }
309
310 #if defined(AES_128) || defined(AES_VAR)
311
312 aes_rval aes_decrypt_key128(const void *in_key, aes_decrypt_ctx cx[1])
313 {   aes_32t    ss[5];
314 #ifdef  d_vars
315         d_vars;
316 #endif
317     cx->ks[0] = ss[0] = word_in(in_key, 0);
318     cx->ks[1] = ss[1] = word_in(in_key, 1);
319     cx->ks[2] = ss[2] = word_in(in_key, 2);
320     cx->ks[3] = ss[3] = word_in(in_key, 3);
321
322 #if DEC_UNROLL == NONE
323     {   aes_32t i;
324
325         for(i = 0; i < (11 * N_COLS - 1) / 4; ++i)
326             ke4(cx->ks, i);
327 #if !(DEC_ROUND == NO_TABLES)
328         for(i = N_COLS; i < 10 * N_COLS; ++i)
329             cx->ks[i] = inv_mcol(cx->ks[i]);
330 #endif
331     }
332 #else
333     kdf4(cx->ks, 0);  kd4(cx->ks, 1);
334      kd4(cx->ks, 2);  kd4(cx->ks, 3);
335      kd4(cx->ks, 4);  kd4(cx->ks, 5);
336      kd4(cx->ks, 6);  kd4(cx->ks, 7);
337      kd4(cx->ks, 8); kdl4(cx->ks, 9);
338 #endif
339
340     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
341     /* key and must be non-zero for 128 and 192 bits keys   */
342     cx->ks[53] = cx->ks[45] = 0;
343     cx->ks[52] = 10;
344 #ifdef AES_ERR_CHK
345     return aes_good;
346 #endif
347 }
348
349 #endif
350
351 #if defined(AES_192) || defined(AES_VAR)
352
353 aes_rval aes_decrypt_key192(const void *in_key, aes_decrypt_ctx cx[1])
354 {   aes_32t    ss[7];
355 #ifdef  d_vars
356         d_vars;
357 #endif
358     cx->ks[0] = ss[0] = word_in(in_key, 0);
359     cx->ks[1] = ss[1] = word_in(in_key, 1);
360     cx->ks[2] = ss[2] = word_in(in_key, 2);
361     cx->ks[3] = ss[3] = word_in(in_key, 3);
362
363 #if DEC_UNROLL == NONE
364     cx->ks[4] = ss[4] = word_in(in_key, 4);
365     cx->ks[5] = ss[5] = word_in(in_key, 5);
366     {   aes_32t i;
367
368         for(i = 0; i < (13 * N_COLS - 1) / 6; ++i)
369             ke6(cx->ks, i);
370 #if !(DEC_ROUND == NO_TABLES)
371         for(i = N_COLS; i < 12 * N_COLS; ++i)
372             cx->ks[i] = inv_mcol(cx->ks[i]);
373 #endif
374     }
375 #else
376     cx->ks[4] = ff(ss[4] = word_in(in_key, 4));
377     cx->ks[5] = ff(ss[5] = word_in(in_key, 5));
378     kdf6(cx->ks, 0); kd6(cx->ks, 1);
379     kd6(cx->ks, 2);  kd6(cx->ks, 3);
380     kd6(cx->ks, 4);  kd6(cx->ks, 5);
381     kd6(cx->ks, 6); kdl6(cx->ks, 7);
382 #endif
383
384     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
385     /* key and must be non-zero for 128 and 192 bits keys   */
386     cx->ks[53] = cx->ks[45];
387     cx->ks[52] = 12;
388 #ifdef AES_ERR_CHK
389     return aes_good;
390 #endif
391 }
392
393 #endif
394
395 #if defined(AES_256) || defined(AES_VAR)
396
397 aes_rval aes_decrypt_key256(const void *in_key, aes_decrypt_ctx cx[1])
398 {   aes_32t    ss[8];
399 #ifdef  d_vars
400         d_vars;
401 #endif
402     cx->ks[0] = ss[0] = word_in(in_key, 0);
403     cx->ks[1] = ss[1] = word_in(in_key, 1);
404     cx->ks[2] = ss[2] = word_in(in_key, 2);
405     cx->ks[3] = ss[3] = word_in(in_key, 3);
406
407 #if DEC_UNROLL == NONE
408     cx->ks[4] = ss[4] = word_in(in_key, 4);
409     cx->ks[5] = ss[5] = word_in(in_key, 5);
410     cx->ks[6] = ss[6] = word_in(in_key, 6);
411     cx->ks[7] = ss[7] = word_in(in_key, 7);
412     {   aes_32t i;
413
414         for(i = 0; i < (15 * N_COLS - 1) / 8; ++i)
415             ke8(cx->ks,  i);
416 #if !(DEC_ROUND == NO_TABLES)
417         for(i = N_COLS; i < 14 * N_COLS; ++i)
418             cx->ks[i] = inv_mcol(cx->ks[i]);
419 #endif
420     }
421 #else
422     cx->ks[4] = ff(ss[4] = word_in(in_key, 4));
423     cx->ks[5] = ff(ss[5] = word_in(in_key, 5));
424     cx->ks[6] = ff(ss[6] = word_in(in_key, 6));
425     cx->ks[7] = ff(ss[7] = word_in(in_key, 7));
426     kdf8(cx->ks, 0); kd8(cx->ks, 1);
427     kd8(cx->ks, 2);  kd8(cx->ks, 3);
428     kd8(cx->ks, 4);  kd8(cx->ks, 5);
429     kdl8(cx->ks, 6);
430 #endif
431 #ifdef AES_ERR_CHK
432     return aes_good;
433 #endif
434 }
435
436 #endif
437
438 #if defined(AES_VAR)
439
440 aes_rval aes_decrypt_key(const void *in_key, int key_len, aes_decrypt_ctx cx[1])
441 {
442     switch(key_len)
443     {
444 #ifdef AES_ERR_CHK
445     case 16: case 128: return aes_decrypt_key128(in_key, cx);
446     case 24: case 192: return aes_decrypt_key192(in_key, cx);
447     case 32: case 256: return aes_decrypt_key256(in_key, cx);
448     default: return aes_error;
449 #else
450     case 16: case 128: aes_decrypt_key128(in_key, cx); return;
451     case 24: case 192: aes_decrypt_key192(in_key, cx); return;
452     case 32: case 256: aes_decrypt_key256(in_key, cx); return;
453 #endif
454     }
455 }
456
457 #endif
458
459 #endif
460
461 #if defined(__cplusplus)
462 }
463 #endif