cloudiful-redactor 0.4.0

Structured text redaction with reversible sessions for secrets, domains, URLs, and related sensitive values.
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

use serde::{Deserialize, Serialize};

use crate::{FindingKind, RedactionPolicy};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RestorationEntry {
    pub token: String,
    pub kind: FindingKind,
    pub original: String,
    pub replacement_hint: Option<String>,
    pub occurrences: usize,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RedactionSession {
    pub version: u32,
    pub session_id: String,
    pub scope_id: String,
    pub external_id: Option<String>,
    pub fingerprint: String,
    pub redacted_fingerprint: String,
    pub redacted_text: String,
    #[serde(default)]
    pub policy: RedactionPolicy,
    pub entries: Vec<RestorationEntry>,
    #[serde(default)]
    pub issued_tokens: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub struct RestoreResult {
    pub restored_text: String,
    pub restored_count: usize,
    pub skipped_tokens: Vec<String>,
    pub unresolved_tokens: Vec<String>,
    pub validation_errors: Vec<String>,
}

impl RestoreResult {
    pub fn is_valid(&self) -> bool {
        self.validation_errors.is_empty() && self.unresolved_tokens.is_empty()
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RestorePermit {
    pub version: u32,
    pub permit_id: String,
    pub scope_id: String,
    pub external_id: Option<String>,
    pub issued_tokens: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub struct SessionEntrySummary {
    pub token: String,
    pub kind: FindingKind,
    pub replacement_hint: Option<String>,
    pub occurrences: usize,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub struct SessionSummary {
    pub version: u32,
    pub session_id: String,
    pub scope_id: String,
    pub external_id: Option<String>,
    pub fingerprint: String,
    pub redacted_fingerprint: String,
    pub entry_count: usize,
    pub entries: Vec<SessionEntrySummary>,
}

impl From<&RedactionSession> for SessionSummary {
    fn from(session: &RedactionSession) -> Self {
        Self {
            version: session.version,
            session_id: session.session_id.clone(),
            scope_id: session.scope_id.clone(),
            external_id: session.external_id.clone(),
            fingerprint: session.fingerprint.clone(),
            redacted_fingerprint: session.redacted_fingerprint.clone(),
            entry_count: session.entries.len(),
            entries: session
                .entries
                .iter()
                .map(|entry| SessionEntrySummary {
                    token: entry.token.clone(),
                    kind: entry.kind,
                    replacement_hint: entry.replacement_hint.clone(),
                    occurrences: entry.occurrences,
                })
                .collect(),
        }
    }
}