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