konarr 0.5.1

Konarr
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

//! # Task to Sync Security Advisories
use async_trait::async_trait;
use geekorm::{Connection, ConnectionManager};
use log::{debug, error, info, warn};
use std::path::PathBuf;

use crate::KonarrError;
use crate::models::{ServerSettings, Setting};
use crate::utils::grypedb::GrypeDatabase;

use super::TaskTrait;

/// Advisories Sync Task to sync security advisories
///
/// This currently is done by syncing the Grype Database
#[derive(Default)]
pub struct AdvisoriesSyncTask {
    grype_path: PathBuf,
}

#[async_trait]
impl TaskTrait for AdvisoriesSyncTask {
    async fn run(&self, database: &ConnectionManager) -> Result<(), crate::KonarrError> {
        match self.sync_advisories(database).await {
            Ok(_) => debug!("Advisories Synced"),
            Err(e) => error!("Advisories Sync Error: {}", e),
        }
        Ok(())
    }
}

impl AdvisoriesSyncTask {
    /// Poll for Advisories and update the database
    pub async fn sync_advisories(
        &self,
        database: &geekorm::ConnectionManager,
    ) -> Result<(), KonarrError> {
        if !ServerSettings::get_bool(&database.acquire().await, Setting::SecurityAdvisories).await?
        {
            info!("Advisories Disabled");
            return Ok(());
        }

        debug!("Grype Path: {:?}", self.grype_path);

        if ServerSettings::get_bool(
            &database.acquire().await,
            Setting::SecurityAdvisoriesPolling,
        )
        .await?
        {
            let mut updated_last = ServerSettings::fetch_by_name(
                &database.acquire().await,
                Setting::SecurityAdvisoriesUpdated,
            )
            .await?;

            // The last updated time could be blank and unparsable
            if let Ok(last_updated_time) =
                chrono::DateTime::parse_from_rfc3339(updated_last.value.as_str())
            {
                debug!("Last Updated: {}", last_updated_time);
                let now = chrono::Utc::now();
                let delta = last_updated_time
                    .checked_add_signed(chrono::Duration::hours(1))
                    .ok_or(KonarrError::UnknownError("Invalid Date".to_string()))?;
                debug!("Next Update: {} < {}", now, delta);

                // Check if its been 1hr since the last update
                if now < delta {
                    debug!("Advisory DB Updated within the last hour");
                    return Ok(());
                }
            } else {
                debug!("Invalid Advisory Last Updated Time");
            }

            info!("Starting Advisory Database Sync");
            match GrypeDatabase::sync(&self.grype_path).await {
                Ok(new) => {
                    if new {
                        info!("New Advisory Database Synced");

                        let mut grypedb_connection =
                            GrypeDatabase::connect(&self.grype_path).await?;
                        grypedb_connection.fetch_vulnerabilities().await?;

                        info!("Scanning projects for security alerts");
                        info!("Project scanning complete");
                    } else {
                        info!(
                            "Advisory Database Synced but no new advisories, skipping project scanning for security alerts"
                        );
                    }
                }
                Err(e) => {
                    warn!("Advisory Sync Error: {}", e);
                    self.reset_polling(&database.acquire().await).await?;
                }
            };

            updated_last
                .set_update(&database.acquire().await, chrono::Utc::now().to_rfc3339())
                .await?;
        } else {
            debug!("Advisory Polling Disabled");
        }

        let grype = match GrypeDatabase::connect(&self.grype_path).await {
            Ok(db) => db,
            Err(_) => {
                warn!("Errors loading Grype DB");
                return Ok(());
            }
        };

        let connection = database.acquire().await;

        // Set Version
        let grype_id = match grype.fetch_grype().await {
            Ok(grype) => grype,
            Err(_) => {
                warn!("Errors loading Grype DB");
                self.reset_polling(&connection).await?;

                return Ok(());
            }
        };
        ServerSettings::fetch_by_name(&connection, Setting::SecurityAdvisoriesVersion)
            .await?
            .set_update(&connection, grype_id.build_timestamp.to_string().as_str())
            .await?;

        Ok(())
    }

    /// Reset the polling flag if there was an error
    async fn reset_polling(&self, connection: &Connection<'_>) -> Result<(), KonarrError> {
        ServerSettings::fetch_by_name(connection, Setting::SecurityAdvisoriesPolling)
            .await?
            .set_update(connection, "disabled")
            .await?;

        Ok(())
    }
}