webhookey/src/main.rs

#![feature(proc_macro_hygiene, decl_macro)]

use anyhow::{anyhow, bail, Result};
use hmac::{Hmac, Mac, NewMac};
use log::{debug, error, info, trace, warn};
use nom::{
    branch::alt,
    bytes::complete::{tag, take_until},
    combinator::map_res,
    multi::many0,
    sequence::delimited,
    Finish, IResult,
};
use regex::Regex;
use rocket::{
    data::{self, FromDataSimple},
    fairing::AdHoc,
    get,
    http::{HeaderMap, Status},
    post, routes, Data,
    Outcome::{Failure, Success},
    Request, Response, State,
};
use serde::{Deserialize, Serialize};
use sha2::Sha256;

use std::{
    collections::HashMap,
    fs::File,
    io::{BufReader, Read},
    net::SocketAddr,
    process::Command,
    str::from_utf8,
};

#[derive(Debug, Deserialize, Serialize)]
struct Config {
    hooks: HashMap<String, Hook>,
}

#[derive(Debug, Deserialize, Serialize)]
struct Hook {
    command: String,
    secrets: Vec<String>,
    filters: HashMap<String, Filter>,
}

#[derive(Debug, Deserialize, Serialize)]
struct Filter {
    pointer: String,
    regex: String,
}

#[derive(Debug)]
struct Hooks(HashMap<String, Vec<String>>);

fn replace_parameter(input: &str, headers: &HeaderMap, data: &serde_json::Value) -> Result<String> {
    let parse: IResult<&str, Vec<&str>> = many0(alt((
        map_res(
            delimited(tag("{{"), take_until("}}"), tag("}}")),
            |param: &str| match param.trim() {
                "event" => {
                    if let Some(event) = headers.get_one("X-Gitea-Event") {
                        Ok(event)
                    } else {
                        bail!("Could not extract event parameter from header");
                    }
                }
                pointer => match data.pointer(pointer) {
                    Some(value) => match value.as_str() {
                        Some(value) => Ok(value),
                        _ => bail!("Could not convert value `{}` to string", value),
                    },
                    _ => bail!("Could not convert field `{}` to string", param.trim()),
                },
            },
        ),
        take_until("{{"),
    )))(input);

    let (last, mut result) = parse
        .finish()
        .map_err(|e| anyhow!("Could not parse command: {}", e))?;
    result.push(last);

    Ok(result.join(""))
}

impl FromDataSimple for Hooks {
    type Error = anyhow::Error;

    fn from_data(request: &Request, data: Data) -> data::Outcome<Self, Self::Error> {
        let config = request.guard::<State<Config>>().unwrap(); // should never fail

        let mut hooks = HashMap::new();

        if let Some(signature) = request.headers().get_one("X-Gitea-Signature") {
            let mut data = data.open();
            let mut buffer = Vec::new();

            match data.read_to_end(&mut buffer) {
                Ok(_) => {}
                Err(e) => {
                    error!("Could not read to end of data: {}", &e);
                    return Failure((
                        Status::BadRequest,
                        anyhow!("Could not read to end of data: {}", &e),
                    ));
                }
            }

            trace!("Data received: {:?}", from_utf8(&buffer));

            let mut valid = false;

            for (hook_name, hook) in &config.hooks {
                let mut commands = Vec::new();

                for secret in &hook.secrets {
                    let mut mac = match Hmac::<Sha256>::new_varkey(&secret.as_bytes()) {
                        Ok(mac) => mac,
                        Err(e) => {
                            error!("Could not instantiate hasher: {}", e);
                            return Failure((
                                Status::InternalServerError,
                                anyhow!("Could not instantiate hasher: {}", e),
                            ));
                        }
                    };

                    mac.update(&buffer);

                    match &hex::decode(&signature.as_bytes()) {
                        Ok(raw_signature) => {
                            if mac.verify(&raw_signature) == Ok(()) {
                                trace!(
                                    "Valid signature found for hook `{}`: {}",
                                    hook_name,
                                    signature
                                );

                                valid = true;

                                let data: serde_json::Value = match serde_json::from_slice(&buffer)
                                {
                                    Ok(data) => data,
                                    Err(e) => {
                                        error!("Could not parse json: {}", e);
                                        return Failure((
                                            Status::BadRequest,
                                            anyhow!("Could not parse json: {}", e),
                                        ));
                                    }
                                };

                                for (filter_name, filter) in &hook.filters {
                                    trace!(
                                        "Matching filter `{}` of hook `{}`",
                                        filter_name,
                                        hook_name
                                    );

                                    let regex = match Regex::new(&filter.regex) {
                                        Ok(regex) => regex,
                                        Err(e) => {
                                            error!(
                                                "Could not compile regex `{}`: {}",
                                                &filter.regex, e
                                            );
                                            continue;
                                        }
                                    };

                                    if let Some(value) = data.pointer(&filter.pointer) {
                                        if let Some(value) = value.as_str() {
                                            if regex.is_match(value) {
                                                debug!(
                                                    "Filter `{}` of hook `{}` matched",
                                                    filter_name, hook_name
                                                );

                                                match replace_parameter(
                                                    &hook.command.to_string(),
                                                    &request.headers(),
                                                    &data,
                                                ) {
                                                    Ok(command) => commands.push(command),
                                                    Err(e) => error!(
                                                "Could not replace all parameter in hook `{}`: {}",
                                                hook_name, e
                                            ),
                                                }
                                            }
                                        } else {
                                            anyhow!(
                                            "Could not parse pointer in hook `{}` from filter `{}`",
                                            hook_name,
                                            filter_name
                                        );
                                        }
                                    }

                                    trace!(
                                        "Filter `{}` of hook `{}` did not match",
                                        filter_name,
                                        hook_name
                                    );
                                }
                            }
                        }
                        Err(e) => {
                            error!("Invalid configuration: {}", e);
                            return Failure((
                                Status::InternalServerError,
                                anyhow!("Invalid configuration: {}", e),
                            ));
                        }
                    }
                }

                if !commands.is_empty() {
                    hooks.insert(hook_name.to_string(), commands);
                }
            }

            if hooks.is_empty() {
                if valid {
                    warn!(
                        "Unmatched hook from {:?} with signature {:?}",
                        &request.client_ip(),
                        &request.headers().get_one("X-Gitea-Signature")
                    );
                    Failure((
                        Status::NotFound,
                        anyhow!(
                            "Unmatched hook from {:?} with signature {:?}",
                            &request.client_ip(),
                            &request.headers().get_one("X-Gitea-Signature")
                        ),
                    ))
                } else {
                    warn!(
                        "Unauthorized request from {:?} with signature {:?}",
                        &request.client_ip(),
                        &request.headers().get_one("X-Gitea-Signature")
                    );
                    Failure((
                        Status::Unauthorized,
                        anyhow!(
                            "Unauthorized request from {:?} with signature {:?}",
                            &request.client_ip(),
                            &request.headers().get_one("X-Gitea-Signature")
                        ),
                    ))
                }
            } else {
                Success(Hooks(hooks))
            }
        } else {
            Failure((
                Status::BadRequest,
                anyhow!("Could not extract signature from header"),
            ))
        }
    }
}

#[get("/")]
fn index() -> &'static str {
    "Hello, webhookey!"
}

#[post("/", format = "json", data = "<hooks>")]
fn receive_hook<'a>(address: SocketAddr, hooks: Hooks) -> Result<Response<'a>> {
    info!("Post request received from: {}", address);

    for hook in hooks.0 {
        for command in hook.1 {
            info!("Execute `{}` from hook `{}`", &command, &hook.0);

            let command = command.split(' ').collect::<Vec<&str>>();
            match Command::new(&command[0]).args(&command[1..]).output() {
                Ok(executed) => {
                    info!(
                        "Command `{}` exited with return code: {}",
                        &command[0], &executed.status
                    );
                    trace!(
                        "Output of command `{}` on stdout: {:?}",
                        &command[0],
                        from_utf8(&executed.stdout)?
                    );
                    debug!(
                        "Output of command `{}` on stderr: {:?}",
                        &command[0],
                        from_utf8(&executed.stderr)?
                    );
                }
                Err(e) => {
                    error!("Execution of `{}` failed: {}", command[0], e);
                }
            }
        }
    }

    Ok(Response::new())
}

fn get_config() -> Result<File> {
    if let Ok(config) = File::open("/etc/webhookey/config.yml") {
        info!("Loading configuration from `/etc/webhookey/config.yml`");

        return Ok(config);
    }

    if let Some(mut path) = dirs::config_dir() {
        path.push("webhookey/config.yml");

        if let Ok(config) = File::open(&path) {
            info!(
                "Loading configuration from `{}`",
                path.to_str().unwrap_or("<path unprintable>"),
            );

            return Ok(config);
        }
    }

    if let Ok(config) = File::open("config.yml") {
        info!("Loading configuration from `./config.yml`");

        return Ok(config);
    }

    bail!("No configuration files found.");
}

fn main() -> Result<()> {
    env_logger::init();

    let config: Config = serde_yaml::from_reader(BufReader::new(get_config()?))?;

    trace!("Parsed configuration:\n{}", serde_yaml::to_string(&config)?);

    rocket::ignite()
        .mount("/", routes![index, receive_hook])
        .attach(AdHoc::on_attach("webhookey config", move |rocket| {
            Ok(rocket.manage(config))
        }))
        .launch();

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use rocket::{
        http::{ContentType, Header},
        local::Client,
    };
    use serde_json::json;

    #[test]
    fn index() {
        let rocket = rocket::ignite().mount("/", routes![index]);

        let client = Client::new(rocket).unwrap();
        let mut response = client.get("/").dispatch();

        assert_eq!(response.status(), Status::Ok);
        assert_eq!(response.body_string(), Some("Hello, webhookey!".into()));
    }

    #[test]
    fn secret() {
        let mut hooks = HashMap::new();
        hooks.insert(
            "test_hook".to_string(),
            Hook {
                command: "".to_string(),
                secrets: vec!["valid".to_string()],
                filters: HashMap::new(),
            },
        );
        let config = Config { hooks: hooks };

        let rocket = rocket::ignite()
            .mount("/", routes![receive_hook])
            .attach(AdHoc::on_attach("webhookey config", move |rocket| {
                Ok(rocket.manage(config))
            }));

        let client = Client::new(rocket).unwrap();
        let response = client
            .post("/")
            .header(Header::new(
                "X-Gitea-Signature",
                "28175a0035f637f3cbb85afee9f9d319631580e7621cf790cd16ca063a2f820e",
            ))
            .header(ContentType::JSON)
            .remote("127.0.0.1:8000".parse().unwrap())
            .body(&serde_json::to_string(&json!({ "foo": "bar" })).unwrap())
            .dispatch();

        assert_eq!(response.status(), Status::NotFound);

        let response = client
            .post("/")
            .header(Header::new("X-Gitea-Signature", "beef"))
            .header(ContentType::JSON)
            .remote("127.0.0.1:8000".parse().unwrap())
            .body(&serde_json::to_string(&json!({ "foo": "bar" })).unwrap())
            .dispatch();

        assert_eq!(response.status(), Status::Unauthorized);

        let response = client
            .post("/")
            .header(Header::new(
                "X-Gitea-Signature",
                "c5c315d76318362ec129ca629b50b626bba09ad3d7ba4cc0f4c0afe4a90537a0",
            ))
            .header(ContentType::JSON)
            .remote("127.0.0.1:8000".parse().unwrap())
            .body(r#"{ "not_secret": "invalid" "#)
            .dispatch();

        assert_eq!(response.status(), Status::BadRequest);
    }

    #[test]
    fn parse_command() {
        let mut map = HeaderMap::new();
        map.add_raw("X-Gitea-Event", "something");

        assert_eq!(
            replace_parameter("command", &map, &serde_json::Value::Null).unwrap(),
            "command"
        );

        assert_eq!(
            replace_parameter("    command", &map, &serde_json::Value::Null).unwrap(),
            "    command"
        );

        assert_eq!(
            replace_parameter("command    ", &map, &serde_json::Value::Null).unwrap(),
            "command    "
        );

        assert_eq!(
            replace_parameter("    command    ", &map, &serde_json::Value::Null).unwrap(),
            "    command    "
        );

        assert_eq!(
            replace_parameter("command command    ", &map, &serde_json::Value::Null).unwrap(),
            "command command    "
        );

        assert_eq!(
            replace_parameter("{{ /foo }}   command", &map, &json!({ "foo": "bar" })).unwrap(),
            "bar   command"
        );

        assert_eq!(
            replace_parameter("   command  {{ /foo }}  ", &map, &json!({ "foo": "bar" })).unwrap(),
            "   command  bar  "
        );

        assert_eq!(
            replace_parameter(
                "{{ /foo }}   command{{/field1/foo}}",
                &map,
                &json!({ "foo": "bar", "field1": { "foo": "baz" } })
            )
            .unwrap(),
            "bar   commandbaz"
        );

        assert_eq!(
            replace_parameter("   command  {{ /foo }}  ", &map, &json!({ "foo": "bar" })).unwrap(),
            "   command  bar  "
        );

        assert_eq!(
            replace_parameter(
                "   {{ /field1/foo }}   command",
                &map,
                &json!({ "field1": { "foo": "bar" } })
            )
            .unwrap(),
            "   bar   command"
        );

        // Add tests with header fields
    }
}