Httpmessage for every scan type

src/lua/parsing/url.rs

@@ -18,16 +18,20 @@ mod url_lua;
 
 #[derive(Clone)]
 pub struct HttpMessage {
-    pub url: Url,
+    pub url: Option<Url>,
 }
 
 impl HttpMessage {
     pub fn change_urlquery(&self, payload: &str, remove_content: bool) -> HashMap<String, String> {
         let mut scan_params = HashMap::with_capacity(16);
         let mut result = HashMap::with_capacity(16);
 
-        for (key, value) in self.url.query_pairs() {
-            scan_params.insert(key.to_string(), value.to_string());
+        if let Some(the_url) = &self.url {
+            for (key, value) in the_url.query_pairs() {
+                scan_params.insert(key.to_string(), value.to_string());
+            }
+        } else {
+            return result;
         }
 
         for (key, value) in scan_params.iter() {
@@ -42,7 +46,7 @@ impl HttpMessage {
                     new_params.insert(key.to_string(), new_value);
                 }
 
-                let mut new_url = self.url.clone();
+                let mut new_url = self.url.clone().unwrap();
                 new_url.set_query(None);
 
                 for (key, value) in new_params.iter() {
@@ -57,27 +61,32 @@ impl HttpMessage {
     }
 
     pub fn set_urlvalue(&self, param: &str, payload: &str, remove_content: bool) -> String {
-        let mut url = self.url.clone();
-        let new_query = url
-            .query_pairs()
-            .fold(String::new(), |mut acc, (key, value)| {
-                if key == param {
-                    if remove_content {
-                        acc += &format!("{}={}", key, payload);
+        if let Some(mut url) = self.url.clone() {
+            let new_query = url
+                .query_pairs()
+                .fold(String::new(), |mut acc, (key, value)| {
+                    if key == param {
+                        if remove_content {
+                            acc += &format!("{}={}", key, payload);
+                        } else {
+                            acc += &format!("{}={}", key, value + payload);
+                        }
                     } else {
-                        acc += &format!("{}={}", key, value + payload);
+                        acc += &format!("{}={}", key, value.to_string());
                     }
-                } else {
-                    acc += &format!("{}={}", key, value.to_string());
-                }
-                acc += "&";
-                acc
-            });
-        url.set_query(Some(&new_query[..new_query.len() - 1]));
-        url.as_str().to_string()
+                    acc += "&";
+                    acc
+                });
+            url.set_query(Some(&new_query[..new_query.len() - 1]));
+            return url.as_str().to_string();
+        }
+        String::new()
     }
 
     pub fn urljoin(&self, path: &str) -> String {
-        self.url.join(path).unwrap().as_str().to_string()
+        if let Some(url) = &self.url {
+            return url.join(path).unwrap().as_str().to_string();
+        }
+        String::new()
     }
 }

src/lua/parsing/url/url_lua.rs

@@ -1,9 +1,20 @@
 use crate::lua::parsing::url::HttpMessage;
-use mlua::UserData;
-use std::collections::HashMap;
+use mlua::{UserData, ExternalResult, ExternalError};
+use url::Url;
 
 impl UserData for HttpMessage {
     fn add_methods<'lua, M: mlua::UserDataMethods<'lua, Self>>(methods: &mut M) {
+        methods.add_method_mut("setUrl", |_, this, url: String| {
+            match Url::parse(&url) {
+                Ok(parsed_url) => {
+                    this.url = Some(parsed_url.clone());
+                    Ok(parsed_url.to_string())
+                }
+                Err(err) => {
+                    Err(err.to_lua_err())
+                }
+            }
+        });
         methods.add_method(
             "setParam",
             |_, this, (param, payload, remove_content): (String, String, bool)| {
@@ -16,21 +27,35 @@ impl UserData for HttpMessage {
                 Ok(this.change_urlquery(&payload, remove_content))
             },
         );
-        methods.add_method("Url", |_, this, ()| Ok(this.url.as_str().to_string()));
-        methods.add_method("Path", |_, this, ()| Ok(this.url.path().to_string()));
+        methods.add_method("Url", |_, this, ()| {
+            match &this.url {
+                Some(url) => Ok(url.as_str().to_string()),
+                None => Err("No url found").to_lua_err(),
+            }
+        });
+        methods.add_method("Path", |_, this, ()| {
+            match &this.url {
+                Some(url) => Ok(url.path().to_string()),
+                None => Err("No url found").to_lua_err(),
+            }
+        });
         methods.add_method("TxtParams", |_, this, ()| {
-            Ok(this.url.query().unwrap().to_string())
+            match &this.url {
+                Some(url) => Ok(url.query().unwrap_or("").to_string()),
+                None => Err("No url found").to_lua_err(),
+            }
         });
         methods.add_method("Params", |_, this, ()| {
             let mut all_params = Vec::new();
-            this.url
-                .query_pairs()
-                .collect::<HashMap<_, _>>()
-                .iter()
-                .for_each(|(param_name, _param_value)| {
-                    all_params.push(param_name.to_string());
-                });
-            Ok(all_params)
+            match &this.url {
+                Some(url) => {
+                    url.query_pairs().for_each(|(param_name, _param_value)| {
+                        all_params.push(param_name.to_string());
+                    });
+                    Ok(all_params)
+                }
+                None => Err("No url found").to_lua_err(),
+            }
         });
         methods.add_method("urlJoin", |_, this, new_path: String| {
             Ok(this.urljoin(new_path.as_str()))

src/lua/run.rs

@@ -95,7 +95,7 @@ impl LuaLoader {
                 self.set_lua(None, &lua);
                 lua.globals()
                     .set(
-                        "TARGET_HOST",
+                        "INPUT_DATA",
                         lua_opts.target_url.unwrap().as_str().unwrap().to_string(),
                     )
                     .unwrap();

src/lua/runtime/http_ext.rs

@@ -130,15 +130,15 @@ impl HTTPEXT for LuaRunTime<'_> {
         self.lua.globals().set("log_debug", log_debug).unwrap();
         self.lua.globals().set("log_warn", log_warn).unwrap();
 
-        if !target_url.is_none() {
+        if let Some(url) = target_url {
             self.lua
                 .globals()
-                .set(
-                    "HttpMessage",
-                    HttpMessage {
-                        url: Url::parse(target_url.unwrap()).unwrap(),
-                    },
-                )
+                .set("HttpMessage", HttpMessage { url: Some(Url::parse(&url).unwrap()) })
+                .unwrap();
+        } else {
+            self.lua
+                .globals()
+                .set("HttpMessage", HttpMessage { url: None })
                 .unwrap();
         }
         self.lua