2 * keydb_hkp.c - Routines to store and fetch keys from another keyserver.
4 * Copyright 2013 Jonathan McDowell <noodles@earth.li>
6 * This program is free software: you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; version 2 of the License.
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 51
17 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
24 #include <curl/curl.h>
27 #include "charfuncs.h"
29 #include "keystructs.h"
32 #include "onak-conf.h"
36 struct onak_hkp_dbctx {
37 struct onak_db_config *config; /* Our DB config info */
42 static int hkp_parse_url(struct onak_hkp_dbctx *privctx, const char *url)
44 char proto[6], host[256];
49 proto[0] = host[0] = 0;
52 matched = sscanf(url, "%5[a-z]://%256[a-zA-Z0-9.-]:%u", proto, host,
56 sscanf(url, "%256[a-zA-Z0-9.-]:%u", host, &port);
60 logthing(LOGTHING_CRITICAL, "Couldn't parse HKP host: %s",
66 if (proto[0] == 0 || !strcmp(proto, "hkp")) {
70 snprintf(privctx->hkpbase, sizeof(privctx->hkpbase),
71 "http://%s:%u/pks", host, port);
72 } else if (!strcmp(proto, "hkps")) {
76 snprintf(privctx->hkpbase, sizeof(privctx->hkpbase),
77 "https://%s:%u/pks", host, port);
78 } else if (strcmp(proto, "http") && strcmp(proto, "https")) {
79 logthing(LOGTHING_CRITICAL, "Unknown HKP protocol: %s",
83 } else if (port == 0) {
84 snprintf(privctx->hkpbase, sizeof(privctx->hkpbase),
85 "%s://%s/pks", proto, host);
87 snprintf(privctx->hkpbase, sizeof(privctx->hkpbase),
88 "%s://%s:%u/pks", proto, host, port);
96 * Receive data from a CURL request and process it into a buffer context.
98 static size_t hkp_curl_recv_data(void *buffer, size_t size, size_t nmemb,
101 buffer_putchar(ctx, nmemb * size, buffer);
103 return (nmemb * size);
106 static int hkp_fetch_key_url(struct onak_dbctx *dbctx,
108 struct openpgp_publickey **publickey,
111 struct onak_hkp_dbctx *privctx = (struct onak_hkp_dbctx *) dbctx->priv;
112 struct openpgp_packet_list *packets = NULL;
114 struct buffer_ctx buf;
119 buf.buffer = malloc(8192);
121 curl_easy_setopt(privctx->curl, CURLOPT_URL, url);
122 curl_easy_setopt(privctx->curl, CURLOPT_WRITEFUNCTION,
124 curl_easy_setopt(privctx->curl, CURLOPT_WRITEDATA, &buf);
125 res = curl_easy_perform(privctx->curl);
129 dearmor_openpgp_stream(buffer_fetchchar, &buf, &packets);
130 count = parse_keys(packets, publickey);
131 free_packet_list(packets);
134 logthing(LOGTHING_ERROR, "Couldn't find key: %s (%d)",
135 curl_easy_strerror(res), res);
139 buf.offset = buf.size = 0;
146 * hkp_fetch_key_id - Given a keyid fetch the key from HKP server.
148 static int hkp_fetch_key_id(struct onak_dbctx *dbctx,
150 struct openpgp_publickey **publickey,
153 struct onak_hkp_dbctx *privctx = (struct onak_hkp_dbctx *) dbctx->priv;
156 snprintf(keyurl, sizeof(keyurl),
157 "%s/lookup?op=get&search=0x%08" PRIX64,
158 privctx->hkpbase, keyid);
160 return (hkp_fetch_key_url(dbctx, keyurl, publickey, intrans));
164 * hkp_fetch_key_fp - Given a fingerprint fetch the key from HKP server.
166 static int hkp_fetch_key_fp(struct onak_dbctx *dbctx,
167 struct openpgp_fingerprint *fingerprint,
168 struct openpgp_publickey **publickey,
171 struct onak_hkp_dbctx *privctx = (struct onak_hkp_dbctx *) dbctx->priv;
175 if (fingerprint->length > MAX_FINGERPRINT_LEN) {
179 ofs = snprintf(keyurl, sizeof(keyurl),
180 "%s/lookup?op=get&search=0x", privctx->hkpbase);
182 if ((ofs + fingerprint->length * 2 + 1)> sizeof(keyurl)) {
186 for (i = 0; i < fingerprint->length; i++) {
187 ofs += sprintf(&keyurl[ofs], "%02X", fingerprint->fp[i]);
190 return (hkp_fetch_key_url(dbctx, keyurl, publickey, intrans));
194 * fetch_key_text - Tries to find the keys that contain the supplied text.
195 * @search: The text to search for.
196 * @publickey: A pointer to a structure to return the key in.
198 * This function searches for the supplied text and returns the keys that
201 * TODO: Write for flat file access. Some sort of grep?
203 static int hkp_fetch_key_text(struct onak_dbctx *dbctx,
205 struct openpgp_publickey **publickey)
207 struct onak_hkp_dbctx *privctx = (struct onak_hkp_dbctx *) dbctx->priv;
210 snprintf(keyurl, sizeof(keyurl),
211 "%s/lookup?op=get&search=%s",
212 privctx->hkpbase, search);
214 return (hkp_fetch_key_url(dbctx, keyurl, publickey, false));
218 * store_key - Takes a key and stores it.
219 * @publickey: A pointer to the public key to store.
220 * @intrans: If we're already in a transaction.
221 * @update: If true the key exists and should be updated.
224 static int hkp_store_key(struct onak_dbctx *dbctx,
225 struct openpgp_publickey *publickey, bool intrans,
228 struct onak_hkp_dbctx *privctx = (struct onak_hkp_dbctx *) dbctx->priv;
229 struct openpgp_packet_list *packets = NULL;
230 struct openpgp_packet_list *list_end = NULL;
233 struct buffer_ctx buf;
238 buf.buffer = malloc(8192);
239 buf.offset = snprintf(buf.buffer, buf.size, "keytextz");
241 flatten_publickey(publickey, &packets, &list_end);
242 armor_openpgp_stream(buffer_putchar, &buf, packets);
243 addform = curl_easy_escape(privctx->curl, buf.buffer, buf.offset);
246 snprintf(keyurl, sizeof(keyurl), "%s/add", privctx->hkpbase);
248 curl_easy_setopt(privctx->curl, CURLOPT_URL, keyurl);
249 curl_easy_setopt(privctx->curl, CURLOPT_POSTFIELDS, addform);
250 curl_easy_setopt(privctx->curl, CURLOPT_WRITEFUNCTION,
253 curl_easy_setopt(privctx->curl, CURLOPT_WRITEDATA, &buf);
254 res = curl_easy_perform(privctx->curl);
257 logthing(LOGTHING_ERROR, "Couldn't send key: %s (%d)",
258 curl_easy_strerror(res), res);
263 /* TODO: buf has any response text we might want to parse. */
265 buf.offset = buf.size = 0;
268 return (res == 0) ? 1 : 0;
272 * delete_key - Given a keyid delete the key from storage.
273 * @keyid: The keyid to delete.
274 * @intrans: If we're already in a transaction.
278 static int hkp_delete_key(struct onak_dbctx *dbctx,
279 uint64_t keyid, bool intrans)
285 * iterate_keys - call a function once for each key in the db.
286 * @iterfunc: The function to call.
287 * @ctx: A context pointer
289 * Not applicable for HKP backend.
291 static int hkp_iterate_keys(struct onak_dbctx *dbctx,
292 void (*iterfunc)(void *ctx, struct openpgp_publickey *key),
299 * starttrans - Start a transaction.
301 * This is just a no-op for HKP access.
303 static bool hkp_starttrans(struct onak_dbctx *dbctx)
309 * endtrans - End a transaction.
311 * This is just a no-op for HKP access.
313 static void hkp_endtrans(struct onak_dbctx *dbctx)
319 * Include the basic keydb routines.
321 #define NEED_KEYID2UID 1
322 #define NEED_GETKEYSIGS 1
323 #define NEED_GETFULLKEYID 1
324 #define NEED_UPDATEKEYS 1
328 * cleanupdb - De-initialize the key database.
330 * We cleanup CURL here.
332 static void hkp_cleanupdb(struct onak_dbctx *dbctx)
334 struct onak_hkp_dbctx *privctx = (struct onak_hkp_dbctx *) dbctx->priv;
337 curl_easy_cleanup(privctx->curl);
338 privctx->curl = NULL;
340 curl_global_cleanup();
346 * initdb - Initialize the key database.
348 * We initialize CURL here.
350 struct onak_dbctx *keydb_hkp_init(struct onak_db_config *dbcfg, bool readonly)
352 struct onak_dbctx *dbctx;
353 struct onak_hkp_dbctx *privctx;
354 curl_version_info_data *curl_info;
356 dbctx = malloc(sizeof(struct onak_dbctx));
361 dbctx->config = dbcfg;
362 dbctx->priv = privctx = malloc(sizeof(*privctx));
363 dbctx->cleanupdb = hkp_cleanupdb;
364 dbctx->starttrans = hkp_starttrans;
365 dbctx->endtrans = hkp_endtrans;
366 dbctx->fetch_key_id = hkp_fetch_key_id;
367 dbctx->fetch_key_fp = hkp_fetch_key_fp;
368 dbctx->fetch_key_text = hkp_fetch_key_text;
369 dbctx->store_key = hkp_store_key;
370 dbctx->update_keys = generic_update_keys;
371 dbctx->delete_key = hkp_delete_key;
372 dbctx->getkeysigs = generic_getkeysigs;
373 dbctx->cached_getkeysigs = generic_cached_getkeysigs;
374 dbctx->keyid2uid = generic_keyid2uid;
375 dbctx->getfullkeyid = generic_getfullkeyid;
376 dbctx->iterate_keys = hkp_iterate_keys;
378 if (!hkp_parse_url(privctx, dbcfg->location)) {
381 logthing(LOGTHING_INFO, "Using %s as HKP forwarding URL.",
383 curl_global_init(CURL_GLOBAL_DEFAULT);
384 privctx->curl = curl_easy_init();
385 if (privctx->curl == NULL) {
386 logthing(LOGTHING_CRITICAL, "Could not initialize CURL.");
387 hkp_cleanupdb(dbctx);
391 curl_easy_setopt(privctx->curl, CURLOPT_USERAGENT,
392 "onak/" ONAK_VERSION);
394 if (strncmp(privctx->hkpbase, "https://", 8) == 0) {
395 curl_info = curl_version_info(CURLVERSION_NOW);
396 if (! (curl_info->features & CURL_VERSION_SSL)) {
397 logthing(LOGTHING_CRITICAL,
398 "CURL lacks SSL support; cannot use HKP url: %s",
400 hkp_cleanupdb(dbctx);