From d0116abc28011849b0de688200b8782d24088021 Mon Sep 17 00:00:00 2001 From: Daniel Kahn Gillmor Date: Sun, 12 Jul 2009 20:25:59 -0400 Subject: [PATCH] broke out gensig() to create individual self-sig packets of various types. --- src/share/keytrans | 226 ++++++++++++++++++++++++++------------------- 1 file changed, 132 insertions(+), 94 deletions(-) diff --git a/src/share/keytrans b/src/share/keytrans index a13d382..171a1f6 100755 --- a/src/share/keytrans +++ b/src/share/keytrans @@ -426,54 +426,22 @@ sub pem2openpgp { my $uid = shift; my $args = shift; - $rsa->use_sha256_hash(); - - # see page 22 of RFC 4880 for why i think this is the right padding - # choice to use: - $rsa->use_pkcs1_padding(); - - if (! $rsa->check_key()) { - die "key does not check"; - } - # strong assertion of identity is the default (for a self-sig): - my $certtype = $sig_types->{positive_certification}; - if (defined $args->{certification_type}) { - $certtype = $args->{certification_type} + 0; + if (! defined $args->{certification_type}) { + $args->{certification_type} = $sig_types->{positive_certification}; } - my $version = pack('C', 4); - my $sigtype = pack('C', $certtype); - # RSA - my $pubkey_algo = pack('C', $asym_algos->{rsa}); - # SHA256 - my $hash_algo = pack('C', $digests->{sha256}); - - # FIXME: i'm worried about generating a bazillion new OpenPGP - # certificates from the same key, which could easily happen if you run - # this script more than once against the same key (because the - # timestamps will differ). How can we prevent this? - - # this argument (if set) overrides the current time, to - # be able to create a standard key. If we read the key from a file - # instead of stdin, should we use the creation time on the file? - my $sig_timestamp = 0; - if (defined $args->{sig_timestamp}) { - $sig_timestamp = ($args->{sig_timestamp} + 0); - } else { - $sig_timestamp = time(); - } - my $key_timestamp = $sig_timestamp; - if (defined $args->{key_timestamp}) { - $key_timestamp = ($args->{key_timestamp} + 0); + if (! defined $args->{sig_timestamp}) { + $args->{sig_timestamp} = time(); } - if ($key_timestamp > $sig_timestamp) { - die "key timestamp must not be later than signature timestamp"; + if (! defined $args->{key_timestamp}) { + $args->{key_timestamp} = $args->{sig_timestamp} + 0; } + my $key_timestamp = $args->{key_timestamp}; - my $creation_time_packet = pack('CCN', 5, $subpacket_types->{sig_creation_time}, $sig_timestamp); - + # generate and aggregate subpackets: + # key usage flags: my $flags = 0; if (! defined $args->{usage_flags}) { $flags = $usage_flags->{certify}; @@ -486,17 +454,15 @@ sub pem2openpgp { $flags |= $usage_flags->{$f}; } } - - my $usage_packet = pack('CCC', 2, $subpacket_types->{usage_flags}, $flags); - + my $usage_subpacket = pack('CCC', 2, $subpacket_types->{usage_flags}, $flags); # how should we determine how far off to set the expiration date? # default is no expiration. Specify the timestamp in seconds from the # key creation. - my $expiration_packet = ''; + my $expiration_subpacket = ''; if (defined $args->{expiration}) { my $expires_in = $args->{expiration} + 0; - $expiration_packet = pack('CCN', 5, $subpacket_types->{key_expiration_time}, $expires_in); + $expiration_subpacket = pack('CCN', 5, $subpacket_types->{key_expiration_time}, $expires_in); } @@ -534,17 +500,71 @@ sub pem2openpgp { my $keyserver_pref = pack('CCC', 2, $subpacket_types->{keyserver_prefs}, $keyserver_prefs->{nomodify}); - my $subpackets_to_be_hashed = - $creation_time_packet. - $usage_packet. - $expiration_packet. + + $args->{hashed_subpackets} = + $usage_subpacket. + $expiration_subpacket. $pref_sym_algos. $pref_hash_algos. $pref_zip_algos. $feature_subpacket. $keyserver_pref; - my $subpacket_octets = pack('n', length($subpackets_to_be_hashed)); + return + make_packet($packet_types->{seckey}, make_rsa_sec_key_body($rsa, $key_timestamp)). + make_packet($packet_types->{uid}, $uid). + gensig($rsa, $uid, $args); +} + +# FIXME: handle non-RSA keys + +# FIXME: this currently only makes self-sigs -- we should parameterize +# it to make certifications over keys other than the issuer. +sub gensig { + my $rsa = shift; + my $uid = shift; + my $args = shift; + + # FIXME: allow signature creation using digests other than SHA256 + $rsa->use_sha256_hash(); + + # see page 22 of RFC 4880 for why i think this is the right padding + # choice to use: + $rsa->use_pkcs1_padding(); + + if (! $rsa->check_key()) { + die "key does not check"; + } + + my $certtype = $args->{certification_type} + 0; + + my $version = pack('C', 4); + my $sigtype = pack('C', $certtype); + # RSA + my $pubkey_algo = pack('C', $asym_algos->{rsa}); + # SHA256 FIXME: allow signature creation using digests other than SHA256 + my $hash_algo = pack('C', $digests->{sha256}); + + # FIXME: i'm worried about generating a bazillion new OpenPGP + # certificates from the same key, which could easily happen if you run + # this script more than once against the same key (because the + # timestamps will differ). How can we prevent this? + + # this argument (if set) overrides the current time, to + # be able to create a standard key. If we read the key from a file + # instead of stdin, should we use the creation time on the file? + my $sig_timestamp = ($args->{sig_timestamp} + 0); + my $key_timestamp = ($args->{key_timestamp} + 0); + + if ($key_timestamp > $sig_timestamp) { + die "key timestamp must not be later than signature timestamp"; + } + + my $creation_time_packet = pack('CCN', 5, $subpacket_types->{sig_creation_time}, $sig_timestamp); + + my $hashed_subs = $creation_time_packet.$args->{hashed_subpackets}; + + my $subpacket_octets = pack('n', length($hashed_subs)); my $sig_data_to_be_hashed = $version. @@ -552,10 +572,9 @@ sub pem2openpgp { $pubkey_algo. $hash_algo. $subpacket_octets. - $subpackets_to_be_hashed; + $hashed_subs; my $pubkey = make_rsa_pub_key_body($rsa, $key_timestamp); - my $seckey = make_rsa_sec_key_body($rsa, $key_timestamp); # this is for signing. it needs to be an old-style header with a # 2-packet octet count. @@ -581,6 +600,8 @@ sub pem2openpgp { $sig_data_to_be_hashed. $trailer; + + # FIXME: handle signatures over digests other than SHA256: my $data_hash = Digest::SHA::sha256_hex($datatosign); my $issuer_packet = pack('CCa8', 9, $subpacket_types->{issuer}, $keyid); @@ -594,10 +615,7 @@ sub pem2openpgp { pack('n', hex(substr($data_hash, 0, 4))). mpi_pack($sig); - return - make_packet($packet_types->{seckey}, $seckey). - make_packet($packet_types->{uid}, $uid). - make_packet($packet_types->{sig}, $sig_body); + return make_packet($packet_types->{sig}, $sig_body); } # FIXME: switch to passing the whole packet as the arg, instead of the @@ -616,7 +634,8 @@ sub finduid { ($tag == $packet_types->{uid}) or die "This should not be called on anything but a User ID packet"; read($instr, $dummy, $packetlen); - $data->{uid} = $dummy; + $data->{uid} = {} unless defined $data->{uid}; + $data->{uid}->{$dummy} = {}; } @@ -627,16 +646,18 @@ sub findsig { my $tag = shift; my $packetlen = shift; - ($tag == $packet_types->{sig}) or die "No calling revuid on anything other than a signature packet."; + ($tag == $packet_types->{sig}) or die "No calling findsig on anything other than a signature packet."; + + my $dummy; + my $readbytes = 0; if ((undef $data->{key}) || (undef $data->{uid}) || - ($data->{uid} ne $data->{target}->{uid})) { + (undef $data->{uid}->{$data->{target}->{uid}})) { # this is not the user ID we are looking for. read($instr, $dummy, $packetlen - $readbytes) or die "Could not skip past this packet.\n"; } - my $data; read($instr, $data, 6) or die "could not read signature header\n"; my ($ver, $sigtype, $pubkeyalgo, $digestalgo, $subpacketsize) = unpack('CCCCn', $data); if ($ver != 4) { @@ -669,19 +690,10 @@ sub findsig { my $hashtail; read($instr, $hashtail, 2) or die "could not read left 16 bits of digest.\n"; - # RSA signatures should read in how many MPIs? - - - # reason for revocation - - # non-revocable + # FIXME: RSA signatures should read in how many MPIs? } -# FIXME: to do in order to generate a proper revocation certificate: -# parse subpackets - - # given an input stream and data, store the found key in data and # consume the rest of the stream corresponding to the packet. # data contains: (fpr: fingerprint to find, key: current best guess at key) @@ -737,7 +749,8 @@ sub findkey { if (defined($data->{key})) { die "Found two matching keys.\n"; } - $data->{key} = $pubkey; + $data->{key} = { 'rsa' => $pubkey, + 'timestamp' => $key_timestamp }; } if ($tag != $packet_types->{seckey} && @@ -747,7 +760,7 @@ sub findkey { } return; } - if (!defined($data->{key})) { + if (!defined($data->{key})) { # we don't think the public part of this key matches if ($readbytes < $packetlen) { read($instr, $dummy, $packetlen - $readbytes) or die "Could not skip past this packet.\n"; @@ -780,20 +793,20 @@ sub findkey { # FIXME: compare with the checksum! how? the data is # gone into the Crypt::OpenSSL::Bignum - $data->{key} = Crypt::OpenSSL::RSA->new_key_from_parameters($modulus, - $exponent, - $d, - $p, - $q); + $data->{key}->{rsa} = Crypt::OpenSSL::RSA->new_key_from_parameters($modulus, + $exponent, + $d, + $p, + $q); - $data->{key}->check_key() or die "Secret key is not a valid RSA key.\n"; + $data->{key}->{rsa}->check_key() or die "Secret key is not a valid RSA key.\n"; if ($readbytes < $packetlen) { read($instr, $dummy, $packetlen - $readbytes) or die "Could not skip past this packet.\n"; } } -sub openpgp2ssh { +sub openpgp2rsa { my $instr = shift; my $fpr = shift; @@ -812,7 +825,7 @@ sub openpgp2ssh { packetwalk($instr, $subs, $data); - return $data->{key}; + return $data->{key}->{rsa}; } sub revokeuserid { @@ -820,26 +833,40 @@ sub revokeuserid { my $fpr = shift; my $uid = shift; - if (defined $fpr) { - if (length($fpr) < 8) { - die "We need at least 8 hex digits of fingerprint.\n"; - } - $fpr = uc($fpr); + if ((! defined $fpr) || + (length($fpr) < 8)) { + die "We need at least 8 hex digits of fingerprint.\n"; + } + + $fpr = uc($fpr); + + if (! defined $uid) { + die "No User ID defined.\n"; } my $data = { target => { fpr => $fpr, - uid => $uid, }, + }, }; - my $subs = { $packet_types->{pubkey} => \&findkey, - $packet_types->{pub_subkey} => \&findkey, - $packet_types->{seckey} => \&findkey, - $packet_types->{sec_subkey} => \&findkey, - $packet_types->{uid} => \&finduid, - $packet_types->{sig} => \&revuid, + my $subs = { $packet_types->{seckey} => \&findkey, + $packet_types->{uid} => \&finduid }; + packetwalk($instr, $subs, $data); + if ((! defined $data->{uid}) || + (! defined $data->{uid}->{$uid})) { + die "The User ID \"$uid\" is not associated with this key"; + } + if ((! defined $data->{key}) || + (! defined $data->{key}->{rsa}) || + (! defined $data->{key}->{timestamp})) { + die "The key requested was not found." + } + + # what does a signature like this look like? + + return 'abc'; } @@ -950,7 +977,7 @@ for (basename($0)) { my $instream; open($instream,'-'); binmode($instream, ":bytes"); - my $key = openpgp2ssh($instream, $fpr); + my $key = openpgp2rsa($instream, $fpr); if (defined($key)) { if ($key->is_private()) { print $key->get_private_key_string(); @@ -961,6 +988,17 @@ for (basename($0)) { die "No matching key found.\n"; } } + elsif (/^revokeuserid$/) { + my $fpr = shift; + my $uid = shift; + my $instream; + open($instream,'-'); + binmode($instream, ":bytes"); + + my $revcert = revokeuserid($instream, $fpr, $uid); + + print $revcert; + } else { die "Unrecognized keytrans call.\n"; } -- 2.25.1