1 use crate::crypto::secp256r1::validate_ecdsa as validate_256r1;
2 use crate::crypto::secp384r1::validate_ecdsa as validate_384r1;
3 use crate::crypto::rsa::validate_rsa;
4 use crate::crypto::hash::{Hasher, HashResult};
6 use hex_conservative::FromHex;
10 fn open_file(name: &str) -> File {
11 if let Ok(f) = File::open(name) { return f; }
12 if let Ok(f) = File::open("../".to_owned() + name) { return f; }
13 if let Ok(f) = File::open("src/test/".to_owned() + name) { return f; }
14 if let Ok(f) = File::open("../src/test/".to_owned() + name) { return f; }
15 if let Ok(f) = File::open("../../src/test/".to_owned() + name) { return f; }
16 panic!("Failed to find file {}", name);
19 fn decode_asn(sig: &str, int_len: usize) -> Result<Vec<u8>, ()> {
20 // Signature is in ASN, so decode the garbage excess headers
21 // Note that some tests are specifically for the ASN parser, so we have to carefully
22 // reject invalid crap here.
23 if sig.len() < 12 { return Err(()); }
25 if &sig[..2] != "30" { return Err(()); }
26 let total_len = (<[u8; 2]>::from_hex(&sig[..4]).unwrap())[1] as usize;
27 if total_len + 2 != sig.len() / 2 { return Err(()); }
29 if &sig[4..6] != "02" { return Err(()); }
30 let r_len = (<[u8; 2]>::from_hex(&sig[4..8]).unwrap())[1] as usize;
31 if sig.len() < r_len * 2 + 8 { return Err(()); }
32 if r_len == 0 { return Err(()); }
33 let r = Vec::from_hex(&sig[8..r_len * 2 + 8]).unwrap();
34 if r.len() > int_len {
35 // If the MSB is 1, an extra byte is required to avoid the sign flag
36 if r.len() > int_len + 1 { return Err(()); }
37 if r[0] != 0 { return Err(()); }
38 if r[1] & 0b1000_0000 == 0 { return Err(()); }
39 } else if r[0] & 0b1000_0000 != 0 { return Err(()); }
41 if sig.len() < r_len * 2 + 12 { return Err(()); }
42 if &sig[r_len * 2 + 8..r_len * 2 + 10] != "02" { return Err(()); }
43 let s_len = (<[u8; 2]>::from_hex(&sig[r_len * 2 + 8..r_len * 2 + 12]).unwrap())[1] as usize;
44 if sig.len() != r_len * 2 + s_len * 2 + 12 { return Err(()); }
45 if s_len == 0 { return Err(()); }
46 let s = Vec::from_hex(&sig[r_len * 2 + 12..]).unwrap();
47 if s.len() > int_len {
48 // If the MSB is 1, an extra byte is required to avoid the sign flag
49 if s.len() > int_len + 1 { return Err(()); }
50 if s[0] != 0 { return Err(()); }
51 if s[1] & 0b1000_0000 == 0 { return Err(()); }
52 } else if s[0] & 0b1000_0000 != 0 { return Err(()); }
54 let mut sig_bytes = vec![0; int_len * 2];
55 sig_bytes[int_len.saturating_sub(r.len())..int_len]
56 .copy_from_slice(&r[r.len().saturating_sub(int_len)..]);
57 sig_bytes[int_len + int_len.saturating_sub(s.len())..int_len * 2]
58 .copy_from_slice(&s[s.len().saturating_sub(int_len)..]);
64 Validate: Fn(&[u8], &[u8], &[u8]) -> Result<(), ()>,
65 Hash: Fn(&[u8]) -> HashResult,
66 >(v: Value, int_len: usize, validate_fn: Validate, hash_fn: Hash) {
67 for (group_idx, group) in v["testGroups"].as_array().unwrap().into_iter().enumerate() {
68 let pk_str = group["publicKey"]["uncompressed"].as_str().unwrap();
69 assert_eq!(&pk_str[..2], "04"); // OpenSSL uncompressed encoding flag
70 let pk = Vec::from_hex(&pk_str[2..]).unwrap();
71 for test in group["tests"].as_array().unwrap() {
72 let msg = Vec::from_hex(test["msg"].as_str().unwrap()).unwrap();
74 let result = match test["result"].as_str().unwrap() {
77 r => panic!("Unknown result type {}", r),
80 let sig = decode_asn(test["sig"].as_str().unwrap(), int_len);
82 assert_eq!(result, Err(()));
86 let hash = hash_fn(&msg);
87 assert_eq!(result, validate_fn(&pk, &sig.unwrap(), hash.as_ref()),
88 "Failed test case group {}, test id {}, comment {}", group_idx, test["tcId"], test["comment"]);
94 fn test_ecdsa_256r1() {
95 let f = open_file("ecdsa_secp256r1_sha256_test.json");
96 let v: Value = serde_json::from_reader(f).unwrap();
97 test_ecdsa(v, 32, validate_256r1, |msg| {
98 let mut hasher = Hasher::sha256();
105 fn test_ecdsa_384r1_sha256() {
106 let f = open_file("ecdsa_secp384r1_sha256_test.json");
107 let v: Value = serde_json::from_reader(f).unwrap();
108 test_ecdsa(v, 48, validate_384r1, |msg| {
109 let mut hasher = Hasher::sha256();
116 fn test_ecdsa_384r1_sha384() {
117 let f = open_file("ecdsa_secp384r1_sha384_test.json");
118 let v: Value = serde_json::from_reader(f).unwrap();
119 test_ecdsa(v, 48, validate_384r1, |msg| {
120 let mut hasher = Hasher::sha384();
126 fn test_rsa<Hash: Fn(&[u8]) -> HashResult>(v: Value, pk_len: usize, hash_fn: Hash) {
127 for (group_idx, group) in v["testGroups"].as_array().unwrap().into_iter().enumerate() {
128 let pk_str = group["publicKey"]["modulus"].as_str().unwrap();
129 assert_eq!(&pk_str[..2], "00"); // No idea why this is here
130 let pk = Vec::from_hex(&pk_str[2..]).unwrap();
131 assert_eq!(pk.len(), pk_len);
132 let exp_vec = Vec::from_hex(group["publicKey"]["publicExponent"].as_str().unwrap()).unwrap();
133 if exp_vec.len() > 4 { panic!(); }
134 let mut exp_bytes = [0; 4];
135 exp_bytes[4 - exp_vec.len()..].copy_from_slice(&exp_vec);
136 let exp = u32::from_be_bytes(exp_bytes);
138 let mut pk_dns_encoded = Vec::new();
139 pk_dns_encoded.push(4);
140 pk_dns_encoded.extend_from_slice(&exp.to_be_bytes());
141 pk_dns_encoded.extend_from_slice(&pk);
143 for test in group["tests"].as_array().unwrap() {
144 let msg = Vec::from_hex(test["msg"].as_str().unwrap()).unwrap();
146 let result = match test["result"].as_str().unwrap() {
148 "invalid" => Err(()),
149 "acceptable" => continue, // Why bother testing if the tests don't care?
150 r => panic!("Unknown result type {}", r),
153 let sig = Vec::from_hex(test["sig"].as_str().unwrap()).unwrap();
155 let hash = hash_fn(&msg);
156 assert_eq!(result, validate_rsa(&pk_dns_encoded, &sig, hash.as_ref()),
157 "Failed test case group {}, test id {}, comment {}", group_idx, test["tcId"], test["comment"]);
163 fn test_rsa2048_sha256() {
164 let f = open_file("rsa_signature_2048_sha256_test.json");
165 let v: Value = serde_json::from_reader(f).unwrap();
166 test_rsa(v, 256, |msg| {
167 let mut hasher = Hasher::sha256();
174 fn test_rsa2048_sha512() {
175 let f = open_file("rsa_signature_2048_sha512_test.json");
176 let v: Value = serde_json::from_reader(f).unwrap();
177 test_rsa(v, 256, |msg| {
178 let mut hasher = Hasher::sha512();
185 fn test_rsa3072_sha256() {
186 let f = open_file("rsa_signature_3072_sha256_test.json");
187 let v: Value = serde_json::from_reader(f).unwrap();
188 test_rsa(v, 384, |msg| {
189 let mut hasher = Hasher::sha256();
196 fn test_rsa3072_sha512() {
197 let f = open_file("rsa_signature_3072_sha512_test.json");
198 let v: Value = serde_json::from_reader(f).unwrap();
199 test_rsa(v, 384, |msg| {
200 let mut hasher = Hasher::sha512();
207 fn test_rsa4096_sha256() {
208 let f = open_file("rsa_signature_4096_sha256_test.json");
209 let v: Value = serde_json::from_reader(f).unwrap();
210 test_rsa(v, 512, |msg| {
211 let mut hasher = Hasher::sha256();
218 fn test_rsa4096_sha512() {
219 let f = open_file("rsa_signature_4096_sha512_test.json");
220 let v: Value = serde_json::from_reader(f).unwrap();
221 test_rsa(v, 512, |msg| {
222 let mut hasher = Hasher::sha512();