355 lines
15 KiB
Rust
355 lines
15 KiB
Rust
use std::collections::{HashMap, HashSet};
|
|
use std::io::{Cursor, Read, Write};
|
|
use std::path::{Component, Path};
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use zip::write::SimpleFileOptions;
|
|
|
|
use crate::nacos::types::{NacosConfigItem, NacosConfigUpsert};
|
|
|
|
pub const MAX_ARCHIVE_BYTES: u64 = 100 * 1024 * 1024;
|
|
pub const MAX_UNCOMPRESSED_BYTES: u64 = 256 * 1024 * 1024;
|
|
pub const MAX_CONFIG_BYTES: u64 = 20 * 1024 * 1024;
|
|
pub const MAX_METADATA_BYTES: u64 = 2 * 1024 * 1024;
|
|
pub const MAX_CONFIG_ITEMS: usize = 10_000;
|
|
const METADATA_PATH: &str = ".metadata.yml";
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct MetadataItem {
|
|
group: String,
|
|
#[serde(rename = "dataId")]
|
|
data_id: String,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
desc: Option<String>,
|
|
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
|
|
config_type: Option<String>,
|
|
#[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
|
|
app_name: Option<String>,
|
|
#[serde(rename = "configTags", default, skip_serializing_if = "Option::is_none")]
|
|
config_tags: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
struct MetadataDocument {
|
|
metadata: Vec<MetadataItem>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Deserialize)]
|
|
#[serde(untagged)]
|
|
enum CompatibleMetadata {
|
|
Document(MetadataDocument),
|
|
Items(Vec<MetadataItem>),
|
|
}
|
|
|
|
impl CompatibleMetadata {
|
|
fn into_items(self) -> Vec<MetadataItem> {
|
|
match self {
|
|
Self::Document(document) => document.metadata,
|
|
Self::Items(items) => items,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn encode_config_archive(configs: &[NacosConfigItem]) -> Result<Vec<u8>, String> {
|
|
if configs.len() > MAX_CONFIG_ITEMS {
|
|
return Err(format!("Nacos archive contains more than {MAX_CONFIG_ITEMS} configurations"));
|
|
}
|
|
let mut sorted = configs.to_vec();
|
|
sorted.sort_by(|left, right| {
|
|
(&left.group, &left.data_id, &left.namespace).cmp(&(&right.group, &right.data_id, &right.namespace))
|
|
});
|
|
let mut seen = HashSet::new();
|
|
let mut metadata = Vec::with_capacity(sorted.len());
|
|
let mut actual_uncompressed = 0u64;
|
|
for config in &sorted {
|
|
validate_config_key(&config.group, &config.data_id)?;
|
|
if !seen.insert((config.group.clone(), config.data_id.clone())) {
|
|
return Err(format!("Duplicate Nacos configuration key: {}/{}", config.group, config.data_id));
|
|
}
|
|
let content = config
|
|
.content
|
|
.as_deref()
|
|
.ok_or_else(|| format!("Nacos configuration {}/{} has no content", config.group, config.data_id))?;
|
|
if content.len() as u64 > MAX_CONFIG_BYTES {
|
|
return Err(format!("Nacos configuration {}/{} exceeds the 20 MiB limit", config.group, config.data_id));
|
|
}
|
|
actual_uncompressed = add_uncompressed_size(actual_uncompressed, content.len() as u64)?;
|
|
metadata.push(MetadataItem {
|
|
group: config.group.clone(),
|
|
data_id: config.data_id.clone(),
|
|
desc: config.desc.clone(),
|
|
config_type: config.config_type.clone(),
|
|
app_name: config.app_name.clone(),
|
|
config_tags: config.tags.clone(),
|
|
});
|
|
}
|
|
let metadata = serde_yaml_ng::to_string(&MetadataDocument { metadata })
|
|
.map_err(|error| format!("Failed to encode Nacos archive metadata: {error}"))?;
|
|
if metadata.len() as u64 > MAX_METADATA_BYTES {
|
|
return Err("Nacos archive metadata exceeds the 2 MiB limit".to_string());
|
|
}
|
|
add_uncompressed_size(actual_uncompressed, metadata.len() as u64)?;
|
|
|
|
let cursor = Cursor::new(Vec::new());
|
|
let mut archive = zip::ZipWriter::new(cursor);
|
|
let options =
|
|
SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated).unix_permissions(0o600);
|
|
archive
|
|
.start_file(METADATA_PATH, options)
|
|
.map_err(|error| format!("Failed to create Nacos archive metadata entry: {error}"))?;
|
|
archive
|
|
.write_all(metadata.as_bytes())
|
|
.map_err(|error| format!("Failed to write Nacos archive metadata: {error}"))?;
|
|
for config in sorted {
|
|
archive
|
|
.start_file(archive_entry_path(&config.group, &config.data_id), options)
|
|
.map_err(|error| format!("Failed to create Nacos archive entry: {error}"))?;
|
|
archive
|
|
.write_all(config.content.as_deref().unwrap_or_default().as_bytes())
|
|
.map_err(|error| format!("Failed to write Nacos archive entry: {error}"))?;
|
|
}
|
|
let bytes = archive.finish().map_err(|error| format!("Failed to finish Nacos archive: {error}"))?.into_inner();
|
|
if bytes.len() as u64 > MAX_ARCHIVE_BYTES {
|
|
return Err("Nacos archive exceeds the 100 MiB limit".to_string());
|
|
}
|
|
Ok(bytes)
|
|
}
|
|
|
|
pub fn decode_config_archive(bytes: &[u8], target_namespace: &str) -> Result<Vec<NacosConfigUpsert>, String> {
|
|
if bytes.len() as u64 > MAX_ARCHIVE_BYTES {
|
|
return Err("Nacos archive exceeds the 100 MiB limit".to_string());
|
|
}
|
|
let mut archive =
|
|
zip::ZipArchive::new(Cursor::new(bytes)).map_err(|error| format!("Invalid Nacos ZIP archive: {error}"))?;
|
|
if archive.len() > MAX_CONFIG_ITEMS.saturating_add(1) {
|
|
return Err(format!("Nacos archive contains more than {MAX_CONFIG_ITEMS} configurations"));
|
|
}
|
|
let mut entries = HashMap::<String, Vec<u8>>::new();
|
|
let mut actual_uncompressed = 0u64;
|
|
for index in 0..archive.len() {
|
|
let mut entry = archive.by_index(index).map_err(|error| format!("Invalid Nacos ZIP entry: {error}"))?;
|
|
let name = entry.name().to_string();
|
|
validate_archive_path(&name)?;
|
|
if entry.is_dir() {
|
|
continue;
|
|
}
|
|
if entry.unix_mode().is_some_and(|mode| mode & 0o170000 == 0o120000) {
|
|
return Err(format!("Nacos archive symlink is not allowed: {name}"));
|
|
}
|
|
let declared_limit = if name == METADATA_PATH { MAX_METADATA_BYTES } else { MAX_CONFIG_BYTES };
|
|
if entry.size() > declared_limit {
|
|
return Err(format!("Nacos archive entry exceeds its size limit: {name}"));
|
|
}
|
|
let mut content = Vec::with_capacity(entry.size().min(declared_limit) as usize);
|
|
entry
|
|
.by_ref()
|
|
.take(declared_limit + 1)
|
|
.read_to_end(&mut content)
|
|
.map_err(|error| format!("Failed to read Nacos archive entry {name}: {error}"))?;
|
|
if content.len() as u64 > declared_limit {
|
|
return Err(format!("Nacos archive entry exceeds its size limit: {name}"));
|
|
}
|
|
actual_uncompressed = add_uncompressed_size(actual_uncompressed, content.len() as u64)?;
|
|
if entries.insert(name.clone(), content).is_some() {
|
|
return Err(format!("Duplicate Nacos archive path: {name}"));
|
|
}
|
|
}
|
|
let metadata = entries.remove(METADATA_PATH).ok_or_else(|| "Nacos archive is missing .metadata.yml".to_string())?;
|
|
let metadata: CompatibleMetadata =
|
|
serde_yaml_ng::from_slice(&metadata).map_err(|error| format!("Invalid Nacos archive metadata: {error}"))?;
|
|
let metadata = metadata.into_items();
|
|
if metadata.len() > MAX_CONFIG_ITEMS {
|
|
return Err(format!("Nacos archive contains more than {MAX_CONFIG_ITEMS} configurations"));
|
|
}
|
|
let mut keys = HashSet::new();
|
|
let mut configs = Vec::with_capacity(metadata.len());
|
|
for item in metadata {
|
|
validate_config_key(&item.group, &item.data_id)?;
|
|
if !keys.insert((item.group.clone(), item.data_id.clone())) {
|
|
return Err(format!("Duplicate Nacos configuration key: {}/{}", item.group, item.data_id));
|
|
}
|
|
let path = archive_entry_path(&item.group, &item.data_id);
|
|
// Archives exported by older DBX versions and the Nacos console use
|
|
// the direct `group/dataId` layout. Keep accepting it as a fallback;
|
|
// new exports only use that layout when both components are safe.
|
|
let legacy_path = format!("{}/{}", item.group, item.data_id);
|
|
let content = entries
|
|
.remove(&path)
|
|
.or_else(|| entries.remove(&legacy_path))
|
|
.ok_or_else(|| format!("Nacos archive metadata references a missing file: {path}"))?;
|
|
let content =
|
|
String::from_utf8(content).map_err(|_| format!("Nacos configuration is not valid UTF-8: {path}"))?;
|
|
configs.push(NacosConfigUpsert {
|
|
namespace: Some(target_namespace.to_string()),
|
|
data_id: item.data_id,
|
|
group: item.group,
|
|
content,
|
|
config_type: item.config_type,
|
|
app_name: item.app_name,
|
|
desc: item.desc,
|
|
tags: item.config_tags,
|
|
});
|
|
}
|
|
if let Some(orphan) = entries.keys().next() {
|
|
return Err(format!("Nacos archive contains an orphan file not present in metadata: {orphan}"));
|
|
}
|
|
Ok(configs)
|
|
}
|
|
|
|
fn validate_archive_path(name: &str) -> Result<(), String> {
|
|
let bytes = name.as_bytes();
|
|
let has_windows_drive_prefix =
|
|
bytes.len() >= 3 && bytes[0].is_ascii_alphabetic() && bytes[1] == b':' && matches!(bytes[2], b'/' | b'\\');
|
|
if name.is_empty()
|
|
|| name.contains('\0')
|
|
|| name.contains('\\')
|
|
|| name.starts_with('/')
|
|
|| has_windows_drive_prefix
|
|
{
|
|
return Err(format!("Unsafe Nacos archive path: {name}"));
|
|
}
|
|
let path = Path::new(name);
|
|
if path.components().any(|component| !matches!(component, Component::Normal(_))) {
|
|
return Err(format!("Unsafe Nacos archive path: {name}"));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn add_uncompressed_size(current: u64, addition: u64) -> Result<u64, String> {
|
|
let total = current.checked_add(addition).ok_or_else(|| "Nacos archive uncompressed size overflow".to_string())?;
|
|
if total > MAX_UNCOMPRESSED_BYTES {
|
|
return Err("Nacos archive exceeds the 256 MiB uncompressed limit".to_string());
|
|
}
|
|
Ok(total)
|
|
}
|
|
|
|
fn validate_config_key(group: &str, data_id: &str) -> Result<(), String> {
|
|
for (label, value) in [("group", group), ("dataId", data_id)] {
|
|
if value.trim().is_empty() || value.contains('\0') {
|
|
return Err(format!("Invalid Nacos configuration {label}: {value:?}"));
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn archive_entry_path(group: &str, data_id: &str) -> String {
|
|
if is_safe_archive_component(group) && is_safe_archive_component(data_id) {
|
|
return format!("{group}/{data_id}");
|
|
}
|
|
// Metadata is the source of truth for the original identifiers. Hex keeps
|
|
// the ZIP entry path portable and collision-free without treating Nacos
|
|
// identifiers as filesystem paths.
|
|
format!("configs/{}--{}", hex_encode(group.as_bytes()), hex_encode(data_id.as_bytes()))
|
|
}
|
|
|
|
fn is_safe_archive_component(value: &str) -> bool {
|
|
!value.is_empty() && value != "." && value != ".." && !value.contains(['/', '\\', '\0'])
|
|
}
|
|
|
|
fn hex_encode(bytes: &[u8]) -> String {
|
|
const HEX: &[u8; 16] = b"0123456789abcdef";
|
|
let mut encoded = String::with_capacity(bytes.len() * 2);
|
|
for byte in bytes {
|
|
encoded.push(HEX[(byte >> 4) as usize] as char);
|
|
encoded.push(HEX[(byte & 0x0f) as usize] as char);
|
|
}
|
|
encoded
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn config(group: &str, data_id: &str, content: &str) -> NacosConfigItem {
|
|
NacosConfigItem {
|
|
data_id: data_id.to_string(),
|
|
group: group.to_string(),
|
|
namespace: "source".to_string(),
|
|
app_name: Some("dbx".to_string()),
|
|
desc: Some("test".to_string()),
|
|
tags: Some("one,two".to_string()),
|
|
config_type: Some("yaml".to_string()),
|
|
md5: None,
|
|
encrypted_data_key: Some("must-not-leak".to_string()),
|
|
content: Some(content.to_string()),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn archive_round_trip_preserves_migratable_fields_only() {
|
|
let bytes = encode_config_archive(&[config("DEFAULT_GROUP", "app.yaml", "数据库: mysql://db")]).unwrap();
|
|
let decoded = decode_config_archive(&bytes, "target").unwrap();
|
|
assert_eq!(decoded.len(), 1);
|
|
assert_eq!(decoded[0].namespace.as_deref(), Some("target"));
|
|
assert_eq!(decoded[0].content, "数据库: mysql://db");
|
|
assert_eq!(decoded[0].tags.as_deref(), Some("one,two"));
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_path_traversal() {
|
|
let cursor = Cursor::new(Vec::new());
|
|
let mut zip = zip::ZipWriter::new(cursor);
|
|
zip.start_file("../evil", SimpleFileOptions::default()).unwrap();
|
|
zip.write_all(b"bad").unwrap();
|
|
let bytes = zip.finish().unwrap().into_inner();
|
|
let error = decode_config_archive(&bytes, "target").unwrap_err();
|
|
assert!(error.contains("Unsafe"));
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_windows_absolute_path() {
|
|
let cursor = Cursor::new(Vec::new());
|
|
let mut zip = zip::ZipWriter::new(cursor);
|
|
zip.start_file("C:/secret", SimpleFileOptions::default()).unwrap();
|
|
zip.write_all(b"bad").unwrap();
|
|
let bytes = zip.finish().unwrap().into_inner();
|
|
let error = decode_config_archive(&bytes, "target").unwrap_err();
|
|
assert!(error.contains("Unsafe"));
|
|
}
|
|
|
|
#[test]
|
|
fn enforces_total_uncompressed_limit_arithmetically() {
|
|
assert_eq!(add_uncompressed_size(MAX_UNCOMPRESSED_BYTES - 1, 1).unwrap(), MAX_UNCOMPRESSED_BYTES);
|
|
assert!(add_uncompressed_size(MAX_UNCOMPRESSED_BYTES, 1).unwrap_err().contains("256 MiB"));
|
|
}
|
|
|
|
#[test]
|
|
fn accepts_official_list_shaped_metadata() {
|
|
let cursor = Cursor::new(Vec::new());
|
|
let mut zip = zip::ZipWriter::new(cursor);
|
|
zip.start_file(METADATA_PATH, SimpleFileOptions::default()).unwrap();
|
|
zip.write_all(b"- group: DEFAULT_GROUP\n dataId: app.properties\n type: properties\n").unwrap();
|
|
zip.start_file("DEFAULT_GROUP/app.properties", SimpleFileOptions::default()).unwrap();
|
|
zip.write_all(b"a=1").unwrap();
|
|
let bytes = zip.finish().unwrap().into_inner();
|
|
assert_eq!(decode_config_archive(&bytes, "").unwrap()[0].content, "a=1");
|
|
}
|
|
|
|
#[test]
|
|
fn archive_round_trip_preserves_identifiers_with_path_separators() {
|
|
let bytes = encode_config_archive(&[config("team/dev", "apps/service.yaml", "enabled: true")]).unwrap();
|
|
let archive = zip::ZipArchive::new(Cursor::new(bytes.clone())).unwrap();
|
|
assert!(archive.file_names().any(|name| name.starts_with("configs/")));
|
|
|
|
let decoded = decode_config_archive(&bytes, "target").unwrap();
|
|
assert_eq!(decoded[0].group, "team/dev");
|
|
assert_eq!(decoded[0].data_id, "apps/service.yaml");
|
|
}
|
|
|
|
#[test]
|
|
fn accepts_legacy_nested_path_for_separator_identifiers() {
|
|
let cursor = Cursor::new(Vec::new());
|
|
let mut zip = zip::ZipWriter::new(cursor);
|
|
zip.start_file(METADATA_PATH, SimpleFileOptions::default()).unwrap();
|
|
zip.write_all(b"- group: team/dev\n dataId: apps/service.yaml\n").unwrap();
|
|
zip.start_file("team/dev/apps/service.yaml", SimpleFileOptions::default()).unwrap();
|
|
zip.write_all(b"enabled: true").unwrap();
|
|
let bytes = zip.finish().unwrap().into_inner();
|
|
|
|
let decoded = decode_config_archive(&bytes, "target").unwrap();
|
|
assert_eq!(decoded[0].group, "team/dev");
|
|
assert_eq!(decoded[0].data_id, "apps/service.yaml");
|
|
}
|
|
}
|