Use correct blocksize of 32 bytes for GOSTR3411-94 HMAC
[libgcrypt.git] / cipher / salsa20.c
1 /* salsa20.c  -  Bernstein's Salsa20 cipher
2  * Copyright (C) 2012 Simon Josefsson, Niels Möller
3  * Copyright (C) 2013 g10 Code GmbH
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser general Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  *
20  * For a description of the algorithm, see:
21  *   http://cr.yp.to/snuffle/spec.pdf
22  *   http://cr.yp.to/snuffle/design.pdf
23  */
24
25 /* The code is based on the code in Nettle
26    (git commit id 9d2d8ddaee35b91a4e1a32ae77cba04bea3480e7)
27    which in turn is based on
28    salsa20-ref.c version 20051118
29    D. J. Bernstein
30    Public domain.
31 */
32
33
34 #include <config.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include "types.h"
39 #include "g10lib.h"
40 #include "cipher.h"
41 #include "bufhelp.h"
42
43
44 /* USE_AMD64 indicates whether to compile with AMD64 code. */
45 #undef USE_AMD64
46 #if defined(__x86_64__) && defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS)
47 # define USE_AMD64 1
48 #endif
49
50 /* USE_ARM_NEON_ASM indicates whether to enable ARM NEON assembly code. */
51 #undef USE_ARM_NEON_ASM
52 #if defined(HAVE_ARM_ARCH_V6) && defined(__ARMEL__)
53 # if defined(HAVE_COMPATIBLE_GCC_ARM_PLATFORM_AS) && \
54      defined(HAVE_GCC_INLINE_ASM_NEON)
55 #  define USE_ARM_NEON_ASM 1
56 # endif
57 #endif
58
59
60 #define SALSA20_MIN_KEY_SIZE 16  /* Bytes.  */
61 #define SALSA20_MAX_KEY_SIZE 32  /* Bytes.  */
62 #define SALSA20_BLOCK_SIZE   64  /* Bytes.  */
63 #define SALSA20_IV_SIZE       8  /* Bytes.  */
64 #define SALSA20_INPUT_LENGTH 16  /* Bytes.  */
65
66 /* Number of rounds.  The standard uses 20 rounds.  In any case the
67    number of rounds must be even.  */
68 #define SALSA20_ROUNDS       20
69 #define SALSA20R12_ROUNDS    12
70
71
72 struct SALSA20_context_s;
73
74 typedef unsigned int (*salsa20_core_t) (u32 *dst, struct SALSA20_context_s *ctx,
75                                         unsigned int rounds);
76 typedef void (* salsa20_keysetup_t)(struct SALSA20_context_s *ctx,
77                                     const byte *key, int keylen);
78 typedef void (* salsa20_ivsetup_t)(struct SALSA20_context_s *ctx,
79                                    const byte *iv);
80
81 typedef struct SALSA20_context_s
82 {
83   /* Indices 1-4 and 11-14 holds the key (two identical copies for the
84      shorter key size), indices 0, 5, 10, 15 are constant, indices 6, 7
85      are the IV, and indices 8, 9 are the block counter:
86
87      C K K K
88      K C I I
89      B B C K
90      K K K C
91   */
92   u32 input[SALSA20_INPUT_LENGTH];
93   u32 pad[SALSA20_INPUT_LENGTH];
94   unsigned int unused; /* bytes in the pad.  */
95 #ifdef USE_ARM_NEON_ASM
96   int use_neon;
97 #endif
98   salsa20_keysetup_t keysetup;
99   salsa20_ivsetup_t ivsetup;
100   salsa20_core_t core;
101 } SALSA20_context_t;
102
103
104 /* The masking of the right shift is needed to allow n == 0 (using
105    just 32 - n and 64 - n results in undefined behaviour). Most uses
106    of these macros use a constant and non-zero rotation count. */
107 #define ROTL32(n,x) (((x)<<(n)) | ((x)>>((-(n)&31))))
108
109
110 #define LE_SWAP32(v) le_bswap32(v)
111
112 #define LE_READ_UINT32(p) buf_get_le32(p)
113
114
115 static void salsa20_setiv (void *context, const byte *iv, size_t ivlen);
116 static const char *selftest (void);
117
118
119 #ifdef USE_AMD64
120 /* AMD64 assembly implementations of Salsa20. */
121 void _gcry_salsa20_amd64_keysetup(u32 *ctxinput, const void *key, int keybits);
122 void _gcry_salsa20_amd64_ivsetup(u32 *ctxinput, const void *iv);
123 unsigned int
124 _gcry_salsa20_amd64_encrypt_blocks(u32 *ctxinput, const void *src, void *dst,
125                                    size_t len, int rounds);
126
127 static void
128 salsa20_keysetup(SALSA20_context_t *ctx, const byte *key, int keylen)
129 {
130   _gcry_salsa20_amd64_keysetup(ctx->input, key, keylen * 8);
131 }
132
133 static void
134 salsa20_ivsetup(SALSA20_context_t *ctx, const byte *iv)
135 {
136   _gcry_salsa20_amd64_ivsetup(ctx->input, iv);
137 }
138
139 static unsigned int
140 salsa20_core (u32 *dst, SALSA20_context_t *ctx, unsigned int rounds)
141 {
142   memset(dst, 0, SALSA20_BLOCK_SIZE);
143   return _gcry_salsa20_amd64_encrypt_blocks(ctx->input, dst, dst, 1, rounds);
144 }
145
146 #else /* USE_AMD64 */
147
148 \f
149
150 #if 0
151 # define SALSA20_CORE_DEBUG(i) do {             \
152     unsigned debug_j;                           \
153     for (debug_j = 0; debug_j < 16; debug_j++)  \
154       {                                         \
155         if (debug_j == 0)                       \
156           fprintf(stderr, "%2d:", (i));         \
157         else if (debug_j % 4 == 0)              \
158           fprintf(stderr, "\n   ");             \
159         fprintf(stderr, " %8x", pad[debug_j]);  \
160       }                                         \
161     fprintf(stderr, "\n");                      \
162   } while (0)
163 #else
164 # define SALSA20_CORE_DEBUG(i)
165 #endif
166
167 #define QROUND(x0, x1, x2, x3)      \
168   do {                              \
169     x1 ^= ROTL32 ( 7, x0 + x3);     \
170     x2 ^= ROTL32 ( 9, x1 + x0);     \
171     x3 ^= ROTL32 (13, x2 + x1);     \
172     x0 ^= ROTL32 (18, x3 + x2);     \
173   } while(0)
174
175 static unsigned int
176 salsa20_core (u32 *dst, SALSA20_context_t *ctx, unsigned rounds)
177 {
178   u32 pad[SALSA20_INPUT_LENGTH], *src = ctx->input;
179   unsigned int i;
180
181   memcpy (pad, src, sizeof(pad));
182   for (i = 0; i < rounds; i += 2)
183     {
184       SALSA20_CORE_DEBUG (i);
185       QROUND (pad[0],  pad[4],  pad[8],  pad[12]);
186       QROUND (pad[5],  pad[9],  pad[13], pad[1] );
187       QROUND (pad[10], pad[14], pad[2],  pad[6] );
188       QROUND (pad[15], pad[3],  pad[7],  pad[11]);
189
190       SALSA20_CORE_DEBUG (i+1);
191       QROUND (pad[0],  pad[1],  pad[2],  pad[3] );
192       QROUND (pad[5],  pad[6],  pad[7],  pad[4] );
193       QROUND (pad[10], pad[11], pad[8],  pad[9] );
194       QROUND (pad[15], pad[12], pad[13], pad[14]);
195     }
196   SALSA20_CORE_DEBUG (i);
197
198   for (i = 0; i < SALSA20_INPUT_LENGTH; i++)
199     {
200       u32 t = pad[i] + src[i];
201       dst[i] = LE_SWAP32 (t);
202     }
203
204   /* Update counter. */
205   if (!++src[8])
206     src[9]++;
207
208   /* burn_stack */
209   return ( 3*sizeof (void*) \
210          + 2*sizeof (void*) \
211          + 64 \
212          + sizeof (unsigned int) \
213          + sizeof (u32) );
214 }
215 #undef QROUND
216 #undef SALSA20_CORE_DEBUG
217
218 static void
219 salsa20_keysetup(SALSA20_context_t *ctx, const byte *key, int keylen)
220 {
221   /* These constants are the little endian encoding of the string
222      "expand 32-byte k".  For the 128 bit variant, the "32" in that
223      string will be fixed up to "16".  */
224   ctx->input[0]  = 0x61707865; /* "apxe"  */
225   ctx->input[5]  = 0x3320646e; /* "3 dn"  */
226   ctx->input[10] = 0x79622d32; /* "yb-2"  */
227   ctx->input[15] = 0x6b206574; /* "k et"  */
228
229   ctx->input[1] = LE_READ_UINT32(key + 0);
230   ctx->input[2] = LE_READ_UINT32(key + 4);
231   ctx->input[3] = LE_READ_UINT32(key + 8);
232   ctx->input[4] = LE_READ_UINT32(key + 12);
233   if (keylen == SALSA20_MAX_KEY_SIZE) /* 256 bits */
234     {
235       ctx->input[11] = LE_READ_UINT32(key + 16);
236       ctx->input[12] = LE_READ_UINT32(key + 20);
237       ctx->input[13] = LE_READ_UINT32(key + 24);
238       ctx->input[14] = LE_READ_UINT32(key + 28);
239     }
240   else  /* 128 bits */
241     {
242       ctx->input[11] = ctx->input[1];
243       ctx->input[12] = ctx->input[2];
244       ctx->input[13] = ctx->input[3];
245       ctx->input[14] = ctx->input[4];
246
247       ctx->input[5]  -= 0x02000000; /* Change to "1 dn".  */
248       ctx->input[10] += 0x00000004; /* Change to "yb-6".  */
249     }
250 }
251
252 static void salsa20_ivsetup(SALSA20_context_t *ctx, const byte *iv)
253 {
254   ctx->input[6] = LE_READ_UINT32(iv + 0);
255   ctx->input[7] = LE_READ_UINT32(iv + 4);
256   /* Reset the block counter.  */
257   ctx->input[8] = 0;
258   ctx->input[9] = 0;
259 }
260
261 #endif /*!USE_AMD64*/
262
263 #ifdef USE_ARM_NEON_ASM
264
265 /* ARM NEON implementation of Salsa20. */
266 unsigned int
267 _gcry_arm_neon_salsa20_encrypt(void *c, const void *m, unsigned int nblks,
268                                void *k, unsigned int rounds);
269
270 static unsigned int
271 salsa20_core_neon (u32 *dst, SALSA20_context_t *ctx, unsigned int rounds)
272 {
273   return _gcry_arm_neon_salsa20_encrypt(dst, NULL, 1, ctx->input, rounds);
274 }
275
276 static void salsa20_ivsetup_neon(SALSA20_context_t *ctx, const byte *iv)
277 {
278   memcpy(ctx->input + 8, iv, 8);
279   /* Reset the block counter.  */
280   memset(ctx->input + 10, 0, 8);
281 }
282
283 static void
284 salsa20_keysetup_neon(SALSA20_context_t *ctx, const byte *key, int klen)
285 {
286   static const unsigned char sigma32[16] = "expand 32-byte k";
287   static const unsigned char sigma16[16] = "expand 16-byte k";
288
289   if (klen == 16)
290     {
291       memcpy (ctx->input, key, 16);
292       memcpy (ctx->input + 4, key, 16); /* Duplicate 128-bit key. */
293       memcpy (ctx->input + 12, sigma16, 16);
294     }
295   else
296     {
297       /* 32-byte key */
298       memcpy (ctx->input, key, 32);
299       memcpy (ctx->input + 12, sigma32, 16);
300     }
301 }
302
303 #endif /*USE_ARM_NEON_ASM*/
304
305
306 static gcry_err_code_t
307 salsa20_do_setkey (SALSA20_context_t *ctx,
308                    const byte *key, unsigned int keylen)
309 {
310   static int initialized;
311   static const char *selftest_failed;
312
313   if (!initialized )
314     {
315       initialized = 1;
316       selftest_failed = selftest ();
317       if (selftest_failed)
318         log_error ("SALSA20 selftest failed (%s)\n", selftest_failed );
319     }
320   if (selftest_failed)
321     return GPG_ERR_SELFTEST_FAILED;
322
323   if (keylen != SALSA20_MIN_KEY_SIZE
324       && keylen != SALSA20_MAX_KEY_SIZE)
325     return GPG_ERR_INV_KEYLEN;
326
327   /* Default ops. */
328   ctx->keysetup = salsa20_keysetup;
329   ctx->ivsetup = salsa20_ivsetup;
330   ctx->core = salsa20_core;
331
332 #ifdef USE_ARM_NEON_ASM
333   ctx->use_neon = (_gcry_get_hw_features () & HWF_ARM_NEON) != 0;
334   if (ctx->use_neon)
335     {
336       /* Use ARM NEON ops instead. */
337       ctx->keysetup = salsa20_keysetup_neon;
338       ctx->ivsetup = salsa20_ivsetup_neon;
339       ctx->core = salsa20_core_neon;
340     }
341 #endif
342
343   ctx->keysetup (ctx, key, keylen);
344
345   /* We default to a zero nonce.  */
346   salsa20_setiv (ctx, NULL, 0);
347
348   return 0;
349 }
350
351
352 static gcry_err_code_t
353 salsa20_setkey (void *context, const byte *key, unsigned int keylen)
354 {
355   SALSA20_context_t *ctx = (SALSA20_context_t *)context;
356   gcry_err_code_t rc = salsa20_do_setkey (ctx, key, keylen);
357   _gcry_burn_stack (4 + sizeof (void *) + 4 * sizeof (void *));
358   return rc;
359 }
360
361
362 static void
363 salsa20_setiv (void *context, const byte *iv, size_t ivlen)
364 {
365   SALSA20_context_t *ctx = (SALSA20_context_t *)context;
366   byte tmp[SALSA20_IV_SIZE];
367
368   if (iv && ivlen != SALSA20_IV_SIZE)
369     log_info ("WARNING: salsa20_setiv: bad ivlen=%u\n", (u32)ivlen);
370
371   if (!iv || ivlen != SALSA20_IV_SIZE)
372     memset (tmp, 0, sizeof(tmp));
373   else
374     memcpy (tmp, iv, SALSA20_IV_SIZE);
375
376   ctx->ivsetup (ctx, tmp);
377
378   /* Reset the unused pad bytes counter.  */
379   ctx->unused = 0;
380
381   wipememory (tmp, sizeof(tmp));
382 }
383
384
385 \f
386 /* Note: This function requires LENGTH > 0.  */
387 static void
388 salsa20_do_encrypt_stream (SALSA20_context_t *ctx,
389                            byte *outbuf, const byte *inbuf,
390                            size_t length, unsigned rounds)
391 {
392   unsigned int nburn, burn = 0;
393
394   if (ctx->unused)
395     {
396       unsigned char *p = (void*)ctx->pad;
397       size_t n;
398
399       gcry_assert (ctx->unused < SALSA20_BLOCK_SIZE);
400
401       n = ctx->unused;
402       if (n > length)
403         n = length;
404       buf_xor (outbuf, inbuf, p + SALSA20_BLOCK_SIZE - ctx->unused, n);
405       length -= n;
406       outbuf += n;
407       inbuf  += n;
408       ctx->unused -= n;
409       if (!length)
410         return;
411       gcry_assert (!ctx->unused);
412     }
413
414 #ifdef USE_AMD64
415   if (length >= SALSA20_BLOCK_SIZE)
416     {
417       size_t nblocks = length / SALSA20_BLOCK_SIZE;
418       burn = _gcry_salsa20_amd64_encrypt_blocks(ctx->input, inbuf, outbuf,
419                                                 nblocks, rounds);
420       length -= SALSA20_BLOCK_SIZE * nblocks;
421       outbuf += SALSA20_BLOCK_SIZE * nblocks;
422       inbuf  += SALSA20_BLOCK_SIZE * nblocks;
423     }
424 #endif
425
426 #ifdef USE_ARM_NEON_ASM
427   if (ctx->use_neon && length >= SALSA20_BLOCK_SIZE)
428     {
429       unsigned int nblocks = length / SALSA20_BLOCK_SIZE;
430       _gcry_arm_neon_salsa20_encrypt (outbuf, inbuf, nblocks, ctx->input,
431                                       rounds);
432       length -= SALSA20_BLOCK_SIZE * nblocks;
433       outbuf += SALSA20_BLOCK_SIZE * nblocks;
434       inbuf  += SALSA20_BLOCK_SIZE * nblocks;
435     }
436 #endif
437
438   while (length > 0)
439     {
440       /* Create the next pad and bump the block counter.  Note that it
441          is the user's duty to change to another nonce not later than
442          after 2^70 processed bytes.  */
443       nburn = ctx->core (ctx->pad, ctx, rounds);
444       burn = nburn > burn ? nburn : burn;
445
446       if (length <= SALSA20_BLOCK_SIZE)
447         {
448           buf_xor (outbuf, inbuf, ctx->pad, length);
449           ctx->unused = SALSA20_BLOCK_SIZE - length;
450           break;
451         }
452       buf_xor (outbuf, inbuf, ctx->pad, SALSA20_BLOCK_SIZE);
453       length -= SALSA20_BLOCK_SIZE;
454       outbuf += SALSA20_BLOCK_SIZE;
455       inbuf  += SALSA20_BLOCK_SIZE;
456     }
457
458   _gcry_burn_stack (burn);
459 }
460
461
462 static void
463 salsa20_encrypt_stream (void *context,
464                         byte *outbuf, const byte *inbuf, size_t length)
465 {
466   SALSA20_context_t *ctx = (SALSA20_context_t *)context;
467
468   if (length)
469     salsa20_do_encrypt_stream (ctx, outbuf, inbuf, length, SALSA20_ROUNDS);
470 }
471
472
473 static void
474 salsa20r12_encrypt_stream (void *context,
475                            byte *outbuf, const byte *inbuf, size_t length)
476 {
477   SALSA20_context_t *ctx = (SALSA20_context_t *)context;
478
479   if (length)
480     salsa20_do_encrypt_stream (ctx, outbuf, inbuf, length, SALSA20R12_ROUNDS);
481 }
482
483
484 static const char*
485 selftest (void)
486 {
487   SALSA20_context_t ctx;
488   byte scratch[8+1];
489   byte buf[256+64+4];
490   int i;
491
492   static byte key_1[] =
493     { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
494       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
495       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
496       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
497   static const byte nonce_1[] =
498     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
499   static const byte plaintext_1[] =
500     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
501   static const byte ciphertext_1[] =
502     { 0xE3, 0xBE, 0x8F, 0xDD, 0x8B, 0xEC, 0xA2, 0xE3};
503
504   salsa20_setkey (&ctx, key_1, sizeof key_1);
505   salsa20_setiv  (&ctx, nonce_1, sizeof nonce_1);
506   scratch[8] = 0;
507   salsa20_encrypt_stream (&ctx, scratch, plaintext_1, sizeof plaintext_1);
508   if (memcmp (scratch, ciphertext_1, sizeof ciphertext_1))
509     return "Salsa20 encryption test 1 failed.";
510   if (scratch[8])
511     return "Salsa20 wrote too much.";
512   salsa20_setkey( &ctx, key_1, sizeof(key_1));
513   salsa20_setiv  (&ctx, nonce_1, sizeof nonce_1);
514   salsa20_encrypt_stream (&ctx, scratch, scratch, sizeof plaintext_1);
515   if (memcmp (scratch, plaintext_1, sizeof plaintext_1))
516     return "Salsa20 decryption test 1 failed.";
517
518   for (i = 0; i < sizeof buf; i++)
519     buf[i] = i;
520   salsa20_setkey (&ctx, key_1, sizeof key_1);
521   salsa20_setiv (&ctx, nonce_1, sizeof nonce_1);
522   /*encrypt*/
523   salsa20_encrypt_stream (&ctx, buf, buf, sizeof buf);
524   /*decrypt*/
525   salsa20_setkey (&ctx, key_1, sizeof key_1);
526   salsa20_setiv (&ctx, nonce_1, sizeof nonce_1);
527   salsa20_encrypt_stream (&ctx, buf, buf, 1);
528   salsa20_encrypt_stream (&ctx, buf+1, buf+1, (sizeof buf)-1-1);
529   salsa20_encrypt_stream (&ctx, buf+(sizeof buf)-1, buf+(sizeof buf)-1, 1);
530   for (i = 0; i < sizeof buf; i++)
531     if (buf[i] != (byte)i)
532       return "Salsa20 encryption test 2 failed.";
533
534   return NULL;
535 }
536
537
538 gcry_cipher_spec_t _gcry_cipher_spec_salsa20 =
539   {
540     GCRY_CIPHER_SALSA20,
541     {0, 0},     /* flags */
542     "SALSA20",  /* name */
543     NULL,       /* aliases */
544     NULL,       /* oids */
545     1,          /* blocksize in bytes. */
546     SALSA20_MAX_KEY_SIZE*8,  /* standard key length in bits. */
547     sizeof (SALSA20_context_t),
548     salsa20_setkey,
549     NULL,
550     NULL,
551     salsa20_encrypt_stream,
552     salsa20_encrypt_stream,
553     NULL,
554     NULL,
555     salsa20_setiv
556   };
557
558 gcry_cipher_spec_t _gcry_cipher_spec_salsa20r12 =
559   {
560     GCRY_CIPHER_SALSA20R12,
561     {0, 0},     /* flags */
562     "SALSA20R12",  /* name */
563     NULL,       /* aliases */
564     NULL,       /* oids */
565     1,          /* blocksize in bytes. */
566     SALSA20_MAX_KEY_SIZE*8,  /* standard key length in bits. */
567     sizeof (SALSA20_context_t),
568     salsa20_setkey,
569     NULL,
570     NULL,
571     salsa20r12_encrypt_stream,
572     salsa20r12_encrypt_stream,
573     NULL,
574     NULL,
575     salsa20_setiv
576   };