-use failure::*;
+use anyhow::{bail, format_err, Error};
use std::convert::TryFrom;
+use std::path::Path;
use serde_json::{json, Value};
+use ::serde::{Deserialize, Serialize};
-use crate::backup::BackupDir;
+use crate::backup::{BackupDir, CryptMode, CryptConfig};
pub const MANIFEST_BLOB_NAME: &str = "index.json.blob";
+pub const CLIENT_LOG_BLOB_NAME: &str = "client.log.blob";
-struct FileInfo {
- filename: String,
- size: u64,
- csum: [u8; 32],
+mod hex_csum {
+ use serde::{self, Deserialize, Serializer, Deserializer};
+
+ pub fn serialize<S>(
+ csum: &[u8; 32],
+ serializer: S,
+ ) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let s = proxmox::tools::digest_to_hex(csum);
+ serializer.serialize_str(&s)
+ }
+
+ pub fn deserialize<'de, D>(
+ deserializer: D,
+ ) -> Result<[u8; 32], D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let s = String::deserialize(deserializer)?;
+ proxmox::tools::hex_to_digest(&s).map_err(serde::de::Error::custom)
+ }
+}
+
+fn crypt_mode_none() -> CryptMode { CryptMode::None }
+fn empty_value() -> Value { json!({}) }
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all="kebab-case")]
+pub struct FileInfo {
+ pub filename: String,
+ #[serde(default="crypt_mode_none")] // to be compatible with < 0.8.0 backups
+ pub crypt_mode: CryptMode,
+ pub size: u64,
+ #[serde(with = "hex_csum")]
+ pub csum: [u8; 32],
}
+impl FileInfo {
+
+ /// Return expected CryptMode of referenced chunks
+ ///
+ /// Encrypted Indices should only reference encrypted chunks, while signed or plain indices
+ /// should only reference plain chunks.
+ pub fn chunk_crypt_mode (&self) -> CryptMode {
+ match self.crypt_mode {
+ CryptMode::Encrypt => CryptMode::Encrypt,
+ CryptMode::SignOnly | CryptMode::None => CryptMode::None,
+ }
+ }
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all="kebab-case")]
pub struct BackupManifest {
- snapshot: BackupDir,
+ backup_type: String,
+ backup_id: String,
+ backup_time: i64,
files: Vec<FileInfo>,
+ #[serde(default="empty_value")] // to be compatible with < 0.8.0 backups
+ pub unprotected: Value,
+ pub signature: Option<String>,
}
+#[derive(PartialEq)]
+pub enum ArchiveType {
+ FixedIndex,
+ DynamicIndex,
+ Blob,
+}
+
+pub fn archive_type<P: AsRef<Path>>(
+ archive_name: P,
+) -> Result<ArchiveType, Error> {
+
+ let archive_name = archive_name.as_ref();
+ let archive_type = match archive_name.extension().and_then(|ext| ext.to_str()) {
+ Some("didx") => ArchiveType::DynamicIndex,
+ Some("fidx") => ArchiveType::FixedIndex,
+ Some("blob") => ArchiveType::Blob,
+ _ => bail!("unknown archive type: {:?}", archive_name),
+ };
+ Ok(archive_type)
+}
+
+
impl BackupManifest {
pub fn new(snapshot: BackupDir) -> Self {
- Self { files: Vec::new(), snapshot }
+ Self {
+ backup_type: snapshot.group().backup_type().into(),
+ backup_id: snapshot.group().backup_id().into(),
+ backup_time: snapshot.backup_time(),
+ files: Vec::new(),
+ unprotected: json!({}),
+ signature: None,
+ }
}
- pub fn add_file(&mut self, filename: String, size: u64, csum: [u8; 32]) {
- self.files.push(FileInfo { filename, size, csum });
+ pub fn add_file(&mut self, filename: String, size: u64, csum: [u8; 32], crypt_mode: CryptMode) -> Result<(), Error> {
+ let _archive_type = archive_type(&filename)?; // check type
+ self.files.push(FileInfo { filename, size, csum, crypt_mode });
+ Ok(())
}
- pub fn into_json(self) -> Value {
- json!({
- "backup-type": self.snapshot.group().backup_type(),
- "backup-id": self.snapshot.group().backup_id(),
- "backup-time": self.snapshot.backup_time().timestamp(),
- "files": self.files.iter()
- .fold(Vec::new(), |mut acc, info| {
- acc.push(json!({
- "filename": info.filename,
- "size": info.size,
- "csum": proxmox::tools::digest_to_hex(&info.csum),
- }));
- acc
- })
- })
+ pub fn files(&self) -> &[FileInfo] {
+ &self.files[..]
}
-}
+ pub fn lookup_file_info(&self, name: &str) -> Result<&FileInfo, Error> {
-impl TryFrom<Value> for BackupManifest {
- type Error = Error;
+ let info = self.files.iter().find(|item| item.filename == name);
+
+ match info {
+ None => bail!("manifest does not contain file '{}'", name),
+ Some(info) => Ok(info),
+ }
+ }
+
+ pub fn verify_file(&self, name: &str, csum: &[u8; 32], size: u64) -> Result<(), Error> {
+
+ let info = self.lookup_file_info(name)?;
+
+ if size != info.size {
+ bail!("wrong size for file '{}' ({} != {})", name, info.size, size);
+ }
+
+ if csum != &info.csum {
+ bail!("wrong checksum for file '{}'", name);
+ }
+
+ Ok(())
+ }
+
+ // Generate canonical json
+ fn to_canonical_json(value: &Value) -> Result<Vec<u8>, Error> {
+ let mut data = Vec::new();
+ Self::write_canonical_json(value, &mut data)?;
+ Ok(data)
+ }
+
+ fn write_canonical_json(value: &Value, output: &mut Vec<u8>) -> Result<(), Error> {
+ match value {
+ Value::Null => bail!("got unexpected null value"),
+ Value::String(_) | Value::Number(_) | Value::Bool(_) => {
+ serde_json::to_writer(output, &value)?;
+ }
+ Value::Array(list) => {
+ output.push(b'[');
+ let mut iter = list.iter();
+ if let Some(item) = iter.next() {
+ Self::write_canonical_json(item, output)?;
+ for item in iter {
+ output.push(b',');
+ Self::write_canonical_json(item, output)?;
+ }
+ }
+ output.push(b']');
+ }
+ Value::Object(map) => {
+ output.push(b'{');
+ let mut keys: Vec<&str> = map.keys().map(String::as_str).collect();
+ keys.sort();
+ let mut iter = keys.into_iter();
+ if let Some(key) = iter.next() {
+ serde_json::to_writer(&mut *output, &key)?;
+ output.push(b':');
+ Self::write_canonical_json(&map[key], output)?;
+ for key in iter {
+ output.push(b',');
+ serde_json::to_writer(&mut *output, &key)?;
+ output.push(b':');
+ Self::write_canonical_json(&map[key], output)?;
+ }
+ }
+ output.push(b'}');
+ }
+ }
+ Ok(())
+ }
- fn try_from(data: Value) -> Result<Self, Error> {
+ /// Compute manifest signature
+ ///
+ /// By generating a HMAC SHA256 over the canonical json
+ /// representation, The 'unpreotected' property is excluded.
+ pub fn signature(&self, crypt_config: &CryptConfig) -> Result<[u8; 32], Error> {
+ Self::json_signature(&serde_json::to_value(&self)?, crypt_config)
+ }
+
+ fn json_signature(data: &Value, crypt_config: &CryptConfig) -> Result<[u8; 32], Error> {
+
+ let mut signed_data = data.clone();
+
+ signed_data.as_object_mut().unwrap().remove("unprotected"); // exclude
+ signed_data.as_object_mut().unwrap().remove("signature"); // exclude
+
+ let canonical = Self::to_canonical_json(&signed_data)?;
- let backup_type = crate::tools::required_string_property(&data, "backup_type")?;
- let backup_id = crate::tools::required_string_property(&data, "backup_id")?;
- let backup_time = crate::tools::required_integer_property(&data, "backup_time")?;
+ let sig = crypt_config.compute_auth_tag(&canonical);
- let snapshot = BackupDir::new(backup_type, backup_id, backup_time);
+ Ok(sig)
+ }
+
+ /// Converts the Manifest into json string, and add a signature if there is a crypt_config.
+ pub fn to_string(&self, crypt_config: Option<&CryptConfig>) -> Result<String, Error> {
+
+ let mut manifest = serde_json::to_value(&self)?;
- let mut files = Vec::new();
- for item in crate::tools::required_array_property(&data, "files")?.iter() {
- let filename = crate::tools::required_string_property(item, "filename")?.to_owned();
- let csum = crate::tools::required_string_property(item, "csum")?;
- let csum = proxmox::tools::hex_to_digest(csum)?;
- let size = crate::tools::required_integer_property(item, "size")? as u64;
- files.push(FileInfo { filename, size, csum });
+ if let Some(crypt_config) = crypt_config {
+ let sig = self.signature(crypt_config)?;
+ manifest["signature"] = proxmox::tools::digest_to_hex(&sig).into();
}
- Ok(Self { files, snapshot })
+ let manifest = serde_json::to_string_pretty(&manifest).unwrap().into();
+ Ok(manifest)
+ }
+
+ /// Try to read the manifest. This verifies the signature if there is a crypt_config.
+ pub fn from_data(data: &[u8], crypt_config: Option<&CryptConfig>) -> Result<BackupManifest, Error> {
+ let json: Value = serde_json::from_slice(data)?;
+ let signature = json["signature"].as_str().map(String::from);
+
+ if let Some(ref crypt_config) = crypt_config {
+ if let Some(signature) = signature {
+ let expected_signature = proxmox::tools::digest_to_hex(&Self::json_signature(&json, crypt_config)?);
+ if signature != expected_signature {
+ bail!("wrong signature in manifest");
+ }
+ } else {
+ // not signed: warn/fail?
+ }
+ }
+
+ let manifest: BackupManifest = serde_json::from_value(json)?;
+ Ok(manifest)
+ }
+}
+
+
+impl TryFrom<super::DataBlob> for BackupManifest {
+ type Error = Error;
+
+ fn try_from(blob: super::DataBlob) -> Result<Self, Error> {
+ // no expected digest available
+ let data = blob.decode(None, None)
+ .map_err(|err| format_err!("decode backup manifest blob failed - {}", err))?;
+ let json: Value = serde_json::from_slice(&data[..])
+ .map_err(|err| format_err!("unable to parse backup manifest json - {}", err))?;
+ let manifest: BackupManifest = serde_json::from_value(json)?;
+ Ok(manifest)
}
}
+
+
+#[test]
+fn test_manifest_signature() -> Result<(), Error> {
+
+ use crate::backup::{KeyDerivationConfig};
+
+ let pw = b"test";
+
+ let kdf = KeyDerivationConfig::Scrypt {
+ n: 65536,
+ r: 8,
+ p: 1,
+ salt: Vec::new(),
+ };
+
+ let testkey = kdf.derive_key(pw)?;
+
+ let crypt_config = CryptConfig::new(testkey)?;
+
+ let snapshot: BackupDir = "host/elsa/2020-06-26T13:56:05Z".parse()?;
+
+ let mut manifest = BackupManifest::new(snapshot);
+
+ manifest.add_file("test1.img.fidx".into(), 200, [1u8; 32], CryptMode::Encrypt)?;
+ manifest.add_file("abc.blob".into(), 200, [2u8; 32], CryptMode::None)?;
+
+ manifest.unprotected["note"] = "This is not protected by the signature.".into();
+
+ let text = manifest.to_string(Some(&crypt_config))?;
+
+ let manifest: Value = serde_json::from_str(&text)?;
+ let signature = manifest["signature"].as_str().unwrap().to_string();
+
+ assert_eq!(signature, "d7b446fb7db081662081d4b40fedd858a1d6307a5aff4ecff7d5bf4fd35679e9");
+
+ let manifest: BackupManifest = serde_json::from_value(manifest)?;
+ let expected_signature = proxmox::tools::digest_to_hex(&manifest.signature(&crypt_config)?);
+
+ assert_eq!(signature, expected_signature);
+
+ Ok(())
+}
projects / proxmox-backup.git / blobdiff