rustsec 0.7.0-alpha3

Client library for the RustSec security advisory 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

//! Vulnerabilities are an `Advisory` collection constructed by matching crates
//! in a particular `Lockfile` against all advisories in an `AdvisoryDatabase`
//! and looking for vulnerable versions.

use std::{ops::Index, slice};

use advisory::Advisory;
use db::AdvisoryDatabase;
use lockfile::Lockfile;
use package::Package;

/// A collection of vulnerabilities (i.e. matching advisories) for a given `Lockfile`
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Vulnerabilities(Vec<Vulnerability>);

impl Vulnerabilities {
    /// Find all vulnerabilities for a given `AdvisoryDatabase` and `Lockfile`
    pub fn find(db: &AdvisoryDatabase, lockfile: &Lockfile) -> Self {
        let mut vulns = vec![];

        for package in &lockfile.packages {
            for advisory in db.advisories_for_crate(&package.name, &package.version) {
                vulns.push(Vulnerability::new(advisory, package))
            }
        }

        Vulnerabilities(vulns)
    }

    /// Number of vulnerabilities
    pub fn len(&self) -> usize {
        self.0.len()
    }

    /// Are we blissfully vulnerability-free?
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    /// Iterate over the vulnerabilities in this collection
    pub fn iter(&self) -> Iter {
        Iter(self.0.as_slice().iter())
    }

    /// Convert this collection into a vector
    pub fn into_vec(self) -> Vec<Vulnerability> {
        self.into()
    }
}

impl Index<usize> for Vulnerabilities {
    type Output = Vulnerability;

    fn index(&self, index: usize) -> &Vulnerability {
        &self.0[index]
    }
}

impl Into<Vec<Vulnerability>> for Vulnerabilities {
    fn into(self) -> Vec<Vulnerability> {
        self.0
    }
}

/// A vulnerable package and the associated advisory
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Vulnerability {
    /// A security advisory for which the package is vulnerable
    pub advisory: Advisory,

    /// A vulnerable package
    pub package: Package,
}

impl Vulnerability {
    /// Create a new vulnerability object from the given references
    pub fn new(advisory: &Advisory, package: &Package) -> Self {
        Self {
            advisory: advisory.clone(),
            package: package.clone(),
        }
    }
}

impl<'a> IntoIterator for &'a Vulnerabilities {
    type Item = &'a Vulnerability;
    type IntoIter = Iter<'a>;

    fn into_iter(self) -> Iter<'a> {
        self.iter()
    }
}

/// Iterator over the advisory database
pub struct Iter<'a>(slice::Iter<'a, Vulnerability>);

impl<'a> Iterator for Iter<'a> {
    type Item = &'a Vulnerability;

    fn next(&mut self) -> Option<&'a Vulnerability> {
        self.0.next()
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.0.size_hint()
    }
}

impl<'a> ExactSizeIterator for Iter<'a> {
    fn len(&self) -> usize {
        self.0.len()
    }
}