acmed/acmed/src/jws.rs

use acme_common::b64_encode;
use acme_common::crypto::{HashFunction, JwsSignatureAlgorithm, KeyPair};
use acme_common::error::Error;
use serde::Serialize;
use serde_json::value::Value;

#[derive(Serialize)]
struct JwsData {
	protected: String,
	payload: String,
	signature: String,
}

#[derive(Serialize)]
struct JwsProtectedHeader {
	alg: String,
	#[serde(skip_serializing_if = "Option::is_none")]
	jwk: Option<Value>,
	#[serde(skip_serializing_if = "Option::is_none")]
	kid: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	nonce: Option<String>,
	url: String,
}

fn get_jws_data(
	key_pair: &KeyPair,
	sign_alg: &JwsSignatureAlgorithm,
	protected: &str,
	payload: &[u8],
) -> Result<String, Error> {
	let protected = b64_encode(protected);
	let payload = b64_encode(payload);
	let signing_input = format!("{}.{}", protected, payload);
	let signature = key_pair.sign(sign_alg, signing_input.as_bytes())?;
	let signature = b64_encode(&signature);
	let data = JwsData {
		protected,
		payload,
		signature,
	};
	let str_data = serde_json::to_string(&data)?;
	Ok(str_data)
}

pub fn encode_jwk(
	key_pair: &KeyPair,
	sign_alg: &JwsSignatureAlgorithm,
	payload: &[u8],
	url: &str,
	nonce: Option<String>,
) -> Result<String, Error> {
	let protected = JwsProtectedHeader {
		alg: sign_alg.to_string(),
		jwk: Some(key_pair.jwk_public_key()?),
		kid: None,
		nonce,
		url: url.into(),
	};
	let protected = serde_json::to_string(&protected)?;
	get_jws_data(key_pair, sign_alg, &protected, payload)
}

pub fn encode_kid(
	key_pair: &KeyPair,
	sign_alg: &JwsSignatureAlgorithm,
	key_id: &str,
	payload: &[u8],
	url: &str,
	nonce: &str,
) -> Result<String, Error> {
	let protected = JwsProtectedHeader {
		alg: sign_alg.to_string(),
		jwk: None,
		kid: Some(key_id.to_string()),
		nonce: Some(nonce.into()),
		url: url.into(),
	};
	let protected = serde_json::to_string(&protected)?;
	get_jws_data(key_pair, sign_alg, &protected, payload)
}

pub fn encode_kid_mac(
	key: &[u8],
	sign_alg: &JwsSignatureAlgorithm,
	key_id: &str,
	payload: &[u8],
	url: &str,
) -> Result<String, Error> {
	let protected = JwsProtectedHeader {
		alg: sign_alg.to_string(),
		jwk: None,
		kid: Some(key_id.to_string()),
		nonce: None,
		url: url.into(),
	};
	let protected = serde_json::to_string(&protected)?;
	let protected = b64_encode(&protected);
	let payload = b64_encode(payload);
	let signing_input = format!("{}.{}", protected, payload);
	let hash_func = match sign_alg {
		JwsSignatureAlgorithm::Hs256 => HashFunction::Sha256,
		JwsSignatureAlgorithm::Hs384 => HashFunction::Sha384,
		JwsSignatureAlgorithm::Hs512 => HashFunction::Sha512,
		_ => {
			return Err(format!("{}: not a HMAC-based signature algorithm", sign_alg).into());
		}
	};
	let signature = hash_func.hmac(key, signing_input.as_bytes())?;
	let signature = b64_encode(&signature);
	let data = JwsData {
		protected,
		payload,
		signature,
	};
	let str_data = serde_json::to_string(&data)?;
	Ok(str_data)
}

#[cfg(test)]
mod tests {
	use super::{encode_jwk, encode_kid};
	use acme_common::crypto::{gen_keypair, KeyType};

	#[test]
	fn test_default_jwk() {
		let key_type = KeyType::EcdsaP256;
		let key_pair = gen_keypair(key_type).unwrap();
		let payload = "Dummy payload 1";
		let payload_b64 = "RHVtbXkgcGF5bG9hZCAx";
		let s = encode_jwk(
			&key_pair,
			&key_type.get_default_signature_alg(),
			payload.as_bytes(),
			"",
			Some(String::new()),
		);
		assert!(s.is_ok());
		let s = s.unwrap();
		assert!(s.contains("\"protected\""));
		assert!(s.contains("\"payload\""));
		assert!(s.contains("\"signature\""));
		assert!(s.contains(payload_b64));
	}

	#[test]
	fn test_default_nopad_jwk() {
		let key_type = KeyType::EcdsaP256;
		let key_pair = gen_keypair(key_type).unwrap();
		let payload = "Dummy payload";
		let payload_b64 = "RHVtbXkgcGF5bG9hZA";
		let payload_b64_pad = "RHVtbXkgcGF5bG9hZA==";
		let s = encode_jwk(
			&key_pair,
			&key_type.get_default_signature_alg(),
			payload.as_bytes(),
			"",
			Some(String::new()),
		);
		assert!(s.is_ok());
		let s = s.unwrap();
		assert!(s.contains("\"protected\""));
		assert!(s.contains("\"payload\""));
		assert!(s.contains("\"signature\""));
		assert!(s.contains(payload_b64));
		assert!(!s.contains(payload_b64_pad));
	}

	#[test]
	fn test_default_kid() {
		let key_type = KeyType::EcdsaP256;
		let key_pair = gen_keypair(key_type).unwrap();
		let payload = "Dummy payload 1";
		let payload_b64 = "RHVtbXkgcGF5bG9hZCAx";
		let key_id = "0x2a";
		let s = encode_kid(
			&key_pair,
			&key_type.get_default_signature_alg(),
			key_id,
			payload.as_bytes(),
			"",
			"",
		);
		assert!(s.is_ok());
		let s = s.unwrap();
		assert!(s.contains("\"protected\""));
		assert!(s.contains("\"payload\""));
		assert!(s.contains("\"signature\""));
		assert!(s.contains(payload_b64));
	}
}