sh4d0wup 0.11.0

Signing-key abuse and update exploitation framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use crate::artifacts::HashedArtifact;
use crate::errors::*;
use crate::templates;
use handlebars::{Context, Handlebars, Helper, HelperDef, Output, RenderContext, RenderError};

#[derive(Debug)]
enum HashType {
    Sha256,
    Sha1,
    Md5,
}

struct HashHelper<'a> {
    artifact: &'a HashedArtifact,
    hash: HashType,
}

impl HashHelper<'_> {
    fn new(artifact: &HashedArtifact, hash: HashType) -> HashHelper {
        HashHelper { artifact, hash }
    }
}

impl HelperDef for HashHelper<'_> {
    fn call<'_reg: '_rc, '_rc>(
        &self,
        _: &Helper,
        _: &'_reg Handlebars,
        _: &Context,
        _: &mut RenderContext,
        out: &mut dyn Output,
    ) -> Result<(), RenderError> {
        let hash = match self.hash {
            HashType::Sha256 => self.artifact.sha256(),
            HashType::Sha1 => self.artifact.sha1(),
            HashType::Md5 => self.artifact.md5(),
        };
        out.write(&hash).map_err(RenderError::from)
    }
}

pub fn render(
    path_template: &str,
    artifact: &HashedArtifact,
    metadata: Option<&templates::ArtifactMetadata>,
) -> Result<String> {
    let mut handlebars = templates::create_engine(path_template)?;

    handlebars.register_helper(
        "sha256",
        Box::new(HashHelper::new(artifact, HashType::Sha256)),
    );
    handlebars.register_helper("sha1", Box::new(HashHelper::new(artifact, HashType::Sha1)));
    handlebars.register_helper("md5", Box::new(HashHelper::new(artifact, HashType::Md5)));

    let values = metadata.map(|m| m.to_values()).unwrap_or_default();

    let rendered = handlebars
        .render("t", &values)
        .context("Failed to render path_template")?;
    debug!("Rendered path for route: {:?}", rendered);
    Ok(rendered)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_render_url() -> Result<()> {
        let template = "/hax.git/objects/{{slice-until (sha1) 2}}/{{slice-after (sha1) 2}}";
        let output = render(template, &HashedArtifact::new(b"ohai".to_vec()), None)?;
        assert_eq!(
            output,
            "/hax.git/objects/dc/a51952447d80bd35bf631bc21f06648798b7e0"
        );
        Ok(())
    }
}