2 * merge.c - Routines to merge OpenPGP public keys.
4 * Jonathan McDowell <noodles@earth.li>
6 * Copyright 2002 Project Purple
8 * $Id: merge.c,v 1.10 2003/06/04 20:57:11 noodles Exp $
16 #include "decodekey.h"
19 #include "keystructs.h"
26 * compare_packets - Check to see if 2 OpenPGP packets are the same.
27 * @a: The first packet to compare.
28 * @b: The second packet to compare.
30 * Takes 2 packets and returns true if they are the same and false
33 bool compare_packets(struct openpgp_packet *a, struct openpgp_packet *b)
35 return (a->tag == b->tag && a->length == b->length &&
36 !memcmp(a->data, b->data, b->length));
40 * compare_signatures - Check to see if 2 OpenPGP signatures are the same.
41 * @a: The first signature to compare.
42 * @b: The second signature to compare.
44 * Takes 2 signature packets and returns true if they are the same and
47 bool compare_signatures(struct openpgp_packet *a, struct openpgp_packet *b)
49 return (sig_keyid(a) == sig_keyid(b));
53 * find_packet - Checks to see if an OpenPGP packet exists in a list.
54 * @packet_list: The list of packets to look in.
55 * @packet: The packet to look for.
57 * Walks through the packet_list checking to see if the packet given is
58 * present in it. Returns true if it is.
60 bool find_packet(struct openpgp_packet_list *packet_list,
61 struct openpgp_packet *packet)
65 while (!found && packet_list != NULL) {
66 if (compare_packets(packet_list->packet, packet)) {
69 packet_list = packet_list -> next;
76 * find_signature - Checks to see if an OpenPGP signature exists in a list.
77 * @packet_list: The list of packets to look in.
78 * @packet: The signature to look for.
80 * Walks through the packet_list checking to see if the signature given is
81 * present in it. Returns a pointer to it if it is, NULL otherwise.
84 struct openpgp_packet_list *find_signature(
85 struct openpgp_packet_list *packet_list,
86 struct openpgp_packet *packet)
88 struct openpgp_packet_list *found = NULL;
90 while (!found && packet_list != NULL) {
91 if (compare_signatures(packet_list->packet, packet)) {
94 packet_list = packet_list -> next;
101 * get_signed_packet - Gets a signed packet from a list.
102 * @packet_list: The list of packets to look in.
103 * @packet: The packet to look for.
105 * Walks through the signedpacket_list looking for the supplied packet and
106 * returns it if found. Otherwise returns NULL.
108 struct openpgp_signedpacket_list *find_signed_packet(
109 struct openpgp_signedpacket_list *packet_list,
110 struct openpgp_packet *packet)
112 struct openpgp_signedpacket_list *found = NULL;
114 while (found == NULL && packet_list != NULL) {
115 if (compare_packets(packet_list->packet, packet)) {
118 packet_list = packet_list -> next;
125 * remove_signed_packet - Removes a signed packet from a list.
126 * @packet_list: The list of packets to look in.
127 * @packet: The packet to remove.
129 * Walks through the signedpacket_list looking for the supplied packet and
130 * removes it if found. Assumes the packet can only exist a maximum of
133 bool remove_signed_packet(struct openpgp_signedpacket_list **packet_list,
134 struct openpgp_signedpacket_list **list_end,
135 struct openpgp_packet *packet)
137 struct openpgp_signedpacket_list *cur = NULL;
138 struct openpgp_signedpacket_list *prev = NULL;
141 for (cur = *packet_list; !found && (cur != NULL); cur = cur->next) {
142 if (compare_packets(cur->packet, packet)) {
145 *packet_list = cur->next;
147 prev->next = cur->next;
149 if (cur->next == NULL) {
152 // TODO: Free the removed signed packet...
161 * merge_packet_sigs - Takes 2 signed packets and merges their sigs.
162 * @old: The old signed packet.
163 * @new: The new signed packet.
165 * Takes 2 signed packet list structures and the sigs of the packets on
166 * the head of these structures. These packets must both be the same and
167 * the fully merged structure is returned in old and the minimal
168 * difference to get from old to new in new.
170 int merge_packet_sigs(struct openpgp_signedpacket_list *old,
171 struct openpgp_signedpacket_list *new)
173 struct openpgp_packet_list *lastpacket = NULL;
174 struct openpgp_packet_list *curpacket = NULL;
175 struct openpgp_packet_list *nextpacket = NULL;
177 assert(compare_packets(old->packet, new->packet));
179 curpacket = new->sigs;
180 while (curpacket != NULL) {
181 nextpacket = curpacket->next;
183 * TODO: We should be checking the signature and then
184 * potentially merging/replacing it depending on the subpackets
185 * really. For now this stops us adding the same one twice
188 if (find_signature(old->sigs, curpacket->packet)) {
190 * We already have this sig, remove it from the
191 * difference list and free the memory allocated for
194 if (lastpacket != NULL) {
195 lastpacket->next = curpacket->next;
197 assert(curpacket == new->sigs);
198 new->sigs = curpacket->next;
200 curpacket->next = NULL;
201 free_packet_list(curpacket);
203 lastpacket = curpacket;
205 curpacket = nextpacket;
207 new->last_sig = lastpacket;
210 * What's left on new->sigs now are the new signatures, so add them to
213 packet_list_add(&old->sigs, &old->last_sig, new->sigs);
219 * merge_signed_packets - Takes 2 lists of signed packets and merges them.
220 * @old: The old signed packet list.
221 * @new: The new signed packet list.
223 * Takes 2 lists of signed packets and merges them. The complete list of
224 * signed packets & sigs is returned in old and the minimal set of
225 * differences required to get from old to new in new.
227 int merge_signed_packets(struct openpgp_signedpacket_list **old,
228 struct openpgp_signedpacket_list **old_end,
229 struct openpgp_signedpacket_list **new,
230 struct openpgp_signedpacket_list **new_end)
232 struct openpgp_signedpacket_list *curelem = NULL;
233 struct openpgp_signedpacket_list *newelem = NULL;
235 for (curelem = *old; curelem != NULL; curelem = curelem->next) {
236 newelem = find_signed_packet(*new, curelem->packet);
237 if (newelem != NULL) {
238 merge_packet_sigs(curelem, newelem);
241 * If there are no sigs left on the new signed packet
242 * then remove it from the list.
244 if (newelem->sigs == NULL) {
245 remove_signed_packet(new,
253 * If *new != NULL now then there might be UIDs on the new key that
254 * weren't on the old key. Walk through them, checking if the UID is
255 * on the old key and if not adding them to it.
257 for (curelem = *new; curelem != NULL;
258 curelem = curelem->next) {
260 if (find_signed_packet(*old, curelem->packet) == NULL) {
261 ADD_PACKET_TO_LIST((*old_end),
262 packet_dup(curelem->packet));
266 packet_list_add(&(*old_end)->sigs,
267 &(*old_end)->last_sig,
276 * merge_keys - Takes 2 public keys and merges them.
277 * @a: The old key. The merged key is returned in this structure.
278 * @b: The new key. The changed from old to new keys are returned in this
281 * This function takes 2 keys and merges them. It then returns the merged
282 * key in a and the difference between this new key and the original a
283 * in b (ie newb contains the minimum amount of detail necessary to
284 * convert olda to newa). The intention is that olda is provided from
285 * internal storage and oldb from the remote user. newa is then stored in
286 * internal storage and newb is sent to all our keysync peers.
288 int merge_keys(struct openpgp_publickey *a, struct openpgp_publickey *b)
290 int rc = 0; /* Return code */
291 struct openpgp_packet_list *curpacket = NULL;
292 struct openpgp_packet_list *lastpacket = NULL;
293 struct openpgp_packet_list *nextpacket = NULL;
295 if (a == NULL || b == NULL) {
300 } else if (get_keyid(a) != get_keyid(b)) {
302 * Key IDs are different.
307 * Key IDs are the same, so I guess we have to merge them.
309 curpacket = b->revocations;
310 while (curpacket != NULL) {
311 nextpacket = curpacket->next;
312 if (find_packet(a->revocations, curpacket->packet)) {
314 * We already have this revocation, remove it
315 * from the difference list and free the memory
319 if (lastpacket != NULL) {
320 lastpacket->next = curpacket->next;
322 assert(curpacket == b->revocations);
323 b->revocations = curpacket->next;
325 curpacket->next = NULL;
326 free_packet_list(curpacket);
329 lastpacket = curpacket;
331 curpacket = nextpacket;
333 b->last_revocation = lastpacket;
336 * Anything left on b->revocations doesn't exist on
337 * a->revocations, so add them to the list.
339 packet_list_add(&a->revocations,
344 * Merge uids (signed list).
345 * Merge subkeys (signed list).
347 merge_signed_packets(&a->uids, &a->last_uid,
348 &b->uids, &b->last_uid);
349 merge_signed_packets(&a->subkeys, &a->last_subkey,
350 &b->subkeys, &b->last_subkey);
358 * update_keys - Takes a list of public keys and updates them in the DB.
359 * @keys: The keys to update in the DB.
361 * Takes a list of keys and adds them to the database, merging them with
362 * the key in the database if it's already present there. The key list is
363 * update to contain the minimum set of updates required to get from what
364 * we had before to what we have now (ie the set of data that was added to
365 * the DB). Returns the number of entirely new keys added.
367 int update_keys(struct openpgp_publickey **keys)
369 struct openpgp_publickey *curkey = NULL;
370 struct openpgp_publickey *oldkey = NULL;
371 struct openpgp_publickey *prev = NULL;
375 for (curkey = *keys; curkey != NULL; curkey = curkey->next) {
376 intrans = starttrans();
377 logthing(LOGTHING_INFO,
378 "Fetching key 0x%llX, result: %d",
380 fetch_key(get_keyid(curkey), &oldkey, intrans));
383 * If we already have the key stored in the DB then merge it
384 * with the new one that's been supplied. Otherwise the key
385 * we've just got is the one that goes in the DB and also the
386 * one that we send out.
388 if (oldkey != NULL) {
389 merge_keys(oldkey, curkey);
390 if (curkey->revocations == NULL &&
391 curkey->uids == NULL &&
392 curkey->subkeys == NULL) {
394 *keys = curkey->next;
396 prev->next = curkey->next;
398 free_publickey(curkey);
403 logthing(LOGTHING_INFO,
404 "Merged key; storing updated key.");
405 store_key(oldkey, intrans, true);
407 free_publickey(oldkey);
410 logthing(LOGTHING_INFO,
411 "Storing completely new key.");
412 store_key(curkey, intrans, false);