memflowup 0.2.0

setup tool for the memflow physical memory introspection framework
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use reqwest::{Response, Url};
use serde::{Deserialize, Serialize};

use crate::error::{Error, Result};

const USER_AGENT: &str = "memflowup 0.2.0";

#[derive(Debug, Serialize, Deserialize)]
pub struct Release {
    pub url: String,
    pub assets_url: String,
    pub upload_url: String,
    pub html_url: String,
    pub id: u64,
    // author
    pub node_id: String,
    pub tag_name: String,
    pub name: String,
    pub draft: bool,
    pub prerelease: bool,
    pub created_at: String,
    pub published_at: String,
    pub assets: Vec<Asset>,
    pub tarball_url: String,
    pub zipball_url: String,
    pub body: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Asset {
    pub url: String,
    pub id: u64,
    pub node_id: String,
    pub name: String,
    pub label: String,
    // uploader
    pub content_type: String,
    pub state: String,
    pub size: u64,
    pub download_count: u64,
    pub created_at: String,
    pub updated_at: String,
    pub browser_download_url: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Branch {
    pub name: String,
    pub commit: Commit,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Tag {
    #[serde(rename = "ref")]
    pub name: String,
    #[serde(rename = "object")]
    pub commit: Commit,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Commit {
    pub sha: String,
}

/// Resolves a specific branch from github
pub async fn branch(url: &str, branch: &str) -> Result<Branch> {
    if !url.contains("github.com") {
        return Err(Error::Http(
            "github api only works with github.com api".to_owned(),
        ));
    }

    let path: Url = format!(
        "{}/branches/{}",
        url.replace("github.com", "api.github.com/repos"),
        branch
    )
    .parse()
    .unwrap(); // TODO: parse error

    let client = reqwest::Client::new();
    let response = client
        .get(path)
        .header("User-Agent", USER_AGENT)
        .send()
        .await?;
    let result = response.json::<Branch>().await?;
    Ok(result)
}

/// Resolves a specific tag from github
pub async fn tag(url: &str, tag: &str) -> Result<Tag> {
    if !url.contains("github.com") {
        return Err(Error::Http(
            "github api only works with github.com api".to_owned(),
        ));
    }

    let path: Url = format!(
        "{}/git/ref/tags/{}",
        url.replace("github.com", "api.github.com/repos"),
        tag
    )
    .parse()
    .unwrap(); // TODO: parse error

    let client = reqwest::Client::new();
    let response = client
        .get(path)
        .header("User-Agent", USER_AGENT)
        .send()
        .await?;
    let result = response.json::<Tag>().await?;
    Ok(result)
}

/// Downloads the code for specific commit in the repository
pub async fn download_code_for_commit(url: &str, commit: &str) -> Result<Response> {
    if !url.contains("github.com") {
        return Err(Error::Http(
            "github api only works with github.com api".to_owned(),
        ));
    }

    let path: Url = format!("{}/archive/{}.zip", url, commit).parse().unwrap(); // TODO: parse error

    let client = reqwest::Client::new();
    let response = client
        .get(path)
        .header("User-Agent", USER_AGENT)
        .send()
        .await?;

    Ok(response)
}