hdiff-update-core 0.1.2

Core library for signed HDiffPatch-based differential application updates.
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

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};

use crate::{Error, Result};

pub const DEFAULT_ALGORITHM_NAME: &str = "hdiffpatch-v5-window-zstd";
pub const MANIFEST_SIGNATURE_ALGORITHM: &str = "ed25519";

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Artifact {
    pub url: String,
    pub sha256: String,
    pub size: u64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DeltaArtifact {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from_version: Option<String>,
    pub from_sha256: String,
    pub url: String,
    pub sha256: String,
    pub size: u64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target_sha256: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target_size: Option<u64>,
    #[serde(default = "default_algorithm")]
    pub algorithm: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ManifestSignature {
    #[serde(default = "default_signature_algorithm")]
    pub algorithm: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key_id: Option<String>,
    pub value: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlatformRelease {
    pub full: Artifact,
    #[serde(default)]
    pub deltas: Vec<DeltaArtifact>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UpdateManifest {
    pub version: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub signature: Option<ManifestSignature>,
    pub platforms: BTreeMap<String, PlatformRelease>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum SelectedArtifact {
    Delta { artifact: DeltaArtifact },
    Full { artifact: Artifact },
}

impl UpdateManifest {
    pub fn signing_payload(&self) -> Result<Vec<u8>> {
        let mut unsigned = self.clone();
        unsigned.signature = None;
        Ok(serde_json::to_vec(&unsigned)?)
    }
}

impl UpdateManifest {
    pub fn platform(&self, platform: &str) -> Result<&PlatformRelease> {
        self.platforms
            .get(platform)
            .ok_or_else(|| Error::MissingPlatform {
                platform: platform.to_string(),
            })
    }

    pub fn select_artifact(
        &self,
        platform: &str,
        current_version: Option<&str>,
        current_sha256: Option<&str>,
    ) -> Result<SelectedArtifact> {
        let platform_release = self.platform(platform)?;

        if let Some(current_sha256) = current_sha256 {
            if let Some(delta) = platform_release.deltas.iter().find(|delta| {
                let hash_matches = delta.from_sha256.eq_ignore_ascii_case(current_sha256);
                let version_matches = match (&delta.from_version, current_version) {
                    (Some(from), Some(current)) => from == current,
                    (Some(_), None) => true,
                    (None, _) => true,
                };
                hash_matches && version_matches
            }) {
                return Ok(SelectedArtifact::Delta {
                    artifact: delta.clone(),
                });
            }
        }

        Ok(SelectedArtifact::Full {
            artifact: platform_release.full.clone(),
        })
    }
}

pub fn default_platform() -> String {
    let os = if cfg!(target_os = "windows") {
        "windows"
    } else if cfg!(target_os = "macos") {
        "darwin"
    } else if cfg!(target_os = "linux") {
        "linux"
    } else {
        std::env::consts::OS
    };

    let arch = if cfg!(target_arch = "x86_64") {
        "x86_64"
    } else if cfg!(target_arch = "aarch64") {
        "aarch64"
    } else {
        std::env::consts::ARCH
    };

    format!("{os}-{arch}")
}

fn default_algorithm() -> String {
    DEFAULT_ALGORITHM_NAME.to_string()
}

fn default_signature_algorithm() -> String {
    MANIFEST_SIGNATURE_ALGORITHM.to_string()
}