gpg: Check and fix keys on import.
[gnupg.git] / g10 / free-packet.c
1 /* free-packet.c - cleanup stuff for packets
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2005, 2010  Free Software Foundation, Inc.
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 <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "gpg.h"
27 #include "../common/util.h"
28 #include "packet.h"
29 #include "../common/iobuf.h"
30 #include "options.h"
31
32
33 /* This is mpi_copy with a fix for opaque MPIs which store a NULL
34    pointer.  This will also be fixed in Libggcrypt 1.7.0.  */
35 static gcry_mpi_t
36 my_mpi_copy (gcry_mpi_t a)
37 {
38   if (a
39       && gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE)
40       && !gcry_mpi_get_opaque (a, NULL))
41     return NULL;
42
43   return gcry_mpi_copy (a);
44 }
45
46
47 void
48 free_symkey_enc( PKT_symkey_enc *enc )
49 {
50     xfree(enc);
51 }
52
53 void
54 free_pubkey_enc( PKT_pubkey_enc *enc )
55 {
56     int n, i;
57     n = pubkey_get_nenc( enc->pubkey_algo );
58     if( !n )
59         mpi_release(enc->data[0]);
60     for(i=0; i < n; i++ )
61         mpi_release( enc->data[i] );
62     xfree(enc);
63 }
64
65 void
66 free_seckey_enc( PKT_signature *sig )
67 {
68   int n, i;
69
70   n = pubkey_get_nsig( sig->pubkey_algo );
71   if( !n )
72     mpi_release(sig->data[0]);
73   for(i=0; i < n; i++ )
74     mpi_release( sig->data[i] );
75
76   xfree(sig->revkey);
77   xfree(sig->hashed);
78   xfree(sig->unhashed);
79
80   if (sig->pka_info)
81     {
82       xfree (sig->pka_info->uri);
83       xfree (sig->pka_info);
84     }
85   xfree (sig->signers_uid);
86
87   xfree(sig);
88 }
89
90
91 void
92 release_public_key_parts (PKT_public_key *pk)
93 {
94   int n, i;
95
96   if (pk->seckey_info)
97     n = pubkey_get_nskey (pk->pubkey_algo);
98   else
99     n = pubkey_get_npkey (pk->pubkey_algo);
100   if (!n)
101     mpi_release (pk->pkey[0]);
102   for (i=0; i < n; i++ )
103     {
104       mpi_release (pk->pkey[i]);
105       pk->pkey[i] = NULL;
106     }
107   if (pk->seckey_info)
108     {
109       xfree (pk->seckey_info);
110       pk->seckey_info = NULL;
111     }
112   if (pk->prefs)
113     {
114       xfree (pk->prefs);
115       pk->prefs = NULL;
116     }
117   free_user_id (pk->user_id);
118   pk->user_id = NULL;
119   if (pk->revkey)
120     {
121       xfree(pk->revkey);
122       pk->revkey=NULL;
123       pk->numrevkeys=0;
124     }
125   if (pk->serialno)
126     {
127       xfree (pk->serialno);
128       pk->serialno = NULL;
129     }
130   if (pk->updateurl)
131     {
132       xfree (pk->updateurl);
133       pk->updateurl = NULL;
134     }
135 }
136
137
138 /* Free an allocated public key structure including all parts.
139    Passing NULL is allowed.  */
140 void
141 free_public_key (PKT_public_key *pk)
142 {
143   if (pk)
144     {
145       release_public_key_parts (pk);
146       xfree(pk);
147     }
148 }
149
150
151 static subpktarea_t *
152 cp_subpktarea (subpktarea_t *s )
153 {
154     subpktarea_t *d;
155
156     if( !s )
157         return NULL;
158     d = xmalloc (sizeof (*d) + s->size - 1 );
159     d->size = s->size;
160     d->len = s->len;
161     memcpy (d->data, s->data, s->len);
162     return d;
163 }
164
165 /*
166  * Return a copy of the preferences
167  */
168 prefitem_t *
169 copy_prefs (const prefitem_t *prefs)
170 {
171     size_t n;
172     prefitem_t *new;
173
174     if (!prefs)
175         return NULL;
176
177     for (n=0; prefs[n].type; n++)
178         ;
179     new = xmalloc ( sizeof (*new) * (n+1));
180     for (n=0; prefs[n].type; n++) {
181         new[n].type = prefs[n].type;
182         new[n].value = prefs[n].value;
183     }
184     new[n].type = PREFTYPE_NONE;
185     new[n].value = 0;
186
187     return new;
188 }
189
190
191 /* Copy the public key S to D.  If D is NULL allocate a new public key
192    structure.  If S has seckret key infos, only the public stuff is
193    copied.  */
194 PKT_public_key *
195 copy_public_key (PKT_public_key *d, PKT_public_key *s)
196 {
197   int n, i;
198
199   if (!d)
200     d = xmalloc (sizeof *d);
201   memcpy (d, s, sizeof *d);
202   d->seckey_info = NULL;
203   d->user_id = scopy_user_id (s->user_id);
204   d->prefs = copy_prefs (s->prefs);
205
206   n = pubkey_get_npkey (s->pubkey_algo);
207   i = 0;
208   if (!n)
209     d->pkey[i++] = my_mpi_copy (s->pkey[0]);
210   else
211     {
212       for (; i < n; i++ )
213         d->pkey[i] = my_mpi_copy (s->pkey[i]);
214     }
215   for (; i < PUBKEY_MAX_NSKEY; i++)
216     d->pkey[i] = NULL;
217
218   if (!s->revkey && s->numrevkeys)
219     BUG();
220   if (s->numrevkeys)
221     {
222       d->revkey = xmalloc(sizeof(struct revocation_key)*s->numrevkeys);
223       memcpy(d->revkey,s->revkey,sizeof(struct revocation_key)*s->numrevkeys);
224     }
225   else
226     d->revkey = NULL;
227   return d;
228 }
229
230
231
232 static pka_info_t *
233 cp_pka_info (const pka_info_t *s)
234 {
235   pka_info_t *d = xmalloc (sizeof *s + strlen (s->email));
236
237   d->valid = s->valid;
238   d->checked = s->checked;
239   d->uri = s->uri? xstrdup (s->uri):NULL;
240   memcpy (d->fpr, s->fpr, sizeof s->fpr);
241   strcpy (d->email, s->email);
242   return d;
243 }
244
245
246 PKT_signature *
247 copy_signature( PKT_signature *d, PKT_signature *s )
248 {
249     int n, i;
250
251     if( !d )
252         d = xmalloc(sizeof *d);
253     memcpy( d, s, sizeof *d );
254     n = pubkey_get_nsig( s->pubkey_algo );
255     if( !n )
256         d->data[0] = my_mpi_copy(s->data[0]);
257     else {
258         for(i=0; i < n; i++ )
259             d->data[i] = my_mpi_copy( s->data[i] );
260     }
261     d->pka_info = s->pka_info? cp_pka_info (s->pka_info) : NULL;
262     d->hashed = cp_subpktarea (s->hashed);
263     d->unhashed = cp_subpktarea (s->unhashed);
264     if (s->signers_uid)
265       d->signers_uid = xstrdup (s->signers_uid);
266     if(s->numrevkeys)
267       {
268         d->revkey=NULL;
269         d->numrevkeys=0;
270         parse_revkeys(d);
271       }
272     return d;
273 }
274
275
276 /*
277  * shallow copy of the user ID
278  */
279 PKT_user_id *
280 scopy_user_id (PKT_user_id *s)
281 {
282     if (s)
283         s->ref++;
284     return s;
285 }
286
287
288
289 void
290 free_comment( PKT_comment *rem )
291 {
292     xfree(rem);
293 }
294
295 void
296 free_attributes(PKT_user_id *uid)
297 {
298   if (!uid)
299     return;
300
301   xfree(uid->attribs);
302   xfree(uid->attrib_data);
303
304   uid->attribs=NULL;
305   uid->attrib_data=NULL;
306   uid->attrib_len=0;
307 }
308
309 void
310 free_user_id (PKT_user_id *uid)
311 {
312   if (!uid)
313     return;
314
315   log_assert (uid->ref > 0);
316   if (--uid->ref)
317     return;
318
319   free_attributes(uid);
320   xfree (uid->prefs);
321   xfree (uid->namehash);
322   xfree (uid->updateurl);
323   xfree (uid->mbox);
324   xfree (uid);
325 }
326
327 void
328 free_compressed( PKT_compressed *zd )
329 {
330   if (!zd)
331     return;
332
333   if (zd->buf)
334     {
335       /* We need to skip some bytes.  Because don't have any
336        * information about the length, so we assume this is the last
337        * packet */
338       while (iobuf_read( zd->buf, NULL, 1<<30 ) != -1)
339         ;
340     }
341   xfree(zd);
342 }
343
344 void
345 free_encrypted( PKT_encrypted *ed )
346 {
347   if (!ed)
348     return;
349
350   if (ed->buf)
351     {
352       /* We need to skip some bytes. */
353       if (ed->is_partial)
354         {
355           while (iobuf_read( ed->buf, NULL, 1<<30 ) != -1)
356             ;
357         }
358       else
359         {
360           while (ed->len)
361             {
362               /* Skip the packet. */
363               int n = iobuf_read( ed->buf, NULL, ed->len );
364               if (n == -1)
365                 ed->len = 0;
366               else
367                 ed->len -= n;
368             }
369         }
370     }
371   xfree (ed);
372 }
373
374
375 void
376 free_plaintext( PKT_plaintext *pt )
377 {
378   if (!pt)
379     return;
380
381   if (pt->buf)
382     { /* We need to skip some bytes.  */
383       if (pt->is_partial)
384         {
385           while (iobuf_read( pt->buf, NULL, 1<<30 ) != -1)
386             ;
387         }
388       else
389         {
390           while( pt->len )
391             { /* Skip the packet.  */
392               int n = iobuf_read( pt->buf, NULL, pt->len );
393               if (n == -1)
394                 pt->len = 0;
395               else
396                 pt->len -= n;
397             }
398         }
399     }
400   xfree (pt);
401 }
402
403
404 /****************
405  * Free the packet in PKT.
406  */
407 void
408 free_packet (PACKET *pkt, parse_packet_ctx_t parsectx)
409 {
410   if (!pkt || !pkt->pkt.generic)
411     {
412       if (parsectx && parsectx->last_pkt.pkt.generic)
413         {
414           if (parsectx->free_last_pkt)
415             {
416               free_packet (&parsectx->last_pkt, NULL);
417               parsectx->free_last_pkt = 0;
418             }
419           parsectx->last_pkt.pkttype = 0;
420           parsectx->last_pkt.pkt.generic = NULL;
421         }
422       return;
423     }
424
425   if (DBG_MEMORY)
426     log_debug ("free_packet() type=%d\n", pkt->pkttype);
427
428   /* If we have a parser context holding PKT then do not free the
429    * packet but set a flag that the packet in the parser context is
430    * now a deep copy.  */
431   if (parsectx && !parsectx->free_last_pkt
432       && parsectx->last_pkt.pkttype == pkt->pkttype
433       && parsectx->last_pkt.pkt.generic == pkt->pkt.generic)
434     {
435       parsectx->last_pkt = *pkt;
436       parsectx->free_last_pkt = 1;
437       pkt->pkt.generic = NULL;
438       return;
439     }
440
441   switch (pkt->pkttype)
442     {
443     case PKT_SIGNATURE:
444       free_seckey_enc (pkt->pkt.signature);
445       break;
446     case PKT_PUBKEY_ENC:
447       free_pubkey_enc (pkt->pkt.pubkey_enc);
448       break;
449     case PKT_SYMKEY_ENC:
450       free_symkey_enc (pkt->pkt.symkey_enc);
451       break;
452     case PKT_PUBLIC_KEY:
453     case PKT_PUBLIC_SUBKEY:
454     case PKT_SECRET_KEY:
455     case PKT_SECRET_SUBKEY:
456       free_public_key (pkt->pkt.public_key);
457       break;
458     case PKT_COMMENT:
459       free_comment (pkt->pkt.comment);
460       break;
461     case PKT_USER_ID:
462       free_user_id (pkt->pkt.user_id);
463       break;
464     case PKT_COMPRESSED:
465       free_compressed (pkt->pkt.compressed);
466       break;
467     case PKT_ENCRYPTED:
468     case PKT_ENCRYPTED_MDC:
469       free_encrypted (pkt->pkt.encrypted);
470       break;
471     case PKT_PLAINTEXT:
472       free_plaintext (pkt->pkt.plaintext);
473       break;
474     default:
475       xfree (pkt->pkt.generic);
476       break;
477     }
478
479   pkt->pkt.generic = NULL;
480 }
481
482
483 /****************
484  * returns 0 if they match.
485  */
486 int
487 cmp_public_keys( PKT_public_key *a, PKT_public_key *b )
488 {
489     int n, i;
490
491     if( a->timestamp != b->timestamp )
492         return -1;
493     if( a->version < 4 && a->expiredate != b->expiredate )
494         return -1;
495     if( a->pubkey_algo != b->pubkey_algo )
496         return -1;
497
498     n = pubkey_get_npkey( b->pubkey_algo );
499     if( !n ) { /* unknown algorithm, rest is in opaque MPI */
500         if( mpi_cmp( a->pkey[0], b->pkey[0] ) )
501             return -1; /* can't compare due to unknown algorithm */
502     } else {
503         for(i=0; i < n; i++ ) {
504             if( mpi_cmp( a->pkey[i], b->pkey[i] ) )
505                 return -1;
506         }
507     }
508
509     return 0;
510 }
511
512
513
514 int
515 cmp_signatures( PKT_signature *a, PKT_signature *b )
516 {
517     int n, i;
518
519     if( a->keyid[0] != b->keyid[0] )
520         return -1;
521     if( a->keyid[1] != b->keyid[1] )
522         return -1;
523     if( a->pubkey_algo != b->pubkey_algo )
524         return -1;
525
526     n = pubkey_get_nsig( a->pubkey_algo );
527     if( !n )
528         return -1; /* can't compare due to unknown algorithm */
529     for(i=0; i < n; i++ ) {
530         if( mpi_cmp( a->data[i] , b->data[i] ) )
531             return -1;
532     }
533     return 0;
534 }
535
536
537 /****************
538  * Returns: true if the user ids do not match
539  */
540 int
541 cmp_user_ids( PKT_user_id *a, PKT_user_id *b )
542 {
543     int res=1;
544
545     if( a == b )
546         return 0;
547
548     if( a->attrib_data && b->attrib_data )
549       {
550         res = a->attrib_len - b->attrib_len;
551         if( !res )
552           res = memcmp( a->attrib_data, b->attrib_data, a->attrib_len );
553       }
554     else if( !a->attrib_data && !b->attrib_data )
555       {
556         res = a->len - b->len;
557         if( !res )
558           res = memcmp( a->name, b->name, a->len );
559       }
560
561     return res;
562 }