web-analyzer 0.1.7

Enterprise domain security & intelligence platform — WHOIS, DNS, SEO, tech detection, subdomain takeover, API security scanning, and more
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

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationResult {
    pub domain: String,
    pub valid: bool,
    pub skip_reason: Option<String>,
    pub dns_valid: bool,
    pub http_valid: bool,
    pub ssl_valid: bool,
    pub dns_info: Option<DnsValidation>,
    pub http_info: Option<HttpValidation>,
    pub ssl_info: Option<SslValidation>,
    pub errors: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DnsValidation {
    pub ip_addresses: Vec<String>,
    pub mx_exists: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HttpValidation {
    pub http_reachable: bool,
    pub https_reachable: bool,
    pub http_status: Option<u16>,
    pub https_status: Option<u16>,
    pub redirects_to_https: bool,
    pub response_time_ms: u128,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SslValidation {
    pub ssl_available: bool,
    pub protocol_version: String,
    pub cipher_suite: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationStats {
    pub total: usize,
    pub valid: usize,
    pub invalid: usize,
    pub skipped: usize,
    pub dns_failed: usize,
    pub http_failed: usize,
    pub ssl_failed: usize,
    pub success_rate: f64,
    pub processing_time_secs: f64,
    pub domains_per_sec: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BulkValidationResult {
    pub stats: ValidationStats,
    pub valid_domains: Vec<String>,
    pub results: Vec<ValidationResult>,
}

pub async fn validate_domain(domain: &str) -> ValidationResult {
    ValidationResult {
        domain: domain.to_string(),
        valid: false,
        skip_reason: Some("Platform Unsupported".to_string()),
        dns_valid: false,
        http_valid: false,
        ssl_valid: false,
        dns_info: None,
        http_info: None,
        ssl_info: None,
        errors: vec!["Mobile integration via native networking is pending implementation.".into()],
    }
}

pub async fn validate_domains_bulk(domains: &[String], _max_concurrency: usize) -> BulkValidationResult {
    BulkValidationResult {
        stats: ValidationStats {
            total: domains.len(),
            valid: 0,
            invalid: domains.len(),
            skipped: 0,
            dns_failed: domains.len(),
            http_failed: domains.len(),
            ssl_failed: domains.len(),
            success_rate: 0.0,
            processing_time_secs: 0.0,
            domains_per_sec: 0.0,
        },
        valid_domains: vec![],
        results: domains.iter().map(|d| ValidationResult {
            domain: d.to_string(),
            valid: false,
            skip_reason: Some("Platform Unsupported".to_string()),
            dns_valid: false,
            http_valid: false,
            ssl_valid: false,
            dns_info: None,
            http_info: None,
            ssl_info: None,
            errors: vec!["Mobile integration via native networking is pending implementation.".into()],
        }).collect(),
    }
}