2698e4f9371e03e18083934394a56021e988b8ff
[openssl.git] / engines / ccgost / pmeth.c
1 /**********************************************************************
2  *                          pmeth.c                                   *
3  *             Copyright (c) 2005-2006 Cryptocom LTD                  *
4  *         This file is distributed under the same license as OpenSSL *
5  *                                                                    *
6  *   Implementation of RFC 4357 (GOST R 34.10) Publick key method     *
7  *       for OpenSSL                                                  *
8  *          Requires OpenSSL 0.9.9 for compilation                    *
9  **********************************************************************/
10 #include <openssl/evp.h>
11 #include <openssl/objects.h>
12 #include <openssl/ec.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <ctype.h>
16 #include "meth.h"
17 #include "pmeth.h"
18 #include "sign.h"
19 #include "gostkeyx.h"
20 #include "paramset.h"
21 #include "tools.h"
22 #include "e_gost_err.h"
23 /*-------init, cleanup, copy - uniform for all algs  ---------------*/
24 /* Allocates new gost_pmeth_data structure and assigns it as data */
25 static int pkey_gost_init(EVP_PKEY_CTX *ctx) {
26         struct gost_pmeth_data *data;
27         data = OPENSSL_malloc(sizeof(struct gost_pmeth_data));
28         if (!data) return 0;
29         memset(data,0,sizeof(struct gost_pmeth_data));
30         EVP_PKEY_CTX_set_data(ctx,data);
31         return 1;
32 }
33 /* Copies contents of gost_pmeth_data structure */
34 static int pkey_gost_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
35 {
36         struct gost_pmeth_data *dst_data,*src_data;
37         if (!pkey_gost_init(dst)) {
38                 return 0;
39         }
40         src_data = EVP_PKEY_CTX_get_data(src);
41         dst_data = EVP_PKEY_CTX_get_data(dst);
42         *dst_data = *src_data;
43         if (src_data -> eph_seckey) {
44                 dst_data ->eph_seckey = NULL;
45         }       
46         return 1;
47 }
48 /* Frees up gost_pmeth_data structure */
49 static void pkey_gost_cleanup (EVP_PKEY_CTX *ctx) {
50         struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
51         if (data->eph_seckey) EVP_PKEY_free(data->eph_seckey);
52         OPENSSL_free(data);
53 }       
54 /* --------------------- control functions  ------------------------------*/
55 static int pkey_gost_ctrl (EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
56 {
57         struct gost_pmeth_data *pctx = (struct gost_pmeth_data*)EVP_PKEY_CTX_get_data(ctx);
58         switch (type)
59         {
60                 case EVP_PKEY_CTRL_MD:
61                         {
62                                 if (EVP_MD_type((const EVP_MD *)p2) != NID_id_GostR3411_94) {
63                                         GOSTerr(GOST_F_PKEY_GOST_CTRL, GOST_R_INVALID_DIGEST_TYPE);
64                                         return 0;
65                                 }
66                                 pctx->md = (EVP_MD *)p2;
67                                 return 1;
68                         }
69                         break;
70
71                 case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
72                 case EVP_PKEY_CTRL_PKCS7_DECRYPT:
73                 case EVP_PKEY_CTRL_PKCS7_SIGN:
74                 return 1; 
75
76                 case EVP_PKEY_CTRL_GOST_PARAMSET:
77                         pctx->sign_param_nid = (int)p1;
78                         pctx->crypt_param_nid= (int)p2;
79                         return 1;
80                         
81         }
82         return -2;
83 }
84
85 static int pkey_gost_ctrl94cc_str(EVP_PKEY_CTX *ctx, 
86                 const char *type, const char *value)
87 {
88         if(!strcmp(type, param_ctrl_string)) {
89                 return pkey_gost_ctrl(ctx, EVP_PKEY_CTRL_GOST_PARAMSET,
90                         NID_id_GostR3410_94_CryptoPro_A_ParamSet, 
91                         (void *)NID_id_Gost28147_89_cc);
92         }
93         return -2;
94 }
95
96 static int pkey_gost_ctrl01cc_str(EVP_PKEY_CTX *ctx, 
97                 const char *type, const char *value)
98 {
99         if(!strcmp(type, param_ctrl_string)) {
100                 return pkey_gost_ctrl(ctx, EVP_PKEY_CTRL_GOST_PARAMSET,
101                         NID_id_GostR3410_2001_ParamSet_cc, 
102                         (void *)
103                         NID_id_Gost28147_89_cc);
104         }
105         return -2;
106 }
107 static int pkey_gost_ctrl94_str(EVP_PKEY_CTX *ctx, 
108                 const char *type, const char *value)
109 {
110         int param_nid=0;
111         if(!strcmp(type, param_ctrl_string)) {
112                 if (!value) {
113                         return 0;
114                 }
115                 if (strlen(value) == 1) {
116                         switch(toupper(value[0])) {
117                                 case 'A':
118                                         param_nid = NID_id_GostR3410_94_CryptoPro_A_ParamSet;
119                                         break;
120                                 case 'B':
121                                         param_nid = NID_id_GostR3410_94_CryptoPro_B_ParamSet;
122                                         break;
123                                 case 'C':
124                                         param_nid = NID_id_GostR3410_94_CryptoPro_C_ParamSet;
125                                         break;
126                                 case 'D':
127                                         param_nid = NID_id_GostR3410_94_CryptoPro_D_ParamSet;
128                                         break;
129                                 default:
130                                         return 0;
131                                         break;
132                         }
133                 } else if ((strlen(value) == 2) && (toupper(value[0]) == 'X')) {
134                         switch (toupper(value[1])) {
135                                 case 'A':
136                                         param_nid = NID_id_GostR3410_94_CryptoPro_XchA_ParamSet;
137                                         break;
138                                 case 'B':
139                                         param_nid = NID_id_GostR3410_94_CryptoPro_XchB_ParamSet;
140                                         break;
141                                 case 'C':
142                                         param_nid = NID_id_GostR3410_94_CryptoPro_XchC_ParamSet;
143                                         break;
144                                 default:
145                                         return 0;
146                                         break;
147                         }
148                 } else {
149                         R3410_params *p = R3410_paramset;
150                         param_nid = OBJ_txt2nid(value);
151                         if (param_nid == NID_undef) {
152                                 return 0;
153                         }
154                         for (;p->nid != NID_undef;p++) {
155                                 if (p->nid == param_nid) break;
156                         }
157                         if (p->nid == NID_undef) {
158                                 GOSTerr(GOST_F_PKEY_GOST_CTRL94_STR,
159                                 GOST_R_INVALID_PARAMSET);
160                                 return 0;
161                         }
162                 }
163
164                 return pkey_gost_ctrl(ctx, EVP_PKEY_CTRL_GOST_PARAMSET, 
165                                 param_nid, (void *)NID_id_Gost28147_89_CryptoPro_A_ParamSet);
166         }
167         return -2;
168 }
169
170 static int pkey_gost_ctrl01_str(EVP_PKEY_CTX *ctx, 
171                 const char *type, const char *value)
172 {
173         int param_nid=0;
174         if(!strcmp(type, param_ctrl_string)) {
175                 if (!value) {
176                         return 0;
177                 }
178                 if (strlen(value) == 1) {
179                         switch(toupper(value[0])) {
180                                 case 'A':
181                                         param_nid = NID_id_GostR3410_2001_CryptoPro_A_ParamSet;
182                                         break;  
183                                 case 'B':
184                                         param_nid = NID_id_GostR3410_2001_CryptoPro_B_ParamSet;
185                                         break;
186                                 case 'C':
187                                         param_nid = NID_id_GostR3410_2001_CryptoPro_C_ParamSet;
188                                         break;
189                                 case '0':
190                                         param_nid = NID_id_GostR3410_2001_TestParamSet;
191                                         break;
192                                 default:
193                                         return 0;
194                                         break;
195                         }
196                 } else if ((strlen(value) == 2) && (toupper(value[0]) == 'X')) {
197                         switch (toupper(value[1])) {
198                                 case 'A':
199                                         param_nid = NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet;
200                                         break;
201                                 case 'B':
202                                         param_nid = NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet;
203                                         break;
204                                 default:
205                                         return 0;
206                                         break;
207                         }
208                 } else {
209                         R3410_2001_params *p = R3410_2001_paramset;
210                         param_nid = OBJ_txt2nid(value);
211                         if (param_nid == NID_undef) {
212                                 return 0;
213                         }
214                         for (;p->nid != NID_undef;p++) {
215                                 if (p->nid == param_nid) break;
216                         }
217                         if (p->nid == NID_undef) {
218                                 GOSTerr(GOST_F_PKEY_GOST_CTRL01_STR,
219                                 GOST_R_INVALID_PARAMSET);
220                                 return 0;
221                         }
222                 }
223
224                 return pkey_gost_ctrl(ctx, EVP_PKEY_CTRL_GOST_PARAMSET, 
225                                 param_nid, (void *)NID_id_Gost28147_89_CryptoPro_A_ParamSet);
226         }
227         return -2;
228 }
229 /* --------------------- key generation  --------------------------------*/
230 /* Generates GOST 94 key and assigns it setting specified type */
231 static int pkey_gost94_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey,int type)
232 {
233         struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
234         DSA *dsa=NULL;
235         if (data->sign_param_nid == NID_undef) {
236                 if (type== NID_id_GostR3410_94_cc) {
237                         data->sign_param_nid = NID_id_GostR3410_94_CryptoPro_A_ParamSet;
238                 } else {
239                         GOSTerr(GOST_F_PKEY_GOST94_KEYGEN,
240                         GOST_R_NO_PARAMETERS_SET);
241                         return 0;
242                 }       
243         }
244         dsa = DSA_new();
245         if (!fill_GOST94_params(dsa,data->sign_param_nid)) {
246                 DSA_free(dsa);
247                 return 0;
248         }
249         gost_sign_keygen(dsa);
250         EVP_PKEY_assign(pkey,type,dsa);
251         return 1;
252 }
253 /* Generates Gost_R3410_94_cc key */
254 static int pkey_gost94cc_keygen (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
255         return pkey_gost94_keygen(ctx,pkey,NID_id_GostR3410_94_cc);
256 }
257
258 /* Generates Gost_R3410_94_cp key */
259 static int pkey_gost94cp_keygen (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
260         return pkey_gost94_keygen(ctx,pkey,NID_id_GostR3410_94);
261 }
262 /* Generates GOST_R3410 2001 key and assigns it using specified type */
263 static int pkey_gost01_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey,int type)
264 {
265         struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
266         EC_KEY *ec=NULL;
267         if (data->sign_param_nid == NID_undef) {
268                 if (type == NID_id_GostR3410_2001_cc) {
269                         data->sign_param_nid = NID_id_GostR3410_2001_ParamSet_cc;
270                 } else {        
271                         GOSTerr(GOST_F_PKEY_GOST01_KEYGEN,
272                         GOST_R_NO_PARAMETERS_SET);
273                         return 0;
274                 }
275         }
276         ec = EC_KEY_new();
277         if (!fill_GOST2001_params(ec,data->sign_param_nid)) {
278                 EC_KEY_free(ec);
279                 return 0;
280         }
281         gost2001_keygen(ec);
282
283         EVP_PKEY_assign(pkey,type,ec);
284         return 1;
285 }
286 /* Generates GOST R3410 2001_cc key */
287 static int pkey_gost01cc_keygen (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
288         return pkey_gost01_keygen(ctx,pkey,NID_id_GostR3410_2001_cc);
289 }
290
291 /* Generates GOST R3410 2001_cp key */
292 static int pkey_gost01cp_keygen (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
293         return pkey_gost01_keygen(ctx,pkey,NID_id_GostR3410_2001);
294 }
295 /* ----------- sign callbacks --------------------------------------*/
296 static int pkey_gost94_cc_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
297         const unsigned char *tbs, size_t tbs_len)
298 {
299         DSA_SIG *unpacked_sig=NULL;
300         EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
301         if (!siglen) return 0;
302         if (!sig) 
303         {
304                 *siglen= 64; /* better to check size of pkey->pkey.dsa-q */
305                 return 1;
306         }       
307         unpacked_sig = gost_do_sign(tbs,tbs_len,EVP_PKEY_get0(pkey));
308         if (!unpacked_sig) {
309                 return 0;
310         }
311
312         return pack_sign_cc(unpacked_sig,32,sig,siglen);
313         
314         
315 }
316 static int pkey_gost94_cp_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
317         const unsigned char *tbs, size_t tbs_len)
318 {
319         DSA_SIG *unpacked_sig=NULL;
320         EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
321         if (!siglen) return 0;
322         if (!sig) 
323         {
324                 *siglen= 64; /* better to check size of pkey->pkey.dsa-q */
325                 return 1;
326         }       
327         unpacked_sig = gost_do_sign(tbs,tbs_len,EVP_PKEY_get0(pkey));
328         if (!unpacked_sig) {
329                 return 0;
330         }
331         return pack_sign_cp(unpacked_sig,32,sig,siglen);
332         
333         
334 }
335 static int pkey_gost01_cc_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
336         const unsigned char *tbs, size_t tbs_len)
337 {
338         DSA_SIG *unpacked_sig=NULL;
339         EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
340         if (!siglen) return 0;
341         if (!sig) 
342         {
343                 *siglen= 64; /* better to check size of curve order*/
344                 return 1;
345         }       
346         unpacked_sig = gost2001_do_sign(tbs,tbs_len,EVP_PKEY_get0(pkey));
347         if (!unpacked_sig) {
348                 return 0;
349         }
350         return pack_sign_cc(unpacked_sig,32,sig,siglen);
351 }
352 static int pkey_gost01_cp_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
353         const unsigned char *tbs, size_t tbs_len)
354 {
355         DSA_SIG *unpacked_sig=NULL;
356         EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
357         if (!siglen) return 0;
358         if (!sig) 
359         {
360                 *siglen= 64; /* better to check size of curve order*/
361                 return 1;
362         }       
363         unpacked_sig = gost2001_do_sign(tbs,tbs_len,EVP_PKEY_get0(pkey));
364         if (!unpacked_sig) {
365                 return 0;
366         }
367         return pack_sign_cp(unpacked_sig,32,sig,siglen);
368 }
369 /* ------------------- verify callbacks ---------------------------*/
370 static int pkey_gost94_cc_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig,
371         size_t siglen, const unsigned char *tbs, size_t tbs_len)
372 {
373         int ok = 0;
374         EVP_PKEY* pub_key = EVP_PKEY_CTX_get0_pkey(ctx);
375         DSA_SIG *s=unpack_cc_signature(sig,siglen);
376         if (!s) return 0;
377         if (pub_key) ok = gost_do_verify(tbs,tbs_len,s,EVP_PKEY_get0(pub_key));
378         DSA_SIG_free(s);
379         return ok;
380 }
381
382 static int pkey_gost94_cp_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig,
383         size_t siglen, const unsigned char *tbs, size_t tbs_len)
384 {
385         int ok = 0;
386         EVP_PKEY* pub_key = EVP_PKEY_CTX_get0_pkey(ctx);
387         DSA_SIG *s=unpack_cp_signature(sig,siglen);
388         if (!s) return 0;
389         if (pub_key) ok = gost_do_verify(tbs,tbs_len,s,EVP_PKEY_get0(pub_key));
390         DSA_SIG_free(s);
391         return ok;
392 }
393 static int pkey_gost01_cc_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig,
394         size_t siglen, const unsigned char *tbs, size_t tbs_len)
395 {
396         int ok = 0;
397         EVP_PKEY* pub_key = EVP_PKEY_CTX_get0_pkey(ctx);
398         DSA_SIG *s=unpack_cc_signature(sig,siglen);
399         fprintf(stderr,"R=");
400         BN_print_fp(stderr,s->r);
401         fprintf(stderr,"\nS=");
402         BN_print_fp(stderr,s->s);
403         fprintf(stderr,"\n");
404         if (!s) return 0;
405         if (pub_key) ok = gost2001_do_verify(tbs,tbs_len,s,EVP_PKEY_get0(pub_key));
406         DSA_SIG_free(s);
407         return ok;
408 }
409
410 static int pkey_gost01_cp_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig,
411         size_t siglen, const unsigned char *tbs, size_t tbs_len)
412 {
413         int ok = 0;
414         EVP_PKEY* pub_key = EVP_PKEY_CTX_get0_pkey(ctx);
415         DSA_SIG *s=unpack_cp_signature(sig,siglen);
416         if (!s) return 0;
417         fprintf(stderr,"R=");
418         BN_print_fp(stderr,s->r);
419         fprintf(stderr,"\nS=");
420         BN_print_fp(stderr,s->s);
421         fprintf(stderr,"\n");
422         if (pub_key) ok = gost2001_do_verify(tbs,tbs_len,s,EVP_PKEY_get0(pub_key));
423         DSA_SIG_free(s);
424         return ok;
425 }
426 /* ------------- encrypt init -------------------------------------*/
427 /* Generates ephermeral key */
428 static int pkey_gost_encrypt_init(EVP_PKEY_CTX *ctx) 
429 {
430         struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
431         EVP_PKEY *eph_key = EVP_PKEY_new();
432         EVP_PKEY *old_key =EVP_PKEY_CTX_get0_pkey(ctx);
433
434         if (data->eph_seckey) EVP_PKEY_free(data->eph_seckey);
435         EVP_PKEY_assign(eph_key,EVP_PKEY_base_id(old_key),NULL);
436         if (!EVP_PKEY_copy_parameters(eph_key,old_key)) return 0;
437         switch (EVP_PKEY_base_id(old_key)) {
438         case NID_id_GostR3410_2001:
439         case NID_id_GostR3410_2001_cc:
440                 gost2001_keygen(EVP_PKEY_get0(eph_key));
441                 break;
442         case NID_id_GostR3410_94:
443         case NID_id_GostR3410_94_cc:
444                 gost_sign_keygen(EVP_PKEY_get0(eph_key));
445                 break;
446         
447                         
448         }
449
450         
451         data->eph_seckey=eph_key;
452         return 1;
453 }
454 /* ----------------------------------------------------------------*/
455 int register_pmeth_gost(int id, EVP_PKEY_METHOD **pmeth,int flags) {
456         *pmeth = EVP_PKEY_meth_new(id, flags);
457         if (!*pmeth) return 0;
458
459         switch (id) {
460                 case NID_id_GostR3410_94_cc:
461                         EVP_PKEY_meth_set_ctrl(*pmeth,pkey_gost_ctrl, pkey_gost_ctrl94cc_str); 
462                         EVP_PKEY_meth_set_keygen(*pmeth,NULL,pkey_gost94cc_keygen);
463                         EVP_PKEY_meth_set_sign(*pmeth, NULL, pkey_gost94_cc_sign);
464                         EVP_PKEY_meth_set_verify(*pmeth, NULL, pkey_gost94_cc_verify);
465                         EVP_PKEY_meth_set_encrypt(*pmeth, 
466                                 pkey_gost_encrypt_init, pkey_GOST94cc_encrypt);
467                         EVP_PKEY_meth_set_decrypt(*pmeth, NULL, pkey_GOST94cc_decrypt); 
468                         break;
469                 case NID_id_GostR3410_94:
470                         EVP_PKEY_meth_set_ctrl(*pmeth,pkey_gost_ctrl, pkey_gost_ctrl94_str);
471                         EVP_PKEY_meth_set_keygen(*pmeth,NULL,pkey_gost94cp_keygen);
472                         EVP_PKEY_meth_set_sign(*pmeth, NULL, pkey_gost94_cp_sign);
473                         EVP_PKEY_meth_set_verify(*pmeth, NULL, pkey_gost94_cp_verify);
474                         EVP_PKEY_meth_set_encrypt(*pmeth, 
475                                 pkey_gost_encrypt_init, pkey_GOST94cp_encrypt);
476                         EVP_PKEY_meth_set_decrypt(*pmeth, NULL, pkey_GOST94cp_decrypt); 
477
478         
479                         break;
480                 case NID_id_GostR3410_2001_cc:
481                         EVP_PKEY_meth_set_ctrl(*pmeth,pkey_gost_ctrl, pkey_gost_ctrl01cc_str);
482                         EVP_PKEY_meth_set_sign(*pmeth, NULL, pkey_gost01_cc_sign);
483                         EVP_PKEY_meth_set_verify(*pmeth, NULL, pkey_gost01_cc_verify);
484
485                         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost01cc_keygen);
486
487                         EVP_PKEY_meth_set_encrypt(*pmeth, 
488                                 pkey_gost_encrypt_init, pkey_GOST01cc_encrypt);
489                         EVP_PKEY_meth_set_decrypt(*pmeth, NULL, pkey_GOST01cc_decrypt); 
490                         break;
491                         /* There is intentionally no break here */
492                 case NID_id_GostR3410_2001:
493                         EVP_PKEY_meth_set_ctrl(*pmeth,pkey_gost_ctrl, pkey_gost_ctrl01_str);
494                         EVP_PKEY_meth_set_sign(*pmeth, NULL, pkey_gost01_cp_sign);
495                         EVP_PKEY_meth_set_verify(*pmeth, NULL, pkey_gost01_cp_verify);
496
497                         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost01cp_keygen);
498
499                         EVP_PKEY_meth_set_encrypt(*pmeth, 
500                                 pkey_gost_encrypt_init, pkey_GOST01cp_encrypt);
501                         EVP_PKEY_meth_set_decrypt(*pmeth, NULL, pkey_GOST01cp_decrypt); 
502                         break;
503                 default: //Unsupported method
504                         return 0;
505         }
506         EVP_PKEY_meth_set_init(*pmeth, pkey_gost_init);
507         EVP_PKEY_meth_set_cleanup(*pmeth, pkey_gost_cleanup);
508
509         EVP_PKEY_meth_set_copy(*pmeth, pkey_gost_copy);
510         //FIXME derive etc...
511         
512         return 1;
513 }
514