ctlog 0.1.0

A simple certificate transparency log client API wrapper
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

// use anyhow::Result;
use reqwest::Client;

use crate::client::CTLog;
use crate::ct::v1::*;
use crate::CTLogError;

#[derive(Debug)]
pub struct CTLogV1(CTLog);

impl CTLogV1 {
    pub fn new(log_server: &str) -> Result<Self, CTLogError> {
        Ok(Self(CTLog {
            inner: Client::new(),
            log_server: log_server.parse()?,
        }))
    }

    /// Add Chain to Log
    ///
    /// [RFC 6962 4.1](https://datatracker.ietf.org/doc/html/rfc6962#section-4.1)
    pub async fn add_chain(&self, chain: Vec<String>) -> Result<AddChainResponse, CTLogError> {
        let url = self.0.log_server.join("ct/v1/add-chain")?;
        let response = self
            .0
            .inner
            .post(url)
            .json(&chain)
            .send()
            .await?
            .json()
            .await?;
        Ok(response)
    }

    /// Add PreCertChain to Log
    ///
    /// [RFC 6962 4.2](https://datatracker.ietf.org/doc/html/rfc6962#section-4.2)
    pub async fn add_pre_chain(&self, chain: Vec<String>) -> Result<AddChainResponse, CTLogError> {
        let url = self.0.log_server.join("ct/v1/add-pre-chain")?;
        let response = self
            .0
            .inner
            .post(url)
            .json(&chain)
            .send()
            .await?
            .json()
            .await?;
        Ok(response)
    }

    /// Retrieve Latest Signed Tree Head
    ///
    /// [RFC 6962 4.3](https://datatracker.ietf.org/doc/html/rfc6962#section-4.3)
    pub async fn get_sth(&self) -> Result<GetSthResponse, CTLogError> {
        let url = self.0.log_server.join("ct/v1/get-sth")?;
        let response = self.0.inner.get(url).send().await?.json().await?;
        Ok(response)
    }

    /// Retrieve Merkle Consistency Proof between Two Signed Tree Heads
    ///
    /// [RFC 6962 4.4](https://datatracker.ietf.org/doc/html/rfc6962#section-4.4)
    pub async fn get_sth_consistency(
        &self,
        first: u64,
        second: u64,
    ) -> Result<GetSthConsistencyResponse, CTLogError> {
        let url = self.0.log_server.join(&format!(
            "ct/v1/get-sth-consistency?first={first}&second={second}"
        ))?;
        let response = self.0.inner.get(url).send().await?.json().await?;
        Ok(response)
    }

    /// Retrieve Merkle Audit Proof from Log by Leaf Hash
    ///
    /// [RFC 6962 4.5](https://datatracker.ietf.org/doc/html/rfc6962#section-4.5)
    pub async fn get_proof_by_hash(
        &self,
        hash: &str,
        tree_size: u64,
    ) -> Result<GetProofByHashResponse, CTLogError> {
        let url = self.0.log_server.join(&format!(
            "ct/v1/get-proof-by-hash?hash={hash}&tree_size={tree_size}",
        ))?;
        let response = self.0.inner.get(url).send().await?.json().await?;
        Ok(response)
    }

    /// Retrieve Entries from Log
    ///
    /// [RFC 6962 4.6](https://datatracker.ietf.org/doc/html/rfc6962#section-4.6)
    pub async fn get_entries(
        &self,
        start: u64,
        end: u64,
    ) -> Result<GetEntriesResponse, CTLogError> {
        let url = self
            .0
            .log_server
            .join(&format!("ct/v1/get-entries?start={start}&end={end}"))?;
        let response = self.0.inner.get(url).send().await?.json().await?;
        Ok(response)
    }

    /// Retrieve Accepted Root Certificates
    ///
    /// [RFC 6962 4.7](https://datatracker.ietf.org/doc/html/rfc6962#section-4.7)
    pub async fn get_roots(&self) -> Result<GetRootsResponse, CTLogError> {
        let url = self.0.log_server.join("ct/v1/get-roots")?;
        let response = self.0.inner.get(url).send().await?.json().await?;
        Ok(response)
    }

    /// Retrieve Entry + Merkle Audit Proof from Log
    ///
    /// [RFC 6962 4.8](https://datatracker.ietf.org/doc/html/rfc6962#section-4.8)
    pub async fn get_entry_and_proof(
        &self,
        leaf_index: u64,
        tree_size: u64,
    ) -> Result<GetEntryAndProofResponse, CTLogError> {
        let url = self.0.log_server.join(&format!(
            "ct/v1/get-entry-and-proof?leaf_index={leaf_index}&tree_size={tree_size}"
        ))?;
        let response = self.0.inner.get(url).send().await?.json().await?;
        Ok(response)
    }
}