euvd 0.2.0

API for querying recent vulnerabilities from the ENISA EUVD database.
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use euvd::apis::configuration::Configuration;
use euvd::apis::default_api;

#[tokio::test()]
async fn get_last_vulnerabilities() {

    // Preparation
    let config = Configuration::default();
    let result = default_api::get_last_vulnerabilities(&config).await;

    // Print result if successful
    if let Ok(response) = &result {
        println!("Response received:");
        for vuln in response {
            println!("• ID: {:?}, Description: {:?}", vuln.id, vuln.description);
        }
    }

    // Asserts
    assert!(result.is_ok(), "API call failed: {:?}", result.err());
}

#[tokio::test()]
async fn get_exploited_vulnerabilities() {

    // Preparation
    let config = Configuration::default();
    let result = default_api::get_exploited_vulnerabilities(&config).await;

    // Print result if successful
    if let Ok(response) = &result {
        println!("Response received:");
        for vuln in response {
            println!("• ID: {:?}, Description: {:?}", vuln.id, vuln.description);
        }
    }

    // Asserts
    assert!(result.is_ok(), "API call failed: {:?}", result.err());
}

#[tokio::test()]
async fn get_critical_vulnerabilities() {

    // Preparation
    let config = Configuration::default();
    let result = default_api::get_critical_vulnerabilities(&config).await;

    // Print result if successful
    if let Ok(response) = &result {
        println!("Response received:");
        for vuln in response {
            println!("• ID: {:?}, Description: {:?}", vuln.id, vuln.description);
        }
    }

    // Asserts
    assert!(result.is_ok(), "API call failed: {:?}", result.err());
}

#[tokio::test]
async fn query_vulnerabilities() {
    
    // Preparation
    let config = Configuration::default();
    let result = default_api::query_vulnerabilities(
        &config,
        None, // from_score
        None, // to_score
        None, // from_epss
        None, // to_epss
        None, // from_date
        None, // to_date
        None, // search
        None, // cvss_version
        None, // cvss_vector
        None, // exploited
        None, // limit
        None, // sort_by
        None, // page
    ).await;

    // Print result if successful
    if let Ok(response) = &result {
        println!("Response received:");

        if let Some(items) = &response.items {
            for vuln in items {
                println!(
                    "• ID: {:?}, Description: {:?}",
                    vuln.id.as_deref().unwrap_or("n/a"),
                    vuln.description.as_deref().unwrap_or("n/a")
                );
            }
        } else {
            println!("No vulnerabilities found in response.");
        }
    }

    // Assert
    assert!(result.is_ok(), "API call failed: {:?}", result.err());
}

#[tokio::test()]
async fn get_by_enisa_id() {

    // Preparation
    let config = Configuration::default();
    let result = default_api::get_by_enisa_id(&config, "EUVD-2024-45012").await;

    // Print result if successful
    if let Ok(vuln) = &result {
        println!("Response received:");
        println!("• ID: {:?}, Description: {:?}", vuln.id, vuln.description);
    }

    // Asserts
    assert!(result.is_ok(), "API call failed: {:?}", result.err());
}

#[tokio::test()]
async fn get_vulnerability_by_id() {

    // Preparation
    let config = Configuration::default();
    let result = default_api::get_vulnerability_by_id(&config, "CVE-2024-0864").await;

    // Print result if successful
    if let Ok(vuln) = &result {
        println!("Response received:");
        println!("• ID: {:?}, Description: {:?}", vuln.id, vuln.description);
    }

    // Asserts
    assert!(result.is_ok(), "API call failed: {:?}", result.err());
}

#[tokio::test()]
async fn get_advisory_by_id() {

    // Preparation
    let config = Configuration::default();
    let result = default_api::get_advisory_by_id(&config, "cisco-sa-ata19x-multi-RDTEqRsy").await;

    // Print result if successful
    if let Ok(vuln) = &result {
        println!("Response received:");
        println!("• ID: {:?}, Description: {:?}", vuln.id, vuln.description);
    }

    // Asserts
    assert!(result.is_ok(), "API call failed: {:?}", result.err());
}