seednaut 0.1.1

A command-line utility for inspecting, verifying, and extracting Seedvault Android backups
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

use crate::engine::crypto::{DerivedKeys, create_streaming_aead};
use crate::engine::decrypt::{RepoFileType, decrypt_and_decompress};
use crate::engine::types::{RawSnapshot, SnapshotInfo, pb};
use anyhow::Result;
use prost::Message;
use regex::Regex;
use std::path::Path;
use walkdir::WalkDir;

const APP_REPO_PATTERN: &str = r"^[a-f0-9]{64}$";
const FILE_REPO_PATTERN: &str = r"^[a-f0-9]{16}\.sv$";

/// Result of snapshot discovery, including any failures encountered.
pub struct DiscoveryResult {
    pub snapshots: Vec<SnapshotInfo>,
    pub failed: Vec<String>,
}

/// Scans the input path for app and file snapshots, decrypts them, and returns them sorted by time.
pub fn discover_snapshots(
    input_path: &Path,
    derived_keys: &DerivedKeys,
) -> Result<DiscoveryResult> {
    let app_repo_regex = Regex::new(APP_REPO_PATTERN).expect("Invalid app repo regex");
    let file_repo_regex = Regex::new(FILE_REPO_PATTERN).expect("Invalid file repo regex");

    let app_aead = create_streaming_aead(derived_keys.app_stream_key)?;
    let file_aead = create_streaming_aead(derived_keys.file_stream_key)?;

    let mut found_snapshots = Vec::new();
    let mut failures = Vec::new();

    for entry in WalkDir::new(input_path).into_iter().filter_map(|e| e.ok()) {
        let path = entry.path();
        if !path.is_file() {
            continue;
        }

        let file_name = match path.file_name().and_then(|n| n.to_str()) {
            Some(name) => name,
            None => continue,
        };

        let Some(parent_dir) = path.parent() else {
            continue;
        };
        let Some(parent_dir_name) = parent_dir
            .file_name()
            .and_then(|n| n.to_str())
            .filter(|s| !s.is_empty())
        else {
            continue;
        };

        // Identify snapshot files by extension + parent directory naming convention.
        if file_name.ends_with(".snapshot") && app_repo_regex.is_match(parent_dir_name) {
            match decrypt_and_decompress(path, &*app_aead, RepoFileType::AppSnapshot) {
                Ok(decrypted_bytes) => {
                    match pb::seedvault::Snapshot::decode(decrypted_bytes.as_slice()) {
                        Ok(snapshot) => {
                            let info = SnapshotInfo {
                                index: 0,
                                // App snapshots use `token` as the backup timestamp.
                                timestamp: snapshot.token,
                                name: snapshot.name.clone(),
                                snapshot_path: path.to_path_buf(),
                                repo_path: parent_dir.to_path_buf(),
                                raw_snapshot: RawSnapshot::App(snapshot),
                            };
                            found_snapshots.push(info);
                        }
                        Err(e) => failures.push(format!("{}: {}", path.display(), e)),
                    }
                }
                Err(e) => failures.push(format!("{}: {}", path.display(), e)),
            }
        } else if file_name.ends_with(".SeedSnap")
            && file_repo_regex.is_match(parent_dir_name)
            && let Some(timestamp_str) = path.file_stem().and_then(|s| s.to_str())
            && let Ok(timestamp) = timestamp_str.parse::<u64>()
        {
            let file_type = RepoFileType::FileSnapshot { timestamp };
            match decrypt_and_decompress(path, &*file_aead, file_type) {
                Ok(decrypted_bytes) => {
                    match pb::calyxos::BackupSnapshot::decode(decrypted_bytes.as_slice()) {
                        Ok(snapshot) => {
                            let info = SnapshotInfo {
                                index: 0,
                                // File snapshots use `time_start` as the backup timestamp.
                                timestamp: snapshot.time_start as u64,
                                name: snapshot.name.clone(),
                                snapshot_path: path.to_path_buf(),
                                repo_path: parent_dir.to_path_buf(),
                                raw_snapshot: RawSnapshot::File(snapshot),
                            };
                            found_snapshots.push(info);
                        }
                        Err(e) => failures.push(format!("{}: {}", path.display(), e)),
                    }
                }
                Err(e) => failures.push(format!("{}: {}", path.display(), e)),
            }
        }
    }

    // Most recent first.
    found_snapshots.sort_by_key(|s| std::cmp::Reverse(s.timestamp));

    for (i, s) in found_snapshots.iter_mut().enumerate() {
        s.index = (i + 1) as u32;
    }

    Ok(DiscoveryResult {
        snapshots: found_snapshots,
        failed: failures,
    })
}