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 <http://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 "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   if (pk->user_id)
 118     {
 119       free_user_id (pk->user_id);
 120       pk->user_id = NULL;
 121     }
 122   if (pk->revkey)
 123     {
 124       xfree(pk->revkey);
 125       pk->revkey=NULL;
 126       pk->numrevkeys=0;
 127     }
 128   if (pk->serialno)
 129     {
 130       xfree (pk->serialno);
 131       pk->serialno = NULL;
 132     }
 133 }
 134
 135
 136 /* Free an allocated public key structure including all parts.
 137    Passing NULL is allowed.  */
 138 void
 139 free_public_key (PKT_public_key *pk)
 140 {
 141   if (pk)
 142     {
 143       release_public_key_parts (pk);
 144       xfree(pk);
 145     }
 146 }
 147
 148
 149 static subpktarea_t *
 150 cp_subpktarea (subpktarea_t *s )
 151 {
 152     subpktarea_t *d;
 153
 154     if( !s )
 155         return NULL;
 156     d = xmalloc (sizeof (*d) + s->size - 1 );
 157     d->size = s->size;
 158     d->len = s->len;
 159     memcpy (d->data, s->data, s->len);
 160     return d;
 161 }
 162
 163 /*
 164  * Return a copy of the preferences
 165  */
 166 prefitem_t *
 167 copy_prefs (const prefitem_t *prefs)
 168 {
 169     size_t n;
 170     prefitem_t *new;
 171
 172     if (!prefs)
 173         return NULL;
 174
 175     for (n=0; prefs[n].type; n++)
 176         ;
 177     new = xmalloc ( sizeof (*new) * (n+1));
 178     for (n=0; prefs[n].type; n++) {
 179         new[n].type = prefs[n].type;
 180         new[n].value = prefs[n].value;
 181     }
 182     new[n].type = PREFTYPE_NONE;
 183     new[n].value = 0;
 184
 185     return new;
 186 }
 187
 188
 189 /* Copy the public key S to D.  If D is NULL allocate a new public key
 190    structure.  If S has seckret key infos, only the public stuff is
 191    copied.  */
 192 PKT_public_key *
 193 copy_public_key (PKT_public_key *d, PKT_public_key *s)
 194 {
 195   int n, i;
 196
 197   if (!d)
 198     d = xmalloc (sizeof *d);
 199   memcpy (d, s, sizeof *d);
 200   d->seckey_info = NULL;
 201   d->user_id = scopy_user_id (s->user_id);
 202   d->prefs = copy_prefs (s->prefs);
 203
 204   n = pubkey_get_npkey (s->pubkey_algo);
 205   i = 0;
 206   if (!n)
 207     d->pkey[i++] = my_mpi_copy (s->pkey[0]);
 208   else
 209     {
 210       for (; i < n; i++ )
 211         d->pkey[i] = my_mpi_copy (s->pkey[i]);
 212     }
 213   for (; i < PUBKEY_MAX_NSKEY; i++)
 214     d->pkey[i] = NULL;
 215
 216   if (!s->revkey && s->numrevkeys)
 217     BUG();
 218   if (s->numrevkeys)
 219     {
 220       d->revkey = xmalloc(sizeof(struct revocation_key)*s->numrevkeys);
 221       memcpy(d->revkey,s->revkey,sizeof(struct revocation_key)*s->numrevkeys);
 222     }
 223   else
 224     d->revkey = NULL;
 225   return d;
 226 }
 227
 228
 229
 230 static pka_info_t *
 231 cp_pka_info (const pka_info_t *s)
 232 {
 233   pka_info_t *d = xmalloc (sizeof *s + strlen (s->email));
 234
 235   d->valid = s->valid;
 236   d->checked = s->checked;
 237   d->uri = s->uri? xstrdup (s->uri):NULL;
 238   memcpy (d->fpr, s->fpr, sizeof s->fpr);
 239   strcpy (d->email, s->email);
 240   return d;
 241 }
 242
 243
 244 PKT_signature *
 245 copy_signature( PKT_signature *d, PKT_signature *s )
 246 {
 247     int n, i;
 248
 249     if( !d )
 250         d = xmalloc(sizeof *d);
 251     memcpy( d, s, sizeof *d );
 252     n = pubkey_get_nsig( s->pubkey_algo );
 253     if( !n )
 254         d->data[0] = my_mpi_copy(s->data[0]);
 255     else {
 256         for(i=0; i < n; i++ )
 257             d->data[i] = my_mpi_copy( s->data[i] );
 258     }
 259     d->pka_info = s->pka_info? cp_pka_info (s->pka_info) : NULL;
 260     d->hashed = cp_subpktarea (s->hashed);
 261     d->unhashed = cp_subpktarea (s->unhashed);
 262     if (s->signers_uid)
 263       d->signers_uid = xstrdup (s->signers_uid);
 264     if(s->numrevkeys)
 265       {
 266         d->revkey=NULL;
 267         d->numrevkeys=0;
 268         parse_revkeys(d);
 269       }
 270     return d;
 271 }
 272
 273
 274 /*
 275  * shallow copy of the user ID
 276  */
 277 PKT_user_id *
 278 scopy_user_id (PKT_user_id *s)
 279 {
 280     if (s)
 281         s->ref++;
 282     return s;
 283 }
 284
 285
 286
 287 void
 288 free_comment( PKT_comment *rem )
 289 {
 290     xfree(rem);
 291 }
 292
 293 void
 294 free_attributes(PKT_user_id *uid)
 295 {
 296   xfree(uid->attribs);
 297   xfree(uid->attrib_data);
 298
 299   uid->attribs=NULL;
 300   uid->attrib_data=NULL;
 301   uid->attrib_len=0;
 302 }
 303
 304 void
 305 free_user_id (PKT_user_id *uid)
 306 {
 307     log_assert (uid->ref > 0);
 308     if (--uid->ref)
 309         return;
 310
 311     free_attributes(uid);
 312     xfree (uid->prefs);
 313     xfree (uid->namehash);
 314     xfree (uid);
 315 }
 316
 317 void
 318 free_compressed( PKT_compressed *zd )
 319 {
 320     if( zd->buf ) { /* have to skip some bytes */
 321         /* don't have any information about the length, so
 322          * we assume this is the last packet */
 323         while( iobuf_read( zd->buf, NULL, 1<<30 ) != -1 )
 324             ;
 325     }
 326     xfree(zd);
 327 }
 328
 329 void
 330 free_encrypted( PKT_encrypted *ed )
 331 {
 332     if( ed->buf ) { /* have to skip some bytes */
 333         if( ed->is_partial ) {
 334             while( iobuf_read( ed->buf, NULL, 1<<30 ) != -1 )
 335                 ;
 336         }
 337         else {
 338            while( ed->len ) { /* skip the packet */
 339                int n = iobuf_read( ed->buf, NULL, ed->len );
 340                if( n == -1 )
 341                    ed->len = 0;
 342                else
 343                    ed->len -= n;
 344            }
 345         }
 346     }
 347     xfree(ed);
 348 }
 349
 350
 351 void
 352 free_plaintext( PKT_plaintext *pt )
 353 {
 354     if( pt->buf ) { /* have to skip some bytes */
 355         if( pt->is_partial ) {
 356             while( iobuf_read( pt->buf, NULL, 1<<30 ) != -1 )
 357                 ;
 358         }
 359         else {
 360            while( pt->len ) { /* skip the packet */
 361                int n = iobuf_read( pt->buf, NULL, pt->len );
 362                if( n == -1 )
 363                    pt->len = 0;
 364                else
 365                    pt->len -= n;
 366            }
 367         }
 368     }
 369     xfree(pt);
 370 }
 371
 372 /****************
 373  * Free the packet in pkt.
 374  */
 375 void
 376 free_packet( PACKET *pkt )
 377 {
 378     if( !pkt || !pkt->pkt.generic )
 379         return;
 380
 381     if( DBG_MEMORY )
 382         log_debug("free_packet() type=%d\n", pkt->pkttype );
 383
 384     switch( pkt->pkttype ) {
 385       case PKT_SIGNATURE:
 386         free_seckey_enc( pkt->pkt.signature );
 387         break;
 388       case PKT_PUBKEY_ENC:
 389         free_pubkey_enc( pkt->pkt.pubkey_enc );
 390         break;
 391       case PKT_SYMKEY_ENC:
 392         free_symkey_enc( pkt->pkt.symkey_enc );
 393         break;
 394       case PKT_PUBLIC_KEY:
 395       case PKT_PUBLIC_SUBKEY:
 396       case PKT_SECRET_KEY:
 397       case PKT_SECRET_SUBKEY:
 398         free_public_key (pkt->pkt.public_key);
 399         break;
 400       case PKT_COMMENT:
 401         free_comment( pkt->pkt.comment );
 402         break;
 403       case PKT_USER_ID:
 404         free_user_id( pkt->pkt.user_id );
 405         break;
 406       case PKT_COMPRESSED:
 407         free_compressed( pkt->pkt.compressed);
 408         break;
 409       case PKT_ENCRYPTED:
 410       case PKT_ENCRYPTED_MDC:
 411         free_encrypted( pkt->pkt.encrypted );
 412         break;
 413       case PKT_PLAINTEXT:
 414         free_plaintext( pkt->pkt.plaintext );
 415         break;
 416       default:
 417         xfree( pkt->pkt.generic );
 418         break;
 419     }
 420     pkt->pkt.generic = NULL;
 421 }
 422
 423 /****************
 424  * returns 0 if they match.
 425  */
 426 int
 427 cmp_public_keys( PKT_public_key *a, PKT_public_key *b )
 428 {
 429     int n, i;
 430
 431     if( a->timestamp != b->timestamp )
 432         return -1;
 433     if( a->version < 4 && a->expiredate != b->expiredate )
 434         return -1;
 435     if( a->pubkey_algo != b->pubkey_algo )
 436         return -1;
 437
 438     n = pubkey_get_npkey( b->pubkey_algo );
 439     if( !n ) { /* unknown algorithm, rest is in opaque MPI */
 440         if( mpi_cmp( a->pkey[0], b->pkey[0] ) )
 441             return -1; /* can't compare due to unknown algorithm */
 442     } else {
 443         for(i=0; i < n; i++ ) {
 444             if( mpi_cmp( a->pkey[i], b->pkey[i] ) )
 445                 return -1;
 446         }
 447     }
 448
 449     return 0;
 450 }
 451
 452
 453
 454 int
 455 cmp_signatures( PKT_signature *a, PKT_signature *b )
 456 {
 457     int n, i;
 458
 459     if( a->keyid[0] != b->keyid[0] )
 460         return -1;
 461     if( a->keyid[1] != b->keyid[1] )
 462         return -1;
 463     if( a->pubkey_algo != b->pubkey_algo )
 464         return -1;
 465
 466     n = pubkey_get_nsig( a->pubkey_algo );
 467     if( !n )
 468         return -1; /* can't compare due to unknown algorithm */
 469     for(i=0; i < n; i++ ) {
 470         if( mpi_cmp( a->data[i] , b->data[i] ) )
 471             return -1;
 472     }
 473     return 0;
 474 }
 475
 476
 477 /****************
 478  * Returns: true if the user ids do not match
 479  */
 480 int
 481 cmp_user_ids( PKT_user_id *a, PKT_user_id *b )
 482 {
 483     int res=1;
 484
 485     if( a == b )
 486         return 0;
 487
 488     if( a->attrib_data && b->attrib_data )
 489       {
 490         res = a->attrib_len - b->attrib_len;
 491         if( !res )
 492           res = memcmp( a->attrib_data, b->attrib_data, a->attrib_len );
 493       }
 494     else if( !a->attrib_data && !b->attrib_data )
 495       {
 496         res = a->len - b->len;
 497         if( !res )
 498           res = memcmp( a->name, b->name, a->len );
 499       }
 500
 501     return res;
 502 }