use std::net::IpAddr;
use sha2::{Digest, Sha256};
use url::{Host, Url};
use time::OffsetDateTime;
use crate::domain::Region;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ThresholdDirection {
Below,
Above,
}
impl ThresholdDirection {
pub fn code(self) -> &'static str {
match self {
ThresholdDirection::Below => "below",
ThresholdDirection::Above => "above",
}
}
pub fn from_code(code: &str) -> Option<Self> {
match code {
"below" => Some(ThresholdDirection::Below),
"above" => Some(ThresholdDirection::Above),
_ => None,
}
}
fn holds(self, v: f64, threshold: f64) -> bool {
match self {
ThresholdDirection::Below => v < threshold,
ThresholdDirection::Above => v > threshold,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct Subscription {
pub id: String,
pub owner_key_hash: String,
pub region: Region,
pub threshold: f64,
pub direction: ThresholdDirection,
pub callback_url: String,
pub secret: String,
pub disabled_at: Option<OffsetDateTime>,
}
pub const DEFAULT_WEBHOOK_MAX_CONSECUTIVE_FAILURES: u32 = 10;
pub const DEFAULT_WEBHOOK_PURGE_DAYS: u32 = 30;
pub fn should_fire(
direction: ThresholdDirection,
threshold: f64,
previous: Option<f64>,
current: f64,
) -> bool {
match previous {
Some(prev) => !direction.holds(prev, threshold) && direction.holds(current, threshold),
None => false,
}
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
#[non_exhaustive]
pub enum WebhookUrlError {
#[error("schéma non autorisé (HTTPS requis)")]
NotHttps,
#[error("URL malformée")]
Malformed,
#[error("hôte interdit (privé/loopback/local)")]
ForbiddenHost,
}
pub fn validate_webhook_url(url: &str) -> Result<(), WebhookUrlError> {
let parsed = Url::parse(url).map_err(|_| WebhookUrlError::Malformed)?;
if parsed.scheme() != "https" {
return Err(WebhookUrlError::NotHttps);
}
if !parsed.username().is_empty() || parsed.password().is_some() {
return Err(WebhookUrlError::ForbiddenHost);
}
match parsed.host() {
None => Err(WebhookUrlError::Malformed),
Some(Host::Ipv4(v4)) if !is_public_ip(IpAddr::V4(v4)) => {
Err(WebhookUrlError::ForbiddenHost)
}
Some(Host::Ipv6(v6)) if !is_public_ip(IpAddr::V6(v6)) => {
Err(WebhookUrlError::ForbiddenHost)
}
Some(Host::Domain(domain)) => {
let lower = domain.to_ascii_lowercase();
if lower == "localhost" || lower.ends_with(".localhost") {
Err(WebhookUrlError::ForbiddenHost)
} else {
Ok(())
}
}
Some(_) => Ok(()),
}
}
pub fn webhook_host(url: &str) -> Option<String> {
let rest = url.strip_prefix("https://")?;
let authority = rest.split(['/', '?', '#']).next().unwrap_or("");
if authority.contains('@') {
return None;
}
let host = if let Some(end) = authority.strip_prefix('[') {
end.split(']').next().unwrap_or("")
} else {
authority.split(':').next().unwrap_or("")
};
(!host.is_empty()).then(|| host.to_string())
}
pub fn is_public_ip(ip: IpAddr) -> bool {
match ip {
IpAddr::V4(v4) => {
let o = v4.octets();
!(v4.is_private()
|| v4.is_loopback()
|| v4.is_link_local()
|| v4.is_broadcast()
|| v4.is_documentation()
|| v4.is_unspecified()
|| v4.is_multicast()
|| o[0] == 0
|| (o[0] == 100 && (64..=127).contains(&o[1]))
|| (o[0] == 192 && o[1] == 0 && o[2] == 0)
|| (o[0] == 198 && (18..=19).contains(&o[1]))
|| o[0] >= 240)
}
IpAddr::V6(v6) => {
let s = v6.segments();
!(v6.is_loopback()
|| v6.is_unspecified()
|| v6.is_multicast()
|| (s[0] & 0xfe00) == 0xfc00
|| (s[0] & 0xffc0) == 0xfe80
|| v6.to_ipv4_mapped().is_some()
|| s[0] == 0x2002
|| (s[0] == 0x2001 && s[1] == 0x0000)
|| (s[0] == 0x0064 && s[1] == 0xff9b && s[2] == 0 && s[3] == 0))
}
}
}
fn json_escape(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars() {
match c {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
'\n' => out.push_str("\\n"),
'\r' => out.push_str("\\r"),
'\t' => out.push_str("\\t"),
c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
c => out.push(c),
}
}
out
}
pub fn render_webhook_payload(
subscription: &Subscription,
timestamp: &str,
intensity: f64,
) -> String {
format!(
"{{\"subscription_id\":\"{}\",\"region\":\"{}\",\"timestamp\":\"{}\",\
\"intensity\":{},\"threshold\":{},\"direction\":\"{}\",\"unit\":\"gCO2eq/kWh\"}}",
json_escape(&subscription.id),
subscription.region.slug(),
json_escape(timestamp),
intensity,
subscription.threshold,
subscription.direction.code(),
)
}
pub fn hmac_sha256_hex(secret: &[u8], message: &[u8]) -> String {
const BLOCK: usize = 64;
let mut key = if secret.len() > BLOCK {
Sha256::digest(secret).to_vec()
} else {
secret.to_vec()
};
key.resize(BLOCK, 0);
let mut inner = Sha256::new();
inner.update(key.iter().map(|b| b ^ 0x36).collect::<Vec<u8>>());
inner.update(message);
let inner = inner.finalize();
let mut outer = Sha256::new();
outer.update(key.iter().map(|b| b ^ 0x5c).collect::<Vec<u8>>());
outer.update(inner);
let outer = outer.finalize();
outer.iter().map(|b| format!("{b:02x}")).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn edge_trigger_fires_only_on_crossing() {
assert!(should_fire(
ThresholdDirection::Below,
50.0,
Some(60.0),
40.0
));
assert!(!should_fire(
ThresholdDirection::Below,
50.0,
Some(40.0),
30.0
));
assert!(!should_fire(
ThresholdDirection::Below,
50.0,
Some(60.0),
55.0
));
assert!(!should_fire(ThresholdDirection::Below, 50.0, None, 40.0));
assert!(should_fire(
ThresholdDirection::Above,
80.0,
Some(70.0),
90.0
));
assert!(!should_fire(
ThresholdDirection::Above,
80.0,
Some(90.0),
95.0
));
}
#[test]
fn ssrf_rejects_dangerous_urls() {
assert_eq!(
validate_webhook_url("http://example.com/hook"),
Err(WebhookUrlError::NotHttps)
);
for bad in [
"https://localhost/hook",
"https://127.0.0.1/hook",
"https://10.0.0.5/hook",
"https://192.168.1.10/hook",
"https://172.16.3.4/hook",
"https://169.254.169.254/latest/meta-data",
"https://[::1]/hook",
"https://[fe80::1]/hook",
"https://user:pass@example.com/hook",
"https://100.64.0.1/hook",
"https://0.0.0.0/hook",
"https://0.1.2.3/hook", "https://240.0.0.1/hook", "https://255.255.255.255/hook",
"https://[2002:a00:1::1]/hook", "https://[64:ff9b::a00:1]/hook", "https://[::ffff:127.0.0.1]/hook", "https://2130706433/hook", "https://0x7f.0.0.1/hook", "https://017700000001/hook", "https://127.1/hook", "https://2852039166/latest/meta-data",
"https://192.0.0.9/hook",
] {
assert_eq!(
validate_webhook_url(bad),
Err(WebhookUrlError::ForbiddenHost),
"devrait rejeter {bad}"
);
}
assert!(validate_webhook_url("https://hooks.example.com/carbon").is_ok());
assert!(validate_webhook_url("https://8.8.8.8/hook").is_ok());
}
#[test]
fn payload_is_well_formed_and_escaped() {
let sub = Subscription {
id: "ab\"cd".to_string(), owner_key_hash: "h".to_string(),
region: Region::National,
threshold: 50.0,
direction: ThresholdDirection::Below,
callback_url: "https://x".to_string(),
secret: "s".to_string(),
disabled_at: None,
};
let body = render_webhook_payload(&sub, "2024-01-01T00:00:00Z", 42.5);
assert!(body.contains("\\\"cd")); assert!(body.contains("\"region\":\"national\""));
assert!(body.contains("\"intensity\":42.5"));
assert!(body.contains("\"direction\":\"below\""));
assert!(body.contains("\"unit\":\"gCO2eq/kWh\""));
}
#[test]
fn hmac_matches_known_vector() {
let key = [0x0b_u8; 20];
let got = hmac_sha256_hex(&key, b"Hi There");
assert_eq!(
got,
"b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7"
);
}
#[test]
fn hmac_with_long_key() {
let key = [0xaa_u8; 131];
let got = hmac_sha256_hex(
&key,
b"Test Using Larger Than Block-Size Key - Hash Key First",
);
assert_eq!(
got,
"60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54"
);
}
}