2 * keyid.c - Routines to calculate key IDs.
4 * Copyright 2002,2011 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, see <https://www.gnu.org/licenses/>.
20 #include <sys/types.h>
21 #include <arpa/inet.h>
23 #include "build-config.h"
25 #include "keystructs.h"
32 #include <nettle/md5.h>
33 #include <nettle/ripemd160.h>
34 #include <nettle/sha.h>
40 uint64_t fingerprint2keyid(struct openpgp_fingerprint *fingerprint)
45 switch (fingerprint->length) {
47 /* v4, keyid is last 64 bits */
48 for (keyid = 0, i = 12; i < 20; i++) {
50 keyid += fingerprint->fp[i];
54 /* v5, keyid is first 64 bits */
55 for (keyid = 0, i = 0; i < 8; i++) {
57 keyid += fingerprint->fp[i];
61 keyid = (uint64_t) -1;
69 * get_keyid - Given a public key returns the keyid.
70 * @publickey: The key to calculate the id for.
72 onak_status_t get_keyid(struct openpgp_publickey *publickey, uint64_t *keyid)
74 return (get_packetid(publickey->publickey, keyid));
78 * get_fingerprint - Given a public key returns the fingerprint.
79 * @publickey: The key to calculate the id for.
80 * @fingerprint: The fingerprint (must be at least 20 bytes of space).
81 * @len: The length of the returned fingerprint.
83 * This function returns the fingerprint for a given public key. As Type 3
84 * fingerprints are 16 bytes and Type 4 are 20 the len field indicates
85 * which we've returned.
87 onak_status_t get_fingerprint(struct openpgp_packet *packet,
88 struct openpgp_fingerprint *fingerprint)
91 struct sha256_ctx sha2_ctx;
93 struct sha1_ctx sha_ctx;
94 struct md5_ctx md5_context;
96 size_t modlen, explen;
98 if (fingerprint == NULL)
99 return ONAK_E_INVALID_PARAM;
101 fingerprint->length = 0;
103 switch (packet->data[0]) {
106 md5_init(&md5_context);
109 * MD5 the modulus and exponent.
111 modlen = ((packet->data[8] << 8) +
112 packet->data[9] + 7) >> 3;
113 md5_update(&md5_context, modlen, &packet->data[10]);
115 explen = ((packet->data[10+modlen] << 8) +
116 packet->data[11+modlen] + 7) >> 3;
117 md5_update(&md5_context, explen, &packet->data[12 + modlen]);
119 fingerprint->length = 16;
120 md5_digest(&md5_context, fingerprint->length, fingerprint->fp);
126 * TODO: Can this be 0x99? Are all public key packets old
127 * format with 2 bytes of length data?
130 sha1_update(&sha_ctx, sizeof(c), &c);
131 c = packet->length >> 8;
132 sha1_update(&sha_ctx, sizeof(c), &c);
133 c = packet->length & 0xFF;
134 sha1_update(&sha_ctx, sizeof(c), &c);
135 sha1_update(&sha_ctx, packet->length,
137 fingerprint->length = 20;
138 sha1_digest(&sha_ctx, fingerprint->length, fingerprint->fp);
143 sha256_init(&sha2_ctx);
144 /* RFC4880bis 12.2 */
146 sha256_update(&sha2_ctx, sizeof(c), &c);
147 c = packet->length >> 24;
148 sha256_update(&sha2_ctx, sizeof(c), &c);
149 c = packet->length >> 16;
150 sha256_update(&sha2_ctx, sizeof(c), &c);
151 c = packet->length >> 8;
152 sha256_update(&sha2_ctx, sizeof(c), &c);
153 c = packet->length & 0xFF;
154 sha256_update(&sha2_ctx, sizeof(c), &c);
155 sha256_update(&sha2_ctx, packet->length,
157 fingerprint->length = 32;
158 sha256_digest(&sha2_ctx, fingerprint->length, fingerprint->fp);
163 return ONAK_E_UNKNOWN_VER;
171 * get_packetid - Given a PGP packet returns the keyid.
172 * @packet: The packet to calculate the id for.
174 onak_status_t get_packetid(struct openpgp_packet *packet, uint64_t *keyid)
178 struct openpgp_fingerprint fingerprint;
179 #ifdef NETTLE_WITH_RIPEMD160
180 struct ripemd160_ctx ripemd160_context;
184 if (packet == NULL || packet->data == NULL)
185 return ONAK_E_INVALID_PARAM;
187 switch (packet->data[0]) {
191 * Old versions of GnuPG would put Elgamal keys inside
192 * a V3 key structure, then generate the keyid using
195 #ifdef NETTLE_WITH_RIPEMD160
196 if (packet->data[7] == 16) {
197 ripemd160_init(&ripemd160_context);
199 ripemd160_update(&ripemd160_context, 1, &data);
200 data = packet->length >> 8;
201 ripemd160_update(&ripemd160_context, 1, &data);
202 data = packet->length & 0xFF;
203 ripemd160_update(&ripemd160_context, 1, &data);
204 ripemd160_update(&ripemd160_context,
208 ripemd160_digest(&ripemd160_context,
209 RIPEMD160_DIGEST_SIZE,
211 fingerprint.length = RIPEMD160_DIGEST_SIZE;
213 *keyid = fingerprint2keyid(&fingerprint);
219 * Check for an RSA key; if not return an error.
221 * 2 == RSA Encrypt-Only
224 if (packet->data[7] < 1 || packet->data[7] > 3) {
225 return ONAK_E_INVALID_PKT;
229 * For a type 2 or 3 key the keyid is the last 64 bits of the
230 * public modulus n, which is stored as an MPI from offset 8
233 offset = (packet->data[8] << 8) +
235 offset = ((offset + 7) / 8) + 2;
237 for (*keyid = 0, i = 0; i < 8; i++) {
239 *keyid += packet->data[offset++];
244 get_fingerprint(packet, &fingerprint);
245 *keyid = fingerprint2keyid(&fingerprint);
248 return ONAK_E_UNKNOWN_VER;
254 static struct openpgp_packet_list *sortpackets(struct openpgp_packet_list
257 struct openpgp_packet_list *sorted, **cur, *next;
260 while (packets != NULL) {
262 while (*cur != NULL && compare_packets((*cur)->packet,
263 packets->packet) < 0) {
264 cur = &((*cur)->next);
268 packets = packets->next;
275 onak_status_t get_skshash(struct openpgp_publickey *key, struct skshash *hash)
277 struct openpgp_packet_list *packets = NULL, *list_end = NULL;
278 struct openpgp_packet_list *curpacket;
279 struct md5_ctx md5_context;
280 struct openpgp_publickey *next;
284 * We only want a single key, so clear any link to the next
285 * one for the period during the flatten.
289 flatten_publickey(key, &packets, &list_end);
291 packets = sortpackets(packets);
293 md5_init(&md5_context);
295 for (curpacket = packets; curpacket != NULL;
296 curpacket = curpacket->next) {
297 tmp = htonl(curpacket->packet->tag);
298 md5_update(&md5_context, sizeof(tmp), (void *) &tmp);
299 tmp = htonl(curpacket->packet->length);
300 md5_update(&md5_context, sizeof(tmp), (void *) &tmp);
301 md5_update(&md5_context,
302 curpacket->packet->length,
303 curpacket->packet->data);
306 md5_digest(&md5_context, 16, (uint8_t *) &hash->hash);
307 free_packet_list(packets);
312 uint8_t hexdigit(char c)
314 if (c >= '0' && c <= '9')
316 else if (c >= 'a' && c <= 'f')
318 else if (c >= 'A' && c <= 'F')
324 int parse_skshash(char *search, struct skshash *hash)
328 len = strlen(search);
333 for (i = 0; i < len; i += 2) {
334 hash->hash[i >> 1] = (hexdigit(search[i]) << 4) +
335 hexdigit(search[i + 1]);