mpi/ec: fix when 'unsigned long' is 32-bit but limb size is 64-bit
[libgcrypt.git] / cipher / gost28147.c
1 /* gost28147.c - GOST 28147-89 implementation for Libgcrypt
2  * Copyright (C) 2012 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /* GOST 28147-89 defines several modes of encryption:
21  * - ECB which should be used only for key transfer
22  * - CFB mode
23  * - OFB-like mode with additional transformation on keystream
24  *   RFC 5830 names this 'counter encryption' mode
25  *   Original GOST text uses the term 'gammirovanie'
26  * - MAC mode
27  *
28  * This implementation handles ECB and CFB modes via usual libgcrypt handling.
29  * OFB-like and MAC modes are unsupported.
30  */
31
32 #include <config.h>
33 #include "types.h"
34 #include "g10lib.h"
35 #include "cipher.h"
36 #include "bufhelp.h"
37
38 #include "gost.h"
39 #include "gost-sb.h"
40
41 static gcry_err_code_t
42 gost_setkey (void *c, const byte *key, unsigned keylen)
43 {
44   int i;
45   GOST28147_context *ctx = c;
46
47   if (keylen != 256 / 8)
48     return GPG_ERR_INV_KEYLEN;
49
50   if (!ctx->sbox)
51     ctx->sbox = sbox_test_3411;
52
53   for (i = 0; i < 8; i++)
54     {
55       ctx->key[i] = buf_get_le32(&key[4*i]);
56     }
57   return GPG_ERR_NO_ERROR;
58 }
59
60 static u32
61 gost_val (GOST28147_context *ctx, u32 cm1, int subkey)
62 {
63   cm1 += ctx->key[subkey];
64   cm1 = ctx->sbox[0*256 + ((cm1 >>  0) & 0xff)] |
65         ctx->sbox[1*256 + ((cm1 >>  8) & 0xff)] |
66         ctx->sbox[2*256 + ((cm1 >> 16) & 0xff)] |
67         ctx->sbox[3*256 + ((cm1 >> 24) & 0xff)];
68   return cm1;
69 }
70
71 static unsigned int
72 _gost_encrypt_data (void *c, u32 *o1, u32 *o2, u32 n1, u32 n2)
73 {
74   GOST28147_context *ctx = c;
75
76   n2 ^= gost_val (ctx, n1, 0); n1 ^= gost_val (ctx, n2, 1);
77   n2 ^= gost_val (ctx, n1, 2); n1 ^= gost_val (ctx, n2, 3);
78   n2 ^= gost_val (ctx, n1, 4); n1 ^= gost_val (ctx, n2, 5);
79   n2 ^= gost_val (ctx, n1, 6); n1 ^= gost_val (ctx, n2, 7);
80
81   n2 ^= gost_val (ctx, n1, 0); n1 ^= gost_val (ctx, n2, 1);
82   n2 ^= gost_val (ctx, n1, 2); n1 ^= gost_val (ctx, n2, 3);
83   n2 ^= gost_val (ctx, n1, 4); n1 ^= gost_val (ctx, n2, 5);
84   n2 ^= gost_val (ctx, n1, 6); n1 ^= gost_val (ctx, n2, 7);
85
86   n2 ^= gost_val (ctx, n1, 0); n1 ^= gost_val (ctx, n2, 1);
87   n2 ^= gost_val (ctx, n1, 2); n1 ^= gost_val (ctx, n2, 3);
88   n2 ^= gost_val (ctx, n1, 4); n1 ^= gost_val (ctx, n2, 5);
89   n2 ^= gost_val (ctx, n1, 6); n1 ^= gost_val (ctx, n2, 7);
90
91   n2 ^= gost_val (ctx, n1, 7); n1 ^= gost_val (ctx, n2, 6);
92   n2 ^= gost_val (ctx, n1, 5); n1 ^= gost_val (ctx, n2, 4);
93   n2 ^= gost_val (ctx, n1, 3); n1 ^= gost_val (ctx, n2, 2);
94   n2 ^= gost_val (ctx, n1, 1); n1 ^= gost_val (ctx, n2, 0);
95
96   *o1 = n2;
97   *o2 = n1;
98
99   return /* burn_stack */ 4*sizeof(void*) /* func call */ +
100                           3*sizeof(void*) /* stack */ +
101                           4*sizeof(void*) /* gost_val call */;
102 }
103
104 static unsigned int
105 gost_encrypt_block (void *c, byte *outbuf, const byte *inbuf)
106 {
107   GOST28147_context *ctx = c;
108   u32 n1, n2;
109   unsigned int burn;
110
111   n1 = buf_get_le32 (inbuf);
112   n2 = buf_get_le32 (inbuf+4);
113
114   burn = _gost_encrypt_data(ctx, &n1, &n2, n1, n2);
115
116   buf_put_le32 (outbuf+0, n1);
117   buf_put_le32 (outbuf+4, n2);
118
119   return /* burn_stack */ burn + 6*sizeof(void*) /* func call */;
120 }
121
122 unsigned int _gcry_gost_enc_data (GOST28147_context *c, const u32 *key,
123     u32 *o1, u32 *o2, u32 n1, u32 n2, int cryptopro)
124 {
125   if (cryptopro)
126     c->sbox = sbox_CryptoPro_3411;
127   else
128     c->sbox = sbox_test_3411;
129   memcpy (c->key, key, 8*4);
130   return _gost_encrypt_data (c, o1, o2, n1, n2) + 7 * sizeof(void *);
131 }
132
133 static unsigned int
134 gost_decrypt_block (void *c, byte *outbuf, const byte *inbuf)
135 {
136   GOST28147_context *ctx = c;
137   u32 n1, n2;
138
139   n1 = buf_get_le32 (inbuf);
140   n2 = buf_get_le32 (inbuf+4);
141
142   n2 ^= gost_val (ctx, n1, 0); n1 ^= gost_val (ctx, n2, 1);
143   n2 ^= gost_val (ctx, n1, 2); n1 ^= gost_val (ctx, n2, 3);
144   n2 ^= gost_val (ctx, n1, 4); n1 ^= gost_val (ctx, n2, 5);
145   n2 ^= gost_val (ctx, n1, 6); n1 ^= gost_val (ctx, n2, 7);
146
147   n2 ^= gost_val (ctx, n1, 7); n1 ^= gost_val (ctx, n2, 6);
148   n2 ^= gost_val (ctx, n1, 5); n1 ^= gost_val (ctx, n2, 4);
149   n2 ^= gost_val (ctx, n1, 3); n1 ^= gost_val (ctx, n2, 2);
150   n2 ^= gost_val (ctx, n1, 1); n1 ^= gost_val (ctx, n2, 0);
151
152   n2 ^= gost_val (ctx, n1, 7); n1 ^= gost_val (ctx, n2, 6);
153   n2 ^= gost_val (ctx, n1, 5); n1 ^= gost_val (ctx, n2, 4);
154   n2 ^= gost_val (ctx, n1, 3); n1 ^= gost_val (ctx, n2, 2);
155   n2 ^= gost_val (ctx, n1, 1); n1 ^= gost_val (ctx, n2, 0);
156
157   n2 ^= gost_val (ctx, n1, 7); n1 ^= gost_val (ctx, n2, 6);
158   n2 ^= gost_val (ctx, n1, 5); n1 ^= gost_val (ctx, n2, 4);
159   n2 ^= gost_val (ctx, n1, 3); n1 ^= gost_val (ctx, n2, 2);
160   n2 ^= gost_val (ctx, n1, 1); n1 ^= gost_val (ctx, n2, 0);
161
162   buf_put_le32 (outbuf+0, n2);
163   buf_put_le32 (outbuf+4, n1);
164
165   return /* burn_stack */ 4*sizeof(void*) /* func call */ +
166                           3*sizeof(void*) /* stack */ +
167                           4*sizeof(void*) /* gost_val call */;
168 }
169
170 static gpg_err_code_t
171 gost_set_sbox (GOST28147_context *ctx, const char *oid)
172 {
173   int i;
174
175   for (i = 0; gost_oid_map[i].oid; i++)
176     {
177       if (!strcmp(gost_oid_map[i].oid, oid))
178         {
179           ctx->sbox = gost_oid_map[i].sbox;
180           return 0;
181         }
182     }
183   return GPG_ERR_VALUE_NOT_FOUND;
184 }
185
186 static gpg_err_code_t
187 gost_set_extra_info (void *c, int what, const void *buffer, size_t buflen)
188 {
189   GOST28147_context *ctx = c;
190   gpg_err_code_t ec = 0;
191
192   (void)buffer;
193   (void)buflen;
194
195   switch (what)
196     {
197     case GCRYCTL_SET_SBOX:
198       ec = gost_set_sbox (ctx, buffer);
199       break;
200
201     default:
202       ec = GPG_ERR_INV_OP;
203       break;
204     }
205   return ec;
206 }
207
208 static gcry_cipher_oid_spec_t oids_gost28147[] =
209   {
210     /* { "1.2.643.2.2.31.0", GCRY_CIPHER_MODE_CNTGOST }, */
211     { "1.2.643.2.2.31.1", GCRY_CIPHER_MODE_CFB },
212     { "1.2.643.2.2.31.2", GCRY_CIPHER_MODE_CFB },
213     { "1.2.643.2.2.31.3", GCRY_CIPHER_MODE_CFB },
214     { "1.2.643.2.2.31.4", GCRY_CIPHER_MODE_CFB },
215     { NULL }
216   };
217
218 gcry_cipher_spec_t _gcry_cipher_spec_gost28147 =
219   {
220     GCRY_CIPHER_GOST28147, {0, 0},
221     "GOST28147", NULL, oids_gost28147, 8, 256,
222     sizeof (GOST28147_context),
223     gost_setkey,
224     gost_encrypt_block,
225     gost_decrypt_block,
226     NULL, NULL, NULL, gost_set_extra_info,
227   };