abec77d9da3d9f4b5e48a01221aa168a527c3816
[gnupg.git] / g10 / pkglue.c
1 /* pkglue.c - public key operations glue code
2  *      Copyright (C) 2000, 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG 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 General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "gpg.h"
29 #include "util.h"
30 #include "pkglue.h"
31
32
33
34 /****************
35  * Emulate our old PK interface here - sometime in the future we might
36  * change the internal design to directly fit to libgcrypt.
37  */
38 int
39 pk_sign (int algo, gcry_mpi_t * data, gcry_mpi_t hash, gcry_mpi_t * skey)
40 {
41   gcry_sexp_t s_sig, s_hash, s_skey, list;
42   int rc;
43
44   /* make a sexp from skey */
45   if (algo == GCRY_PK_DSA)
46     {
47       rc = gcry_sexp_build (&s_skey, NULL,
48                             "(private-key(dsa(p%m)(q%m)(g%m)(y%m)(x%m)))",
49                             skey[0], skey[1], skey[2], skey[3], skey[4]);
50     }
51   else if (algo == GCRY_PK_RSA)
52     {
53       rc = gcry_sexp_build (&s_skey, NULL,
54                             "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
55                             skey[0], skey[1], skey[2], skey[3], skey[4],
56                             skey[5]);
57     }
58   else if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
59     {
60       rc = gcry_sexp_build (&s_skey, NULL,
61                             "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
62                             skey[0], skey[1], skey[2], skey[3]);
63     }
64   else
65     return GPG_ERR_PUBKEY_ALGO;
66
67   if (rc)
68     BUG ();
69
70   /* put hash into a S-Exp s_hash */
71   if (gcry_sexp_build (&s_hash, NULL, "%m", hash))
72     BUG ();
73
74   rc = gcry_pk_sign (&s_sig, s_hash, s_skey);
75   gcry_sexp_release (s_hash);
76   gcry_sexp_release (s_skey);
77
78   if (rc)
79     ;
80   else if (algo == GCRY_PK_RSA)
81     {
82       list = gcry_sexp_find_token (s_sig, "s", 0);
83       assert (list);
84       data[0] = gcry_sexp_nth_mpi (list, 1, 0);
85       assert (data[0]);
86       gcry_sexp_release (list);
87     }
88   else
89     {
90       list = gcry_sexp_find_token (s_sig, "r", 0);
91       assert (list);
92       data[0] = gcry_sexp_nth_mpi (list, 1, 0);
93       assert (data[0]);
94       gcry_sexp_release (list);
95
96       list = gcry_sexp_find_token (s_sig, "s", 0);
97       assert (list);
98       data[1] = gcry_sexp_nth_mpi (list, 1, 0);
99       assert (data[1]);
100       gcry_sexp_release (list);
101     }
102
103
104   gcry_sexp_release (s_sig);
105   return rc;
106 }
107
108 /****************
109  * Emulate our old PK interface here - sometime in the future we might
110  * change the internal design to directly fit to libgcrypt.
111  */
112 int
113 pk_verify (int algo, gcry_mpi_t hash, gcry_mpi_t * data, gcry_mpi_t * pkey)
114 {
115   gcry_sexp_t s_sig, s_hash, s_pkey;
116   int rc;
117
118   /* make a sexp from pkey */
119   if (algo == GCRY_PK_DSA)
120     {
121       rc = gcry_sexp_build (&s_pkey, NULL,
122                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
123                             pkey[0], pkey[1], pkey[2], pkey[3]);
124     }
125   else if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
126     {
127       rc = gcry_sexp_build (&s_pkey, NULL,
128                             "(public-key(elg(p%m)(g%m)(y%m)))",
129                             pkey[0], pkey[1], pkey[2]);
130     }
131   else if (algo == GCRY_PK_RSA)
132     {
133       rc = gcry_sexp_build (&s_pkey, NULL,
134                             "(public-key(rsa(n%m)(e%m)))", pkey[0], pkey[1]);
135     }
136   else
137     return GPG_ERR_PUBKEY_ALGO;
138
139   if (rc)
140     BUG ();
141
142   /* put hash into a S-Exp s_hash */
143   if (gcry_sexp_build (&s_hash, NULL, "%m", hash))
144     BUG ();
145
146   /* put data into a S-Exp s_sig */
147   if (algo == GCRY_PK_DSA)
148     {
149       if (!data[0] || !data[1])
150         rc = gpg_error (GPG_ERR_BAD_MPI);
151       else
152         rc = gcry_sexp_build (&s_sig, NULL,
153                               "(sig-val(dsa(r%m)(s%m)))", data[0], data[1]);
154     }
155   else if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
156     {
157       if (!data[0] || !data[1])
158         rc = gpg_error (GPG_ERR_BAD_MPI);
159       else
160         rc = gcry_sexp_build (&s_sig, NULL,
161                               "(sig-val(elg(r%m)(s%m)))", data[0], data[1]);
162     }
163   else if (algo == GCRY_PK_RSA)
164     {
165       if (!data[0])
166         rc = gpg_error (GPG_ERR_BAD_MPI);
167       else
168         rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(rsa(s%m)))", data[0]);
169     }
170   else
171     BUG ();
172
173   if (rc)
174     BUG ();
175
176
177   rc = gcry_pk_verify (s_sig, s_hash, s_pkey);
178   gcry_sexp_release (s_sig);
179   gcry_sexp_release (s_hash);
180   gcry_sexp_release (s_pkey);
181   return rc;
182 }
183
184
185
186
187 /****************
188  * Emulate our old PK interface here - sometime in the future we might
189  * change the internal design to directly fit to libgcrypt.
190  */
191 int
192 pk_encrypt (int algo, gcry_mpi_t * resarr, gcry_mpi_t data, gcry_mpi_t * pkey)
193 {
194   gcry_sexp_t s_ciph, s_data, s_pkey;
195   int rc;
196
197   /* make a sexp from pkey */
198   if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
199     {
200       rc = gcry_sexp_build (&s_pkey, NULL,
201                             "(public-key(elg(p%m)(g%m)(y%m)))",
202                             pkey[0], pkey[1], pkey[2]);
203     }
204   else if (algo == GCRY_PK_RSA)
205     {
206       rc = gcry_sexp_build (&s_pkey, NULL,
207                             "(public-key(rsa(n%m)(e%m)))",
208                             pkey[0], pkey[1]);
209     }
210   else
211     return GPG_ERR_PUBKEY_ALGO;
212
213   if (rc)
214     BUG ();
215
216   /* put the data into a simple list */
217   if (gcry_sexp_build (&s_data, NULL, "%m", data))
218     BUG ();
219
220   /* pass it to libgcrypt */
221   rc = gcry_pk_encrypt (&s_ciph, s_data, s_pkey);
222   gcry_sexp_release (s_data);
223   gcry_sexp_release (s_pkey);
224
225   if (rc)
226     ;
227   else
228     { /* add better error handling or make gnupg use S-Exp directly */
229       gcry_sexp_t list = gcry_sexp_find_token (s_ciph, "a", 0);
230       assert (list);
231       resarr[0] = gcry_sexp_nth_mpi (list, 1, 0);
232       assert (resarr[0]);
233       gcry_sexp_release (list);
234
235       if (algo != GCRY_PK_RSA)
236         {
237           list = gcry_sexp_find_token (s_ciph, "b", 0);
238           assert (list);
239           resarr[1] = gcry_sexp_nth_mpi (list, 1, 0);
240           assert (resarr[1]);
241           gcry_sexp_release (list);
242         }
243     }
244
245   gcry_sexp_release (s_ciph);
246   return rc;
247 }
248
249
250
251 /****************
252  * Emulate our old PK interface here - sometime in the future we might
253  * change the internal design to directly fit to libgcrypt.
254  */
255 int
256 pk_decrypt (int algo, gcry_mpi_t * result, gcry_mpi_t * data,
257             gcry_mpi_t * skey)
258 {
259   gcry_sexp_t s_skey, s_data, s_plain;
260   int rc;
261
262   *result = NULL;
263   /* make a sexp from skey */
264   if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
265     {
266       rc = gcry_sexp_build (&s_skey, NULL,
267                             "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
268                             skey[0], skey[1], skey[2], skey[3]);
269     }
270   else if (algo == GCRY_PK_RSA)
271     {
272       rc = gcry_sexp_build (&s_skey, NULL,
273                             "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
274                             skey[0], skey[1], skey[2], skey[3], skey[4],
275                             skey[5]);
276     }
277   else
278     return GPG_ERR_PUBKEY_ALGO;
279
280   if (rc)
281     BUG ();
282
283   /* put data into a S-Exp s_data */
284   if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
285     {
286       if (!data[0] || !data[1])
287         rc = gpg_error (GPG_ERR_BAD_MPI);
288       else
289         rc = gcry_sexp_build (&s_data, NULL,
290                               "(enc-val(elg(a%m)(b%m)))", data[0], data[1]);
291     }
292   else if (algo == GCRY_PK_RSA)
293     {
294       if (!data[0])
295         rc = gpg_error (GPG_ERR_BAD_MPI);
296       else
297         rc = gcry_sexp_build (&s_data, NULL, "(enc-val(rsa(a%m)))", data[0]);
298     }
299   else
300     BUG ();
301
302   if (rc)
303     BUG ();
304
305   rc = gcry_pk_decrypt (&s_plain, s_data, s_skey);
306   gcry_sexp_release (s_skey);
307   gcry_sexp_release (s_data);
308   if (rc)
309     return rc;
310
311   *result = gcry_sexp_nth_mpi (s_plain, 0, 0);
312   gcry_sexp_release (s_plain);
313   if (!*result)
314     return -1;                  /* oops */
315
316   return 0;
317 }
318
319
320 /* Check whether SKEY is a suitable secret key. */
321 int
322 pk_check_secret_key (int algo, gcry_mpi_t *skey)
323 {
324   gcry_sexp_t s_skey;
325   int rc;
326
327   if (algo == GCRY_PK_DSA)
328     {
329       rc = gcry_sexp_build (&s_skey, NULL,
330                             "(private-key(dsa(p%m)(q%m)(g%m)(y%m)(x%m)))",
331                             skey[0], skey[1], skey[2], skey[3], skey[4]);
332     }
333   else if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
334     {
335       rc = gcry_sexp_build (&s_skey, NULL,
336                             "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
337                             skey[0], skey[1], skey[2], skey[3]);
338     }
339   else if (algo == GCRY_PK_RSA)
340     {
341       rc = gcry_sexp_build (&s_skey, NULL,
342                             "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
343                             skey[0], skey[1], skey[2], skey[3], skey[4],
344                             skey[5]);
345     }
346   else
347     return GPG_ERR_PUBKEY_ALGO;
348
349   if (!rc)
350     {
351       rc = gcry_pk_testkey (s_skey);
352       gcry_sexp_release (s_skey);
353     }
354   return rc;
355 }