gpg: Remove all assert.h and s/assert/log_assert/.
[gnupg.git] / g10 / pkglue.c
1 /* pkglue.c - public key operations glue code
2  * Copyright (C) 2000, 2003, 2010 Free Software Foundation, Inc.
3  * Copyright (C) 2014 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "gpg.h"
28 #include "util.h"
29 #include "pkglue.h"
30 #include "main.h"
31 #include "options.h"
32
33 /* FIXME: Better change the function name because mpi_ is used by
34    gcrypt macros.  */
35 gcry_mpi_t
36 get_mpi_from_sexp (gcry_sexp_t sexp, const char *item, int mpifmt)
37 {
38   gcry_sexp_t list;
39   gcry_mpi_t data;
40
41   list = gcry_sexp_find_token (sexp, item, 0);
42   log_assert (list);
43   data = gcry_sexp_nth_mpi (list, 1, mpifmt);
44   log_assert (data);
45   gcry_sexp_release (list);
46   return data;
47 }
48
49
50
51 /****************
52  * Emulate our old PK interface here - sometime in the future we might
53  * change the internal design to directly fit to libgcrypt.
54  */
55 int
56 pk_verify (pubkey_algo_t pkalgo, gcry_mpi_t hash,
57            gcry_mpi_t *data, gcry_mpi_t *pkey)
58 {
59   gcry_sexp_t s_sig, s_hash, s_pkey;
60   int rc;
61
62   /* Make a sexp from pkey.  */
63   if (pkalgo == PUBKEY_ALGO_DSA)
64     {
65       rc = gcry_sexp_build (&s_pkey, NULL,
66                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
67                             pkey[0], pkey[1], pkey[2], pkey[3]);
68     }
69   else if (pkalgo == PUBKEY_ALGO_ELGAMAL_E || pkalgo == PUBKEY_ALGO_ELGAMAL)
70     {
71       rc = gcry_sexp_build (&s_pkey, NULL,
72                             "(public-key(elg(p%m)(g%m)(y%m)))",
73                             pkey[0], pkey[1], pkey[2]);
74     }
75   else if (pkalgo == PUBKEY_ALGO_RSA || pkalgo == PUBKEY_ALGO_RSA_S)
76     {
77       rc = gcry_sexp_build (&s_pkey, NULL,
78                             "(public-key(rsa(n%m)(e%m)))", pkey[0], pkey[1]);
79     }
80   else if (pkalgo == PUBKEY_ALGO_ECDSA)
81     {
82       char *curve = openpgp_oid_to_str (pkey[0]);
83       if (!curve)
84         rc = gpg_error_from_syserror ();
85       else
86         {
87           rc = gcry_sexp_build (&s_pkey, NULL,
88                                 "(public-key(ecdsa(curve %s)(q%m)))",
89                                 curve, pkey[1]);
90           xfree (curve);
91         }
92     }
93   else if (pkalgo == PUBKEY_ALGO_EDDSA)
94     {
95       char *curve = openpgp_oid_to_str (pkey[0]);
96       if (!curve)
97         rc = gpg_error_from_syserror ();
98       else
99         {
100           rc = gcry_sexp_build (&s_pkey, NULL,
101                                 "(public-key(ecc(curve %s)"
102                                 "(flags eddsa)(q%m)))",
103                                 curve, pkey[1]);
104           xfree (curve);
105         }
106     }
107   else
108     return GPG_ERR_PUBKEY_ALGO;
109
110   if (rc)
111     BUG ();  /* gcry_sexp_build should never fail.  */
112
113   /* Put hash into a S-Exp s_hash. */
114   if (pkalgo == PUBKEY_ALGO_EDDSA)
115     {
116       if (gcry_sexp_build (&s_hash, NULL,
117                            "(data(flags eddsa)(hash-algo sha512)(value %m))",
118                            hash))
119         BUG (); /* gcry_sexp_build should never fail.  */
120     }
121   else
122     {
123       if (gcry_sexp_build (&s_hash, NULL, "%m", hash))
124         BUG (); /* gcry_sexp_build should never fail.  */
125     }
126
127   /* Put data into a S-Exp s_sig. */
128   s_sig = NULL;
129   if (pkalgo == PUBKEY_ALGO_DSA)
130     {
131       if (!data[0] || !data[1])
132         rc = gpg_error (GPG_ERR_BAD_MPI);
133       else
134         rc = gcry_sexp_build (&s_sig, NULL,
135                               "(sig-val(dsa(r%m)(s%m)))", data[0], data[1]);
136     }
137   else if (pkalgo == PUBKEY_ALGO_ECDSA)
138     {
139       if (!data[0] || !data[1])
140         rc = gpg_error (GPG_ERR_BAD_MPI);
141       else
142         rc = gcry_sexp_build (&s_sig, NULL,
143                               "(sig-val(ecdsa(r%m)(s%m)))", data[0], data[1]);
144     }
145   else if (pkalgo == PUBKEY_ALGO_EDDSA)
146     {
147       if (!data[0] || !data[1])
148         rc = gpg_error (GPG_ERR_BAD_MPI);
149       else
150         rc = gcry_sexp_build (&s_sig, NULL,
151                               "(sig-val(eddsa(r%M)(s%M)))", data[0], data[1]);
152     }
153   else if (pkalgo == PUBKEY_ALGO_ELGAMAL || pkalgo == PUBKEY_ALGO_ELGAMAL_E)
154     {
155       if (!data[0] || !data[1])
156         rc = gpg_error (GPG_ERR_BAD_MPI);
157       else
158         rc = gcry_sexp_build (&s_sig, NULL,
159                               "(sig-val(elg(r%m)(s%m)))", data[0], data[1]);
160     }
161   else if (pkalgo == PUBKEY_ALGO_RSA || pkalgo == PUBKEY_ALGO_RSA_S)
162     {
163       if (!data[0])
164         rc = gpg_error (GPG_ERR_BAD_MPI);
165       else
166         rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(rsa(s%m)))", data[0]);
167     }
168   else
169     BUG ();
170
171   if (!rc)
172     rc = gcry_pk_verify (s_sig, s_hash, s_pkey);
173
174   gcry_sexp_release (s_sig);
175   gcry_sexp_release (s_hash);
176   gcry_sexp_release (s_pkey);
177   return rc;
178 }
179
180
181
182
183 /****************
184  * Emulate our old PK interface here - sometime in the future we might
185  * change the internal design to directly fit to libgcrypt.
186  * PK is only required to compute the fingerprint for ECDH.
187  */
188 int
189 pk_encrypt (pubkey_algo_t algo, gcry_mpi_t *resarr, gcry_mpi_t data,
190             PKT_public_key *pk, gcry_mpi_t *pkey)
191 {
192   gcry_sexp_t s_ciph = NULL;
193   gcry_sexp_t s_data = NULL;
194   gcry_sexp_t s_pkey = NULL;
195   int rc;
196
197   /* Make a sexp from pkey.  */
198   if (algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_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       /* Put DATA into a simplified S-expression.  */
204       if (!rc)
205         rc = gcry_sexp_build (&s_data, NULL, "%m", data);
206     }
207   else if (algo == PUBKEY_ALGO_RSA || algo == PUBKEY_ALGO_RSA_E)
208     {
209       rc = gcry_sexp_build (&s_pkey, NULL,
210                             "(public-key(rsa(n%m)(e%m)))",
211                             pkey[0], pkey[1]);
212       /* Put DATA into a simplified S-expression.  */
213       if (!rc)
214         rc = gcry_sexp_build (&s_data, NULL, "%m", data);
215     }
216   else if (algo == PUBKEY_ALGO_ECDH)
217     {
218       gcry_mpi_t k;
219
220       rc = pk_ecdh_generate_ephemeral_key (pkey, &k);
221       if (!rc)
222         {
223           char *curve;
224
225           curve = openpgp_oid_to_str (pkey[0]);
226           if (!curve)
227             rc = gpg_error_from_syserror ();
228           else
229             {
230               int with_djb_tweak_flag = openpgp_oid_is_crv25519 (pkey[0]);
231
232               /* Now use the ephemeral secret to compute the shared point.  */
233               rc = gcry_sexp_build (&s_pkey, NULL,
234                                     with_djb_tweak_flag ?
235                                     "(public-key(ecdh(curve%s)(flags djb-tweak)(q%m)))"
236                                     : "(public-key(ecdh(curve%s)(q%m)))",
237                                     curve, pkey[1]);
238               xfree (curve);
239               /* Put K into a simplified S-expression.  */
240               if (!rc)
241                 rc = gcry_sexp_build (&s_data, NULL, "%m", k);
242             }
243           gcry_mpi_release (k);
244         }
245     }
246   else
247     rc = gpg_error (GPG_ERR_PUBKEY_ALGO);
248
249   /* Pass it to libgcrypt. */
250   if (!rc)
251     rc = gcry_pk_encrypt (&s_ciph, s_data, s_pkey);
252
253   gcry_sexp_release (s_data);
254   gcry_sexp_release (s_pkey);
255
256   if (rc)
257     ;
258   else if (algo == PUBKEY_ALGO_ECDH)
259     {
260       gcry_mpi_t shared, public, result;
261       byte fp[MAX_FINGERPRINT_LEN];
262       size_t fpn;
263
264       /* Get the shared point and the ephemeral public key.  */
265       shared = get_mpi_from_sexp (s_ciph, "s", GCRYMPI_FMT_USG);
266       public = get_mpi_from_sexp (s_ciph, "e", GCRYMPI_FMT_USG);
267       gcry_sexp_release (s_ciph);
268       s_ciph = NULL;
269       if (DBG_CRYPTO)
270         {
271           log_debug ("ECDH ephemeral key:");
272           gcry_mpi_dump (public);
273           log_printf ("\n");
274         }
275
276       result = NULL;
277       fingerprint_from_pk (pk, fp, &fpn);
278       if (fpn != 20)
279         rc = gpg_error (GPG_ERR_INV_LENGTH);
280       else
281         rc = pk_ecdh_encrypt_with_shared_point (1 /*=encrypton*/, shared,
282                                                 fp, data, pkey, &result);
283       gcry_mpi_release (shared);
284       if (!rc)
285         {
286           resarr[0] = public;
287           resarr[1] = result;
288         }
289       else
290         {
291           gcry_mpi_release (public);
292           gcry_mpi_release (result);
293         }
294     }
295   else /* Elgamal or RSA case.  */
296     { /* Fixme: Add better error handling or make gnupg use
297          S-expressions directly.  */
298       resarr[0] = get_mpi_from_sexp (s_ciph, "a", GCRYMPI_FMT_USG);
299       if (!is_RSA (algo))
300         resarr[1] = get_mpi_from_sexp (s_ciph, "b", GCRYMPI_FMT_USG);
301     }
302
303   gcry_sexp_release (s_ciph);
304   return rc;
305 }
306
307
308 /* Check whether SKEY is a suitable secret key. */
309 int
310 pk_check_secret_key (pubkey_algo_t pkalgo, gcry_mpi_t *skey)
311 {
312   gcry_sexp_t s_skey;
313   int rc;
314
315   if (pkalgo == PUBKEY_ALGO_DSA)
316     {
317       rc = gcry_sexp_build (&s_skey, NULL,
318                             "(private-key(dsa(p%m)(q%m)(g%m)(y%m)(x%m)))",
319                             skey[0], skey[1], skey[2], skey[3], skey[4]);
320     }
321   else if (pkalgo == PUBKEY_ALGO_ELGAMAL || pkalgo == PUBKEY_ALGO_ELGAMAL_E)
322     {
323       rc = gcry_sexp_build (&s_skey, NULL,
324                             "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
325                             skey[0], skey[1], skey[2], skey[3]);
326     }
327   else if (is_RSA (pkalgo))
328     {
329       rc = gcry_sexp_build (&s_skey, NULL,
330                             "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
331                             skey[0], skey[1], skey[2], skey[3], skey[4],
332                             skey[5]);
333     }
334   else if (pkalgo == PUBKEY_ALGO_ECDSA || pkalgo == PUBKEY_ALGO_ECDH)
335     {
336       char *curve = openpgp_oid_to_str (skey[0]);
337       if (!curve)
338         rc = gpg_error_from_syserror ();
339       else
340         {
341           rc = gcry_sexp_build (&s_skey, NULL,
342                                 "(private-key(ecc(curve%s)(q%m)(d%m)))",
343                                 curve, skey[1], skey[2]);
344           xfree (curve);
345         }
346     }
347   else if (pkalgo == PUBKEY_ALGO_EDDSA)
348     {
349       char *curve = openpgp_oid_to_str (skey[0]);
350       if (!curve)
351         rc = gpg_error_from_syserror ();
352       else
353         {
354           rc = gcry_sexp_build (&s_skey, NULL,
355                                 "(private-key(ecc(curve %s)"
356                                 "(flags eddsa)(q%m)(d%m)))",
357                                 curve, skey[1], skey[2]);
358           xfree (curve);
359         }
360     }
361   else
362     return GPG_ERR_PUBKEY_ALGO;
363
364   if (!rc)
365     {
366       rc = gcry_pk_testkey (s_skey);
367       gcry_sexp_release (s_skey);
368     }
369   return rc;
370 }