dd-sensitive-data-scanner 0.0.0

Core Sensitive Data Scanner library for detecting and redacting sensitive information.
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

use crate::scanner::RuleResult;
use crate::{
    CompiledRule, CreateScannerError, Labels, MatchAction, Path, RootRuleConfig, RuleConfig,
    ScannerBuilder, ScannerError, StringMatch, StringMatchesCtx,
};
use futures::executor::block_on;
use std::sync::Arc;
use std::time::Duration;
use tokio::task::block_in_place;

pub struct AsyncRuleConfig {
    wait: Duration,
}

pub struct AsyncCompiledRule {
    wait: Duration,
}

impl CompiledRule for AsyncCompiledRule {
    fn get_string_matches(
        &self,
        _content: &str,
        _path: &Path,
        ctx: &mut StringMatchesCtx,
    ) -> RuleResult {
        let wait = self.wait;
        ctx.process_async(move |ctx| {
            Box::pin(async move {
                tokio::time::sleep(wait).await;
                ctx.emit_match(StringMatch {
                    start: 10,
                    end: 16,
                    keyword: None,
                });
                Ok(())
            })
        })
    }
}

impl RuleConfig for AsyncRuleConfig {
    fn convert_to_compiled_rule(
        &self,
        _content: usize,
        _: Labels,
    ) -> Result<Box<dyn CompiledRule>, CreateScannerError> {
        Ok(Box::new(AsyncCompiledRule { wait: self.wait }))
    }
}

#[tokio::test(flavor = "multi_thread")]
async fn run_async_rule() {
    let scanner = ScannerBuilder::new(&[RootRuleConfig::new(Arc::new(AsyncRuleConfig {
        wait: Duration::from_millis(1),
    }) as Arc<dyn RuleConfig>)
    .match_action(MatchAction::Redact {
        replacement: "[REDACTED]".to_string(),
    })])
    .build()
    .unwrap();

    // synchronous scan
    block_in_place(|| {
        let mut input = "this is a secret with random data".to_owned();
        let matched_rules = scanner.scan(&mut input).unwrap();
        assert_eq!(matched_rules.len(), 1);
        assert_eq!(input, "this is a [REDACTED] with random data");
    });

    // async scan
    let mut input = "this is a secret with random data".to_owned();
    let matched_rules = scanner.scan_async(&mut input).await.unwrap();
    assert_eq!(matched_rules.len(), 1);
    assert_eq!(input, "this is a [REDACTED] with random data");
}

#[tokio::test(flavor = "multi_thread")]
async fn async_scan_timeout() {
    let scanner = ScannerBuilder::new(&[RootRuleConfig::new(Arc::new(AsyncRuleConfig {
        wait: Duration::from_secs(99999),
    }) as Arc<dyn RuleConfig>)
    .match_action(MatchAction::Redact {
        replacement: "[REDACTED]".to_string(),
    })])
    .with_async_scan_timeout(Duration::from_millis(1))
    .build()
    .unwrap();

    let mut input = "this is a secret with random data".to_owned();
    let result = scanner.scan_async(&mut input).await;
    assert!(result.is_err());
    assert_eq!(
        result.unwrap_err(),
        ScannerError::Transient("Async scan timeout".to_string())
    );
}

#[test]
fn async_scan_outside_of_tokio() {
    // Make sure scanning works without requiring users to explicitly enter a Tokio runtime.
    // This is done automatically for tests with `#[tokio::test]` so this one excludes it.

    let scanner = ScannerBuilder::new(&[RootRuleConfig::new(Arc::new(AsyncRuleConfig {
        wait: Duration::from_millis(1),
    }) as Arc<dyn RuleConfig>)
    .match_action(MatchAction::Redact {
        replacement: "[REDACTED]".to_string(),
    })])
    .build()
    .unwrap();

    let fut = async move {
        let mut input = "this is a secret with random data".to_owned();
        let matched_rules = scanner.scan_async(&mut input).await.unwrap();
        assert_eq!(matched_rules.len(), 1);
        assert_eq!(input, "this is a [REDACTED] with random data");
    };

    // moving the future to a separate thread before executing it to make sure it is `Send`
    std::thread::spawn(move || {
        block_on(fut);
    })
    .join()
    .unwrap();
}