2010-06-08 Marcus Brinkmann <marcus@g10code.de>
[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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <assert.h>
26
27 #include "gpg.h"
28 #include "util.h"
29 #include "pkglue.h"
30
31
32 static gcry_mpi_t
33 mpi_from_sexp (gcry_sexp_t sexp, const char * item)
34 {
35   gcry_sexp_t list;
36   gcry_mpi_t data;
37   
38   list = gcry_sexp_find_token (sexp, item, 0);
39   assert (list);
40   data = gcry_sexp_nth_mpi (list, 1, 0);
41   assert (data);
42   gcry_sexp_release (list);
43   return data;
44 }
45
46
47
48 /****************
49  * Emulate our old PK interface here - sometime in the future we might
50  * change the internal design to directly fit to libgcrypt.
51  */
52 int
53 pk_verify (int algo, gcry_mpi_t hash, gcry_mpi_t * data, gcry_mpi_t * pkey)
54 {
55   gcry_sexp_t s_sig, s_hash, s_pkey;
56   int rc;
57
58   /* make a sexp from pkey */
59   if (algo == GCRY_PK_DSA)
60     {
61       rc = gcry_sexp_build (&s_pkey, NULL,
62                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
63                             pkey[0], pkey[1], pkey[2], pkey[3]);
64     }
65   else if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
66     {
67       rc = gcry_sexp_build (&s_pkey, NULL,
68                             "(public-key(elg(p%m)(g%m)(y%m)))",
69                             pkey[0], pkey[1], pkey[2]);
70     }
71   else if (algo == GCRY_PK_RSA || algo == GCRY_PK_RSA_S)
72     {
73       rc = gcry_sexp_build (&s_pkey, NULL,
74                             "(public-key(rsa(n%m)(e%m)))", pkey[0], pkey[1]);
75     }
76   else
77     return GPG_ERR_PUBKEY_ALGO;
78
79   if (rc)
80     BUG ();  /* gcry_sexp_build should never fail.  */
81
82   /* put hash into a S-Exp s_hash */
83   if (gcry_sexp_build (&s_hash, NULL, "%m", hash))
84     BUG (); /* gcry_sexp_build should never fail.  */
85
86   /* Put data into a S-Exp s_sig. */
87   s_sig = NULL;
88   if (algo == GCRY_PK_DSA)
89     {
90       if (!data[0] || !data[1])
91         rc = gpg_error (GPG_ERR_BAD_MPI);
92       else
93         rc = gcry_sexp_build (&s_sig, NULL,
94                               "(sig-val(dsa(r%m)(s%m)))", data[0], data[1]);
95     }
96   else if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
97     {
98       if (!data[0] || !data[1])
99         rc = gpg_error (GPG_ERR_BAD_MPI);
100       else
101         rc = gcry_sexp_build (&s_sig, NULL,
102                               "(sig-val(elg(r%m)(s%m)))", data[0], data[1]);
103     }
104   else if (algo == GCRY_PK_RSA || algo == GCRY_PK_RSA_S)
105     {
106       if (!data[0])
107         rc = gpg_error (GPG_ERR_BAD_MPI);
108       else
109         rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(rsa(s%m)))", data[0]);
110     }
111   else
112     BUG ();
113
114   if (!rc)
115     rc = gcry_pk_verify (s_sig, s_hash, s_pkey);
116
117   gcry_sexp_release (s_sig);
118   gcry_sexp_release (s_hash);
119   gcry_sexp_release (s_pkey);
120   return rc;
121 }
122
123
124
125
126 /****************
127  * Emulate our old PK interface here - sometime in the future we might
128  * change the internal design to directly fit to libgcrypt.
129  */
130 int
131 pk_encrypt (int algo, gcry_mpi_t * resarr, gcry_mpi_t data, gcry_mpi_t * pkey)
132 {
133   gcry_sexp_t s_ciph, s_data, s_pkey;
134   int rc;
135
136   /* make a sexp from pkey */
137   if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
138     {
139       rc = gcry_sexp_build (&s_pkey, NULL,
140                             "(public-key(elg(p%m)(g%m)(y%m)))",
141                             pkey[0], pkey[1], pkey[2]);
142     }
143   else if (algo == GCRY_PK_RSA || algo == GCRY_PK_RSA_E)
144     {
145       rc = gcry_sexp_build (&s_pkey, NULL,
146                             "(public-key(rsa(n%m)(e%m)))",
147                             pkey[0], pkey[1]);
148     }
149   else
150     return GPG_ERR_PUBKEY_ALGO;
151
152   if (rc)
153     BUG ();
154
155   /* put the data into a simple list */
156   if (gcry_sexp_build (&s_data, NULL, "%m", data))
157     BUG ();
158
159   /* pass it to libgcrypt */
160   rc = gcry_pk_encrypt (&s_ciph, s_data, s_pkey);
161   gcry_sexp_release (s_data);
162   gcry_sexp_release (s_pkey);
163
164   if (rc)
165     ;
166   else
167     { /* add better error handling or make gnupg use S-Exp directly */
168       resarr[0] = mpi_from_sexp (s_ciph, "a");
169       if (algo != GCRY_PK_RSA && algo != GCRY_PK_RSA_E)
170         resarr[1] = mpi_from_sexp (s_ciph, "b");
171     }
172
173   gcry_sexp_release (s_ciph);
174   return rc;
175 }
176
177
178
179 /****************
180  * Emulate our old PK interface here - sometime in the future we might
181  * change the internal design to directly fit to libgcrypt.
182  */
183 int
184 pk_decrypt (int algo, gcry_mpi_t * result, gcry_mpi_t * data,
185             gcry_mpi_t * skey)
186 {
187   gcry_sexp_t s_skey, s_data, s_plain;
188   int rc;
189
190   *result = NULL;
191   /* make a sexp from skey */
192   if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
193     {
194       rc = gcry_sexp_build (&s_skey, NULL,
195                             "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
196                             skey[0], skey[1], skey[2], skey[3]);
197     }
198   else if (algo == GCRY_PK_RSA || algo == GCRY_PK_RSA_E)
199     {
200       rc = gcry_sexp_build (&s_skey, NULL,
201                             "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
202                             skey[0], skey[1], skey[2], skey[3], skey[4],
203                             skey[5]);
204     }
205   else
206     return GPG_ERR_PUBKEY_ALGO;
207
208   if (rc)
209     BUG ();
210
211   /* put data into a S-Exp s_data */
212   if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
213     {
214       if (!data[0] || !data[1])
215         rc = gpg_error (GPG_ERR_BAD_MPI);
216       else
217         rc = gcry_sexp_build (&s_data, NULL,
218                               "(enc-val(elg(a%m)(b%m)))", data[0], data[1]);
219     }
220   else if (algo == GCRY_PK_RSA || algo == GCRY_PK_RSA_E)
221     {
222       if (!data[0])
223         rc = gpg_error (GPG_ERR_BAD_MPI);
224       else
225         rc = gcry_sexp_build (&s_data, NULL, "(enc-val(rsa(a%m)))", data[0]);
226     }
227   else
228     BUG ();
229
230   if (rc)
231     BUG ();
232
233   rc = gcry_pk_decrypt (&s_plain, s_data, s_skey);
234   gcry_sexp_release (s_skey);
235   gcry_sexp_release (s_data);
236   if (rc)
237     return rc;
238
239   *result = gcry_sexp_nth_mpi (s_plain, 0, 0);
240   gcry_sexp_release (s_plain);
241   if (!*result)
242     return -1;                  /* oops */
243
244   return 0;
245 }
246
247
248 /* Check whether SKEY is a suitable secret key. */
249 int
250 REMOVE_ME_pk_check_secret_key (int algo, gcry_mpi_t *skey)
251 {
252   gcry_sexp_t s_skey;
253   int rc;
254
255   if (algo == GCRY_PK_DSA)
256     {
257       rc = gcry_sexp_build (&s_skey, NULL,
258                             "(private-key(dsa(p%m)(q%m)(g%m)(y%m)(x%m)))",
259                             skey[0], skey[1], skey[2], skey[3], skey[4]);
260     }
261   else if (algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E)
262     {
263       rc = gcry_sexp_build (&s_skey, NULL,
264                             "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
265                             skey[0], skey[1], skey[2], skey[3]);
266     }
267   else if (algo == GCRY_PK_RSA
268            || algo == GCRY_PK_RSA_S || algo == GCRY_PK_RSA_E)
269     {
270       rc = gcry_sexp_build (&s_skey, NULL,
271                             "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
272                             skey[0], skey[1], skey[2], skey[3], skey[4],
273                             skey[5]);
274     }
275   else
276     return GPG_ERR_PUBKEY_ALGO;
277
278   if (!rc)
279     {
280       rc = gcry_pk_testkey (s_skey);
281       gcry_sexp_release (s_skey);
282     }
283   return rc;
284 }