crates/apub/src/extensions/signatures.rs

   1 use actix_web::HttpRequest;
   2 use anyhow::anyhow;
   3 use http::{header::HeaderName, HeaderMap, HeaderValue};
   4 use http_signature_normalization_actix::Config as ConfigActix;
   5 use http_signature_normalization_reqwest::prelude::{Config, SignExt};
   6 use lemmy_utils::LemmyError;
   7 use log::debug;
   8 use openssl::{
   9   hash::MessageDigest,
  10   pkey::PKey,
  11   sign::{Signer, Verifier},
  12 };
  13 use reqwest::{Client, Response};
  14 use serde::{Deserialize, Serialize};
  15 use sha2::{Digest, Sha256};
  16 use std::{collections::BTreeMap, str::FromStr};
  17 use url::Url;
  18
  19 lazy_static! {
  20   static ref CONFIG2: ConfigActix = ConfigActix::new();
  21   static ref HTTP_SIG_CONFIG: Config = Config::new();
  22 }
  23
  24 /// Creates an HTTP post request to `inbox_url`, with the given `client` and `headers`, and
  25 /// `activity` as request body. The request is signed with `private_key` and then sent.
  26 pub(crate) async fn sign_and_send(
  27   client: &Client,
  28   headers: BTreeMap<String, String>,
  29   inbox_url: &Url,
  30   activity: String,
  31   actor_id: &Url,
  32   private_key: String,
  33 ) -> Result<Response, LemmyError> {
  34   let signing_key_id = format!("{}#main-key", actor_id);
  35
  36   let mut header_map = HeaderMap::new();
  37   for h in headers {
  38     header_map.insert(
  39       HeaderName::from_str(h.0.as_str())?,
  40       HeaderValue::from_str(h.1.as_str())?,
  41     );
  42   }
  43   let response = client
  44     .post(&inbox_url.to_string())
  45     .headers(header_map)
  46     .signature_with_digest(
  47       HTTP_SIG_CONFIG.clone(),
  48       signing_key_id,
  49       Sha256::new(),
  50       activity,
  51       move |signing_string| {
  52         let private_key = PKey::private_key_from_pem(private_key.as_bytes())?;
  53         let mut signer = Signer::new(MessageDigest::sha256(), &private_key)?;
  54         signer.update(signing_string.as_bytes())?;
  55
  56         Ok(base64::encode(signer.sign_to_vec()?)) as Result<_, LemmyError>
  57       },
  58     )
  59     .await?;
  60
  61   Ok(response)
  62 }
  63
  64 /// Verifies the HTTP signature on an incoming inbox request.
  65 pub fn verify_signature(request: &HttpRequest, public_key: &str) -> Result<(), LemmyError> {
  66   let verified = CONFIG2
  67     .begin_verify(
  68       request.method(),
  69       request.uri().path_and_query(),
  70       request.headers().clone(),
  71     )?
  72     .verify(|signature, signing_string| -> Result<bool, LemmyError> {
  73       debug!(
  74         "Verifying with key {}, message {}",
  75         &public_key, &signing_string
  76       );
  77       let public_key = PKey::public_key_from_pem(public_key.as_bytes())?;
  78       let mut verifier = Verifier::new(MessageDigest::sha256(), &public_key)?;
  79       verifier.update(signing_string.as_bytes())?;
  80       Ok(verifier.verify(&base64::decode(signature)?)?)
  81     })?;
  82
  83   if verified {
  84     debug!("verified signature for {}", &request.uri());
  85     Ok(())
  86   } else {
  87     Err(anyhow!("Invalid signature on request: {}", &request.uri()).into())
  88   }
  89 }
  90
  91 #[derive(Clone, Debug, Deserialize, Serialize)]
  92 #[serde(rename_all = "camelCase")]
  93 pub struct PublicKey {
  94   pub id: String,
  95   pub owner: Url,
  96   pub public_key_pem: String,
  97 }