2 * Salsa20: Salsa20 stream cipher algorithm
4 * Copyright (c) 2007 Tan Swee Heng <thesweeheng@gmail.com>
7 * - salsa20.c: Public domain C code by Daniel J. Bernstein <djb@cr.yp.to>
9 * Salsa20 is a stream cipher candidate in eSTREAM, the ECRYPT Stream
10 * Cipher Project. It is designed by Daniel J. Bernstein <djb@cr.yp.to>.
11 * More information about eSTREAM and Salsa20 can be found here:
12 * http://www.ecrypt.eu.org/stream/
13 * http://cr.yp.to/snuffle.html
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the Free
17 * Software Foundation; either version 2 of the License, or (at your option)
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/errno.h>
25 #include <linux/crypto.h>
26 #include <linux/types.h>
27 #include <crypto/algapi.h>
28 #include <asm/byteorder.h>
30 #define SALSA20_IV_SIZE 8U
31 #define SALSA20_MIN_KEY_SIZE 16U
32 #define SALSA20_MAX_KEY_SIZE 32U
35 * Start of code taken from D. J. Bernstein's reference implementation.
36 * With some modifications and optimizations made to suit our needs.
40 salsa20-ref.c version 20051118
45 #define ROTATE(v,n) (((v) << (n)) | ((v) >> (32 - (n))))
46 #define XOR(v,w) ((v) ^ (w))
47 #define PLUS(v,w) (((v) + (w)))
48 #define PLUSONE(v) (PLUS((v),1))
49 #define U32TO8_LITTLE(p, v) \
50 { (p)[0] = (v >> 0) & 0xff; (p)[1] = (v >> 8) & 0xff; \
51 (p)[2] = (v >> 16) & 0xff; (p)[3] = (v >> 24) & 0xff; }
52 #define U8TO32_LITTLE(p) \
53 (((u32)((p)[0]) ) | ((u32)((p)[1]) << 8) | \
54 ((u32)((p)[2]) << 16) | ((u32)((p)[3]) << 24) )
61 static void salsa20_wordtobyte(u8 output
[64], const u32 input
[16])
66 memcpy(x
, input
, sizeof(x
));
67 for (i
= 20; i
> 0; i
-= 2) {
68 x
[ 4] = XOR(x
[ 4],ROTATE(PLUS(x
[ 0],x
[12]), 7));
69 x
[ 8] = XOR(x
[ 8],ROTATE(PLUS(x
[ 4],x
[ 0]), 9));
70 x
[12] = XOR(x
[12],ROTATE(PLUS(x
[ 8],x
[ 4]),13));
71 x
[ 0] = XOR(x
[ 0],ROTATE(PLUS(x
[12],x
[ 8]),18));
72 x
[ 9] = XOR(x
[ 9],ROTATE(PLUS(x
[ 5],x
[ 1]), 7));
73 x
[13] = XOR(x
[13],ROTATE(PLUS(x
[ 9],x
[ 5]), 9));
74 x
[ 1] = XOR(x
[ 1],ROTATE(PLUS(x
[13],x
[ 9]),13));
75 x
[ 5] = XOR(x
[ 5],ROTATE(PLUS(x
[ 1],x
[13]),18));
76 x
[14] = XOR(x
[14],ROTATE(PLUS(x
[10],x
[ 6]), 7));
77 x
[ 2] = XOR(x
[ 2],ROTATE(PLUS(x
[14],x
[10]), 9));
78 x
[ 6] = XOR(x
[ 6],ROTATE(PLUS(x
[ 2],x
[14]),13));
79 x
[10] = XOR(x
[10],ROTATE(PLUS(x
[ 6],x
[ 2]),18));
80 x
[ 3] = XOR(x
[ 3],ROTATE(PLUS(x
[15],x
[11]), 7));
81 x
[ 7] = XOR(x
[ 7],ROTATE(PLUS(x
[ 3],x
[15]), 9));
82 x
[11] = XOR(x
[11],ROTATE(PLUS(x
[ 7],x
[ 3]),13));
83 x
[15] = XOR(x
[15],ROTATE(PLUS(x
[11],x
[ 7]),18));
84 x
[ 1] = XOR(x
[ 1],ROTATE(PLUS(x
[ 0],x
[ 3]), 7));
85 x
[ 2] = XOR(x
[ 2],ROTATE(PLUS(x
[ 1],x
[ 0]), 9));
86 x
[ 3] = XOR(x
[ 3],ROTATE(PLUS(x
[ 2],x
[ 1]),13));
87 x
[ 0] = XOR(x
[ 0],ROTATE(PLUS(x
[ 3],x
[ 2]),18));
88 x
[ 6] = XOR(x
[ 6],ROTATE(PLUS(x
[ 5],x
[ 4]), 7));
89 x
[ 7] = XOR(x
[ 7],ROTATE(PLUS(x
[ 6],x
[ 5]), 9));
90 x
[ 4] = XOR(x
[ 4],ROTATE(PLUS(x
[ 7],x
[ 6]),13));
91 x
[ 5] = XOR(x
[ 5],ROTATE(PLUS(x
[ 4],x
[ 7]),18));
92 x
[11] = XOR(x
[11],ROTATE(PLUS(x
[10],x
[ 9]), 7));
93 x
[ 8] = XOR(x
[ 8],ROTATE(PLUS(x
[11],x
[10]), 9));
94 x
[ 9] = XOR(x
[ 9],ROTATE(PLUS(x
[ 8],x
[11]),13));
95 x
[10] = XOR(x
[10],ROTATE(PLUS(x
[ 9],x
[ 8]),18));
96 x
[12] = XOR(x
[12],ROTATE(PLUS(x
[15],x
[14]), 7));
97 x
[13] = XOR(x
[13],ROTATE(PLUS(x
[12],x
[15]), 9));
98 x
[14] = XOR(x
[14],ROTATE(PLUS(x
[13],x
[12]),13));
99 x
[15] = XOR(x
[15],ROTATE(PLUS(x
[14],x
[13]),18));
101 for (i
= 0; i
< 16; ++i
)
102 x
[i
] = PLUS(x
[i
],input
[i
]);
103 for (i
= 0; i
< 16; ++i
)
104 U32TO8_LITTLE(output
+ 4 * i
,x
[i
]);
107 static const char sigma
[16] = "expand 32-byte k";
108 static const char tau
[16] = "expand 16-byte k";
110 static void salsa20_keysetup(struct salsa20_ctx
*ctx
, const u8
*k
, u32 kbytes
)
112 const char *constants
;
114 ctx
->input
[1] = U8TO32_LITTLE(k
+ 0);
115 ctx
->input
[2] = U8TO32_LITTLE(k
+ 4);
116 ctx
->input
[3] = U8TO32_LITTLE(k
+ 8);
117 ctx
->input
[4] = U8TO32_LITTLE(k
+ 12);
118 if (kbytes
== 32) { /* recommended */
121 } else { /* kbytes == 16 */
124 ctx
->input
[11] = U8TO32_LITTLE(k
+ 0);
125 ctx
->input
[12] = U8TO32_LITTLE(k
+ 4);
126 ctx
->input
[13] = U8TO32_LITTLE(k
+ 8);
127 ctx
->input
[14] = U8TO32_LITTLE(k
+ 12);
128 ctx
->input
[0] = U8TO32_LITTLE(constants
+ 0);
129 ctx
->input
[5] = U8TO32_LITTLE(constants
+ 4);
130 ctx
->input
[10] = U8TO32_LITTLE(constants
+ 8);
131 ctx
->input
[15] = U8TO32_LITTLE(constants
+ 12);
134 static void salsa20_ivsetup(struct salsa20_ctx
*ctx
, const u8
*iv
)
136 ctx
->input
[6] = U8TO32_LITTLE(iv
+ 0);
137 ctx
->input
[7] = U8TO32_LITTLE(iv
+ 4);
142 static void salsa20_encrypt_bytes(struct salsa20_ctx
*ctx
, u8
*dst
,
143 const u8
*src
, unsigned int bytes
)
148 memcpy(dst
, src
, bytes
);
151 salsa20_wordtobyte(buf
, ctx
->input
);
153 ctx
->input
[8] = PLUSONE(ctx
->input
[8]);
155 ctx
->input
[9] = PLUSONE(ctx
->input
[9]);
158 crypto_xor(dst
, buf
, bytes
);
162 crypto_xor(dst
, buf
, 64);
169 * End of code taken from D. J. Bernstein's reference implementation.
172 static int setkey(struct crypto_tfm
*tfm
, const u8
*key
,
173 unsigned int keysize
)
175 struct salsa20_ctx
*ctx
= crypto_tfm_ctx(tfm
);
176 salsa20_keysetup(ctx
, key
, keysize
);
180 static int encrypt(struct blkcipher_desc
*desc
,
181 struct scatterlist
*dst
, struct scatterlist
*src
,
184 struct blkcipher_walk walk
;
185 struct crypto_blkcipher
*tfm
= desc
->tfm
;
186 struct salsa20_ctx
*ctx
= crypto_blkcipher_ctx(tfm
);
189 blkcipher_walk_init(&walk
, dst
, src
, nbytes
);
190 err
= blkcipher_walk_virt_block(desc
, &walk
, 64);
192 salsa20_ivsetup(ctx
, walk
.iv
);
194 if (likely(walk
.nbytes
== nbytes
))
196 salsa20_encrypt_bytes(ctx
, walk
.dst
.virt
.addr
,
197 walk
.src
.virt
.addr
, nbytes
);
198 return blkcipher_walk_done(desc
, &walk
, 0);
201 while (walk
.nbytes
>= 64) {
202 salsa20_encrypt_bytes(ctx
, walk
.dst
.virt
.addr
,
204 walk
.nbytes
- (walk
.nbytes
% 64));
205 err
= blkcipher_walk_done(desc
, &walk
, walk
.nbytes
% 64);
209 salsa20_encrypt_bytes(ctx
, walk
.dst
.virt
.addr
,
210 walk
.src
.virt
.addr
, walk
.nbytes
);
211 err
= blkcipher_walk_done(desc
, &walk
, 0);
217 static struct crypto_alg alg
= {
218 .cra_name
= "salsa20",
219 .cra_driver_name
= "salsa20-generic",
221 .cra_flags
= CRYPTO_ALG_TYPE_BLKCIPHER
,
222 .cra_type
= &crypto_blkcipher_type
,
224 .cra_ctxsize
= sizeof(struct salsa20_ctx
),
226 .cra_module
= THIS_MODULE
,
227 .cra_list
= LIST_HEAD_INIT(alg
.cra_list
),
233 .min_keysize
= SALSA20_MIN_KEY_SIZE
,
234 .max_keysize
= SALSA20_MAX_KEY_SIZE
,
235 .ivsize
= SALSA20_IV_SIZE
,
240 static int __init
init(void)
242 return crypto_register_alg(&alg
);
245 static void __exit
fini(void)
247 crypto_unregister_alg(&alg
);
253 MODULE_LICENSE("GPL");
254 MODULE_DESCRIPTION ("Salsa20 stream cipher algorithm");
255 MODULE_ALIAS("salsa20");