server/src/apub/extensions/signatures.rs

   1 use crate::apub::ActorType;
   2 use activitystreams::ext::Extension;
   3 use actix_web::HttpRequest;
   4 use failure::Error;
   5 use http::request::Builder;
   6 use http_signature_normalization::Config;
   7 use log::debug;
   8 use openssl::{
   9   hash::MessageDigest,
  10   pkey::PKey,
  11   rsa::Rsa,
  12   sign::{Signer, Verifier},
  13 };
  14 use serde::{Deserialize, Serialize};
  15 use std::collections::BTreeMap;
  16
  17 lazy_static! {
  18   static ref HTTP_SIG_CONFIG: Config = Config::new();
  19 }
  20
  21 pub struct Keypair {
  22   pub private_key: String,
  23   pub public_key: String,
  24 }
  25
  26 /// Generate the asymmetric keypair for ActivityPub HTTP signatures.
  27 pub fn generate_actor_keypair() -> Result<Keypair, Error> {
  28   let rsa = Rsa::generate(2048)?;
  29   let pkey = PKey::from_rsa(rsa)?;
  30   let public_key = pkey.public_key_to_pem()?;
  31   let private_key = pkey.private_key_to_pem_pkcs8()?;
  32   Ok(Keypair {
  33     private_key: String::from_utf8(private_key)?,
  34     public_key: String::from_utf8(public_key)?,
  35   })
  36 }
  37
  38 /// Signs request headers with the given keypair.
  39 pub fn sign(request: &Builder, actor: &dyn ActorType) -> Result<String, Error> {
  40   let signing_key_id = format!("{}#main-key", actor.actor_id());
  41
  42   let headers = request
  43     .headers_ref()
  44     .unwrap()
  45     .iter()
  46     .map(|h| -> Result<(String, String), Error> {
  47       Ok((h.0.as_str().to_owned(), h.1.to_str()?.to_owned()))
  48     })
  49     .collect::<Result<BTreeMap<String, String>, Error>>()?;
  50
  51   let signature_header_value = HTTP_SIG_CONFIG
  52     .begin_sign(
  53       request.method_ref().unwrap().as_str(),
  54       request
  55         .uri_ref()
  56         .unwrap()
  57         .path_and_query()
  58         .unwrap()
  59         .as_str(),
  60       headers,
  61     )?
  62     .sign(signing_key_id, |signing_string| {
  63       let private_key = PKey::private_key_from_pem(actor.private_key().as_bytes())?;
  64       let mut signer = Signer::new(MessageDigest::sha256(), &private_key).unwrap();
  65       signer.update(signing_string.as_bytes()).unwrap();
  66       Ok(base64::encode(signer.sign_to_vec()?)) as Result<_, Error>
  67     })?
  68     .signature_header();
  69
  70   Ok(signature_header_value)
  71 }
  72
  73 pub fn verify(request: &HttpRequest, actor: &dyn ActorType) -> Result<(), Error> {
  74   let headers = request
  75     .headers()
  76     .iter()
  77     .map(|h| -> Result<(String, String), Error> {
  78       Ok((h.0.as_str().to_owned(), h.1.to_str()?.to_owned()))
  79     })
  80     .collect::<Result<BTreeMap<String, String>, Error>>()?;
  81
  82   let verified = HTTP_SIG_CONFIG
  83     .begin_verify(
  84       request.method().as_str(),
  85       request.uri().path_and_query().unwrap().as_str(),
  86       headers,
  87     )?
  88     .verify(|signature, signing_string| -> Result<bool, Error> {
  89       debug!(
  90         "Verifying with key {}, message {}",
  91         &actor.public_key(),
  92         &signing_string
  93       );
  94       let public_key = PKey::public_key_from_pem(actor.public_key().as_bytes())?;
  95       let mut verifier = Verifier::new(MessageDigest::sha256(), &public_key).unwrap();
  96       verifier.update(&signing_string.as_bytes()).unwrap();
  97       Ok(verifier.verify(&base64::decode(signature)?)?)
  98     })?;
  99
 100   if verified {
 101     debug!("verified signature for {}", &request.uri());
 102     Ok(())
 103   } else {
 104     Err(format_err!(
 105       "Invalid signature on request: {}",
 106       &request.uri()
 107     ))
 108   }
 109 }
 110
 111 // The following is taken from here:
 112 // https://docs.rs/activitystreams/0.5.0-alpha.17/activitystreams/ext/index.html
 113
 114 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 115 #[serde(rename_all = "camelCase")]
 116 pub struct PublicKey {
 117   pub id: String,
 118   pub owner: String,
 119   pub public_key_pem: String,
 120 }
 121
 122 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 123 #[serde(rename_all = "camelCase")]
 124 pub struct PublicKeyExtension {
 125   pub public_key: PublicKey,
 126 }
 127
 128 impl PublicKey {
 129   pub fn to_ext(&self) -> PublicKeyExtension {
 130     PublicKeyExtension {
 131       public_key: self.to_owned(),
 132     }
 133   }
 134 }
 135
 136 impl<T> Extension<T> for PublicKeyExtension where T: activitystreams::Actor {}