summaryrefslogtreecommitdiffstats
path: root/g10/free-packet.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--g10/free-packet.c569
1 files changed, 569 insertions, 0 deletions
diff --git a/g10/free-packet.c b/g10/free-packet.c
new file mode 100644
index 0000000..4df8896
--- /dev/null
+++ b/g10/free-packet.c
@@ -0,0 +1,569 @@
+/* free-packet.c - cleanup stuff for packets
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
+ * 2005, 2010 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "gpg.h"
+#include "../common/util.h"
+#include "packet.h"
+#include "../common/iobuf.h"
+#include "options.h"
+
+
+/* This is mpi_copy with a fix for opaque MPIs which store a NULL
+ pointer. This will also be fixed in Libggcrypt 1.7.0. */
+static gcry_mpi_t
+my_mpi_copy (gcry_mpi_t a)
+{
+ if (a
+ && gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE)
+ && !gcry_mpi_get_opaque (a, NULL))
+ return NULL;
+
+ return gcry_mpi_copy (a);
+}
+
+
+void
+free_symkey_enc( PKT_symkey_enc *enc )
+{
+ xfree(enc);
+}
+
+void
+free_pubkey_enc( PKT_pubkey_enc *enc )
+{
+ int n, i;
+ n = pubkey_get_nenc( enc->pubkey_algo );
+ if( !n )
+ mpi_release(enc->data[0]);
+ for(i=0; i < n; i++ )
+ mpi_release( enc->data[i] );
+ xfree(enc);
+}
+
+void
+free_seckey_enc( PKT_signature *sig )
+{
+ int n, i;
+
+ n = pubkey_get_nsig( sig->pubkey_algo );
+ if( !n )
+ mpi_release(sig->data[0]);
+ for(i=0; i < n; i++ )
+ mpi_release( sig->data[i] );
+
+ xfree(sig->revkey);
+ xfree(sig->hashed);
+ xfree(sig->unhashed);
+
+ if (sig->pka_info)
+ {
+ xfree (sig->pka_info->uri);
+ xfree (sig->pka_info);
+ }
+ xfree (sig->signers_uid);
+
+ xfree(sig);
+}
+
+
+void
+release_public_key_parts (PKT_public_key *pk)
+{
+ int n, i;
+
+ if (pk->seckey_info)
+ n = pubkey_get_nskey (pk->pubkey_algo);
+ else
+ n = pubkey_get_npkey (pk->pubkey_algo);
+ if (!n)
+ mpi_release (pk->pkey[0]);
+ for (i=0; i < n; i++ )
+ {
+ mpi_release (pk->pkey[i]);
+ pk->pkey[i] = NULL;
+ }
+ if (pk->seckey_info)
+ {
+ xfree (pk->seckey_info);
+ pk->seckey_info = NULL;
+ }
+ if (pk->prefs)
+ {
+ xfree (pk->prefs);
+ pk->prefs = NULL;
+ }
+ free_user_id (pk->user_id);
+ pk->user_id = NULL;
+ if (pk->revkey)
+ {
+ xfree(pk->revkey);
+ pk->revkey=NULL;
+ pk->numrevkeys=0;
+ }
+ if (pk->serialno)
+ {
+ xfree (pk->serialno);
+ pk->serialno = NULL;
+ }
+ if (pk->updateurl)
+ {
+ xfree (pk->updateurl);
+ pk->updateurl = NULL;
+ }
+}
+
+
+/* Free an allocated public key structure including all parts.
+ Passing NULL is allowed. */
+void
+free_public_key (PKT_public_key *pk)
+{
+ if (pk)
+ {
+ release_public_key_parts (pk);
+ xfree(pk);
+ }
+}
+
+
+static subpktarea_t *
+cp_subpktarea (subpktarea_t *s )
+{
+ subpktarea_t *d;
+
+ if( !s )
+ return NULL;
+ d = xmalloc (sizeof (*d) + s->size - 1 );
+ d->size = s->size;
+ d->len = s->len;
+ memcpy (d->data, s->data, s->len);
+ return d;
+}
+
+/*
+ * Return a copy of the preferences
+ */
+prefitem_t *
+copy_prefs (const prefitem_t *prefs)
+{
+ size_t n;
+ prefitem_t *new;
+
+ if (!prefs)
+ return NULL;
+
+ for (n=0; prefs[n].type; n++)
+ ;
+ new = xmalloc ( sizeof (*new) * (n+1));
+ for (n=0; prefs[n].type; n++) {
+ new[n].type = prefs[n].type;
+ new[n].value = prefs[n].value;
+ }
+ new[n].type = PREFTYPE_NONE;
+ new[n].value = 0;
+
+ return new;
+}
+
+
+/* Copy the public key S to D. If D is NULL allocate a new public key
+ structure. If S has seckret key infos, only the public stuff is
+ copied. */
+PKT_public_key *
+copy_public_key (PKT_public_key *d, PKT_public_key *s)
+{
+ int n, i;
+
+ if (!d)
+ d = xmalloc (sizeof *d);
+ memcpy (d, s, sizeof *d);
+ d->seckey_info = NULL;
+ d->user_id = scopy_user_id (s->user_id);
+ d->prefs = copy_prefs (s->prefs);
+
+ n = pubkey_get_npkey (s->pubkey_algo);
+ i = 0;
+ if (!n)
+ d->pkey[i++] = my_mpi_copy (s->pkey[0]);
+ else
+ {
+ for (; i < n; i++ )
+ d->pkey[i] = my_mpi_copy (s->pkey[i]);
+ }
+ for (; i < PUBKEY_MAX_NSKEY; i++)
+ d->pkey[i] = NULL;
+
+ if (!s->revkey && s->numrevkeys)
+ BUG();
+ if (s->numrevkeys)
+ {
+ d->revkey = xmalloc(sizeof(struct revocation_key)*s->numrevkeys);
+ memcpy(d->revkey,s->revkey,sizeof(struct revocation_key)*s->numrevkeys);
+ }
+ else
+ d->revkey = NULL;
+
+ if (s->serialno)
+ d->serialno = xstrdup (s->serialno);
+ if (s->updateurl)
+ d->updateurl = xstrdup (s->updateurl);
+
+ return d;
+}
+
+
+
+static pka_info_t *
+cp_pka_info (const pka_info_t *s)
+{
+ pka_info_t *d = xmalloc (sizeof *s + strlen (s->email));
+
+ d->valid = s->valid;
+ d->checked = s->checked;
+ d->uri = s->uri? xstrdup (s->uri):NULL;
+ memcpy (d->fpr, s->fpr, sizeof s->fpr);
+ strcpy (d->email, s->email);
+ return d;
+}
+
+
+PKT_signature *
+copy_signature( PKT_signature *d, PKT_signature *s )
+{
+ int n, i;
+
+ if( !d )
+ d = xmalloc(sizeof *d);
+ memcpy( d, s, sizeof *d );
+ n = pubkey_get_nsig( s->pubkey_algo );
+ if( !n )
+ d->data[0] = my_mpi_copy(s->data[0]);
+ else {
+ for(i=0; i < n; i++ )
+ d->data[i] = my_mpi_copy( s->data[i] );
+ }
+ d->pka_info = s->pka_info? cp_pka_info (s->pka_info) : NULL;
+ d->hashed = cp_subpktarea (s->hashed);
+ d->unhashed = cp_subpktarea (s->unhashed);
+ if (s->signers_uid)
+ d->signers_uid = xstrdup (s->signers_uid);
+ if(s->numrevkeys)
+ {
+ d->revkey=NULL;
+ d->numrevkeys=0;
+ parse_revkeys(d);
+ }
+ return d;
+}
+
+
+/*
+ * shallow copy of the user ID
+ */
+PKT_user_id *
+scopy_user_id (PKT_user_id *s)
+{
+ if (s)
+ s->ref++;
+ return s;
+}
+
+
+
+void
+free_comment( PKT_comment *rem )
+{
+ xfree(rem);
+}
+
+void
+free_attributes(PKT_user_id *uid)
+{
+ if (!uid)
+ return;
+
+ xfree(uid->attribs);
+ xfree(uid->attrib_data);
+
+ uid->attribs=NULL;
+ uid->attrib_data=NULL;
+ uid->attrib_len=0;
+}
+
+void
+free_user_id (PKT_user_id *uid)
+{
+ if (!uid)
+ return;
+
+ log_assert (uid->ref > 0);
+ if (--uid->ref)
+ return;
+
+ free_attributes(uid);
+ xfree (uid->prefs);
+ xfree (uid->namehash);
+ xfree (uid->updateurl);
+ xfree (uid->mbox);
+ xfree (uid);
+}
+
+void
+free_compressed( PKT_compressed *zd )
+{
+ if (!zd)
+ return;
+
+ if (zd->buf)
+ {
+ /* We need to skip some bytes. Because don't have any
+ * information about the length, so we assume this is the last
+ * packet */
+ while (iobuf_read( zd->buf, NULL, 1<<30 ) != -1)
+ ;
+ }
+ xfree(zd);
+}
+
+void
+free_encrypted( PKT_encrypted *ed )
+{
+ if (!ed)
+ return;
+
+ if (ed->buf)
+ {
+ /* We need to skip some bytes. */
+ if (ed->is_partial)
+ {
+ while (iobuf_read( ed->buf, NULL, 1<<30 ) != -1)
+ ;
+ }
+ else
+ {
+ while (ed->len)
+ {
+ /* Skip the packet. */
+ int n = iobuf_read( ed->buf, NULL, ed->len );
+ if (n == -1)
+ ed->len = 0;
+ else
+ ed->len -= n;
+ }
+ }
+ }
+ xfree (ed);
+}
+
+
+void
+free_plaintext( PKT_plaintext *pt )
+{
+ if (!pt)
+ return;
+
+ if (pt->buf)
+ { /* We need to skip some bytes. */
+ if (pt->is_partial)
+ {
+ while (iobuf_read( pt->buf, NULL, 1<<30 ) != -1)
+ ;
+ }
+ else
+ {
+ while( pt->len )
+ { /* Skip the packet. */
+ int n = iobuf_read( pt->buf, NULL, pt->len );
+ if (n == -1)
+ pt->len = 0;
+ else
+ pt->len -= n;
+ }
+ }
+ }
+ xfree (pt);
+}
+
+
+/****************
+ * Free the packet in PKT.
+ */
+void
+free_packet (PACKET *pkt, parse_packet_ctx_t parsectx)
+{
+ if (!pkt || !pkt->pkt.generic)
+ {
+ if (parsectx && parsectx->last_pkt.pkt.generic)
+ {
+ if (parsectx->free_last_pkt)
+ {
+ free_packet (&parsectx->last_pkt, NULL);
+ parsectx->free_last_pkt = 0;
+ }
+ parsectx->last_pkt.pkttype = 0;
+ parsectx->last_pkt.pkt.generic = NULL;
+ }
+ return;
+ }
+
+ if (DBG_MEMORY)
+ log_debug ("free_packet() type=%d\n", pkt->pkttype);
+
+ /* If we have a parser context holding PKT then do not free the
+ * packet but set a flag that the packet in the parser context is
+ * now a deep copy. */
+ if (parsectx && !parsectx->free_last_pkt
+ && parsectx->last_pkt.pkttype == pkt->pkttype
+ && parsectx->last_pkt.pkt.generic == pkt->pkt.generic)
+ {
+ parsectx->last_pkt = *pkt;
+ parsectx->free_last_pkt = 1;
+ pkt->pkt.generic = NULL;
+ return;
+ }
+
+ switch (pkt->pkttype)
+ {
+ case PKT_SIGNATURE:
+ free_seckey_enc (pkt->pkt.signature);
+ break;
+ case PKT_PUBKEY_ENC:
+ free_pubkey_enc (pkt->pkt.pubkey_enc);
+ break;
+ case PKT_SYMKEY_ENC:
+ free_symkey_enc (pkt->pkt.symkey_enc);
+ break;
+ case PKT_PUBLIC_KEY:
+ case PKT_PUBLIC_SUBKEY:
+ case PKT_SECRET_KEY:
+ case PKT_SECRET_SUBKEY:
+ free_public_key (pkt->pkt.public_key);
+ break;
+ case PKT_COMMENT:
+ free_comment (pkt->pkt.comment);
+ break;
+ case PKT_USER_ID:
+ free_user_id (pkt->pkt.user_id);
+ break;
+ case PKT_COMPRESSED:
+ free_compressed (pkt->pkt.compressed);
+ break;
+ case PKT_ENCRYPTED:
+ case PKT_ENCRYPTED_MDC:
+ case PKT_ENCRYPTED_AEAD:
+ free_encrypted (pkt->pkt.encrypted);
+ break;
+ case PKT_PLAINTEXT:
+ free_plaintext (pkt->pkt.plaintext);
+ break;
+ default:
+ xfree (pkt->pkt.generic);
+ break;
+ }
+
+ pkt->pkt.generic = NULL;
+}
+
+
+/****************
+ * returns 0 if they match.
+ */
+int
+cmp_public_keys( PKT_public_key *a, PKT_public_key *b )
+{
+ int n, i;
+
+ if( a->timestamp != b->timestamp )
+ return -1;
+ if( a->version < 4 && a->expiredate != b->expiredate )
+ return -1;
+ if( a->pubkey_algo != b->pubkey_algo )
+ return -1;
+
+ n = pubkey_get_npkey( b->pubkey_algo );
+ if( !n ) { /* unknown algorithm, rest is in opaque MPI */
+ if( mpi_cmp( a->pkey[0], b->pkey[0] ) )
+ return -1; /* can't compare due to unknown algorithm */
+ } else {
+ for(i=0; i < n; i++ ) {
+ if( mpi_cmp( a->pkey[i], b->pkey[i] ) )
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+
+
+int
+cmp_signatures( PKT_signature *a, PKT_signature *b )
+{
+ int n, i;
+
+ if( a->keyid[0] != b->keyid[0] )
+ return -1;
+ if( a->keyid[1] != b->keyid[1] )
+ return -1;
+ if( a->pubkey_algo != b->pubkey_algo )
+ return -1;
+
+ n = pubkey_get_nsig( a->pubkey_algo );
+ if( !n )
+ return -1; /* can't compare due to unknown algorithm */
+ for(i=0; i < n; i++ ) {
+ if( mpi_cmp( a->data[i] , b->data[i] ) )
+ return -1;
+ }
+ return 0;
+}
+
+
+/****************
+ * Returns: true if the user ids do not match
+ */
+int
+cmp_user_ids( PKT_user_id *a, PKT_user_id *b )
+{
+ int res=1;
+
+ if( a == b )
+ return 0;
+
+ if( a->attrib_data && b->attrib_data )
+ {
+ res = a->attrib_len - b->attrib_len;
+ if( !res )
+ res = memcmp( a->attrib_data, b->attrib_data, a->attrib_len );
+ }
+ else if( !a->attrib_data && !b->attrib_data )
+ {
+ res = a->len - b->len;
+ if( !res )
+ res = memcmp( a->name, b->name, a->len );
+ }
+
+ return res;
+}