2f2a88781e883ce98b1d4cf0cf7fa4f01db94da9
[gnuk/gnuk.git] / src / call-rsa.c
1 /*
2  * call-rsa.c -- Glue code between RSA computation and OpenPGP card protocol
3  *
4  * Copyright (C) 2010, 2011, 2012 Free Software Initiative of Japan
5  * Author: NIIBE Yutaka <gniibe@fsij.org>
6  *
7  * This file is a part of Gnuk, a GnuPG USB Token implementation.
8  *
9  * Gnuk is free software: you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * Gnuk is distributed in the hope that it will be useful, but WITHOUT
15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17  * License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  *
22  */
23
24 #include <stdlib.h>
25 #include "config.h"
26 #include "ch.h"
27 #include "gnuk.h"
28 #include "openpgp.h"
29 #include "polarssl/config.h"
30 #include "polarssl/rsa.h"
31
32 #define RSA_SIGNATURE_LENGTH KEY_CONTENT_LEN
33  /* 256 byte == 2048-bit */
34  /* 128 byte == 1024-bit */
35
36 static rsa_context rsa_ctx;
37
38 int
39 rsa_sign (const uint8_t *raw_message, uint8_t *output, int msg_len,
40           struct key_data *kd)
41 {
42   mpi P1, Q1, H;
43   int r;
44   unsigned char temp[RSA_SIGNATURE_LENGTH];
45
46   mpi_init (&P1, &Q1, &H, NULL);
47   rsa_init (&rsa_ctx, RSA_PKCS_V15, 0);
48
49   rsa_ctx.len = KEY_CONTENT_LEN;
50   mpi_read_string (&rsa_ctx.E, 16, "10001");
51   mpi_read_binary (&rsa_ctx.P, &kd->data[0], rsa_ctx.len / 2);
52   mpi_read_binary (&rsa_ctx.Q, &kd->data[KEY_CONTENT_LEN/2], rsa_ctx.len / 2);
53   mpi_mul_mpi (&rsa_ctx.N, &rsa_ctx.P, &rsa_ctx.Q);
54   mpi_sub_int (&P1, &rsa_ctx.P, 1);
55   mpi_sub_int (&Q1, &rsa_ctx.Q, 1);
56   mpi_mul_mpi (&H, &P1, &Q1);
57   mpi_inv_mod (&rsa_ctx.D , &rsa_ctx.E, &H);
58   mpi_mod_mpi (&rsa_ctx.DP, &rsa_ctx.D, &P1);
59   mpi_mod_mpi (&rsa_ctx.DQ, &rsa_ctx.D, &Q1);
60   mpi_inv_mod (&rsa_ctx.QP, &rsa_ctx.Q, &rsa_ctx.P);
61   mpi_free (&P1, &Q1, &H, NULL);
62
63   DEBUG_INFO ("RSA sign...");
64 #if 0
65   if ((r = rsa_check_privkey (&rsa_ctx)) == 0)
66     DEBUG_INFO ("ok...");
67   else
68     {
69       DEBUG_INFO ("failed.\r\n");
70       DEBUG_SHORT (r);
71       rsa_free (&rsa_ctx);
72       return r;
73     }
74 #endif
75
76   r = rsa_pkcs1_sign (&rsa_ctx, RSA_PRIVATE, SIG_RSA_RAW,
77                       msg_len, raw_message, temp);
78   memcpy (output, temp, RSA_SIGNATURE_LENGTH);
79   rsa_free (&rsa_ctx);
80   if (r < 0)
81     {
82       DEBUG_INFO ("fail:");
83       DEBUG_SHORT (r);
84       return r;
85     }
86   else
87     {
88       res_APDU_size = RSA_SIGNATURE_LENGTH;
89       DEBUG_INFO ("done.\r\n");
90       GPG_SUCCESS ();
91       return 0;
92     }
93 }
94
95 /*
96  * LEN: length in byte
97  */
98 const uint8_t *
99 modulus_calc (const uint8_t *p, int len)
100 {
101   mpi P, Q, N;
102   uint8_t *modulus;
103
104   modulus = malloc (len);
105   if (modulus == NULL)
106     return NULL;
107
108   mpi_init (&P, &Q, &N, NULL);
109   mpi_read_binary (&P, p, len / 2);
110   mpi_read_binary (&Q, p + len / 2, len / 2);
111   mpi_mul_mpi (&N, &P, &Q);
112
113   mpi_write_binary (&N, modulus, len);
114   mpi_free (&P, &Q, &N, NULL);
115   return modulus;
116 }
117
118 void
119 modulus_free (const uint8_t *p)
120 {
121   free ((void *)p);
122 }
123
124 int
125 rsa_decrypt (const uint8_t *input, uint8_t *output, int msg_len,
126              struct key_data *kd)
127 {
128   mpi P1, Q1, H;
129   int r;
130   int output_len;
131
132   DEBUG_INFO ("RSA decrypt:");
133   DEBUG_WORD ((uint32_t)&output_len);
134
135   mpi_init (&P1, &Q1, &H, NULL);
136   rsa_init (&rsa_ctx, RSA_PKCS_V15, 0);
137
138   rsa_ctx.len = msg_len;
139   DEBUG_WORD (msg_len);
140
141   mpi_read_string (&rsa_ctx.E, 16, "10001");
142   mpi_read_binary (&rsa_ctx.P, &kd->data[0], KEY_CONTENT_LEN / 2);
143   mpi_read_binary (&rsa_ctx.Q, &kd->data[KEY_CONTENT_LEN/2],
144                    KEY_CONTENT_LEN / 2);
145   mpi_mul_mpi (&rsa_ctx.N, &rsa_ctx.P, &rsa_ctx.Q);
146   mpi_sub_int (&P1, &rsa_ctx.P, 1);
147   mpi_sub_int (&Q1, &rsa_ctx.Q, 1);
148   mpi_mul_mpi (&H, &P1, &Q1);
149   mpi_inv_mod (&rsa_ctx.D , &rsa_ctx.E, &H);
150   mpi_mod_mpi (&rsa_ctx.DP, &rsa_ctx.D, &P1);
151   mpi_mod_mpi (&rsa_ctx.DQ, &rsa_ctx.D, &Q1);
152   mpi_inv_mod (&rsa_ctx.QP, &rsa_ctx.Q, &rsa_ctx.P);
153   mpi_free (&P1, &Q1, &H, NULL);
154
155   DEBUG_INFO ("RSA decrypt ...");
156 #if 0
157   /* This consume some memory */
158   if ((r = rsa_check_privkey (&rsa_ctx)) == 0)
159     DEBUG_INFO ("ok...");
160   else
161     {
162       DEBUG_INFO ("failed.\r\n");
163       DEBUG_SHORT (r);
164       rsa_free (&rsa_ctx);
165       return r;
166     }
167 #endif
168
169   r = rsa_pkcs1_decrypt (&rsa_ctx, RSA_PRIVATE, &output_len,
170                          input, output, MAX_RES_APDU_DATA_SIZE);
171   rsa_free (&rsa_ctx);
172   if (r < 0)
173     {
174       DEBUG_INFO ("fail:");
175       DEBUG_SHORT (r);
176       return r;
177     }
178   else
179     {
180       res_APDU_size = output_len;
181       DEBUG_INFO ("done.\r\n");
182       GPG_SUCCESS ();
183       return 0;
184     }
185 }
186
187 int
188 rsa_verify (const uint8_t *pubkey, const uint8_t *hash, const uint8_t *sig)
189 {
190   int r;
191
192   rsa_init (&rsa_ctx, RSA_PKCS_V15, 0);
193   rsa_ctx.len = KEY_CONTENT_LEN;
194   mpi_read_string (&rsa_ctx.E, 16, "10001");
195   mpi_read_binary (&rsa_ctx.N, pubkey, KEY_CONTENT_LEN);
196
197   DEBUG_INFO ("RSA verify...");
198
199   r = rsa_pkcs1_verify (&rsa_ctx, RSA_PUBLIC, SIG_RSA_SHA1, 20, hash, sig);
200
201   rsa_free (&rsa_ctx);
202   if (r < 0)
203     {
204       DEBUG_INFO ("fail:");
205       DEBUG_SHORT (r);
206       return r;
207     }
208   else
209     {
210       DEBUG_INFO ("verified.\r\n");
211       return 0;
212     }
213 }
214
215 #define RSA_EXPONENT 0x10001
216
217 const uint8_t *
218 rsa_genkey (void)
219 {
220   int r;
221   uint8_t index = 0;
222   uint8_t *p_q_modulus = (uint8_t *)malloc (KEY_CONTENT_LEN*2);
223   uint8_t *p = p_q_modulus;
224   uint8_t *q = p_q_modulus + KEY_CONTENT_LEN/2;
225   uint8_t *modulus = p_q_modulus + KEY_CONTENT_LEN;
226
227   if (p_q_modulus == NULL)
228     return NULL;
229
230   rsa_init (&rsa_ctx, RSA_PKCS_V15, 0);
231   r = rsa_gen_key (&rsa_ctx, random_byte, &index,
232                    KEY_CONTENT_LEN * 8, RSA_EXPONENT);
233   if (r < 0)
234     {
235       free (p_q_modulus);
236       rsa_free (&rsa_ctx);
237       return NULL;
238     }
239
240   mpi_write_binary (&rsa_ctx.P, p, KEY_CONTENT_LEN/2);
241   mpi_write_binary (&rsa_ctx.Q, q, KEY_CONTENT_LEN/2);
242   mpi_write_binary (&rsa_ctx.N, modulus, KEY_CONTENT_LEN);
243   rsa_free (&rsa_ctx);
244   return p_q_modulus;
245 }