krill 0.16.0

Resource Public Key Infrastructure (RPKI) daemon
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

//! Logging of CMS protocol messages for auditing purposes.

use std::fmt;
use std::path::PathBuf;
use bytes::Bytes;
use rpki::ca::idexchange::{
    CaHandle, PublisherHandle, RecipientHandle, SenderHandle,
};
use rpki::repository::x509::Time;
use crate::commons::file;
use crate::commons::error::KrillIoError;


//------------ CmsLogger -----------------------------------------------------

/// Logs CMS (RFC8181 and RFC6492) protocol messages for auditing purposes.
pub struct CmsLogger {
    /// The path to log to,
    ///
    /// If this is `None`, we don’t actually log.
    path: Option<PathBuf>,

    /// The current Unix timestamp.
    now: i64,
}

impl CmsLogger {
    /// Creates a new logger with the given base path.
    ///
    /// If the path is `None`, nothing will be logged.
    fn new(path: Option<PathBuf>) -> Self {
        CmsLogger {
            path,
            now: Time::now().timestamp_millis(),
        }
    }

    /// Creates a new logger for a received RFC 6492 message.
    pub fn for_rfc6492_rcvd(
        log_dir: Option<&PathBuf>,
        recipient: &RecipientHandle,
        sender: &SenderHandle,
    ) -> Self {
        let path = log_dir.map(|dir| {
            let mut path = dir.clone();
            path.push(recipient.as_str());
            path.push("rcvd");
            path.push(sender.as_str());
            path
        });

        Self::new(path)
    }

    /// Creates a new logger for a sent RFC 6492 message.
    pub fn for_rfc6492_sent(
        log_dir: Option<&PathBuf>,
        sender: &SenderHandle,
        recipient: &RecipientHandle,
    ) -> Self {
        let path = log_dir.map(|dir| {
            let mut path = dir.clone();
            path.push(sender.as_str());
            path.push("sent");
            path.push(recipient.as_str());
            path
        });

        Self::new(path)
    }

    /// Creates a new logger for a received RFC 8181 message.
    pub fn for_rfc8181_rcvd(
        log_dir: Option<&PathBuf>,
        publisher: &PublisherHandle,
    ) -> Self {
        let path = log_dir.map(|dir| {
            let mut path = dir.clone();
            path.push(publisher.as_str());
            path.push("rcvd");
            path
        });

        Self::new(path)
    }

    /// Creates a new logger for a sent RFC 8181 message.
    pub fn for_rfc8181_sent(
        log_dir: Option<&PathBuf>,
        ca: &CaHandle,
    ) -> Self {
        let path = log_dir.map(|dir| {
            let mut path = dir.clone();
            path.push(ca.as_str());
            path.push("sent");
            path
        });

        Self::new(path)
    }

    /// Saves the received message.
    pub fn received(&self, msg: &Bytes) -> Result<(), KrillIoError> {
        self.save(msg, "rcvd")
    }

    /// Saves the reply message.
    pub fn reply(&self, msg: &Bytes) -> Result<(), KrillIoError> {
        self.save(msg, "repl")
    }

    /// Saves the sent message.
    pub fn sent(&self, msg: &Bytes) -> Result<(), KrillIoError> {
        self.save(msg, "sent")
    }

    /// Saves the error message.
    pub fn err(&self, msg: impl fmt::Display) -> Result<(), KrillIoError> {
        self.save(msg.to_string().as_bytes(), "err")
    }

    /// Saves the message.
    fn save(&self, content: &[u8], ext: &str) -> Result<(), KrillIoError> {
        if let Some(path) = self.path.as_ref() {
            let mut path = path.clone();
            path.push(format!("{}.{}", self.now, ext));

            file::save(content, &path)
        }
        else {
            Ok(())
        }
    }
}