implement a proper csp template struct

Author: lovasoa

src/webserver/content_security_policy.rs

@@ -7,21 +7,45 @@ use rand::random;
 use std::fmt::{Display, Formatter};
 use std::sync::Arc;
 
-use crate::AppState;
-
 pub const DEFAULT_CONTENT_SECURITY_POLICY: &str = "script-src 'self' 'nonce-{NONCE}'";
 
 #[derive(Debug, Clone)]
 pub struct ContentSecurityPolicy {
     pub nonce: u64,
-    app_state: Arc<AppState>,
+    template: ContentSecurityPolicyTemplate,
+}
+
+/// A template for the Content Security Policy header.
+/// The template is a string that contains the nonce placeholder.
+/// The nonce placeholder is replaced with the nonce value when the Content Security Policy is applied to a response.
+/// This struct is cheap to clone.
+#[derive(Debug, Clone)]
+pub struct ContentSecurityPolicyTemplate {
+    pub before_nonce: Arc<str>,
+    pub after_nonce: Option<Arc<str>>,
+}
+
+impl From<&str> for ContentSecurityPolicyTemplate {
+    fn from(s: &str) -> Self {
+        if let Some((before, after)) = s.split_once("{NONCE}") {
+            Self {
+                before_nonce: Arc::from(before),
+                after_nonce: Some(Arc::from(after)),
+            }
+        } else {
+            Self {
+                before_nonce: Arc::from(s),
+                after_nonce: None,
+            }
+        }
+    }
 }
 
 impl ContentSecurityPolicy {
-    pub fn new(app_state: Arc<AppState>) -> Self {
+    pub fn new(template: ContentSecurityPolicyTemplate) -> Self {
         Self {
             nonce: random(),
-            app_state,
+            template,
         }
     }
 
@@ -31,26 +55,22 @@ impl ContentSecurityPolicy {
         }
     }
 
-    fn template_string(&self) -> &str {
-        &self.app_state.config.content_security_policy
-    }
-
     fn is_enabled(&self) -> bool {
-        !self.app_state.config.content_security_policy.is_empty()
+        !self.template.before_nonce.is_empty()
     }
 }
 
 impl Display for ContentSecurityPolicy {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let template = self.template_string();
-        if let Some((before, after)) = template.split_once("{NONCE}") {
-            write!(f, "{before}{nonce}{after}", nonce = self.nonce)
+        let before = self.template.before_nonce.as_ref();
+        if let Some(after) = &self.template.after_nonce {
+            let nonce = self.nonce;
+            write!(f, "{before}{nonce}{after}")
         } else {
-            write!(f, "{}", template)
+            write!(f, "{before}")
         }
     }
 }
-
 impl TryIntoHeaderPair for &ContentSecurityPolicy {
     type Error = InvalidHeaderValue;
 
@@ -61,3 +81,25 @@ impl TryIntoHeaderPair for &ContentSecurityPolicy {
         ))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_content_security_policy_display() {
+        let template = ContentSecurityPolicyTemplate::from(
+            "script-src 'self' 'nonce-{NONCE}' 'unsafe-inline'",
+        );
+        let csp = ContentSecurityPolicy::new(template.clone());
+        let csp_str = csp.to_string();
+        assert!(csp_str.starts_with("script-src 'self' 'nonce-"));
+        assert!(csp_str.ends_with("' 'unsafe-inline'"));
+        let second_csp = ContentSecurityPolicy::new(template);
+        let second_csp_str = second_csp.to_string();
+        assert_ne!(
+            csp_str, second_csp_str,
+            "We should not generate the same nonce twice"
+        );
+    }
+}

src/webserver/http.rs

@@ -177,7 +177,11 @@ async fn render_sql(
     actix_web::rt::spawn(async move {
         let request_context = RequestContext {
             is_embedded: req_param.get_variables.contains_key("_sqlpage_embed"),
-            content_security_policy: ContentSecurityPolicy::new(Arc::clone(&app_state)),
+            content_security_policy: ContentSecurityPolicy::new(
+                crate::webserver::content_security_policy::ContentSecurityPolicyTemplate::from(
+                    app_state.config.content_security_policy.as_str(),
+                ),
+            ),
         };
         let mut conn = None;
         let database_entries_stream =