X-Git-Url: http://the.earth.li/gitweb/?a=blobdiff_plain;f=keyindex.c;h=f3c36aafbf3527408894357ce80c1c7f6ecc2bd0;hb=cab77e4ffc25ba4fb2e5289beaa47c7d915de942;hp=c708aa48642aada710f8589de1ae40883958c865;hpb=e21d57328129d20ebef11143909ebc58bc0affce;p=onak.git diff --git a/keyindex.c b/keyindex.c index c708aa4..f3c36aa 100644 --- a/keyindex.c +++ b/keyindex.c @@ -1,9 +1,20 @@ /* * keyindex.c - Routines to list an OpenPGP key. * - * Jonathan McDowell + * Copyright 2002-2008 Jonathan McDowell * - * Copyright 2002-2005 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. + * + * 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 @@ -21,7 +32,111 @@ #include "keyindex.h" #include "keystructs.h" #include "log.h" +#include "onak.h" #include "onak-conf.h" +#include "openpgp.h" + +/* + * Convert a Public Key algorithm to its single character representation. + */ +char pkalgo2char(uint8_t algo) +{ + char typech; + + switch (algo) { + case OPENPGP_PKALGO_DSA: + typech = 'D'; + break; + case OPENPGP_PKALGO_ECDSA: + typech = 'E'; + break; + case OPENPGP_PKALGO_EC: + typech = 'e'; + break; + case OPENPGP_PKALGO_ELGAMAL_SIGN: + typech = 'G'; + break; + case OPENPGP_PKALGO_ELGAMAL_ENC: + typech = 'g'; + break; + case OPENPGP_PKALGO_RSA: + typech = 'R'; + break; + case OPENPGP_PKALGO_RSA_ENC: + typech = 'r'; + break; + case OPENPGP_PKALGO_RSA_SIGN: + typech = 's'; + break; + default: + typech = '?'; + break; + } + + return typech; +} + +/* + * Given a public key/subkey packet return the key length. + */ +unsigned int keylength(struct openpgp_packet *keydata) +{ + unsigned int length; + + switch (keydata->data[0]) { + case 2: + case 3: + length = (keydata->data[8] << 8) + + keydata->data[9]; + break; + case 4: + switch (keydata->data[5]) { + case OPENPGP_PKALGO_EC: + case OPENPGP_PKALGO_ECDSA: + /* Elliptic curve key size is based on OID */ + if ((keydata->data[6] == 8) && + (keydata->data[7] == 0x2A) && + (keydata->data[8] == 0x86) && + (keydata->data[9] == 0x48) && + (keydata->data[10] == 0xCE) && + (keydata->data[11] == 0x3D) && + (keydata->data[12] == 0x03) && + (keydata->data[13] == 0x01) && + (keydata->data[14] == 0x07)) { + length = 256; + } else if ((keydata->data[6] == 5) && + (keydata->data[7] == 0x2B) && + (keydata->data[8] == 0x81) && + (keydata->data[9] == 0x04) && + (keydata->data[10] == 0x00) && + (keydata->data[11] == 0x22)) { + length = 384; + } else if ((keydata->data[6] == 5) && + (keydata->data[7] == 0x2B) && + (keydata->data[8] == 0x81) && + (keydata->data[9] == 0x04) && + (keydata->data[10] == 0x00) && + (keydata->data[11] == 0x23)) { + length = 521; + } else { + logthing(LOGTHING_ERROR, + "Unknown elliptic curve size"); + length = 0; + } + break; + default: + length = (keydata->data[6] << 8) + + keydata->data[7]; + } + break; + default: + logthing(LOGTHING_ERROR, "Unknown key version: %d", + keydata->data[0]); + length = 0; + } + + return length; +} int list_sigs(struct openpgp_packet_list *sigs, bool html) { @@ -41,7 +156,7 @@ int list_sigs(struct openpgp_packet_list *sigs, bool html) } if (html && uid != NULL) { printf("%s %08" PRIX64 + "search=0x%016" PRIX64 "\">%08" PRIX64 " " "%s\n", @@ -80,18 +195,18 @@ int list_uids(uint64_t keyid, struct openpgp_signedpacket_list *uids, int imgindx = 0; while (uids != NULL) { - if (uids->packet->tag == 13) { + if (uids->packet->tag == OPENPGP_PACKET_UID) { snprintf(buf, 1023, "%.*s", (int) uids->packet->length, uids->packet->data); printf(" %s\n", (html) ? txt2html(buf) : buf); - } else if (uids->packet->tag == 17) { + } else if (uids->packet->tag == OPENPGP_PACKET_UAT) { printf(" "); if (html) { - printf("\"[photo" - "\n", + printf("\""\n", keyid, imgindx); imgindx++; @@ -115,9 +230,10 @@ int list_subkeys(struct openpgp_signedpacket_list *subkeys, bool verbose, time_t created_time = 0; int type = 0; int length = 0; + uint64_t keyid = 0; while (subkeys != NULL) { - if (subkeys->packet->tag == 14) { + if (subkeys->packet->tag == OPENPGP_PACKET_PUBLICSUBKEY) { created_time = (subkeys->packet->data[1] << 24) + (subkeys->packet->data[2] << 16) + @@ -129,26 +245,25 @@ int list_subkeys(struct openpgp_signedpacket_list *subkeys, bool verbose, case 2: case 3: type = subkeys->packet->data[7]; - length = (subkeys->packet->data[8] << 8) + - subkeys->packet->data[9]; break; case 4: type = subkeys->packet->data[5]; - length = (subkeys->packet->data[6] << 8) + - subkeys->packet->data[7]; break; default: logthing(LOGTHING_ERROR, "Unknown key type: %d", subkeys->packet->data[0]); } - + length = keylength(subkeys->packet); + + if (get_packetid(subkeys->packet, + &keyid) != ONAK_E_OK) { + logthing(LOGTHING_ERROR, "Couldn't get keyid."); + } printf("sub %5d%c/%08X %04d/%02d/%02d\n", length, - (type == 1) ? 'R' : ((type == 16) ? 'g' : - ((type == 17) ? 'D' : '?')), - (uint32_t) (get_packetid(subkeys->packet) & - 0xFFFFFFFF), + pkalgo2char(type), + (uint32_t) (keyid & 0xFFFFFFFF), created->tm_year + 1900, created->tm_mon + 1, created->tm_mday); @@ -176,10 +291,36 @@ void display_fingerprint(struct openpgp_publickey *key) (i % 2 == 0)) { printf(" "); } - printf("%02X", fp[i]); - if ((i * 2) == length) { + if (length == 20 && (i * 2) == length) { + /* Extra space in the middle of a SHA1 fingerprint */ printf(" "); } + printf("%02X", fp[i]); + } + printf("\n"); + + return; +} + +void display_skshash(struct openpgp_publickey *key, bool html) +{ + int i = 0; + struct skshash hash; + + get_skshash(key, &hash); + printf(" Key hash = "); + if (html) { + printf(""); + } + for (i = 0; i < sizeof(hash.hash); i++) { + printf("%02X", hash.hash[i]); + } + if (html) { + printf(""); } printf("\n"); @@ -197,7 +338,7 @@ void display_fingerprint(struct openpgp_publickey *key) * of them. Useful for debugging or the keyserver Index function. */ int key_index(struct openpgp_publickey *keys, bool verbose, bool fingerprint, - bool html) + bool skshash, bool html) { struct openpgp_signedpacket_list *curuid = NULL; struct tm *created = NULL; @@ -222,28 +363,26 @@ int key_index(struct openpgp_publickey *keys, bool verbose, bool fingerprint, case 2: case 3: type = keys->publickey->data[7]; - length = (keys->publickey->data[8] << 8) + - keys->publickey->data[9]; break; case 4: type = keys->publickey->data[5]; - length = (keys->publickey->data[6] << 8) + - keys->publickey->data[7]; break; default: logthing(LOGTHING_ERROR, "Unknown key type: %d", keys->publickey->data[0]); } - - keyid = get_keyid(keys); + length = keylength(keys->publickey); + + if (get_keyid(keys, &keyid) != ONAK_E_OK) { + logthing(LOGTHING_ERROR, "Couldn't get keyid."); + } if (html) { printf("pub %5d%c/%08" PRIX64 + "search=0x%016" PRIX64 "\">%08" PRIX64 " %04d/%02d/%02d ", length, - (type == 1) ? 'R' : ((type == 16) ? 'g' : - ((type == 17) ? 'D' : '?')), + pkalgo2char(type), keyid, keyid & 0xFFFFFFFF, created->tm_year + 1900, @@ -252,8 +391,7 @@ int key_index(struct openpgp_publickey *keys, bool verbose, bool fingerprint, } else { printf("pub %5d%c/%08" PRIX64 " %04d/%02d/%02d ", length, - (type == 1) ? 'R' : ((type == 16) ? 'g' : - ((type == 17) ? 'D' : '?')), + pkalgo2char(type), keyid & 0xFFFFFFFF, created->tm_year + 1900, created->tm_mon + 1, @@ -261,7 +399,8 @@ int key_index(struct openpgp_publickey *keys, bool verbose, bool fingerprint, } curuid = keys->uids; - if (curuid != NULL && curuid->packet->tag == 13) { + if (curuid != NULL && + curuid->packet->tag == OPENPGP_PACKET_UID) { snprintf(buf, 1023, "%.*s", (int) curuid->packet->length, curuid->packet->data); @@ -274,6 +413,9 @@ int key_index(struct openpgp_publickey *keys, bool verbose, bool fingerprint, (html) ? txt2html(buf) : buf, (html) ? "" : "", (keys->revoked) ? " *** REVOKED ***" : ""); + if (skshash) { + display_skshash(keys, html); + } if (fingerprint) { display_fingerprint(keys); } @@ -320,6 +462,8 @@ int mrkey_index(struct openpgp_publickey *keys) int i = 0; size_t fplength = 0; unsigned char fp[20]; + int c; + uint64_t keyid; while (keys != NULL) { created_time = (keys->publickey->data[1] << 24) + @@ -332,10 +476,11 @@ int mrkey_index(struct openpgp_publickey *keys) switch (keys->publickey->data[0]) { case 2: case 3: - printf("%016" PRIX64, get_keyid(keys)); + if (get_keyid(keys, &keyid) != ONAK_E_OK) { + logthing(LOGTHING_ERROR, "Couldn't get keyid"); + } + printf("%016" PRIX64, keyid); type = keys->publickey->data[7]; - length = (keys->publickey->data[8] << 8) + - keys->publickey->data[9]; break; case 4: (void) get_fingerprint(keys->publickey, fp, &fplength); @@ -345,13 +490,12 @@ int mrkey_index(struct openpgp_publickey *keys) } type = keys->publickey->data[5]; - length = (keys->publickey->data[6] << 8) + - keys->publickey->data[7]; break; default: logthing(LOGTHING_ERROR, "Unknown key type: %d", keys->publickey->data[0]); } + length = keylength(keys->publickey); printf(":%d:%d:%ld::%s\n", type, @@ -362,10 +506,21 @@ int mrkey_index(struct openpgp_publickey *keys) for (curuid = keys->uids; curuid != NULL; curuid = curuid->next) { - if (curuid->packet->tag == 13) { - printf("uid:%.*s\n", - (int) curuid->packet->length, - curuid->packet->data); + if (curuid->packet->tag == OPENPGP_PACKET_UID) { + printf("uid:"); + for (i = 0; i < (int) curuid->packet->length; + i++) { + c = curuid->packet->data[i]; + if (c == '%') { + putchar('%'); + putchar(c); + } else if (c == ':' || c > 127) { + printf("%%%X", c); + } else { + putchar(c); + } + } + printf("\n"); } } keys = keys->next;