fix(hosted): use trusted proxy to remove trusted ips in logs, fix errors in operator

Author: joelwurtz

src/api/ffi.rs

@@ -48,7 +48,7 @@ pub unsafe extern "C" fn redirectionio_api_create_log_in_json(
     let request = &*_request;
     let response_headers = header_map_to_http_headers(_response_headers);
 
-    let log = Log::from_proxy(request, code, &response_headers, action, proxy, time, client_ip);
+    let log = Log::from_proxy(request, code, &response_headers, action, proxy, time, client_ip, None);
 
     let log_serialized = match json_encode(&log) {
         Err(_) => return null(),

src/api/log.rs

@@ -1,6 +1,7 @@
 use crate::action::Action;
-use crate::http::{Header, Request};
+use crate::http::{Header, Request, TrustedProxies};
 use serde::{Deserialize, Serialize};
+use std::net::IpAddr;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -76,12 +77,20 @@ impl Log {
         proxy: &str,
         time: u64,
         client_ip: &str,
+        trusted_proxies: Option<&TrustedProxies>,
     ) -> Log {
         let mut location = None;
         let mut user_agent = None;
         let mut referer = None;
         let mut content_type = None;
-        let mut ips = vec![client_ip.to_string()];
+        let mut ips = Vec::new();
+
+        match client_ip.parse::<IpAddr>() {
+            Ok(ip) => ips.push(ip),
+            Err(e) => {
+                log::error!("cannot parse ip address {}, skipping: {}", client_ip, e);
+            }
+        }
 
         for header in &request.headers {
             if header.name.to_lowercase() == "user-agent" {
@@ -96,11 +105,39 @@ impl Log {
                 let forwarded_ips = header.value.split(',');
 
                 for forwarded_ip in forwarded_ips {
-                    ips.push(forwarded_ip.trim().to_string());
+                    match forwarded_ip.parse::<IpAddr>() {
+                        Ok(ip) => ips.push(ip),
+                        Err(e) => {
+                            log::error!("cannot parse ip address {}, skipping: {}", forwarded_ip, e);
+                        }
+                    }
+                }
+            }
+
+            if header.name.to_lowercase() == "forwarded" {
+                for (name, val) in header.value.split(';').flat_map(|val| val.split(',')).flat_map(|pair| {
+                    let mut items = pair.trim().splitn(2, '=');
+                    Some((items.next()?, items.next()?))
+                }) {
+                    if name.trim().to_lowercase().as_str() == "for" {
+                        let ip = val.trim().trim_start_matches('"').trim_end_matches('"').to_string();
+
+                        match ip.parse::<IpAddr>() {
+                            Ok(ip) => ips.push(ip),
+                            Err(e) => {
+                                log::error!("cannot parse ip address {}, skipping: {}", ip, e);
+                            }
+                        }
+                    }
                 }
             }
         }
 
+        let untrusted_ips = match trusted_proxies {
+            Some(trusted_proxies) => trusted_proxies.remove_trusted_ips(ips),
+            None => ips,
+        };
+
         for header in response_headers {
             if header.name.to_lowercase() == "location" {
                 location = Some(header.value.clone())
@@ -127,7 +164,7 @@ impl Log {
             from,
             proxy: proxy.to_string(),
             time,
-            ips: Some(ips),
+            ips: Some(untrusted_ips.iter().map(|ip| ip.to_string()).collect()),
             to: location.unwrap_or_default(),
         }
     }

src/http/trusted_proxies.rs

@@ -1,10 +1,19 @@
 use cidr::{errors::NetworkParseError, AnyIpCidr};
 use std::net::IpAddr;
+use std::str::FromStr;
 
 #[derive(Debug, Clone, Default)]
 pub struct TrustedProxies(Vec<AnyIpCidr>);
 
 impl TrustedProxies {
+    pub fn new_local() -> Self {
+        Self(vec![
+            AnyIpCidr::from_str("10.0.0.0/8").unwrap(),
+            AnyIpCidr::from_str("172.16.0.0/12").unwrap(),
+            AnyIpCidr::from_str("192.168.0.0/16").unwrap(),
+        ])
+    }
+
     pub fn len(&self) -> usize {
         self.0.len()
     }