profuzz_core 0.1.0

profuzz is a generic approach to easily create a fast and easy-to use network protocol fuzzer for custom targets.
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

use tracing::level_filters::LevelFilter;
use tracing_subscriber::Layer;
use tracing_subscriber::Registry;
use tracing_subscriber::filter::Filtered;
use tracing_subscriber::layer::Layered;
use tracing_subscriber::prelude::__tracing_subscriber_SubscriberExt;
use tracing_subscriber::reload;
use tracing_subscriber::util::SubscriberInitExt;
use tui_logger::TuiTracingSubscriberLayer;

/// Manual manage the logging behavior of profuzz
#[derive(Clone)]
pub struct Logger {
    level_filter: LevelFilter,
    tui_reload_handle: tracing_subscriber::reload::Handle<
        Filtered<TuiTracingSubscriberLayer, tracing::level_filters::LevelFilter, Registry>,
        Registry,
    >,
    // // if you have a better idea go for it!!
    #[allow(clippy::complexity)]
    fmt_reload_handle: tracing_subscriber::reload::Handle<
        Filtered<
            tracing_subscriber::fmt::Layer<
                Layered<
                    tracing_subscriber::reload::Layer<
                        Filtered<
                            TuiTracingSubscriberLayer,
                            tracing::level_filters::LevelFilter,
                            Registry,
                        >,
                        Registry,
                    >,
                    Registry,
                >,
            >,
            tracing::level_filters::LevelFilter,
            Layered<
                tracing_subscriber::reload::Layer<
                    Filtered<
                        TuiTracingSubscriberLayer,
                        tracing::level_filters::LevelFilter,
                        Registry,
                    >,
                    Registry,
                >,
                Registry,
            >,
        >,
        Layered<
            tracing_subscriber::reload::Layer<
                Filtered<TuiTracingSubscriberLayer, tracing::level_filters::LevelFilter, Registry>,
                Registry,
            >,
            Registry,
        >,
    >,
}

impl Logger {
    /// Initialized the logger. This allows to collect all logs and show then in the TUI if
    /// enabled.
    /// # Panics
    #[must_use]
    pub fn init(verbose: bool) -> Self {
        let mut level_filter = LevelFilter::INFO;
        if verbose {
            level_filter = LevelFilter::DEBUG;
        }

        let fmt_logger = tracing_subscriber::fmt::Layer::new().with_filter(level_filter);
        let (fmt_logger, fmt_reload_handle) = reload::Layer::new(fmt_logger);

        let tui_logger = tui_logger::TuiTracingSubscriberLayer.with_filter(LevelFilter::OFF);
        let (tui_logger, tui_reload_handle) = reload::Layer::new(tui_logger);

        tracing_subscriber::registry()
            .with(tui_logger)
            .with(fmt_logger)
            .init();

        tui_logger::init_logger(tui_logger::LevelFilter::max()).expect("");

        Self {
            level_filter,
            tui_reload_handle,
            fmt_reload_handle,
        }
    }
    pub(crate) fn enable_tui(&self) {
        let _ = self
            .fmt_reload_handle
            .modify(|layer| *layer.filter_mut() = LevelFilter::OFF);
        let _ = self
            .tui_reload_handle
            .modify(|layer| *layer.filter_mut() = self.level_filter);
    }
    pub(crate) fn disable_tui(&self) {
        let _ = self
            .fmt_reload_handle
            .modify(|layer| *layer.filter_mut() = self.level_filter);
        let _ = self
            .tui_reload_handle
            .modify(|layer| *layer.filter_mut() = LevelFilter::OFF);
    }
}