backdisco 0.4.0

Discover backend origins from CDN frontends using LLM-assisted pattern analysis and brute force enumeration
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 anyhow::Result;
use colored::*;
use indicatif::{ProgressBar, ProgressStyle};
use std::fs::File;
use std::io::Write;
use std::path::PathBuf;

pub struct Output {
    verbose: u8,
    file: Option<File>,
}

impl Output {
    pub fn new(verbose: u8, output_path: Option<PathBuf>) -> Result<Self> {
        let file = if let Some(path) = &output_path {
            Some(File::create(path)?)
        } else {
            None
        };

        Ok(Output { verbose, file })
    }

    fn write(&mut self, plain_message: &str, colored_message: Option<&str>) {
        // Write plain text to file if specified
        if let Some(ref mut file) = self.file {
            let _ = writeln!(file, "{}", plain_message);
        }
        // Write colored text to terminal
        if let Some(colored) = colored_message {
            println!("{}", colored);
        } else {
            println!("{}", plain_message);
        }
    }

    pub fn info(&mut self, message: &str) {
        if self.verbose >= 1 {
            let styled = format!("{} {}", "ℹ".cyan(), message);
            self.write(message, Some(&styled));
        }
    }

    pub fn success(&mut self, message: &str) {
        if self.verbose >= 1 {
            let styled = format!("{} {}", "✓".green(), message);
            self.write(message, Some(&styled));
        }
    }

    pub fn error(&mut self, message: &str) {
        let styled = format!("{} {}", "✗".red(), message);
        self.write(message, Some(&styled));
    }

    pub fn debug(&mut self, message: &str) {
        if self.verbose >= 2 {
            let styled = format!("{} {}", "→".yellow(), message);
            self.write(message, Some(&styled));
        }
    }

    pub fn warning(&mut self, message: &str) {
        if self.verbose >= 1 {
            let styled = format!("{} {}", "⚠".yellow(), message);
            self.write(message, Some(&styled));
        }
    }

    pub fn warn(&mut self, message: &str) {
        self.warning(message);
    }

    /// Create a progress bar for brute force candidate generation
    pub fn create_brute_progress(&self, total: u64, message: &str) -> ProgressBar {
        let pb = ProgressBar::new(total);
        pb.set_style(
            ProgressStyle::default_bar()
                .template("{spinner:.cyan} {msg} {bar:40.cyan/blue} {pos}/{len} ({percent}%)")
                .unwrap()
                .progress_chars("█▉▊▋▌▍▎▏  "),
        );
        pb.set_message(message.to_string());
        pb
    }

    /// Create a progress bar for verification
    pub fn create_verify_progress(&self, total: u64) -> ProgressBar {
        let pb = ProgressBar::new(total);
        pb.set_style(
            ProgressStyle::default_bar()
                .template("{spinner:.green} {msg} {bar:40.green/yellow} {pos}/{len} ({percent}%) | {elapsed_precise} | ETA: {eta_precise}")
                .unwrap()
                .progress_chars("█▉▊▋▌▍▎▏  "),
        );
        pb.set_message("Verifying candidates".to_string());
        pb
    }
}