/*
* parsekey.c - Routines to parse an OpenPGP key.
*
- * Jonathan McDowell <noodles@earth.li>
+ * Copyright 2002-2004,2007-2008,2011 Jonathan McDowell <noodles@earth.li>
*
- * Copyright 2002 Project Purple
+ * This program 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; version 2 of the License.
*
- * $Id: parsekey.c,v 1.11 2003/09/30 16:58:04 noodles Exp $
+ * This program 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, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include "keyid.h"
#include "keystructs.h"
#include "ll.h"
-#include "log.h"
#include "mem.h"
+#include "onak.h"
+#include "openpgp.h"
#include "parsekey.h"
-/**
- * add_key - Takes a key and adds it to the keyserver.
- * @key: The public key to add.
- *
- * This function takes a public key and adds it to the keyserver.
- * It first of all sees if we already have the key locally. If we do then
- * we retrieve it and merge the two keys. We then store the resulting key
- * (or just the original we received if we don't already have it). We then
- * send out the appropriate updates to our keyserver peers.
- */
-int add_key(struct openpgp_publickey *key) {
- return 0;
-}
-
/**
* parse_keys - Process a stream of packets for public keys + sigs.
* @packets: The packet list to parse.
while (packets != NULL) {
switch (packets->packet->tag) {
- case 2:
+ case OPENPGP_PACKET_SIGNATURE:
/*
* It's a signature packet. Add it to either the public
- * key (it should be a revocation), to the current UID
- * or the current subkey.
+ * key, to the current UID or the current subkey.
*/
- assert(curkey != NULL);
+ if (curkey == NULL)
+ return ONAK_E_INVALID_PARAM;
if (curkey->subkeys != NULL) {
ADD_PACKET_TO_LIST_END(curkey->last_subkey,
sig,
packet_dup(packets->packet));
} else {
ADD_PACKET_TO_LIST_END(curkey,
- revocation,
+ sig,
packet_dup(packets->packet));
+ /*
+ * This is a signature on the public key; check
+ * if it's a revocation.
+ */
+ if (packets->packet->data[0] == 3 &&
+ packets->packet->data[2] ==
+ OPENPGP_SIGTYPE_KEY_REV) {
+ /*
+ * Type 3 key, 0x20 == revocation
+ */
+ curkey->revoked = true;
+ } else if (packets->packet->data[0] == 4 &&
+ packets->packet->data[1] ==
+ OPENPGP_SIGTYPE_KEY_REV) {
+ /*
+ * Type 4 key, 0x20 == revocation
+ */
+ curkey->revoked = true;
+ }
}
break;
- case 6:
+ case OPENPGP_PACKET_PUBLICKEY:
/*
* It's a public key packet, so start a new key in our
* list.
curkey->publickey = packet_dup(packets->packet);
count++;
break;
- case 13:
- case 17:
+ case OPENPGP_PACKET_UID:
+ case OPENPGP_PACKET_UAT:
/*
* It's a UID packet (or a photo id, which is similar).
*/
- assert(curkey != NULL);
- assert(curkey->subkeys == NULL);
+ if (curkey == NULL)
+ return ONAK_E_INVALID_PARAM;
+ if (curkey->subkeys != NULL)
+ return ONAK_E_INVALID_PARAM;
ADD_PACKET_TO_LIST_END(curkey,
uid,
packet_dup(packets->packet));
break;
- case 14:
+ case OPENPGP_PACKET_PUBLICSUBKEY:
/*
* It's a subkey packet.
*/
- assert(curkey != NULL);
+ if (curkey == NULL)
+ return ONAK_E_INVALID_PARAM;
ADD_PACKET_TO_LIST_END(curkey,
subkey,
packet_dup(packets->packet));
break;
- case 12:
- case 61:
+ case OPENPGP_PACKET_TRUST:
+ case OPENPGP_PACKET_COMMENT:
/*
* One of:
*
*/
break;
default:
- logthing(LOGTHING_ERROR,
- "Unsupported packet type: %d",
- packets->packet->tag);
+ /* Unsupported packet. Do what? Ignore for now. */
+ break;
}
packets = packets->next;
}
*/
int debug_packet(struct openpgp_packet *packet)
{
- printf("\tNew format: %d, Tag: %d, Length: %d\n",
+ printf("\tNew format: %d, Tag: %u, Length: %zd\n",
packet->newformat,
packet->tag,
packet->length);
* @getchar_func: The function to get the next character from the stream.
* @ctx: A pointer to the context structure for getchar_func.
* @packets: The outputted list of packets.
+ * @maxnum: The maximum number of keys to read. 0 means unlimited.
*
* This function uses getchar_func to read characters from an OpenPGP
* packet stream and reads the packets into a linked list of packets
* ready for parsing as a public key or whatever.
*/
-int read_openpgp_stream(int (*getchar_func)(void *ctx, size_t count,
- unsigned char *c),
+onak_status_t read_openpgp_stream(int (*getchar_func)(void *ctx, size_t count,
+ void *c),
void *ctx,
- struct openpgp_packet_list **packets)
+ struct openpgp_packet_list **packets,
+ int maxnum)
{
unsigned char curchar = 0;
- unsigned long count = 0;
- struct openpgp_packet_list *curpacket = NULL;
- int rc = 0;
+ struct openpgp_packet_list *curpacket = NULL, **packetend = NULL;
+ onak_status_t rc = ONAK_E_OK;
+ int keys = 0;
bool inpacket = false;
- assert(packets != NULL);
+ if (packets == NULL)
+ return ONAK_E_INVALID_PARAM;
+
curpacket = *packets;
- while (curpacket->next != NULL) {
- curpacket = curpacket->next;
+ if (curpacket != NULL) {
+ while (curpacket->next != NULL) {
+ curpacket = curpacket->next;
+ }
}
- while (!rc && !getchar_func(ctx, 1, &curchar)) {
+ while (!rc && (maxnum == 0 || keys < maxnum) &&
+ !getchar_func(ctx, 1, &curchar)) {
if (!inpacket && (curchar & 0x80)) {
/*
* New packet. Record the fact we're in a packet and
* allocate memory for it.
*/
inpacket = true;
- count = 0;
if (curpacket != NULL) {
curpacket->next = malloc(sizeof (*curpacket));
+ packetend = &curpacket->next;
curpacket = curpacket->next;
} else {
*packets = curpacket =
malloc(sizeof (*curpacket));
+ packetend = packets;
}
memset(curpacket, 0, sizeof(*curpacket));
curpacket->packet =
curpacket->packet->length += 192;
} else if (curpacket->packet->length > 223 &&
curpacket->packet->length < 255) {
- logthing(LOGTHING_NOTICE,
- "Partial length;"
- " not supported.\n");
+ free(curpacket->packet);
+ curpacket->packet = NULL;
+ rc = ONAK_E_UNSUPPORTED_FEATURE;
} else if (curpacket->packet->length == 255) {
/*
* 5 byte length; ie 255 followed by 3
curpacket->packet->length = curchar;
curpacket->packet->length <<= 8;
rc = getchar_func(ctx, 1, &curchar);
- curpacket->packet->length = curchar;
+ curpacket->packet->length += curchar;
curpacket->packet->length <<= 8;
rc = getchar_func(ctx, 1, &curchar);
- curpacket->packet->length = curchar;
+ curpacket->packet->length += curchar;
curpacket->packet->length <<= 8;
rc = getchar_func(ctx, 1, &curchar);
- curpacket->packet->length = curchar;
+ curpacket->packet->length += curchar;
}
} else {
curpacket->packet->tag = (curchar & 0x3C) >> 2;
curpacket->packet->length += curchar;
break;
case 3:
- logthing(LOGTHING_ERROR,
- "Unsupported length type 3.");
- curpacket->packet->length = 0;
- curpacket->packet->data = NULL;
- rc = -1;
+ rc = ONAK_E_UNSUPPORTED_FEATURE;
+ free(curpacket->packet);
+ curpacket->packet = NULL;
break;
}
}
if (rc == 0) {
+ if (curpacket->packet->tag ==
+ OPENPGP_PACKET_PUBLICKEY) {
+ keys++;
+ }
curpacket->packet->data =
malloc(curpacket->packet->length *
sizeof(unsigned char));
if (curpacket->packet->data == NULL) {
- logthing(LOGTHING_ERROR,
- "Can't allocate memory for "
- "packet!");
- rc = -1;
+ rc = ONAK_E_NOMEM;
} else {
rc = getchar_func(ctx,
curpacket->packet->length,
}
inpacket = false;
} else {
- logthing(LOGTHING_ERROR, "Unexpected character: 0x%X",
- curchar);
+ rc = ONAK_E_INVALID_PKT;
}
}
+ /* Trim the last packet if it doesn't actually exist */
+ if (packetend != NULL && (*packetend)->packet == NULL) {
+ free(*packetend);
+ *packetend = NULL;
+ }
+
return (rc);
}
* This function uses putchar_func to write characters to an OpenPGP
* packet stream from a linked list of packets.
*/
-int write_openpgp_stream(int (*putchar_func)(void *ctx, size_t count,
- unsigned char *c),
+onak_status_t write_openpgp_stream(int (*putchar_func)(void *ctx, size_t count,
+ void *c),
void *ctx,
struct openpgp_packet_list *packets)
{
curchar = (packets->packet->length - 192) &
0xFF;
putchar_func(ctx, 1, &curchar);
+ } else if (packets->packet->length > 8382 &&
+ packets->packet->length < 0xFFFFFFFF) {
+ curchar = 255;
+ putchar_func(ctx, 1, &curchar);
+
+ curchar = (packets->packet->length >> 24);
+ curchar &= 0xFF;
+ putchar_func(ctx, 1, &curchar);
+
+ curchar = (packets->packet->length >> 16);
+ curchar &= 0xFF;
+ putchar_func(ctx, 1, &curchar);
+
+ curchar = (packets->packet->length >> 8);
+ curchar &= 0xFF;
+ putchar_func(ctx, 1, &curchar);
+
+ curchar = packets->packet->length;
+ curchar &= 0xFF;
+ putchar_func(ctx, 1, &curchar);
} else {
- logthing(LOGTHING_ERROR,
- "Unsupported new format length.");
+ return ONAK_E_UNSUPPORTED_FEATURE;
}
} else {
curchar |= (packets->packet->tag << 2);
packets->packet->data);
packets = packets->next;
}
- return 0;
+
+ return ONAK_E_OK;
}
/**
}
/*
- * Now do any revocation signatures on the main key.
+ * Now do any signatures on the main key.
*/
- for (tmplist = key->revocations; tmplist != NULL;
+ for (tmplist = key->sigs; tmplist != NULL;
tmplist = tmplist->next) {
ADD_PACKET_TO_LIST((*list_end),
packet_dup(tmplist->packet));
projects / onak.git / blobdiff