htb-cli 0.1.11

Hack The Box CLI
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
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
136
137

use serde_json::json;

use crate::error::HtbError;
use crate::models::ctf::{
    CtfChallengeSolve, CtfEvent, CtfEventData, CtfEventDetail, CtfFlagResult, CtfMenu,
    CtfScoreboard, CtfSolve, CtfTeamOverview, CtfUserProfile,
};
use crate::models::ActionResponse;

#[derive(serde::Serialize)]
struct ProgressBody {
    status: Option<String>,
}

use super::HtbClient;

pub struct CtfApi<'a>(pub(crate) &'a HtbClient);

impl CtfApi<'_> {
    pub async fn profile(&self) -> Result<CtfUserProfile, HtbError> {
        self.0.get("/api/users/profile").await
    }

    pub async fn events(&self) -> Result<Vec<CtfEvent>, HtbError> {
        self.0.get("/api/ctfs").await
    }

    pub async fn event_details(&self, slug: &str) -> Result<CtfEventDetail, HtbError> {
        let encoded = super::encode_path(slug);
        self.0.get(&format!("/api/ctfs/details/{encoded}")).await
    }

    pub async fn event_data(&self, event_id: u64) -> Result<CtfEventData, HtbError> {
        self.0.get(&format!("/api/ctfs/{event_id}")).await
    }

    pub async fn menu(&self, event_id: u64) -> Result<CtfMenu, HtbError> {
        self.0.get(&format!("/api/ctfs/{event_id}/menu")).await
    }

    pub async fn submit_flag(
        &self,
        challenge_id: u64,
        flag: &str,
    ) -> Result<CtfFlagResult, HtbError> {
        self.0
            .post(
                "/api/flags/own",
                &json!({"challenge_id": challenge_id, "flag": flag}),
            )
            .await
    }

    pub async fn download_file(&self, challenge_id: u64) -> Result<Vec<u8>, HtbError> {
        self.0
            .get_bytes(&format!("/api/challenges/{challenge_id}/download"))
            .await
    }

    pub async fn container_start(&self, challenge_id: u64) -> Result<ActionResponse, HtbError> {
        self.0
            .post(
                "/api/challenges/containers/start",
                &json!({"id": challenge_id}),
            )
            .await
    }

    pub async fn container_stop(&self, challenge_id: u64) -> Result<ActionResponse, HtbError> {
        self.0
            .post(
                "/api/challenges/containers/stop",
                &json!({"id": challenge_id}),
            )
            .await
    }

    pub async fn scoreboard(&self, event_id: u64) -> Result<CtfScoreboard, HtbError> {
        self.0.get(&format!("/api/ctfs/scores/{event_id}")).await
    }

    pub async fn solves(&self, event_id: u64) -> Result<Vec<CtfSolve>, HtbError> {
        self.0.get(&format!("/api/ctfs/solves/{event_id}")).await
    }

    pub async fn challenge_solves(
        &self,
        challenge_id: u64,
    ) -> Result<Vec<CtfChallengeSolve>, HtbError> {
        self.0
            .get(&format!("/api/challenges/{challenge_id}/solves"))
            .await
    }

    pub async fn team_overview(&self, team_id: u64) -> Result<CtfTeamOverview, HtbError> {
        self.0.get(&format!("/api/teams/{team_id}/overview")).await
    }

    pub async fn associate_challenge(
        &self,
        challenge_id: u64,
        user_id: u64,
    ) -> Result<ActionResponse, HtbError> {
        self.0
            .get(&format!(
                "/api/challenges/{challenge_id}/associate/{user_id}"
            ))
            .await
    }

    pub async fn disassociate_challenge(
        &self,
        challenge_id: u64,
        user_id: u64,
    ) -> Result<ActionResponse, HtbError> {
        self.0
            .get(&format!(
                "/api/challenges/{challenge_id}/disassociate/{user_id}"
            ))
            .await
    }

    pub async fn set_challenge_progress(
        &self,
        challenge_id: u64,
        status: Option<&str>,
    ) -> Result<(), HtbError> {
        self.0
            .post_no_content(
                &format!("/api/challenges/{challenge_id}/progress"),
                &ProgressBody {
                    status: status.map(|s| s.to_string()),
                },
            )
            .await
    }
}