X-Git-Url: http://the.earth.li/gitweb/?a=blobdiff_plain;f=keyindex.c;h=f3c36aafbf3527408894357ce80c1c7f6ecc2bd0;hb=0e735a0b184b202a0533c52171fc55506fa45db2;hp=6aab5d3c73da891faeebe6d3262d3420a464fead;hpb=0211c730256c9bbaf10a569c88f7df0ef882311e;p=onak.git diff --git a/keyindex.c b/keyindex.c index 6aab5d3..f3c36aa 100644 --- a/keyindex.c +++ b/keyindex.c @@ -2,6 +2,19 @@ * keyindex.c - Routines to list an OpenPGP key. * * Copyright 2002-2008 Jonathan McDowell + * + * 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 @@ -19,9 +32,112 @@ #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) { char *uid = NULL; @@ -40,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", @@ -114,6 +230,7 @@ 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 == OPENPGP_PACKET_PUBLICSUBKEY) { @@ -128,27 +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 == OPENPGP_PKALGO_RSA) ? 'R' : - ((type == OPENPGP_PKALGO_ELGAMAL) ? 'g' : - ((type == OPENPGP_PKALGO_DSA) ? '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,11 @@ 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"); @@ -228,7 +344,6 @@ int key_index(struct openpgp_publickey *keys, bool verbose, bool fingerprint, struct tm *created = NULL; time_t created_time = 0; int type = 0; - char typech; int length = 0; char buf[1024]; uint64_t keyid; @@ -248,45 +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); - switch (type) { - case OPENPGP_PKALGO_RSA: - typech = 'R'; - break; - case OPENPGP_PKALGO_ELGAMAL: - typech = 'g'; - break; - case OPENPGP_PKALGO_DSA: - typech = 'D'; - break; - case OPENPGP_PKALGO_ELGAMAL_SIGN: - typech = 'G'; - break; - default: - typech = '?'; - break; + 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, - typech, + pkalgo2char(type), keyid, keyid & 0xFFFFFFFF, created->tm_year + 1900, @@ -295,7 +391,7 @@ int key_index(struct openpgp_publickey *keys, bool verbose, bool fingerprint, } else { printf("pub %5d%c/%08" PRIX64 " %04d/%02d/%02d ", length, - typech, + pkalgo2char(type), keyid & 0xFFFFFFFF, created->tm_year + 1900, created->tm_mon + 1, @@ -367,6 +463,7 @@ int mrkey_index(struct openpgp_publickey *keys) size_t fplength = 0; unsigned char fp[20]; int c; + uint64_t keyid; while (keys != NULL) { created_time = (keys->publickey->data[1] << 24) + @@ -379,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); @@ -392,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,