use std::convert::TryFrom;
use dyn_clone::DynClone;
use crate::HashAlgorithm;
use crate::packet::Key;
use crate::packet::UserID;
use crate::packet::UserAttribute;
use crate::packet::key;
use crate::packet::key::Key4;
use crate::packet::Signature;
use crate::packet::signature::{self, Signature4};
use crate::Result;
use crate::types::Timestamp;
use std::fs::{File, OpenOptions};
use std::io::{self, Write};
const DUMP_HASHED_VALUES: Option<&str> = None;
pub trait Digest: DynClone + Write + Send + Sync {
fn algo(&self) -> HashAlgorithm;
fn digest_size(&self) -> usize;
fn update(&mut self, data: &[u8]);
fn digest(&mut self, digest: &mut [u8]) -> Result<()>;
fn into_digest(mut self) -> Result<Vec<u8>>
where Self: std::marker::Sized
{
let mut digest = vec![0u8; self.digest_size()];
self.digest(&mut digest)?;
Ok(digest)
}
}
dyn_clone::clone_trait_object!(Digest);
impl Digest for Box<dyn Digest> {
fn algo(&self) -> HashAlgorithm {
self.as_ref().algo()
}
fn digest_size(&self) -> usize {
self.as_ref().digest_size()
}
fn update(&mut self, data: &[u8]) {
self.as_mut().update(data)
}
fn digest(&mut self, digest: &mut [u8]) -> Result<()>{
self.as_mut().digest(digest)
}
}
impl HashAlgorithm {
pub fn context(self) -> Result<Box<dyn Digest>> {
let hasher: Box<dyn Digest> = match self {
HashAlgorithm::SHA1 =>
Box::new(crate::crypto::backend::sha1cd::build()),
_ => self.new_hasher()?,
};
Ok(if let Some(prefix) = DUMP_HASHED_VALUES {
Box::new(HashDumper::new(hasher, prefix))
} else {
hasher
})
}
}
struct HashDumper {
hasher: Box<dyn Digest>,
sink: File,
filename: String,
written: usize,
}
impl HashDumper {
fn new(hasher: Box<dyn Digest>, prefix: &str) -> Self {
let mut n = 0;
let mut filename;
let sink = loop {
filename = format!("{}-{}", prefix, n);
match OpenOptions::new().write(true).create_new(true)
.open(&filename)
{
Ok(f) => break f,
Err(_) => n += 1,
}
};
eprintln!("HashDumper: Writing to {}...", &filename);
HashDumper {
hasher,
sink,
filename,
written: 0,
}
}
}
impl Clone for HashDumper {
fn clone(&self) -> HashDumper {
let prefix = DUMP_HASHED_VALUES
.expect("cloning a HashDumper but DUMP_HASHED_VALUES wasn't specified");
HashDumper::new(self.hasher.clone(), prefix)
}
}
impl Drop for HashDumper {
fn drop(&mut self) {
eprintln!("HashDumper: Wrote {} bytes to {}...", self.written,
self.filename);
}
}
impl Digest for HashDumper {
fn algo(&self) -> HashAlgorithm {
self.hasher.algo()
}
fn digest_size(&self) -> usize {
self.hasher.digest_size()
}
fn update(&mut self, data: &[u8]) {
self.hasher.update(data);
self.sink.write_all(data).unwrap();
self.written += data.len();
}
fn digest(&mut self, digest: &mut [u8]) -> Result<()> {
self.hasher.digest(digest)
}
}
impl io::Write for HashDumper {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.hasher.write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.hasher.flush()
}
}
pub trait Hash {
fn hash(&self, hash: &mut dyn Digest);
}
impl Hash for UserID {
fn hash(&self, hash: &mut dyn Digest) {
let len = self.value().len() as u32;
let mut header = [0; 5];
header[0] = 0xB4;
header[1..5].copy_from_slice(&len.to_be_bytes());
hash.update(&header);
hash.update(self.value());
}
}
impl Hash for UserAttribute {
fn hash(&self, hash: &mut dyn Digest) {
let len = self.value().len() as u32;
let mut header = [0; 5];
header[0] = 0xD1;
header[1..5].copy_from_slice(&len.to_be_bytes());
hash.update(&header);
hash.update(self.value());
}
}
impl<P, R> Hash for Key4<P, R>
where P: key::KeyParts,
R: key::KeyRole,
{
fn hash(&self, hash: &mut dyn Digest) {
use crate::serialize::MarshalInto;
let len = (9 - 3) + self.mpis().serialized_len() as u16;
let mut header: Vec<u8> = Vec::with_capacity(9);
header.push(0x99);
header.extend_from_slice(&len.to_be_bytes());
header.push(4);
let creation_time: u32 =
Timestamp::try_from(self.creation_time())
.unwrap_or_else(|_| Timestamp::from(0))
.into();
header.extend_from_slice(&creation_time.to_be_bytes());
header.push(self.pk_algo().into());
hash.update(&header[..]);
self.mpis().hash(hash);
}
}
impl Hash for Signature {
fn hash(&self, hash: &mut dyn Digest) {
match self {
Signature::V4(sig) => sig.hash(hash),
}
}
}
impl Hash for Signature4 {
fn hash(&self, hash: &mut dyn Digest) {
self.fields.hash(hash);
}
}
impl Hash for signature::SignatureFields {
fn hash(&self, hash: &mut dyn Digest) {
use crate::serialize::MarshalInto;
let hashed_area = self.hashed_area().to_vec()
.unwrap_or_else(|_| Vec::new());
let mut header = [0u8; 6];
header[0] = 4;
header[1] = self.typ().into();
header[2] = self.pk_algo().into();
header[3] = self.hash_algo().into();
let len = hashed_area.len() as u16;
header[4..6].copy_from_slice(&len.to_be_bytes());
hash.update(&header[..]);
hash.update(&hashed_area);
let mut trailer = [0u8; 6];
trailer[0] = 4;
trailer[1] = 0xff;
let len = (header.len() + hashed_area.len()) as u32;
trailer[2..6].copy_from_slice(&len.to_be_bytes());
hash.update(&trailer[..]);
}
}
impl signature::SignatureFields {
pub fn hash_standalone(&self, hash: &mut dyn Digest)
{
self.hash(hash);
}
pub fn hash_timestamp(&self, hash: &mut dyn Digest)
{
self.hash_standalone(hash);
}
pub fn hash_direct_key<P>(&self, hash: &mut dyn Digest,
key: &Key<P, key::PrimaryRole>)
where P: key::KeyParts,
{
key.hash(hash);
self.hash(hash);
}
pub fn hash_subkey_binding<P, Q>(&self, hash: &mut dyn Digest,
key: &Key<P, key::PrimaryRole>,
subkey: &Key<Q, key::SubordinateRole>)
where P: key::KeyParts,
Q: key::KeyParts,
{
key.hash(hash);
subkey.hash(hash);
self.hash(hash);
}
pub fn hash_primary_key_binding<P, Q>(&self, hash: &mut dyn Digest,
key: &Key<P, key::PrimaryRole>,
subkey: &Key<Q, key::SubordinateRole>)
where P: key::KeyParts,
Q: key::KeyParts,
{
self.hash_subkey_binding(hash, key, subkey);
}
pub fn hash_userid_binding<P>(&self, hash: &mut dyn Digest,
key: &Key<P, key::PrimaryRole>,
userid: &UserID)
where P: key::KeyParts,
{
key.hash(hash);
userid.hash(hash);
self.hash(hash);
}
pub fn hash_user_attribute_binding<P>(
&self,
hash: &mut dyn Digest,
key: &Key<P, key::PrimaryRole>,
ua: &UserAttribute)
where P: key::KeyParts,
{
key.hash(hash);
ua.hash(hash);
self.hash(hash);
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::Cert;
use crate::parse::Parse;
#[test]
fn hash_verification() {
fn check(cert: Cert) -> (usize, usize, usize) {
let mut userid_sigs = 0;
for (i, binding) in cert.userids().enumerate() {
for selfsig in binding.self_signatures() {
let mut hash = selfsig.hash_algo().context().unwrap();
selfsig.hash_userid_binding(
&mut hash,
cert.primary_key().key(),
binding.userid());
let h = hash.into_digest().unwrap();
if &h[..2] != selfsig.digest_prefix() {
eprintln!("{:?}: {:?} / {:?}",
i, binding.userid(), selfsig);
eprintln!(" Hash: {:?}", h);
}
assert_eq!(&h[..2], selfsig.digest_prefix());
userid_sigs += 1;
}
}
let mut ua_sigs = 0;
for (i, a) in cert.user_attributes().enumerate()
{
for selfsig in a.self_signatures() {
let mut hash = selfsig.hash_algo().context().unwrap();
selfsig.hash_user_attribute_binding(
&mut hash,
cert.primary_key().key(),
a.user_attribute());
let h = hash.into_digest().unwrap();
if &h[..2] != selfsig.digest_prefix() {
eprintln!("{:?}: {:?} / {:?}",
i, a.user_attribute(), selfsig);
eprintln!(" Hash: {:?}", h);
}
assert_eq!(&h[..2], selfsig.digest_prefix());
ua_sigs += 1;
}
}
let mut subkey_sigs = 0;
for (i, binding) in cert.subkeys().enumerate() {
for selfsig in binding.self_signatures() {
let mut hash = selfsig.hash_algo().context().unwrap();
selfsig.hash_subkey_binding(
&mut hash,
cert.primary_key().key(),
binding.key());
let h = hash.into_digest().unwrap();
if &h[..2] != selfsig.digest_prefix() {
eprintln!("{:?}: {:?}", i, binding);
eprintln!(" Hash: {:?}", h);
}
assert_eq!(h[0], selfsig.digest_prefix()[0]);
assert_eq!(h[1], selfsig.digest_prefix()[1]);
subkey_sigs += 1;
}
}
(userid_sigs, ua_sigs, subkey_sigs)
}
check(Cert::from_bytes(crate::tests::key("hash-algos/MD5.gpg")).unwrap());
check(Cert::from_bytes(crate::tests::key("hash-algos/RipeMD160.gpg")).unwrap());
check(Cert::from_bytes(crate::tests::key("hash-algos/SHA1.gpg")).unwrap());
check(Cert::from_bytes(crate::tests::key("hash-algos/SHA224.gpg")).unwrap());
check(Cert::from_bytes(crate::tests::key("hash-algos/SHA256.gpg")).unwrap());
check(Cert::from_bytes(crate::tests::key("hash-algos/SHA384.gpg")).unwrap());
check(Cert::from_bytes(crate::tests::key("hash-algos/SHA512.gpg")).unwrap());
check(Cert::from_bytes(crate::tests::key("bannon-all-uids-subkeys.gpg")).unwrap());
let (_userid_sigs, ua_sigs, _subkey_sigs)
= check(Cert::from_bytes(crate::tests::key("dkg.gpg")).unwrap());
assert!(ua_sigs > 0);
}
}