rsa key verification
diff --git a/src/asn1.rs b/src/asn1.rs
deleted file mode 100644
index 5f6a31d..0000000
--- a/src/asn1.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-//! Helper for writing ASN.1
-
-use ring;
-use std::io::{self, Write};
-use untrusted::Input;
-
-use der::Tag;
-
-pub struct Asn1<'a, W: Write + 'a> {
- writer: &'a mut W,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct Error;
-
-impl From<ring::error::Unspecified> for Error {
- fn from(_: ring::error::Unspecified) -> Error {
- Error
- }
-}
-
-impl From<io::Error> for Error {
- fn from(_: io::Error) -> Error {
- Error
- }
-}
-
-
-impl<'a, W: Write> Asn1<'a, W> {
- pub fn new(writer: &'a mut W) -> Self {
- Asn1 { writer: writer }
- }
-
- fn length_of_length(len: usize) -> u8 {
- let mut i = len;
- let mut num_bytes = 1;
-
- while i > 255 {
- num_bytes += 1;
- i >>= 8;
- }
-
- num_bytes
- }
-
- fn write_len(&mut self, len: usize) -> Result<(), Error> {
- if len >= 128 {
- let n = Self::length_of_length(len);
- self.writer.write_all(&[0x80 | n])?;
-
- for i in (1..n + 1).rev() {
- self.writer.write_all(&[(len >> ((i - 1) * 8)) as u8])?;
- }
- } else {
- self.writer.write_all(&[len as u8])?;
- }
-
- Ok(())
- }
-
- pub fn write_integer(&mut self, input: Input) -> Result<(), Error> {
- self.writer.write_all(&[Tag::Integer as u8])?;
- let mut buf = Vec::new();
-
- input.read_all(Error, |read| {
- while let Ok(byte) = read.read_byte() {
- buf.push(byte);
- }
-
- Ok(())
- })?;
-
- self.write_len(buf.len())?;
-
- Ok(self.writer.write_all(&mut buf)?)
- }
-
- pub fn write_sequence<F: FnOnce(&mut Asn1<Vec<u8>>) -> Result<(), Error>>
- (&mut self,
- func: F)
- -> Result<(), Error> {
- self.writer.write_all(&[Tag::Sequence as u8])?;
- let mut buf = Vec::new();
-
- {
- let mut inner = Asn1::new(&mut buf);
- func(&mut inner)?;
- }
-
- self.write_len(buf.len())?;
- Ok(self.writer.write_all(&buf)?)
- }
-}
diff --git a/src/cjson.rs b/src/cjson.rs
index 377d4f6..b624980 100644
--- a/src/cjson.rs
+++ b/src/cjson.rs
@@ -3,7 +3,7 @@
use std::collections::BTreeMap;
use std::io;
-pub fn canonicalize(jsn: json::Value) -> Result<Vec<u8>, String> {
+pub fn canonicalize(jsn: &json::Value) -> Result<Vec<u8>, String> {
let converted = convert(jsn)?;
let mut buf = Vec::new();
let _ = converted.write(&mut buf); // Vec<u8> impl always succeeds (or panics).
@@ -74,32 +74,32 @@
U64(u64),
}
-fn convert(jsn: json::Value) -> Result<Value, String> {
+fn convert(jsn: &json::Value) -> Result<Value, String> {
match jsn {
- json::Value::Null => Ok(Value::Null),
- json::Value::Bool(b) => Ok(Value::Bool(b)),
- json::Value::Number(n) => {
+ &json::Value::Null => Ok(Value::Null),
+ &json::Value::Bool(b) => Ok(Value::Bool(b)),
+ &json::Value::Number(ref n) => {
n.as_i64()
.map(Number::I64)
.or(n.as_u64().map(Number::U64))
.map(Value::Number)
.ok_or_else(|| String::from("only i64 and u64 are supported"))
}
- json::Value::Array(arr) => {
+ &json::Value::Array(ref arr) => {
let mut out = Vec::new();
- for res in arr.iter().cloned().map(|v| convert(v)) {
+ for res in arr.iter().map(|v| convert(v)) {
out.push(res?)
}
Ok(Value::Array(out))
}
- json::Value::Object(obj) => {
+ &json::Value::Object(ref obj) => {
let mut out = BTreeMap::new();
for (k, v) in obj.iter() {
- let _ = out.insert(k.clone(), convert(v.clone())?);
+ let _ = out.insert(k.clone(), convert(v)?);
}
Ok(Value::Object(out))
}
- json::Value::String(s) => Ok(Value::String(s)),
+ &json::Value::String(ref s) => Ok(Value::String(s.clone())),
}
}
@@ -209,7 +209,7 @@
let mut cjsn = String::new();
file.read_to_string(&mut cjsn).expect("couldn't read root.cjson");
- let jsn = json::from_str(&buf).expect("not json");
+ let ref jsn = json::from_str(&buf).expect("not json");
let out = canonicalize(jsn).expect("couldn't canonicalize");
let out = ::std::str::from_utf8(&out).expect("not utf-8");
diff --git a/src/lib.rs b/src/lib.rs
index 463c114..292ee33 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -156,9 +156,7 @@
#[macro_use]
mod util;
-mod asn1;
mod cjson;
-mod der;
mod error;
mod http;
mod metadata;
diff --git a/src/metadata.rs b/src/metadata.rs
index e1c35c8..7d77a93 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -53,11 +53,11 @@
}
}
-pub trait RoleType: Debug {
+pub trait RoleType: Debug + Clone{
fn matches(role: &Role) -> bool;
}
-#[derive(Debug)]
+#[derive(Debug, Clone)]
pub struct Root {}
impl RoleType for Root {
fn matches(role: &Role) -> bool {
@@ -68,7 +68,7 @@
}
}
-#[derive(Debug)]
+#[derive(Debug, Clone)]
pub struct Targets {}
impl RoleType for Targets {
fn matches(role: &Role) -> bool {
@@ -79,7 +79,7 @@
}
}
-#[derive(Debug)]
+#[derive(Debug, Clone)]
pub struct Timestamp {}
impl RoleType for Timestamp {
fn matches(role: &Role) -> bool {
@@ -90,7 +90,7 @@
}
}
-#[derive(Debug)]
+#[derive(Debug, Clone)]
pub struct Snapshot {}
impl RoleType for Snapshot {
fn matches(role: &Role) -> bool {
@@ -101,8 +101,8 @@
}
}
-#[derive(Debug)]
-pub struct SignedMetadata<R: RoleType> {
+#[derive(Debug, Clone)]
+pub struct SignedMetadata<R: RoleType + Clone> {
pub signatures: Vec<Signature>,
pub signed: json::Value,
_role: PhantomData<R>,
@@ -557,7 +557,7 @@
match self.typ {
KeyType::Unsupported(_) => KeyId(String::from("error")), // TODO this feels wrong, but we check this everywhere else
_ => {
- let key_value = canonicalize(json::Value::String(self.original.clone())).unwrap(); // TODO unwrap
+ let key_value = canonicalize(&json::Value::String(self.original.clone())).unwrap(); // TODO unwrap
KeyId(HEXLOWER.encode(digest(&SHA256, &key_value).as_ref()))
}
}
@@ -674,6 +674,8 @@
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"ed25519" => Ok(SignatureScheme::Ed25519),
+ "rsassa-pss-sha256" => Ok(SignatureScheme::RsaSsaPssSha256),
+ "rsassa-pss-sha512" => Ok(SignatureScheme::RsaSsaPssSha512),
typ => Ok(SignatureScheme::Unsupported(typ.into())),
}
}
diff --git a/src/der.rs b/src/rsa/der.rs
similarity index 73%
rename from src/der.rs
rename to src/rsa/der.rs
index 901f7dd..6b465a6 100644
--- a/src/der.rs
+++ b/src/rsa/der.rs
@@ -17,6 +17,7 @@
//! This module contains the foundational parts of an ASN.1 DER parser.
use ring;
+use std::io::{self, Write};
use untrusted;
pub const CONSTRUCTED: u8 = 1 << 5;
@@ -24,6 +25,7 @@
#[derive(Clone, Copy, PartialEq, Debug)]
#[repr(u8)]
pub enum Tag {
+ EOC = 0x00,
Integer = 0x02,
BitString = 0x03,
Null = 0x05,
@@ -34,7 +36,8 @@
pub fn expect_tag_and_get_value<'a>(input: &mut untrusted::Reader<'a>,
tag: Tag)
-> Result<untrusted::Input<'a>, ring::error::Unspecified> {
- let (actual_tag, inner) = try!(read_tag_and_get_value(input));
+
+ let (actual_tag, inner) = read_tag_and_get_value(input)?;
if (tag as usize) != (actual_tag as usize) {
return Err(ring::error::Unspecified);
}
@@ -44,7 +47,11 @@
pub fn read_tag_and_get_value<'a>
(input: &mut untrusted::Reader<'a>)
-> Result<(u8, untrusted::Input<'a>), ring::error::Unspecified> {
- let tag = try!(input.read_byte());
+ let tag = input.read_byte()?;
+
+ if tag as usize == Tag::EOC as usize {
+ return Ok((tag, untrusted::Input::from(&[])))
+ }
if (tag & 0x1F) == 0x1F {
return Err(ring::error::Unspecified); // High tag number form is not allowed.
@@ -53,20 +60,20 @@
// If the high order bit of the first byte is set to zero then the length
// is encoded in the seven remaining bits of that byte. Otherwise, those
// seven bits represent the number of bytes used to encode the length.
- let length = match try!(input.read_byte()) {
+ let length = match input.read_byte()? {
n if (n & 0x80) == 0 => n as usize,
0x81 => {
- let second_byte = try!(input.read_byte());
+ let second_byte = input.read_byte()?;
if second_byte < 128 {
return Err(ring::error::Unspecified); // Not the canonical encoding.
}
second_byte as usize
}
0x82 => {
- println!("FACK");
- let second_byte = try!(input.read_byte()) as usize;
- let third_byte = try!(input.read_byte()) as usize;
+ let second_byte = input.read_byte()? as usize;
+ let third_byte = input.read_byte()? as usize;
let combined = (second_byte << 8) | third_byte;
+
if combined < 256 {
return Err(ring::error::Unspecified); // Not the canonical encoding.
}
@@ -77,7 +84,8 @@
}
};
- let inner = try!(input.skip_and_get_input(length));
+
+ let inner = input.skip_and_get_input(length)?;
Ok((tag, inner))
}
@@ -90,7 +98,7 @@
-> Result<R, E>
where F: FnOnce(&mut untrusted::Reader<'a>) -> Result<R, E>
{
- let inner = try!(expect_tag_and_get_value(input, tag).map_err(|_| error));
+ let inner = expect_tag_and_get_value(input, tag).map_err(|_| error)?;
inner.read_all(error, decoder)
}
@@ -103,7 +111,7 @@
min_value: u8)
-> Result<(), ring::error::Unspecified> {
input.read_all(ring::error::Unspecified, |input| {
- let first_byte = try!(input.read_byte());
+ let first_byte = input.read_byte()?;
if input.at_end() && first_byte < min_value {
return Err(ring::error::Unspecified);
}
@@ -112,11 +120,11 @@
})
}
- let value = try!(expect_tag_and_get_value(input, Tag::Integer));
+ let value = expect_tag_and_get_value(input, Tag::Integer)?;
value.read_all(ring::error::Unspecified, |input| {
// Empty encodings are not allowed.
- let first_byte = try!(input.read_byte());
+ let first_byte = input.read_byte()?;
if first_byte == 0 {
if input.at_end() {
@@ -128,8 +136,8 @@
}
let r = input.skip_to_end();
- try!(r.read_all(ring::error::Unspecified, |input| {
- let second_byte = try!(input.read_byte());
+ r.read_all(ring::error::Unspecified, |input| {
+ let second_byte = input.read_byte()?;
if (second_byte & 0x80) == 0 {
// A leading zero is only allowed when the value's high bit
// is set.
@@ -137,8 +145,8 @@
}
let _ = input.skip_to_end();
Ok(())
- }));
- try!(check_minimum(r, min_value));
+ })?;
+ check_minimum(r, min_value)?;
return Ok(r);
}
@@ -148,7 +156,7 @@
}
let _ = input.skip_to_end();
- try!(check_minimum(value, min_value));
+ check_minimum(value, min_value)?;
Ok(value)
})
}
@@ -162,6 +170,93 @@
}
+pub struct Der<'a, W: Write + 'a> {
+ writer: &'a mut W,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct Error;
+
+impl From<ring::error::Unspecified> for Error {
+ fn from(_: ring::error::Unspecified) -> Error {
+ Error
+ }
+}
+
+impl From<io::Error> for Error {
+ fn from(_: io::Error) -> Error {
+ Error
+ }
+}
+
+
+impl<'a, W: Write> Der<'a, W> {
+ pub fn new(writer: &'a mut W) -> Self {
+ Der { writer: writer }
+ }
+
+ fn length_of_length(len: usize) -> u8 {
+ let mut i = len;
+ let mut num_bytes = 1;
+
+ while i > 255 {
+ num_bytes += 1;
+ i >>= 8;
+ }
+
+ num_bytes
+ }
+
+ fn write_len(&mut self, len: usize) -> Result<(), Error> {
+ if len >= 128 {
+ let n = Self::length_of_length(len);
+ self.writer.write_all(&[0x80 | n])?;
+
+ for i in (1..n + 1).rev() {
+ self.writer.write_all(&[(len >> ((i - 1) * 8)) as u8])?;
+ }
+ } else {
+ self.writer.write_all(&[len as u8])?;
+ }
+
+ Ok(())
+ }
+
+ pub fn write_integer(&mut self, input: untrusted::Input) -> Result<(), Error> {
+ self.writer.write_all(&[Tag::Integer as u8])?;
+ let mut buf = Vec::new();
+
+ input.read_all(Error, |read| {
+ while let Ok(byte) = read.read_byte() {
+ buf.push(byte);
+ }
+
+ Ok(())
+ })?;
+
+ self.write_len(buf.len())?;
+
+ Ok(self.writer.write_all(&mut buf)?)
+ }
+
+ pub fn write_sequence<F: FnOnce(&mut Der<Vec<u8>>) -> Result<(), Error>>
+ (&mut self,
+ func: F)
+ -> Result<(), Error> {
+ self.writer.write_all(&[Tag::Sequence as u8])?;
+ let mut buf = Vec::new();
+
+ {
+ let mut inner = Der::new(&mut buf);
+ func(&mut inner)?;
+ }
+
+ self.write_len(buf.len())?;
+ Ok(self.writer.write_all(&buf)?)
+ }
+}
+
+
#[cfg(test)]
mod tests {
use super::*;
@@ -222,20 +317,20 @@
#[test]
fn test_positive_integer() {
with_bad_i(ZERO_INTEGER, |input| {
- let _ = try!(positive_integer(input));
+ let _ = positive_integer(input)?;
Ok(())
});
for &(ref test_in, test_out) in GOOD_POSITIVE_INTEGERS.iter() {
with_good_i(test_in, |input| {
let test_out = [test_out];
- assert_eq!(try!(positive_integer(input)),
+ assert_eq!(positive_integer(input)?,
untrusted::Input::from(&test_out[..]));
Ok(())
});
}
for &test_in in BAD_NONNEGATIVE_INTEGERS.iter() {
with_bad_i(test_in, |input| {
- let _ = try!(positive_integer(input));
+ let _ = positive_integer(input)?;
Ok(())
});
}
diff --git a/src/rsa.rs b/src/rsa/mod.rs
similarity index 68%
rename from src/rsa.rs
rename to src/rsa/mod.rs
index e02628a..3a46bdb 100644
--- a/src/rsa.rs
+++ b/src/rsa/mod.rs
@@ -1,22 +1,25 @@
//! Helper module for RSA key encoding / decoding.
+mod der;
+
use untrusted::Input;
-use asn1::{self, Asn1};
-use der::{self, Tag};
+use self::der::{Tag, Der};
+/// Corresponds to `1.2.840.113549.1.1.1 rsaEncryption(PKCS #1)`
const RSA_PKCS1_OID: &'static [u8] = &[0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01];
pub fn convert_to_pkcs1<'a>(input: &[u8]) -> Vec<u8> {
+ // if we ever move away from `ring`, this needs to do an explicit key size check (>= 2048)
from_pkcs1(input)
.or_else(|| from_spki(input))
.unwrap_or_else(|| input.to_vec())
}
fn from_pkcs1(input: &[u8]) -> Option<Vec<u8>> {
- let _input = Input::from(input.clone());
- _input.read_all(asn1::Error, |i| {
- der::nested(i, Tag::Sequence, asn1::Error, |i| {
+ let _input = Input::from(&input);
+ _input.read_all(der::Error, |i| {
+ der::nested(i, Tag::Sequence, der::Error, |i| {
let _ = der::positive_integer(i)?;
let _ = der::positive_integer(i)?;
// if the input was already pkcs1, just return it
@@ -27,43 +30,42 @@
}
fn from_spki(input: &[u8]) -> Option<Vec<u8>> {
- let _input = Input::from(input.clone());
- _input.read_all(asn1::Error, |i| {
- der::nested(i, Tag::Sequence, asn1::Error, |i| {
- der::nested(i, Tag::Sequence, asn1::Error, |i| {
+ let _input = Input::from(&input);
+ _input.read_all(der::Error, |i| {
+ der::nested(i, Tag::Sequence, der::Error, |i| {
+ der::nested(i, Tag::Sequence, der::Error, |i| {
let oid = der::expect_tag_and_get_value(i, Tag::OID)?;
if oid != Input::from(RSA_PKCS1_OID) {
- return Err(asn1::Error);
+ return Err(der::Error);
}
let _ = der::expect_tag_and_get_value(i, Tag::Null)?;
Ok(())
})?;
- println!(">>>>>> A");
- der::nested(i, Tag::BitString, asn1::Error, |i| {
- println!(">>>>>> B");
- //assert_eq!(i.read_byte().map_err(|_| asn1::Error)?, 0); // TODO wtf why
-
- der::nested(i, Tag::Sequence, asn1::Error, |i| {
- println!(">>>>>> C");
- let n = der::positive_integer(i)?;
- let e = der::positive_integer(i)?;
- write_pkcs1(n, e)
- })
+ der::nested(i, Tag::BitString, der::Error, |i| {
+ // wtf why
+ let _ = der::expect_tag_and_get_value(i, Tag::EOC)?;
+ Ok(i.skip_to_end().iter().cloned().collect())
+ //der::nested(i, Tag::Sequence, der::Error, |i| {
+ // let n = der::positive_integer(i)?;
+ // let e = der::positive_integer(i)?;
+ // write_pkcs1(n, e)
+ //})
})
})
})
.ok()
}
-fn write_pkcs1(n: Input, e: Input) -> Result<Vec<u8>, asn1::Error> {
+#[allow(dead_code)]
+fn write_pkcs1(n: Input, e: Input) -> Result<Vec<u8>, der::Error> {
let mut output = Vec::new();
{
- let mut asn1 = Asn1::new(&mut output);
- asn1.write_sequence(|_asn1| {
- _asn1.write_integer(n)?;
- _asn1.write_integer(e)
+ let mut _der = Der::new(&mut output);
+ _der.write_sequence(|_der| {
+ _der.write_integer(n)?;
+ _der.write_integer(e)
})?;
}
@@ -118,18 +120,21 @@
}
#[test]
- fn pkcs1_noop_conversion() {
+ fn pkcs1_noop_conversion_1() {
let contents = read_file("./tests/rsa/pkcs1-1.pub");
let contents = pem::parse(&contents).expect("not PEM").contents;
assert_eq!(convert_to_pkcs1(&contents), contents);
+ }
+ #[test]
+ fn pkcs1_noop_conversion_2() {
let contents = read_file("./tests/rsa/pkcs1-2.pub");
let contents = pem::parse(&contents).expect("not PEM").contents;
assert_eq!(convert_to_pkcs1(&contents), contents);
}
#[test]
- fn pkcs1_from_spki_conversion() {
+ fn pkcs1_from_spki_conversion_1() {
let spki = read_file("./tests/rsa/spki-1.pub");
let spki = pem::parse(&spki).expect("not PEM").contents;
@@ -138,11 +143,23 @@
for (i, (a, b)) in convert_to_pkcs1(&spki).iter().zip(pkcs1.iter()).enumerate() {
println!("{} {} {}", i, a, b);
- if a != b {
- //break;
- }
}
- assert_eq!(convert_to_pkcs1(&spki), pkcs1);
+ assert!(convert_to_pkcs1(&spki) == pkcs1);
+ }
+
+ #[test]
+ fn pkcs1_from_spki_conversion_2() {
+ let spki = read_file("./tests/rsa/spki-2.pub");
+ let spki = pem::parse(&spki).expect("not PEM").contents;
+
+ let pkcs1 = read_file("./tests/rsa/pkcs1-2.pub");
+ let pkcs1 = pem::parse(&pkcs1).expect("not PEM").contents;
+
+ for (i, (a, b)) in convert_to_pkcs1(&spki).iter().zip(pkcs1.iter()).enumerate() {
+ println!("{} {} {}", i, a, b);
+ }
+
+ assert!(convert_to_pkcs1(&spki) == pkcs1);
}
}
diff --git a/src/tuf.rs b/src/tuf.rs
index 3a8e0ce..8b666e4 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -590,9 +590,10 @@
}
};
- let signed = json::from_slice(&buf)?;
- let safe_bytes = Self::verify_meta::<R>(signed, role, threshold, trusted_ids, available_keys)?;
- let meta: M = json::from_slice(&safe_bytes)?;
+ let signed: SignedMetadata<R> = json::from_slice(&buf)?;
+ // TODO clone
+ Self::verify_meta::<R>(signed.clone(), role, threshold, trusted_ids, available_keys)?;
+ let meta: M = json::from_value(signed.signed)?;
if !allow_expired && meta.expires() <= &UTC::now() {
return Err(Error::ExpiredMetadata(role.clone()));
@@ -735,9 +736,9 @@
threshold: i32,
trusted_ids: &[KeyId],
available_keys: &HashMap<KeyId, Key>)
- -> Result<Vec<u8>, Error> {
+ -> Result<(), Error> {
let bytes =
- cjson::canonicalize(signed.signed).map_err(|err| Error::CanonicalJsonError(err))?;
+ cjson::canonicalize(&signed.signed).map_err(|err| Error::CanonicalJsonError(err))?;
let unique_count = signed.signatures
.iter()
@@ -779,7 +780,7 @@
Err(e) => warn!("Failed to verify with key ID {:?}: {:?}", &sig.key_id, e),
}
if valid_sigs == threshold {
- return Ok(bytes);
+ return Ok(());
}
}
}
diff --git a/tests/vectors.rs b/tests/vectors.rs
index 5927cc6..594977f 100644
--- a/tests/vectors.rs
+++ b/tests/vectors.rs
@@ -139,9 +139,9 @@
let val = pem::parse(key.clone())
.expect("key value not pem");
Key {
- typ: KeyType::Ed25519,
+ typ: KeyType::Rsa,
value: KeyValue {
- typ: KeyType::Ed25519,
+ typ: KeyType::Rsa,
value: val.contents,
original: key,
},
@@ -188,6 +188,11 @@
}
(Err(Error::UnmetThreshold(ref role)), &Some(ref err))
+ if err == &"IllegalRsaKeySize".to_string() => {
+ ()
+ }
+
+ (Err(Error::UnmetThreshold(_)), &Some(ref err))
if err.starts_with("UnmetThreshold::") => {
assert!(err.to_lowercase()
.ends_with(role.to_string().as_str()),
