mirror of
https://github.com/rustfs/rustfs.git
synced 2026-11-22 16:02:46 +00:00
Compare commits
53 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| e6435510f8 | |||
| 5696c6f759 | |||
| 7c3732799e | |||
| adad36dc3b | |||
| 83afcf52f7 | |||
| bb044df449 | |||
| 3565ae1ddf | |||
| cce3b0873d | |||
| 6bb25182c9 | |||
| ceb8f49aae | |||
| 33aae31cb7 | |||
| f8924deb68 | |||
| 9e8c426e6f | |||
| 9815b67c51 | |||
| 496a34a6a7 | |||
| 7c9ebadffe | |||
| e376e7d774 | |||
| d211df88d5 | |||
| 21caf8bf34 | |||
| d3eaaa21a6 | |||
| ad457a2d1c | |||
| fa3ea5b4e5 | |||
| f3396952b6 | |||
| 8736b49d08 | |||
| eec468e488 | |||
| f2af45ee68 | |||
| 25b55febc5 | |||
| c2e50b3b10 | |||
| 6fde592da1 | |||
| 98259d7c46 | |||
| b5a35fc2c7 | |||
| 11a7572bba | |||
| 4c4dc84671 | |||
| 52986eefd5 | |||
| 7a5ffcfee7 | |||
| 334d615a67 | |||
| 0c813e1a9e | |||
| 0de0b85374 | |||
| 78f78ce5ee | |||
| 82ad3f0007 | |||
| 82f094f4d5 | |||
| e1df1d569b | |||
| 19487a6e34 | |||
| 6177fc280f | |||
| 14db51bba7 | |||
| 353de54fcc | |||
| 6a4f93bbaf | |||
| 74fab85ba0 | |||
| 44db2be5f9 | |||
| 3e41233589 | |||
| f36a771389 | |||
| 0447e68073 | |||
| 94dbca3840 |
@@ -57,6 +57,7 @@ rustfs-scanner 1392 20
|
||||
rustfs-scanner-metrics 90 0
|
||||
rustfs-security-governance 20 0
|
||||
rustfs-signer 34 0
|
||||
rustfs-sse 145 0
|
||||
rustfs-storage-api 34 0
|
||||
rustfs-targets 612 26
|
||||
rustfs-test-utils 1 0
|
||||
|
||||
@@ -231,7 +231,7 @@ jobs:
|
||||
# --all-targets links the same test binaries as the reader lane.
|
||||
CARGO_BUILD_JOBS: "2"
|
||||
run: |
|
||||
cargo build -p rustfs -p rustfs-ecstore --all-targets --features rio-v2
|
||||
cargo build -p rustfs -p rustfs-ecstore -p rustfs-sse --all-targets --features rio-v2
|
||||
cargo build -p rustfs --bins --features rio-v2,e2e-test-hooks
|
||||
|
||||
# Readers: the swift and sftp legs of test-and-lint-protocols. Built in
|
||||
|
||||
@@ -563,7 +563,7 @@ jobs:
|
||||
run: chmod go-w "$(realpath "$HOME")"
|
||||
|
||||
- name: Run rio-v2 clippy lints
|
||||
run: cargo clippy -p rustfs -p rustfs-ecstore --all-targets --features rio-v2 -- -D warnings
|
||||
run: cargo clippy -p rustfs -p rustfs-ecstore -p rustfs-sse --all-targets --features rio-v2 -- -D warnings
|
||||
|
||||
- name: Run rio-v2 feature tests
|
||||
shell: bash
|
||||
@@ -580,7 +580,7 @@ jobs:
|
||||
rm -f target/nextest/ci/junit.xml
|
||||
./scripts/ci/resource_sampler.sh start nextest-rio-v2
|
||||
trap './scripts/ci/resource_sampler.sh stop' EXIT
|
||||
cargo nextest run --profile ci -p rustfs -p rustfs-ecstore --features rio-v2 \
|
||||
cargo nextest run --profile ci -p rustfs -p rustfs-ecstore -p rustfs-sse --features rio-v2 \
|
||||
2>&1 | tee artifacts/workspace/nextest.log
|
||||
cargo test -p rustfs --doc --features rio-v2
|
||||
|
||||
|
||||
+1
-1
@@ -94,7 +94,7 @@ refactors.
|
||||
|--------|--------------------------|----------------|
|
||||
| Foundation | `checksums`, `common`, `config`, `data-usage`, `heal-contracts`, `scanner-metrics`, `utils` | Shared configuration, data-usage models, heal domain contracts, scanner telemetry types, utilities, and checksums. |
|
||||
| I/O and storage | `concurrency`, `ecstore`, `filemeta`, `heal`, `io-core`, `io-metrics`, `lifecycle`, `lock`, `object-capacity`, `object-data-cache`, `replication`, `rio`, `rio-v2`, `s3-client`, `scanner`, `storage-api` | Erasure-coded object storage, metadata, recovery, lifecycle, replication, locking, cache, I/O pipelines, and the engine-side S3 client for remote tier/transition targets. |
|
||||
| Security and identity | `credentials`, `crypto`, `iam`, `keystone`, `kms`, `policy`, `security-governance`, `signer`, `tls-runtime`, `trusted-proxies` | Credentials, authentication, authorization, encryption, key management, TLS, and security contracts. |
|
||||
| Security and identity | `credentials`, `crypto`, `iam`, `keystone`, `kms`, `policy`, `security-governance`, `signer`, `sse`, `tls-runtime`, `trusted-proxies` | Credentials, authentication, authorization, encryption, key management, server-side encryption key resolution, TLS, and security contracts. |
|
||||
| Protocols and contracts | `extension-schema`, `madmin`, `protos`, `protocols`, `s3-ops`, `s3-types`, `s3select-api`, `s3select-query` | Admin, inter-node, S3, S3 Select, and optional protocol contracts. |
|
||||
| Operations and integration | `audit`, `notify`, `obs`, `targets`, `zip` | Auditing, observability, event delivery, notification targets, and archive support. |
|
||||
| Test support | `e2e_test`, `test-utils` | End-to-end validation and shared test bootstrap utilities. |
|
||||
|
||||
@@ -116,6 +116,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
||||
- Four-layer regression-prevention tests guard against silent feature deletion: compile-time module assertion, module-presence unit test, cross-module `Protocol` enum assertion, end-to-end SSH banner test against the running binary
|
||||
|
||||
### Changed
|
||||
- **Startup reports the state of `RUSTFS_SSE_S3_MASTER_KEY`**: the server now checks the local SSE-S3 master key when it starts and logs one `sse_local_master_key` event with `state` `loaded`, `not_set`, or `invalid`. An unusable value used to surface only as a `400 InvalidRequest` on the first SSE-S3 request served without a KMS; it is now logged as an error at startup with the reason. Startup still succeeds and request behavior is unchanged. The line "Using RUSTFS_SSE_S3_MASTER_KEY for SSE-S3 (KMS not configured)", logged when the key was first used, is replaced by this event.
|
||||
- **Scanner bucket walkers are no longer tied to the disk count**: a new scanner key `walkers_per_disk` (`RUSTFS_SCANNER_WALKERS_PER_DISK`, `1` through `16`, default `1`) spawns that many bucket walkers per local disk of an erasure set, so a single-disk deployment can walk several buckets at once instead of one bucket, one object at a time. The walkers of one disk share its scanner admission, so a peer still sees one scan session per physical disk, and remote disks keep one walker. The walker count is what `max_concurrent_disk_scans` caps and the disk count stays the floor; the `disk_concurrency_budget` log line now reports `walkers_per_disk`, `walkers`, and the `reason` for the effective limit. The default keeps today's I/O profile because a local disk cannot yet report whether it is rotational; the design intends a higher default on flash once it can (`docs/architecture/scanner-per-bucket-convergence.md`). As groundwork for pacing, the raw-enumeration page writer inserts into its building page in place and commits pages without copying them, and a regression test pins the cost of recording 20,000 entries in one prefix so the quadratic bookkeeping removed by [#8114](https://github.com/rustfs/rustfs/pull/8114) (rustfs#8113) cannot return. No persisted format, protocol or admin API changes beyond the additional config key, which older releases preserve and ignore.
|
||||
- **Encryption and KMS work merged since `1.0.0-rc.5`** (entries were missing from this section):
|
||||
- **Persisted KMS configuration secrets** are sealed field-by-field with `RUSTFS_KMS_CONFIG_SECRET`. **When the variable is unset the secrets are persisted in cleartext and the server only warns** (`persisted KMS configuration carries cleartext secrets`); it never refuses the write. Set it, identically, on every node, and re-save the configuration to seal an existing one.
|
||||
|
||||
Generated
+212
-187
File diff suppressed because it is too large
Load Diff
+24
-19
@@ -60,6 +60,7 @@ members = [
|
||||
"crates/security-governance", # Security governance contracts
|
||||
"crates/extension-schema", # Extension schema contracts
|
||||
"crates/signer", # client signer
|
||||
"crates/sse", # S3 server-side encryption key resolution and metadata
|
||||
"crates/storage-api", # Storage API contracts
|
||||
"crates/test-utils", # Shared test bootstrap helpers (dev-dependency only)
|
||||
"crates/targets", # Target-specific configurations and utilities
|
||||
@@ -140,6 +141,7 @@ rustfs-scanner = { path = "crates/scanner", version = "1.0.5" }
|
||||
rustfs-security-governance = { path = "crates/security-governance", version = "1.0.5" }
|
||||
rustfs-extension-schema = { path = "crates/extension-schema", version = "1.0.5" }
|
||||
rustfs-signer = { path = "crates/signer", version = "1.0.5" }
|
||||
rustfs-sse = { path = "crates/sse", version = "1.0.5" }
|
||||
rustfs-storage-api = { path = "crates/storage-api", version = "1.0.5" }
|
||||
rustfs-trusted-proxies = { path = "crates/trusted-proxies", version = "1.0.5" }
|
||||
rustfs-targets = { path = "crates/targets", version = "1.0.5" }
|
||||
@@ -175,9 +177,9 @@ futures = "0.3.34"
|
||||
futures-core = "0.3.34"
|
||||
futures-lite = "2.6.1"
|
||||
futures-util = "0.3.34"
|
||||
pollster = "1.0.2"
|
||||
pollster = "1.0.3"
|
||||
pulsar = { default-features = false, version = "=6.9.0" }
|
||||
lapin = { default-features = false, version = "4.12.3" }
|
||||
lapin = { default-features = false, version = "4.13.0" }
|
||||
hyper = { version = "1.12.0" }
|
||||
h2 = { version = "0.4.20" }
|
||||
hyper-rustls = { default-features = false, version = "0.27.10" }
|
||||
@@ -216,7 +218,7 @@ csv-core = "0.1.13"
|
||||
bytesize = "2.7.0"
|
||||
byteorder = "1.5.0"
|
||||
flatbuffers = "25.12.19"
|
||||
form_urlencoded = "1.2.2"
|
||||
form_urlencoded = "1.2.3"
|
||||
prost = "0.14.6"
|
||||
quick-xml = "0.42.0"
|
||||
rmp = { version = "0.8.15" }
|
||||
@@ -258,7 +260,7 @@ proptest = "1"
|
||||
# Time and Date
|
||||
chrono = { version = "0.4.45" }
|
||||
humantime = "2.4.0"
|
||||
jiff = { version = "1.0.1" }
|
||||
jiff = { version = "1.0.2" }
|
||||
time = { version = "0.3.55" }
|
||||
|
||||
# Database
|
||||
@@ -278,15 +280,15 @@ atomic_enum = "0.3.0"
|
||||
aws-config = { version = "1.13.3" }
|
||||
aws-credential-types = { version = "1.3.1" }
|
||||
aws-sdk-kms = { default-features = false, version = "1.133.0" }
|
||||
aws-sdk-s3 = { default-features = false, version = "1.160.0" }
|
||||
aws-sdk-sts = { default-features = false, version = "1.127.0" }
|
||||
aws-sdk-s3 = { default-features = false, version = "1.161.0" }
|
||||
aws-sdk-sts = { default-features = false, version = "1.128.0" }
|
||||
aws-smithy-async = { version = "1.3.1" }
|
||||
aws-smithy-http-client = { default-features = false, version = "1.5.3" }
|
||||
aws-smithy-runtime-api = { version = "1.22.0" }
|
||||
aws-smithy-types = { version = "1.9.4" }
|
||||
base64-simd = "0.8.0"
|
||||
brotli = "9.1.3"
|
||||
clap = { version = "4.6.8" }
|
||||
clap = { version = "4.6.9" }
|
||||
const-str = { version = "1.1.0" }
|
||||
convert_case = "0.12.0"
|
||||
criterion = { version = "0.8" }
|
||||
@@ -298,12 +300,12 @@ datafusion = { default-features = false, version = "55.3.0" }
|
||||
derive_builder = "0.20.2"
|
||||
ed25519-dalek = "3.0.0"
|
||||
enumset = "1.1.15"
|
||||
faster-hex = "1.0.0"
|
||||
faster-hex = "2.0.0"
|
||||
flate2 = "1.1.11"
|
||||
glob = "0.3.4"
|
||||
google-cloud-storage = "1.22.0"
|
||||
google-cloud-auth = "1.19.0"
|
||||
hashbrown = { version = "0.17.1" }
|
||||
hashbrown = { version = "0.17.2" }
|
||||
# Base32 for RFC 6238 TOTP shared secrets (RFC 4648 unpadded, the alphabet
|
||||
# every authenticator app expects). Already in the graph transitively.
|
||||
data-encoding = "2.11.1"
|
||||
@@ -337,7 +339,7 @@ percent-encoding = "2.3.2"
|
||||
# CLI needs its own QR encoder. No default features: the image/render backends
|
||||
# pull in an image stack this only needs SVG and text output from.
|
||||
qrcode-rs = { version = "2.2.0", default-features = false, features = ["std", "svg"] }
|
||||
pin-project-lite = "0.2.17"
|
||||
pin-project-lite = "0.2.18"
|
||||
pretty_assertions = "1.4.1"
|
||||
rand = { version = "0.10.4" }
|
||||
ratelimit = "2.0.0"
|
||||
@@ -360,7 +362,7 @@ legacy-s3s = { package = "s3s", git = "https://github.com/s3s-project/s3s", rev
|
||||
serial_test = "4.0.1"
|
||||
shadow-rs = { default-features = false, version = "2.0.0" }
|
||||
siphasher = "1.0.4"
|
||||
smallvec = { version = "1.16.5" }
|
||||
smallvec = { version = "1.16.6" }
|
||||
compact_str = "0.10.0"
|
||||
snap = "1.1.2"
|
||||
starshard = { version = "2.4.1" }
|
||||
@@ -378,23 +380,23 @@ tracing-error = "0.2.1"
|
||||
tracing-opentelemetry = { version = "0.34.0" }
|
||||
tracing-subscriber = { version = "0.3.23" }
|
||||
transform-stream = "0.3.1"
|
||||
url = "2.5.8"
|
||||
url = "2.5.9"
|
||||
urlencoding = "2.1.3"
|
||||
uuid = { version = "1.29.3" }
|
||||
vaultrs = { version = "0.8.0" }
|
||||
tar = "0.4.46"
|
||||
walkdir = "2.5.0"
|
||||
walkdir = "2.5.1"
|
||||
winapi-util = "0.1.11"
|
||||
windows = { version = "0.62.2" }
|
||||
windows-sys = "0.61.2"
|
||||
xxhash-rust = { version = "0.8.21" }
|
||||
zip = "9.7.0"
|
||||
zip = "9.8.1"
|
||||
zstd = "0.14.4"
|
||||
|
||||
# Observability and Metrics
|
||||
metrics = "0.24.6"
|
||||
metrics-util = "0.20"
|
||||
dial9 = { version = "0.5.8", default-features = false }
|
||||
dial9 = { version = "0.5.9", default-features = false }
|
||||
opentelemetry = { version = "0.33.1" }
|
||||
opentelemetry-appender-tracing = { version = "0.33.1" }
|
||||
opentelemetry-otlp = { version = "0.33.1" }
|
||||
@@ -405,12 +407,12 @@ opentelemetry-stdout = { version = "0.33.1" }
|
||||
pyroscope = { version = "2.1.5" }
|
||||
|
||||
# FTP and SFTP
|
||||
libunftp = { version = "0.25.0" }
|
||||
libunftp = { version = "0.25.1" }
|
||||
unftp-core = "0.1.1"
|
||||
suppaftp = { version = "13.0.0" }
|
||||
rcgen = { version = "0.14.10", default-features = false, features = ["aws_lc_rs", "crypto", "pem"] }
|
||||
russh = { version = "0.65.2" }
|
||||
russh-sftp = "3.0.1"
|
||||
russh = { version = "0.65.4" }
|
||||
russh-sftp = "4.0.0"
|
||||
|
||||
# WebDAV
|
||||
dav-server = "0.12.0"
|
||||
@@ -423,7 +425,10 @@ hotpath = { version = "0.32.1", default-features = false }
|
||||
insta = { version = "1.49" }
|
||||
|
||||
[workspace.metadata.cargo-shear]
|
||||
ignored = ["hotpath", "rustfs"]
|
||||
# The `#[path]` test modules under `rustfs/src/server/http/tests/` are linked by
|
||||
# rustc (including the `http.rs` + `http/` sibling-directory rule), but cargo-shear
|
||||
# resolves those nested `#[path]` attributes against the wrong base directory.
|
||||
ignored-paths = ["rustfs/src/server/http/tests/**/*.rs"]
|
||||
|
||||
[profile.dev]
|
||||
# Full debuginfo roughly doubles compile+link time and produces multi-GB
|
||||
|
||||
@@ -15,12 +15,11 @@ workspace = true
|
||||
|
||||
[features]
|
||||
default = []
|
||||
hotpath = ["hotpath/hotpath", "hotpath/tokio", "rustfs-io-core/hotpath"]
|
||||
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc", "rustfs-io-core/hotpath-alloc"]
|
||||
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu", "rustfs-io-core/hotpath-cpu"]
|
||||
hotpath = ["rustfs-io-core/hotpath"]
|
||||
hotpath-alloc = ["hotpath", "rustfs-io-core/hotpath-alloc"]
|
||||
hotpath-cpu = ["hotpath", "rustfs-io-core/hotpath-cpu"]
|
||||
|
||||
[dependencies]
|
||||
hotpath.workspace = true
|
||||
# Internal crates
|
||||
rustfs-io-core = { workspace = true }
|
||||
serde = { workspace = true, features = ["derive"] }
|
||||
|
||||
@@ -183,7 +183,6 @@ rmp.workspace = true
|
||||
rmp-serde.workspace = true
|
||||
tokio-util = { workspace = true, features = ["io", "compat", "rt"] }
|
||||
tokio-stream = { workspace = true, features = ["sync"] }
|
||||
hmac = { workspace = true }
|
||||
sha2 = { workspace = true }
|
||||
hex-simd = { workspace = true }
|
||||
tempfile.workspace = true
|
||||
|
||||
@@ -29,12 +29,11 @@ workspace = true
|
||||
|
||||
[features]
|
||||
default = []
|
||||
hotpath = ["hotpath/hotpath", "hotpath/tokio", "rustfs-io-metrics/hotpath"]
|
||||
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc", "rustfs-io-metrics/hotpath-alloc"]
|
||||
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu", "rustfs-io-metrics/hotpath-cpu"]
|
||||
hotpath = ["rustfs-io-metrics/hotpath"]
|
||||
hotpath-alloc = ["hotpath", "rustfs-io-metrics/hotpath-alloc"]
|
||||
hotpath-cpu = ["hotpath", "rustfs-io-metrics/hotpath-cpu"]
|
||||
|
||||
[dependencies]
|
||||
hotpath.workspace = true
|
||||
bytes = { workspace = true, features = ["serde"] }
|
||||
thiserror = { workspace = true }
|
||||
tokio = { workspace = true, features = ["io-util", "fs", "sync", "rt-multi-thread"] }
|
||||
|
||||
@@ -6,7 +6,8 @@ Applies to `crates/kms/`.
|
||||
|
||||
When changing key-management behavior, verify compatibility with:
|
||||
|
||||
- `rustfs/src/storage/sse.rs`
|
||||
- `crates/sse/` (SSE key resolution; consumes this crate on the data path)
|
||||
- `rustfs/src/storage/sse.rs` (binds `crates/sse/` to the running server)
|
||||
- `rustfs/src/admin/handlers/kms.rs`
|
||||
- `rustfs/src/admin/handlers/kms_dynamic.rs`
|
||||
- `rustfs/src/admin/handlers/kms_keys.rs`
|
||||
|
||||
@@ -410,7 +410,10 @@ impl<S: StorageBackend + Send + Sync + 'static> SftpDriver<S> {
|
||||
}
|
||||
};
|
||||
let handle = self.allocate_handle(HandleState::Dir(cursor))?;
|
||||
Ok(Handle { id, handle })
|
||||
Ok(Handle {
|
||||
id,
|
||||
handle: handle.into(),
|
||||
})
|
||||
}
|
||||
|
||||
/// READDIR body shared with the Handler trait wrapper. Removes the
|
||||
@@ -666,8 +669,11 @@ mod tests {
|
||||
assert_eq!(auth.continuation_token, call.continuation_token);
|
||||
}
|
||||
assert_eq!(authorized[2].continuation_token.as_ref().map(|value| value.as_str()), Some("next-page"));
|
||||
let denied =
|
||||
with_test_auth_override(|_, _, prefix| prefix != Some("private/"), driver.readdir_inner(2, handle.handle)).await;
|
||||
let denied = with_test_auth_override(
|
||||
|_, _, prefix| prefix != Some("private/"),
|
||||
driver.readdir_inner(2, String::from_utf8(handle.handle.into_bytes()).expect("utf8 handle")),
|
||||
)
|
||||
.await;
|
||||
assert!(denied.is_err(), "policy change must deny the next READDIR");
|
||||
assert_eq!(backend.list_objects_calls().len(), 2, "denied READDIR cannot reach storage");
|
||||
}
|
||||
@@ -716,7 +722,7 @@ mod tests {
|
||||
};
|
||||
let handle_id = driver.allocate_handle(HandleState::Dir(cursor)).expect("allocate");
|
||||
|
||||
let readdir_fut = driver.readdir(1, handle_id.clone());
|
||||
let readdir_fut = driver.readdir(1, handle_id.clone().into());
|
||||
|
||||
with_test_auth_override(|_, _, _| true, async {
|
||||
tokio::select! {
|
||||
@@ -758,7 +764,7 @@ mod tests {
|
||||
// token, no skipped entries).
|
||||
backend.clear_stall_list_objects_v2();
|
||||
backend.queue_list_objects_v2_ok_empty();
|
||||
let result = with_test_auth_override(|_, _, _| true, driver.readdir(2, handle_id)).await;
|
||||
let result = with_test_auth_override(|_, _, _| true, driver.readdir(2, handle_id.into())).await;
|
||||
// Empty page returns Eof per readdir's empty-Name-to-Eof translation.
|
||||
let err = result.expect_err("re-issued READDIR against an empty listing must return Eof, not Ok");
|
||||
assert!(
|
||||
@@ -785,7 +791,7 @@ mod tests {
|
||||
let handle_id = driver.allocate_handle(HandleState::Dir(cursor)).expect("allocate");
|
||||
|
||||
let (result, captured) =
|
||||
capture_tracing_at(Level::ERROR, with_test_auth_override(|_, _, _| true, driver.readdir(7, handle_id))).await;
|
||||
capture_tracing_at(Level::ERROR, with_test_auth_override(|_, _, _| true, driver.readdir(7, handle_id.into()))).await;
|
||||
let err = result.expect_err("exhausted cursor must return Eof");
|
||||
assert!(matches!(StatusCode::from(err), StatusCode::Eof));
|
||||
assert!(
|
||||
@@ -818,7 +824,7 @@ mod tests {
|
||||
let handle_id = driver.allocate_handle(HandleState::Dir(cursor)).expect("allocate");
|
||||
|
||||
let (result, captured) =
|
||||
capture_tracing_at(Level::ERROR, with_test_auth_override(|_, _, _| true, driver.readdir(8, handle_id))).await;
|
||||
capture_tracing_at(Level::ERROR, with_test_auth_override(|_, _, _| true, driver.readdir(8, handle_id.into()))).await;
|
||||
let err = result.expect_err("backend error must propagate as Err");
|
||||
assert!(!matches!(StatusCode::from(err), StatusCode::Eof), "backend error must not be Eof");
|
||||
assert!(
|
||||
|
||||
@@ -33,7 +33,9 @@ use super::write::{build_write_tombstone, fstat_reported_size, rejects_excl_or_t
|
||||
use crate::common::client::s3::StorageBackend;
|
||||
use crate::common::gateway::{AuthorizationError, S3Action};
|
||||
use crate::common::session::SessionContext;
|
||||
use russh_sftp::protocol::{Attrs, Data, File, FileAttributes, Handle, Name, OpenFlags, Packet, Status, StatusCode, Version};
|
||||
use russh_sftp::protocol::{
|
||||
Attrs, Data, File, FileAttributes, Handle, Name, OpenFlags, Packet, SftpHandle, Status, StatusCode, Version,
|
||||
};
|
||||
use rustfs_credentials::Credentials;
|
||||
use rustfs_gateway_types::dto::{AbortMultipartUploadInput, CopyObjectInput, ListObjectsV2Input};
|
||||
use rustfs_gateway_types::{BucketName, ObjectKey, UploadIdClaim};
|
||||
@@ -208,6 +210,12 @@ impl<S: StorageBackend + Send + Sync + 'static> SftpDriver<S> {
|
||||
}
|
||||
}
|
||||
|
||||
/// russh-sftp 4 hands the Handler opaque `SftpHandle` bytes; the table
|
||||
/// keys remain the UTF-8 UUID strings this driver mints.
|
||||
fn handle_table_key(handle: SftpHandle) -> Result<String, SftpError> {
|
||||
String::from_utf8(handle.into_bytes()).map_err(|_| SftpError::code(StatusCode::Failure))
|
||||
}
|
||||
|
||||
/// Generate a fresh UUID v4 handle, insert the given state into the
|
||||
/// per-session handle table, and return the handle string. Enforces
|
||||
/// self.handles_per_session before any UUID generation. Cap-exceeded
|
||||
@@ -494,8 +502,9 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
|
||||
/// Streaming returns (next_part_number - 1) * part_size + buffer
|
||||
/// length. Failed returns the size recorded at the most recent
|
||||
/// successful write. An unknown handle returns Failure.
|
||||
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = %handle), err(Debug))]
|
||||
async fn fstat(&mut self, id: u32, handle: String) -> Result<Attrs, Self::Error> {
|
||||
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = ?handle), err(Debug))]
|
||||
async fn fstat(&mut self, id: u32, handle: SftpHandle) -> Result<Attrs, Self::Error> {
|
||||
let handle = Self::handle_table_key(handle)?;
|
||||
self.session_diag.stamp();
|
||||
let part_size = self.part_size;
|
||||
let result = self.with_handle_ref(&handle, |state| match state {
|
||||
@@ -541,8 +550,9 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
|
||||
/// exhaustion, so it is normal control flow on this handler. The
|
||||
/// instrument attribute therefore omits err(Debug) and non-Eof
|
||||
/// failures are surfaced via the explicit error log below.
|
||||
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = %handle))]
|
||||
async fn readdir(&mut self, id: u32, handle: String) -> Result<Name, Self::Error> {
|
||||
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = ?handle))]
|
||||
async fn readdir(&mut self, id: u32, handle: SftpHandle) -> Result<Name, Self::Error> {
|
||||
let handle = Self::handle_table_key(handle)?;
|
||||
self.session_diag.stamp();
|
||||
let result = self.readdir_inner(id, handle.clone()).await;
|
||||
self.session_diag.stamp();
|
||||
@@ -617,8 +627,9 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
|
||||
/// read-past-end-of-file, so it is normal control flow on this
|
||||
/// handler. The instrument attribute therefore omits err(Debug) and
|
||||
/// non-Eof failures are surfaced via the explicit error log below.
|
||||
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = %handle, offset, len))]
|
||||
async fn read(&mut self, id: u32, handle: String, offset: u64, len: u32) -> Result<Data, Self::Error> {
|
||||
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = ?handle, offset, len))]
|
||||
async fn read(&mut self, id: u32, handle: SftpHandle, offset: u64, len: u32) -> Result<Data, Self::Error> {
|
||||
let handle = Self::handle_table_key(handle)?;
|
||||
self.session_diag.stamp();
|
||||
let result = self.read_inner(id, handle.clone(), offset, len).await;
|
||||
self.session_diag.stamp();
|
||||
@@ -650,8 +661,9 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
|
||||
///
|
||||
/// A missing handle is treated as Ok to tolerate clients that
|
||||
/// double-close on session teardown.
|
||||
#[tracing::instrument(level = "info", skip(self), fields(id, handle = %handle), err(Debug))]
|
||||
async fn close(&mut self, id: u32, handle: String) -> Result<Status, Self::Error> {
|
||||
#[tracing::instrument(level = "info", skip(self), fields(id, handle = ?handle), err(Debug))]
|
||||
async fn close(&mut self, id: u32, handle: SftpHandle) -> Result<Status, Self::Error> {
|
||||
let handle = Self::handle_table_key(handle)?;
|
||||
self.session_diag.stamp();
|
||||
let removed = self.handles.remove(&handle);
|
||||
let Some(HandleState::Write {
|
||||
@@ -755,8 +767,9 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
|
||||
/// to Streaming by issuing CreateMultipartUpload. A Failed handle
|
||||
/// rejects every subsequent write with the same status that caused
|
||||
/// the failure.
|
||||
#[tracing::instrument(level = "debug", skip(self, data), fields(id, handle = %handle, offset, len = data.len()), err(Debug))]
|
||||
async fn write(&mut self, id: u32, handle: String, offset: u64, data: Vec<u8>) -> Result<Status, Self::Error> {
|
||||
#[tracing::instrument(level = "debug", skip(self, data), fields(id, handle = ?handle, offset, len = data.len()), err(Debug))]
|
||||
async fn write(&mut self, id: u32, handle: SftpHandle, offset: u64, data: Vec<u8>) -> Result<Status, Self::Error> {
|
||||
let handle = Self::handle_table_key(handle)?;
|
||||
self.session_diag.stamp();
|
||||
self.enforce_server_readonly()?;
|
||||
|
||||
@@ -983,8 +996,8 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
|
||||
/// SSH_FXP_FSETSTAT, SFTP Internet Draft section 6.6. Same rationale
|
||||
/// as setstat: S3 cannot honour POSIX attributes, and clients use
|
||||
/// FSETSTAT during transfers to stamp the in-flight handle.
|
||||
#[tracing::instrument(level = "debug", skip(self, _attrs), fields(id, handle = %_handle), err(Debug))]
|
||||
async fn fsetstat(&mut self, id: u32, _handle: String, _attrs: FileAttributes) -> Result<Status, Self::Error> {
|
||||
#[tracing::instrument(level = "debug", skip(self, _attrs), fields(id, handle = ?_handle), err(Debug))]
|
||||
async fn fsetstat(&mut self, id: u32, _handle: SftpHandle, _attrs: FileAttributes) -> Result<Status, Self::Error> {
|
||||
self.enforce_server_readonly()?;
|
||||
Ok(ok_status(id))
|
||||
}
|
||||
@@ -1254,7 +1267,7 @@ mod tests {
|
||||
let handle_id = driver
|
||||
.allocate_handle(file_handle("bucket", "k", 1234, attrs.clone()))
|
||||
.expect("allocate");
|
||||
let out = driver.fstat(4, handle_id).await.expect("fstat on File must succeed");
|
||||
let out = driver.fstat(4, handle_id.into()).await.expect("fstat on File must succeed");
|
||||
assert_eq!(out.attrs.size, Some(1234));
|
||||
assert_eq!(out.attrs.mtime, Some(1_700_000_000));
|
||||
}
|
||||
@@ -1267,7 +1280,7 @@ mod tests {
|
||||
part_buffer: vec![0u8; 4096],
|
||||
};
|
||||
let handle_id = driver.allocate_handle(write_handle("bucket", "k", phase)).expect("allocate");
|
||||
let out = driver.fstat(5, handle_id).await.expect("fstat on Write must succeed");
|
||||
let out = driver.fstat(5, handle_id.into()).await.expect("fstat on Write must succeed");
|
||||
assert_eq!(
|
||||
out.attrs.size,
|
||||
Some(4096),
|
||||
@@ -1283,7 +1296,7 @@ mod tests {
|
||||
.allocate_handle(file_handle("bucket", "k", 0, FileAttributes::default()))
|
||||
.expect("allocate");
|
||||
let status = driver
|
||||
.fsetstat(6, handle_id, FileAttributes::default())
|
||||
.fsetstat(6, handle_id.into(), FileAttributes::default())
|
||||
.await
|
||||
.expect("fsetstat must succeed on any attrs");
|
||||
assert!(matches!(status.status_code, StatusCode::Ok));
|
||||
@@ -1417,7 +1430,7 @@ mod tests {
|
||||
let handle_id = driver
|
||||
.allocate_handle(file_handle("bucket", "k", 0, FileAttributes::default()))
|
||||
.expect("allocate");
|
||||
let result = driver.fsetstat(10, handle_id, FileAttributes::default()).await;
|
||||
let result = driver.fsetstat(10, handle_id.into(), FileAttributes::default()).await;
|
||||
match result {
|
||||
Err(err) => assert!(matches!(err.0, StatusCode::PermissionDenied)),
|
||||
Ok(_) => panic!("fsetstat must error in read-only mode"),
|
||||
|
||||
@@ -69,7 +69,10 @@ impl<S: StorageBackend + Send + Sync + 'static> SftpDriver<S> {
|
||||
attrs,
|
||||
read_cache,
|
||||
})?;
|
||||
Ok(Handle { id, handle })
|
||||
Ok(Handle {
|
||||
id,
|
||||
handle: handle.into(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Body of the SSH_FXP_READ handler. Returns up to len bytes starting
|
||||
@@ -256,7 +259,7 @@ mod tests {
|
||||
.allocate_handle(file_handle("bucket", "secret.txt", 4096, FileAttributes::default()))
|
||||
.expect("allocate read handle");
|
||||
driver.try_populate_read_cache(&handle, 0, vec![42; 4096]);
|
||||
let error = with_test_auth_override(|_, _, _| true, driver.read(1, handle, 0, 1024))
|
||||
let error = with_test_auth_override(|_, _, _| true, driver.read(1, handle.into(), 0, 1024))
|
||||
.await
|
||||
.expect_err("backend policy denial must prevent cached content disclosure");
|
||||
assert!(matches!(StatusCode::from(error), StatusCode::PermissionDenied));
|
||||
@@ -270,7 +273,7 @@ mod tests {
|
||||
.allocate_handle(file_handle("bucket", "k", 100, FileAttributes::default()))
|
||||
.expect("allocate");
|
||||
let err = driver
|
||||
.read(1, handle_id, 0, 0)
|
||||
.read(1, handle_id.into(), 0, 0)
|
||||
.await
|
||||
.expect_err("len=0 must return BadMessage");
|
||||
assert!(matches!(StatusCode::from(err), StatusCode::BadMessage));
|
||||
@@ -284,7 +287,7 @@ mod tests {
|
||||
.allocate_handle(file_handle("bucket", "k", 10, FileAttributes::default()))
|
||||
.expect("allocate");
|
||||
let err = driver
|
||||
.read(2, handle_id, 10, 4)
|
||||
.read(2, handle_id.into(), 10, 4)
|
||||
.await
|
||||
.expect_err("offset==size must return Eof");
|
||||
assert!(matches!(StatusCode::from(err), StatusCode::Eof));
|
||||
@@ -299,7 +302,7 @@ mod tests {
|
||||
.allocate_handle(file_handle("bucket", "k", 5, FileAttributes::default()))
|
||||
.expect("allocate");
|
||||
|
||||
let data = with_test_auth_override(|_, _, _| true, driver.read(3, handle_id, 0, 1024))
|
||||
let data = with_test_auth_override(|_, _, _| true, driver.read(3, handle_id.into(), 0, 1024))
|
||||
.await
|
||||
.expect("read must succeed");
|
||||
assert_eq!(data.data, b"hello".to_vec());
|
||||
@@ -317,7 +320,7 @@ mod tests {
|
||||
.allocate_handle(file_handle("bucket", "k", 10, FileAttributes::default()))
|
||||
.expect("allocate");
|
||||
|
||||
let (result, captured) = capture_tracing_at(Level::ERROR, async { driver.read(11, handle_id, 10, 4).await }).await;
|
||||
let (result, captured) = capture_tracing_at(Level::ERROR, async { driver.read(11, handle_id.into(), 10, 4).await }).await;
|
||||
let err = result.expect_err("offset==size must return Eof");
|
||||
assert!(matches!(StatusCode::from(err), StatusCode::Eof));
|
||||
assert!(
|
||||
@@ -342,8 +345,11 @@ mod tests {
|
||||
.allocate_handle(file_handle("bucket", "k", 1024, FileAttributes::default()))
|
||||
.expect("allocate");
|
||||
|
||||
let (result, captured) =
|
||||
capture_tracing_at(Level::ERROR, with_test_auth_override(|_, _, _| true, driver.read(12, handle_id, 0, 256))).await;
|
||||
let (result, captured) = capture_tracing_at(
|
||||
Level::ERROR,
|
||||
with_test_auth_override(|_, _, _| true, driver.read(12, handle_id.into(), 0, 256)),
|
||||
)
|
||||
.await;
|
||||
let err = result.expect_err("backend error must propagate as Err");
|
||||
assert!(!matches!(StatusCode::from(err), StatusCode::Eof), "backend error must not be Eof");
|
||||
assert!(
|
||||
@@ -379,7 +385,7 @@ mod tests {
|
||||
let start = Instant::now();
|
||||
let outcome = tokio::time::timeout(
|
||||
Duration::from_secs(10),
|
||||
with_test_auth_override(|_, _, _| true, driver.read(14, handle_id, 0, 4096)),
|
||||
with_test_auth_override(|_, _, _| true, driver.read(14, handle_id.into(), 0, 4096)),
|
||||
)
|
||||
.await;
|
||||
let elapsed = start.elapsed();
|
||||
@@ -425,7 +431,7 @@ mod tests {
|
||||
let mut assembled: Vec<u8> = Vec::with_capacity(object_size as usize);
|
||||
let mut reads: u32 = 0;
|
||||
while offset < object_size {
|
||||
let data = with_test_auth_override(|_, _, _| true, driver.read(20 + reads, handle_id.clone(), offset, chunk))
|
||||
let data = with_test_auth_override(|_, _, _| true, driver.read(20 + reads, handle_id.clone().into(), offset, chunk))
|
||||
.await
|
||||
.expect("read inside the cached window must succeed without a second backend call");
|
||||
assert!(!data.data.is_empty(), "non-empty hit");
|
||||
@@ -461,21 +467,21 @@ mod tests {
|
||||
.expect("allocate");
|
||||
|
||||
// First read fetches from the backend and populates window 1.
|
||||
let r1 = with_test_auth_override(|_, _, _| true, driver.read(30, handle_id.clone(), 0, 1024))
|
||||
let r1 = with_test_auth_override(|_, _, _| true, driver.read(30, handle_id.clone().into(), 0, 1024))
|
||||
.await
|
||||
.expect("first read must succeed");
|
||||
assert!(r1.data.iter().all(|b| *b == 0xAA), "first read must come from window 1");
|
||||
|
||||
// Second read inside the cached chunk is served from the
|
||||
// buffer. No second backend call yet.
|
||||
let r2 = with_test_auth_override(|_, _, _| true, driver.read(31, handle_id.clone(), 1024, 1024))
|
||||
let r2 = with_test_auth_override(|_, _, _| true, driver.read(31, handle_id.clone().into(), 1024, 1024))
|
||||
.await
|
||||
.expect("mid-window read must succeed from cache");
|
||||
assert!(r2.data.iter().all(|b| *b == 0xAA), "mid-window read still in window 1");
|
||||
|
||||
// Reading at offset == window falls outside the cached chunk
|
||||
// and triggers the second backend call.
|
||||
let r3 = with_test_auth_override(|_, _, _| true, driver.read(32, handle_id.clone(), window, 1024))
|
||||
let r3 = with_test_auth_override(|_, _, _| true, driver.read(32, handle_id.clone().into(), window, 1024))
|
||||
.await
|
||||
.expect("read at offset=window must succeed via second backend call");
|
||||
assert!(r3.data.iter().all(|b| *b == 0xBB), "read at window boundary must come from window 2");
|
||||
@@ -483,7 +489,7 @@ mod tests {
|
||||
// A read inside the second cached chunk is served from the
|
||||
// buffer. The queue is empty by now, so any third backend
|
||||
// call would fail.
|
||||
let r4 = with_test_auth_override(|_, _, _| true, driver.read(33, handle_id, window + 1024, 1024))
|
||||
let r4 = with_test_auth_override(|_, _, _| true, driver.read(33, handle_id.into(), window + 1024, 1024))
|
||||
.await
|
||||
.expect("mid-window-2 read must succeed from cache");
|
||||
assert!(r4.data.iter().all(|b| *b == 0xBB), "mid-window-2 read still in window 2");
|
||||
@@ -511,13 +517,13 @@ mod tests {
|
||||
.expect("allocate");
|
||||
|
||||
// Populate window 1 with a full read.
|
||||
let _ = with_test_auth_override(|_, _, _| true, driver.read(40, handle_id.clone(), 0, window as u32))
|
||||
let _ = with_test_auth_override(|_, _, _| true, driver.read(40, handle_id.clone().into(), 0, window as u32))
|
||||
.await
|
||||
.expect("populate window 1");
|
||||
|
||||
// Ask for 256 bytes starting 64 bytes before window end. Only
|
||||
// 64 bytes are in the window. The driver must return 64.
|
||||
let edge = with_test_auth_override(|_, _, _| true, driver.read(41, handle_id, window - 64, 256))
|
||||
let edge = with_test_auth_override(|_, _, _| true, driver.read(41, handle_id.into(), window - 64, 256))
|
||||
.await
|
||||
.expect("partial-hit read must succeed");
|
||||
assert_eq!(edge.data.len(), 64, "partial hit must return only the in-window portion");
|
||||
@@ -552,9 +558,10 @@ mod tests {
|
||||
|
||||
for i in 0..read_count {
|
||||
let offset = (chunk_size as u64) * (i as u64);
|
||||
let data = with_test_auth_override(|_, _, _| true, driver.read(50 + i, handle_id.clone(), offset, chunk_size as u32))
|
||||
.await
|
||||
.expect("each read must succeed via the backend");
|
||||
let data =
|
||||
with_test_auth_override(|_, _, _| true, driver.read(50 + i, handle_id.clone().into(), offset, chunk_size as u32))
|
||||
.await
|
||||
.expect("each read must succeed via the backend");
|
||||
assert_eq!(data.data.len(), chunk_size, "read must return full requested length");
|
||||
let expected_byte = (i + 1) as u8;
|
||||
assert!(
|
||||
|
||||
@@ -336,7 +336,10 @@ impl<S: StorageBackend + Send + Sync + 'static> SftpDriver<S> {
|
||||
open_attrs,
|
||||
phase: WritePhase::Buffering { part_buffer: Vec::new() },
|
||||
})?;
|
||||
Ok(Handle { id, handle })
|
||||
Ok(Handle {
|
||||
id,
|
||||
handle: handle.into(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Upload the buffered bytes to S3 with a single PutObject call.
|
||||
@@ -2105,7 +2108,7 @@ mod tests {
|
||||
)
|
||||
.await
|
||||
.expect("WRITE | CREATE | TRUNCATE on a missing file must allocate a handle");
|
||||
assert!(!handle.handle.is_empty());
|
||||
assert!(!handle.handle.as_bytes().is_empty());
|
||||
assert!(backend.head_object_calls().is_empty(), "the non-EXCL accept path must not HEAD");
|
||||
}
|
||||
|
||||
@@ -2130,7 +2133,7 @@ mod tests {
|
||||
)
|
||||
.await
|
||||
.expect("WRITE | CREATE | TRUNCATE on an existing file must allocate a handle");
|
||||
assert!(!handle.handle.is_empty());
|
||||
assert!(!handle.handle.as_bytes().is_empty());
|
||||
assert!(backend.head_object_calls().is_empty(), "the non-EXCL accept path must not HEAD");
|
||||
}
|
||||
|
||||
@@ -2177,7 +2180,7 @@ mod tests {
|
||||
)
|
||||
.await
|
||||
.expect("EXCL on a missing key must allow creation");
|
||||
assert!(!handle.handle.is_empty());
|
||||
assert!(!handle.handle.as_bytes().is_empty());
|
||||
assert_eq!(backend.head_object_calls().len(), 1, "EXCL must HEAD exactly once");
|
||||
}
|
||||
|
||||
|
||||
@@ -38,8 +38,6 @@ default = []
|
||||
# event. Requires `RUSTFLAGS="--cfg hyper_unstable_tracing"`.
|
||||
diagnostic-internode-http2-ping = ["dep:hyper", "rustfs-io-metrics/diagnostic-internode-http2-ping"]
|
||||
hotpath = [
|
||||
"hotpath/hotpath",
|
||||
"hotpath/tokio",
|
||||
"rustfs-common/hotpath",
|
||||
"rustfs-config/hotpath",
|
||||
"rustfs-io-metrics/hotpath",
|
||||
@@ -48,7 +46,6 @@ hotpath = [
|
||||
]
|
||||
hotpath-alloc = [
|
||||
"hotpath",
|
||||
"hotpath/hotpath-alloc",
|
||||
"rustfs-common/hotpath-alloc",
|
||||
"rustfs-config/hotpath-alloc",
|
||||
"rustfs-io-metrics/hotpath-alloc",
|
||||
@@ -57,7 +54,6 @@ hotpath-alloc = [
|
||||
]
|
||||
hotpath-cpu = [
|
||||
"hotpath",
|
||||
"hotpath/hotpath-cpu",
|
||||
"rustfs-common/hotpath-cpu",
|
||||
"rustfs-config/hotpath-cpu",
|
||||
"rustfs-io-metrics/hotpath-cpu",
|
||||
@@ -66,7 +62,6 @@ hotpath-cpu = [
|
||||
]
|
||||
|
||||
[dependencies]
|
||||
hotpath.workspace = true
|
||||
rustfs-common.workspace = true
|
||||
rustfs-heal-contracts.workspace = true
|
||||
rustfs-io-metrics.workspace = true
|
||||
|
||||
@@ -31,29 +31,24 @@ workspace = true
|
||||
[features]
|
||||
default = []
|
||||
hotpath = [
|
||||
"hotpath/hotpath",
|
||||
"hotpath/tokio",
|
||||
"rustfs-rio/hotpath",
|
||||
"rustfs-utils/hotpath",
|
||||
"rustfs-filemeta/hotpath",
|
||||
]
|
||||
hotpath-alloc = [
|
||||
"hotpath",
|
||||
"hotpath/hotpath-alloc",
|
||||
"rustfs-rio/hotpath-alloc",
|
||||
"rustfs-utils/hotpath-alloc",
|
||||
"rustfs-filemeta/hotpath-alloc",
|
||||
]
|
||||
hotpath-cpu = [
|
||||
"hotpath",
|
||||
"hotpath/hotpath-cpu",
|
||||
"rustfs-rio/hotpath-cpu",
|
||||
"rustfs-utils/hotpath-cpu",
|
||||
"rustfs-filemeta/hotpath-cpu",
|
||||
]
|
||||
|
||||
[dependencies]
|
||||
hotpath.workspace = true
|
||||
aes-gcm = { workspace = true, features = ["rand_core"] }
|
||||
bytes = { workspace = true, features = ["serde"] }
|
||||
chacha20poly1305.workspace = true
|
||||
|
||||
@@ -32,6 +32,7 @@ workspace = true
|
||||
internode-transport = []
|
||||
default = []
|
||||
hotpath = [
|
||||
"dep:hotpath",
|
||||
"hotpath/hotpath",
|
||||
"hotpath/tokio",
|
||||
"hotpath/futures",
|
||||
@@ -59,7 +60,8 @@ hotpath-cpu = [
|
||||
]
|
||||
|
||||
[dependencies]
|
||||
hotpath.workspace = true
|
||||
# Feature-gated in src (measure_block!); optional so default builds do not warn.
|
||||
hotpath = { workspace = true, optional = true }
|
||||
arc-swap.workspace = true
|
||||
tokio = { workspace = true, features = ["io-util", "macros", "net", "rt-multi-thread", "sync", "time"] }
|
||||
rand = { workspace = true, features = ["serde"] }
|
||||
@@ -79,7 +81,6 @@ rustfs-io-metrics.workspace = true
|
||||
rustfs-tls-runtime.workspace = true
|
||||
rustfs-utils = { workspace = true, features = ["io", "hash", "compress"] }
|
||||
serde_json = { workspace = true, features = ["raw_value"] }
|
||||
md-5 = { workspace = true }
|
||||
hmac.workspace = true
|
||||
minlz.workspace = true
|
||||
tracing.workspace = true
|
||||
@@ -91,6 +92,7 @@ xxhash-rust = { workspace = true, features = ["xxh64", "xxh3"] }
|
||||
hex-simd.workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
md-5 = { workspace = true }
|
||||
faster-hex.workspace = true
|
||||
rcgen.workspace = true
|
||||
tokio-rustls.workspace = true
|
||||
|
||||
@@ -15,6 +15,30 @@
|
||||
use super::*;
|
||||
use crate::data_usage_define::{DATA_USAGE_OBJ_NAME_PATH, read_config_with_revision};
|
||||
|
||||
// Two-pool EC fixtures keep many scan futures live at once and overflow
|
||||
// Linux libtest's default 2 MiB test-thread stack. Run each case on a
|
||||
// dedicated 32 MiB thread (same approach as scoped_entry_fallback).
|
||||
fn run_cohort_test<F, Fut>(thread_name: &'static str, test_fn: F)
|
||||
where
|
||||
F: FnOnce() -> Fut + Send + 'static,
|
||||
Fut: std::future::Future<Output = ()> + 'static,
|
||||
{
|
||||
let handle = std::thread::Builder::new()
|
||||
.name(thread_name.to_string())
|
||||
.stack_size(32 * 1024 * 1024)
|
||||
.spawn(move || {
|
||||
let runtime = tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()
|
||||
.expect("service cohort test runtime should build");
|
||||
runtime.block_on(test_fn());
|
||||
})
|
||||
.expect("service cohort test thread should spawn");
|
||||
if let Err(payload) = handle.join() {
|
||||
std::panic::resume_unwind(payload);
|
||||
}
|
||||
}
|
||||
|
||||
async fn create_cohort_bucket(store: &ECStore, bucket: &str) {
|
||||
create_cohort_bucket_objects(store, bucket, 1).await;
|
||||
}
|
||||
@@ -104,9 +128,16 @@ async fn run_cohort_cycle(
|
||||
(result, usage)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn service_cohort_production_dispatch_services_waiters_across_sources() {
|
||||
fn service_cohort_production_dispatch_services_waiters_across_sources() {
|
||||
run_cohort_test(
|
||||
"cohort-prod-disp",
|
||||
service_cohort_production_dispatch_services_waiters_across_sources_case,
|
||||
);
|
||||
}
|
||||
|
||||
async fn service_cohort_production_dispatch_services_waiters_across_sources_case() {
|
||||
let (_dir, store) = setup_two_pool_scanner_store().await;
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
let hot = format!("a-hot-{}", Uuid::new_v4().simple());
|
||||
@@ -197,9 +228,16 @@ async fn service_cohort_production_dispatch_services_waiters_across_sources() {
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn service_cohort_flat_bucket_budget_does_not_publish_unscanned_small_bucket() {
|
||||
fn service_cohort_flat_bucket_budget_does_not_publish_unscanned_small_bucket() {
|
||||
run_cohort_test(
|
||||
"cohort-flat-bud",
|
||||
service_cohort_flat_bucket_budget_does_not_publish_unscanned_small_bucket_case,
|
||||
);
|
||||
}
|
||||
|
||||
async fn service_cohort_flat_bucket_budget_does_not_publish_unscanned_small_bucket_case() {
|
||||
let (_dir, store) = setup_two_pool_scanner_store().await;
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
let flat = format!("a-flat-{}", Uuid::new_v4().simple());
|
||||
@@ -283,9 +321,16 @@ async fn service_cohort_flat_bucket_budget_does_not_publish_unscanned_small_buck
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn service_cohort_fresh_complete_aggregate_preserves_reordered_sources() {
|
||||
fn service_cohort_fresh_complete_aggregate_preserves_reordered_sources() {
|
||||
run_cohort_test(
|
||||
"cohort-fresh-agg",
|
||||
service_cohort_fresh_complete_aggregate_preserves_reordered_sources_case,
|
||||
);
|
||||
}
|
||||
|
||||
async fn service_cohort_fresh_complete_aggregate_preserves_reordered_sources_case() {
|
||||
let (_dir, store) = setup_two_pool_scanner_store().await;
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
for bucket in ["cohort-first", "cohort-second"] {
|
||||
@@ -329,9 +374,16 @@ async fn service_cohort_fresh_complete_aggregate_preserves_reordered_sources() {
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn service_cohort_cancelled_dispatch_does_not_consume_waiters_or_leak_permits() {
|
||||
fn service_cohort_cancelled_dispatch_does_not_consume_waiters_or_leak_permits() {
|
||||
run_cohort_test(
|
||||
"cohort-cancelled",
|
||||
service_cohort_cancelled_dispatch_does_not_consume_waiters_or_leak_permits_case,
|
||||
);
|
||||
}
|
||||
|
||||
async fn service_cohort_cancelled_dispatch_does_not_consume_waiters_or_leak_permits_case() {
|
||||
let (_dir, store) = setup_two_pool_scanner_store().await;
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
let bucket = format!("cancel-{}", Uuid::new_v4().simple());
|
||||
@@ -360,9 +412,16 @@ async fn service_cohort_cancelled_dispatch_does_not_consume_waiters_or_leak_perm
|
||||
/// N=17, q=4: every bucket reaches a worker within ceil(17/4)=5 rounds while
|
||||
/// one bucket stays hot and another fails forever, with leader-local state
|
||||
/// discarded after each round as a restart would.
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn cold_bucket_service_bound_survives_restart_with_hot_and_failing_bucket() {
|
||||
fn cold_bucket_service_bound_survives_restart_with_hot_and_failing_bucket() {
|
||||
run_cohort_test(
|
||||
"cold-svc-bound",
|
||||
cold_bucket_service_bound_survives_restart_with_hot_and_failing_bucket_case,
|
||||
);
|
||||
}
|
||||
|
||||
async fn cold_bucket_service_bound_survives_restart_with_hot_and_failing_bucket_case() {
|
||||
const BUCKETS: usize = 17;
|
||||
const QUANTA: u64 = 4;
|
||||
const ROUND_BOUND: usize = 5;
|
||||
@@ -434,9 +493,16 @@ fn quantum_budget(quantum: crate::scanner_budget::ScannerBucketQuantum) -> Arc<S
|
||||
)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn source_turn_dispatch_rotates_real_sources_and_retains_completed_roots() {
|
||||
fn source_turn_dispatch_rotates_real_sources_and_retains_completed_roots() {
|
||||
run_cohort_test(
|
||||
"src-turn-disp",
|
||||
source_turn_dispatch_rotates_real_sources_and_retains_completed_roots_case,
|
||||
);
|
||||
}
|
||||
|
||||
async fn source_turn_dispatch_rotates_real_sources_and_retains_completed_roots_case() {
|
||||
let mut evidence = None;
|
||||
temp_env::async_with_vars([(ENV_SCANNER_MAX_CONCURRENT_SET_SCANS, Some("1"))], async {
|
||||
crate::runtime_config::refresh_scanner_runtime_config_for_tests();
|
||||
@@ -503,9 +569,16 @@ async fn source_turn_dispatch_rotates_real_sources_and_retains_completed_roots()
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn source_turn_zero_new_frontier_stops_requeuing_without_starving_other_sources() {
|
||||
fn source_turn_zero_new_frontier_stops_requeuing_without_starving_other_sources() {
|
||||
run_cohort_test(
|
||||
"src-turn-zero",
|
||||
source_turn_zero_new_frontier_stops_requeuing_without_starving_other_sources_case,
|
||||
);
|
||||
}
|
||||
|
||||
async fn source_turn_zero_new_frontier_stops_requeuing_without_starving_other_sources_case() {
|
||||
temp_env::async_with_vars([(ENV_SCANNER_MAX_CONCURRENT_SET_SCANS, Some("1"))], async {
|
||||
crate::runtime_config::refresh_scanner_runtime_config_for_tests();
|
||||
let (_dir, store) = setup_two_pool_scanner_store().await;
|
||||
@@ -533,9 +606,13 @@ async fn source_turn_zero_new_frontier_stops_requeuing_without_starving_other_so
|
||||
crate::runtime_config::refresh_scanner_runtime_config_for_tests();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn fair_prefix_quantum_spent_bucket_returns_behind_waiting_buckets() {
|
||||
fn fair_prefix_quantum_spent_bucket_returns_behind_waiting_buckets() {
|
||||
run_cohort_test("fair-spent-qm", fair_prefix_quantum_spent_bucket_returns_behind_waiting_buckets_case);
|
||||
}
|
||||
|
||||
async fn fair_prefix_quantum_spent_bucket_returns_behind_waiting_buckets_case() {
|
||||
let (_dir, store) = setup_local_scanner_store(1, 4).await;
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
create_cohort_bucket_objects(&store, "a-flat", 6).await;
|
||||
@@ -565,9 +642,13 @@ async fn fair_prefix_quantum_spent_bucket_returns_behind_waiting_buckets() {
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn fair_prefix_quantum_without_durable_motion_ends_the_bucket_turn() {
|
||||
fn fair_prefix_quantum_without_durable_motion_ends_the_bucket_turn() {
|
||||
run_cohort_test("fair-no-motion", fair_prefix_quantum_without_durable_motion_ends_the_bucket_turn_case);
|
||||
}
|
||||
|
||||
async fn fair_prefix_quantum_without_durable_motion_ends_the_bucket_turn_case() {
|
||||
let (_dir, store) = setup_local_scanner_store(1, 4).await;
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
create_cohort_bucket_objects(&store, "a-flat", 6).await;
|
||||
@@ -590,9 +671,16 @@ async fn fair_prefix_quantum_without_durable_motion_ends_the_bucket_turn() {
|
||||
|
||||
/// A one-object share stops inside its first child, so the frontier never
|
||||
/// moves. Requeuing that bucket would spin until the cycle deadline.
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn fair_prefix_quantum_repeated_share_without_a_new_frontier_stops_requeuing() {
|
||||
fn fair_prefix_quantum_repeated_share_without_a_new_frontier_stops_requeuing() {
|
||||
run_cohort_test(
|
||||
"fair-rep-share",
|
||||
fair_prefix_quantum_repeated_share_without_a_new_frontier_stops_requeuing_case,
|
||||
);
|
||||
}
|
||||
|
||||
async fn fair_prefix_quantum_repeated_share_without_a_new_frontier_stops_requeuing_case() {
|
||||
let (_dir, store) = setup_local_scanner_store(1, 4).await;
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
create_cohort_bucket_objects(&store, "a-flat", 3).await;
|
||||
@@ -613,9 +701,16 @@ async fn fair_prefix_quantum_repeated_share_without_a_new_frontier_stops_requeui
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[test]
|
||||
#[serial]
|
||||
async fn cold_bucket_service_saved_order_keeps_coverage_and_rejects_older_owners() {
|
||||
fn cold_bucket_service_saved_order_keeps_coverage_and_rejects_older_owners() {
|
||||
run_cohort_test(
|
||||
"cold-saved-ord",
|
||||
cold_bucket_service_saved_order_keeps_coverage_and_rejects_older_owners_case,
|
||||
);
|
||||
}
|
||||
|
||||
async fn cold_bucket_service_saved_order_keeps_coverage_and_rejects_older_owners_case() {
|
||||
let (_dir, store) = setup_local_scanner_store(1, 4).await;
|
||||
clear_dirty_usage_buckets_for_tests();
|
||||
create_cohort_bucket(&store, "cold-only").await;
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
# SSE Crate Instructions
|
||||
|
||||
Applies to `crates/sse/`.
|
||||
|
||||
## Boundary
|
||||
|
||||
- This crate sits between the S3 layer and the storage engine and depends on neither. Its `rustfs-*` dependencies are pinned by `scripts/check_architecture_migration_rules.sh` to `rustfs-config`, `rustfs-kms`, `rustfs-policy`, `rustfs-s3-types`, and `rustfs-utils`; see [crate boundaries](../../docs/architecture/crate-boundaries.md).
|
||||
- Anything the crate needs from the running server arrives through `SseHost` (`src/host.rs`), passed as the first argument of every entry point that consults the server. Do not add a global that stands in for the host: a caller must not be able to reach key selection without naming the server it speaks for.
|
||||
- Translation to and from storage-engine types (`ObjectEncryptionResolver`, `WriteEncryption`, `MultipartCompletionAuthorization`) and request types belongs in `rustfs/src/storage/sse.rs`, not here.
|
||||
- Report failures as `SseError`, classified with the S3 error code the caller answers with. A failure that did not originate from the request goes through `SseError::internal`, which keeps its detail out of the response.
|
||||
|
||||
## Layout
|
||||
|
||||
- `src/startup.rs` settles the state that is fixed for the lifetime of the process and reports it. Nothing that follows the KMS service state belongs there: the service follows configuration and can be started, restarted, or stopped from the admin API, so every choice that depends on it is made per request.
|
||||
- `src/core/` holds the entry points (`write.rs`, `read.rs`, `rewrap.rs`) and the request principal (`request.rs`). An entry point only orders the steps; the decisions live in the two layers below it.
|
||||
- `src/core/s3/` is what S3 defines: the SSE headers of a request and a response, the scheme a write or a stored object resolves to, the SSE-C checks, and the authorization of a KMS key.
|
||||
- `src/core/keying/` is how RustFS forms, seals, and records an object's key. `direct.rs` and `object.rs` are the two modes, and each owns both directions of its stored record: the code that writes a key's metadata sits next to the code that reads it back. `mod.rs` is the only place that says which mode a build writes; `stored.rs` holds the order in which a read recognizes the modes and picks the provider that unwraps the data key; `metadata.rs` records the scheme and lists every stored key name.
|
||||
- `src/kms/` holds the data-key providers: they wrap and unwrap a data key and decide nothing about schemes. The write and rewrap entry points, `core/keying/stored.rs`, and the startup check of the local master key call them; `core/s3/` never does.
|
||||
|
||||
Rules that keep the layers apart:
|
||||
|
||||
- `core/keying/` never imports from `core/s3/`. `core/s3/` reads stored metadata only through `core/keying/metadata.rs`. Anything else that needs both layers is joined in an entry point.
|
||||
- `#[cfg(feature = "rio-v2")]` appears only under `core/keying/` and `kms/`. An entry point or `core/s3/` that needs a build-dependent answer asks `core/keying/` for it.
|
||||
- A new stored format, including a MinIO-compatible one, is added under `core/keying/` (and `kms/` when it brings its own wrapping) without changes under `core/s3/`: a mode file with its record and read functions, one entry in the recognition order of `stored.rs`, and its key names in the lists of `metadata.rs`.
|
||||
- A read decides from what the object recorded. The scheme a request advertises and whether a KMS is running now are write policy and runtime state; neither says how an existing object was keyed.
|
||||
|
||||
## Security
|
||||
|
||||
- Never log plaintext customer keys, decrypted key material, data-key envelopes, nonces, or SSE request payloads, including through error strings and `Debug` output.
|
||||
- KMS audit tags may carry only the fields documented on `KmsRequestAuditState`.
|
||||
- The `test-util` feature exposes authorization overrides and DEK-provider injection. It is a dev-dependency feature only; never enable it from a normal dependency.
|
||||
|
||||
## Change Coordination
|
||||
|
||||
When changing key resolution, metadata, or error classification, verify compatibility with:
|
||||
|
||||
- `rustfs/src/storage/sse.rs` (the host implementation and the engine-boundary adapters)
|
||||
- `crates/kms/`
|
||||
- `crates/utils/src/http/object_encryption_keys.rs` (the stored-metadata key vocabulary)
|
||||
- `rustfs/src/kms_rekey.rs` and `rustfs/src/admin/handlers/kms*.rs`
|
||||
|
||||
## Testing
|
||||
|
||||
Run both builds; the `rio-v2` feature swaps the object-key scheme and compiles different code paths:
|
||||
|
||||
```bash
|
||||
cargo nextest run -p rustfs-sse --no-tests fail
|
||||
cargo nextest run -p rustfs-sse --features rio-v2 --no-tests fail
|
||||
```
|
||||
|
||||
The adapter tests live with the adapter:
|
||||
|
||||
```bash
|
||||
cargo nextest run -p rustfs --no-tests fail -E 'test(/^storage::sse::/)'
|
||||
```
|
||||
|
||||
A change that should leave client-visible behavior or the stored form untouched (a refactor, a move between layers) is checked against a real server: run `scripts/test/sse_blackbox/` on the binary before and after the change, compare the two runs, and cross-read their data directories. Its README has the commands.
|
||||
@@ -0,0 +1,70 @@
|
||||
# Copyright 2024 RustFS Team
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
[package]
|
||||
name = "rustfs-sse"
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
repository.workspace = true
|
||||
rust-version.workspace = true
|
||||
version.workspace = true
|
||||
homepage.workspace = true
|
||||
description = "S3 server-side encryption (SSE-S3, SSE-KMS, SSE-C) key resolution and metadata for RustFS."
|
||||
keywords = ["sse", "encryption", "s3", "kms", "rustfs"]
|
||||
categories = ["cryptography"]
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
|
||||
[features]
|
||||
default = []
|
||||
# MinIO-compatible sealed object keys (DARE). Mirrors the `rio-v2` feature of
|
||||
# the server binary, which enables both together.
|
||||
rio-v2 = ["dep:chacha20poly1305", "dep:hmac", "dep:sha2"]
|
||||
# Test seams for dependents: per-principal authorization overrides, DEK
|
||||
# provider injection and metadata fixtures. Never enable in a release build.
|
||||
test-util = []
|
||||
|
||||
[dependencies]
|
||||
# The only RustFS crates this one may reach. It sits between the S3 layer and
|
||||
# the storage engine and must not depend on either: what it needs from the
|
||||
# running server arrives through `SseHost`.
|
||||
rustfs-config = { workspace = true }
|
||||
rustfs-kms = { workspace = true }
|
||||
rustfs-policy = { workspace = true }
|
||||
rustfs-s3-types = { workspace = true }
|
||||
rustfs-utils = { workspace = true, features = ["http", "path"] }
|
||||
|
||||
aes-gcm = { workspace = true, features = ["rand_core", "zeroize"] }
|
||||
async-trait = { workspace = true }
|
||||
base64-simd = { workspace = true }
|
||||
chacha20poly1305 = { workspace = true, optional = true }
|
||||
hmac = { workspace = true, optional = true }
|
||||
http = { workspace = true }
|
||||
md-5 = { workspace = true }
|
||||
rand = { workspace = true }
|
||||
serde = { workspace = true, features = ["derive"] }
|
||||
serde_json = { workspace = true }
|
||||
sha2 = { workspace = true, optional = true }
|
||||
tracing = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
# The fake AWS KMS endpoint the backend-selection tests talk to.
|
||||
axum = { workspace = true }
|
||||
temp-env = { workspace = true, features = ["async_closure"] }
|
||||
tempfile = { workspace = true }
|
||||
tokio = { workspace = true, features = ["macros", "net", "rt-multi-thread", "sync", "time"] }
|
||||
|
||||
[lib]
|
||||
doctest = false
|
||||
@@ -0,0 +1,292 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Per-request summary of data-plane KMS use, attached to the request's audit entry.
|
||||
|
||||
use crate::core::request::SseKmsPrincipal;
|
||||
use crate::error::SseError;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use rustfs_kms::is_data_key_envelope;
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
use rustfs_utils::http::object_encryption_keys::{INTERNAL_ENCRYPTION_KEY_HEADER, SSEType, normalize_managed_metadata};
|
||||
use serde_json::Value;
|
||||
use std::collections::{BTreeSet, HashMap};
|
||||
use std::sync::{Arc, LazyLock, Mutex, Weak};
|
||||
|
||||
/// Tag keys carrying the KMS summary on an S3 audit entry.
|
||||
///
|
||||
/// Audit consumers key off these strings, so they are a wire contract: append
|
||||
/// new keys rather than renaming existing ones.
|
||||
const KMS_AUDIT_TAG_SSE_TYPE: &str = "sseType";
|
||||
|
||||
const KMS_AUDIT_TAG_KEY_ID: &str = "kmsKeyId";
|
||||
|
||||
const KMS_AUDIT_TAG_KEY_VERSION: &str = "kmsKeyVersion";
|
||||
|
||||
const KMS_AUDIT_TAG_OUTCOME: &str = "kmsOutcome";
|
||||
|
||||
const KMS_AUDIT_TAG_ERROR_CLASS: &str = "kmsErrorClass";
|
||||
|
||||
/// Separator for the rare request that touched more than one key or scheme.
|
||||
const KMS_AUDIT_VALUE_SEPARATOR: &str = ",";
|
||||
|
||||
/// What the data path did with KMS while serving one S3 request.
|
||||
///
|
||||
/// This rides on the request's existing S3 audit entry instead of becoming its
|
||||
/// own event: the entry already carries the principal, request ID and API, so
|
||||
/// attaching the KMS outcome costs no extra event volume and needs no second
|
||||
/// correlation key.
|
||||
///
|
||||
/// # Redaction
|
||||
///
|
||||
/// Only the fields below may ever be recorded. The S3 audit entry fans out to
|
||||
/// every configured target, several of which sit outside the KMS trust
|
||||
/// boundary, so nothing derived from a data key — plaintext, ciphertext,
|
||||
/// envelope, nonce — nor any caller-supplied encryption-context value belongs
|
||||
/// here. Key identifiers and scheme names are configuration, not secrets.
|
||||
#[derive(Debug, Default)]
|
||||
struct KmsRequestAuditState {
|
||||
sse_types: BTreeSet<&'static str>,
|
||||
key_ids: BTreeSet<String>,
|
||||
key_versions: BTreeSet<u32>,
|
||||
/// Set by the first failure. A request that failed any KMS interaction is
|
||||
/// reported as failed even if others succeeded: a partially completed
|
||||
/// envelope operation is not a success for an audit reader.
|
||||
error_class: Option<&'static str>,
|
||||
recorded: bool,
|
||||
}
|
||||
|
||||
/// Shared accumulator for one request's KMS summary.
|
||||
///
|
||||
/// Written by the managed-SSE code paths through the request's principal, read
|
||||
/// once through [`KmsRequestAuditScope::audit_tags`] by whoever owns the
|
||||
/// request's audit entry.
|
||||
#[derive(Debug, Default)]
|
||||
pub(crate) struct KmsRequestAudit(Mutex<KmsRequestAuditState>);
|
||||
|
||||
impl KmsRequestAudit {
|
||||
pub(crate) fn record(
|
||||
&self,
|
||||
sse_type: SSEType,
|
||||
key_id: Option<&str>,
|
||||
key_version: Option<u32>,
|
||||
error_class: Option<&'static str>,
|
||||
) {
|
||||
// A poisoned lock costs the audit entry its KMS tags; it must never cost
|
||||
// the request its result.
|
||||
let Ok(mut state) = self.0.lock() else {
|
||||
return;
|
||||
};
|
||||
|
||||
state.recorded = true;
|
||||
state.sse_types.insert(sse_type.audit_label());
|
||||
if let Some(key_id) = key_id.filter(|value| !value.is_empty()) {
|
||||
state.key_ids.insert(key_id.to_string());
|
||||
}
|
||||
if let Some(key_version) = key_version {
|
||||
state.key_versions.insert(key_version);
|
||||
}
|
||||
if state.error_class.is_none() {
|
||||
state.error_class = error_class;
|
||||
}
|
||||
}
|
||||
|
||||
/// Render the summary as audit tags, or nothing when the request performed
|
||||
/// no KMS work at all (SSE-C and unencrypted objects never reach KMS).
|
||||
pub fn audit_tags(&self) -> Vec<(&'static str, Value)> {
|
||||
let Ok(state) = self.0.lock() else {
|
||||
return Vec::new();
|
||||
};
|
||||
if !state.recorded {
|
||||
return Vec::new();
|
||||
}
|
||||
|
||||
let mut tags = Vec::with_capacity(5);
|
||||
tags.push((KMS_AUDIT_TAG_SSE_TYPE, join_audit_values(state.sse_types.iter().copied())));
|
||||
if !state.key_ids.is_empty() {
|
||||
tags.push((KMS_AUDIT_TAG_KEY_ID, join_audit_values(state.key_ids.iter().map(String::as_str))));
|
||||
}
|
||||
if !state.key_versions.is_empty() {
|
||||
tags.push((
|
||||
KMS_AUDIT_TAG_KEY_VERSION,
|
||||
join_audit_values(state.key_versions.iter().map(u32::to_string)),
|
||||
));
|
||||
}
|
||||
let outcome = if state.error_class.is_some() { "failure" } else { "success" };
|
||||
tags.push((KMS_AUDIT_TAG_OUTCOME, Value::String(outcome.to_string())));
|
||||
if let Some(error_class) = state.error_class {
|
||||
tags.push((KMS_AUDIT_TAG_ERROR_CLASS, Value::String(error_class.to_string())));
|
||||
}
|
||||
|
||||
tags
|
||||
}
|
||||
}
|
||||
|
||||
/// Render a set of values as one tag value.
|
||||
///
|
||||
/// Always a string, including for the single-value case: a consumer that would
|
||||
/// have to branch on the JSON type of a tag is a consumer that will get it
|
||||
/// wrong for the request that happens to touch two keys.
|
||||
fn join_audit_values(values: impl Iterator<Item = impl AsRef<str>>) -> Value {
|
||||
let joined = values.map(|value| value.as_ref().to_string()).collect::<Vec<_>>();
|
||||
Value::String(joined.join(KMS_AUDIT_VALUE_SEPARATOR))
|
||||
}
|
||||
|
||||
/// Slots of the requests currently being audited, keyed by canonical request ID.
|
||||
///
|
||||
/// Only a weak reference is held: the owning [`KmsRequestAuditScope`] decides the
|
||||
/// lifetime, so a scope that is somehow not dropped cannot keep a slot alive.
|
||||
static KMS_REQUEST_AUDITS: LazyLock<Mutex<HashMap<String, Weak<KmsRequestAudit>>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
|
||||
|
||||
/// Registration of one request's KMS audit slot, dropped with the request's
|
||||
/// audit entry.
|
||||
pub struct KmsRequestAuditScope {
|
||||
request_id: String,
|
||||
audit: Arc<KmsRequestAudit>,
|
||||
}
|
||||
|
||||
impl KmsRequestAuditScope {
|
||||
/// Open a slot for `request_id`, so managed-SSE operations served under it can
|
||||
/// be summarised onto its audit entry.
|
||||
pub fn register(request_id: &str) -> Self {
|
||||
let audit = Arc::new(KmsRequestAudit::default());
|
||||
if let Ok(mut registry) = KMS_REQUEST_AUDITS.lock() {
|
||||
registry.insert(request_id.to_string(), Arc::downgrade(&audit));
|
||||
}
|
||||
|
||||
Self {
|
||||
request_id: request_id.to_string(),
|
||||
audit,
|
||||
}
|
||||
}
|
||||
|
||||
/// Tags describing the KMS work recorded under this request.
|
||||
pub fn audit_tags(&self) -> Vec<(&'static str, Value)> {
|
||||
self.audit.audit_tags()
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for KmsRequestAuditScope {
|
||||
fn drop(&mut self) {
|
||||
if let Ok(mut registry) = KMS_REQUEST_AUDITS.lock() {
|
||||
registry.remove(&self.request_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Resolve the audit slot opened for `request_id`, if the request is being audited.
|
||||
pub(crate) fn kms_request_audit(request_id: &str) -> Option<Arc<KmsRequestAudit>> {
|
||||
KMS_REQUEST_AUDITS.lock().ok()?.get(request_id)?.upgrade()
|
||||
}
|
||||
|
||||
/// Failure classes for data-path failures that never reached a KMS backend.
|
||||
///
|
||||
/// Backend failures carry the classification defined by the KMS audit contract;
|
||||
/// everything else is classified at the S3 boundary it surfaced through.
|
||||
pub(crate) fn kms_data_plane_error_class(error: &SseError) -> &'static str {
|
||||
if let Some(failure) = error
|
||||
.source
|
||||
.as_ref()
|
||||
.and_then(|source| source.downcast_ref::<KmsDataPlaneFailure>())
|
||||
{
|
||||
return failure.class;
|
||||
}
|
||||
|
||||
match error.code {
|
||||
S3ErrorCode::AccessDenied => "access_denied",
|
||||
S3ErrorCode::InvalidArgument | S3ErrorCode::InvalidRequest => "invalid_argument",
|
||||
_ => "sse_internal",
|
||||
}
|
||||
}
|
||||
|
||||
/// Carries a KMS failure class across the conversion to an S3-facing error.
|
||||
///
|
||||
/// The class is decided while the `KmsError` is still typed; re-deriving it from
|
||||
/// a rendered message downstream would be guesswork.
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct KmsDataPlaneFailure {
|
||||
pub(crate) class: &'static str,
|
||||
pub(crate) source: Option<Box<dyn std::error::Error + Send + Sync>>,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for KmsDataPlaneFailure {
|
||||
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match &self.source {
|
||||
Some(source) => source.fmt(formatter),
|
||||
None => formatter.write_str(self.class),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for KmsDataPlaneFailure {
|
||||
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
|
||||
self.source
|
||||
.as_ref()
|
||||
.map(|source| source.as_ref() as &(dyn std::error::Error + 'static))
|
||||
}
|
||||
}
|
||||
|
||||
/// Record the outcome of one managed-SSE operation on the request's audit entry.
|
||||
///
|
||||
/// A `None` principal marks an internal caller — replication, lifecycle, heal —
|
||||
/// which has no S3 audit entry to attach to. `key_version` is a closure for
|
||||
/// exactly that caller: extracting the version means base64-decoding and
|
||||
/// parsing the stored envelope, work that must not run on the internal hot
|
||||
/// paths that discard it.
|
||||
pub(crate) fn record_managed_kms_outcome(
|
||||
principal: Option<&SseKmsPrincipal>,
|
||||
sse_type: SSEType,
|
||||
key_id: Option<&str>,
|
||||
key_version: impl FnOnce() -> Option<u32>,
|
||||
result: Result<(), &SseError>,
|
||||
) {
|
||||
let Some(audit) = principal.and_then(|principal| principal.request_audit.as_ref()) else {
|
||||
return;
|
||||
};
|
||||
|
||||
audit.record(sse_type, key_id, key_version(), result.err().map(kms_data_plane_error_class));
|
||||
}
|
||||
|
||||
/// Master-key version recorded in a managed-SSE data-key envelope, if the
|
||||
/// wrapping backend recorded one.
|
||||
///
|
||||
/// `None` is the honest answer for every other shape: Transit and AWS keep
|
||||
/// the version inside their own opaque ciphertext, Local records no version,
|
||||
/// and pre-versioning envelopes never carried the field. The single field is
|
||||
/// read through `serde_json::Value` rather than a full `DataKeyEnvelope`
|
||||
/// parse, so the audit path cannot double-count the envelope's unknown-field
|
||||
/// observability and touches nothing else in the envelope.
|
||||
pub(crate) fn envelope_master_key_version(envelope_bytes: &[u8]) -> Option<u32> {
|
||||
if !is_data_key_envelope(envelope_bytes) {
|
||||
return None;
|
||||
}
|
||||
u32::try_from(
|
||||
serde_json::from_slice::<Value>(envelope_bytes)
|
||||
.ok()?
|
||||
.get("master_key_version")?
|
||||
.as_u64()?,
|
||||
)
|
||||
.ok()
|
||||
}
|
||||
|
||||
/// Master-key version of the envelope stored on an object, for the audit
|
||||
/// summary of a read against that object.
|
||||
pub(crate) fn stored_envelope_master_key_version(metadata: &HashMap<String, String>) -> Option<u32> {
|
||||
// No context recoder: the recode only ever inserts the context key, which
|
||||
// this lookup never reads, so the normalized result is identical without it.
|
||||
let encoded = normalize_managed_metadata(metadata, None);
|
||||
let encoded = encoded.get(INTERNAL_ENCRYPTION_KEY_HEADER)?;
|
||||
let envelope = BASE64_STANDARD.decode_to_vec(encoded).ok()?;
|
||||
envelope_master_key_version(&envelope)
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! The encryption context a data key is bound to.
|
||||
|
||||
use crate::error::SseError;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use rustfs_kms::types::ObjectEncryptionContext;
|
||||
use rustfs_utils::http::object_encryption_keys::MINIO_INTERNAL_ENCRYPTION_KMS_CONTEXT_HEADER;
|
||||
use rustfs_utils::path::path_join_buf;
|
||||
use std::collections::HashMap;
|
||||
|
||||
pub(crate) fn canonical_kms_bucket_path(bucket: &str, key: &str) -> String {
|
||||
path_join_buf(&[bucket, key])
|
||||
}
|
||||
|
||||
pub(crate) fn build_kms_request_context(
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
provided_context: Option<&HashMap<String, String>>,
|
||||
) -> HashMap<String, String> {
|
||||
let mut context = provided_context.cloned().unwrap_or_default();
|
||||
context
|
||||
.entry(bucket.to_string())
|
||||
.or_insert_with(|| canonical_kms_bucket_path(bucket, key));
|
||||
context
|
||||
}
|
||||
|
||||
pub(crate) fn build_object_encryption_context(
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
provided_context: Option<&HashMap<String, String>>,
|
||||
) -> ObjectEncryptionContext {
|
||||
let mut context = ObjectEncryptionContext::new(bucket.to_string(), key.to_string());
|
||||
for (ctx_key, ctx_value) in build_kms_request_context(bucket, key, provided_context) {
|
||||
context = context.with_encryption_context(ctx_key, ctx_value);
|
||||
}
|
||||
context
|
||||
}
|
||||
|
||||
pub(crate) fn encode_minio_kms_context(context: &HashMap<String, String>) -> Result<String, SseError> {
|
||||
let encoded = serde_json::to_vec(context).map_err(|e| SseError::internal(format!("Failed to serialize KMS context: {e}")))?;
|
||||
Ok(BASE64_STANDARD.encode_to_string(encoded))
|
||||
}
|
||||
|
||||
pub(crate) fn decode_minio_kms_context(metadata: &HashMap<String, String>) -> Result<Option<HashMap<String, String>>, SseError> {
|
||||
let Some(encoded) = metadata.get(MINIO_INTERNAL_ENCRYPTION_KMS_CONTEXT_HEADER) else {
|
||||
return Ok(None);
|
||||
};
|
||||
let decoded = BASE64_STANDARD
|
||||
.decode_to_vec(encoded)
|
||||
.map_err(|e| SseError::internal(format!("Failed to decode MinIO KMS context: {e}")))?;
|
||||
serde_json::from_slice(&decoded)
|
||||
.map(Some)
|
||||
.map_err(|e| SseError::internal(format!("Failed to parse MinIO KMS context: {e}")))
|
||||
}
|
||||
@@ -0,0 +1,212 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Direct keying: the data key encrypts the object itself, under a stored base nonce.
|
||||
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
use crate::core::keying::NewObjectKey;
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
use crate::core::keying::material::EncryptionKeyKind;
|
||||
use crate::core::keying::{StoredDataKey, StoredKeyMode};
|
||||
use crate::error::SseError;
|
||||
use crate::host::SseHost;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use md5::{Digest as Md5Digest, Md5};
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
use rand::Rng;
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
use rustfs_kms::DataKey;
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
use rustfs_utils::http::object_encryption_keys::SSEType;
|
||||
use rustfs_utils::http::object_encryption_keys::{
|
||||
INTERNAL_ENCRYPTION_ALGORITHM_HEADER, INTERNAL_ENCRYPTION_IV_HEADER, INTERNAL_ENCRYPTION_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_IV_HEADER,
|
||||
};
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// SSE-C: record the base nonce the object is encrypted under.
|
||||
///
|
||||
/// The nonce is random, so decrypt reads it back instead of recomputing a
|
||||
/// deterministic value. It is written under both the RustFS and the MinIO key per
|
||||
/// repo convention. This covers a single PUT and a multipart session alike:
|
||||
/// CreateMultipartUpload builds the session metadata through the same call.
|
||||
pub(crate) fn record_customer_key_nonce(metadata: &mut HashMap<String, String>, base_nonce: [u8; 12]) {
|
||||
metadata.insert(INTERNAL_ENCRYPTION_IV_HEADER.to_string(), BASE64_STANDARD.encode_to_string(base_nonce));
|
||||
metadata.insert(
|
||||
MINIO_INTERNAL_ENCRYPTION_IV_HEADER.to_string(),
|
||||
BASE64_STANDARD.encode_to_string(base_nonce),
|
||||
);
|
||||
}
|
||||
|
||||
/// Managed SSE: record the wrapped data key, the nonce issued with it, and the cipher.
|
||||
pub(crate) fn record_wrapped_data_key(
|
||||
metadata: &mut HashMap<String, String>,
|
||||
wrapped_data_key: &[u8],
|
||||
base_nonce: [u8; 12],
|
||||
algorithm: &str,
|
||||
) {
|
||||
metadata.insert(
|
||||
INTERNAL_ENCRYPTION_KEY_HEADER.to_string(),
|
||||
BASE64_STANDARD.encode_to_string(wrapped_data_key),
|
||||
);
|
||||
metadata.insert(INTERNAL_ENCRYPTION_IV_HEADER.to_string(), BASE64_STANDARD.encode_to_string(base_nonce));
|
||||
metadata.insert(INTERNAL_ENCRYPTION_ALGORITHM_HEADER.to_string(), algorithm.to_string());
|
||||
}
|
||||
|
||||
/// Managed SSE: read back what [`record_wrapped_data_key`] stored.
|
||||
///
|
||||
/// `normalized_metadata` is the object's metadata with the managed keys normalized.
|
||||
pub(crate) async fn read_wrapped_data_key(
|
||||
host: &dyn SseHost,
|
||||
normalized_metadata: &HashMap<String, String>,
|
||||
) -> Result<StoredDataKey, SseError> {
|
||||
let (wrapped, iv, algorithm) = if let Some(service) = host.encryption_service().await {
|
||||
// Production mode: use service for metadata parsing
|
||||
let parsed = service
|
||||
.headers_to_metadata(normalized_metadata)
|
||||
.map_err(|e| SseError::internal(format!("Failed to parse encryption metadata: {e}")))?;
|
||||
|
||||
(parsed.encrypted_data_key, parsed.iv, parsed.algorithm)
|
||||
} else {
|
||||
// Test mode: parse metadata manually
|
||||
let encrypted_key_b64 = normalized_metadata
|
||||
.get(INTERNAL_ENCRYPTION_KEY_HEADER)
|
||||
.ok_or_else(|| SseError::internal("Missing encrypted key in metadata"))?;
|
||||
let encrypted_data_key = BASE64_STANDARD
|
||||
.decode_to_vec(encrypted_key_b64)
|
||||
.map_err(|e| SseError::internal(format!("Failed to decode encrypted key: {e}")))?;
|
||||
|
||||
let iv_b64 = normalized_metadata
|
||||
.get(INTERNAL_ENCRYPTION_IV_HEADER)
|
||||
.ok_or_else(|| SseError::internal("Missing IV in metadata"))?;
|
||||
let iv = BASE64_STANDARD
|
||||
.decode_to_vec(iv_b64)
|
||||
.map_err(|e| SseError::internal(format!("Failed to decode IV: {e}")))?;
|
||||
|
||||
let algorithm = normalized_metadata
|
||||
.get(INTERNAL_ENCRYPTION_ALGORITHM_HEADER)
|
||||
.cloned()
|
||||
.unwrap_or_else(|| "AES256".to_string());
|
||||
|
||||
(encrypted_data_key, iv, algorithm)
|
||||
};
|
||||
|
||||
let base_nonce = <[u8; 12]>::try_from(iv.as_slice())
|
||||
.map_err(|_| SseError::internal("Invalid encryption nonce length; expected 12 bytes"))?;
|
||||
|
||||
Ok(StoredDataKey {
|
||||
wrapped,
|
||||
algorithm,
|
||||
mode: StoredKeyMode::Direct { base_nonce },
|
||||
})
|
||||
}
|
||||
|
||||
/// Resolve the SSE-C Direct base nonce for decryption.
|
||||
///
|
||||
/// New objects persist a random nonce at encryption time (see
|
||||
/// [`record_customer_key_nonce`]) under `INTERNAL_ENCRYPTION_IV_HEADER` (preferred) or,
|
||||
/// for MinIO interop, `MINIO_INTERNAL_ENCRYPTION_IV_HEADER`. Legacy objects written before
|
||||
/// random nonces were persisted carry no stored IV; for those we fall back to the
|
||||
/// deterministic `generate_ssec_nonce(bucket, key)` value they were originally encrypted
|
||||
/// with, so previously stored objects still decrypt correctly.
|
||||
pub(crate) fn read_stored_ssec_nonce(metadata: &HashMap<String, String>, bucket: &str, key: &str) -> [u8; 12] {
|
||||
metadata
|
||||
.get(INTERNAL_ENCRYPTION_IV_HEADER)
|
||||
.or_else(|| metadata.get(MINIO_INTERNAL_ENCRYPTION_IV_HEADER))
|
||||
.and_then(|encoded| BASE64_STANDARD.decode_to_vec(encoded).ok())
|
||||
.and_then(|bytes| <[u8; 12]>::try_from(bytes.as_slice()).ok())
|
||||
.unwrap_or_else(|| generate_ssec_nonce(bucket, key))
|
||||
}
|
||||
|
||||
/// Generate deterministic nonce for SSE-C encryption
|
||||
///
|
||||
/// The nonce is derived from the bucket and key to ensure:
|
||||
/// 1. Same object always gets the same nonce (required for SSE-C)
|
||||
/// 2. Different objects get different nonces
|
||||
pub(crate) fn generate_ssec_nonce(bucket: &str, key: &str) -> [u8; 12] {
|
||||
let nonce_source = format!("{bucket}-{key}");
|
||||
let nonce_hash: [u8; 16] = Md5::digest(nonce_source.as_bytes()).into();
|
||||
let mut nonce = [0u8; 12];
|
||||
nonce.copy_from_slice(&nonce_hash[..12]);
|
||||
nonce
|
||||
}
|
||||
|
||||
/// Whether a multipart session needs the customer key when it is created.
|
||||
///
|
||||
/// Direct mode records only a nonce for the session; the customer key is checked
|
||||
/// per part, against what the session recorded.
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
pub(crate) const SESSION_KEY_NEEDS_CUSTOMER_KEY: bool = false;
|
||||
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
fn random_base_nonce() -> [u8; 12] {
|
||||
let mut base_nonce = [0u8; 12];
|
||||
rand::rng().fill_bytes(&mut base_nonce);
|
||||
base_nonce
|
||||
}
|
||||
|
||||
/// SSE-C object: the customer key encrypts the object itself.
|
||||
///
|
||||
/// Uses a fresh random nonce per encryption. A deterministic nonce derived from
|
||||
/// (bucket, key) would repeat whenever the same object is overwritten under the same
|
||||
/// SSE-C key, reusing an identical (key, nonce) pair and catastrophically breaking
|
||||
/// AES-256-GCM. The nonce is persisted (see [`record_customer_key_nonce`]) and read
|
||||
/// back on decrypt (see [`read_stored_ssec_nonce`]).
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
pub(crate) fn new_key_under_customer_key(customer_key: [u8; 32], _bucket: &str, _key: &str) -> Result<NewObjectKey, SseError> {
|
||||
Ok(NewObjectKey {
|
||||
key_bytes: customer_key,
|
||||
base_nonce: random_base_nonce(),
|
||||
key_kind: EncryptionKeyKind::Direct,
|
||||
sealed_key: None,
|
||||
})
|
||||
}
|
||||
|
||||
/// SSE-C multipart session: a nonce every part of the upload shares.
|
||||
///
|
||||
/// Generates a real random nonce for the session and persists it (see
|
||||
/// [`record_customer_key_nonce`]). Every part of this upload reads the same
|
||||
/// persisted nonce back, so all parts share one nonce without reintroducing the
|
||||
/// deterministic (bucket, key) reuse hazard. `key_bytes` stays a placeholder: it is
|
||||
/// neither used for encryption nor persisted; the real customer key is validated per
|
||||
/// part on upload.
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
pub(crate) fn new_session_key_under_customer_key(
|
||||
_customer_key: Option<[u8; 32]>,
|
||||
_bucket: &str,
|
||||
_key: &str,
|
||||
) -> Result<NewObjectKey, SseError> {
|
||||
Ok(NewObjectKey {
|
||||
key_bytes: [0; 32],
|
||||
base_nonce: random_base_nonce(),
|
||||
key_kind: EncryptionKeyKind::Direct,
|
||||
sealed_key: None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Managed SSE: the data key encrypts the object itself, under the nonce issued with it.
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
pub(crate) fn new_key_under_data_key(
|
||||
data_key: &DataKey,
|
||||
_sse_type: SSEType,
|
||||
_bucket: &str,
|
||||
_key: &str,
|
||||
) -> Result<NewObjectKey, SseError> {
|
||||
Ok(NewObjectKey {
|
||||
key_bytes: data_key.plaintext_key,
|
||||
base_nonce: data_key.nonce,
|
||||
key_kind: EncryptionKeyKind::Direct,
|
||||
sealed_key: None,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! The key material an encrypted write or read runs on.
|
||||
|
||||
#[cfg(feature = "rio-v2")]
|
||||
use crate::core::keying::object::{SEALED_KEY_IV_SIZE, SEALED_KEY_SIZE};
|
||||
use rustfs_utils::http::object_encryption_keys::SSEType;
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// Encryption material returned by [`sse_encryption`] / [`sse_prepare_encryption`].
|
||||
pub struct EncryptionMaterial {
|
||||
#[allow(unused)]
|
||||
pub sse_type: SSEType,
|
||||
pub server_side_encryption: String,
|
||||
pub kms_key_id: Option<String>,
|
||||
|
||||
#[allow(unused)]
|
||||
pub algorithm: String,
|
||||
|
||||
/// Encryption key bytes
|
||||
pub key_bytes: [u8; 32],
|
||||
/// Base nonce/IV used by rio to derive block/part nonces.
|
||||
pub base_nonce: [u8; 12],
|
||||
/// Encrypted DEK for managed SSE. Absent for SSE-C.
|
||||
pub encrypted_data_key: Option<Vec<u8>>,
|
||||
/// SSE-C key MD5 if customer-managed encryption is in use.
|
||||
pub customer_key_md5: Option<String>,
|
||||
/// Original plaintext size when it should be persisted alongside metadata.
|
||||
pub original_size: Option<i64>,
|
||||
/// Indicates whether `key_bytes` is a direct stream key or a MinIO-style object key.
|
||||
pub key_kind: EncryptionKeyKind,
|
||||
/// Original client-provided SSE-KMS context, stored in MinIO-compatible metadata.
|
||||
pub managed_kms_context: Option<HashMap<String, String>>,
|
||||
/// MinIO-compatible sealed object-key metadata for managed SSE object-key mode.
|
||||
#[cfg_attr(not(feature = "rio-v2"), allow(dead_code))]
|
||||
pub managed_sealed_key: Option<ManagedSealedKey>,
|
||||
}
|
||||
|
||||
/// Decryption material returned by [`sse_decryption`].
|
||||
pub struct DecryptionMaterial {
|
||||
#[allow(unused)]
|
||||
pub sse_type: SSEType,
|
||||
pub server_side_encryption: String,
|
||||
pub kms_key_id: Option<String>,
|
||||
#[allow(unused)]
|
||||
pub algorithm: String,
|
||||
pub customer_key_md5: Option<String>, // if use SSE-C, check key md5
|
||||
|
||||
/// Decryption key bytes
|
||||
pub key_bytes: [u8; 32],
|
||||
/// Base nonce/IV used by rio to derive block/part nonces.
|
||||
pub base_nonce: [u8; 12],
|
||||
/// Indicates whether `key_bytes` is a direct stream key or a MinIO-style object key.
|
||||
pub key_kind: EncryptionKeyKind,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for EncryptionMaterial {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("EncryptionMaterial")
|
||||
.field("sse_type", &self.sse_type)
|
||||
.field("server_side_encryption", &self.server_side_encryption)
|
||||
.field("original_size", &self.original_size)
|
||||
.finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for DecryptionMaterial {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("DecryptionMaterial")
|
||||
.field("sse_type", &self.sse_type)
|
||||
.field("server_side_encryption", &self.server_side_encryption)
|
||||
.finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum EncryptionKeyKind {
|
||||
Direct,
|
||||
Object,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ManagedSealedKey {
|
||||
#[cfg(feature = "rio-v2")]
|
||||
pub iv: [u8; SEALED_KEY_IV_SIZE],
|
||||
#[cfg(feature = "rio-v2")]
|
||||
pub sealed_key: [u8; SEALED_KEY_SIZE],
|
||||
}
|
||||
|
||||
impl EncryptionMaterial {
|
||||
/// The KMS key id a write response may advertise.
|
||||
///
|
||||
/// `kms_key_id` is always set for managed SSE because SSE-S3 also wraps
|
||||
/// its data key under the service default key, but that key is an
|
||||
/// internal detail of an `AES256` object: only an `aws:kms` object names
|
||||
/// a key the caller can act on, and `x-amz-server-side-encryption-aws-kms-key-id`
|
||||
/// is defined only for that scheme.
|
||||
pub fn response_kms_key_id(&self) -> Option<String> {
|
||||
matches!(self.sse_type, SSEType::SseKms)
|
||||
.then(|| self.kms_key_id.clone())
|
||||
.flatten()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,270 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Encryption metadata as it is stored with the object.
|
||||
|
||||
use crate::core::keying::context::encode_minio_kms_context;
|
||||
use crate::core::keying::direct::{record_customer_key_nonce, record_wrapped_data_key};
|
||||
use crate::core::keying::material::{EncryptionKeyKind, EncryptionMaterial};
|
||||
#[cfg(feature = "rio-v2")]
|
||||
use crate::core::keying::object::{record_data_key_in_minio_slots, record_sealed_customer_key};
|
||||
use crate::error::SseError;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use rustfs_utils::http::object_encryption_keys::{
|
||||
INTERNAL_ENCRYPTION_ALGORITHM_HEADER, INTERNAL_ENCRYPTION_CONTEXT_HEADER, INTERNAL_ENCRYPTION_IV_HEADER,
|
||||
INTERNAL_ENCRYPTION_KEY_HEADER, INTERNAL_ENCRYPTION_KEY_ID_HEADER, INTERNAL_ENCRYPTION_ORIGINAL_SIZE_HEADER,
|
||||
INTERNAL_ENCRYPTION_TAG_HEADER, MINIO_INTERNAL_ENCRYPTION_ALGORITHM_HEADER, MINIO_INTERNAL_ENCRYPTION_IV_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_CONTEXT_HEADER, MINIO_INTERNAL_ENCRYPTION_KMS_DATA_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_KEY_ID_HEADER, MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_MULTIPART_HEADER, MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_SSEC_SEALED_KEY_HEADER, SSEC_ORIGINAL_SIZE_HEADER, SSEType,
|
||||
};
|
||||
use std::borrow::Cow;
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// Two spellings of one encryption metadata key carry different values.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct ConflictingEncryptionMetadata {
|
||||
/// The canonical key whose case-variants disagree.
|
||||
pub key: &'static str,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for ConflictingEncryptionMetadata {
|
||||
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(formatter, "conflicting object encryption metadata for {}", self.key)
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for ConflictingEncryptionMetadata {}
|
||||
|
||||
/// Fold case-variant spellings of the encryption metadata keys onto their canonical names.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// When two spellings of the same key hold different values: picking either
|
||||
/// would decrypt with material the object may not have been written under.
|
||||
pub fn normalize_encryption_metadata_case(
|
||||
metadata: &HashMap<String, String>,
|
||||
) -> Result<Cow<'_, HashMap<String, String>>, ConflictingEncryptionMetadata> {
|
||||
const CANONICAL_KEYS: &[&str] = &[
|
||||
"x-amz-server-side-encryption",
|
||||
"x-amz-server-side-encryption-aws-kms-key-id",
|
||||
"x-amz-server-side-encryption-customer-algorithm",
|
||||
"x-amz-server-side-encryption-customer-key-md5",
|
||||
SSEC_ORIGINAL_SIZE_HEADER,
|
||||
INTERNAL_ENCRYPTION_KEY_ID_HEADER,
|
||||
INTERNAL_ENCRYPTION_KEY_HEADER,
|
||||
INTERNAL_ENCRYPTION_ALGORITHM_HEADER,
|
||||
INTERNAL_ENCRYPTION_IV_HEADER,
|
||||
INTERNAL_ENCRYPTION_CONTEXT_HEADER,
|
||||
INTERNAL_ENCRYPTION_TAG_HEADER,
|
||||
INTERNAL_ENCRYPTION_ORIGINAL_SIZE_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_MULTIPART_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_IV_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_ALGORITHM_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_SSEC_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_KEY_ID_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_CONTEXT_HEADER,
|
||||
];
|
||||
|
||||
let needs_normalization = metadata.keys().any(|key| {
|
||||
CANONICAL_KEYS
|
||||
.iter()
|
||||
.any(|canonical| key != canonical && key.eq_ignore_ascii_case(canonical))
|
||||
});
|
||||
if !needs_normalization {
|
||||
return Ok(Cow::Borrowed(metadata));
|
||||
}
|
||||
|
||||
let mut normalized = metadata.clone();
|
||||
for canonical in CANONICAL_KEYS {
|
||||
let mut matching_values = metadata
|
||||
.iter()
|
||||
.filter_map(|(key, value)| key.eq_ignore_ascii_case(canonical).then_some(value));
|
||||
let Some(value) = matching_values.next() else {
|
||||
continue;
|
||||
};
|
||||
if matching_values.any(|candidate| candidate != value) {
|
||||
return Err(ConflictingEncryptionMetadata { key: canonical });
|
||||
}
|
||||
if !normalized.contains_key(*canonical) {
|
||||
normalized.insert((*canonical).to_string(), value.clone());
|
||||
}
|
||||
}
|
||||
Ok(Cow::Owned(normalized))
|
||||
}
|
||||
|
||||
/// Turn the material of an encrypted write into the metadata stored with the object.
|
||||
///
|
||||
/// The scheme is recorded here. How the key itself is recorded belongs to the mode
|
||||
/// that formed it, in `direct.rs` and `object.rs`, next to the code that reads it back.
|
||||
pub fn encryption_material_to_metadata(material: &EncryptionMaterial) -> Result<HashMap<String, String>, SseError> {
|
||||
let mut metadata = HashMap::new();
|
||||
|
||||
match material.sse_type {
|
||||
SSEType::SseC => {
|
||||
record_ssec_scheme(&mut metadata, material);
|
||||
|
||||
// A `rio-v2` build seals an object key instead, so a Direct key there is a
|
||||
// multipart session created without its customer key.
|
||||
if material.key_kind == EncryptionKeyKind::Direct {
|
||||
record_customer_key_nonce(&mut metadata, material.base_nonce);
|
||||
}
|
||||
#[cfg(feature = "rio-v2")]
|
||||
if let Some(sealed) = &material.managed_sealed_key {
|
||||
record_sealed_customer_key(&mut metadata, sealed);
|
||||
}
|
||||
}
|
||||
SSEType::SseS3 | SSEType::SseKms => {
|
||||
let wrapped_data_key = material
|
||||
.encrypted_data_key
|
||||
.as_deref()
|
||||
.ok_or_else(|| SseError::internal("managed SSE materials must carry an encrypted data key"))?;
|
||||
record_managed_scheme(&mut metadata, material);
|
||||
|
||||
if material.key_kind == EncryptionKeyKind::Direct {
|
||||
record_wrapped_data_key(&mut metadata, wrapped_data_key, material.base_nonce, material.algorithm.as_str());
|
||||
}
|
||||
#[cfg(feature = "rio-v2")]
|
||||
record_data_key_in_minio_slots(&mut metadata, material, wrapped_data_key);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(metadata)
|
||||
}
|
||||
|
||||
/// SSE-C: the scheme, the fingerprint of the customer key, and the plaintext size.
|
||||
fn record_ssec_scheme(metadata: &mut HashMap<String, String>, material: &EncryptionMaterial) {
|
||||
metadata.insert(
|
||||
"x-amz-server-side-encryption".to_string(),
|
||||
material.server_side_encryption.as_str().to_string(),
|
||||
);
|
||||
metadata.insert(
|
||||
"x-amz-server-side-encryption-customer-algorithm".to_string(),
|
||||
material.algorithm.as_str().to_string(),
|
||||
);
|
||||
if let Some(customer_key_md5) = &material.customer_key_md5 {
|
||||
metadata.insert("x-amz-server-side-encryption-customer-key-md5".to_string(), customer_key_md5.to_string());
|
||||
}
|
||||
if let Some(original_size) = material.original_size {
|
||||
metadata.insert(SSEC_ORIGINAL_SIZE_HEADER.to_string(), original_size.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
/// Managed SSE: the scheme, the key the data key is wrapped under, the plaintext
|
||||
/// size, and the encryption context of the request.
|
||||
fn record_managed_scheme(metadata: &mut HashMap<String, String>, material: &EncryptionMaterial) {
|
||||
metadata.insert(
|
||||
"x-amz-server-side-encryption".to_string(),
|
||||
material.server_side_encryption.as_str().to_string(),
|
||||
);
|
||||
|
||||
let internal_key_id = material.kms_key_id.clone().unwrap_or_else(|| "default".to_string());
|
||||
metadata.insert(INTERNAL_ENCRYPTION_KEY_ID_HEADER.to_string(), internal_key_id.clone());
|
||||
|
||||
if matches!(material.sse_type, SSEType::SseKms) {
|
||||
metadata.insert("x-amz-server-side-encryption-aws-kms-key-id".to_string(), internal_key_id);
|
||||
}
|
||||
|
||||
if let Some(original_size) = material.original_size {
|
||||
metadata.insert(INTERNAL_ENCRYPTION_ORIGINAL_SIZE_HEADER.to_string(), original_size.to_string());
|
||||
}
|
||||
|
||||
if let Some(kms_context) = &material.managed_kms_context
|
||||
&& !kms_context.is_empty()
|
||||
{
|
||||
if let Ok(serialized) = serde_json::to_string(kms_context) {
|
||||
metadata.insert(INTERNAL_ENCRYPTION_CONTEXT_HEADER.to_string(), serialized);
|
||||
}
|
||||
if matches!(material.sse_type, SSEType::SseKms)
|
||||
&& let Ok(encoded) = encode_minio_kms_context(kms_context)
|
||||
{
|
||||
metadata.insert(MINIO_INTERNAL_ENCRYPTION_KMS_CONTEXT_HEADER.to_string(), encoded);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Strip source encryption metadata before constructing metadata for a copy destination.
|
||||
///
|
||||
/// Encryption metadata describes the physical source representation and must never be
|
||||
/// inherited by a plaintext destination or by a destination using a different key.
|
||||
pub fn strip_managed_encryption_metadata(metadata: &mut HashMap<String, String>) {
|
||||
const KEYS: [&str; 21] = [
|
||||
"x-amz-server-side-encryption",
|
||||
"x-amz-server-side-encryption-aws-kms-key-id",
|
||||
"x-amz-server-side-encryption-customer-algorithm",
|
||||
"x-amz-server-side-encryption-customer-key-md5",
|
||||
SSEC_ORIGINAL_SIZE_HEADER,
|
||||
INTERNAL_ENCRYPTION_KEY_ID_HEADER,
|
||||
INTERNAL_ENCRYPTION_ALGORITHM_HEADER,
|
||||
INTERNAL_ENCRYPTION_IV_HEADER,
|
||||
INTERNAL_ENCRYPTION_TAG_HEADER,
|
||||
INTERNAL_ENCRYPTION_KEY_HEADER,
|
||||
INTERNAL_ENCRYPTION_CONTEXT_HEADER,
|
||||
INTERNAL_ENCRYPTION_ORIGINAL_SIZE_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_MULTIPART_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_IV_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_ALGORITHM_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_SSEC_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_KEY_ID_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_DATA_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_CONTEXT_HEADER,
|
||||
];
|
||||
|
||||
for key in KEYS.iter() {
|
||||
metadata.remove(*key);
|
||||
}
|
||||
rustfs_utils::http::metadata_compat::remove_str(metadata, rustfs_utils::http::SUFFIX_OPAQUE_ENCRYPTED_ETAG);
|
||||
}
|
||||
|
||||
pub fn mark_encrypted_multipart_metadata(metadata: &mut HashMap<String, String>) {
|
||||
metadata.insert(MINIO_INTERNAL_ENCRYPTION_MULTIPART_HEADER.to_string(), String::new());
|
||||
}
|
||||
|
||||
/// True when the stored metadata marks the object as SSE-C protected.
|
||||
///
|
||||
/// RustFS persists the public `x-amz-server-side-encryption-customer-algorithm`
|
||||
/// key on SSE-C writes. MinIO persists only its internal sealed-key slot and
|
||||
/// synthesizes the public header onto responses (backlog#1638), so the slot is
|
||||
/// the only durable evidence on a MinIO-written object. That shape is readable
|
||||
/// solely through the rio-v2 sealed-object-key path, so it participates in
|
||||
/// detection only in builds that can actually read it — default builds keep
|
||||
/// the resolver's fail-closed diagnosis instead of demanding customer keys
|
||||
/// they could not use.
|
||||
pub fn stored_ssec_metadata(metadata: &HashMap<String, String>) -> bool {
|
||||
metadata.contains_key("x-amz-server-side-encryption-customer-algorithm") || minio_sealed_ssec_metadata(metadata)
|
||||
}
|
||||
|
||||
/// True when the object carries MinIO's SSE-C sealed-key slot — the shape that
|
||||
/// stores no customer-key MD5 and proves the key through the AEAD unseal
|
||||
/// instead.
|
||||
pub(crate) fn minio_sealed_ssec_metadata(metadata: &HashMap<String, String>) -> bool {
|
||||
cfg!(feature = "rio-v2") && metadata.contains_key(MINIO_INTERNAL_ENCRYPTION_SSEC_SEALED_KEY_HEADER)
|
||||
}
|
||||
|
||||
/// Recodes a stored MinIO KMS context value (base64-wrapped JSON) into the
|
||||
/// plain-JSON form RustFS stores under [`INTERNAL_ENCRYPTION_CONTEXT_HEADER`].
|
||||
///
|
||||
/// Injected into the shared [`normalize_managed_metadata`] because the shared
|
||||
/// crate carries no JSON codec; any decode failure returns `None`, which skips
|
||||
/// the context mapping exactly like the historical inline `if let Ok` chain.
|
||||
pub(crate) fn recode_minio_kms_context(value: &str) -> Option<String> {
|
||||
let decoded = BASE64_STANDARD.decode_to_vec(value).ok()?;
|
||||
let context = serde_json::from_slice::<HashMap<String, String>>(&decoded).ok()?;
|
||||
serde_json::to_string(&context).ok()
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! The internal keying modes: how an object's key is formed and how it is stored.
|
||||
|
||||
pub(crate) mod context;
|
||||
pub(crate) mod direct;
|
||||
pub(crate) mod material;
|
||||
pub(crate) mod metadata;
|
||||
#[cfg(feature = "rio-v2")]
|
||||
pub(crate) mod object;
|
||||
pub(crate) mod stored;
|
||||
|
||||
use crate::core::keying::material::{EncryptionKeyKind, ManagedSealedKey};
|
||||
|
||||
/// The key a new object is encrypted with, in the mode this build writes.
|
||||
pub(crate) struct NewObjectKey {
|
||||
/// Key handed to the stream cipher.
|
||||
pub(crate) key_bytes: [u8; 32],
|
||||
/// Base nonce the stream cipher derives its block nonces from.
|
||||
pub(crate) base_nonce: [u8; 12],
|
||||
/// The mode `key_bytes` belongs to.
|
||||
pub(crate) key_kind: EncryptionKeyKind,
|
||||
/// The sealed form to store, in a mode that seals a separate object key.
|
||||
pub(crate) sealed_key: Option<ManagedSealedKey>,
|
||||
}
|
||||
|
||||
/// A managed-SSE data key as a stored object recorded it, still wrapped.
|
||||
pub(crate) struct StoredDataKey {
|
||||
/// The data key, wrapped by the provider that issued it.
|
||||
pub(crate) wrapped: Vec<u8>,
|
||||
/// The cipher the object recorded.
|
||||
pub(crate) algorithm: String,
|
||||
/// What the data key is to the object once it is unwrapped.
|
||||
pub(crate) mode: StoredKeyMode,
|
||||
}
|
||||
|
||||
/// The mode a stored key was recorded in.
|
||||
pub(crate) enum StoredKeyMode {
|
||||
/// The data key is the object's key, under the nonce stored beside it.
|
||||
Direct { base_nonce: [u8; 12] },
|
||||
/// The data key unseals the object's key.
|
||||
#[cfg(feature = "rio-v2")]
|
||||
Object { sealed_key: ManagedSealedKey },
|
||||
}
|
||||
|
||||
// The mode new objects are written in. Every build reads every mode it can
|
||||
// recognize; writing picks exactly one, and this is the only place that says which.
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
pub(crate) use direct::{
|
||||
SESSION_KEY_NEEDS_CUSTOMER_KEY, new_key_under_customer_key, new_key_under_data_key, new_session_key_under_customer_key,
|
||||
};
|
||||
#[cfg(feature = "rio-v2")]
|
||||
pub(crate) use object::{
|
||||
SESSION_KEY_NEEDS_CUSTOMER_KEY, new_key_under_customer_key, new_key_under_data_key, new_session_key_under_customer_key,
|
||||
};
|
||||
@@ -0,0 +1,436 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Object keying: a derived object key, sealed in the MinIO-compatible format.
|
||||
|
||||
use crate::core::keying::material::{EncryptionKeyKind, EncryptionMaterial, ManagedSealedKey};
|
||||
use crate::core::keying::{NewObjectKey, StoredDataKey, StoredKeyMode};
|
||||
use crate::error::SseError;
|
||||
use aes_gcm::aead::{Aead, KeyInit, Payload};
|
||||
use aes_gcm::{Aes256Gcm, Nonce};
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use chacha20poly1305::ChaCha20Poly1305;
|
||||
use hmac::{Hmac, Mac};
|
||||
use rand::RngExt;
|
||||
use rustfs_kms::DataKey;
|
||||
use rustfs_utils::http::object_encryption_keys::{
|
||||
INTERNAL_ENCRYPTION_ALGORITHM_HEADER, INTERNAL_ENCRYPTION_IV_HEADER, INTERNAL_ENCRYPTION_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_ALGORITHM_HEADER, MINIO_INTERNAL_ENCRYPTION_IV_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_DATA_KEY_HEADER, MINIO_INTERNAL_ENCRYPTION_KMS_KEY_ID_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER, MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_SSEC_SEALED_KEY_HEADER, SSEType,
|
||||
};
|
||||
use sha2::Sha256;
|
||||
use std::collections::HashMap;
|
||||
|
||||
pub(crate) const MINIO_INTERNAL_ENCRYPTION_SEAL_ALGORITHM: &str = "DAREv2-HMAC-SHA256";
|
||||
|
||||
const DARE_VERSION_20: u8 = 0x20;
|
||||
|
||||
pub(crate) const DARE_CIPHER_AES_256_GCM: u8 = 0x00;
|
||||
|
||||
pub(crate) const DARE_CIPHER_CHACHA20_POLY1305: u8 = 0x01;
|
||||
|
||||
const DARE_HEADER_SIZE: usize = 16;
|
||||
|
||||
const DARE_TAG_SIZE: usize = 16;
|
||||
|
||||
pub(crate) const SEALED_KEY_IV_SIZE: usize = 32;
|
||||
|
||||
pub(crate) const SEALED_KEY_SIZE: usize = DARE_HEADER_SIZE + 32 + DARE_TAG_SIZE;
|
||||
|
||||
const OBJECT_KEY_DERIVATION_CONTEXT: &[u8] = b"object-encryption-key generation";
|
||||
|
||||
pub(crate) type HmacSha256 = Hmac<Sha256>;
|
||||
|
||||
fn managed_sse_domain(sse_type: SSEType) -> &'static str {
|
||||
match sse_type {
|
||||
SSEType::SseS3 => "SSE-S3",
|
||||
SSEType::SseKms => "SSE-KMS",
|
||||
SSEType::SseC => "SSE-C",
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn is_supported_sealed_object_key_cipher(cipher: u8) -> bool {
|
||||
matches!(cipher, DARE_CIPHER_AES_256_GCM | DARE_CIPHER_CHACHA20_POLY1305)
|
||||
}
|
||||
|
||||
fn decrypt_sealed_object_key_payload(sealing_key: [u8; 32], header: &[u8], sealed_key: &[u8]) -> Result<Vec<u8>, SseError> {
|
||||
let nonce = &header[4..16];
|
||||
let ciphertext = &sealed_key[DARE_HEADER_SIZE..];
|
||||
let aad = &header[..4];
|
||||
match header[1] {
|
||||
DARE_CIPHER_AES_256_GCM => {
|
||||
let cipher = Aes256Gcm::new_from_slice(&sealing_key)
|
||||
.map_err(|err| SseError::internal(format!("Invalid AES-GCM sealing key: {err}")))?;
|
||||
let nonce = Nonce::try_from(nonce).map_err(|_| SseError::internal("Invalid sealed object-key package nonce"))?;
|
||||
cipher.decrypt(&nonce, Payload { msg: ciphertext, aad })
|
||||
}
|
||||
DARE_CIPHER_CHACHA20_POLY1305 => {
|
||||
let cipher = ChaCha20Poly1305::new_from_slice(&sealing_key)
|
||||
.map_err(|err| SseError::internal(format!("Invalid ChaCha20-Poly1305 sealing key: {err}")))?;
|
||||
let nonce = chacha20poly1305::Nonce::try_from(nonce)
|
||||
.map_err(|_| SseError::internal("Invalid sealed object-key package nonce"))?;
|
||||
cipher.decrypt(&nonce, Payload { msg: ciphertext, aad })
|
||||
}
|
||||
_ => return Err(SseError::internal("Unsupported sealed object-key DARE header")),
|
||||
}
|
||||
.map_err(|err| SseError::internal(format!("Failed to unseal object key: {err}")))
|
||||
}
|
||||
|
||||
fn canonical_sse_path(bucket: &str, object: &str) -> String {
|
||||
let bucket = bucket.trim_matches('/');
|
||||
let object = object.trim_matches('/');
|
||||
if object.is_empty() {
|
||||
bucket.to_string()
|
||||
} else if bucket.is_empty() {
|
||||
object.to_string()
|
||||
} else {
|
||||
format!("{bucket}/{object}")
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn derive_object_key(external_key: [u8; 32]) -> Result<[u8; 32], SseError> {
|
||||
let mut random = [0u8; 32];
|
||||
rand::rng().fill(&mut random);
|
||||
|
||||
let mut mac = HmacSha256::new_from_slice(&external_key)
|
||||
.map_err(|err| SseError::internal(format!("Invalid HMAC key for object-key derivation: {err}")))?;
|
||||
mac.update(OBJECT_KEY_DERIVATION_CONTEXT);
|
||||
mac.update(&random);
|
||||
|
||||
let mut object_key = [0u8; 32];
|
||||
object_key.copy_from_slice(mac.finalize().into_bytes().as_slice());
|
||||
Ok(object_key)
|
||||
}
|
||||
|
||||
fn derive_sealing_key(
|
||||
external_key: [u8; 32],
|
||||
iv: [u8; SEALED_KEY_IV_SIZE],
|
||||
domain: &str,
|
||||
bucket: &str,
|
||||
object: &str,
|
||||
) -> Result<[u8; 32], SseError> {
|
||||
let mut mac = HmacSha256::new_from_slice(&external_key)
|
||||
.map_err(|err| SseError::internal(format!("Invalid HMAC key for sealing-key derivation: {err}")))?;
|
||||
mac.update(&iv);
|
||||
mac.update(domain.as_bytes());
|
||||
mac.update(MINIO_INTERNAL_ENCRYPTION_SEAL_ALGORITHM.as_bytes());
|
||||
mac.update(canonical_sse_path(bucket, object).as_bytes());
|
||||
|
||||
let mut sealing_key = [0u8; 32];
|
||||
sealing_key.copy_from_slice(mac.finalize().into_bytes().as_slice());
|
||||
Ok(sealing_key)
|
||||
}
|
||||
|
||||
pub(crate) fn seal_object_key(
|
||||
object_key: [u8; 32],
|
||||
external_key: [u8; 32],
|
||||
sse_type: SSEType,
|
||||
bucket: &str,
|
||||
object: &str,
|
||||
) -> Result<ManagedSealedKey, SseError> {
|
||||
let mut iv = [0u8; SEALED_KEY_IV_SIZE];
|
||||
rand::rng().fill(&mut iv);
|
||||
let sealing_key = derive_sealing_key(external_key, iv, managed_sse_domain(sse_type), bucket, object)?;
|
||||
|
||||
let mut header = [0u8; DARE_HEADER_SIZE];
|
||||
header[0] = DARE_VERSION_20;
|
||||
header[1] = DARE_CIPHER_AES_256_GCM;
|
||||
header[2..4].copy_from_slice(&(31u16).to_le_bytes());
|
||||
let mut stream_nonce = [0u8; 12];
|
||||
rand::rng().fill(&mut stream_nonce);
|
||||
stream_nonce[0] |= 0x80;
|
||||
header[4..16].copy_from_slice(&stream_nonce);
|
||||
|
||||
let cipher =
|
||||
Aes256Gcm::new_from_slice(&sealing_key).map_err(|err| SseError::internal(format!("Invalid sealing key: {err}")))?;
|
||||
let nonce =
|
||||
Nonce::try_from(stream_nonce.as_slice()).map_err(|_| SseError::internal("Invalid sealed object-key stream nonce"))?;
|
||||
let ciphertext = cipher
|
||||
.encrypt(
|
||||
&nonce,
|
||||
aes_gcm::aead::Payload {
|
||||
msg: &object_key,
|
||||
aad: &header[..4],
|
||||
},
|
||||
)
|
||||
.map_err(|err| SseError::internal(format!("Failed to seal object key: {err}")))?;
|
||||
|
||||
let mut sealed_key = [0u8; SEALED_KEY_SIZE];
|
||||
sealed_key[..DARE_HEADER_SIZE].copy_from_slice(&header);
|
||||
sealed_key[DARE_HEADER_SIZE..].copy_from_slice(&ciphertext);
|
||||
|
||||
Ok(ManagedSealedKey { iv, sealed_key })
|
||||
}
|
||||
|
||||
pub(crate) fn unseal_object_key(
|
||||
sealed: &ManagedSealedKey,
|
||||
external_key: [u8; 32],
|
||||
sse_type: SSEType,
|
||||
bucket: &str,
|
||||
object: &str,
|
||||
) -> Result<[u8; 32], SseError> {
|
||||
let header = &sealed.sealed_key[..DARE_HEADER_SIZE];
|
||||
if header[0] != DARE_VERSION_20 || !is_supported_sealed_object_key_cipher(header[1]) {
|
||||
return Err(SseError::internal("Unsupported sealed object-key DARE header"));
|
||||
}
|
||||
if u16::from_le_bytes([header[2], header[3]]) != 31 || header[4] & 0x80 == 0 {
|
||||
return Err(SseError::internal("Invalid sealed object-key payload header"));
|
||||
}
|
||||
|
||||
let sealing_key = derive_sealing_key(external_key, sealed.iv, managed_sse_domain(sse_type), bucket, object)?;
|
||||
let plaintext = decrypt_sealed_object_key_payload(sealing_key, header, &sealed.sealed_key)?;
|
||||
|
||||
let object_key: [u8; 32] = plaintext
|
||||
.as_slice()
|
||||
.try_into()
|
||||
.map_err(|_| SseError::internal("Sealed object key must decrypt to 32 bytes"))?;
|
||||
Ok(object_key)
|
||||
}
|
||||
|
||||
fn try_decode_minio_sealed_key(bytes: &str) -> Result<Option<[u8; SEALED_KEY_SIZE]>, SseError> {
|
||||
let decoded = BASE64_STANDARD
|
||||
.decode_to_vec(bytes)
|
||||
.map_err(|e| SseError::internal(format!("Failed to decode sealed object key: {e}")))?;
|
||||
match decoded.as_slice().try_into() {
|
||||
Ok(sealed_key) => Ok(Some(sealed_key)),
|
||||
Err(_) => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
fn try_decode_minio_sealing_iv(bytes: &str) -> Result<Option<[u8; SEALED_KEY_IV_SIZE]>, SseError> {
|
||||
let decoded = BASE64_STANDARD
|
||||
.decode_to_vec(bytes)
|
||||
.map_err(|e| SseError::internal(format!("Failed to decode sealing IV: {e}")))?;
|
||||
match decoded.as_slice().try_into() {
|
||||
Ok(iv) => Ok(Some(iv)),
|
||||
Err(_) => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn is_legacy_rustfs_managed_metadata(metadata: &HashMap<String, String>) -> bool {
|
||||
metadata.contains_key(INTERNAL_ENCRYPTION_KEY_HEADER)
|
||||
&& metadata.contains_key(INTERNAL_ENCRYPTION_IV_HEADER)
|
||||
&& !metadata.contains_key(MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER)
|
||||
&& !metadata.contains_key(MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER)
|
||||
}
|
||||
|
||||
/// Infer the managed SSE scheme from the MinIO sealed-key slot that is present.
|
||||
///
|
||||
/// Returns `None` when no managed MinIO slot is present, which keeps callers on
|
||||
/// their fail-closed path. SSE-C is not a managed scheme and is handled by the
|
||||
/// SSE-C read path, so its slot is not considered here.
|
||||
pub(crate) fn infer_minio_managed_sse_type(metadata: &HashMap<String, String>) -> Option<SSEType> {
|
||||
if metadata.contains_key(MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER) {
|
||||
Some(SSEType::SseS3)
|
||||
} else if metadata.contains_key(MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER) {
|
||||
Some(SSEType::SseKms)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn parse_minio_managed_sealed_key(
|
||||
metadata: &HashMap<String, String>,
|
||||
sse_type: SSEType,
|
||||
) -> Result<Option<ManagedSealedKey>, SseError> {
|
||||
let algorithm = match metadata.get(MINIO_INTERNAL_ENCRYPTION_ALGORITHM_HEADER) {
|
||||
Some(algorithm) => algorithm,
|
||||
None => return Ok(None),
|
||||
};
|
||||
if algorithm != MINIO_INTERNAL_ENCRYPTION_SEAL_ALGORITHM {
|
||||
return Ok(None);
|
||||
}
|
||||
|
||||
let iv = match metadata.get(MINIO_INTERNAL_ENCRYPTION_IV_HEADER) {
|
||||
Some(iv) => match try_decode_minio_sealing_iv(iv)? {
|
||||
Some(iv) => iv,
|
||||
None => return Ok(None),
|
||||
},
|
||||
None => return Ok(None),
|
||||
};
|
||||
|
||||
let header_key = match sse_type {
|
||||
SSEType::SseS3 => MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER,
|
||||
SSEType::SseKms => MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER,
|
||||
SSEType::SseC => MINIO_INTERNAL_ENCRYPTION_SSEC_SEALED_KEY_HEADER,
|
||||
};
|
||||
let sealed_key = match metadata.get(header_key) {
|
||||
Some(value) => match try_decode_minio_sealed_key(value)? {
|
||||
Some(sealed_key) => sealed_key,
|
||||
None => return Ok(None),
|
||||
},
|
||||
None => return Ok(None),
|
||||
};
|
||||
|
||||
Ok(Some(ManagedSealedKey { iv, sealed_key }))
|
||||
}
|
||||
|
||||
/// SSE-C: record the object key sealed under the customer key.
|
||||
pub(crate) fn record_sealed_customer_key(metadata: &mut HashMap<String, String>, sealed: &ManagedSealedKey) {
|
||||
metadata.insert(
|
||||
MINIO_INTERNAL_ENCRYPTION_IV_HEADER.to_string(),
|
||||
BASE64_STANDARD.encode_to_string(sealed.iv),
|
||||
);
|
||||
metadata.insert(
|
||||
MINIO_INTERNAL_ENCRYPTION_ALGORITHM_HEADER.to_string(),
|
||||
MINIO_INTERNAL_ENCRYPTION_SEAL_ALGORITHM.to_string(),
|
||||
);
|
||||
metadata.insert(
|
||||
MINIO_INTERNAL_ENCRYPTION_SSEC_SEALED_KEY_HEADER.to_string(),
|
||||
BASE64_STANDARD.encode_to_string(sealed.sealed_key),
|
||||
);
|
||||
}
|
||||
|
||||
/// Managed SSE: record the wrapped data key in MinIO's slots.
|
||||
///
|
||||
/// With a sealed object key the slots hold what MinIO itself writes. Without one
|
||||
/// the key was formed in Direct mode, and the slots mirror its wrapped data key and
|
||||
/// nonce: [`parse_minio_managed_sealed_key`] turns that shape down by its length, so
|
||||
/// the object is read back in Direct mode.
|
||||
pub(crate) fn record_data_key_in_minio_slots(
|
||||
metadata: &mut HashMap<String, String>,
|
||||
material: &EncryptionMaterial,
|
||||
wrapped_data_key: &[u8],
|
||||
) {
|
||||
metadata.insert(
|
||||
MINIO_INTERNAL_ENCRYPTION_ALGORITHM_HEADER.to_string(),
|
||||
MINIO_INTERNAL_ENCRYPTION_SEAL_ALGORITHM.to_string(),
|
||||
);
|
||||
if let Some(kms_key_id) = &material.kms_key_id {
|
||||
metadata.insert(MINIO_INTERNAL_ENCRYPTION_KMS_KEY_ID_HEADER.to_string(), kms_key_id.to_string());
|
||||
}
|
||||
|
||||
let encoded_data_key = BASE64_STANDARD.encode_to_string(wrapped_data_key);
|
||||
match &material.managed_sealed_key {
|
||||
Some(sealed) => {
|
||||
metadata.insert(
|
||||
MINIO_INTERNAL_ENCRYPTION_IV_HEADER.to_string(),
|
||||
BASE64_STANDARD.encode_to_string(sealed.iv),
|
||||
);
|
||||
match material.sse_type {
|
||||
SSEType::SseS3 => {
|
||||
metadata.insert(
|
||||
MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER.to_string(),
|
||||
BASE64_STANDARD.encode_to_string(sealed.sealed_key),
|
||||
);
|
||||
}
|
||||
SSEType::SseKms => {
|
||||
metadata.insert(
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER.to_string(),
|
||||
BASE64_STANDARD.encode_to_string(sealed.sealed_key),
|
||||
);
|
||||
}
|
||||
SSEType::SseC => {}
|
||||
}
|
||||
metadata.insert(MINIO_INTERNAL_ENCRYPTION_KMS_DATA_KEY_HEADER.to_string(), encoded_data_key);
|
||||
}
|
||||
None => {
|
||||
metadata.insert(
|
||||
MINIO_INTERNAL_ENCRYPTION_IV_HEADER.to_string(),
|
||||
BASE64_STANDARD.encode_to_string(material.base_nonce),
|
||||
);
|
||||
match material.sse_type {
|
||||
SSEType::SseS3 => {
|
||||
metadata.insert(MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER.to_string(), encoded_data_key);
|
||||
}
|
||||
SSEType::SseKms => {
|
||||
metadata.insert(MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER.to_string(), encoded_data_key.clone());
|
||||
metadata.insert(MINIO_INTERNAL_ENCRYPTION_KMS_DATA_KEY_HEADER.to_string(), encoded_data_key);
|
||||
}
|
||||
SSEType::SseC => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Managed SSE: read back the wrapped data key that seals `sealed_key`.
|
||||
///
|
||||
/// `normalized_metadata` is `metadata` with the managed keys normalized.
|
||||
pub(crate) fn read_sealed_data_key(
|
||||
metadata: &HashMap<String, String>,
|
||||
normalized_metadata: &HashMap<String, String>,
|
||||
sealed_key: ManagedSealedKey,
|
||||
) -> Result<StoredDataKey, SseError> {
|
||||
let encrypted_key_b64 = normalized_metadata
|
||||
.get(INTERNAL_ENCRYPTION_KEY_HEADER)
|
||||
.or_else(|| metadata.get(MINIO_INTERNAL_ENCRYPTION_KMS_DATA_KEY_HEADER))
|
||||
.ok_or_else(|| SseError::internal("Missing encrypted key in metadata"))?;
|
||||
let wrapped = BASE64_STANDARD
|
||||
.decode_to_vec(encrypted_key_b64)
|
||||
.map_err(|e| SseError::internal(format!("Failed to decode encrypted key: {e}")))?;
|
||||
|
||||
Ok(StoredDataKey {
|
||||
wrapped,
|
||||
algorithm: normalized_metadata
|
||||
.get(INTERNAL_ENCRYPTION_ALGORITHM_HEADER)
|
||||
.cloned()
|
||||
.unwrap_or_else(|| "AES256".to_string()),
|
||||
mode: StoredKeyMode::Object { sealed_key },
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether a multipart session needs the customer key when it is created.
|
||||
///
|
||||
/// Object mode seals the session's object key under the customer key, so the key
|
||||
/// has to be present, and valid, at that point.
|
||||
pub(crate) const SESSION_KEY_NEEDS_CUSTOMER_KEY: bool = true;
|
||||
|
||||
/// Derive a fresh object key from `external_key` and seal it under the same key.
|
||||
fn new_sealed_object_key(external_key: [u8; 32], sse_type: SSEType, bucket: &str, key: &str) -> Result<NewObjectKey, SseError> {
|
||||
let object_key = derive_object_key(external_key)?;
|
||||
let sealed_key = seal_object_key(object_key, external_key, sse_type, bucket, key)?;
|
||||
Ok(NewObjectKey {
|
||||
key_bytes: object_key,
|
||||
base_nonce: [0; 12],
|
||||
key_kind: EncryptionKeyKind::Object,
|
||||
sealed_key: Some(sealed_key),
|
||||
})
|
||||
}
|
||||
|
||||
/// SSE-C object: an object key sealed under the customer key.
|
||||
pub(crate) fn new_key_under_customer_key(customer_key: [u8; 32], bucket: &str, key: &str) -> Result<NewObjectKey, SseError> {
|
||||
new_sealed_object_key(customer_key, SSEType::SseC, bucket, key)
|
||||
}
|
||||
|
||||
/// SSE-C multipart session: an object key sealed under the customer key.
|
||||
///
|
||||
/// A session created without its customer key has nothing to seal and records a
|
||||
/// placeholder instead.
|
||||
pub(crate) fn new_session_key_under_customer_key(
|
||||
customer_key: Option<[u8; 32]>,
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
) -> Result<NewObjectKey, SseError> {
|
||||
match customer_key {
|
||||
Some(customer_key) => new_sealed_object_key(customer_key, SSEType::SseC, bucket, key),
|
||||
None => Ok(NewObjectKey {
|
||||
key_bytes: [0; 32],
|
||||
base_nonce: [0; 12],
|
||||
key_kind: EncryptionKeyKind::Direct,
|
||||
sealed_key: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
/// Managed SSE: an object key sealed under the data key.
|
||||
pub(crate) fn new_key_under_data_key(
|
||||
data_key: &DataKey,
|
||||
sse_type: SSEType,
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
) -> Result<NewObjectKey, SseError> {
|
||||
new_sealed_object_key(data_key.plaintext_key, sse_type, bucket, key)
|
||||
}
|
||||
@@ -0,0 +1,253 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Reading: recognize how a stored object was keyed, and recover its key.
|
||||
//!
|
||||
//! What an object recorded is the only source of truth here. The scheme a request
|
||||
//! advertises and whether a KMS is running now are write policy and runtime state;
|
||||
//! neither says how an object written earlier was keyed.
|
||||
|
||||
use crate::core::keying::context::{build_object_encryption_context, decode_minio_kms_context};
|
||||
use crate::core::keying::direct::{read_stored_ssec_nonce, read_wrapped_data_key};
|
||||
use crate::core::keying::material::EncryptionKeyKind;
|
||||
use crate::core::keying::metadata::recode_minio_kms_context;
|
||||
#[cfg(feature = "rio-v2")]
|
||||
use crate::core::keying::object::{
|
||||
infer_minio_managed_sse_type, is_legacy_rustfs_managed_metadata, parse_minio_managed_sealed_key, read_sealed_data_key,
|
||||
unseal_object_key,
|
||||
};
|
||||
use crate::core::keying::{StoredDataKey, StoredKeyMode};
|
||||
use crate::error::SseError;
|
||||
use crate::host::SseHost;
|
||||
use crate::kms::local::is_local_sse_dek;
|
||||
#[cfg(feature = "rio-v2")]
|
||||
use crate::kms::local::is_rustfs_managed_data_key;
|
||||
#[cfg(feature = "rio-v2")]
|
||||
use crate::kms::provider::decrypt_unenveloped_sealed_dek;
|
||||
use crate::kms::provider::{SseDekProvider, bare_data_key_kms_provider, get_local_sse_dek_provider, kms_sse_dek_provider};
|
||||
use rustfs_kms::is_data_key_envelope;
|
||||
use rustfs_utils::http::headers::AMZ_ENCRYPTION_KMS;
|
||||
use rustfs_utils::http::object_encryption_keys::{
|
||||
INTERNAL_ENCRYPTION_KEY_ID_HEADER, SSEType, contains_managed_encryption_metadata, normalize_managed_metadata,
|
||||
};
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
/// The key a stored object is decrypted with, recovered from what the object recorded.
|
||||
pub(crate) struct OpenedObjectKey {
|
||||
/// Key handed to the stream cipher.
|
||||
pub(crate) key_bytes: [u8; 32],
|
||||
/// Base nonce the stream cipher derives its block nonces from.
|
||||
pub(crate) base_nonce: [u8; 12],
|
||||
/// The mode the object was written in.
|
||||
pub(crate) key_kind: EncryptionKeyKind,
|
||||
}
|
||||
|
||||
/// The managed scheme a stored object was written under, or `None` when this build
|
||||
/// cannot establish it.
|
||||
fn stored_managed_sse_type(metadata: &HashMap<String, String>) -> Option<SSEType> {
|
||||
match metadata.get("x-amz-server-side-encryption").map(String::as_str) {
|
||||
Some(AMZ_ENCRYPTION_KMS) => Some(SSEType::SseKms),
|
||||
Some(_) => Some(SSEType::SseS3),
|
||||
// MinIO never persists the public scheme header: `crypto.S3.CreateMetadata`
|
||||
// writes only the `X-Minio-Internal-*` family and the public header is
|
||||
// synthesized onto the response by `DecryptObjectInfo`. Requiring it here
|
||||
// is what made every MinIO-encrypted object unreadable (backlog#1638).
|
||||
//
|
||||
// Inferring from the sealed-key slot is self-consistent by construction:
|
||||
// the slot decides which header the unseal reads AND which domain string
|
||||
// the sealing key is derived under, so a scheme that disagrees with the
|
||||
// slot cannot silently derive a wrong key — it finds no key at all.
|
||||
// Inferring from the KMS key id would NOT be safe: MinIO writes
|
||||
// `-S3-Kms-Key-Id` on SSE-S3 objects too.
|
||||
//
|
||||
// An object whose scheme cannot be established stays fail-closed, and
|
||||
// deliberately not through an error raised here: the read plan independently
|
||||
// classifies the object as encrypted from its markers and refuses to serve
|
||||
// it without material, so it never degrades into a plaintext read.
|
||||
#[cfg(feature = "rio-v2")]
|
||||
None => infer_minio_managed_sse_type(metadata),
|
||||
// Without the rio-v2 reader there is no MinIO-format read path to serve
|
||||
// such an object with, so it stays on the fail-closed branch.
|
||||
#[cfg(not(feature = "rio-v2"))]
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// SSE-C: recover the object's key from the customer key.
|
||||
///
|
||||
/// A sealed object key recorded in MinIO's slot is unsealed under the customer key;
|
||||
/// otherwise the customer key is the object's key, under the nonce the object recorded.
|
||||
pub(crate) fn open_under_customer_key(
|
||||
metadata: &HashMap<String, String>,
|
||||
customer_key: [u8; 32],
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
) -> Result<OpenedObjectKey, SseError> {
|
||||
#[cfg(feature = "rio-v2")]
|
||||
if let Some(sealed_key) = parse_minio_managed_sealed_key(metadata, SSEType::SseC)? {
|
||||
return Ok(OpenedObjectKey {
|
||||
key_bytes: unseal_object_key(&sealed_key, customer_key, SSEType::SseC, bucket, key)?,
|
||||
base_nonce: [0; 12],
|
||||
key_kind: EncryptionKeyKind::Object,
|
||||
});
|
||||
}
|
||||
|
||||
Ok(OpenedObjectKey {
|
||||
key_bytes: customer_key,
|
||||
base_nonce: read_stored_ssec_nonce(metadata, bucket, key),
|
||||
key_kind: EncryptionKeyKind::Direct,
|
||||
})
|
||||
}
|
||||
|
||||
/// A stored managed-SSE object, as recognized from its metadata alone.
|
||||
pub(crate) struct StoredManagedKey<'a> {
|
||||
/// The object's metadata as stored.
|
||||
metadata: &'a HashMap<String, String>,
|
||||
/// The same metadata with the managed keys normalized.
|
||||
normalized_metadata: HashMap<String, String>,
|
||||
/// The scheme the object was written under.
|
||||
pub(crate) sse_type: SSEType,
|
||||
/// The KMS key id the object recorded, if it recorded one.
|
||||
pub(crate) recorded_kms_key_id: Option<String>,
|
||||
}
|
||||
|
||||
/// Recognize a stored managed-SSE object.
|
||||
///
|
||||
/// `None` means the object carries no managed-SSE metadata, or carries some whose
|
||||
/// scheme this build cannot establish.
|
||||
pub(crate) fn recognize_stored_managed_key(metadata: &HashMap<String, String>) -> Option<StoredManagedKey<'_>> {
|
||||
if !contains_managed_encryption_metadata(metadata) {
|
||||
return None;
|
||||
}
|
||||
let sse_type = stored_managed_sse_type(metadata)?;
|
||||
|
||||
let normalized_metadata = normalize_managed_metadata(metadata, Some(recode_minio_kms_context));
|
||||
let recorded_kms_key_id = normalized_metadata
|
||||
.get(INTERNAL_ENCRYPTION_KEY_ID_HEADER)
|
||||
.or_else(|| metadata.get("x-amz-server-side-encryption-aws-kms-key-id"))
|
||||
.cloned();
|
||||
|
||||
Some(StoredManagedKey {
|
||||
metadata,
|
||||
normalized_metadata,
|
||||
sse_type,
|
||||
recorded_kms_key_id,
|
||||
})
|
||||
}
|
||||
|
||||
/// Managed SSE: unwrap the stored data key and recover the object's key from it.
|
||||
///
|
||||
/// `kms_key_id` is the key the read was authorized against. Returns the object's key
|
||||
/// together with the algorithm the object recorded.
|
||||
pub(crate) async fn open_under_stored_data_key(
|
||||
host: &dyn SseHost,
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
stored: &StoredManagedKey<'_>,
|
||||
kms_key_id: &str,
|
||||
) -> Result<(OpenedObjectKey, String), SseError> {
|
||||
let record = read_stored_data_key(host, stored).await?;
|
||||
let data_key = unwrap_stored_data_key(host, bucket, key, stored, &record, kms_key_id).await?;
|
||||
|
||||
let opened = match record.mode {
|
||||
StoredKeyMode::Direct { base_nonce } => OpenedObjectKey {
|
||||
key_bytes: data_key,
|
||||
base_nonce,
|
||||
key_kind: EncryptionKeyKind::Direct,
|
||||
},
|
||||
#[cfg(feature = "rio-v2")]
|
||||
StoredKeyMode::Object { sealed_key } => OpenedObjectKey {
|
||||
key_bytes: unseal_object_key(&sealed_key, data_key, stored.sse_type, bucket, key)?,
|
||||
base_nonce: [0u8; 12],
|
||||
key_kind: EncryptionKeyKind::Object,
|
||||
},
|
||||
};
|
||||
|
||||
Ok((opened, record.algorithm))
|
||||
}
|
||||
|
||||
/// Read the stored data key in the mode the object recorded.
|
||||
///
|
||||
/// This is the recognition order: a mode listed earlier claims the object first, and
|
||||
/// Direct takes whatever no other mode recognizes. A mode this build cannot read is
|
||||
/// not listed, so its objects fail in the Direct reader instead of being misread.
|
||||
async fn read_stored_data_key(host: &dyn SseHost, stored: &StoredManagedKey<'_>) -> Result<StoredDataKey, SseError> {
|
||||
#[cfg(feature = "rio-v2")]
|
||||
if let Some(sealed_key) = parse_minio_managed_sealed_key(stored.metadata, stored.sse_type)? {
|
||||
return read_sealed_data_key(stored.metadata, &stored.normalized_metadata, sealed_key);
|
||||
}
|
||||
|
||||
read_wrapped_data_key(host, &stored.normalized_metadata).await
|
||||
}
|
||||
|
||||
/// Unwrap the stored data key with the provider its own bytes identify.
|
||||
async fn unwrap_stored_data_key(
|
||||
host: &dyn SseHost,
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
stored: &StoredManagedKey<'_>,
|
||||
record: &StoredDataKey,
|
||||
kms_key_id: &str,
|
||||
) -> Result<[u8; 32], SseError> {
|
||||
let kms_context = if matches!(stored.sse_type, SSEType::SseKms) {
|
||||
decode_minio_kms_context(stored.metadata)?
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let object_context = build_object_encryption_context(bucket, key, kms_context.as_ref());
|
||||
let wrapped = record.wrapped.as_slice();
|
||||
|
||||
// Persisted wrapping format is the read-side source of truth. The
|
||||
// advertised SSE scheme and current KMS availability are write policy
|
||||
// and runtime state, neither of which identifies the historical provider.
|
||||
//
|
||||
// The one shape that cannot name its provider is a backend-native blob
|
||||
// stored without an envelope. It is offered to the KMS only when the
|
||||
// local provider could not have written those bytes and the active
|
||||
// backend is one whose released versions persisted them that way.
|
||||
let bare_kms = if is_data_key_envelope(wrapped) || is_local_sse_dek(wrapped) {
|
||||
None
|
||||
} else {
|
||||
bare_data_key_kms_provider(host).await
|
||||
};
|
||||
|
||||
// A MinIO sealed key alone does not mean MinIO wrote the object: RustFS's own
|
||||
// writer fills MinIO's metadata slots too, while still storing a RustFS
|
||||
// envelope in them, so neither the slot nor the header name distinguishes the
|
||||
// two. The data key's own shape does. RustFS envelopes are strictly-parsed
|
||||
// JSON; MinIO's builtin-KMS ciphertext is opaque bytes that match neither, so
|
||||
// recognizing RustFS positively — and treating only the remainder as MinIO —
|
||||
// keeps a RustFS envelope from ever reaching MinIO's decoder.
|
||||
#[cfg(feature = "rio-v2")]
|
||||
if matches!(record.mode, StoredKeyMode::Object { .. }) && !is_rustfs_managed_data_key(wrapped) {
|
||||
return decrypt_unenveloped_sealed_dek(bare_kms, get_local_sse_dek_provider(), wrapped, kms_key_id, &object_context)
|
||||
.await;
|
||||
}
|
||||
|
||||
let provider: Arc<dyn SseDekProvider> = if is_data_key_envelope(wrapped) {
|
||||
kms_sse_dek_provider(host).await?
|
||||
} else if let Some(kms_provider) = bare_kms {
|
||||
kms_provider
|
||||
} else {
|
||||
get_local_sse_dek_provider()?
|
||||
};
|
||||
|
||||
#[cfg(feature = "rio-v2")]
|
||||
if is_legacy_rustfs_managed_metadata(&stored.normalized_metadata) {
|
||||
return provider.decrypt_legacy_sse_dek(wrapped, kms_key_id, &object_context).await;
|
||||
}
|
||||
|
||||
provider.decrypt_sse_dek(wrapped, kms_key_id, &object_context).await
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! SSE key resolution: the S3-defined schemes, the internal keying modes, and the entry points that join them.
|
||||
|
||||
pub(crate) mod audit;
|
||||
pub(crate) mod keying;
|
||||
pub(crate) mod read;
|
||||
pub(crate) mod request;
|
||||
pub(crate) mod rewrap;
|
||||
pub(crate) mod s3;
|
||||
pub(crate) mod write;
|
||||
@@ -0,0 +1,303 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Read entry points: resolve the decryption material, or the response headers, for a stored object.
|
||||
|
||||
use crate::core::audit::{record_managed_kms_outcome, stored_envelope_master_key_version};
|
||||
use crate::core::keying::material::DecryptionMaterial;
|
||||
use crate::core::keying::metadata::stored_ssec_metadata;
|
||||
use crate::core::keying::stored::{
|
||||
StoredManagedKey, open_under_customer_key, open_under_stored_data_key, recognize_stored_managed_key,
|
||||
};
|
||||
use crate::core::request::SseKmsPrincipal;
|
||||
use crate::core::s3::authorization::authorize_sse_kms_key;
|
||||
use crate::core::s3::headers::{SseReadResponseHeaders, managed_sse_public_header};
|
||||
use crate::core::s3::scheme::resolve_stored_kms_key_id;
|
||||
use crate::core::s3::ssec::{SsecParams, require_matching_ssec_key, stored_ssec_algorithm, validate_ssec_params};
|
||||
use crate::error::SseError;
|
||||
use crate::host::SseHost;
|
||||
use rustfs_policy::policy::action::KmsAction;
|
||||
use rustfs_utils::http::headers::AMZ_ENCRYPTION_AES;
|
||||
use rustfs_utils::http::object_encryption_keys::{SSEType, contains_managed_encryption_metadata, stored_managed_encryption_key};
|
||||
use std::collections::HashMap;
|
||||
|
||||
impl std::fmt::Debug for DecryptionRequest<'_> {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("DecryptionRequest").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
/// Request parameters for unified decryption
|
||||
pub struct DecryptionRequest<'a> {
|
||||
/// Bucket name
|
||||
pub bucket: &'a str,
|
||||
/// Object key
|
||||
pub key: &'a str,
|
||||
/// Object metadata containing encryption headers
|
||||
pub metadata: &'a HashMap<String, String>,
|
||||
/// SSE-C key (Base64-encoded) - required if object was encrypted with SSE-C
|
||||
pub sse_customer_key: Option<&'a String>,
|
||||
/// SSE-C key MD5 (Base64-encoded) - required if object was encrypted with SSE-C
|
||||
pub sse_customer_key_md5: Option<&'a String>,
|
||||
/// Caller the SSE-KMS key usage is authorized as. `None` marks an internal caller.
|
||||
pub principal: Option<&'a SseKmsPrincipal>,
|
||||
}
|
||||
|
||||
/// **Core API**: Apply decryption based on stored metadata
|
||||
///
|
||||
/// This function automatically detects the encryption type from metadata:
|
||||
/// - SSE-C if customer key is provided
|
||||
/// - SSE-S3/SSE-KMS if managed encryption metadata is found
|
||||
/// - None if object is not encrypted
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `request` - Decryption request with metadata and optional customer key
|
||||
///
|
||||
/// # Returns
|
||||
/// * `Ok(Some(material))` - Decryption should be applied with the returned material
|
||||
/// * `Ok(None)` - Object is not encrypted
|
||||
/// * `Err` - Decryption configuration error or key mismatch
|
||||
///
|
||||
/// # Example
|
||||
/// ```rust,ignore
|
||||
/// let request = DecryptionRequest {
|
||||
/// bucket: &bucket,
|
||||
/// key: &key,
|
||||
/// metadata: &metadata,
|
||||
/// sse_customer_key: sse_customer_key.as_deref(),
|
||||
/// sse_customer_key_md5: sse_customer_key_md5.as_deref(),
|
||||
/// };
|
||||
///
|
||||
/// if let Some(material) = sse_decryption(host, request).await? {
|
||||
/// content_size = material.original_size.unwrap_or(actual_size);
|
||||
/// }
|
||||
/// ```
|
||||
pub async fn sse_decryption(host: &dyn SseHost, request: DecryptionRequest<'_>) -> Result<Option<DecryptionMaterial>, SseError> {
|
||||
// Check for SSE-C encryption
|
||||
if stored_ssec_metadata(request.metadata) {
|
||||
let (key, key_md5) = require_matching_ssec_key(request.metadata, request.sse_customer_key, request.sse_customer_key_md5)?;
|
||||
|
||||
let mut material = apply_ssec_decryption_material(request.bucket, request.key, request.metadata, key, key_md5).await?;
|
||||
material.customer_key_md5 = Some(key_md5.clone());
|
||||
return Ok(Some(material));
|
||||
}
|
||||
|
||||
// Check for managed SSE encryption
|
||||
if contains_managed_encryption_metadata(request.metadata) {
|
||||
return apply_managed_decryption_material(host, request.bucket, request.key, request.metadata, request.principal).await;
|
||||
}
|
||||
|
||||
// No encryption detected
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
/// Read-side response classification for an object whose payload the object
|
||||
/// layer's encryption resolver already decrypted.
|
||||
///
|
||||
/// [`sse_decryption`] both unwraps the data key and derives the response
|
||||
/// headers. The GET path only needs the latter — its stream comes out of the
|
||||
/// object layer decrypted (see [`SseObjectEncryptionResolver`]) — so calling
|
||||
/// [`sse_decryption`] there performed a second KMS `Decrypt` per request whose
|
||||
/// key bytes were discarded. This function reproduces that call's header,
|
||||
/// validation, authorization and audit behavior from stored metadata alone.
|
||||
///
|
||||
/// Contract, mirrored from [`sse_decryption`] item by item:
|
||||
/// - SSE-C: missing request key/MD5 and stored/request MD5 mismatch fail with
|
||||
/// the same errors and precedence, and the provided key is fully validated.
|
||||
/// - Managed SSE: per-key `kms:Decrypt` authorization runs ahead of every other
|
||||
/// failure mode, and the request's KMS audit summary records the same
|
||||
/// scheme/key/version/outcome fields the unwrap-based path recorded. The
|
||||
/// success outcome is honest because a failed unwrap aborts the read in the
|
||||
/// object layer before response classification is ever reached.
|
||||
/// - Objects without SSE metadata — and managed metadata whose scheme cannot
|
||||
/// be established in this build — classify as `None`, exactly where
|
||||
/// [`sse_decryption`] returned `None`.
|
||||
pub async fn classify_sse_read_response(
|
||||
host: &dyn SseHost,
|
||||
request: DecryptionRequest<'_>,
|
||||
) -> Result<Option<SseReadResponseHeaders>, SseError> {
|
||||
if stored_ssec_metadata(request.metadata) {
|
||||
let (key, key_md5) = require_matching_ssec_key(request.metadata, request.sse_customer_key, request.sse_customer_key_md5)?;
|
||||
|
||||
let algorithm = stored_ssec_algorithm(request.metadata);
|
||||
validate_ssec_params(SsecParams {
|
||||
algorithm: algorithm.to_string(),
|
||||
key: key.to_string(),
|
||||
key_md5: key_md5.to_string(),
|
||||
})?;
|
||||
|
||||
return Ok(Some(SseReadResponseHeaders {
|
||||
server_side_encryption: String::from(AMZ_ENCRYPTION_AES),
|
||||
sse_customer_algorithm: Some(String::from(algorithm)),
|
||||
sse_customer_key_md5: Some(key_md5.clone()),
|
||||
ssekms_key_id: None,
|
||||
}));
|
||||
}
|
||||
|
||||
// Same scheme and key resolution as the unwrap path, so authorization and the
|
||||
// response header name the same key.
|
||||
let Some((stored, kms_key_id)) = resolve_stored_managed_key(host, request.metadata).await else {
|
||||
return Ok(None);
|
||||
};
|
||||
|
||||
// Ahead of every other failure mode, so a denied caller learns nothing
|
||||
// about the key beyond "not yours".
|
||||
if let Err(error) =
|
||||
authorize_sse_kms_key(host, request.principal, stored.sse_type, KmsAction::DecryptAction, &kms_key_id).await
|
||||
{
|
||||
if let Some((sse_type, key_id)) = stored_managed_encryption_key(request.metadata) {
|
||||
record_managed_kms_outcome(
|
||||
request.principal,
|
||||
sse_type,
|
||||
Some(&key_id),
|
||||
|| stored_envelope_master_key_version(request.metadata),
|
||||
Err(&error),
|
||||
);
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
|
||||
record_managed_kms_outcome(
|
||||
request.principal,
|
||||
stored.sse_type,
|
||||
Some(&kms_key_id),
|
||||
|| stored_envelope_master_key_version(request.metadata),
|
||||
Ok(()),
|
||||
);
|
||||
|
||||
Ok(Some(SseReadResponseHeaders {
|
||||
server_side_encryption: managed_sse_public_header(stored.sse_type).to_string(),
|
||||
sse_customer_algorithm: None,
|
||||
sse_customer_key_md5: None,
|
||||
// The key id was needed above to authorize the read, but an AES256
|
||||
// object's wrapping key is internal: only aws:kms objects advertise it.
|
||||
ssekms_key_id: matches!(stored.sse_type, SSEType::SseKms).then_some(kms_key_id),
|
||||
}))
|
||||
}
|
||||
|
||||
/// Recognize a stored managed-SSE object and name the key it is read under.
|
||||
///
|
||||
/// One resolution for every read: authorization, the response headers and the
|
||||
/// unwrap all name the key this returns. `None` means the object carries no
|
||||
/// managed-SSE metadata, or carries some whose scheme this build cannot establish.
|
||||
async fn resolve_stored_managed_key<'m>(
|
||||
host: &dyn SseHost,
|
||||
metadata: &'m HashMap<String, String>,
|
||||
) -> Option<(StoredManagedKey<'m>, String)> {
|
||||
let stored = recognize_stored_managed_key(metadata)?;
|
||||
let kms_key_id = resolve_stored_kms_key_id(host, stored.recorded_kms_key_id.clone()).await;
|
||||
Some((stored, kms_key_id))
|
||||
}
|
||||
|
||||
pub(crate) async fn apply_ssec_decryption_material(
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
metadata: &HashMap<String, String>,
|
||||
sse_key: &str,
|
||||
sse_key_md5: &str,
|
||||
) -> Result<DecryptionMaterial, SseError> {
|
||||
// Validate provided key
|
||||
let algorithm = stored_ssec_algorithm(metadata);
|
||||
|
||||
let params = SsecParams {
|
||||
algorithm: algorithm.to_string(),
|
||||
key: sse_key.to_string(),
|
||||
key_md5: sse_key_md5.to_string(),
|
||||
};
|
||||
|
||||
let validated = validate_ssec_params(params)?;
|
||||
let opened = open_under_customer_key(metadata, validated.key_bytes, bucket, key)?;
|
||||
|
||||
Ok(DecryptionMaterial {
|
||||
sse_type: SSEType::SseC,
|
||||
server_side_encryption: String::from(AMZ_ENCRYPTION_AES), // const
|
||||
kms_key_id: None,
|
||||
algorithm: String::from(algorithm),
|
||||
|
||||
customer_key_md5: None,
|
||||
key_bytes: opened.key_bytes,
|
||||
base_nonce: opened.base_nonce,
|
||||
key_kind: opened.key_kind,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) async fn apply_managed_decryption_material(
|
||||
host: &dyn SseHost,
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
metadata: &HashMap<String, String>,
|
||||
principal: Option<&SseKmsPrincipal>,
|
||||
) -> Result<Option<DecryptionMaterial>, SseError> {
|
||||
let result = apply_managed_decryption_material_inner(host, bucket, key, metadata, principal).await;
|
||||
|
||||
match &result {
|
||||
// `None` means the object carries no managed-SSE metadata — SSE-C and
|
||||
// plaintext objects never reach KMS and must not appear in the summary.
|
||||
Ok(None) => {}
|
||||
Ok(Some(material)) => record_managed_kms_outcome(
|
||||
principal,
|
||||
material.sse_type,
|
||||
material.kms_key_id.as_deref(),
|
||||
|| stored_envelope_master_key_version(metadata),
|
||||
Ok(()),
|
||||
),
|
||||
Err(error) => {
|
||||
if let Some((sse_type, key_id)) = stored_managed_encryption_key(metadata) {
|
||||
record_managed_kms_outcome(
|
||||
principal,
|
||||
sse_type,
|
||||
Some(&key_id),
|
||||
|| stored_envelope_master_key_version(metadata),
|
||||
Err(error),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
async fn apply_managed_decryption_material_inner(
|
||||
host: &dyn SseHost,
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
metadata: &HashMap<String, String>,
|
||||
principal: Option<&SseKmsPrincipal>,
|
||||
) -> Result<Option<DecryptionMaterial>, SseError> {
|
||||
let Some((stored, kms_key_id)) = resolve_stored_managed_key(host, metadata).await else {
|
||||
return Ok(None);
|
||||
};
|
||||
|
||||
// Ahead of every other failure mode below, so a denied caller learns nothing about the
|
||||
// key beyond "not yours" — not whether it is disabled, pending deletion, or unreadable.
|
||||
authorize_sse_kms_key(host, principal, stored.sse_type, KmsAction::DecryptAction, &kms_key_id).await?;
|
||||
|
||||
let (opened, algorithm) = open_under_stored_data_key(host, bucket, key, &stored, &kms_key_id).await?;
|
||||
|
||||
Ok(Some(DecryptionMaterial {
|
||||
sse_type: stored.sse_type,
|
||||
// Synthesized from the resolved scheme rather than read back from
|
||||
// metadata: a MinIO-written object has no stored scheme header, which is
|
||||
// exactly why the scheme had to be inferred. MinIO synthesizes the same
|
||||
// header onto its own responses.
|
||||
server_side_encryption: managed_sse_public_header(stored.sse_type).to_string(),
|
||||
kms_key_id: Some(kms_key_id),
|
||||
algorithm,
|
||||
customer_key_md5: None,
|
||||
|
||||
key_bytes: opened.key_bytes,
|
||||
base_nonce: opened.base_nonce,
|
||||
key_kind: opened.key_kind,
|
||||
}))
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! The caller an SSE operation is authorized as.
|
||||
|
||||
use crate::core::audit::{KmsRequestAudit, kms_request_audit};
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
use crate::host::KmsKeyAuthorizer;
|
||||
use serde_json::Value;
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
/// Identity a data-path KMS key operation is attributed to.
|
||||
///
|
||||
/// Only requests that crossed the S3 authorization boundary carry one. Internal
|
||||
/// callers — replication, lifecycle transition, heal, scanner — enter the object
|
||||
/// layer directly and run with server credentials, so they never build a principal
|
||||
/// and are exempt by construction; `None` therefore means "system principal".
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct SseKmsPrincipal {
|
||||
pub(crate) account: String,
|
||||
groups: Option<Vec<String>>,
|
||||
is_owner: bool,
|
||||
claims: HashMap<String, Value>,
|
||||
conditions: HashMap<String, Vec<String>>,
|
||||
/// Audit slot of the S3 request this principal was built for, when the request
|
||||
/// is being audited. The principal is the only request-derived value that reaches
|
||||
/// the managed-SSE code paths, so it doubles as the carrier for the slot.
|
||||
pub(crate) request_audit: Option<Arc<KmsRequestAudit>>,
|
||||
/// Test-only decision overrides. Carried per principal rather than in a global slot so
|
||||
/// concurrent tests cannot observe each other's injection.
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
pub(crate) test_hooks: Option<TestAuthorizationHooks>,
|
||||
}
|
||||
|
||||
impl SseKmsPrincipal {
|
||||
/// Build the principal of a request that crossed the S3 authorization boundary.
|
||||
///
|
||||
/// Anonymous requests use an empty account, matching the bucket-policy authorization
|
||||
/// path. This keeps every request that crossed the S3 boundary distinct from trusted
|
||||
/// internal callers, which are represented by `None`.
|
||||
pub fn new(
|
||||
account: String,
|
||||
groups: Option<Vec<String>>,
|
||||
is_owner: bool,
|
||||
claims: HashMap<String, Value>,
|
||||
conditions: HashMap<String, Vec<String>>,
|
||||
) -> Self {
|
||||
Self {
|
||||
account,
|
||||
groups,
|
||||
is_owner,
|
||||
claims,
|
||||
conditions,
|
||||
request_audit: None,
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
test_hooks: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The access key the request authenticated with; empty for an anonymous request.
|
||||
pub fn account(&self) -> &str {
|
||||
&self.account
|
||||
}
|
||||
|
||||
pub fn groups(&self) -> &Option<Vec<String>> {
|
||||
&self.groups
|
||||
}
|
||||
|
||||
pub fn is_owner(&self) -> bool {
|
||||
self.is_owner
|
||||
}
|
||||
|
||||
pub fn claims(&self) -> &HashMap<String, Value> {
|
||||
&self.claims
|
||||
}
|
||||
|
||||
/// Policy condition values of the request that do not depend on the resource.
|
||||
pub fn conditions(&self) -> &HashMap<String, Vec<String>> {
|
||||
&self.conditions
|
||||
}
|
||||
|
||||
/// Attach the audit slot opened for `request_id`, if that request is being audited
|
||||
/// (see [`KmsRequestAuditScope::register`]).
|
||||
#[must_use]
|
||||
pub fn with_request_id(mut self, request_id: &str) -> Self {
|
||||
self.request_audit = kms_request_audit(request_id);
|
||||
self
|
||||
}
|
||||
|
||||
/// Override the enforcement switch and the authorizer for this principal only.
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
#[must_use]
|
||||
pub fn with_test_hooks(mut self, hooks: Option<TestAuthorizationHooks>) -> Self {
|
||||
self.test_hooks = hooks;
|
||||
self
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn for_test(account: &str, enforced: bool, authorizer: Arc<dyn KmsKeyAuthorizer>) -> Self {
|
||||
Self {
|
||||
account: account.to_string(),
|
||||
groups: None,
|
||||
is_owner: false,
|
||||
claims: HashMap::new(),
|
||||
conditions: HashMap::new(),
|
||||
request_audit: None,
|
||||
test_hooks: Some(TestAuthorizationHooks { enforced, authorizer }),
|
||||
}
|
||||
}
|
||||
|
||||
/// Bind this principal to `audit` so managed-SSE operations performed for it are
|
||||
/// summarised onto the request's S3 audit entry.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn with_request_audit(mut self, audit: Arc<KmsRequestAudit>) -> Self {
|
||||
self.request_audit = Some(audit);
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
/// Per-principal override of SSE-KMS key authorization, for tests.
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
#[derive(Clone)]
|
||||
pub struct TestAuthorizationHooks {
|
||||
pub enforced: bool,
|
||||
pub authorizer: Arc<dyn KmsKeyAuthorizer>,
|
||||
}
|
||||
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
impl std::fmt::Debug for TestAuthorizationHooks {
|
||||
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
formatter
|
||||
.debug_struct("TestAuthorizationHooks")
|
||||
.field("enforced", &self.enforced)
|
||||
.finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Re-wrap a stored data key onto its master key's current version.
|
||||
|
||||
use crate::core::keying::context::{build_object_encryption_context, decode_minio_kms_context};
|
||||
use crate::core::keying::metadata::recode_minio_kms_context;
|
||||
use crate::error::SseError;
|
||||
use crate::host::SseHost;
|
||||
use crate::kms::provider::kms_sse_dek_provider;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use rustfs_kms::is_data_key_envelope;
|
||||
use rustfs_utils::http::headers::AMZ_ENCRYPTION_KMS;
|
||||
use rustfs_utils::http::object_encryption_keys::{
|
||||
INTERNAL_ENCRYPTION_KEY_HEADER, MINIO_INTERNAL_ENCRYPTION_KMS_DATA_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER, MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER, SSEType,
|
||||
contains_managed_encryption_metadata, normalize_managed_metadata,
|
||||
};
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// Outcome of a single object's DEK rewrap attempt.
|
||||
// Consumed by the bulk rekey sweep in the follow-up PR; tests exercise it now.
|
||||
#[allow(dead_code)]
|
||||
#[derive(Debug)]
|
||||
pub enum ObjectDekRewrapOutcome {
|
||||
/// The object carries no KMS-wrapped RustFS data-key envelope this build
|
||||
/// can rewrap: plaintext, SSE-C, or a MinIO-sealed data key.
|
||||
NotApplicable,
|
||||
/// The envelope is already on the current master key version and format;
|
||||
/// the caller must persist nothing, so a sweep re-run converges.
|
||||
AlreadyCurrent,
|
||||
/// The envelope was rewrapped. `metadata` holds the overrides to merge
|
||||
/// into the object's user-defined metadata — every stored copy of the old
|
||||
/// envelope, replaced — via `ObjectLayer::put_object_metadata`.
|
||||
Rewrapped { metadata: HashMap<String, String> },
|
||||
}
|
||||
|
||||
/// Rewrap the KMS-wrapped data key in an object's stored metadata onto its
|
||||
/// master key's current version (and current envelope format), without
|
||||
/// touching the object's data or its plaintext DEK.
|
||||
///
|
||||
/// Mirrors the managed decrypt path byte for byte where it matters: the
|
||||
/// envelope is located through the same normalized-header resolution, and the
|
||||
/// encryption context is rebuilt with the same helpers, so an envelope the
|
||||
/// read path can open is exactly an envelope this can rewrap. The KMS backend
|
||||
/// owns the format and the no-op decision.
|
||||
///
|
||||
/// The returned overrides replace every stored copy of the old envelope
|
||||
/// (RustFS's internal header and the MinIO-compatible slots that the writer
|
||||
/// fills with the same bytes). A copy left behind would win a read-path
|
||||
/// fallback and resurrect the old wrapping, so finding no replaceable copy is
|
||||
/// an error, never a silent success.
|
||||
pub async fn rewrap_object_encryption_metadata(
|
||||
host: &dyn SseHost,
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
metadata: &HashMap<String, String>,
|
||||
) -> Result<ObjectDekRewrapOutcome, SseError> {
|
||||
if !contains_managed_encryption_metadata(metadata) {
|
||||
return Ok(ObjectDekRewrapOutcome::NotApplicable);
|
||||
}
|
||||
|
||||
let encryption_type = match metadata.get("x-amz-server-side-encryption").map(String::as_str) {
|
||||
Some(AMZ_ENCRYPTION_KMS) => SSEType::SseKms,
|
||||
Some(_) => SSEType::SseS3,
|
||||
// MinIO-written objects synthesize the public header on read; their
|
||||
// sealed data keys are not RustFS envelopes and fall out below.
|
||||
None => SSEType::SseS3,
|
||||
};
|
||||
|
||||
let normalized_metadata = normalize_managed_metadata(metadata, Some(recode_minio_kms_context));
|
||||
let Some(envelope_b64) = normalized_metadata
|
||||
.get(INTERNAL_ENCRYPTION_KEY_HEADER)
|
||||
.or_else(|| metadata.get(MINIO_INTERNAL_ENCRYPTION_KMS_DATA_KEY_HEADER))
|
||||
else {
|
||||
return Ok(ObjectDekRewrapOutcome::NotApplicable);
|
||||
};
|
||||
let encrypted_data_key = BASE64_STANDARD
|
||||
.decode_to_vec(envelope_b64)
|
||||
.map_err(|e| SseError::internal(format!("Failed to decode encrypted key: {e}")))?;
|
||||
// Only RustFS envelopes are rewrappable here; MinIO's builtin-KMS
|
||||
// ciphertext is opaque bytes owned by a different root of trust.
|
||||
if !is_data_key_envelope(&encrypted_data_key) {
|
||||
return Ok(ObjectDekRewrapOutcome::NotApplicable);
|
||||
}
|
||||
|
||||
let kms_context = if matches!(encryption_type, SSEType::SseKms) {
|
||||
decode_minio_kms_context(metadata)?
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let object_context = build_object_encryption_context(bucket, key, kms_context.as_ref());
|
||||
|
||||
// The same provider selection as the managed decrypt path.
|
||||
let provider = kms_sse_dek_provider(host).await?;
|
||||
let response = provider.rewrap_sse_dek(&encrypted_data_key, &object_context).await?;
|
||||
if !response.rewrapped {
|
||||
return Ok(ObjectDekRewrapOutcome::AlreadyCurrent);
|
||||
}
|
||||
|
||||
// Replace every stored copy of the old envelope, keyed by value and
|
||||
// matched case-insensitively: metadata key casing drifts through the
|
||||
// storage layer, and an override inserted under a differently-cased name
|
||||
// would sit beside the old copy instead of replacing it. The MinIO
|
||||
// sealed-key slots can instead hold a sealed *object* key (rio-v2 writer);
|
||||
// those bytes differ from the envelope and are untouched — the data key
|
||||
// they seal is unchanged by a rewrap.
|
||||
const REWRAP_ENVELOPE_HEADERS: [&str; 4] = [
|
||||
INTERNAL_ENCRYPTION_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_DATA_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER,
|
||||
];
|
||||
let old_envelope_b64 = envelope_b64.clone();
|
||||
let new_envelope_b64 = BASE64_STANDARD.encode_to_string(&response.ciphertext);
|
||||
let mut overrides = HashMap::new();
|
||||
for (stored_name, stored_value) in metadata {
|
||||
let is_envelope_slot = REWRAP_ENVELOPE_HEADERS
|
||||
.iter()
|
||||
.any(|header| stored_name.eq_ignore_ascii_case(header));
|
||||
if is_envelope_slot && *stored_value == old_envelope_b64 {
|
||||
overrides.insert(stored_name.clone(), new_envelope_b64.clone());
|
||||
}
|
||||
}
|
||||
if overrides.is_empty() {
|
||||
return Err(SseError::internal(
|
||||
"rewrapped a data-key envelope but found no stored metadata copy to replace; refusing a write that would \
|
||||
leave the old wrapping live",
|
||||
));
|
||||
}
|
||||
|
||||
Ok(ObjectDekRewrapOutcome::Rewrapped { metadata: overrides })
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Per-key KMS authorization on the SSE-KMS data path.
|
||||
|
||||
use crate::core::audit::{record_managed_kms_outcome, stored_envelope_master_key_version};
|
||||
use crate::core::request::SseKmsPrincipal;
|
||||
use crate::error::SseError;
|
||||
use crate::host::SseHost;
|
||||
use crate::{LOG_COMPONENT_STORAGE, LOG_SUBSYSTEM_SSE};
|
||||
use rustfs_config::ENV_RUSTFS_KMS_ENFORCE_SSE_KEY_POLICY;
|
||||
use rustfs_policy::policy::action::KmsAction;
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
use rustfs_utils::http::object_encryption_keys::{SSEType, stored_managed_encryption_key};
|
||||
use std::collections::HashMap;
|
||||
use tracing::debug;
|
||||
|
||||
/// Ask the authorizer that decides for `principal`: the host's, unless a test overrode it.
|
||||
async fn is_kms_key_allowed(
|
||||
host: &dyn SseHost,
|
||||
principal: &SseKmsPrincipal,
|
||||
action: KmsAction,
|
||||
key_id: &str,
|
||||
) -> Result<bool, SseError> {
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
if let Some(hooks) = principal.test_hooks.as_ref() {
|
||||
return hooks.authorizer.is_allowed(principal, action, key_id).await;
|
||||
}
|
||||
|
||||
host.kms_key_authorizer().is_allowed(principal, action, key_id).await
|
||||
}
|
||||
|
||||
/// Whether per-key KMS authorization is enforced on the SSE-KMS data path.
|
||||
fn sse_kms_key_policy_enforced(principal: Option<&SseKmsPrincipal>) -> bool {
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
if let Some(hooks) = principal.and_then(|candidate| candidate.test_hooks.as_ref()) {
|
||||
return hooks.enforced;
|
||||
}
|
||||
#[cfg(not(any(test, feature = "test-util")))]
|
||||
let _ = principal;
|
||||
|
||||
crate::startup::key_policy_enforced()
|
||||
}
|
||||
|
||||
/// The principal whose KMS key permissions this operation must satisfy, if any.
|
||||
///
|
||||
/// Scoping is limited to SSE-KMS, matching AWS: SSE-S3 wraps its data key with a
|
||||
/// server-owned key the caller never names, and SSE-C never reaches KMS at all.
|
||||
pub(crate) fn kms_authorization_subject(
|
||||
enforced: bool,
|
||||
principal: Option<&SseKmsPrincipal>,
|
||||
sse_type: SSEType,
|
||||
) -> Option<&SseKmsPrincipal> {
|
||||
if !enforced || !matches!(sse_type, SSEType::SseKms) {
|
||||
return None;
|
||||
}
|
||||
|
||||
principal
|
||||
}
|
||||
|
||||
/// Authorize `action` against `key_id` for the caller behind this SSE operation.
|
||||
///
|
||||
/// Runs before the key is used, so a denied request cannot distinguish an unauthorized
|
||||
/// key from a disabled or pending-deletion one.
|
||||
pub(crate) async fn authorize_sse_kms_key(
|
||||
host: &dyn SseHost,
|
||||
principal: Option<&SseKmsPrincipal>,
|
||||
sse_type: SSEType,
|
||||
action: KmsAction,
|
||||
key_id: &str,
|
||||
) -> Result<(), SseError> {
|
||||
let Some(principal) = kms_authorization_subject(sse_kms_key_policy_enforced(principal), principal, sse_type) else {
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
if is_kms_key_allowed(host, principal, action, key_id).await? {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
debug!(
|
||||
component = LOG_COMPONENT_STORAGE,
|
||||
subsystem = LOG_SUBSYSTEM_SSE,
|
||||
event = "sse_kms_key_authorization_denied",
|
||||
account = %principal.account,
|
||||
action = ?action,
|
||||
"Principal is not authorized for the KMS key resolved for this request"
|
||||
);
|
||||
|
||||
// One warn per process, not per request: anonymous denials are driven by
|
||||
// unauthenticated traffic, so a per-request warn would let anyone flood the
|
||||
// log. Per-request detail stays on the audit entry and the debug event above.
|
||||
if principal.account.is_empty() {
|
||||
static ANONYMOUS_DENIAL_WARNED: std::sync::Once = std::sync::Once::new();
|
||||
ANONYMOUS_DENIAL_WARNED.call_once(|| {
|
||||
tracing::warn!(
|
||||
component = LOG_COMPONENT_STORAGE,
|
||||
subsystem = LOG_SUBSYSTEM_SSE,
|
||||
event = "sse_kms_anonymous_key_authorization_denied",
|
||||
action = ?action,
|
||||
"Anonymous requests are being denied by SSE-KMS per-key authorization: anonymous \
|
||||
callers hold no kms grants, so a public bucket serving SSE-KMS objects is \
|
||||
incompatible with {ENV_RUSTFS_KMS_ENFORCE_SSE_KEY_POLICY}=true. Reported once per \
|
||||
process; per-request denials are on audit entries and at debug level."
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
Err(SseError {
|
||||
code: S3ErrorCode::AccessDenied,
|
||||
message: "Access Denied".to_string(),
|
||||
source: None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Authorize `kms:Decrypt` for an object whose stored encryption material is unwrapped
|
||||
/// outside [`sse_decryption`].
|
||||
///
|
||||
/// The copy-source read resolves its material inside the object layer, which has no
|
||||
/// request identity, so the S3 layer has to run the check itself.
|
||||
pub async fn authorize_sse_kms_object_read(
|
||||
host: &dyn SseHost,
|
||||
principal: Option<&SseKmsPrincipal>,
|
||||
metadata: &HashMap<String, String>,
|
||||
) -> Result<(), SseError> {
|
||||
let Some((sse_type, key_id)) = stored_managed_encryption_key(metadata) else {
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
let result = authorize_sse_kms_key(host, principal, sse_type, KmsAction::DecryptAction, &key_id).await;
|
||||
// Only a denial is recorded here: an allowed read goes on to unwrap the key,
|
||||
// and that operation reports its own outcome.
|
||||
if let Err(error) = &result {
|
||||
record_managed_kms_outcome(
|
||||
principal,
|
||||
sse_type,
|
||||
Some(&key_id),
|
||||
|| stored_envelope_master_key_version(metadata),
|
||||
Err(error),
|
||||
);
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
/// Authorize the current request to write under the upload's stored KMS key.
|
||||
/// Upload IDs do not confer the creator's KMS permissions on another caller.
|
||||
pub async fn authorize_sse_kms_multipart_write(
|
||||
host: &dyn SseHost,
|
||||
principal: Option<&SseKmsPrincipal>,
|
||||
metadata: &HashMap<String, String>,
|
||||
) -> Result<(), SseError> {
|
||||
let Some((sse_type, key_id)) = stored_managed_encryption_key(metadata) else {
|
||||
return Ok(());
|
||||
};
|
||||
let result = authorize_sse_kms_key(host, principal, sse_type, KmsAction::GenerateDataKeyAction, &key_id).await;
|
||||
if let Err(error) = &result {
|
||||
record_managed_kms_outcome(
|
||||
principal,
|
||||
sse_type,
|
||||
Some(&key_id),
|
||||
|| stored_envelope_master_key_version(metadata),
|
||||
Err(error),
|
||||
);
|
||||
}
|
||||
result
|
||||
}
|
||||
@@ -0,0 +1,454 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! SSE request headers in, SSE response headers out.
|
||||
|
||||
use crate::core::keying::metadata::{normalize_encryption_metadata_case, recode_minio_kms_context, stored_ssec_metadata};
|
||||
use crate::core::s3::ssec::ssec_invalid_request;
|
||||
use crate::error::SseError;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use http::{HeaderMap, HeaderName, HeaderValue};
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
use rustfs_utils::http::headers::{
|
||||
AMZ_ENCRYPTION_AES, AMZ_ENCRYPTION_KMS, AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM,
|
||||
AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY, AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5, AMZ_SERVER_SIDE_ENCRYPTION_KMS_CONTEXT,
|
||||
SSEC_ALGORITHM_HEADER, SSEC_KEY_MD5_HEADER,
|
||||
};
|
||||
use rustfs_utils::http::object_encryption_keys::{
|
||||
INTERNAL_ENCRYPTION_CONTEXT_HEADER, INTERNAL_ENCRYPTION_KEY_ID_HEADER, MINIO_INTERNAL_ENCRYPTION_KMS_CONTEXT_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_KMS_KEY_ID_HEADER, MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER,
|
||||
MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER, MINIO_INTERNAL_ENCRYPTION_SSEC_SEALED_KEY_HEADER, SSEType,
|
||||
normalize_managed_metadata,
|
||||
};
|
||||
use std::collections::HashMap;
|
||||
|
||||
// The same header names s3s publishes. Owned so this module does not import s3s.
|
||||
pub(crate) const X_AMZ_SERVER_SIDE_ENCRYPTION: HeaderName = HeaderName::from_static("x-amz-server-side-encryption");
|
||||
|
||||
pub(crate) const X_AMZ_SERVER_SIDE_ENCRYPTION_AWS_KMS_KEY_ID: HeaderName =
|
||||
HeaderName::from_static("x-amz-server-side-encryption-aws-kms-key-id");
|
||||
|
||||
pub(crate) const X_AMZ_SERVER_SIDE_ENCRYPTION_CONTEXT: HeaderName =
|
||||
HeaderName::from_static("x-amz-server-side-encryption-context");
|
||||
|
||||
pub(crate) const X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM: HeaderName =
|
||||
HeaderName::from_static("x-amz-server-side-encryption-customer-algorithm");
|
||||
|
||||
pub(crate) const X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5: HeaderName =
|
||||
HeaderName::from_static("x-amz-server-side-encryption-customer-key-md5");
|
||||
|
||||
#[inline]
|
||||
pub(crate) fn sse_invalid_argument(message: &str) -> SseError {
|
||||
SseError {
|
||||
code: S3ErrorCode::InvalidArgument,
|
||||
message: message.to_string(),
|
||||
source: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// SSE-C parameters extracted from headers (algorithm, key, key MD5).
|
||||
pub type SsecParamsFromHeaders = (Option<String>, Option<String>, Option<String>);
|
||||
|
||||
/// Extract SSE-C parameters from request headers.
|
||||
/// Used as fallback when the S3 layer does not populate them in the input struct.
|
||||
///
|
||||
/// Returns an error if an SSE-C header is present but cannot be parsed as valid UTF-8,
|
||||
/// ensuring malformed headers do not bypass validation.
|
||||
pub fn extract_ssec_params_from_headers(headers: &HeaderMap) -> Result<SsecParamsFromHeaders, SseError> {
|
||||
let algorithm = match headers.get("x-amz-server-side-encryption-customer-algorithm") {
|
||||
None => Ok(None),
|
||||
Some(v) => v
|
||||
.to_str()
|
||||
.map(|s| Some(s.to_string()))
|
||||
.map_err(|_| sse_invalid_argument("The x-amz-server-side-encryption-customer-algorithm header must be valid UTF-8.")),
|
||||
}?;
|
||||
|
||||
let key = match headers.get("x-amz-server-side-encryption-customer-key") {
|
||||
None => Ok(None),
|
||||
Some(v) => v
|
||||
.to_str()
|
||||
.map(|s| Some(s.to_string()))
|
||||
.map_err(|_| sse_invalid_argument("The x-amz-server-side-encryption-customer-key header must be valid UTF-8.")),
|
||||
}?;
|
||||
|
||||
let key_md5 = match headers.get("x-amz-server-side-encryption-customer-key-md5") {
|
||||
None => Ok(None),
|
||||
Some(v) => v
|
||||
.to_str()
|
||||
.map(|s| Some(s.to_string()))
|
||||
.map_err(|_| sse_invalid_argument("The x-amz-server-side-encryption-customer-key-md5 header must be valid UTF-8.")),
|
||||
}?;
|
||||
|
||||
Ok((algorithm, key, key_md5))
|
||||
}
|
||||
|
||||
/// Extract x-amz-server-side-encryption from request headers.
|
||||
/// Used as fallback when the S3 layer does not populate it in the input struct.
|
||||
///
|
||||
/// Returns an error if the header is present but cannot be parsed as valid UTF-8,
|
||||
/// ensuring malformed headers do not bypass validation.
|
||||
pub fn extract_server_side_encryption_from_headers(headers: &HeaderMap) -> Result<Option<String>, SseError> {
|
||||
match headers.get("x-amz-server-side-encryption") {
|
||||
None => Ok(None),
|
||||
Some(v) => v
|
||||
.to_str()
|
||||
.map(|s| Some(s.to_string()))
|
||||
.map_err(|_| sse_invalid_argument("The x-amz-server-side-encryption header must be valid UTF-8.")),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn extract_ssekms_context_from_headers(headers: &HeaderMap) -> Result<Option<HashMap<String, String>>, SseError> {
|
||||
let Some(v) = headers.get(AMZ_SERVER_SIDE_ENCRYPTION_KMS_CONTEXT) else {
|
||||
return Ok(None);
|
||||
};
|
||||
|
||||
let value = v
|
||||
.to_str()
|
||||
.map_err(|_| sse_invalid_argument("The x-amz-server-side-encryption-context header must be valid UTF-8."))?;
|
||||
let decoded = BASE64_STANDARD.decode_to_vec(value).map_err(|_| {
|
||||
sse_invalid_argument("The x-amz-server-side-encryption-context header must be valid base64-encoded JSON.")
|
||||
})?;
|
||||
|
||||
serde_json::from_slice(&decoded).map(Some).map_err(|_| {
|
||||
sse_invalid_argument("The x-amz-server-side-encryption-context header must be a base64-encoded JSON object.")
|
||||
})
|
||||
}
|
||||
|
||||
/// Rejects a client encryption context that would replace the location binding.
|
||||
///
|
||||
/// The request context binds the data key to `{bucket: bucket/key}` only when the
|
||||
/// client supplied no entry under that name, and only the client context is
|
||||
/// persisted. A client entry keyed by the bucket name therefore travels with the
|
||||
/// object and replaces the binding on every read, so the envelope would no longer
|
||||
/// be tied to the object's location. Only the write side rejects it: objects stored
|
||||
/// with such an entry stay readable because the read side rebuilds the context
|
||||
/// unchanged.
|
||||
pub(crate) fn reject_kms_context_location_override(
|
||||
bucket: &str,
|
||||
ssekms_context: Option<&HashMap<String, String>>,
|
||||
) -> Result<(), SseError> {
|
||||
if ssekms_context.is_some_and(|context| context.contains_key(bucket)) {
|
||||
return Err(sse_invalid_argument(&format!(
|
||||
"The x-amz-server-side-encryption-context header contains the key \"{bucket}\", which equals the bucket name; \
|
||||
that key is reserved for binding the data key to the object's location."
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn validate_sse_headers_for_write(
|
||||
server_side_encryption: Option<&str>,
|
||||
ssekms_key_id: Option<&String>,
|
||||
ssekms_context: Option<&HashMap<String, String>>,
|
||||
sse_customer_algorithm: Option<&String>,
|
||||
sse_customer_key: Option<&String>,
|
||||
sse_customer_key_md5: Option<&String>,
|
||||
require_sse_customer_key: bool,
|
||||
) -> Result<(), SseError> {
|
||||
if let Some(sse) = server_side_encryption {
|
||||
let s = sse;
|
||||
if s != AMZ_ENCRYPTION_AES && s != AMZ_ENCRYPTION_KMS {
|
||||
return Err(sse_invalid_argument(
|
||||
"The SSE algorithm specified is not supported. The valid values are AES256 or aws:kms.",
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
let has_ssec_headers = sse_customer_algorithm.is_some() || sse_customer_key.is_some() || sse_customer_key_md5.is_some();
|
||||
let has_managed_headers = server_side_encryption.is_some() || ssekms_key_id.is_some() || ssekms_context.is_some();
|
||||
|
||||
if has_ssec_headers {
|
||||
if has_managed_headers {
|
||||
return Err(sse_invalid_argument(
|
||||
"The SSE-C and managed server-side encryption headers cannot be used together.",
|
||||
));
|
||||
}
|
||||
|
||||
let has_valid_ssec_headers = if require_sse_customer_key {
|
||||
matches!(
|
||||
(sse_customer_algorithm, sse_customer_key, sse_customer_key_md5),
|
||||
(Some(_), Some(_), Some(_))
|
||||
)
|
||||
} else {
|
||||
matches!((sse_customer_algorithm, sse_customer_key_md5), (Some(_), Some(_)))
|
||||
};
|
||||
|
||||
if !has_valid_ssec_headers {
|
||||
let message = if require_sse_customer_key {
|
||||
"Missing SSE-C parameters. Algorithm, customer key and customer key MD5 are all required."
|
||||
} else {
|
||||
"Missing SSE-C parameters. Algorithm and customer key MD5 are required."
|
||||
};
|
||||
|
||||
return Err(ssec_invalid_request(message));
|
||||
}
|
||||
}
|
||||
|
||||
if ssekms_key_id.is_some() && server_side_encryption.is_none_or(|sse| sse != AMZ_ENCRYPTION_KMS) {
|
||||
return Err(sse_invalid_argument(
|
||||
"The SSE-KMS key ID header can only be used when x-amz-server-side-encryption is set to aws:kms.",
|
||||
));
|
||||
}
|
||||
|
||||
if ssekms_context.is_some() && server_side_encryption.is_none_or(|sse| sse != AMZ_ENCRYPTION_KMS) {
|
||||
return Err(sse_invalid_argument(
|
||||
"The SSE-KMS context header can only be used when x-amz-server-side-encryption is set to aws:kms.",
|
||||
));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn validate_sse_headers_for_read(metadata: &HashMap<String, String>, headers: &HeaderMap) -> Result<(), SseError> {
|
||||
let has_req_ssec = headers.contains_key("x-amz-server-side-encryption-customer-algorithm")
|
||||
|| headers.contains_key("x-amz-server-side-encryption-customer-key")
|
||||
|| headers.contains_key("x-amz-server-side-encryption-customer-key-md5");
|
||||
|
||||
let has_req_sse = headers.contains_key("x-amz-server-side-encryption")
|
||||
|| headers.contains_key("x-amz-server-side-encryption-aws-kms-key-id")
|
||||
|| headers.contains_key("x-amz-server-side-encryption-context");
|
||||
|
||||
let is_object_ssec = stored_ssec_metadata(metadata);
|
||||
let is_object_sse = metadata.contains_key("x-amz-server-side-encryption");
|
||||
|
||||
if is_object_ssec {
|
||||
if has_req_sse {
|
||||
return Err(sse_invalid_argument(
|
||||
"Server-side encryption headers cannot be used with an object encrypted using SSE-C.",
|
||||
));
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if is_object_sse && has_req_ssec {
|
||||
return Err(sse_invalid_argument(
|
||||
"SSE-C headers cannot be used with an object encrypted using server-side managed encryption.",
|
||||
));
|
||||
}
|
||||
|
||||
if has_req_ssec {
|
||||
return Err(ssec_invalid_request(
|
||||
"The object was stored without SSE-C. The correct SSE-C parameters must not be provided.",
|
||||
));
|
||||
}
|
||||
|
||||
if has_req_sse {
|
||||
return Err(sse_invalid_argument(
|
||||
"The object is not encrypted with server-side encryption. Do not provide server-side encryption headers.",
|
||||
));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The public `x-amz-server-side-encryption` value a managed scheme reports.
|
||||
pub(crate) fn managed_sse_public_header(sse_type: SSEType) -> &'static str {
|
||||
match sse_type {
|
||||
SSEType::SseKms => AMZ_ENCRYPTION_KMS,
|
||||
// SSE-C never reaches the managed path; reporting AES256 keeps this
|
||||
// total without inventing a third public value.
|
||||
SSEType::SseS3 | SSEType::SseC => AMZ_ENCRYPTION_AES,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn build_ssec_read_headers(algorithm: Option<&String>, key: Option<&String>, key_md5: Option<&String>) -> HeaderMap {
|
||||
let mut headers = HeaderMap::new();
|
||||
|
||||
if let Some(algorithm) = algorithm
|
||||
&& let Ok(mut value) = HeaderValue::from_str(algorithm.as_str())
|
||||
{
|
||||
value.set_sensitive(true);
|
||||
headers.insert(AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM, value);
|
||||
}
|
||||
|
||||
if let Some(key) = key
|
||||
&& let Ok(mut value) = HeaderValue::from_str(key.as_str())
|
||||
{
|
||||
value.set_sensitive(true);
|
||||
headers.insert(AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY, value);
|
||||
}
|
||||
|
||||
if let Some(key_md5) = key_md5
|
||||
&& let Ok(mut value) = HeaderValue::from_str(key_md5.as_str())
|
||||
{
|
||||
value.set_sensitive(true);
|
||||
headers.insert(AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5, value);
|
||||
}
|
||||
|
||||
headers
|
||||
}
|
||||
|
||||
/// Response headers derived for a decrypted read without unwrapping the data key.
|
||||
#[derive(Debug)]
|
||||
pub struct SseReadResponseHeaders {
|
||||
pub server_side_encryption: String,
|
||||
pub sse_customer_algorithm: Option<String>,
|
||||
pub sse_customer_key_md5: Option<String>,
|
||||
pub ssekms_key_id: Option<String>,
|
||||
}
|
||||
|
||||
fn invalid_sse_response_metadata() -> SseError {
|
||||
SseError {
|
||||
code: S3ErrorCode::InternalError,
|
||||
message: "Persisted object encryption metadata is invalid.".to_string(),
|
||||
source: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn insert_sse_response_header(headers: &mut HeaderMap, name: HeaderName, value: &str) -> Result<(), SseError> {
|
||||
let value = HeaderValue::from_str(value).map_err(|_| invalid_sse_response_metadata())?;
|
||||
headers.insert(name, value);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Project response headers after the caller has completed its existing read
|
||||
/// validation and KMS authorization path.
|
||||
pub fn project_sse_read_response_headers(
|
||||
metadata: &HashMap<String, String>,
|
||||
sse_customer_algorithm: Option<&String>,
|
||||
sse_customer_key_md5: Option<&String>,
|
||||
) -> Result<HeaderMap, SseError> {
|
||||
if metadata.keys().any(|key| {
|
||||
key.eq_ignore_ascii_case(AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY)
|
||||
|| key.eq_ignore_ascii_case(AMZ_SERVER_SIDE_ENCRYPTION_KMS_CONTEXT)
|
||||
}) {
|
||||
return Err(invalid_sse_response_metadata());
|
||||
}
|
||||
|
||||
let metadata = normalize_encryption_metadata_case(metadata).map_err(|_| invalid_sse_response_metadata())?;
|
||||
let public_mode = metadata.get("x-amz-server-side-encryption").map(String::as_str);
|
||||
let customer_algorithm = metadata.get(SSEC_ALGORITHM_HEADER).map(String::as_str);
|
||||
|
||||
let public_mode = match public_mode {
|
||||
Some(AMZ_ENCRYPTION_AES) => Some(SSEType::SseS3),
|
||||
Some(AMZ_ENCRYPTION_KMS) => Some(SSEType::SseKms),
|
||||
Some(_) => return Err(invalid_sse_response_metadata()),
|
||||
None => None,
|
||||
};
|
||||
if customer_algorithm.is_some_and(|algorithm| algorithm != AMZ_ENCRYPTION_AES) {
|
||||
return Err(invalid_sse_response_metadata());
|
||||
}
|
||||
|
||||
let mode = if customer_algorithm.is_some() {
|
||||
if public_mode == Some(SSEType::SseKms) {
|
||||
return Err(invalid_sse_response_metadata());
|
||||
}
|
||||
Some(SSEType::SseC)
|
||||
} else {
|
||||
public_mode
|
||||
};
|
||||
for marker_mode in [
|
||||
metadata
|
||||
.contains_key(MINIO_INTERNAL_ENCRYPTION_SSEC_SEALED_KEY_HEADER)
|
||||
.then_some(SSEType::SseC),
|
||||
metadata
|
||||
.contains_key(MINIO_INTERNAL_ENCRYPTION_S3_SEALED_KEY_HEADER)
|
||||
.then_some(SSEType::SseS3),
|
||||
metadata
|
||||
.contains_key(MINIO_INTERNAL_ENCRYPTION_KMS_SEALED_KEY_HEADER)
|
||||
.then_some(SSEType::SseKms),
|
||||
]
|
||||
.into_iter()
|
||||
.flatten()
|
||||
{
|
||||
if mode != Some(marker_mode) {
|
||||
return Err(invalid_sse_response_metadata());
|
||||
}
|
||||
}
|
||||
let Some(mode) = mode else {
|
||||
if metadata
|
||||
.keys()
|
||||
.any(|key| rustfs_utils::http::is_object_encryption_marker(key))
|
||||
{
|
||||
return Err(invalid_sse_response_metadata());
|
||||
}
|
||||
return Ok(HeaderMap::new());
|
||||
};
|
||||
|
||||
let mut key_id = None;
|
||||
for value in [
|
||||
metadata.get("x-amz-server-side-encryption-aws-kms-key-id"),
|
||||
metadata.get(INTERNAL_ENCRYPTION_KEY_ID_HEADER),
|
||||
metadata.get(MINIO_INTERNAL_ENCRYPTION_KMS_KEY_ID_HEADER),
|
||||
]
|
||||
.into_iter()
|
||||
.flatten()
|
||||
{
|
||||
if key_id.is_some_and(|current| current != value) {
|
||||
return Err(invalid_sse_response_metadata());
|
||||
}
|
||||
key_id = Some(value);
|
||||
}
|
||||
|
||||
let normalized_managed = normalize_managed_metadata(metadata.as_ref(), Some(recode_minio_kms_context));
|
||||
let mut response_headers = HeaderMap::with_capacity(3);
|
||||
match mode {
|
||||
SSEType::SseS3 => {
|
||||
if metadata.contains_key("x-amz-server-side-encryption-aws-kms-key-id") || metadata.contains_key(SSEC_KEY_MD5_HEADER)
|
||||
{
|
||||
return Err(invalid_sse_response_metadata());
|
||||
}
|
||||
response_headers.insert(X_AMZ_SERVER_SIDE_ENCRYPTION, HeaderValue::from_static(AMZ_ENCRYPTION_AES));
|
||||
}
|
||||
SSEType::SseKms => {
|
||||
if metadata.contains_key(SSEC_KEY_MD5_HEADER) {
|
||||
return Err(invalid_sse_response_metadata());
|
||||
}
|
||||
let key_id = key_id
|
||||
.map(String::as_str)
|
||||
.filter(|value| !value.is_empty())
|
||||
.ok_or_else(invalid_sse_response_metadata)?;
|
||||
response_headers.insert(X_AMZ_SERVER_SIDE_ENCRYPTION, HeaderValue::from_static(AMZ_ENCRYPTION_KMS));
|
||||
insert_sse_response_header(&mut response_headers, X_AMZ_SERVER_SIDE_ENCRYPTION_AWS_KMS_KEY_ID, key_id)?;
|
||||
|
||||
if metadata.contains_key(MINIO_INTERNAL_ENCRYPTION_KMS_CONTEXT_HEADER)
|
||||
&& !normalized_managed.contains_key(INTERNAL_ENCRYPTION_CONTEXT_HEADER)
|
||||
{
|
||||
return Err(invalid_sse_response_metadata());
|
||||
}
|
||||
if let Some(context) = normalized_managed.get(INTERNAL_ENCRYPTION_CONTEXT_HEADER) {
|
||||
serde_json::from_str::<HashMap<String, String>>(context).map_err(|_| invalid_sse_response_metadata())?;
|
||||
let encoded = BASE64_STANDARD.encode_to_string(context);
|
||||
insert_sse_response_header(&mut response_headers, X_AMZ_SERVER_SIDE_ENCRYPTION_CONTEXT, &encoded)?;
|
||||
}
|
||||
}
|
||||
SSEType::SseC => {
|
||||
if key_id.is_some() || normalized_managed.contains_key(INTERNAL_ENCRYPTION_CONTEXT_HEADER) {
|
||||
return Err(invalid_sse_response_metadata());
|
||||
}
|
||||
let algorithm = sse_customer_algorithm
|
||||
.map(|value| value.as_ref())
|
||||
.filter(|value| *value == AMZ_ENCRYPTION_AES)
|
||||
.ok_or_else(|| {
|
||||
ssec_invalid_request(
|
||||
"The object was stored using a form of Server Side Encryption. The correct parameters must be provided to retrieve the object.",
|
||||
)
|
||||
})?;
|
||||
let key_md5 = sse_customer_key_md5
|
||||
.map(|value| value.as_ref())
|
||||
.ok_or_else(|| ssec_invalid_request("Missing SSE-C customer key MD5."))?;
|
||||
let stored_md5 = metadata.get(SSEC_KEY_MD5_HEADER).ok_or_else(invalid_sse_response_metadata)?;
|
||||
if stored_md5 != key_md5 {
|
||||
return Err(ssec_invalid_request(
|
||||
"The provided encryption parameters did not match the ones used originally to encrypt the object.",
|
||||
));
|
||||
}
|
||||
insert_sse_response_header(&mut response_headers, X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM, algorithm)?;
|
||||
insert_sse_response_header(&mut response_headers, X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5, key_md5)?;
|
||||
}
|
||||
}
|
||||
Ok(response_headers)
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! The schemes S3 defines: SSE-S3, SSE-KMS and SSE-C, as a request names them and a response reports them.
|
||||
|
||||
pub(crate) mod authorization;
|
||||
pub(crate) mod headers;
|
||||
pub(crate) mod scheme;
|
||||
pub(crate) mod ssec;
|
||||
@@ -0,0 +1,288 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Which SSE scheme and which key a request resolves to: the request first, then the bucket default.
|
||||
|
||||
use crate::core::s3::headers::validate_sse_headers_for_write;
|
||||
use crate::error::SseError;
|
||||
use crate::host::SseHost;
|
||||
use crate::{LOG_COMPONENT_STORAGE, LOG_SUBSYSTEM_SSE};
|
||||
use rustfs_utils::http::headers::{AMZ_ENCRYPTION_AES, AMZ_ENCRYPTION_KMS};
|
||||
use rustfs_utils::http::object_encryption_keys::SSEType;
|
||||
use std::collections::HashMap;
|
||||
use tracing::debug;
|
||||
|
||||
pub const DEFAULT_SSE_ALGORITHM: &str = "AES256";
|
||||
|
||||
pub(crate) const SUPPORT_SSE_ALGORITHMS: &[&str] = &[DEFAULT_SSE_ALGORITHM];
|
||||
|
||||
/// SSE configuration resolved from request and bucket defaults
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct SseConfiguration {
|
||||
/// Effective server-side encryption algorithm (after considering bucket defaults)
|
||||
pub effective_sse: String,
|
||||
/// Effective KMS key ID (after considering bucket defaults)
|
||||
pub effective_kms_key_id: Option<String>,
|
||||
}
|
||||
|
||||
/// Managed SSE resolved from a bucket default encryption rule on a write path.
|
||||
///
|
||||
/// The single mapping shared by every writer: the resolver in this crate, and
|
||||
/// the server's PUT, COPY and extract paths. Unknown algorithms fall back to AES256 rather
|
||||
/// than to `None`. Resolving `None` instead lets a same-name copy under a
|
||||
/// malformed bucket default pass the `copy_changes_encryption` guard and take
|
||||
/// the metadata-only shortcut while this layer still encrypts: fresh DEK
|
||||
/// metadata is committed beside the untouched plaintext blocks and the object
|
||||
/// becomes unreadable. PutBucketEncryption refuses unknown algorithms, so this
|
||||
/// is reachable only through a configuration stored before that check or
|
||||
/// through hand-edited bucket metadata (backlog#1826).
|
||||
pub fn bucket_default_write_sse(sse_algorithm: &str) -> String {
|
||||
match sse_algorithm {
|
||||
"AES256" => String::from(AMZ_ENCRYPTION_AES),
|
||||
"aws:kms" => String::from(AMZ_ENCRYPTION_KMS),
|
||||
_ => String::from(AMZ_ENCRYPTION_AES),
|
||||
}
|
||||
}
|
||||
|
||||
/// Prepare SSE configuration by resolving request parameters with bucket defaults
|
||||
///
|
||||
/// This function:
|
||||
/// 1. Queries bucket default encryption configuration
|
||||
/// 2. Resolves effective encryption (request overrides bucket default)
|
||||
/// 3. Prepares metadata headers for managed SSE
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `bucket` - Bucket name
|
||||
/// * `server_side_encryption` - SSE algorithm from request (SSE-S3 or SSE-KMS)
|
||||
/// * `ssekms_key_id` - KMS key ID from request
|
||||
/// * `sse_customer_algorithm` - SSE-C algorithm from request
|
||||
///
|
||||
/// # Returns
|
||||
/// `SseConfiguration` with resolved encryption parameters and metadata headers
|
||||
pub(crate) async fn prepare_sse_configuration(
|
||||
host: &dyn SseHost,
|
||||
bucket: &str,
|
||||
server_side_encryption: Option<String>,
|
||||
ssekms_key_id: Option<String>,
|
||||
) -> Result<Option<SseConfiguration>, SseError> {
|
||||
if let Some(server_side_encryption) = server_side_encryption.clone()
|
||||
&& server_side_encryption.as_str() == AMZ_ENCRYPTION_AES
|
||||
{
|
||||
return Ok(Some(SseConfiguration {
|
||||
effective_sse: server_side_encryption,
|
||||
effective_kms_key_id: None,
|
||||
}));
|
||||
}
|
||||
|
||||
if let Some(server_side_encryption) = server_side_encryption.clone()
|
||||
&& let Some(ssekms_key_id) = ssekms_key_id
|
||||
{
|
||||
return Ok(Some(SseConfiguration {
|
||||
effective_sse: server_side_encryption,
|
||||
effective_kms_key_id: Some(ssekms_key_id),
|
||||
}));
|
||||
}
|
||||
|
||||
// Get bucket default encryption configuration.
|
||||
let bucket_encryption = host.bucket_encryption(bucket).await;
|
||||
debug!(
|
||||
component = LOG_COMPONENT_STORAGE,
|
||||
subsystem = LOG_SUBSYSTEM_SSE,
|
||||
event = "bucket_sse_config_lookup",
|
||||
bucket = %bucket,
|
||||
found = matches!(bucket_encryption, Ok(Some(_))),
|
||||
"Bucket SSE configuration lookup completed"
|
||||
);
|
||||
|
||||
let Some(bucket_encryption) = bucket_encryption? else {
|
||||
// The bucket has no SSE config. If the user explicitly requested
|
||||
// aws:kms, we must honor that — return the explicit SSE header so
|
||||
// downstream logic can try (and fail if KMS is unavailable).
|
||||
return Ok(server_side_encryption.map(|sse| SseConfiguration {
|
||||
effective_sse: sse,
|
||||
effective_kms_key_id: ssekms_key_id,
|
||||
}));
|
||||
};
|
||||
|
||||
let default_rule = bucket_encryption.default_rule.as_ref();
|
||||
let effective_sse = server_side_encryption.clone().or_else(|| {
|
||||
default_rule.map(|sse| {
|
||||
debug!(
|
||||
component = LOG_COMPONENT_STORAGE,
|
||||
subsystem = LOG_SUBSYSTEM_SSE,
|
||||
event = "bucket_sse_default_applied",
|
||||
bucket = %bucket,
|
||||
algorithm = sse.sse_algorithm.as_str(),
|
||||
has_kms_key_id = sse.kms_master_key_id.is_some(),
|
||||
"Bucket SSE default resolved"
|
||||
);
|
||||
bucket_default_write_sse(&sse.sse_algorithm)
|
||||
})
|
||||
});
|
||||
let Some(effective_sse) = effective_sse else {
|
||||
return Ok(None);
|
||||
};
|
||||
|
||||
debug!(
|
||||
component = LOG_COMPONENT_STORAGE,
|
||||
subsystem = LOG_SUBSYSTEM_SSE,
|
||||
event = "effective_sse_resolved",
|
||||
bucket = %bucket,
|
||||
requested = ?server_side_encryption,
|
||||
effective = ?effective_sse,
|
||||
"Resolved effective SSE configuration"
|
||||
);
|
||||
|
||||
let effective_kms_key_id = resolve_effective_kms_key_id(Some(&effective_sse), ssekms_key_id, || {
|
||||
default_rule.and_then(|sse| sse.kms_master_key_id.clone())
|
||||
});
|
||||
|
||||
Ok(Some(SseConfiguration {
|
||||
effective_sse,
|
||||
effective_kms_key_id,
|
||||
}))
|
||||
}
|
||||
|
||||
pub(crate) fn resolve_effective_kms_key_id<F>(
|
||||
effective_sse: Option<&str>,
|
||||
requested_kms_key_id: Option<String>,
|
||||
bucket_default_kms_key_id: F,
|
||||
) -> Option<String>
|
||||
where
|
||||
F: FnOnce() -> Option<String>,
|
||||
{
|
||||
if effective_sse.is_none_or(|sse| sse != AMZ_ENCRYPTION_KMS) {
|
||||
return requested_kms_key_id;
|
||||
}
|
||||
|
||||
requested_kms_key_id.or_else(bucket_default_kms_key_id)
|
||||
}
|
||||
|
||||
/// The SSE headers of a write request, as the S3 layer received them.
|
||||
pub(crate) struct WriteSchemeHeaders<'a> {
|
||||
pub(crate) server_side_encryption: Option<String>,
|
||||
pub(crate) ssekms_key_id: Option<String>,
|
||||
pub(crate) ssekms_context: Option<&'a HashMap<String, String>>,
|
||||
pub(crate) sse_customer_algorithm: Option<String>,
|
||||
pub(crate) sse_customer_key: Option<String>,
|
||||
pub(crate) sse_customer_key_md5: Option<String>,
|
||||
}
|
||||
|
||||
/// The scheme a write resolved to, in S3's terms.
|
||||
#[derive(Clone)]
|
||||
pub(crate) enum WriteScheme {
|
||||
/// `AES256`: the server chooses the wrapping key and the caller names none.
|
||||
SseS3,
|
||||
/// `aws:kms`, under the key the request or the bucket default named, if either did.
|
||||
SseKms { key_id: Option<String> },
|
||||
/// A key the client supplies; only its MD5 is ever stored.
|
||||
SseC {
|
||||
algorithm: String,
|
||||
key: String,
|
||||
key_md5: String,
|
||||
},
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for WriteScheme {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(match self {
|
||||
Self::SseS3 => "SseS3",
|
||||
Self::SseKms { .. } => "SseKms(..)",
|
||||
Self::SseC { .. } => "SseC(..)",
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Decide the scheme of a write: validate the headers, then the request first and the
|
||||
/// bucket default second.
|
||||
///
|
||||
/// Every write goes through here, an object and a multipart session alike, so the two
|
||||
/// cannot resolve the same headers differently.
|
||||
pub(crate) async fn resolve_write_scheme(
|
||||
host: &dyn SseHost,
|
||||
bucket: &str,
|
||||
headers: WriteSchemeHeaders<'_>,
|
||||
) -> Result<Option<WriteScheme>, SseError> {
|
||||
validate_sse_headers_for_write(
|
||||
headers.server_side_encryption.as_deref(),
|
||||
headers.ssekms_key_id.as_ref(),
|
||||
headers.ssekms_context,
|
||||
headers.sse_customer_algorithm.as_ref(),
|
||||
headers.sse_customer_key.as_ref(),
|
||||
headers.sse_customer_key_md5.as_ref(),
|
||||
true,
|
||||
)?;
|
||||
|
||||
// Validation admits SSE-C headers only as a complete set, and never beside the
|
||||
// managed ones, so their presence alone decides.
|
||||
if let (Some(algorithm), Some(key), Some(key_md5)) =
|
||||
(headers.sse_customer_algorithm, headers.sse_customer_key, headers.sse_customer_key_md5)
|
||||
{
|
||||
return Ok(Some(WriteScheme::SseC { algorithm, key, key_md5 }));
|
||||
}
|
||||
|
||||
let Some(config) = prepare_sse_configuration(host, bucket, headers.server_side_encryption, headers.ssekms_key_id).await?
|
||||
else {
|
||||
return Ok(None);
|
||||
};
|
||||
|
||||
Ok(match config.effective_sse.as_str() {
|
||||
AMZ_ENCRYPTION_AES => {
|
||||
// Validation admits a key id only beside `aws:kms`, and the bucket default's
|
||||
// key is consulted only for `aws:kms`.
|
||||
debug_assert!(config.effective_kms_key_id.is_none(), "SSE-S3 never names a KMS key");
|
||||
Some(WriteScheme::SseS3)
|
||||
}
|
||||
AMZ_ENCRYPTION_KMS => Some(WriteScheme::SseKms {
|
||||
key_id: config.effective_kms_key_id,
|
||||
}),
|
||||
_ => None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Scheme a managed-SSE header names, defaulting to SSE-S3 the same way the
|
||||
/// encryption and decryption paths do.
|
||||
pub(crate) fn managed_sse_type(server_side_encryption: &str) -> SSEType {
|
||||
match server_side_encryption {
|
||||
AMZ_ENCRYPTION_KMS => SSEType::SseKms,
|
||||
_ => SSEType::SseS3,
|
||||
}
|
||||
}
|
||||
|
||||
/// Key id an SSE-KMS read authorizes and reports when the stored metadata
|
||||
/// carries none (legacy envelopes and MinIO-written objects predate the
|
||||
/// explicit key-id headers).
|
||||
///
|
||||
/// The KMS service's configured default key is the key such envelopes were
|
||||
/// actually wrapped under, so per-key authorization must target it — the bare
|
||||
/// literal `default` would silently escape any policy narrowed to real key
|
||||
/// ids. The literal remains only as the last resort when no service is
|
||||
/// running, matching what the legacy write path recorded implicitly.
|
||||
pub(crate) async fn resolve_stored_kms_key_id(host: &dyn SseHost, stored: Option<String>) -> String {
|
||||
if let Some(key_id) = stored {
|
||||
return key_id;
|
||||
}
|
||||
if let Some(service) = host.encryption_service().await
|
||||
&& let Some(key_id) = service.get_default_key_id()
|
||||
{
|
||||
return key_id.clone();
|
||||
}
|
||||
"default".to_string()
|
||||
}
|
||||
|
||||
/// Check if the server_side_encryption is a managed SSE type (SSE-S3 or SSE-KMS)
|
||||
#[inline]
|
||||
pub(crate) fn is_managed_sse(server_side_encryption: &str) -> bool {
|
||||
matches!(server_side_encryption, "AES256" | "aws:kms")
|
||||
}
|
||||
@@ -0,0 +1,217 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! SSE-C: validating the customer-provided key and matching it against the stored object.
|
||||
|
||||
use crate::core::keying::metadata::{minio_sealed_ssec_metadata, stored_ssec_metadata};
|
||||
use crate::core::s3::scheme::{DEFAULT_SSE_ALGORITHM, SUPPORT_SSE_ALGORITHMS};
|
||||
use crate::error::SseError;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use md5::{Digest as Md5Digest, Md5};
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
use std::collections::HashMap;
|
||||
use tracing::error;
|
||||
|
||||
fn md5_bytes(input: impl AsRef<[u8]>) -> [u8; 16] {
|
||||
let mut hasher = Md5::new();
|
||||
hasher.update(input.as_ref());
|
||||
hasher.finalize().into()
|
||||
}
|
||||
|
||||
pub(crate) fn md5_base64(input: impl AsRef<[u8]>) -> String {
|
||||
BASE64_STANDARD.encode_to_string(md5_bytes(input))
|
||||
}
|
||||
|
||||
/// Validated SSE-C parameters
|
||||
#[derive(Debug, Clone)]
|
||||
pub(crate) struct ValidatedSsecParams {
|
||||
/// Encryption algorithm (always "AES256" for SSE-C)
|
||||
pub algorithm: String,
|
||||
/// Decoded encryption key bytes (32 bytes for AES-256)
|
||||
pub key_bytes: [u8; 32],
|
||||
/// Base64-encoded MD5 of the key
|
||||
pub key_md5: String,
|
||||
}
|
||||
|
||||
/// SSE-C parameters from client request
|
||||
#[derive(Debug, Clone)]
|
||||
pub(crate) struct SsecParams {
|
||||
/// Encryption algorithm
|
||||
pub algorithm: String,
|
||||
/// Base64-encoded encryption key
|
||||
pub key: String,
|
||||
/// Base64-encoded MD5 of the key
|
||||
pub key_md5: String,
|
||||
}
|
||||
|
||||
/// Validate SSE-C parameters from client request
|
||||
///
|
||||
/// Validates:
|
||||
/// 1. Algorithm is "AES256"
|
||||
/// 2. Key is valid Base64 and exactly 32 bytes
|
||||
/// 3. MD5 hash matches the key
|
||||
///
|
||||
/// # Returns
|
||||
/// `ValidatedSsecParams` with decoded key bytes
|
||||
pub(crate) fn validate_ssec_params(params: SsecParams) -> Result<ValidatedSsecParams, SseError> {
|
||||
if !SUPPORT_SSE_ALGORITHMS.contains(¶ms.algorithm.as_str()) {
|
||||
return Err(ssec_invalid_request(&format!(
|
||||
"Unsupported SSE-C algorithm. Only {DEFAULT_SSE_ALGORITHM} is supported."
|
||||
)));
|
||||
}
|
||||
|
||||
let key_bytes = BASE64_STANDARD.decode_to_vec(¶ms.key).map_err(|e| {
|
||||
error!("Failed to decode SSE-C key: {}", e);
|
||||
ssec_invalid_request("Invalid SSE-C key: not valid Base64.")
|
||||
})?;
|
||||
|
||||
if key_bytes.len() != 32 {
|
||||
return Err(ssec_invalid_request(&format!(
|
||||
"SSE-C key must be 32 bytes (256 bits), got {} bytes.",
|
||||
key_bytes.len()
|
||||
)));
|
||||
}
|
||||
|
||||
let computed_md5 = md5_base64(&key_bytes);
|
||||
if computed_md5 != params.key_md5 {
|
||||
return Err(ssec_invalid_request(
|
||||
"The calculated MD5 hash of the key did not match the hash that was provided.",
|
||||
));
|
||||
}
|
||||
|
||||
let key_array: [u8; 32] = key_bytes
|
||||
.try_into()
|
||||
.map_err(|_| ssec_invalid_request("SSE-C key must be exactly 32 bytes."))?;
|
||||
|
||||
Ok(ValidatedSsecParams {
|
||||
algorithm: params.algorithm,
|
||||
key_bytes: key_array,
|
||||
key_md5: params.key_md5,
|
||||
})
|
||||
}
|
||||
|
||||
/// Verify SSE-C key matches the stored metadata.
|
||||
///
|
||||
/// Used during GetObject/HeadObject to ensure the client provided the correct key.
|
||||
/// Returns 400 InvalidRequest on mismatch, consistent with AWS S3 behavior.
|
||||
pub(crate) fn verify_ssec_key_match(
|
||||
provided_md5: &str,
|
||||
stored_md5: Option<&String>,
|
||||
minio_sealed_ssec: bool,
|
||||
) -> Result<(), SseError> {
|
||||
match stored_md5 {
|
||||
Some(stored) if stored == provided_md5 => Ok(()),
|
||||
Some(_) => Err(ssec_invalid_request(
|
||||
"The provided encryption parameters did not match the ones used originally to encrypt the object.",
|
||||
)),
|
||||
// MinIO never persists the customer-key MD5, so this early check has
|
||||
// nothing to compare against on a migrated object. The key itself is
|
||||
// still proven: a wrong key fails the AEAD unseal of the sealed object
|
||||
// key. The check exists only for the friendlier early error, so its
|
||||
// absence is tolerated for exactly that shape and no other.
|
||||
None if minio_sealed_ssec => Ok(()),
|
||||
None => Err(ssec_invalid_request("Object has no stored SSE-C key metadata.")),
|
||||
}
|
||||
}
|
||||
|
||||
/// Algorithm an SSE-C object recorded; objects that recorded none were written as `AES256`.
|
||||
pub(crate) fn stored_ssec_algorithm(metadata: &HashMap<String, String>) -> &str {
|
||||
metadata
|
||||
.get("x-amz-server-side-encryption-customer-algorithm")
|
||||
.map(|s| s.as_str())
|
||||
.unwrap_or("AES256")
|
||||
}
|
||||
|
||||
/// The customer key and MD5 of a read of an SSE-C object, once both are present and
|
||||
/// the MD5 matches what the object recorded.
|
||||
///
|
||||
/// The key itself is not validated here; the caller does that next, so a request
|
||||
/// that names the wrong key learns of the mismatch before anything else.
|
||||
pub(crate) fn require_matching_ssec_key<'r>(
|
||||
metadata: &HashMap<String, String>,
|
||||
sse_customer_key: Option<&'r String>,
|
||||
sse_customer_key_md5: Option<&'r String>,
|
||||
) -> Result<(&'r String, &'r String), SseError> {
|
||||
let (key, key_md5) = match (sse_customer_key, sse_customer_key_md5) {
|
||||
(Some(k), Some(md5)) => (k, md5),
|
||||
_ => {
|
||||
return Err(ssec_invalid_request(
|
||||
"The object was stored using a form of Server Side Encryption. \
|
||||
The correct parameters must be provided to retrieve the object.",
|
||||
));
|
||||
}
|
||||
};
|
||||
|
||||
// Verify that the provided key MD5 matches the stored MD5 for security
|
||||
let stored_md5 = metadata.get("x-amz-server-side-encryption-customer-key-md5");
|
||||
verify_ssec_key_match(key_md5, stored_md5, minio_sealed_ssec_metadata(metadata))?;
|
||||
|
||||
Ok((key, key_md5))
|
||||
}
|
||||
|
||||
/// Validate that the SSE-C headers required for reading an SSE-C encrypted object
|
||||
/// are present in the request. This is used by HeadObject which does not decrypt
|
||||
/// the data but still must verify the caller holds the correct key.
|
||||
///
|
||||
/// Performs full validation: decodes the customer key, recomputes its MD5,
|
||||
/// verifies the client-provided MD5 header matches the key, then compares
|
||||
/// the computed MD5 against the stored metadata. This prevents a client from
|
||||
/// bypassing validation by guessing/obtaining only the stored MD5 without
|
||||
/// possessing the actual encryption key.
|
||||
///
|
||||
/// Returns `Ok(())` if either the object is not SSE-C encrypted, or valid SSE-C
|
||||
/// headers are provided and the key matches. Returns 400 InvalidRequest otherwise.
|
||||
pub fn validate_ssec_for_read(
|
||||
metadata: &HashMap<String, String>,
|
||||
sse_customer_key: Option<&String>,
|
||||
sse_customer_key_md5: Option<&String>,
|
||||
) -> Result<(), SseError> {
|
||||
if !stored_ssec_metadata(metadata) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let (key, key_md5) = match (sse_customer_key, sse_customer_key_md5) {
|
||||
(Some(k), Some(md5)) => (k, md5),
|
||||
_ => {
|
||||
return Err(ssec_invalid_request(
|
||||
"The object was stored using a form of Server Side Encryption. \
|
||||
The correct parameters must be provided to retrieve the object.",
|
||||
));
|
||||
}
|
||||
};
|
||||
|
||||
// Full param validation: decode key, verify 32 bytes, recompute MD5
|
||||
// from actual key bytes and compare to the client-provided MD5 header.
|
||||
let algorithm = metadata
|
||||
.get("x-amz-server-side-encryption-customer-algorithm")
|
||||
.cloned()
|
||||
.unwrap_or_else(|| DEFAULT_SSE_ALGORITHM.to_string());
|
||||
let validated = validate_ssec_params(SsecParams {
|
||||
algorithm,
|
||||
key: key.to_string(),
|
||||
key_md5: key_md5.clone(),
|
||||
})?;
|
||||
|
||||
let stored_md5 = metadata.get("x-amz-server-side-encryption-customer-key-md5");
|
||||
verify_ssec_key_match(&validated.key_md5, stored_md5, minio_sealed_ssec_metadata(metadata))
|
||||
}
|
||||
|
||||
/// Build an `SseError` with `InvalidRequest` (HTTP 400) for SSE-C related errors.
|
||||
pub fn ssec_invalid_request(message: &str) -> SseError {
|
||||
SseError {
|
||||
code: S3ErrorCode::InvalidRequest,
|
||||
message: message.to_string(),
|
||||
source: None,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,550 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Write entry points: resolve the encryption material for a new object or multipart upload.
|
||||
|
||||
use crate::core::audit::{envelope_master_key_version, record_managed_kms_outcome};
|
||||
use crate::core::keying::context::build_object_encryption_context;
|
||||
use crate::core::keying::material::EncryptionMaterial;
|
||||
use crate::core::keying::{
|
||||
SESSION_KEY_NEEDS_CUSTOMER_KEY, new_key_under_customer_key, new_key_under_data_key, new_session_key_under_customer_key,
|
||||
};
|
||||
use crate::core::request::SseKmsPrincipal;
|
||||
use crate::core::s3::authorization::authorize_sse_kms_key;
|
||||
use crate::core::s3::headers::reject_kms_context_location_override;
|
||||
use crate::core::s3::scheme::{
|
||||
DEFAULT_SSE_ALGORITHM, WriteScheme, WriteSchemeHeaders, is_managed_sse, managed_sse_type, resolve_write_scheme,
|
||||
};
|
||||
use crate::core::s3::ssec::{SsecParams, ssec_invalid_request, validate_ssec_params, verify_ssec_key_match};
|
||||
use crate::error::SseError;
|
||||
use crate::host::SseHost;
|
||||
use crate::kms::provider::get_sse_dek_provider;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use rustfs_kms::KmsUnavailableError;
|
||||
use rustfs_policy::policy::action::KmsAction;
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
use rustfs_utils::http::headers::{AMZ_ENCRYPTION_AES, AMZ_ENCRYPTION_KMS};
|
||||
use rustfs_utils::http::object_encryption_keys::SSEType;
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// Request parameters for unified encryption
|
||||
#[derive(Clone)]
|
||||
pub struct EncryptionRequest<'a> {
|
||||
/// Bucket name
|
||||
pub bucket: &'a str,
|
||||
/// Object key
|
||||
pub key: &'a str,
|
||||
/// Server-side encryption algorithm (SSE-S3 or SSE-KMS)
|
||||
pub server_side_encryption: Option<String>,
|
||||
/// KMS key ID (for SSE-KMS)
|
||||
pub ssekms_key_id: Option<String>,
|
||||
/// Optional client-provided KMS context for SSE-KMS.
|
||||
pub ssekms_context: Option<HashMap<String, String>>,
|
||||
/// SSE-C algorithm (customer-provided key)
|
||||
pub sse_customer_algorithm: Option<String>,
|
||||
/// SSE-C key (Base64-encoded)
|
||||
pub sse_customer_key: Option<String>,
|
||||
/// SSE-C key MD5 (Base64-encoded)
|
||||
pub sse_customer_key_md5: Option<String>,
|
||||
/// Content size (for metadata)
|
||||
pub content_size: i64,
|
||||
/// Caller the SSE-KMS key usage is authorized as. `None` marks an internal caller.
|
||||
pub principal: Option<&'a SseKmsPrincipal>,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for EncryptionRequest<'_> {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("EncryptionRequest")
|
||||
.field("server_side_encryption", &self.server_side_encryption)
|
||||
.field("content_size", &self.content_size)
|
||||
.finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
impl EncryptionRequest<'_> {
|
||||
pub fn validate_complete_multipart_ssec(&self, user_defined: &HashMap<String, String>) -> Result<(), SseError> {
|
||||
let request_uses_ssec =
|
||||
self.sse_customer_algorithm.is_some() || self.sse_customer_key.is_some() || self.sse_customer_key_md5.is_some();
|
||||
if !request_uses_ssec {
|
||||
let stored_algorithm = user_defined.get("x-amz-server-side-encryption-customer-algorithm");
|
||||
let stored_key_md5 = user_defined.get("x-amz-server-side-encryption-customer-key-md5");
|
||||
return match (stored_algorithm, stored_key_md5) {
|
||||
(None, None) => Ok(()),
|
||||
(Some(algorithm), Some(key_md5))
|
||||
if algorithm == DEFAULT_SSE_ALGORITHM
|
||||
&& BASE64_STANDARD
|
||||
.decode_to_vec(key_md5)
|
||||
.is_ok_and(|decoded| decoded.len() == 16) =>
|
||||
{
|
||||
if rustfs_utils::http::contains_key_str(user_defined, rustfs_utils::http::SUFFIX_PLAINTEXT_CHECKSUM) {
|
||||
return Err(ssec_invalid_request(
|
||||
"SSE-C multipart uploads with additional checksums require the customer key for completion.",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
_ => Err(ssec_invalid_request("The multipart upload contains invalid SSE-C metadata.")),
|
||||
};
|
||||
}
|
||||
self.validate_multipart_ssec(user_defined)
|
||||
}
|
||||
|
||||
pub fn validate_multipart_ssec(&self, user_defined: &HashMap<String, String>) -> Result<(), SseError> {
|
||||
let stored_algorithm = user_defined.get("x-amz-server-side-encryption-customer-algorithm");
|
||||
let stored_key_md5 = user_defined.get("x-amz-server-side-encryption-customer-key-md5");
|
||||
let session_uses_ssec = stored_algorithm.is_some() || stored_key_md5.is_some();
|
||||
let request_uses_ssec =
|
||||
self.sse_customer_algorithm.is_some() || self.sse_customer_key.is_some() || self.sse_customer_key_md5.is_some();
|
||||
|
||||
if !session_uses_ssec {
|
||||
return if request_uses_ssec {
|
||||
Err(ssec_invalid_request(
|
||||
"SSE-C parameters cannot be used for a multipart upload that was not initiated with SSE-C.",
|
||||
))
|
||||
} else {
|
||||
Ok(())
|
||||
};
|
||||
}
|
||||
|
||||
let (Some(algorithm), Some(key), Some(key_md5)) = (
|
||||
self.sse_customer_algorithm.as_ref(),
|
||||
self.sse_customer_key.as_ref(),
|
||||
self.sse_customer_key_md5.as_ref(),
|
||||
) else {
|
||||
return Err(ssec_invalid_request(
|
||||
"Missing SSE-C parameters. Algorithm, customer key and customer key MD5 are all required.",
|
||||
));
|
||||
};
|
||||
|
||||
let validated = validate_ssec_params(SsecParams {
|
||||
algorithm: algorithm.to_string(),
|
||||
key: key.to_string(),
|
||||
key_md5: key_md5.to_string(),
|
||||
})?;
|
||||
if stored_algorithm.map(String::as_str) != Some(validated.algorithm.as_str()) {
|
||||
return Err(ssec_invalid_request(
|
||||
"The provided encryption parameters did not match the multipart upload.",
|
||||
));
|
||||
}
|
||||
// Multipart session metadata is written by our own CreateMultipartUpload,
|
||||
// which always records the MD5 — the MinIO no-stored-MD5 shape cannot occur.
|
||||
verify_ssec_key_match(&validated.key_md5, stored_key_md5, false)
|
||||
}
|
||||
}
|
||||
|
||||
/// **Core API**: Apply encryption based on request parameters
|
||||
///
|
||||
/// This function automatically routes to the appropriate encryption method:
|
||||
/// - SSE-C if customer key is provided
|
||||
/// - SSE-S3/SSE-KMS if server-side encryption is requested
|
||||
/// - None if no encryption is requested
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `request` - Encryption request with all possible encryption parameters
|
||||
///
|
||||
/// # Returns
|
||||
/// * `Ok(Some(material))` - Encryption should be applied with the returned material
|
||||
/// * `Ok(None)` - No encryption requested
|
||||
/// * `Err` - Encryption configuration error
|
||||
///
|
||||
/// # Example
|
||||
/// ```rust,ignore
|
||||
/// let request = EncryptionRequest {
|
||||
/// bucket: &bucket,
|
||||
/// key: &key,
|
||||
/// server_side_encryption: effective_sse.as_ref(),
|
||||
/// ssekms_key_id: effective_kms_key_id.as_deref(),
|
||||
/// sse_customer_algorithm: sse_customer_algorithm.as_ref(),
|
||||
/// sse_customer_key: sse_customer_key.as_deref(),
|
||||
/// sse_customer_key_md5: sse_customer_key_md5.as_deref(),
|
||||
/// content_size: actual_size,
|
||||
/// part_number: None,
|
||||
/// };
|
||||
///
|
||||
/// if let Some(material) = sse_encryption(host, request).await? {
|
||||
/// reader = material.wrap_reader(reader);
|
||||
/// metadata.extend(material.metadata);
|
||||
/// }
|
||||
/// ```
|
||||
pub async fn sse_encryption(host: &dyn SseHost, request: EncryptionRequest<'_>) -> Result<Option<EncryptionMaterial>, SseError> {
|
||||
let scheme = resolve_write_scheme(
|
||||
host,
|
||||
request.bucket,
|
||||
WriteSchemeHeaders {
|
||||
server_side_encryption: request.server_side_encryption,
|
||||
ssekms_key_id: request.ssekms_key_id,
|
||||
ssekms_context: request.ssekms_context.as_ref(),
|
||||
sse_customer_algorithm: request.sse_customer_algorithm,
|
||||
sse_customer_key: request.sse_customer_key,
|
||||
sse_customer_key_md5: request.sse_customer_key_md5,
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
|
||||
let (server_side_encryption, kms_key_id) = match scheme {
|
||||
None => return Ok(None),
|
||||
Some(WriteScheme::SseC { algorithm, key, key_md5 }) => {
|
||||
return apply_ssec_encryption_material(request.bucket, request.key, algorithm, key, key_md5, request.content_size)
|
||||
.await
|
||||
.map(Some);
|
||||
}
|
||||
Some(WriteScheme::SseS3) => (String::from(AMZ_ENCRYPTION_AES), None),
|
||||
Some(WriteScheme::SseKms { key_id }) => (String::from(AMZ_ENCRYPTION_KMS), key_id),
|
||||
};
|
||||
|
||||
apply_managed_encryption_material(
|
||||
host,
|
||||
ManagedEncryptionRequest {
|
||||
bucket: request.bucket,
|
||||
key: request.key,
|
||||
server_side_encryption,
|
||||
kms_key_id,
|
||||
ssekms_context: request.ssekms_context,
|
||||
content_size: request.content_size,
|
||||
principal: request.principal,
|
||||
},
|
||||
)
|
||||
.await
|
||||
.map(Some)
|
||||
}
|
||||
|
||||
/// **Core API**: Apply encryption based on request parameters
|
||||
///
|
||||
/// sse_prepare_encryption, support SSE-C, SSE-S3, SSE-KMS
|
||||
pub struct PrepareEncryptionRequest<'a> {
|
||||
/// Bucket name
|
||||
pub bucket: &'a str,
|
||||
/// Object key
|
||||
pub key: &'a str,
|
||||
/// Server-side encryption algorithm (SSE-S3 or SSE-KMS)
|
||||
pub server_side_encryption: Option<String>,
|
||||
/// KMS key ID (for SSE-KMS)
|
||||
pub ssekms_key_id: Option<String>,
|
||||
/// Optional client-provided KMS context for SSE-KMS.
|
||||
pub ssekms_context: Option<HashMap<String, String>>,
|
||||
/// SSE-C algorithm (customer-provided key)
|
||||
pub sse_customer_algorithm: Option<String>,
|
||||
/// SSE-C key (Base64-encoded)
|
||||
pub sse_customer_key: Option<String>,
|
||||
/// SSE-C key MD5 (Base64-encoded)
|
||||
pub sse_customer_key_md5: Option<String>,
|
||||
/// Caller the SSE-KMS key usage is authorized as. `None` marks an internal caller.
|
||||
///
|
||||
/// This is the only point at which a multipart upload evaluates KMS key permissions:
|
||||
/// it is where the session data key is generated. `UploadPart`, `UploadPartCopy` and
|
||||
/// `CompleteMultipartUpload` reuse that envelope and are not re-authorized.
|
||||
pub principal: Option<&'a SseKmsPrincipal>,
|
||||
}
|
||||
|
||||
pub async fn sse_prepare_encryption(
|
||||
host: &dyn SseHost,
|
||||
request: PrepareEncryptionRequest<'_>,
|
||||
) -> Result<Option<EncryptionMaterial>, SseError> {
|
||||
let scheme = resolve_write_scheme(
|
||||
host,
|
||||
request.bucket,
|
||||
WriteSchemeHeaders {
|
||||
server_side_encryption: request.server_side_encryption,
|
||||
ssekms_key_id: request.ssekms_key_id,
|
||||
ssekms_context: request.ssekms_context.as_ref(),
|
||||
sse_customer_algorithm: request.sse_customer_algorithm,
|
||||
sse_customer_key: request.sse_customer_key,
|
||||
sse_customer_key_md5: request.sse_customer_key_md5,
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
|
||||
let (server_side_encryption, kms_key_id) = match scheme {
|
||||
None => return Ok(None),
|
||||
Some(WriteScheme::SseC { algorithm, key, key_md5 }) => {
|
||||
return apply_ssec_prepare_encryption_material(request.bucket, request.key, algorithm, Some(key), key_md5)
|
||||
.await
|
||||
.map(Some);
|
||||
}
|
||||
Some(WriteScheme::SseS3) => (String::from(AMZ_ENCRYPTION_AES), None),
|
||||
Some(WriteScheme::SseKms { key_id }) => (String::from(AMZ_ENCRYPTION_KMS), key_id),
|
||||
};
|
||||
|
||||
// A session records no plaintext size: the parts decide it.
|
||||
apply_managed_encryption_material(
|
||||
host,
|
||||
ManagedEncryptionRequest {
|
||||
bucket: request.bucket,
|
||||
key: request.key,
|
||||
server_side_encryption,
|
||||
kms_key_id,
|
||||
ssekms_context: request.ssekms_context,
|
||||
content_size: 0,
|
||||
principal: request.principal,
|
||||
},
|
||||
)
|
||||
.await
|
||||
.map(Some)
|
||||
}
|
||||
|
||||
async fn apply_ssec_prepare_encryption_material(
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
algorithm: String,
|
||||
sse_key: Option<String>,
|
||||
sse_key_md5: String,
|
||||
) -> Result<EncryptionMaterial, SseError> {
|
||||
// The customer key is validated here only in a mode that seals the session's
|
||||
// key under it. Otherwise it is validated per part, against what the session
|
||||
// records.
|
||||
let customer_key = match sse_key {
|
||||
Some(sse_key) if SESSION_KEY_NEEDS_CUSTOMER_KEY => Some(
|
||||
validate_ssec_params(SsecParams {
|
||||
algorithm: algorithm.clone(),
|
||||
key: sse_key,
|
||||
key_md5: sse_key_md5.clone(),
|
||||
})?
|
||||
.key_bytes,
|
||||
),
|
||||
_ => None,
|
||||
};
|
||||
let object_key = new_session_key_under_customer_key(customer_key, bucket, key)?;
|
||||
|
||||
Ok(EncryptionMaterial {
|
||||
sse_type: SSEType::SseC,
|
||||
server_side_encryption: String::from(AMZ_ENCRYPTION_AES),
|
||||
kms_key_id: None,
|
||||
algorithm,
|
||||
key_bytes: object_key.key_bytes,
|
||||
base_nonce: object_key.base_nonce,
|
||||
encrypted_data_key: None,
|
||||
customer_key_md5: Some(sse_key_md5),
|
||||
original_size: None,
|
||||
key_kind: object_key.key_kind,
|
||||
managed_kms_context: None,
|
||||
managed_sealed_key: object_key.sealed_key,
|
||||
})
|
||||
}
|
||||
|
||||
async fn apply_ssec_encryption_material(
|
||||
bucket: &str,
|
||||
key: &str,
|
||||
algorithm: String,
|
||||
sse_key: String,
|
||||
sse_key_md5: String,
|
||||
content_size: i64,
|
||||
) -> Result<EncryptionMaterial, SseError> {
|
||||
let params = SsecParams {
|
||||
algorithm,
|
||||
key: sse_key,
|
||||
key_md5: sse_key_md5,
|
||||
};
|
||||
|
||||
let validated = validate_ssec_params(params)?;
|
||||
let object_key = new_key_under_customer_key(validated.key_bytes, bucket, key)?;
|
||||
|
||||
// Build metadata
|
||||
Ok(EncryptionMaterial {
|
||||
sse_type: SSEType::SseC,
|
||||
server_side_encryption: String::from(AMZ_ENCRYPTION_AES),
|
||||
kms_key_id: None,
|
||||
algorithm: validated.algorithm,
|
||||
key_bytes: object_key.key_bytes,
|
||||
base_nonce: object_key.base_nonce,
|
||||
encrypted_data_key: None,
|
||||
customer_key_md5: Some(validated.key_md5),
|
||||
original_size: Some(content_size),
|
||||
key_kind: object_key.key_kind,
|
||||
managed_kms_context: None,
|
||||
managed_sealed_key: object_key.sealed_key,
|
||||
})
|
||||
}
|
||||
|
||||
/// A managed-SSE (SSE-S3 / SSE-KMS) write, once its effective scheme is known.
|
||||
pub(crate) struct ManagedEncryptionRequest<'a> {
|
||||
pub(crate) bucket: &'a str,
|
||||
pub(crate) key: &'a str,
|
||||
pub(crate) server_side_encryption: String,
|
||||
pub(crate) kms_key_id: Option<String>,
|
||||
pub(crate) ssekms_context: Option<HashMap<String, String>>,
|
||||
pub(crate) content_size: i64,
|
||||
pub(crate) principal: Option<&'a SseKmsPrincipal>,
|
||||
}
|
||||
|
||||
pub(crate) async fn apply_managed_encryption_material(
|
||||
host: &dyn SseHost,
|
||||
request: ManagedEncryptionRequest<'_>,
|
||||
) -> Result<EncryptionMaterial, SseError> {
|
||||
// Request validation, not a KMS operation: reject before the KMS is called
|
||||
// and before an audit outcome is recorded.
|
||||
reject_kms_context_location_override(request.bucket, request.ssekms_context.as_ref())?;
|
||||
|
||||
let principal = request.principal;
|
||||
let requested_sse_type = managed_sse_type(request.server_side_encryption.as_str());
|
||||
let requested_key_id = request.kms_key_id.clone();
|
||||
let result = apply_managed_encryption_material_inner(host, request).await;
|
||||
|
||||
match &result {
|
||||
// The resolved key is only known on success: it may come from the request,
|
||||
// the bucket default or the KMS service default. On failure the audit entry
|
||||
// records what the caller asked for, which is what a reader needs to see.
|
||||
Ok(material) => record_managed_kms_outcome(
|
||||
principal,
|
||||
material.sse_type,
|
||||
material.kms_key_id.as_deref(),
|
||||
|| material.encrypted_data_key.as_deref().and_then(envelope_master_key_version),
|
||||
Ok(()),
|
||||
),
|
||||
Err(error) => record_managed_kms_outcome(principal, requested_sse_type, requested_key_id.as_deref(), || None, Err(error)),
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
pub(crate) async fn apply_managed_encryption_material_inner(
|
||||
host: &dyn SseHost,
|
||||
request: ManagedEncryptionRequest<'_>,
|
||||
) -> Result<EncryptionMaterial, SseError> {
|
||||
let ManagedEncryptionRequest {
|
||||
bucket,
|
||||
key,
|
||||
server_side_encryption,
|
||||
kms_key_id,
|
||||
ssekms_context,
|
||||
content_size,
|
||||
principal,
|
||||
} = request;
|
||||
if !is_managed_sse(&server_side_encryption) {
|
||||
return Err(SseError::internal(format!(
|
||||
"Unsupported server-side encryption: {}",
|
||||
server_side_encryption.as_str()
|
||||
)));
|
||||
}
|
||||
|
||||
let encryption_type = match server_side_encryption.as_str() {
|
||||
"AES256" => SSEType::SseS3,
|
||||
"aws:kms" => SSEType::SseKms,
|
||||
_ => SSEType::SseS3,
|
||||
};
|
||||
|
||||
// Determine KMS key ID to use for internal key wrapping.
|
||||
let mut kms_key_candidate = kms_key_id.clone();
|
||||
if kms_key_candidate.is_none() {
|
||||
// Try to get default key from KMS service (if available)
|
||||
if let Some(service) = host.encryption_service().await {
|
||||
kms_key_candidate = service.get_default_key_id().cloned();
|
||||
tracing::debug!(
|
||||
default_key_id = ?kms_key_candidate,
|
||||
"SSE-S3: KMS service available, default_key_id from config"
|
||||
);
|
||||
} else {
|
||||
tracing::debug!("SSE-S3: KMS encryption service not available");
|
||||
}
|
||||
}
|
||||
|
||||
let kms_key_to_use = match (encryption_type, kms_key_candidate.clone()) {
|
||||
(SSEType::SseS3, Some(kms_key_id)) => kms_key_id,
|
||||
(SSEType::SseS3, None) => {
|
||||
tracing::debug!("SSE-S3: no KMS key configured, falling back to \"default\" key ID");
|
||||
"default".to_string()
|
||||
}
|
||||
(SSEType::SseKms, Some(kms_key_id)) => kms_key_id,
|
||||
(SSEType::SseKms, None) => {
|
||||
// Neither the request nor the bucket default named a key and no
|
||||
// service default filled in. Without a service this is the same
|
||||
// outage/misconfiguration the provider check below reports, so it
|
||||
// must carry the same 503/400 split rather than an untyped
|
||||
// internal error; with a running service that has no default key
|
||||
// the caller simply has to name one.
|
||||
if host.encryption_service().await.is_none() {
|
||||
return Err(sse_kms_unavailable_error(kms_configured_but_unavailable(host).await));
|
||||
}
|
||||
return Err(SseError {
|
||||
code: S3ErrorCode::InvalidRequest,
|
||||
message: "SSE-KMS requires a KMS key id: the request named none and the KMS service has no default key"
|
||||
.to_string(),
|
||||
source: None,
|
||||
});
|
||||
}
|
||||
_ => unreachable!("managed SSE branch only supports SSE-S3 or SSE-KMS"),
|
||||
};
|
||||
|
||||
// The key is fully resolved here (request header, then bucket default, then the KMS
|
||||
// service default), so this is the first point at which the caller can be held to the
|
||||
// key it will actually be encrypted under.
|
||||
authorize_sse_kms_key(host, principal, encryption_type, KmsAction::GenerateDataKeyAction, &kms_key_to_use).await?;
|
||||
|
||||
// A node-local master key is the explicit SSE-S3 fallback. Letting it serve
|
||||
// an SSE-KMS request would persist an `aws:kms` marker and a KMS key id
|
||||
// that never wrapped the data key, so refuse rather than downgrade.
|
||||
//
|
||||
// The refusal sits after the authorization gate so an unauthorized caller
|
||||
// still sees AccessDenied whatever the KMS runtime state is, and it asks
|
||||
// the resolved provider rather than a parallel availability signal,
|
||||
// because the provider is what actually wraps the DEK.
|
||||
let provider = match get_sse_dek_provider(host).await {
|
||||
Ok(provider) => {
|
||||
if matches!(encryption_type, SSEType::SseKms) && provider.wraps_dek_with_local_master_key() {
|
||||
return Err(sse_kms_unavailable_error(kms_configured_but_unavailable(host).await));
|
||||
}
|
||||
provider
|
||||
}
|
||||
// With no master key set the local fallback fails with an SSE-S3-worded
|
||||
// configuration error. An SSE-KMS request never asked for that provider,
|
||||
// so it gets the SSE-KMS refusal instead of a message naming the wrong
|
||||
// scheme.
|
||||
Err(err) => {
|
||||
if matches!(encryption_type, SSEType::SseKms) && host.encryption_service().await.is_none() {
|
||||
return Err(sse_kms_unavailable_error(kms_configured_but_unavailable(host).await));
|
||||
}
|
||||
return Err(err);
|
||||
}
|
||||
};
|
||||
let object_context = build_object_encryption_context(bucket, key, ssekms_context.as_ref());
|
||||
let (data_key, encrypted_data_key) = provider.generate_sse_dek(&object_context, &kms_key_to_use).await?;
|
||||
|
||||
let algorithm = server_side_encryption.as_str().to_string();
|
||||
let object_key = new_key_under_data_key(&data_key, encryption_type, bucket, key)?;
|
||||
|
||||
Ok(EncryptionMaterial {
|
||||
sse_type: encryption_type,
|
||||
server_side_encryption,
|
||||
kms_key_id: Some(kms_key_to_use),
|
||||
algorithm,
|
||||
key_bytes: object_key.key_bytes,
|
||||
base_nonce: object_key.base_nonce,
|
||||
encrypted_data_key: Some(encrypted_data_key),
|
||||
customer_key_md5: None,
|
||||
original_size: Some(content_size),
|
||||
key_kind: object_key.key_kind,
|
||||
managed_kms_context: matches!(encryption_type, SSEType::SseKms).then_some(ssekms_context.unwrap_or_default()),
|
||||
managed_sealed_key: object_key.sealed_key,
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether this node has a KMS configured that is not currently serving, which
|
||||
/// separates a transient outage (retryable, 503) from a deployment that never
|
||||
/// configured KMS at all (a client-side configuration error, 400).
|
||||
async fn kms_configured_but_unavailable(host: &dyn SseHost) -> bool {
|
||||
match host.kms_service_manager() {
|
||||
Some(manager) => !matches!(manager.get_status().await, rustfs_kms::KmsServiceStatus::NotConfigured),
|
||||
None => false,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn sse_kms_unavailable_error(configured_but_unavailable: bool) -> SseError {
|
||||
if configured_but_unavailable {
|
||||
return SseError::internal(KmsUnavailableError);
|
||||
}
|
||||
SseError {
|
||||
code: S3ErrorCode::InvalidRequest,
|
||||
message: "SSE-KMS requires a configured and running KMS service".to_string(),
|
||||
source: None,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,176 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! The error every SSE operation reports, already classified for the S3 data path.
|
||||
|
||||
use rustfs_kms::{KmsError, KmsUnavailableError};
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
|
||||
type BoxError = Box<dyn std::error::Error + Send + Sync>;
|
||||
|
||||
/// S3 error code a KMS key that does not exist is reported under.
|
||||
pub const KMS_KEY_NOT_FOUND_ERROR_CODE: &str = "KMS.NotFoundException";
|
||||
|
||||
pub(crate) const INTERNAL_ERROR_MESSAGE: &str = "We encountered an internal error, please try again.";
|
||||
const SERVICE_UNAVAILABLE_MESSAGE: &str = "The service is unavailable. Please retry.";
|
||||
const ACCESS_DENIED_MESSAGE: &str = "Access Denied.";
|
||||
|
||||
/// A failed SSE operation, carrying the S3 error code and message the caller answers with.
|
||||
///
|
||||
/// `source` keeps the underlying failure for logs and for classification by
|
||||
/// callers; it is never part of the response.
|
||||
#[derive(Debug)]
|
||||
pub struct SseError {
|
||||
pub code: S3ErrorCode,
|
||||
pub message: String,
|
||||
pub source: Option<BoxError>,
|
||||
}
|
||||
|
||||
impl SseError {
|
||||
/// Classify a failure that did not originate from the request itself.
|
||||
///
|
||||
/// A [`KmsUnavailableError`] is a retryable `ServiceUnavailable`, a
|
||||
/// [`KmsError`] follows [`data_plane_kms_error`], and everything else is an
|
||||
/// `InternalError` whose detail stays in `source` and out of the response.
|
||||
pub fn internal(error: impl Into<BoxError>) -> Self {
|
||||
let source = error.into();
|
||||
let (code, message) = if source.downcast_ref::<KmsUnavailableError>().is_some() {
|
||||
(S3ErrorCode::ServiceUnavailable, SERVICE_UNAVAILABLE_MESSAGE.to_string())
|
||||
} else if let Some(classified) = source.downcast_ref::<KmsError>().and_then(data_plane_kms_error) {
|
||||
classified
|
||||
} else {
|
||||
(S3ErrorCode::InternalError, INTERNAL_ERROR_MESSAGE.to_string())
|
||||
};
|
||||
Self {
|
||||
code,
|
||||
message,
|
||||
source: Some(source),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for SseError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(&self.message)
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for SseError {
|
||||
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
|
||||
self.source.as_deref().map(|source| source as _)
|
||||
}
|
||||
}
|
||||
|
||||
/// Map a KMS failure that surfaced on the S3 data path to its S3 error code.
|
||||
///
|
||||
/// The contract deliberately differs from the admin key-lifecycle handlers:
|
||||
/// there a key id is the resource being addressed, so a missing key is `404`.
|
||||
/// Here the key id arrives inside a request header or a bucket default, so a
|
||||
/// key that is missing, disabled, or otherwise unusable is configuration the
|
||||
/// caller has to correct — AWS answers `400`, and reporting `500` instead both
|
||||
/// misfiles the failure as a server fault and makes SDKs back off and retry a
|
||||
/// request that cannot succeed.
|
||||
///
|
||||
/// `None` keeps the caller's fallthrough, which is the `500` that integrity
|
||||
/// faults — damaged, unreadable, or unknown-format key material — must keep.
|
||||
///
|
||||
/// Messages either name what the caller asked for or stay generic; detail that
|
||||
/// belongs to the deployment rather than the request stays in `source`, which
|
||||
/// the caller attaches and the logs retain.
|
||||
pub fn data_plane_kms_error(error: &KmsError) -> Option<(S3ErrorCode, String)> {
|
||||
use KmsError as Kms;
|
||||
|
||||
match error {
|
||||
Kms::KeyNotFound { key_id } => Some((
|
||||
S3ErrorCode::Custom(KMS_KEY_NOT_FOUND_ERROR_CODE.into()),
|
||||
format!("KMS key not found: {key_id}"),
|
||||
)),
|
||||
Kms::KeyVersionNotFound { key_id, version } => Some((
|
||||
S3ErrorCode::Custom(KMS_KEY_NOT_FOUND_ERROR_CODE.into()),
|
||||
format!("KMS key version {version} not found for key {key_id}"),
|
||||
)),
|
||||
// The key exists but its state forbids the operation (disabled,
|
||||
// pending deletion). AWS treats an invalid key state as a request
|
||||
// error, not a server fault.
|
||||
Kms::InvalidOperation { .. } => Some((S3ErrorCode::InvalidRequest, error.to_string())),
|
||||
// A policy decision needs a human, so it must be distinguishable from
|
||||
// the transient classes an SDK retries.
|
||||
Kms::AccessDenied { .. } => Some((S3ErrorCode::AccessDenied, ACCESS_DENIED_MESSAGE.to_string())),
|
||||
// Request-side faults: what was asked for cannot be served as asked.
|
||||
Kms::ContextMismatch { .. }
|
||||
| Kms::InvalidKey { .. }
|
||||
| Kms::ValidationError { .. }
|
||||
| Kms::UnsupportedAlgorithm { .. }
|
||||
| Kms::InvalidKeySize { .. } => Some((S3ErrorCode::InvalidRequest, error.to_string())),
|
||||
// A deployment whose KMS configuration cannot serve the request (for
|
||||
// example no key named and no default). Actionable, but the detail
|
||||
// describes the deployment, so it stays out of the response body.
|
||||
Kms::ConfigurationError { .. } => {
|
||||
Some((S3ErrorCode::InvalidRequest, "The KMS configuration cannot serve this request".to_string()))
|
||||
}
|
||||
// Transient: worth retrying, and must be counted against availability
|
||||
// rather than against the caller. `IoError` belongs here because it is
|
||||
// how a backend reports that its key store itself was unreachable —
|
||||
// rustfs/rustfs#7470 separated that from a missing key precisely so the
|
||||
// two stop looking alike, and leaving it on the 500 fallthrough would
|
||||
// erase that distinction again at the S3 boundary.
|
||||
Kms::BackendError { .. }
|
||||
| Kms::IoError { .. }
|
||||
| Kms::OperationTimedOut { .. }
|
||||
| Kms::OperationCancelled { .. }
|
||||
| Kms::CredentialsUnavailable { .. }
|
||||
| Kms::CacheError { .. } => Some((S3ErrorCode::ServiceUnavailable, SERVICE_UNAVAILABLE_MESSAGE.to_string())),
|
||||
// A permanent gap in the configured backend, never a missing resource.
|
||||
Kms::UnsupportedCapability { .. } => Some((S3ErrorCode::NotImplemented, error.to_string())),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn internal_keeps_request_free_failures_generic() {
|
||||
let error = SseError::internal("Failed to decode IV: bad base64");
|
||||
|
||||
assert_eq!(error.code, S3ErrorCode::InternalError);
|
||||
assert_eq!(error.message, INTERNAL_ERROR_MESSAGE);
|
||||
assert!(
|
||||
error
|
||||
.source
|
||||
.as_ref()
|
||||
.is_some_and(|source| source.to_string().contains("Failed to decode IV"))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn internal_reports_an_unavailable_kms_as_retryable() {
|
||||
let error = SseError::internal(KmsUnavailableError);
|
||||
|
||||
assert_eq!(error.code, S3ErrorCode::ServiceUnavailable);
|
||||
assert_eq!(error.message, SERVICE_UNAVAILABLE_MESSAGE);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn internal_classifies_kms_errors_for_the_data_path() {
|
||||
let missing = SseError::internal(KmsError::key_not_found("absent-key"));
|
||||
assert_eq!(missing.code, S3ErrorCode::Custom(KMS_KEY_NOT_FOUND_ERROR_CODE.into()));
|
||||
assert_eq!(missing.message, "KMS key not found: absent-key");
|
||||
|
||||
let damaged = SseError::internal(KmsError::cryptographic_error("decrypt", "authentication failed"));
|
||||
assert_eq!(damaged.code, S3ErrorCode::InternalError);
|
||||
assert_eq!(damaged.message, INTERNAL_ERROR_MESSAGE);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! What SSE needs from the server it runs in.
|
||||
//!
|
||||
//! This crate reaches the running server only through [`SseHost`]: it holds no
|
||||
//! handle to the storage engine, to IAM, or to the bucket metadata system. Every
|
||||
//! entry point that consults the server takes the host as its first argument, so
|
||||
//! a caller cannot reach key selection without saying which server it speaks for.
|
||||
|
||||
use crate::{SseError, SseKmsPrincipal};
|
||||
use async_trait::async_trait;
|
||||
use rustfs_kms::KmsServiceManager;
|
||||
use rustfs_kms::service::ObjectEncryptionService;
|
||||
use rustfs_policy::policy::action::KmsAction;
|
||||
use std::sync::Arc;
|
||||
|
||||
/// The server capabilities SSE key resolution depends on.
|
||||
#[async_trait]
|
||||
pub trait SseHost: Send + Sync {
|
||||
/// The KMS object-encryption service currently serving, if one is.
|
||||
///
|
||||
/// Resolved on every call: the KMS backend can be reconfigured while the
|
||||
/// server runs, so a service handle must not outlive the operation it serves.
|
||||
async fn encryption_service(&self) -> Option<Arc<ObjectEncryptionService>>;
|
||||
|
||||
/// The KMS service manager, when the server has one.
|
||||
///
|
||||
/// Only its status is read, to tell a configured KMS that is not serving
|
||||
/// (retryable) from a deployment that never configured one (a request error).
|
||||
fn kms_service_manager(&self) -> Option<Arc<KmsServiceManager>>;
|
||||
|
||||
/// The bucket's default-encryption configuration.
|
||||
///
|
||||
/// `Ok(None)` means the bucket has no encryption configuration.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Any failure to read the configuration, already classified for the S3
|
||||
/// response. A write must not proceed as if the bucket had no default when
|
||||
/// the configuration could not be read.
|
||||
async fn bucket_encryption(&self, bucket: &str) -> Result<Option<BucketEncryption>, SseError>;
|
||||
|
||||
/// The authorizer deciding per-key KMS permissions on the data path.
|
||||
fn kms_key_authorizer(&self) -> &dyn KmsKeyAuthorizer;
|
||||
}
|
||||
|
||||
/// A bucket's stored encryption configuration, reduced to what a write consults.
|
||||
#[derive(Debug, Clone, Default, PartialEq, Eq)]
|
||||
pub struct BucketEncryption {
|
||||
/// The default-encryption rule of the first configuration rule, if it has one.
|
||||
pub default_rule: Option<BucketDefaultEncryption>,
|
||||
}
|
||||
|
||||
/// The `ApplyServerSideEncryptionByDefault` element of a bucket encryption rule.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct BucketDefaultEncryption {
|
||||
/// The stored algorithm, exactly as persisted (`AES256`, `aws:kms`, or an unknown value).
|
||||
pub sse_algorithm: String,
|
||||
pub kms_master_key_id: Option<String>,
|
||||
}
|
||||
|
||||
/// Decides whether a principal may use a specific KMS key on the data path.
|
||||
///
|
||||
/// Behind a trait so tests can pin the allow/deny contract of the SSE call sites
|
||||
/// without a running IAM subsystem.
|
||||
#[async_trait]
|
||||
pub trait KmsKeyAuthorizer: Send + Sync {
|
||||
/// # Errors
|
||||
///
|
||||
/// When the decision itself could not be made, for example because the
|
||||
/// policy subsystem is not ready. A denial is `Ok(false)`.
|
||||
async fn is_allowed(&self, principal: &SseKmsPrincipal, action: KmsAction, key_id: &str) -> Result<bool, SseError>;
|
||||
}
|
||||
@@ -0,0 +1,180 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! The provider that wraps and unwraps data keys through the KMS service.
|
||||
|
||||
use crate::core::audit::KmsDataPlaneFailure;
|
||||
use crate::error::SseError;
|
||||
use crate::host::SseHost;
|
||||
use crate::kms::provider::SseDekProvider;
|
||||
use async_trait::async_trait;
|
||||
use rustfs_kms::types::ObjectEncryptionContext;
|
||||
use rustfs_kms::{DataKey, KmsUnavailableError};
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
use std::sync::Arc;
|
||||
|
||||
/// Production KMS-backed DEK provider
|
||||
/// Resolves the latest ObjectEncryptionService on each call.
|
||||
pub(crate) struct KmsSseDekProvider<'a> {
|
||||
service_source: KmsServiceSource<'a>,
|
||||
}
|
||||
|
||||
/// Where a [`KmsSseDekProvider`] finds the service that is serving right now.
|
||||
enum KmsServiceSource<'a> {
|
||||
Host(&'a dyn SseHost),
|
||||
#[cfg(test)]
|
||||
Manager(Arc<rustfs_kms::KmsServiceManager>),
|
||||
}
|
||||
|
||||
pub(crate) fn kms_operation_error(error: rustfs_kms::KmsError) -> SseError {
|
||||
let class = rustfs_kms::audit::error_class(&error);
|
||||
let mut api_error = SseError::internal(error);
|
||||
// Wrap rather than replace the source so the original chain stays intact for
|
||||
// logging; the wrapper only adds the class the audit attachment needs.
|
||||
let source = api_error.source.take();
|
||||
api_error.source = Some(Box::new(KmsDataPlaneFailure { class, source }));
|
||||
api_error
|
||||
}
|
||||
|
||||
/// Classification for a failed data-key unwrap.
|
||||
///
|
||||
/// An AEAD failure stays `500` (the envelope is an integrity fault, not a
|
||||
/// request a retry or a different header can fix), but the generic internal
|
||||
/// error text hides the one diagnosis an operator needs: the configured
|
||||
/// backend holds different key material under this key id than the one that
|
||||
/// wrapped the object, typically after re-creating a key of the same name or
|
||||
/// switching backends.
|
||||
pub(crate) fn kms_unwrap_error(error: rustfs_kms::KmsError) -> SseError {
|
||||
let unwrap_rejected = matches!(error, rustfs_kms::KmsError::CryptographicError { .. });
|
||||
let mut api_error = kms_operation_error(error);
|
||||
if unwrap_rejected && api_error.code == S3ErrorCode::InternalError {
|
||||
api_error.message = "The object's data key envelope could not be unwrapped by the configured KMS backend: the \
|
||||
key material under this key id differs from the one that wrapped it, or the envelope is damaged"
|
||||
.to_string();
|
||||
}
|
||||
api_error
|
||||
}
|
||||
|
||||
impl<'a> KmsSseDekProvider<'a> {
|
||||
/// Create a new KMS-backed provider
|
||||
pub async fn new(host: &'a dyn SseHost) -> Result<Self, SseError> {
|
||||
let provider = Self {
|
||||
service_source: KmsServiceSource::Host(host),
|
||||
};
|
||||
provider
|
||||
.current_service()
|
||||
.await
|
||||
.ok_or_else(|| SseError::internal(KmsUnavailableError))?;
|
||||
Ok(provider)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) async fn new_with_service_manager(service_manager: Arc<rustfs_kms::KmsServiceManager>) -> Result<Self, SseError> {
|
||||
let provider = Self {
|
||||
service_source: KmsServiceSource::Manager(service_manager),
|
||||
};
|
||||
provider
|
||||
.current_service()
|
||||
.await
|
||||
.ok_or_else(|| SseError::internal(KmsUnavailableError))?;
|
||||
Ok(provider)
|
||||
}
|
||||
|
||||
async fn current_service(&self) -> Option<Arc<rustfs_kms::service::ObjectEncryptionService>> {
|
||||
match &self.service_source {
|
||||
KmsServiceSource::Host(host) => host.encryption_service().await,
|
||||
#[cfg(test)]
|
||||
KmsServiceSource::Manager(service_manager) => service_manager.get_encryption_service().await,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl SseDekProvider for KmsSseDekProvider<'_> {
|
||||
async fn generate_sse_dek(
|
||||
&self,
|
||||
context: &ObjectEncryptionContext,
|
||||
kms_key_id: &str,
|
||||
) -> Result<(DataKey, Vec<u8>), SseError> {
|
||||
let kms_key_option = Some(kms_key_id.to_string());
|
||||
let service = self
|
||||
.current_service()
|
||||
.await
|
||||
.ok_or_else(|| SseError::internal(KmsUnavailableError))?;
|
||||
let (data_key, encrypted_data_key) = service
|
||||
.create_data_key(&kms_key_option, context)
|
||||
.await
|
||||
.map_err(kms_operation_error)?;
|
||||
|
||||
Ok((data_key, encrypted_data_key))
|
||||
}
|
||||
|
||||
async fn reads_bare_data_key_ciphertext(&self) -> bool {
|
||||
self.current_service()
|
||||
.await
|
||||
.is_some_and(|service| service.reads_bare_data_key_ciphertext())
|
||||
}
|
||||
|
||||
async fn rewrap_sse_dek(
|
||||
&self,
|
||||
encrypted_dek: &[u8],
|
||||
context: &ObjectEncryptionContext,
|
||||
) -> Result<rustfs_kms::types::RewrapDataKeyResponse, SseError> {
|
||||
let service = self
|
||||
.current_service()
|
||||
.await
|
||||
.ok_or_else(|| SseError::internal(KmsUnavailableError))?;
|
||||
service
|
||||
.rewrap_data_key(encrypted_dek, context)
|
||||
.await
|
||||
.map_err(kms_operation_error)
|
||||
}
|
||||
|
||||
async fn decrypt_sse_dek(
|
||||
&self,
|
||||
encrypted_dek: &[u8],
|
||||
_kms_key_id: &str,
|
||||
context: &ObjectEncryptionContext,
|
||||
) -> Result<[u8; 32], SseError> {
|
||||
let service = self
|
||||
.current_service()
|
||||
.await
|
||||
.ok_or_else(|| SseError::internal(KmsUnavailableError))?;
|
||||
let data_key = service
|
||||
.decrypt_data_key(encrypted_dek, context)
|
||||
.await
|
||||
.map_err(kms_unwrap_error)?;
|
||||
|
||||
Ok(data_key.plaintext_key)
|
||||
}
|
||||
|
||||
#[cfg(feature = "rio-v2")]
|
||||
async fn decrypt_legacy_sse_dek(
|
||||
&self,
|
||||
encrypted_dek: &[u8],
|
||||
_kms_key_id: &str,
|
||||
_context: &ObjectEncryptionContext,
|
||||
) -> Result<[u8; 32], SseError> {
|
||||
let service = self
|
||||
.current_service()
|
||||
.await
|
||||
.ok_or_else(|| SseError::internal(KmsUnavailableError))?;
|
||||
let data_key = service
|
||||
.decrypt_legacy_data_key(encrypted_dek)
|
||||
.await
|
||||
.map_err(kms_unwrap_error)?;
|
||||
|
||||
Ok(data_key.plaintext_key)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,323 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! The provider that wraps data keys with a node-local master key when no KMS is configured.
|
||||
|
||||
use crate::error::SseError;
|
||||
#[cfg(feature = "rio-v2")]
|
||||
use crate::kms::minio::{decrypt_minio_kms_data_key, minio_kms_associated_data};
|
||||
use crate::kms::provider::SseDekProvider;
|
||||
use aes_gcm::aead::{Aead, KeyInit};
|
||||
use aes_gcm::{Aes256Gcm, Key, Nonce};
|
||||
use async_trait::async_trait;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use rand::Rng;
|
||||
use rustfs_kms::DataKey;
|
||||
use rustfs_kms::types::ObjectEncryptionContext;
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
use rustfs_utils::get_env_opt_str;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// Local SSE DEK provider for deployments without a KMS.
|
||||
///
|
||||
/// Uses `RUSTFS_SSE_S3_MASTER_KEY` (base64-encoded 32-byte key) to wrap
|
||||
/// data-encryption keys with AES-256-GCM. This is the production fallback
|
||||
/// when no KMS service is configured.
|
||||
///
|
||||
/// # Environment Variable
|
||||
///
|
||||
/// ```text
|
||||
/// RUSTFS_SSE_S3_MASTER_KEY=<base64_encoded_32_byte_key>
|
||||
/// ```
|
||||
pub struct LocalSseDekProvider {
|
||||
master_key: [u8; 32],
|
||||
}
|
||||
|
||||
pub(crate) const LOCAL_SSE_DEK_FORMAT_VERSION: u8 = 1;
|
||||
|
||||
/// Environment variable that carries the local SSE-S3 master key.
|
||||
pub(crate) const ENV_SSE_S3_MASTER_KEY: &str = "RUSTFS_SSE_S3_MASTER_KEY";
|
||||
|
||||
/// The configured local master key, still encoded; `None` when unset or blank.
|
||||
fn local_master_key_env_value() -> Option<String> {
|
||||
get_env_opt_str(ENV_SSE_S3_MASTER_KEY).filter(|value| !value.trim().is_empty())
|
||||
}
|
||||
|
||||
/// Whether the operator configured a local SSE-S3 master key at all.
|
||||
///
|
||||
/// Says nothing about whether the value is usable; loading it decides that.
|
||||
pub(crate) fn local_master_key_configured() -> bool {
|
||||
local_master_key_env_value().is_some()
|
||||
}
|
||||
|
||||
#[cfg(feature = "rio-v2")]
|
||||
/// Returns true when a managed-SSE data key is one RustFS itself wrote.
|
||||
///
|
||||
/// Both RustFS envelope shapes are strict JSON — the KMS envelope
|
||||
/// ([`rustfs_kms::is_data_key_envelope`]) and the local provider's
|
||||
/// [`LocalSseDekEnvelope`], whose `deny_unknown_fields` keeps it from accepting
|
||||
/// anything else. Recognition is deliberately positive: an unrecognized payload
|
||||
/// is left to MinIO's decoder rather than guessed at, and neither decoder is
|
||||
/// ever handed the other's format.
|
||||
pub(crate) fn is_rustfs_managed_data_key(encrypted_dek: &[u8]) -> bool {
|
||||
if rustfs_kms::is_data_key_envelope(encrypted_dek) {
|
||||
return true;
|
||||
}
|
||||
std::str::from_utf8(encrypted_dek)
|
||||
.ok()
|
||||
.is_some_and(|text| serde_json::from_str::<LocalSseDekEnvelope<'_>>(text).is_ok())
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub(crate) struct LocalSseDekEnvelope<'a> {
|
||||
pub(crate) version: u8,
|
||||
pub(crate) nonce: &'a str,
|
||||
ciphertext: &'a str,
|
||||
}
|
||||
|
||||
/// Whether [`LocalSseDekProvider`] could have written these bytes.
|
||||
///
|
||||
/// Covers both shapes [`LocalSseDekProvider::decrypt_dek`] accepts — anything
|
||||
/// presented as a JSON object, so a damaged local envelope keeps its own
|
||||
/// diagnosis, and the deprecated `nonce:ciphertext` base64 pair. Everything
|
||||
/// else is bytes the local provider can only reject.
|
||||
pub(crate) fn is_local_sse_dek(encrypted_dek: &[u8]) -> bool {
|
||||
let Ok(text) = std::str::from_utf8(encrypted_dek) else {
|
||||
return false;
|
||||
};
|
||||
if text.trim_start().starts_with('{') {
|
||||
return true;
|
||||
}
|
||||
let is_base64 = |part: &str| BASE64_STANDARD.decode_to_vec(part).is_ok();
|
||||
text.split_once(':')
|
||||
.is_some_and(|(nonce, ciphertext)| is_base64(nonce) && is_base64(ciphertext))
|
||||
}
|
||||
|
||||
/// Test-only alias so existing test code that references `TestSseDekProvider`
|
||||
/// continues to compile without changes.
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub type TestSseDekProvider = LocalSseDekProvider;
|
||||
|
||||
/// Parse the base64-encoded 32-byte master key from `__RUSTFS_SSE_SIMPLE_CMK`.
|
||||
///
|
||||
/// Returns an error (never crashes) for a missing, non-base64, wrong-length, or
|
||||
/// all-zero key so callers on the request path can fail the request instead of
|
||||
/// taking the whole server down (backlog#806).
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
pub(crate) fn parse_simple_sse_cmk(cmk_value: &str) -> Result<[u8; 32], SseError> {
|
||||
let trimmed = cmk_value.trim();
|
||||
if trimmed.is_empty() {
|
||||
return Err(SseError::internal(
|
||||
"SSE simple mode requires __RUSTFS_SSE_SIMPLE_CMK to be set to a base64-encoded 32-byte key",
|
||||
));
|
||||
}
|
||||
let decoded = BASE64_STANDARD
|
||||
.decode_to_vec(trimmed)
|
||||
.map_err(|e| SseError::internal(format!("__RUSTFS_SSE_SIMPLE_CMK must be valid base64: {e}")))?;
|
||||
let master_key: [u8; 32] = decoded.try_into().map_err(|v: Vec<u8>| {
|
||||
SseError::internal(format!("__RUSTFS_SSE_SIMPLE_CMK must decode to exactly 32 bytes, got {} bytes", v.len()))
|
||||
})?;
|
||||
if master_key == [0u8; 32] {
|
||||
return Err(SseError::internal("__RUSTFS_SSE_SIMPLE_CMK must not be an all-zero key"));
|
||||
}
|
||||
Ok(master_key)
|
||||
}
|
||||
|
||||
impl LocalSseDekProvider {
|
||||
/// Create a LocalSseDekProvider with a predefined key (for testing)
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
pub fn new_with_key(master_key: [u8; 32]) -> Self {
|
||||
Self { master_key }
|
||||
}
|
||||
|
||||
/// Create a TestSseDekProvider from `__RUSTFS_SSE_SIMPLE_CMK` (test-only).
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
pub fn new() -> Result<Self, SseError> {
|
||||
let cmk_value = std::env::var("__RUSTFS_SSE_SIMPLE_CMK").unwrap_or_default();
|
||||
// A missing/invalid key must surface as a request error, never crash the
|
||||
// whole server: `LocalSseDekProvider::new` is reached from the SSE request
|
||||
// path (get_sse_dek_provider), so `process::exit(1)` here turned a bad
|
||||
// `__RUSTFS_SSE_SIMPLE_CMK` into a process crash-loop DoS (backlog#806).
|
||||
let master_key = parse_simple_sse_cmk(&cmk_value)?;
|
||||
tracing::info!("Successfully loaded SSE master key (32 bytes) from __RUSTFS_SSE_SIMPLE_CMK");
|
||||
Ok(Self { master_key })
|
||||
}
|
||||
|
||||
/// Create a local SSE DEK provider for SSE-S3 when KMS is not configured.
|
||||
/// Requires RUSTFS_SSE_S3_MASTER_KEY to be a valid base64-encoded 32-byte key.
|
||||
///
|
||||
/// The failures here are server configuration problems, not internal
|
||||
/// faults: surface them as `InvalidRequest` (HTTP 400) so a managed-SSE
|
||||
/// request against an unconfigured server does not report 500 (rustfs#4844).
|
||||
pub fn new_from_env() -> Result<Self, SseError> {
|
||||
fn sse_not_configured(message: impl Into<String>) -> SseError {
|
||||
SseError {
|
||||
code: S3ErrorCode::InvalidRequest,
|
||||
message: message.into(),
|
||||
source: None,
|
||||
}
|
||||
}
|
||||
|
||||
let Some(raw_value) = local_master_key_env_value() else {
|
||||
return Err(sse_not_configured(
|
||||
"SSE-S3 requires RUSTFS_SSE_S3_MASTER_KEY to be set to a base64-encoded 32-byte key when KMS is not configured",
|
||||
));
|
||||
};
|
||||
|
||||
let decoded = BASE64_STANDARD.decode_to_vec(raw_value.trim()).map_err(|err| {
|
||||
sse_not_configured(format!(
|
||||
"RUSTFS_SSE_S3_MASTER_KEY must be valid base64 for SSE-S3 when KMS is not configured: {err}"
|
||||
))
|
||||
})?;
|
||||
let master_key: [u8; 32] = decoded.try_into().map_err(|_| {
|
||||
sse_not_configured("RUSTFS_SSE_S3_MASTER_KEY must decode to exactly 32 bytes for SSE-S3 when KMS is not configured")
|
||||
})?;
|
||||
|
||||
Ok(Self { master_key })
|
||||
}
|
||||
|
||||
// Simple encryption of DEK
|
||||
pub fn encrypt_dek(dek: [u8; 32], cmk_value: [u8; 32]) -> Result<String, SseError> {
|
||||
// Use AES-256-GCM to encrypt DEK
|
||||
let key = Key::<Aes256Gcm>::from(cmk_value);
|
||||
|
||||
let cipher = Aes256Gcm::new(&key);
|
||||
let mut nonce_bytes = [0u8; 12];
|
||||
rand::rng().fill_bytes(&mut nonce_bytes);
|
||||
let nonce = Nonce::from(nonce_bytes);
|
||||
let ciphertext = cipher
|
||||
.encrypt(&nonce, dek.as_slice())
|
||||
.map_err(|_| SseError::internal("Failed to encrypt DEK"))?;
|
||||
|
||||
let nonce = BASE64_STANDARD.encode_to_string(nonce);
|
||||
let ciphertext = BASE64_STANDARD.encode_to_string(ciphertext);
|
||||
serde_json::to_string(&LocalSseDekEnvelope {
|
||||
version: LOCAL_SSE_DEK_FORMAT_VERSION,
|
||||
nonce: &nonce,
|
||||
ciphertext: &ciphertext,
|
||||
})
|
||||
.map_err(|e| SseError::internal(format!("Failed to serialize encrypted DEK: {e}")))
|
||||
}
|
||||
|
||||
// Simple decryption of DEK
|
||||
pub fn decrypt_dek(encrypted_dek: &str, cmk_value: [u8; 32]) -> Result<[u8; 32], SseError> {
|
||||
let envelope = serde_json::from_str::<LocalSseDekEnvelope<'_>>(encrypted_dek);
|
||||
let (nonce, ciphertext) = match envelope {
|
||||
Ok(envelope) => {
|
||||
if envelope.version != LOCAL_SSE_DEK_FORMAT_VERSION {
|
||||
return Err(SseError::internal(format!(
|
||||
"Unsupported encrypted DEK format version: {}",
|
||||
envelope.version
|
||||
)));
|
||||
}
|
||||
(envelope.nonce, envelope.ciphertext)
|
||||
}
|
||||
Err(json_error) if encrypted_dek.trim_start().starts_with('{') => {
|
||||
return Err(SseError::internal(format!("Invalid encrypted DEK JSON format: {json_error}")));
|
||||
}
|
||||
Err(_) => {
|
||||
// DEPRECATED: read-only compatibility for persisted colon-delimited DEKs.
|
||||
// RUSTFS_COMPAT_TODO(sse-local-dek-json-v1): Remove after all supported upgrades have rewritten legacy DEKs.
|
||||
let Some((nonce, ciphertext)) = encrypted_dek.split_once(':') else {
|
||||
return Err(SseError::internal("Invalid encrypted DEK format"));
|
||||
};
|
||||
if ciphertext.contains(':') {
|
||||
return Err(SseError::internal("Invalid encrypted DEK format"));
|
||||
}
|
||||
(nonce, ciphertext)
|
||||
}
|
||||
};
|
||||
let nonce_vec = BASE64_STANDARD
|
||||
.decode_to_vec(nonce)
|
||||
.map_err(|_| SseError::internal("Invalid nonce format"))?;
|
||||
let ciphertext = BASE64_STANDARD
|
||||
.decode_to_vec(ciphertext)
|
||||
.map_err(|_| SseError::internal("Invalid ciphertext format"))?;
|
||||
|
||||
let key = Key::<Aes256Gcm>::from(cmk_value);
|
||||
let cipher = Aes256Gcm::new(&key);
|
||||
|
||||
let nonce_array: [u8; 12] = nonce_vec.try_into().map_err(|_| SseError::internal("Invalid nonce length"))?;
|
||||
let nonce = Nonce::from(nonce_array);
|
||||
|
||||
let plaintext = cipher
|
||||
.decrypt(&nonce, ciphertext.as_slice())
|
||||
.map_err(|e| SseError::internal(format!("Failed to decrypt DEK: {e}")))?;
|
||||
|
||||
let dek: [u8; 32] = plaintext
|
||||
.try_into()
|
||||
.map_err(|_| SseError::internal("Decrypted DEK has invalid length"))?;
|
||||
|
||||
Ok(dek)
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl SseDekProvider for LocalSseDekProvider {
|
||||
fn wraps_dek_with_local_master_key(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
async fn generate_sse_dek(
|
||||
&self,
|
||||
_context: &ObjectEncryptionContext,
|
||||
_kms_key_id: &str,
|
||||
) -> Result<(DataKey, Vec<u8>), SseError> {
|
||||
// Generate a 32-byte array as data key
|
||||
let mut dek = [0u8; 32];
|
||||
rand::rng().fill_bytes(&mut dek);
|
||||
|
||||
// Generate a 12-byte array as IV
|
||||
let mut nonce = [0u8; 12];
|
||||
rand::rng().fill_bytes(&mut nonce);
|
||||
|
||||
// Encrypt data key with master key
|
||||
let encrypted_dek = Self::encrypt_dek(dek, self.master_key)?;
|
||||
|
||||
// Return data key and IV
|
||||
Ok((
|
||||
DataKey {
|
||||
plaintext_key: dek,
|
||||
nonce,
|
||||
},
|
||||
encrypted_dek.into_bytes(),
|
||||
))
|
||||
}
|
||||
|
||||
async fn decrypt_sse_dek(
|
||||
&self,
|
||||
encrypted_dek: &[u8],
|
||||
_kms_key_id: &str,
|
||||
_context: &ObjectEncryptionContext,
|
||||
) -> Result<[u8; 32], SseError> {
|
||||
// Decrypt data key with master key
|
||||
let encrypted_dek_str =
|
||||
std::str::from_utf8(encrypted_dek).map_err(|_| SseError::internal("Invalid UTF-8 in encrypted DEK"))?;
|
||||
let dek = Self::decrypt_dek(encrypted_dek_str, self.master_key)?;
|
||||
Ok(dek)
|
||||
}
|
||||
|
||||
#[cfg(feature = "rio-v2")]
|
||||
async fn decrypt_minio_sse_dek(
|
||||
&self,
|
||||
encrypted_dek: &[u8],
|
||||
_kms_key_id: &str,
|
||||
context: &ObjectEncryptionContext,
|
||||
) -> Result<[u8; 32], SseError> {
|
||||
let aad = minio_kms_associated_data(context)?;
|
||||
decrypt_minio_kms_data_key(encrypted_dek, &self.master_key, &aad)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Reading data keys sealed by MinIO's builtin KMS.
|
||||
|
||||
use crate::core::keying::context::canonical_kms_bucket_path;
|
||||
use crate::core::keying::object::HmacSha256;
|
||||
use crate::error::SseError;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use hmac::Mac;
|
||||
use rustfs_kms::types::ObjectEncryptionContext;
|
||||
use serde::Deserialize;
|
||||
|
||||
/// Associated data MinIO binds when sealing a data key.
|
||||
///
|
||||
/// MinIO passes the object's encryption context as the AEAD's associated data,
|
||||
/// serialized as canonical JSON with sorted keys — the same canonicalization
|
||||
/// [`rustfs_kms::context_aad`] performs, which is why the context RustFS
|
||||
/// already rebuilds for the read can be reused verbatim. For SSE-S3 that
|
||||
/// context is `{bucket: "bucket/object"}`; for SSE-KMS it is whatever the
|
||||
/// request supplied, recovered from the stored MinIO context header.
|
||||
pub(crate) fn minio_kms_associated_data(context: &ObjectEncryptionContext) -> Result<Vec<u8>, SseError> {
|
||||
let mut ctx = context.encryption_context.clone();
|
||||
ctx.entry(context.bucket.clone())
|
||||
.or_insert_with(|| canonical_kms_bucket_path(&context.bucket, &context.object_key));
|
||||
rustfs_kms::context_aad(&ctx).map_err(|e| SseError::internal(format!("Failed to canonicalize MinIO KMS context: {e}")))
|
||||
}
|
||||
|
||||
/// MinIO's builtin-KMS ciphertext in its JSON encoding.
|
||||
///
|
||||
/// Deliberately its own type rather than a relaxation of
|
||||
/// [`LocalSseDekEnvelope`]: widening that envelope's `deny_unknown_fields`
|
||||
/// to admit this shape would also admit malformed RustFS envelopes, which
|
||||
/// backlog#1567 requires to keep failing closed.
|
||||
#[derive(Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct MinioKmsCiphertextJson {
|
||||
aead: String,
|
||||
#[allow(
|
||||
dead_code,
|
||||
reason = "present in MinIO's encoding; the key is identified by metadata instead"
|
||||
)]
|
||||
#[serde(default)]
|
||||
id: String,
|
||||
iv: String,
|
||||
nonce: String,
|
||||
bytes: String,
|
||||
}
|
||||
|
||||
/// Bytes of trailing randomness every MinIO builtin-KMS ciphertext carries:
|
||||
/// a 16-byte IV followed by a 12-byte nonce, *after* the sealed bytes.
|
||||
const MINIO_KMS_RANDOM_LEN: usize = 28;
|
||||
|
||||
const MINIO_KMS_IV_LEN: usize = 16;
|
||||
|
||||
const MINIO_KMS_AEAD_AES_GCM: &str = "AES-256-GCM-HMAC-SHA-256";
|
||||
|
||||
const MINIO_KMS_AEAD_CHACHA20: &str = "ChaCha20Poly1305";
|
||||
|
||||
/// Unwrap a data key sealed by MinIO's builtin (static-secret) KMS.
|
||||
///
|
||||
/// The wire format is `sealed_bytes || iv[16] || nonce[12]` — the randomness
|
||||
/// trails the ciphertext rather than leading it, and MinIO's own decoder
|
||||
/// normalizes its legacy JSON encoding into exactly that byte order before
|
||||
/// opening it (`internal/kms/secret-key.go`, `parseCiphertext`). A raw
|
||||
/// (non-JSON) ciphertext is AES-256-GCM by definition there; the JSON form
|
||||
/// names its algorithm.
|
||||
///
|
||||
/// The sealing key is derived per ciphertext rather than being the master key:
|
||||
/// `HMAC-SHA256(master, iv)` for AES-256-GCM, `HChaCha20(master, iv)` for
|
||||
/// ChaCha20-Poly1305. The encryption context is bound as associated data.
|
||||
pub(crate) fn decrypt_minio_kms_data_key(encrypted_dek: &[u8], master_key: &[u8; 32], aad: &[u8]) -> Result<[u8; 32], SseError> {
|
||||
let (body, algorithm) = match std::str::from_utf8(encrypted_dek) {
|
||||
// MinIO only treats a payload as JSON when it both starts and ends like
|
||||
// an object, and falls back to the raw layout when it does not parse —
|
||||
// mirrored here so a ciphertext that merely looks like JSON is not
|
||||
// rejected outright.
|
||||
Ok(text)
|
||||
if text.starts_with('{')
|
||||
&& text.ends_with('}')
|
||||
&& let Ok(json) = serde_json::from_str::<MinioKmsCiphertextJson>(text) =>
|
||||
{
|
||||
let decode = |what: &str, value: &str| -> Result<Vec<u8>, SseError> {
|
||||
BASE64_STANDARD
|
||||
.decode_to_vec(value)
|
||||
.map_err(|e| SseError::internal(format!("Invalid MinIO KMS {what}: {e}")))
|
||||
};
|
||||
let mut body = decode("ciphertext", &json.bytes)?;
|
||||
body.extend_from_slice(&decode("iv", &json.iv)?);
|
||||
body.extend_from_slice(&decode("nonce", &json.nonce)?);
|
||||
(body, json.aead)
|
||||
}
|
||||
_ => (encrypted_dek.to_vec(), MINIO_KMS_AEAD_AES_GCM.to_string()),
|
||||
};
|
||||
|
||||
if body.len() <= MINIO_KMS_RANDOM_LEN {
|
||||
return Err(SseError::internal("MinIO KMS ciphertext is too short to carry its IV and nonce"));
|
||||
}
|
||||
let (sealed, random) = body.split_at(body.len() - MINIO_KMS_RANDOM_LEN);
|
||||
let (iv, nonce) = random.split_at(MINIO_KMS_IV_LEN);
|
||||
|
||||
let plaintext = match algorithm.as_str() {
|
||||
MINIO_KMS_AEAD_AES_GCM => {
|
||||
use aes_gcm::{Aes256Gcm, KeyInit, aead::Aead};
|
||||
let mut mac = HmacSha256::new_from_slice(master_key)
|
||||
.map_err(|_| SseError::internal("MinIO KMS sealing key derivation failed"))?;
|
||||
mac.update(iv);
|
||||
let sealing_key: [u8; 32] = mac.finalize().into_bytes().into();
|
||||
let cipher = Aes256Gcm::new_from_slice(&sealing_key)
|
||||
.map_err(|_| SseError::internal("MinIO KMS sealing key is not a valid AES-256 key"))?;
|
||||
let nonce = aes_gcm::Nonce::try_from(nonce).map_err(|_| SseError::internal("MinIO KMS nonce is not 12 bytes"))?;
|
||||
cipher.decrypt(&nonce, aes_gcm::aead::Payload { msg: sealed, aad })
|
||||
}
|
||||
MINIO_KMS_AEAD_CHACHA20 => {
|
||||
use chacha20poly1305::{KeyInit, XChaCha20Poly1305, aead::Aead};
|
||||
// MinIO derives this branch's key with HChaCha20 over the 16-byte
|
||||
// IV, which is exactly XChaCha20-Poly1305's own construction, so the
|
||||
// extended-nonce cipher does the derivation rather than hand-rolling it.
|
||||
let mut extended = Vec::with_capacity(MINIO_KMS_IV_LEN + nonce.len());
|
||||
extended.extend_from_slice(iv);
|
||||
extended.extend_from_slice(nonce);
|
||||
let cipher = XChaCha20Poly1305::new_from_slice(master_key)
|
||||
.map_err(|_| SseError::internal("MinIO KMS master key is not a valid ChaCha20 key"))?;
|
||||
let nonce = chacha20poly1305::XNonce::try_from(extended.as_slice())
|
||||
.map_err(|_| SseError::internal("MinIO KMS extended nonce is not 24 bytes"))?;
|
||||
cipher.decrypt(&nonce, chacha20poly1305::aead::Payload { msg: sealed, aad })
|
||||
}
|
||||
other => {
|
||||
return Err(SseError::internal(format!("Unsupported MinIO KMS AEAD algorithm: {other}")));
|
||||
}
|
||||
}
|
||||
// An AEAD failure here is authentication, not a decode slip: a wrong master
|
||||
// key, a tampered ciphertext, and an encryption context that does not match
|
||||
// what sealed it all land here and must all fail closed.
|
||||
.map_err(|_| SseError::internal("MinIO KMS data key failed authentication"))?;
|
||||
|
||||
plaintext
|
||||
.try_into()
|
||||
.map_err(|value: Vec<u8>| SseError::internal(format!("MinIO KMS data key must be 32 bytes, got {}", value.len())))
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Data-key providers: where a data key is wrapped and unwrapped.
|
||||
|
||||
pub(crate) mod kms_backed;
|
||||
pub(crate) mod local;
|
||||
#[cfg(feature = "rio-v2")]
|
||||
pub(crate) mod minio;
|
||||
pub(crate) mod provider;
|
||||
@@ -0,0 +1,288 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! The data-key provider interface and the per-request choice between the KMS and the local master key.
|
||||
|
||||
use crate::error::SseError;
|
||||
use crate::host::SseHost;
|
||||
use crate::kms::kms_backed::KmsSseDekProvider;
|
||||
use crate::kms::local::LocalSseDekProvider;
|
||||
use async_trait::async_trait;
|
||||
use rustfs_kms::DataKey;
|
||||
use rustfs_kms::types::ObjectEncryptionContext;
|
||||
use std::sync::{Arc, LazyLock, RwLock};
|
||||
use tracing::debug;
|
||||
|
||||
/// Trait for SSE data encryption key management
|
||||
/// Abstracts the source of encryption keys (KMS, test provider, etc.)
|
||||
#[async_trait]
|
||||
pub trait SseDekProvider: Send + Sync {
|
||||
/// Generate an SSE data encryption key
|
||||
async fn generate_sse_dek(&self, context: &ObjectEncryptionContext, kms_key_id: &str)
|
||||
-> Result<(DataKey, Vec<u8>), SseError>;
|
||||
|
||||
/// Decrypt an SSE data encryption key (returns only plaintext key, nonce should be read from metadata)
|
||||
async fn decrypt_sse_dek(
|
||||
&self,
|
||||
encrypted_dek: &[u8],
|
||||
kms_key_id: &str,
|
||||
context: &ObjectEncryptionContext,
|
||||
) -> Result<[u8; 32], SseError>;
|
||||
|
||||
/// Whether this provider may own a stored data key that is not a RustFS
|
||||
/// envelope — see `KmsBackend::reads_bare_data_key_ciphertext`.
|
||||
async fn reads_bare_data_key_ciphertext(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Re-wrap a KMS-wrapped DEK envelope onto its master key's current
|
||||
/// version without exposing the plaintext DEK to the caller.
|
||||
///
|
||||
/// Defaults to refusing: only the KMS-backed provider can rewrap, and a
|
||||
/// provider that cannot must say so rather than hand back the input as if
|
||||
/// it had been re-protected.
|
||||
async fn rewrap_sse_dek(
|
||||
&self,
|
||||
_encrypted_dek: &[u8],
|
||||
_context: &ObjectEncryptionContext,
|
||||
) -> Result<rustfs_kms::types::RewrapDataKeyResponse, SseError> {
|
||||
Err(SseError::internal("This DEK provider cannot rewrap KMS-wrapped data keys"))
|
||||
}
|
||||
|
||||
/// Whether this provider wraps data keys with a node-local master key
|
||||
/// instead of a KMS service.
|
||||
///
|
||||
/// SSE-KMS must never be served by such a provider: the stored object would
|
||||
/// claim `aws:kms` and name a KMS key id that never wrapped anything.
|
||||
/// Defaults to false so only the local fallback has to declare itself.
|
||||
fn wraps_dek_with_local_master_key(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Decrypt a DEK from positively identified legacy managed metadata.
|
||||
#[cfg(feature = "rio-v2")]
|
||||
async fn decrypt_legacy_sse_dek(
|
||||
&self,
|
||||
encrypted_dek: &[u8],
|
||||
kms_key_id: &str,
|
||||
context: &ObjectEncryptionContext,
|
||||
) -> Result<[u8; 32], SseError> {
|
||||
self.decrypt_sse_dek(encrypted_dek, kms_key_id, context).await
|
||||
}
|
||||
|
||||
/// Unwrap a data key that MinIO's builtin KMS sealed.
|
||||
///
|
||||
/// A separate entry point rather than a shape sniff inside
|
||||
/// [`Self::decrypt_sse_dek`]: the caller already knows the object carries a
|
||||
/// MinIO sealed key, and MinIO's raw ciphertext is unstructured bytes that
|
||||
/// no parser can reliably tell apart from anything else. Routing on the
|
||||
/// caller's knowledge keeps a RustFS envelope from ever reaching MinIO's
|
||||
/// decoder, and vice versa.
|
||||
///
|
||||
/// Defaults to refusing: only a provider holding the MinIO master secret
|
||||
/// can serve these, and a provider that cannot must fail rather than fall
|
||||
/// back to a decoder that would misread the bytes.
|
||||
#[cfg(feature = "rio-v2")]
|
||||
async fn decrypt_minio_sse_dek(
|
||||
&self,
|
||||
_encrypted_dek: &[u8],
|
||||
_kms_key_id: &str,
|
||||
_context: &ObjectEncryptionContext,
|
||||
) -> Result<[u8; 32], SseError> {
|
||||
Err(SseError::internal(
|
||||
"This KMS provider cannot unwrap a data key sealed by MinIO's builtin KMS",
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
/// Unwrap the data key of an object that carries a sealed object key but no
|
||||
/// RustFS envelope.
|
||||
///
|
||||
/// Two writers produce that shape, and nothing in the bytes tells them apart:
|
||||
/// MinIO, whose data key is sealed under the static master key, and a RustFS
|
||||
/// `rio-v2` build on a backend that persisted its native ciphertext bare.
|
||||
/// MinIO's sealing is authenticated, so opening it under the local master key
|
||||
/// is a proof rather than a guess: the bare blob is offered to the KMS only
|
||||
/// once that has failed, or when no local master key exists to try. Without a
|
||||
/// backend that reads bare ciphertext the MinIO route is the only one, exactly
|
||||
/// as before.
|
||||
#[cfg(feature = "rio-v2")]
|
||||
pub(crate) async fn decrypt_unenveloped_sealed_dek(
|
||||
bare_kms: Option<Arc<dyn SseDekProvider + '_>>,
|
||||
local: Result<Arc<dyn SseDekProvider>, SseError>,
|
||||
encrypted_dek: &[u8],
|
||||
kms_key_id: &str,
|
||||
context: &ObjectEncryptionContext,
|
||||
) -> Result<[u8; 32], SseError> {
|
||||
let Some(kms) = bare_kms else {
|
||||
return local?.decrypt_minio_sse_dek(encrypted_dek, kms_key_id, context).await;
|
||||
};
|
||||
if let Ok(local) = local
|
||||
&& let Ok(data_key) = local.decrypt_minio_sse_dek(encrypted_dek, kms_key_id, context).await
|
||||
{
|
||||
return Ok(data_key);
|
||||
}
|
||||
kms.decrypt_sse_dek(encrypted_dek, kms_key_id, context).await
|
||||
}
|
||||
|
||||
/// The provider that unwraps KMS-wrapped data keys.
|
||||
///
|
||||
/// A provider registered through `set_sse_dek_provider_for_test` stands in for
|
||||
/// the fresh [`KmsSseDekProvider`], which cannot resolve a KMS service from a
|
||||
/// host that has none. Only `GLOBAL_KMS_DEK_PROVIDER` is consulted, never
|
||||
/// `GLOBAL_SSE_DEK_PROVIDER`, so a local provider cached by an earlier
|
||||
/// `get_local_sse_dek_provider` call cannot be selected to unwrap a KMS envelope.
|
||||
pub(crate) async fn kms_sse_dek_provider<'a>(host: &'a dyn SseHost) -> Result<Arc<dyn SseDekProvider + 'a>, SseError> {
|
||||
if let Some(cached) = GLOBAL_KMS_DEK_PROVIDER.read().ok().and_then(|guard| guard.as_ref().cloned()) {
|
||||
return Ok(cached);
|
||||
}
|
||||
Ok(Arc::new(KmsSseDekProvider::new(host).await?))
|
||||
}
|
||||
|
||||
/// The KMS provider, when its backend may own a stored data key that is not a
|
||||
/// RustFS envelope. `None` without a running KMS, which leaves such a key to
|
||||
/// the local provider exactly as before.
|
||||
pub(crate) async fn bare_data_key_kms_provider<'a>(host: &'a dyn SseHost) -> Option<Arc<dyn SseDekProvider + 'a>> {
|
||||
let provider = kms_sse_dek_provider(host).await.ok()?;
|
||||
provider.reads_bare_data_key_ciphertext().await.then_some(provider)
|
||||
}
|
||||
|
||||
/// Global SSE DEK provider cache for local / test providers.
|
||||
///
|
||||
/// Populated by `get_local_sse_dek_provider` and (for backward-compat in tests)
|
||||
/// `set_sse_dek_provider_for_test`. Read by `get_local_sse_dek_provider` only —
|
||||
/// the KMS-envelope decrypt path uses `GLOBAL_KMS_DEK_PROVIDER` so that a cached
|
||||
/// local provider can never be selected for a KMS-wrapped data-key.
|
||||
pub(crate) static GLOBAL_SSE_DEK_PROVIDER: LazyLock<RwLock<Option<Arc<dyn SseDekProvider>>>> =
|
||||
LazyLock::new(|| RwLock::new(None));
|
||||
|
||||
/// Global KMS DEK provider cache for test-injected KMS providers.
|
||||
///
|
||||
/// Populated **only** by `set_sse_dek_provider_for_test` (test-only).
|
||||
/// Read **only** by the KMS-envelope branch of `apply_managed_decryption_material`.
|
||||
/// Separation from `GLOBAL_SSE_DEK_PROVIDER` prevents a previously-cached local
|
||||
/// provider from being selected to unwrap a KMS data-key envelope.
|
||||
static GLOBAL_KMS_DEK_PROVIDER: LazyLock<RwLock<Option<Arc<dyn SseDekProvider>>>> = LazyLock::new(|| RwLock::new(None));
|
||||
|
||||
/// Get or initialize the global SSE DEK provider
|
||||
///
|
||||
/// Factory function that automatically selects the appropriate provider:
|
||||
/// - If `__RUSTFS_SSE_SIMPLE_CMK` environment variable exists: use SimpleSseDekProvider (test mode)
|
||||
/// - Otherwise: use KmsSseDekProvider (production mode with real KMS)
|
||||
///
|
||||
/// # Returns
|
||||
/// Arc to the global SSE DEK provider instance
|
||||
///
|
||||
/// # Example
|
||||
/// ```rust,ignore
|
||||
/// let provider = get_sse_dek_provider(host).await?;
|
||||
/// let (data_key, encrypted_dek) = provider
|
||||
/// .generate_sse_dek("bucket", "key", "kms-key-id")
|
||||
/// .await?;
|
||||
/// ```
|
||||
pub(crate) async fn get_sse_dek_provider<'a>(host: &'a dyn SseHost) -> Result<Arc<dyn SseDekProvider + 'a>, SseError> {
|
||||
if host.encryption_service().await.is_some() {
|
||||
debug!("Using KmsSseDekProvider (KMS configured)");
|
||||
return Ok(Arc::new(KmsSseDekProvider::new(host).await?));
|
||||
}
|
||||
|
||||
get_local_sse_dek_provider()
|
||||
}
|
||||
|
||||
/// Get the local data-key provider, loading and caching it on first use.
|
||||
///
|
||||
/// Startup calls this to check the local master key ahead of traffic; a request
|
||||
/// that arrives without that step loads it the same way and gets the same error.
|
||||
pub(crate) fn get_local_sse_dek_provider() -> Result<Arc<dyn SseDekProvider>, SseError> {
|
||||
// An explicitly injected test provider overrides both the cache and the
|
||||
// environment-based selection below.
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
if let Some(injected) = test_injected_sse_dek_provider() {
|
||||
return Ok(injected);
|
||||
}
|
||||
|
||||
// Check if already initialized
|
||||
if let Some(provider) = GLOBAL_SSE_DEK_PROVIDER
|
||||
.read()
|
||||
.map_err(|_| SseError::internal("Failed to read global SSE DEK provider cache"))?
|
||||
.as_ref()
|
||||
.cloned()
|
||||
{
|
||||
return Ok(provider);
|
||||
}
|
||||
|
||||
// In test mode, prefer the simple CMK provider when the env var is set.
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
{
|
||||
if std::env::var("__RUSTFS_SSE_SIMPLE_CMK").is_ok() {
|
||||
debug!("Using LocalSseDekProvider (test mode) based on __RUSTFS_SSE_SIMPLE_CMK");
|
||||
let provider: Arc<dyn SseDekProvider> = Arc::new(LocalSseDekProvider::new()?);
|
||||
let mut slot = GLOBAL_SSE_DEK_PROVIDER
|
||||
.write()
|
||||
.map_err(|_| SseError::internal("Failed to update global SSE DEK provider cache"))?;
|
||||
if let Some(existing) = slot.as_ref() {
|
||||
return Ok(existing.clone());
|
||||
}
|
||||
*slot = Some(provider.clone());
|
||||
return Ok(provider);
|
||||
}
|
||||
}
|
||||
|
||||
// Production fallback: local SSE-S3 provider (no KMS configured).
|
||||
debug!("Using local SSE-S3 provider (KMS not configured)");
|
||||
let provider: Arc<dyn SseDekProvider> = Arc::new(LocalSseDekProvider::new_from_env()?);
|
||||
|
||||
let mut slot = GLOBAL_SSE_DEK_PROVIDER
|
||||
.write()
|
||||
.map_err(|_| SseError::internal("Failed to update global SSE DEK provider cache"))?;
|
||||
if let Some(existing) = slot.as_ref() {
|
||||
return Ok(existing.clone());
|
||||
}
|
||||
*slot = Some(provider.clone());
|
||||
|
||||
Ok(provider)
|
||||
}
|
||||
|
||||
/// Reset both global SSE DEK provider caches (for testing only)
|
||||
///
|
||||
/// Clears GLOBAL_SSE_DEK_PROVIDER (local/test providers) and
|
||||
/// GLOBAL_KMS_DEK_PROVIDER (test-injected KMS providers).
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
pub fn reset_sse_dek_provider() {
|
||||
if let Ok(mut slot) = GLOBAL_SSE_DEK_PROVIDER.write() {
|
||||
*slot = None;
|
||||
}
|
||||
if let Ok(mut slot) = GLOBAL_KMS_DEK_PROVIDER.write() {
|
||||
*slot = None;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
pub fn set_sse_dek_provider_for_test(provider: Arc<dyn SseDekProvider>) {
|
||||
if let Ok(mut slot) = GLOBAL_KMS_DEK_PROVIDER.write() {
|
||||
*slot = Some(provider.clone());
|
||||
}
|
||||
if let Ok(mut slot) = GLOBAL_SSE_DEK_PROVIDER.write() {
|
||||
*slot = Some(provider);
|
||||
}
|
||||
}
|
||||
|
||||
/// Provider explicitly injected via `set_sse_dek_provider_for_test`, if any.
|
||||
///
|
||||
/// Reads `GLOBAL_KMS_DEK_PROVIDER` because that slot is populated *only* by the
|
||||
/// test setter, so a hit here always means an explicit test injection.
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
fn test_injected_sse_dek_provider() -> Option<Arc<dyn SseDekProvider>> {
|
||||
GLOBAL_KMS_DEK_PROVIDER.read().ok().and_then(|guard| guard.as_ref().cloned())
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! S3 server-side encryption: which key encrypts an object, and what is stored to find it again.
|
||||
//!
|
||||
//! Covers the three S3 schemes:
|
||||
//! - SSE-S3 (`AES256`): a data key wrapped by a key the server owns
|
||||
//! - SSE-KMS (`aws:kms`): a data key wrapped by a KMS key the caller names
|
||||
//! - SSE-C: a key the client supplies on every request and the server never stores
|
||||
//!
|
||||
//! ## Where this crate sits
|
||||
//!
|
||||
//! Between the S3 layer and the storage engine, depending on neither. It decides
|
||||
//! the effective scheme of a write, obtains and unwraps data keys, authorizes the
|
||||
//! use of a KMS key, and encodes and reads the encryption metadata of an object.
|
||||
//! It does not transform object bytes: it hands back key material
|
||||
//! ([`EncryptionMaterial`], [`DecryptionMaterial`]) and the caller applies it.
|
||||
//!
|
||||
//! What it needs from the running server — the KMS service, a bucket's default
|
||||
//! encryption, a key-permission decision — arrives through [`SseHost`], passed
|
||||
//! to every entry point that consults the server. Failures are reported as
|
||||
//! [`SseError`], already classified with the S3 error code the caller answers with.
|
||||
//!
|
||||
//! ## Entry points
|
||||
//!
|
||||
//! - [`sse_encryption`] and [`sse_prepare_encryption`] resolve the material of a write;
|
||||
//! [`encryption_material_to_metadata`] turns it into the metadata to store.
|
||||
//! - [`sse_decryption`] resolves the material of a read from stored metadata;
|
||||
//! [`classify_sse_read_response`] derives the response headers without unwrapping a key.
|
||||
//! - [`rewrap_object_encryption_metadata`] moves a stored data key onto the current
|
||||
//! version of its KMS key.
|
||||
//! - [`startup::init`] settles the environment-driven configuration once per process
|
||||
//! and reports it; calling it is optional.
|
||||
//!
|
||||
//! ```rust,ignore
|
||||
//! let request = EncryptionRequest {
|
||||
//! bucket: &bucket,
|
||||
//! key: &key,
|
||||
//! server_side_encryption: effective_sse,
|
||||
//! ssekms_key_id: effective_kms_key_id,
|
||||
//! ssekms_context: None,
|
||||
//! sse_customer_algorithm: None,
|
||||
//! sse_customer_key: None,
|
||||
//! sse_customer_key_md5: None,
|
||||
//! content_size: actual_size,
|
||||
//! principal: principal.as_ref(),
|
||||
//! };
|
||||
//!
|
||||
//! if let Some(material) = sse_encryption(host, request).await? {
|
||||
//! metadata.extend(encryption_material_to_metadata(&material)?);
|
||||
//! }
|
||||
//! ```
|
||||
|
||||
mod core;
|
||||
mod error;
|
||||
mod host;
|
||||
mod kms;
|
||||
pub mod startup;
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
pub mod testing;
|
||||
#[cfg(test)]
|
||||
#[allow(unused_imports)]
|
||||
mod tests;
|
||||
|
||||
pub use crate::core::audit::KmsRequestAuditScope;
|
||||
pub use crate::core::keying::material::{DecryptionMaterial, EncryptionKeyKind, EncryptionMaterial, ManagedSealedKey};
|
||||
pub use crate::core::keying::metadata::{
|
||||
ConflictingEncryptionMetadata, encryption_material_to_metadata, mark_encrypted_multipart_metadata,
|
||||
normalize_encryption_metadata_case, stored_ssec_metadata, strip_managed_encryption_metadata,
|
||||
};
|
||||
pub use crate::core::read::{DecryptionRequest, classify_sse_read_response, sse_decryption};
|
||||
pub use crate::core::request::SseKmsPrincipal;
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
pub use crate::core::request::TestAuthorizationHooks;
|
||||
pub use crate::core::rewrap::{ObjectDekRewrapOutcome, rewrap_object_encryption_metadata};
|
||||
pub use crate::core::s3::authorization::{authorize_sse_kms_multipart_write, authorize_sse_kms_object_read};
|
||||
pub use crate::core::s3::headers::{
|
||||
SseReadResponseHeaders, SsecParamsFromHeaders, build_ssec_read_headers, extract_server_side_encryption_from_headers,
|
||||
extract_ssec_params_from_headers, extract_ssekms_context_from_headers, project_sse_read_response_headers,
|
||||
validate_sse_headers_for_read, validate_sse_headers_for_write,
|
||||
};
|
||||
pub use crate::core::s3::scheme::{DEFAULT_SSE_ALGORITHM, bucket_default_write_sse};
|
||||
pub use crate::core::s3::ssec::{ssec_invalid_request, validate_ssec_for_read};
|
||||
pub use crate::core::write::{EncryptionRequest, PrepareEncryptionRequest, sse_encryption, sse_prepare_encryption};
|
||||
pub use crate::error::{KMS_KEY_NOT_FOUND_ERROR_CODE, SseError, data_plane_kms_error};
|
||||
pub use crate::host::{BucketDefaultEncryption, BucketEncryption, KmsKeyAuthorizer, SseHost};
|
||||
pub use crate::kms::local::LocalSseDekProvider;
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
pub use crate::kms::local::TestSseDekProvider;
|
||||
pub use crate::kms::provider::SseDekProvider;
|
||||
#[cfg(any(test, feature = "test-util"))]
|
||||
pub use crate::kms::provider::{reset_sse_dek_provider, set_sse_dek_provider_for_test};
|
||||
// The managed-SSE classifier lives in the shared encryption-keys module so the
|
||||
// scanner can reuse it; re-exported here so SSE callers find it beside the rest.
|
||||
pub use rustfs_utils::http::object_encryption_keys::SSEType;
|
||||
pub use rustfs_utils::http::object_encryption_keys::contains_managed_encryption_metadata;
|
||||
|
||||
pub(crate) const LOG_COMPONENT_STORAGE: &str = "storage";
|
||||
pub(crate) const LOG_SUBSYSTEM_SSE: &str = "sse";
|
||||
@@ -0,0 +1,250 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! The crate's process-startup step.
|
||||
//!
|
||||
//! [`init`] settles the two things that cannot change without a restart, both
|
||||
//! read from the environment, and reports them once:
|
||||
//!
|
||||
//! - whether SSE-KMS requests are authorized against the key they name;
|
||||
//! - whether the local SSE-S3 master key is usable.
|
||||
//!
|
||||
//! Nothing that follows the KMS service is decided here. The KMS can be
|
||||
//! configured, started, restarted, and stopped while the server runs, so the
|
||||
//! choice between the KMS and the local master key is made per request, and no
|
||||
//! KMS state is cached by this crate.
|
||||
//!
|
||||
//! Calling [`init`] is optional. A process that never calls it reads the same
|
||||
//! switch and loads the same master key on first use, with the same errors; it
|
||||
//! only goes without the startup report.
|
||||
|
||||
use crate::error::SseError;
|
||||
use crate::kms::local::{ENV_SSE_S3_MASTER_KEY, local_master_key_configured};
|
||||
use crate::kms::provider::get_local_sse_dek_provider;
|
||||
use crate::{LOG_COMPONENT_STORAGE, LOG_SUBSYSTEM_SSE};
|
||||
use rustfs_config::{DEFAULT_KMS_ENFORCE_SSE_KEY_POLICY, ENV_RUSTFS_KMS_ENFORCE_SSE_KEY_POLICY};
|
||||
use rustfs_utils::get_env_bool;
|
||||
use std::sync::{LazyLock, OnceLock};
|
||||
|
||||
const EVENT_SSE_KMS_KEY_POLICY_MODE: &str = "sse_kms_key_policy_mode";
|
||||
const EVENT_SSE_LOCAL_MASTER_KEY: &str = "sse_local_master_key";
|
||||
|
||||
/// State of the local SSE-S3 master key at startup.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum LocalMasterKeyStatus {
|
||||
/// Configured and usable; SSE-S3 works without a KMS.
|
||||
Loaded,
|
||||
/// Not configured; SSE-S3 requires a running KMS.
|
||||
NotSet,
|
||||
/// Configured but unusable; SSE-S3 requests that need it are rejected.
|
||||
Invalid,
|
||||
}
|
||||
|
||||
impl LocalMasterKeyStatus {
|
||||
fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Self::Loaded => "loaded",
|
||||
Self::NotSet => "not_set",
|
||||
Self::Invalid => "invalid",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// What [`init`] settled for this process.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct StartupReport {
|
||||
/// Whether SSE-KMS requests are authorized against the KMS key they name.
|
||||
pub key_policy_enforced: bool,
|
||||
/// State of the local SSE-S3 master key.
|
||||
pub local_master_key: LocalMasterKeyStatus,
|
||||
}
|
||||
|
||||
/// Settle the process-wide SSE configuration and report it.
|
||||
///
|
||||
/// Idempotent: the first call does the work and logs; later calls, such as a
|
||||
/// second embedded server in the same process, return the same report silently.
|
||||
/// An unusable master key does not fail startup, because a server whose KMS is
|
||||
/// running never needs it.
|
||||
pub fn init() -> StartupReport {
|
||||
static REPORT: OnceLock<StartupReport> = OnceLock::new();
|
||||
*REPORT.get_or_init(|| {
|
||||
let key_policy_enforced = key_policy_enforced();
|
||||
log_key_policy_mode(key_policy_enforced);
|
||||
|
||||
let local_master_key = load_local_master_key();
|
||||
log_local_master_key(&local_master_key);
|
||||
|
||||
StartupReport {
|
||||
key_policy_enforced,
|
||||
local_master_key: local_master_key.unwrap_or(LocalMasterKeyStatus::Invalid),
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether per-key KMS authorization is enforced on the SSE-KMS data path.
|
||||
///
|
||||
/// Frozen on first read, by [`init`] or by the first request, so one process
|
||||
/// never answers the same question two ways.
|
||||
pub(crate) fn key_policy_enforced() -> bool {
|
||||
static ENFORCED: LazyLock<bool> =
|
||||
LazyLock::new(|| get_env_bool(ENV_RUSTFS_KMS_ENFORCE_SSE_KEY_POLICY, DEFAULT_KMS_ENFORCE_SSE_KEY_POLICY));
|
||||
*ENFORCED
|
||||
}
|
||||
|
||||
/// Load the local master key through the loader the request path uses.
|
||||
///
|
||||
/// An absent key is a state, not a failure: only a configured key is loaded, so
|
||||
/// the error case is exactly "configured but unusable".
|
||||
fn load_local_master_key() -> Result<LocalMasterKeyStatus, SseError> {
|
||||
if !local_master_key_configured() {
|
||||
return Ok(LocalMasterKeyStatus::NotSet);
|
||||
}
|
||||
get_local_sse_dek_provider().map(|_| LocalMasterKeyStatus::Loaded)
|
||||
}
|
||||
|
||||
/// Report the configured SSE-KMS authorization mode.
|
||||
///
|
||||
/// The disabled case warns rather than logs: while enforcement is off, any identity
|
||||
/// allowed to write an object can encrypt it under any key, and operators should hear
|
||||
/// about that even though disabled is the long-term default.
|
||||
fn log_key_policy_mode(enforced: bool) {
|
||||
if enforced {
|
||||
tracing::info!(
|
||||
event = EVENT_SSE_KMS_KEY_POLICY_MODE,
|
||||
component = LOG_COMPONENT_STORAGE,
|
||||
subsystem = LOG_SUBSYSTEM_SSE,
|
||||
enforced = true,
|
||||
"SSE-KMS requests are authorized against the resolved KMS key (kms:GenerateDataKey / kms:Decrypt)"
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
tracing::warn!(
|
||||
event = EVENT_SSE_KMS_KEY_POLICY_MODE,
|
||||
component = LOG_COMPONENT_STORAGE,
|
||||
subsystem = LOG_SUBSYSTEM_SSE,
|
||||
enforced = false,
|
||||
"SSE-KMS requests are not authorized against the KMS key they name; any identity allowed to \
|
||||
write an object may encrypt it under any key, and any identity allowed to read it may have it \
|
||||
decrypted. Grant kms:GenerateDataKey and kms:Decrypt on the keys your workloads use, then set \
|
||||
{ENV_RUSTFS_KMS_ENFORCE_SSE_KEY_POLICY}=true."
|
||||
);
|
||||
}
|
||||
|
||||
/// Report the local master key's state.
|
||||
///
|
||||
/// The failure text is the one a request is answered with. It describes the
|
||||
/// configuration problem and never carries the configured value.
|
||||
fn log_local_master_key(outcome: &Result<LocalMasterKeyStatus, SseError>) {
|
||||
match outcome {
|
||||
Ok(status @ LocalMasterKeyStatus::Loaded) => tracing::info!(
|
||||
event = EVENT_SSE_LOCAL_MASTER_KEY,
|
||||
component = LOG_COMPONENT_STORAGE,
|
||||
subsystem = LOG_SUBSYSTEM_SSE,
|
||||
state = status.as_str(),
|
||||
"{ENV_SSE_S3_MASTER_KEY} is loaded; SSE-S3 uses it whenever no KMS is running"
|
||||
),
|
||||
Ok(status) => tracing::info!(
|
||||
event = EVENT_SSE_LOCAL_MASTER_KEY,
|
||||
component = LOG_COMPONENT_STORAGE,
|
||||
subsystem = LOG_SUBSYSTEM_SSE,
|
||||
state = status.as_str(),
|
||||
"{ENV_SSE_S3_MASTER_KEY} is not set; SSE-S3 requires a running KMS"
|
||||
),
|
||||
Err(error) => tracing::error!(
|
||||
event = EVENT_SSE_LOCAL_MASTER_KEY,
|
||||
component = LOG_COMPONENT_STORAGE,
|
||||
subsystem = LOG_SUBSYSTEM_SSE,
|
||||
state = LocalMasterKeyStatus::Invalid.as_str(),
|
||||
reason = %error.message,
|
||||
"{ENV_SSE_S3_MASTER_KEY} is set but unusable; SSE-S3 requests are rejected while no KMS is running"
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::kms::provider::reset_sse_dek_provider;
|
||||
use crate::tests::lock_sse_test_state;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
use temp_env::with_vars;
|
||||
|
||||
/// Run `check` with the local master key set to `value` and nothing cached or injected.
|
||||
async fn with_master_key<T>(value: Option<&str>, check: impl FnOnce() -> T) -> T {
|
||||
let _guard = lock_sse_test_state().await;
|
||||
reset_sse_dek_provider();
|
||||
let outcome = with_vars([(ENV_SSE_S3_MASTER_KEY, value), ("__RUSTFS_SSE_SIMPLE_CMK", None)], check);
|
||||
reset_sse_dek_provider();
|
||||
outcome
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn an_absent_master_key_is_reported_as_not_set() {
|
||||
let status = with_master_key(None, load_local_master_key)
|
||||
.await
|
||||
.expect("an absent key is a state, not a failure");
|
||||
assert_eq!(status, LocalMasterKeyStatus::NotSet);
|
||||
|
||||
let blank = with_master_key(Some(" "), load_local_master_key)
|
||||
.await
|
||||
.expect("a blank value counts as absent");
|
||||
assert_eq!(blank, LocalMasterKeyStatus::NotSet);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_valid_master_key_is_loaded_and_cached_for_requests() {
|
||||
let encoded = BASE64_STANDARD.encode_to_string([7u8; 32]);
|
||||
let cached = with_master_key(Some(&encoded), || {
|
||||
let status = load_local_master_key().expect("a 32-byte key should load");
|
||||
assert_eq!(status, LocalMasterKeyStatus::Loaded);
|
||||
// The request path must find the provider startup loaded, not load a second one.
|
||||
crate::kms::provider::GLOBAL_SSE_DEK_PROVIDER
|
||||
.read()
|
||||
.expect("provider cache lock")
|
||||
.is_some()
|
||||
})
|
||||
.await;
|
||||
assert!(cached, "startup should leave the provider cached for the request path");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn an_unusable_master_key_fails_the_way_a_request_would() {
|
||||
let short = BASE64_STANDARD.encode_to_string([7u8; 16]);
|
||||
for unusable in ["not base64 at all!", short.as_str()] {
|
||||
let error = with_master_key(Some(unusable), load_local_master_key)
|
||||
.await
|
||||
.expect_err("an unusable key must not load");
|
||||
assert_eq!(error.code, S3ErrorCode::InvalidRequest);
|
||||
assert!(
|
||||
!error.message.contains(unusable),
|
||||
"the failure text must not carry the configured value: {}",
|
||||
error.message
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn init_reports_once_and_repeats_the_same_report() {
|
||||
let encoded = BASE64_STANDARD.encode_to_string([9u8; 32]);
|
||||
let (first, second) = with_master_key(Some(&encoded), || (init(), init())).await;
|
||||
|
||||
assert_eq!(first, second, "a second call must return the first report");
|
||||
assert_eq!(first.key_policy_enforced, key_policy_enforced());
|
||||
// The report is settled once per process, so this holds whether this test
|
||||
// or another caller of `init` ran first.
|
||||
assert_eq!(init(), first);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Fixtures for tests of SSE call sites, in this crate and in its dependents.
|
||||
|
||||
use crate::{KmsKeyAuthorizer, SseError, SseKmsPrincipal};
|
||||
use async_trait::async_trait;
|
||||
use base64_simd::STANDARD as BASE64_STANDARD;
|
||||
use rustfs_policy::policy::action::KmsAction;
|
||||
use rustfs_utils::http::headers::AMZ_ENCRYPTION_KMS;
|
||||
use rustfs_utils::http::object_encryption_keys::{
|
||||
INTERNAL_ENCRYPTION_ALGORITHM_HEADER, INTERNAL_ENCRYPTION_IV_HEADER, INTERNAL_ENCRYPTION_KEY_HEADER,
|
||||
INTERNAL_ENCRYPTION_KEY_ID_HEADER,
|
||||
};
|
||||
use std::collections::HashMap;
|
||||
use std::sync::{Arc, Mutex, PoisonError};
|
||||
|
||||
/// An authorizer that answers every request the same way and records what it was asked.
|
||||
pub struct RecordingKmsKeyAuthorizer {
|
||||
allowed: bool,
|
||||
calls: Mutex<Vec<(KmsAction, String)>>,
|
||||
}
|
||||
|
||||
impl RecordingKmsKeyAuthorizer {
|
||||
pub fn new(allowed: bool) -> Arc<Self> {
|
||||
Arc::new(Self {
|
||||
allowed,
|
||||
calls: Mutex::new(Vec::new()),
|
||||
})
|
||||
}
|
||||
|
||||
/// The `(action, key id)` pairs this authorizer was asked about, in order.
|
||||
pub fn calls(&self) -> Vec<(KmsAction, String)> {
|
||||
self.calls.lock().unwrap_or_else(PoisonError::into_inner).clone()
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl KmsKeyAuthorizer for RecordingKmsKeyAuthorizer {
|
||||
async fn is_allowed(&self, _principal: &SseKmsPrincipal, action: KmsAction, key_id: &str) -> Result<bool, SseError> {
|
||||
self.calls
|
||||
.lock()
|
||||
.unwrap_or_else(PoisonError::into_inner)
|
||||
.push((action, key_id.to_string()));
|
||||
Ok(self.allowed)
|
||||
}
|
||||
}
|
||||
|
||||
/// Stored metadata of an SSE-KMS object wrapped under the key `finance-key`.
|
||||
pub fn sse_kms_object_metadata() -> HashMap<String, String> {
|
||||
HashMap::from([
|
||||
("x-amz-server-side-encryption".to_string(), AMZ_ENCRYPTION_KMS.to_string()),
|
||||
("x-amz-server-side-encryption-aws-kms-key-id".to_string(), "finance-key".to_string()),
|
||||
(INTERNAL_ENCRYPTION_KEY_ID_HEADER.to_string(), "finance-key".to_string()),
|
||||
(INTERNAL_ENCRYPTION_KEY_HEADER.to_string(), BASE64_STANDARD.encode_to_string([7u8; 48])),
|
||||
(INTERNAL_ENCRYPTION_IV_HEADER.to_string(), BASE64_STANDARD.encode_to_string([9u8; 12])),
|
||||
(INTERNAL_ENCRYPTION_ALGORITHM_HEADER.to_string(), "aws:kms".to_string()),
|
||||
])
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -30,12 +30,11 @@ doctest = false
|
||||
|
||||
[features]
|
||||
default = []
|
||||
hotpath = ["hotpath/hotpath", "hotpath/tokio", "rustfs-rio/hotpath"]
|
||||
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc", "rustfs-rio/hotpath-alloc"]
|
||||
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu", "rustfs-rio/hotpath-cpu"]
|
||||
hotpath = ["rustfs-rio/hotpath"]
|
||||
hotpath-alloc = ["hotpath", "rustfs-rio/hotpath-alloc"]
|
||||
hotpath-cpu = ["hotpath", "rustfs-rio/hotpath-cpu"]
|
||||
|
||||
[dependencies]
|
||||
hotpath.workspace = true
|
||||
async-compression = { workspace = true, features = [
|
||||
"tokio",
|
||||
"bzip2",
|
||||
@@ -49,10 +48,6 @@ rustfs-rio.workspace = true
|
||||
tokio = { workspace = true, features = ["io-util", "macros", "rt"] }
|
||||
thiserror = { workspace = true }
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
# Keep XZ decoding self-contained in macOS binaries instead of linking Homebrew liblzma.
|
||||
liblzma = { version = "0.4.9", features = ["static"] }
|
||||
|
||||
[dev-dependencies]
|
||||
rustfs-tokio-tar = { workspace = true }
|
||||
futures = { workspace = true }
|
||||
|
||||
@@ -29,14 +29,16 @@ zdict_builder = ["zstd_fixed/zdict_builder"]
|
||||
zstdmt = ["zstd_fixed/zstdmt"]
|
||||
|
||||
[dev-dependencies]
|
||||
# Enables zstd-safe's `seekable` feature for tests/security.rs. The test imports
|
||||
# `zstd_safe::seekable` directly so cargo-shear treats this as a used dependency.
|
||||
zstd-safe = { version = "8.3.0", features = ["seekable"] }
|
||||
toml = "1.2.1"
|
||||
toml = "1.2.2"
|
||||
semver = "1.0.28"
|
||||
apache-avro.workspace = true
|
||||
arrow-array = "60.1.0"
|
||||
arrow-ipc = { version = "60.1.0", features = ["zstd"] }
|
||||
arrow-schema = "60.1.0"
|
||||
parquet = { version = "60.1.0", default-features = false, features = ["arrow", "zstd"] }
|
||||
arrow-array = "60.2.0"
|
||||
arrow-ipc = { version = "60.2.0", features = ["zstd"] }
|
||||
arrow-schema = "60.2.0"
|
||||
parquet = { version = "60.2.0", default-features = false, features = ["arrow", "zstd"] }
|
||||
kafka-protocol = { version = "0.18.0", default-features = false, features = ["zstd"] }
|
||||
bytes.workspace = true
|
||||
|
||||
|
||||
@@ -86,7 +86,7 @@ fn corrupt_legacy_frame_cannot_emit_bytes_when_writer_is_dropped() {
|
||||
|
||||
#[test]
|
||||
fn seekable_offsets_past_eof_keep_vec_length_within_capacity() {
|
||||
use zstd::zstd_safe::seekable::{Seekable, SeekableCStream};
|
||||
use zstd_safe::seekable::{Seekable, SeekableCStream};
|
||||
|
||||
let source = b"seekable frame fixture with enough data for several independent frames";
|
||||
let mut encoded = [0; 1024];
|
||||
|
||||
@@ -30,9 +30,11 @@ Contract crates stay below implementation crates. Forbidden edges:
|
||||
| `security-governance -> rustfs` | Governance contracts stay below the binary crate |
|
||||
| `extension-schema -> rustfs` | The extension schema is consumed by the binary, never the reverse |
|
||||
| `extension-schema -> ecstore` | The extension schema must not reach storage internals |
|
||||
| `sse -> ecstore`, `sse -> iam`, `sse -> rustfs` | SSE key resolution reaches the running server only through its `SseHost` port |
|
||||
|
||||
- `rustfs-storage-api` exposes storage-facing replication status/state contracts only through `crates/storage-api/src/replication.rs`, so its temporary dependency on `rustfs-filemeta` wire types stays centralized and no `rustfs-replication` / `rustfs-storage-api` cycle appears.
|
||||
- Leaf crates (`config`, `credentials`, `crypto`, `io-metrics`, `madmin`) may not depend on other `rustfs-*` crates, in either TOML spelling, except the adjudicated edges pinned in the guard's leaf allowlist: `io-metrics -> rustfs-s3-ops` (pure contract crates sharing the `S3Operation` vocabulary) and `madmin -> rustfs-signer` (the SigV4-signed admin SDK client). A new leaf exception must be a pure contract dependency (types and enums only, no I/O, no globals, no non-contract internal dependencies) and land together with its allowlist entry.
|
||||
- `rustfs-sse` sits between the S3 layer and the storage engine and depends on neither. Its internal dependencies are pinned in the same guard to `rustfs-config`, `rustfs-kms`, `rustfs-policy`, `rustfs-s3-types`, and `rustfs-utils`; the KMS service, a bucket's default encryption, and key-permission decisions arrive through `rustfs_sse::SseHost`, which `rustfs/src/storage/sse.rs` implements. That file also owns every translation across the engine boundary (`ObjectEncryptionResolver`, `WriteEncryption`, `MultipartCompletionAuthorization`), so neither side names the other's types.
|
||||
- Compile-time source reads follow the same direction: `include_str!` / `include!` of a `.rs` file must not resolve outside the including crate (`scripts/check_layer_dependencies.sh`). Shared source-text expectations belong in a contract surface such as `rustfs_protos::compat_manifest` (`crates/protos/src/compat_manifest.rs`) and are asserted by each owning crate.
|
||||
|
||||
## ECStore Access Boundary
|
||||
|
||||
@@ -47,7 +47,7 @@ RustFS-side statics that matter architecturally because other modules are tempte
|
||||
| `KEYSTONE_AUTH`, `KEYSTONE_MAPPER`, `KEYSTONE_CONFIG` | `rustfs/src/auth_keystone.rs` | Keystone provider, mapper, and config stay private to the Keystone owner. |
|
||||
| `DEADLOCK_DETECTOR` | `rustfs/src/storage/deadlock_detector.rs` | Detector lifecycle stays private to the storage deadlock detector. |
|
||||
| `CONCURRENCY_MANAGER` | `rustfs/src/storage/concurrency/manager.rs` | Storage concurrency scheduler state stays inside the concurrency owner. |
|
||||
| `GLOBAL_KMS_DEK_PROVIDER`, `GLOBAL_SSE_DEK_PROVIDER` | `rustfs/src/storage/sse.rs` | DEK provider caches stay private to the SSE owner. |
|
||||
| `GLOBAL_KMS_DEK_PROVIDER`, `GLOBAL_SSE_DEK_PROVIDER` | `crates/sse/src/kms/provider.rs` | DEK provider caches stay private to the SSE owner. |
|
||||
| `ECSTORE_EVENT_DISPATCH_HOOK` | `rustfs/src/server/event.rs` | Event bridge registration goes through the storage facade. |
|
||||
| `AUDIT_MODULE_ENABLED`, `NOTIFY_MODULE_ENABLED` | `rustfs/src/module_switches.rs` | Module toggles are read through module-switch helpers; `MODULE_SWITCH_RMW_LOCK` (`rustfs/src/server/module_switch.rs`) serializes persisted updates. |
|
||||
| `RUNTIME_CONFIG_RELOAD_MUTEX` | `rustfs/src/admin/service/config.rs` | Serializes dynamic config reload fanout. |
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
# KMS Bulk Rekey Job Contract
|
||||
|
||||
**Use this when:** changing the bulk envelope re-wrap sweep (`rustfs/src/kms_rekey.rs`), its admin endpoints (`rustfs/src/admin/handlers/kms_rekey.rs`), the re-wrap primitive, or anything that decides which objects a rekey may touch.
|
||||
**Source of truth:** `rustfs/src/kms_rekey.rs`, `rustfs/src/admin/handlers/kms_rekey.rs`, `rewrap_object_encryption_metadata` in `rustfs/src/storage/sse.rs`, `KmsManager::rewrap_data_key` / `KmsManager::describe_data_key_wrapping` in `crates/kms/src/manager.rs`, `put_object_metadata` in `crates/ecstore/src/set_disk/ops/object.rs`.
|
||||
**Source of truth:** `rustfs/src/kms_rekey.rs`, `rustfs/src/admin/handlers/kms_rekey.rs`, `rewrap_object_encryption_metadata` in `crates/sse/src/core/rewrap.rs`, `KmsManager::rewrap_data_key` / `KmsManager::describe_data_key_wrapping` in `crates/kms/src/manager.rs`, `put_object_metadata` in `crates/ecstore/src/set_disk/ops/object.rs`.
|
||||
|
||||
The bulk rekey job re-wraps stored data-key envelopes under the current key-encryption key (KEK) without rewriting object bodies. This document is the acceptance bar; where the shipped v1 sweep deliberately narrows it, [Implementation Status](#implementation-status-v1-sweep) records the deviation.
|
||||
|
||||
@@ -52,7 +52,7 @@ Idempotency comes from object metadata itself: the envelope's state is the targe
|
||||
|
||||
### Reading the wrapping KEK version
|
||||
|
||||
There is no key-version metadata key. Object metadata carries the key id (`x-rustfs-encryption-key-id`) and the sealed blob under `x-rustfs-encryption-key`; `DecryptResponse` in `crates/kms/src/types.rs` does not report a version either. The version is recoverable because the sealed blob is structured: for every backend that builds one, the ciphertext is the JSON of `DataKeyEnvelope` (`crates/kms/src/encryption/dek.rs`), and the read path already discriminates on it via `is_data_key_envelope` in `rustfs/src/storage/sse.rs`.
|
||||
There is no key-version metadata key. Object metadata carries the key id (`x-rustfs-encryption-key-id`) and the sealed blob under `x-rustfs-encryption-key`; `DecryptResponse` in `crates/kms/src/types.rs` does not report a version either. The version is recoverable because the sealed blob is structured: for every backend that builds one, the ciphertext is the JSON of `DataKeyEnvelope` (`crates/kms/src/encryption/dek.rs`), and the read path already discriminates on it via `is_data_key_envelope` in `crates/sse/src/core/read.rs`.
|
||||
|
||||
| Backend | Rotates | Where the wrapping version lives | Recoverable by a scan |
|
||||
|---|---|---|---|
|
||||
@@ -95,7 +95,7 @@ Replication destinations are unresolved: propagation depends on `rustfs/backlog#
|
||||
|
||||
Three properties of `put_object_metadata` (`crates/ecstore/src/set_disk/ops/object.rs`) constrain the re-wrap write:
|
||||
|
||||
- **The merge is additive; it cannot remove keys.** Overwriting a key that keeps its name is safe; a re-wrap that changes *which* keys describe the envelope leaves the old keys behind. This is a live hazard: `parse_minio_managed_sealed_key` in `rustfs/src/storage/sse.rs` selects the MinIO decrypt branch on the mere presence of the MinIO seal-algorithm header, so a RustFS-native envelope written onto MinIO-compatible headers without neutralizing them steers reads down the stale branch. Any envelope-shape change must neutralize superseded keys in the same write.
|
||||
- **The merge is additive; it cannot remove keys.** Overwriting a key that keeps its name is safe; a re-wrap that changes *which* keys describe the envelope leaves the old keys behind. This is a live hazard: `parse_minio_managed_sealed_key` in `crates/sse/src/core/keying/object.rs` selects the MinIO decrypt branch on the mere presence of the MinIO seal-algorithm header, so a RustFS-native envelope written onto MinIO-compatible headers without neutralizing them steers reads down the stale branch. Any envelope-shape change must neutralize superseded keys in the same write.
|
||||
- **Object-lock retention is enforced before the merge.** `check_object_lock_retention_update` (`crates/ecstore/src/set_disk/mod.rs`) runs first; rekey inherits its decision and must not acquire a bypass.
|
||||
- **`mod_time` is preserved unless the caller sets it.** The re-wrap path leaves it unset so age-based lifecycle rules are not perturbed.
|
||||
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
# MinIO On-Disk Format Interoperability
|
||||
|
||||
**Use this when:** deciding whether a MinIO drive set, bucket-metadata blob, or SSE object can be read or imported by a given RustFS build, or before touching any constant or codec listed under Version Anchors.
|
||||
**Source of truth:** `crates/filemeta/src/filemeta.rs`, `crates/filemeta/src/filemeta/codec.rs`, `crates/ecstore/src/bucket/metadata.rs`, `crates/ecstore/src/bucket/migration.rs`, `rustfs/src/storage/sse.rs`, `rustfs/Cargo.toml` `[features]`, `.github/workflows/ci.yml`, `.github/workflows/minio-interop.yml`.
|
||||
**Source of truth:** `crates/filemeta/src/filemeta.rs`, `crates/filemeta/src/filemeta/codec.rs`, `crates/ecstore/src/bucket/metadata.rs`, `crates/ecstore/src/bucket/migration.rs`, `crates/sse/src/core/`, `crates/sse/src/kms/`, `rustfs/Cargo.toml` `[features]`, `.github/workflows/ci.yml`, `.github/workflows/minio-interop.yml`.
|
||||
|
||||
This is an interop contract, not a plan. Migration is one-way (MinIO to RustFS). Erasure-coding internals are owned by [erasure-coding.md](erasure-coding.md); this document owns the interop claim, the fixture evidence, and the out-of-scope list.
|
||||
|
||||
## Scope Matrix By Build Variant
|
||||
|
||||
Build variants are the `rustfs` crate features in `rustfs/Cargo.toml`: `default`, `full`, and `rio-v2` (which enables `rustfs-ecstore/rio-v2` and pulls in `crates/rio-v2`). `rio-v2` is absent from both `default` and `full`.
|
||||
Build variants are the `rustfs` crate features in `rustfs/Cargo.toml`: `default`, `full`, and `rio-v2` (which enables `rustfs-ecstore/rio-v2` and `rustfs-sse/rio-v2`, and pulls in `crates/rio-v2`). `rio-v2` is absent from both `default` and `full`.
|
||||
|
||||
| MinIO artifact | `default` / `full` build | `rio-v2` build | Notes |
|
||||
|---|:--:|:--:|---|
|
||||
@@ -81,7 +81,7 @@ The `xl.meta` around a MinIO SSE object parses in every build, so such objects l
|
||||
|
||||
### Seams
|
||||
|
||||
The cryptography (DARE v2 stream format, object-key derivation, sealing) was never the gap. Three metadata seams above it rejected MinIO objects; all are closed in `rio-v2` builds. Symbols are in `rustfs/src/storage/sse.rs` unless noted.
|
||||
The cryptography (DARE v2 stream format, object-key derivation, sealing) was never the gap. Three metadata seams above it rejected MinIO objects; all are closed in `rio-v2` builds. Symbols are under `crates/sse/src/core/` unless noted.
|
||||
|
||||
| Seam | Resolution |
|
||||
|---|---|
|
||||
@@ -113,10 +113,10 @@ Inventory the source first: bucket default encryption means objects can be encry
|
||||
| Fact | Value |
|
||||
|---|---|
|
||||
| Shipping status | Ships in no default build: absent from `default` and `full` in `rustfs/Cargo.toml`; released binaries and container images never include it. Enable with `--features rio-v2`. |
|
||||
| Pull-request coverage | `test-and-lint-rio-v2` in `.github/workflows/ci.yml`: clippy plus `cargo nextest` for `rustfs` and `rustfs-ecstore` with `--features rio-v2`. This is the cfg-seam guard; it keeps the feature compiling and its unit suite green on every pull request. |
|
||||
| Pull-request coverage | `test-and-lint-rio-v2` in `.github/workflows/ci.yml`: clippy plus `cargo nextest` for `rustfs`, `rustfs-ecstore`, and `rustfs-sse` with `--features rio-v2`. This is the cfg-seam guard; it keeps the feature compiling and its unit suite green on every pull request. |
|
||||
| Full-suite lane | `build-rustfs-debug-binary-rio-v2` and `e2e-tests-rio-v2` in `ci.yml` run only on the nightly schedule and manual dispatch (`cache-warm.yml` keeps the `ci-feat-rio` cache warm so the scheduled build fits its timeout). |
|
||||
| Interop evidence | `.github/workflows/minio-interop.yml` (nightly plus manual) regenerates real MinIO backend trees via `crates/rio-v2/tests/minio_fixture_lab/` and runs the `#[ignore]` reader tests in `rustfs/src/storage/minio_generated_read_test.rs` with `--features rio-v2`. Its freshness is tracked in `.github/scheduled-validations.json`. |
|
||||
| Promote-or-delete condition | The variant stays dormant until one of two things happens. **Promote**: a release commits to shipping MinIO SSE migration as a supported capability; then `rio-v2` joins `default`/`full`, the scheduled lanes run on every pull request, and this section is rewritten. **Delete**: no release commits to it and the scheduled lanes are not kept green; then the feature flag, `crates/rio-v2`, the cfg seams in `rustfs/src/storage/sse.rs`, the three `ci.yml` jobs, the `cache-warm.yml` warm step, `minio-interop.yml`, and its `scheduled-validations.json` entry are removed in one change. Either outcome must update `ARCHITECTURE.md` and the `ci.yml` job comments that cite this section. |
|
||||
| Promote-or-delete condition | The variant stays dormant until one of two things happens. **Promote**: a release commits to shipping MinIO SSE migration as a supported capability; then `rio-v2` joins `default`/`full`, the scheduled lanes run on every pull request, and this section is rewritten. **Delete**: no release commits to it and the scheduled lanes are not kept green; then the feature flag, `crates/rio-v2`, the cfg seams under `crates/sse/src/`, the three `ci.yml` jobs, the `cache-warm.yml` warm step, `minio-interop.yml`, and its `scheduled-validations.json` entry are removed in one change. Either outcome must update `ARCHITECTURE.md` and the `ci.yml` job comments that cite this section. |
|
||||
|
||||
## Fixture Evidence
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
# AWS KMS backend: setup, verification, and operations
|
||||
|
||||
**Use this when:** connecting RustFS to AWS KMS for the first time, verifying an existing AWS-backed deployment, upgrading one from 1.0.4 or 1.0.5, or deciding how to run and protect the AWS keys RustFS depends on.
|
||||
**Source of truth:** `crates/kms/src/backends/aws.rs` (backend behavior and its deviations), `crates/kms/src/config.rs` (`ENV_KMS_AWS_*`), `crates/kms/src/policy.rs` (retry, deadline and circuit breaker), `rustfs/src/storage/sse.rs` (SSE data path). 中文版: [kms-aws-backend-guide.zh-CN.md](kms-aws-backend-guide.zh-CN.md).
|
||||
**Source of truth:** `crates/kms/src/backends/aws.rs` (backend behavior and its deviations), `crates/kms/src/config.rs` (`ENV_KMS_AWS_*`), `crates/kms/src/policy.rs` (retry, deadline and circuit breaker), `crates/sse/src/core/` (SSE data path). 中文版: [kms-aws-backend-guide.zh-CN.md](kms-aws-backend-guide.zh-CN.md).
|
||||
|
||||
The statements about behavior on this page were observed against the real AWS KMS service (region `eu-north-1`) and, for failures AWS cannot be asked to produce on demand, against a loopback stand-in that speaks the AWS KMS wire protocol. Where a statement is guidance that was not exercised, it says so. For the contract-level differences between AWS and the other backends, see [KMS backend security properties](kms-backend-security.md#aws-kms-deviations-from-the-shared-backend-contract).
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
# AWS KMS 后端:接入、验证与运维
|
||||
|
||||
**适用场景:** 首次把 RustFS 接入 AWS KMS、验证已有的 AWS 后端部署、从 1.0.4 或 1.0.5 升级,或者规划如何运维并保护 RustFS 所依赖的 AWS 密钥。
|
||||
**事实来源:** `crates/kms/src/backends/aws.rs`(后端行为及其差异)、`crates/kms/src/config.rs`(`ENV_KMS_AWS_*`)、`crates/kms/src/policy.rs`(重试、超时与熔断)、`rustfs/src/storage/sse.rs`(SSE 数据面)。English: [kms-aws-backend-guide.md](kms-aws-backend-guide.md)。
|
||||
**事实来源:** `crates/kms/src/backends/aws.rs`(后端行为及其差异)、`crates/kms/src/config.rs`(`ENV_KMS_AWS_*`)、`crates/kms/src/policy.rs`(重试、超时与熔断)、`crates/sse/src/core/`(SSE 数据面)。English: [kms-aws-backend-guide.md](kms-aws-backend-guide.md)。
|
||||
|
||||
本页关于行为的描述,均来自对真实 AWS KMS 服务(区域 `eu-north-1`)的实测;对于无法让 AWS 按需产生的故障,则使用一个实现了 AWS KMS 线上协议的本机替身来实测。属于未经实测的建议之处,文中会明确标注。AWS 与其它后端在契约层面的差异,见 [KMS backend security properties](kms-backend-security.md#aws-kms-deviations-from-the-shared-backend-contract)。
|
||||
|
||||
|
||||
+3
-1
@@ -80,7 +80,7 @@ e2e-test-hooks = ["rustfs-ecstore/e2e-test-hooks", "rustfs-scanner/e2e-test-hook
|
||||
connect-e2e-short-credentials = []
|
||||
# Builds the dedicated rustfs-cli-e2e target with a build-time public enrollment root.
|
||||
offline-enrollment-e2e-root = []
|
||||
rio-v2 = ["rustfs-ecstore/rio-v2"]
|
||||
rio-v2 = ["rustfs-ecstore/rio-v2", "rustfs-sse/rio-v2"]
|
||||
# Linux-only cuObject S3-over-RDMA GET into client (GPU) memory; needs libcuobjserver.
|
||||
cuobject = ["dep:rustfs-cuobject", "rustfs-cuobject/server"]
|
||||
# NIXL/UCX transport for S3-over-RDMA; replaces cuobject when both are enabled.
|
||||
@@ -281,6 +281,7 @@ rustfs-rio = { workspace = true }
|
||||
rustfs-s3-client = { workspace = true }
|
||||
rustfs-s3-types = { workspace = true, features = ["compat-s3s"] }
|
||||
rustfs-s3-ops = { workspace = true }
|
||||
rustfs-sse = { workspace = true }
|
||||
rustfs-security-governance = { workspace = true }
|
||||
rustfs-data-usage = { workspace = true }
|
||||
rustfs-s3select-api = { workspace = true }
|
||||
@@ -424,6 +425,7 @@ h2.workspace = true
|
||||
rustfs-targets = { workspace = true, features = ["test-support"] }
|
||||
uuid = { workspace = true, features = ["v4", "v5", "fast-rng", "macro-diagnostics"] }
|
||||
rustfs-iam = { workspace = true, features = ["test-util"] }
|
||||
rustfs-sse = { workspace = true, features = ["test-util"] }
|
||||
serial_test = { workspace = true }
|
||||
tempfile = { workspace = true }
|
||||
aws-config = { workspace = true }
|
||||
|
||||
+23
-24
@@ -1021,31 +1021,30 @@ impl<T> S3Router<T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Dispatches one legacy admin request. Callers keep their assertions and do not name s3s.
|
||||
/// Free function (not an inherent impl) so the `OwnedOperation` bound stays `pub(crate)`.
|
||||
#[cfg(test)]
|
||||
impl<T: OwnedOperation> S3Router<T> {
|
||||
/// Dispatches one legacy admin request. Callers keep their assertions and do not name s3s.
|
||||
pub(crate) async fn call_legacy(
|
||||
&self,
|
||||
method: Method,
|
||||
uri: &str,
|
||||
extensions: http::Extensions,
|
||||
) -> s3s::S3Result<S3Response<Body>> {
|
||||
S3Route::call(
|
||||
self,
|
||||
S3Request {
|
||||
input: Body::empty(),
|
||||
method,
|
||||
uri: uri.parse().expect("test URI"),
|
||||
headers: HeaderMap::new(),
|
||||
extensions,
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
trailing_headers: None,
|
||||
},
|
||||
)
|
||||
.await
|
||||
}
|
||||
pub(crate) async fn call_legacy<T: OwnedOperation>(
|
||||
router: &S3Router<T>,
|
||||
method: Method,
|
||||
uri: &str,
|
||||
extensions: http::Extensions,
|
||||
) -> s3s::S3Result<S3Response<Body>> {
|
||||
S3Route::call(
|
||||
router,
|
||||
S3Request {
|
||||
input: Body::empty(),
|
||||
method,
|
||||
uri: uri.parse().expect("test URI"),
|
||||
headers: HeaderMap::new(),
|
||||
extensions,
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
trailing_headers: None,
|
||||
},
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
impl<T> Default for S3Router<T> {
|
||||
|
||||
@@ -141,7 +141,7 @@ mod tests {
|
||||
object_store_from_envelope, publish_test_app_context,
|
||||
};
|
||||
use crate::admin::operation::{AdminRequest, AdminResponse, Operation};
|
||||
use crate::admin::router::S3Router;
|
||||
use crate::admin::router::{S3Router, call_legacy};
|
||||
use crate::app::{RequestEnvelope, RequestHead};
|
||||
use hyper::{Method, StatusCode};
|
||||
use matchit::Params;
|
||||
@@ -323,15 +323,13 @@ mod tests {
|
||||
.insert(Method::GET, "/context-probe", ContextDependentAdminRoute)
|
||||
.expect("register test route");
|
||||
|
||||
let err = router
|
||||
.call_legacy(Method::GET, "/context-probe", http::Extensions::new())
|
||||
let err = call_legacy(&router, Method::GET, "/context-probe", http::Extensions::new())
|
||||
.await
|
||||
.expect_err("empty slot must fail closed");
|
||||
assert_eq!(err.code(), &S3ErrorCode::ServiceUnavailable.into());
|
||||
|
||||
assert!(slot.install(distinct_context(&ambient)));
|
||||
let response = router
|
||||
.call_legacy(Method::GET, "/context-probe", http::Extensions::new())
|
||||
let response = call_legacy(&router, Method::GET, "/context-probe", http::Extensions::new())
|
||||
.await
|
||||
.expect("installed slot must serve request");
|
||||
assert_eq!(response.status, Some(StatusCode::NO_CONTENT));
|
||||
|
||||
@@ -1320,23 +1320,22 @@ mod tests {
|
||||
};
|
||||
for (index, expected_key) in ["a&local", "z-local"].into_iter().enumerate() {
|
||||
let request_marker = input.marker.clone().unwrap_or_default();
|
||||
let list_req = S3Request {
|
||||
input: input.clone(),
|
||||
method: http::Method::GET,
|
||||
uri: http::Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
extensions: http::Extensions::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
trailing_headers: None,
|
||||
};
|
||||
let envelope = crate::app::RequestEnvelope::from_s3s(&list_req);
|
||||
let gateway_input =
|
||||
rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::list_objects::input_from_s3s(
|
||||
list_req.input,
|
||||
input.clone(),
|
||||
)
|
||||
.expect("convert ListObjectsInput");
|
||||
let envelope = crate::app::RequestEnvelope::from_parts(
|
||||
crate::app::RequestHead {
|
||||
method: http::Method::GET,
|
||||
uri: http::Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
http::Extensions::new(),
|
||||
);
|
||||
let gateway_output = tokio::time::timeout(
|
||||
Duration::from_secs(10),
|
||||
DefaultBucketUsecase::from_global().execute_list_objects(envelope, gateway_input),
|
||||
|
||||
@@ -509,7 +509,7 @@ impl DefaultBucketUsecase {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info};
|
||||
use crate::app::bucket_usecase::test_support::{build_request_with_req_info, owned_envelope};
|
||||
use crate::app::storage_api::s3::dto::CreateBucketInput;
|
||||
use http::Method;
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
|
||||
@@ -1005,11 +1005,10 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_list_buckets_returns_internal_error_when_store_uninitialized() {
|
||||
let req = build_request((), Method::GET);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
|
||||
let err = usecase
|
||||
.execute_list_buckets(RequestEnvelope::from_s3s(&req), gateway_dto::ListBucketsInput::default())
|
||||
.execute_list_buckets(owned_envelope(Method::GET), gateway_dto::ListBucketsInput::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), &rustfs_s3_types::S3ErrorCode::InternalError);
|
||||
|
||||
@@ -366,7 +366,7 @@ impl DefaultBucketUsecase {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info, s3_op_total};
|
||||
use crate::app::bucket_usecase::test_support::{build_request_with_req_info, owned_envelope, s3_op_total};
|
||||
use http::Method;
|
||||
|
||||
#[test]
|
||||
@@ -399,11 +399,10 @@ mod tests {
|
||||
|
||||
/// The envelope of a request whose access phase installed `req_info`, or none.
|
||||
fn envelope(req_info: Option<ReqInfo>) -> RequestEnvelope {
|
||||
let req = match req_info {
|
||||
Some(req_info) => build_request_with_req_info((), Method::PUT, req_info),
|
||||
None => build_request((), Method::PUT),
|
||||
};
|
||||
RequestEnvelope::from_s3s(&req)
|
||||
match req_info {
|
||||
Some(req_info) => RequestEnvelope::from_s3s(&build_request_with_req_info((), Method::PUT, req_info)),
|
||||
None => owned_envelope(Method::PUT),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -203,7 +203,7 @@ impl DefaultBucketUsecase {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::owned_envelope;
|
||||
use crate::app::storage_api::s3::dto::{self, PutBucketEncryptionInput, ServerSideEncryption};
|
||||
use http::Method;
|
||||
use rustfs_gateway_types::persistence::{
|
||||
@@ -292,20 +292,19 @@ mod tests {
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let req = build_request(input, Method::PUT);
|
||||
let prepared = crate::storage::persisted_from_s3s(&req.input.server_side_encryption_configuration);
|
||||
let prepared = crate::storage::persisted_from_s3s(&input.server_side_encryption_configuration);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
|
||||
let err = usecase
|
||||
.execute_put_bucket_encryption(RequestEnvelope::from_s3s(&req), &req.input.bucket, prepared.map_err(Into::into))
|
||||
.execute_put_bucket_encryption(owned_envelope(Method::PUT), &input.bucket, prepared.map_err(Into::into))
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), &S3ErrorCode::InternalError);
|
||||
|
||||
let err = usecase
|
||||
.execute_put_bucket_encryption(
|
||||
RequestEnvelope::from_s3s(&req),
|
||||
&req.input.bucket,
|
||||
owned_envelope(Method::PUT),
|
||||
&input.bucket,
|
||||
Ok(PersistedBucketEncryptionConfiguration { rules: vec![] }),
|
||||
)
|
||||
.await
|
||||
|
||||
@@ -405,7 +405,7 @@ mod tests {
|
||||
// waiter again on the single-thread test runtime.
|
||||
assert_eq!(admission.available_permits(), 1);
|
||||
}
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, owned_envelope};
|
||||
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
|
||||
use crate::app::runtime_sources::ServerContextSlot;
|
||||
use crate::app::storage_api::bucket_usecase::helper::MutationCompletionProbe;
|
||||
@@ -775,13 +775,12 @@ mod tests {
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let req = build_request(input, Method::PUT);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
|
||||
let err = usecase
|
||||
.execute_put_bucket_lifecycle_configuration(
|
||||
RequestEnvelope::from_s3s(&req),
|
||||
&req.input.bucket,
|
||||
owned_envelope(Method::PUT),
|
||||
&input.bucket,
|
||||
PreparedLifecycleConfiguration::Missing,
|
||||
)
|
||||
.await
|
||||
|
||||
@@ -159,7 +159,7 @@ fn list_object_versions_output(
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::owned_envelope;
|
||||
use rustfs_gateway_types::BucketName;
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
|
||||
@@ -319,7 +319,7 @@ mod tests {
|
||||
};
|
||||
|
||||
let err = DefaultBucketUsecase::without_context()
|
||||
.execute_list_object_versions(RequestEnvelope::from_s3s(&build_request((), http::Method::GET)), input)
|
||||
.execute_list_object_versions(owned_envelope(http::Method::GET), input)
|
||||
.await
|
||||
.expect_err("a negative page size");
|
||||
assert_eq!(err.code(), &S3ErrorCode::InvalidArgument);
|
||||
@@ -333,7 +333,7 @@ mod tests {
|
||||
};
|
||||
|
||||
let err = DefaultBucketUsecase::without_context()
|
||||
.execute_list_object_versions(RequestEnvelope::from_s3s(&build_request((), http::Method::GET)), input)
|
||||
.execute_list_object_versions(owned_envelope(http::Method::GET), input)
|
||||
.await
|
||||
.expect_err("no store");
|
||||
assert_eq!(err.code(), &S3ErrorCode::InternalError);
|
||||
|
||||
@@ -372,13 +372,12 @@ fn list_objects_next_marker(info: &ListObjectsV2Info, cursor: Option<&str>) -> O
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::owned_envelope;
|
||||
use rustfs_gateway_types::BucketName;
|
||||
|
||||
#[test]
|
||||
#[serial_test::serial]
|
||||
fn list_apis_report_storage_read_quorum_as_unavailable() {
|
||||
use crate::app::bucket_usecase::test_support::owned_envelope;
|
||||
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient, shared_gating_ecstore};
|
||||
run_large_stack_test("list-quorum-surface", || async {
|
||||
let usecase = DefaultBucketUsecase::with_context(Some(shared_gating_ambient().await));
|
||||
@@ -485,7 +484,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn envelope() -> RequestEnvelope {
|
||||
RequestEnvelope::from_s3s(&build_request((), http::Method::GET))
|
||||
owned_envelope(http::Method::GET)
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -56,7 +56,7 @@ impl DefaultBucketUsecase {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, owned_envelope};
|
||||
use crate::app::bucket_usecase::{BucketOperations, DeleteBucketOptions, MakeBucketOptions};
|
||||
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
|
||||
use crate::app::runtime_sources::ServerContextSlot;
|
||||
@@ -75,10 +75,8 @@ mod tests {
|
||||
let context = shared_gating_ambient().await;
|
||||
let bucket = format!("logging-missing-{}", uuid::Uuid::new_v4().simple());
|
||||
let usecase = DefaultBucketUsecase::with_context(Some(context));
|
||||
let request = build_request((), Method::PUT);
|
||||
let envelope = RequestEnvelope::from_s3s(&request);
|
||||
let error = usecase
|
||||
.execute_put_bucket_logging(envelope, &bucket, || {
|
||||
.execute_put_bucket_logging(owned_envelope(Method::PUT), &bucket, || {
|
||||
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid logging configuration"))
|
||||
})
|
||||
.await
|
||||
|
||||
@@ -243,16 +243,15 @@ impl DefaultBucketUsecase {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::owned_envelope;
|
||||
use http::Method;
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_delete_bucket_policy_returns_internal_error_when_store_uninitialized() {
|
||||
let req = build_request((), Method::DELETE);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
|
||||
let err = usecase
|
||||
.execute_delete_bucket_policy(RequestEnvelope::from_s3s(&req), "test-bucket")
|
||||
.execute_delete_bucket_policy(owned_envelope(Method::DELETE), "test-bucket")
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), &rustfs_s3_types::S3ErrorCode::InternalError);
|
||||
@@ -280,11 +279,10 @@ mod tests {
|
||||
bucket: bucket("test-bucket"),
|
||||
..Default::default()
|
||||
};
|
||||
let req = build_request((), Method::GET);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
|
||||
let err = usecase
|
||||
.execute_get_bucket_policy_status(RequestEnvelope::from_s3s(&req), input)
|
||||
.execute_get_bucket_policy_status(owned_envelope(Method::GET), input)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), &rustfs_s3_types::S3ErrorCode::InternalError);
|
||||
@@ -292,11 +290,10 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_put_bucket_policy_returns_internal_error_when_store_uninitialized() {
|
||||
let req = build_request((), Method::PUT);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
|
||||
let err = usecase
|
||||
.execute_put_bucket_policy(RequestEnvelope::from_s3s(&req), "test-bucket", "{}")
|
||||
.execute_put_bucket_policy(owned_envelope(Method::PUT), "test-bucket", "{}")
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), &rustfs_s3_types::S3ErrorCode::InternalError);
|
||||
|
||||
@@ -112,7 +112,7 @@ impl DefaultBucketUsecase {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, owned_envelope};
|
||||
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
|
||||
use crate::app::runtime_sources::ServerContextSlot;
|
||||
use crate::app::storage_api::bucket_usecase::helper::MutationCompletionProbe;
|
||||
@@ -278,7 +278,7 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_delete_public_access_block_returns_internal_error_when_store_uninitialized() {
|
||||
let envelope = RequestEnvelope::from_s3s(&build_request((), Method::DELETE));
|
||||
let envelope = owned_envelope(Method::DELETE);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
let err = usecase
|
||||
.execute_delete_public_access_block(envelope, "test-bucket")
|
||||
@@ -296,7 +296,7 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_put_public_access_block_returns_internal_error_when_store_uninitialized() {
|
||||
let envelope = RequestEnvelope::from_s3s(&build_request((), Method::PUT));
|
||||
let envelope = owned_envelope(Method::PUT);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
let err = usecase
|
||||
.execute_put_public_access_block(envelope, "test-bucket", Ok(PersistedPublicAccessBlockConfiguration::default()))
|
||||
|
||||
@@ -138,7 +138,7 @@ impl DefaultBucketUsecase {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, owned_envelope};
|
||||
use crate::app::storage_api::s3::dto::{self, PutBucketTaggingInput, Tag, Tagging};
|
||||
use http::Method;
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
@@ -249,11 +249,10 @@ mod tests {
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let req = build_request(input, Method::PUT);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
|
||||
let err = usecase
|
||||
.execute_put_bucket_tagging(RequestEnvelope::from_s3s(&req), &req.input.bucket, PersistedTagging::default())
|
||||
.execute_put_bucket_tagging(owned_envelope(Method::PUT), &input.bucket, PersistedTagging::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), &S3ErrorCode::InternalError);
|
||||
@@ -267,7 +266,7 @@ mod tests {
|
||||
(vec![tag; MAX_BUCKET_TAGS + 1], "Cannot have more than 50 tags per bucket"),
|
||||
] {
|
||||
let err = usecase
|
||||
.execute_put_bucket_tagging(RequestEnvelope::from_s3s(&req), &req.input.bucket, PersistedTagging { tag_set })
|
||||
.execute_put_bucket_tagging(owned_envelope(Method::PUT), &input.bucket, PersistedTagging { tag_set })
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), &S3ErrorCode::InvalidTag);
|
||||
|
||||
@@ -47,7 +47,17 @@ pub(super) fn gateway_bucket(name: &str) -> rustfs_gateway_types::BucketName {
|
||||
|
||||
/// The envelope of a request that carries nothing but `method`.
|
||||
pub(super) fn owned_envelope(method: Method) -> RequestEnvelope {
|
||||
RequestEnvelope::from_s3s(&build_request((), method))
|
||||
RequestEnvelope::from_parts(
|
||||
crate::app::RequestHead {
|
||||
method,
|
||||
uri: Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
Extensions::new(),
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn build_request_with_req_info<T>(input: T, method: Method, req_info: ReqInfo) -> S3Request<T> {
|
||||
|
||||
@@ -81,7 +81,7 @@ impl DefaultBucketUsecase {
|
||||
mod tests {
|
||||
use super::super::{BUCKET_ACCELERATE_CONFIG, BUCKET_REQUEST_PAYMENT_CONFIG};
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info};
|
||||
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info, owned_envelope};
|
||||
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
|
||||
use crate::app::runtime_sources::ServerContextSlot;
|
||||
use crate::app::storage_api::object_usecase::helper::MutationCompletionProbe;
|
||||
@@ -190,22 +190,21 @@ mod tests {
|
||||
let ambient = shared_gating_ambient().await;
|
||||
let usecase = DefaultBucketUsecase::with_context(Some(ambient));
|
||||
let bucket = format!("core-config-missing-{}", uuid::Uuid::new_v4().simple());
|
||||
let request = build_request((), http::Method::PUT);
|
||||
let mut converted = [false; 3];
|
||||
let accelerate = usecase
|
||||
.execute_put_bucket_accelerate_configuration(RequestEnvelope::from_s3s(&request), &bucket, || {
|
||||
.execute_put_bucket_accelerate_configuration(owned_envelope(http::Method::PUT), &bucket, || {
|
||||
converted[0] = true;
|
||||
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid acceleration"))
|
||||
})
|
||||
.await;
|
||||
let payment = usecase
|
||||
.execute_put_bucket_request_payment(RequestEnvelope::from_s3s(&request), &bucket, || {
|
||||
.execute_put_bucket_request_payment(owned_envelope(http::Method::PUT), &bucket, || {
|
||||
converted[1] = true;
|
||||
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid request payment"))
|
||||
})
|
||||
.await;
|
||||
let website = usecase
|
||||
.execute_put_bucket_website(RequestEnvelope::from_s3s(&request), &bucket, || {
|
||||
.execute_put_bucket_website(owned_envelope(http::Method::PUT), &bucket, || {
|
||||
converted[2] = true;
|
||||
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid website"))
|
||||
})
|
||||
|
||||
@@ -52,8 +52,19 @@ async fn object_lock_handlers_schedule_replication() {
|
||||
.expect("Failed to create object-lock bucket");
|
||||
upload_test_object(&ecstore, bucket.as_str(), object, b"worm payload").await;
|
||||
|
||||
let req = build_request((), Method::PUT);
|
||||
let envelope = || RequestEnvelope::from_s3s(&req);
|
||||
let envelope = || {
|
||||
RequestEnvelope::from_parts(
|
||||
crate::app::RequestHead {
|
||||
method: Method::PUT,
|
||||
uri: Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
Extensions::new(),
|
||||
)
|
||||
};
|
||||
|
||||
// A bucket without a replication configuration can skip the decision.
|
||||
MUST_REPLICATE_OBJECT_CALLS.store(0, Ordering::SeqCst);
|
||||
|
||||
@@ -22,7 +22,17 @@ const RESTORE_SUSPENDED_WAIT_TIMEOUT: Duration = Duration::from_secs(15);
|
||||
async fn suspend_test_bucket(bucket: &str) {
|
||||
DefaultBucketUsecase::from_global()
|
||||
.execute_put_bucket_versioning(
|
||||
crate::app::RequestEnvelope::from_s3s(&build_request((), Method::PUT)),
|
||||
crate::app::RequestEnvelope::from_parts(
|
||||
crate::app::RequestHead {
|
||||
method: Method::PUT,
|
||||
uri: Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
Extensions::new(),
|
||||
),
|
||||
bucket,
|
||||
Ok(rustfs_gateway_types::persistence::PersistedVersioningConfiguration {
|
||||
status: Some("Suspended".to_owned()),
|
||||
|
||||
@@ -62,7 +62,7 @@ use super::storage_api::multipart_usecase::s3_api::multipart::{
|
||||
};
|
||||
use super::storage_api::multipart_usecase::set_disk::is_valid_storage_class;
|
||||
use super::storage_api::multipart_usecase::sse::{
|
||||
DecryptionRequest, EncryptionKeyKind, EncryptionRequest, PrepareEncryptionRequest, SseKmsPrincipal,
|
||||
DecryptionRequest, EncryptionKeyKind, EncryptionRequest, PrepareEncryptionRequest, SseKmsPrincipal, SseKmsPrincipalExt,
|
||||
apply_bucket_default_lock_retention, authorize_sse_kms_multipart_write, authorize_sse_kms_object_read,
|
||||
build_ssec_read_headers, encryption_material_to_metadata, extract_server_side_encryption_from_headers,
|
||||
extract_ssec_params_from_headers, extract_ssekms_context_from_headers, get_buffer_size_opt_in,
|
||||
@@ -545,10 +545,17 @@ mod tests {
|
||||
.key(key.to_owned())
|
||||
.build()
|
||||
.expect("valid create request DTO");
|
||||
let error = make_usecase()
|
||||
.execute_create_multipart_upload_from_s3s(build_request(create, Method::POST))
|
||||
let error = match make_usecase()
|
||||
.execute_create_multipart_upload(
|
||||
owned_envelope(Method::POST),
|
||||
super::create_values::CreateMultipartUploadFields::from_legacy(create),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.expect_err("reserved key must be rejected before accessing storage");
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("reserved key must be rejected before accessing storage"),
|
||||
};
|
||||
assert_eq!(error.code(), &crate::app::storage_api::s3::S3ErrorCode::InvalidArgument);
|
||||
|
||||
let complete = CompleteMultipartUploadInput::builder()
|
||||
@@ -558,9 +565,15 @@ mod tests {
|
||||
.multipart_upload(Some(CompletedMultipartUpload::default()))
|
||||
.build()
|
||||
.expect("valid complete request DTO");
|
||||
let error = Box::pin(make_usecase().complete_for_s3s_request(build_request(complete, Method::POST)))
|
||||
.await
|
||||
.expect_err("uploads created before the fix must not publish reserved keys");
|
||||
let error =
|
||||
match rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload::input_from_s3s(
|
||||
complete,
|
||||
) {
|
||||
Err(error) => crate::app::dto_values::seam_error(error),
|
||||
Ok(input) => Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), input))
|
||||
.await
|
||||
.expect_err("uploads created before the fix must not publish reserved keys"),
|
||||
};
|
||||
assert_eq!(error.code(), &rustfs_s3_types::S3ErrorCode::InvalidArgument);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -24,8 +24,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_abort_multipart_upload_returns_internal_error_when_store_uninitialized() {
|
||||
let request = build_request((), Method::DELETE);
|
||||
let envelope = RequestEnvelope::from_s3s(&request);
|
||||
let envelope = owned_envelope(Method::DELETE);
|
||||
let before = s3_op_total(S3Operation::AbortMultipartUpload);
|
||||
let target = AbortMultipartUploadTarget::Legacy {
|
||||
bucket: "bucket".to_owned(),
|
||||
|
||||
@@ -943,21 +943,72 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_complete_multipart_upload_rejects_missing_parts_payload() {
|
||||
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
|
||||
|
||||
let input = CompleteMultipartUploadInput::builder()
|
||||
.bucket("bucket".to_string())
|
||||
.key("object".to_string())
|
||||
.upload_id("upload-id".to_string())
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::POST);
|
||||
|
||||
let err = Box::pin(make_usecase().complete_for_s3s_request(req)).await.unwrap_err();
|
||||
let mut s3s_input = input;
|
||||
let has_upload = s3s_input.multipart_upload.is_some();
|
||||
s3s_input.multipart_upload.get_or_insert_with(Default::default);
|
||||
let tags: Vec<Option<String>> = s3s_input
|
||||
.multipart_upload
|
||||
.iter_mut()
|
||||
.flat_map(|upload| upload.parts.iter_mut().flatten())
|
||||
.map(|part| {
|
||||
part.part_number.get_or_insert(0);
|
||||
part.e_tag.take().map(|tag| tag.value().to_owned())
|
||||
})
|
||||
.collect();
|
||||
for checksum in [
|
||||
&mut s3s_input.checksum_crc32,
|
||||
&mut s3s_input.checksum_crc32c,
|
||||
&mut s3s_input.checksum_crc64nvme,
|
||||
&mut s3s_input.checksum_md5,
|
||||
&mut s3s_input.checksum_sha1,
|
||||
&mut s3s_input.checksum_sha256,
|
||||
&mut s3s_input.checksum_sha512,
|
||||
&mut s3s_input.checksum_xxhash128,
|
||||
&mut s3s_input.checksum_xxhash3,
|
||||
&mut s3s_input.checksum_xxhash64,
|
||||
] {
|
||||
*checksum = None;
|
||||
}
|
||||
let err = match complete_multipart_upload::input_from_s3s(s3s_input) {
|
||||
Err(error) => crate::app::dto_values::seam_error(error),
|
||||
Ok(mut owned) => {
|
||||
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
|
||||
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
|
||||
}
|
||||
let taken = std::mem::take(&mut owned.multipart_upload);
|
||||
let parts = has_upload.then_some(taken);
|
||||
let result = match parts {
|
||||
Some(parts) => {
|
||||
owned.multipart_upload = parts;
|
||||
Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
|
||||
}
|
||||
None => {
|
||||
Box::pin(make_usecase().execute_complete_multipart_upload_parts(
|
||||
owned_envelope(Method::POST),
|
||||
owned,
|
||||
None,
|
||||
))
|
||||
.await
|
||||
}
|
||||
};
|
||||
result.unwrap_err()
|
||||
}
|
||||
};
|
||||
assert_eq!(err.code(), &S3ErrorCode::InvalidPart);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_complete_multipart_upload_rejects_missing_parts_list() {
|
||||
use crate::app::storage_api::s3::xml::Deserialize as _;
|
||||
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
|
||||
|
||||
let mut deserializer = crate::app::storage_api::s3::xml::Deserializer::new(b"<CompleteMultipartUpload/>");
|
||||
let multipart_upload =
|
||||
@@ -974,17 +1025,65 @@ mod tests {
|
||||
.multipart_upload(Some(multipart_upload))
|
||||
.build()
|
||||
.expect("complete multipart input should build");
|
||||
let req = build_request(input, Method::POST);
|
||||
|
||||
let err = Box::pin(make_usecase().complete_for_s3s_request(req))
|
||||
.await
|
||||
.expect_err("missing parts list must be rejected");
|
||||
let mut s3s_input = input;
|
||||
let has_upload = s3s_input.multipart_upload.is_some();
|
||||
s3s_input.multipart_upload.get_or_insert_with(Default::default);
|
||||
let tags: Vec<Option<String>> = s3s_input
|
||||
.multipart_upload
|
||||
.iter_mut()
|
||||
.flat_map(|upload| upload.parts.iter_mut().flatten())
|
||||
.map(|part| {
|
||||
part.part_number.get_or_insert(0);
|
||||
part.e_tag.take().map(|tag| tag.value().to_owned())
|
||||
})
|
||||
.collect();
|
||||
for checksum in [
|
||||
&mut s3s_input.checksum_crc32,
|
||||
&mut s3s_input.checksum_crc32c,
|
||||
&mut s3s_input.checksum_crc64nvme,
|
||||
&mut s3s_input.checksum_md5,
|
||||
&mut s3s_input.checksum_sha1,
|
||||
&mut s3s_input.checksum_sha256,
|
||||
&mut s3s_input.checksum_sha512,
|
||||
&mut s3s_input.checksum_xxhash128,
|
||||
&mut s3s_input.checksum_xxhash3,
|
||||
&mut s3s_input.checksum_xxhash64,
|
||||
] {
|
||||
*checksum = None;
|
||||
}
|
||||
let err = match complete_multipart_upload::input_from_s3s(s3s_input) {
|
||||
Err(error) => crate::app::dto_values::seam_error(error),
|
||||
Ok(mut owned) => {
|
||||
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
|
||||
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
|
||||
}
|
||||
let taken = std::mem::take(&mut owned.multipart_upload);
|
||||
let parts = has_upload.then_some(taken);
|
||||
let result = match parts {
|
||||
Some(parts) => {
|
||||
owned.multipart_upload = parts;
|
||||
Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
|
||||
}
|
||||
None => {
|
||||
Box::pin(make_usecase().execute_complete_multipart_upload_parts(
|
||||
owned_envelope(Method::POST),
|
||||
owned,
|
||||
None,
|
||||
))
|
||||
.await
|
||||
}
|
||||
};
|
||||
result.expect_err("missing parts list must be rejected")
|
||||
}
|
||||
};
|
||||
assert_eq!(err.code(), &S3ErrorCode::InvalidRequest);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[serial_test::serial]
|
||||
async fn compressed_complete_records_logical_quota_usage_and_overwrite_delta() {
|
||||
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
|
||||
|
||||
let (store, bucket) = crate::app::gating_test_env::durable_quota_test_bucket("compressed-complete-quota", 16_384).await;
|
||||
let object = "object";
|
||||
|
||||
@@ -1024,10 +1123,53 @@ mod tests {
|
||||
}))
|
||||
.build()
|
||||
.expect("complete multipart input should build");
|
||||
usecase
|
||||
.complete_for_s3s_request(build_request(input, Method::POST))
|
||||
.await
|
||||
.expect("compressed multipart completion should succeed");
|
||||
let mut s3s_input = input;
|
||||
let has_upload = s3s_input.multipart_upload.is_some();
|
||||
s3s_input.multipart_upload.get_or_insert_with(Default::default);
|
||||
let tags: Vec<Option<String>> = s3s_input
|
||||
.multipart_upload
|
||||
.iter_mut()
|
||||
.flat_map(|upload| upload.parts.iter_mut().flatten())
|
||||
.map(|part| {
|
||||
part.part_number.get_or_insert(0);
|
||||
part.e_tag.take().map(|tag| tag.value().to_owned())
|
||||
})
|
||||
.collect();
|
||||
for checksum in [
|
||||
&mut s3s_input.checksum_crc32,
|
||||
&mut s3s_input.checksum_crc32c,
|
||||
&mut s3s_input.checksum_crc64nvme,
|
||||
&mut s3s_input.checksum_md5,
|
||||
&mut s3s_input.checksum_sha1,
|
||||
&mut s3s_input.checksum_sha256,
|
||||
&mut s3s_input.checksum_sha512,
|
||||
&mut s3s_input.checksum_xxhash128,
|
||||
&mut s3s_input.checksum_xxhash3,
|
||||
&mut s3s_input.checksum_xxhash64,
|
||||
] {
|
||||
*checksum = None;
|
||||
}
|
||||
let completed = match complete_multipart_upload::input_from_s3s(s3s_input) {
|
||||
Err(error) => Err(crate::app::dto_values::seam_error(error)),
|
||||
Ok(mut owned) => {
|
||||
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
|
||||
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
|
||||
}
|
||||
let taken = std::mem::take(&mut owned.multipart_upload);
|
||||
let parts = has_upload.then_some(taken);
|
||||
match parts {
|
||||
Some(parts) => {
|
||||
owned.multipart_upload = parts;
|
||||
Box::pin(usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
|
||||
}
|
||||
None => {
|
||||
Box::pin(usecase.execute_complete_multipart_upload_parts(owned_envelope(Method::POST), owned, None))
|
||||
.await
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
completed.expect("compressed multipart completion should succeed");
|
||||
|
||||
let quota = quota_checker
|
||||
.check_quota(&bucket, QuotaOperation::PutObject, 0)
|
||||
@@ -1124,10 +1266,9 @@ mod tests {
|
||||
crate::app::gating_test_env::run_large_stack_test("ssec-completion-checksums", || async {
|
||||
let (_store, bucket) =
|
||||
crate::app::gating_test_env::durable_quota_test_bucket("ssec-completion-checksums", 16_384).await;
|
||||
let versioning_req = build_request((), Method::PUT);
|
||||
crate::app::bucket_usecase::DefaultBucketUsecase::from_global()
|
||||
.execute_put_bucket_versioning(
|
||||
RequestEnvelope::from_s3s(&versioning_req),
|
||||
super::super::test_support::owned_envelope(Method::PUT),
|
||||
&bucket,
|
||||
Ok(rustfs_gateway_types::persistence::PersistedVersioningConfiguration {
|
||||
status: Some("Enabled".to_owned()),
|
||||
@@ -1304,16 +1445,13 @@ mod tests {
|
||||
|
||||
let bucket_usecase = crate::app::bucket_usecase::DefaultBucketUsecase::from_global();
|
||||
// Listings carry neither the SSE-C key nor a per-object decryption request.
|
||||
let versions_req = build_request(
|
||||
ListObjectVersionsInput {
|
||||
bucket: bucket.to_string(),
|
||||
prefix: Some(key.to_string()),
|
||||
..Default::default()
|
||||
},
|
||||
Method::GET,
|
||||
);
|
||||
let versions_env = RequestEnvelope::from_s3s(&versions_req);
|
||||
let versions_in = list_object_versions::input_from_s3s(versions_req.input).expect("convert ListObjectVersionsInput");
|
||||
let versions_input = ListObjectVersionsInput {
|
||||
bucket: bucket.to_string(),
|
||||
prefix: Some(key.to_string()),
|
||||
..Default::default()
|
||||
};
|
||||
let versions_env = super::super::test_support::owned_envelope(Method::GET);
|
||||
let versions_in = list_object_versions::input_from_s3s(versions_input).expect("convert ListObjectVersionsInput");
|
||||
let versions = list_object_versions::output_to_s3s(
|
||||
bucket_usecase
|
||||
.execute_list_object_versions(versions_env, versions_in)
|
||||
@@ -1328,16 +1466,13 @@ mod tests {
|
||||
assert_eq!(entries[0].e_tag.as_ref(), Some(etag));
|
||||
assert_xml_etag(&versions, etag);
|
||||
|
||||
let v1_req = build_request(
|
||||
ListObjectsInput {
|
||||
bucket: bucket.to_string(),
|
||||
prefix: Some(key.to_string()),
|
||||
..Default::default()
|
||||
},
|
||||
Method::GET,
|
||||
);
|
||||
let v1_env = RequestEnvelope::from_s3s(&v1_req);
|
||||
let v1_in = list_objects::input_from_s3s(v1_req.input).expect("convert ListObjectsInput");
|
||||
let v1_input = ListObjectsInput {
|
||||
bucket: bucket.to_string(),
|
||||
prefix: Some(key.to_string()),
|
||||
..Default::default()
|
||||
};
|
||||
let v1_env = super::super::test_support::owned_envelope(Method::GET);
|
||||
let v1_in = list_objects::input_from_s3s(v1_input).expect("convert ListObjectsInput");
|
||||
let v1 = list_objects::output_to_s3s(
|
||||
bucket_usecase
|
||||
.execute_list_objects(v1_env, v1_in)
|
||||
@@ -1411,7 +1546,6 @@ mod tests {
|
||||
.await
|
||||
.expect("create versioned Object Lock bucket");
|
||||
let key = "kms-encrypted";
|
||||
let enc_req = build_request((), Method::PUT);
|
||||
let enc_cfg = crate::app::storage_api::s3::dto::ServerSideEncryptionConfiguration {
|
||||
rules: vec![crate::app::storage_api::s3::dto::ServerSideEncryptionRule {
|
||||
apply_server_side_encryption_by_default: Some(
|
||||
@@ -1425,7 +1559,7 @@ mod tests {
|
||||
};
|
||||
let prepared = crate::storage::persisted_from_s3s(&enc_cfg).map_err(Into::into);
|
||||
crate::app::bucket_usecase::DefaultBucketUsecase::from_global()
|
||||
.execute_put_bucket_encryption(RequestEnvelope::from_s3s(&enc_req), &bucket, prepared)
|
||||
.execute_put_bucket_encryption(super::super::test_support::owned_envelope(Method::PUT), &bucket, prepared)
|
||||
.await
|
||||
.expect("configure bucket-default SSE-KMS");
|
||||
let usecase = DefaultMultipartUsecase::from_global();
|
||||
@@ -2094,10 +2228,55 @@ mod tests {
|
||||
.multipart_upload(Some(CompletedMultipartUpload { parts: Some(Vec::new()) }))
|
||||
.build()
|
||||
.expect("complete multipart input should build");
|
||||
let err = DefaultMultipartUsecase::from_global()
|
||||
.complete_for_s3s_request(build_request(input, Method::POST))
|
||||
.await
|
||||
.expect_err("empty parts list must be rejected");
|
||||
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
|
||||
|
||||
let usecase = DefaultMultipartUsecase::from_global();
|
||||
let mut s3s_input = input;
|
||||
let has_upload = s3s_input.multipart_upload.is_some();
|
||||
s3s_input.multipart_upload.get_or_insert_with(Default::default);
|
||||
let tags: Vec<Option<String>> = s3s_input
|
||||
.multipart_upload
|
||||
.iter_mut()
|
||||
.flat_map(|upload| upload.parts.iter_mut().flatten())
|
||||
.map(|part| {
|
||||
part.part_number.get_or_insert(0);
|
||||
part.e_tag.take().map(|tag| tag.value().to_owned())
|
||||
})
|
||||
.collect();
|
||||
for checksum in [
|
||||
&mut s3s_input.checksum_crc32,
|
||||
&mut s3s_input.checksum_crc32c,
|
||||
&mut s3s_input.checksum_crc64nvme,
|
||||
&mut s3s_input.checksum_md5,
|
||||
&mut s3s_input.checksum_sha1,
|
||||
&mut s3s_input.checksum_sha256,
|
||||
&mut s3s_input.checksum_sha512,
|
||||
&mut s3s_input.checksum_xxhash128,
|
||||
&mut s3s_input.checksum_xxhash3,
|
||||
&mut s3s_input.checksum_xxhash64,
|
||||
] {
|
||||
*checksum = None;
|
||||
}
|
||||
let rejected = match complete_multipart_upload::input_from_s3s(s3s_input) {
|
||||
Err(error) => Err(crate::app::dto_values::seam_error(error)),
|
||||
Ok(mut owned) => {
|
||||
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
|
||||
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
|
||||
}
|
||||
let taken = std::mem::take(&mut owned.multipart_upload);
|
||||
let parts = has_upload.then_some(taken);
|
||||
match parts {
|
||||
Some(parts) => {
|
||||
owned.multipart_upload = parts;
|
||||
Box::pin(usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
|
||||
}
|
||||
None => {
|
||||
Box::pin(usecase.execute_complete_multipart_upload_parts(owned_envelope(Method::POST), owned, None)).await
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
let err = rejected.expect_err("empty parts list must be rejected");
|
||||
assert_eq!(err.code(), &S3ErrorCode::InvalidRequest);
|
||||
|
||||
let current_info = store
|
||||
@@ -2129,10 +2308,53 @@ mod tests {
|
||||
}))
|
||||
.build()
|
||||
.expect("complete multipart input should build");
|
||||
let completed = DefaultMultipartUsecase::from_global()
|
||||
.complete_for_s3s_request(build_request(input, Method::POST))
|
||||
.await
|
||||
.expect("staged part should remain completable after empty request rejection");
|
||||
let usecase = DefaultMultipartUsecase::from_global();
|
||||
let mut s3s_input = input;
|
||||
let has_upload = s3s_input.multipart_upload.is_some();
|
||||
s3s_input.multipart_upload.get_or_insert_with(Default::default);
|
||||
let tags: Vec<Option<String>> = s3s_input
|
||||
.multipart_upload
|
||||
.iter_mut()
|
||||
.flat_map(|upload| upload.parts.iter_mut().flatten())
|
||||
.map(|part| {
|
||||
part.part_number.get_or_insert(0);
|
||||
part.e_tag.take().map(|tag| tag.value().to_owned())
|
||||
})
|
||||
.collect();
|
||||
for checksum in [
|
||||
&mut s3s_input.checksum_crc32,
|
||||
&mut s3s_input.checksum_crc32c,
|
||||
&mut s3s_input.checksum_crc64nvme,
|
||||
&mut s3s_input.checksum_md5,
|
||||
&mut s3s_input.checksum_sha1,
|
||||
&mut s3s_input.checksum_sha256,
|
||||
&mut s3s_input.checksum_sha512,
|
||||
&mut s3s_input.checksum_xxhash128,
|
||||
&mut s3s_input.checksum_xxhash3,
|
||||
&mut s3s_input.checksum_xxhash64,
|
||||
] {
|
||||
*checksum = None;
|
||||
}
|
||||
let completed = match complete_multipart_upload::input_from_s3s(s3s_input) {
|
||||
Err(error) => Err(crate::app::dto_values::seam_error(error)),
|
||||
Ok(mut owned) => {
|
||||
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
|
||||
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
|
||||
}
|
||||
let taken = std::mem::take(&mut owned.multipart_upload);
|
||||
let parts = has_upload.then_some(taken);
|
||||
match parts {
|
||||
Some(parts) => {
|
||||
owned.multipart_upload = parts;
|
||||
Box::pin(usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
|
||||
}
|
||||
None => {
|
||||
Box::pin(usecase.execute_complete_multipart_upload_parts(owned_envelope(Method::POST), owned, None)).await
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
let completed = completed.expect("staged part should remain completable after empty request rejection");
|
||||
assert!(completed.e_tag.is_some());
|
||||
let completed_info = store
|
||||
.get_object_info(
|
||||
@@ -2151,6 +2373,8 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_complete_multipart_upload_allows_duplicate_part_numbers_by_using_last_occurrence() {
|
||||
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
|
||||
|
||||
let multipart_upload = CompletedMultipartUpload {
|
||||
parts: Some(vec![
|
||||
CompletedPart {
|
||||
@@ -2170,14 +2394,67 @@ mod tests {
|
||||
.multipart_upload(Some(multipart_upload))
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::POST);
|
||||
|
||||
let err = Box::pin(make_usecase().complete_for_s3s_request(req)).await.unwrap_err();
|
||||
let mut s3s_input = input;
|
||||
let has_upload = s3s_input.multipart_upload.is_some();
|
||||
s3s_input.multipart_upload.get_or_insert_with(Default::default);
|
||||
let tags: Vec<Option<String>> = s3s_input
|
||||
.multipart_upload
|
||||
.iter_mut()
|
||||
.flat_map(|upload| upload.parts.iter_mut().flatten())
|
||||
.map(|part| {
|
||||
part.part_number.get_or_insert(0);
|
||||
part.e_tag.take().map(|tag| tag.value().to_owned())
|
||||
})
|
||||
.collect();
|
||||
for checksum in [
|
||||
&mut s3s_input.checksum_crc32,
|
||||
&mut s3s_input.checksum_crc32c,
|
||||
&mut s3s_input.checksum_crc64nvme,
|
||||
&mut s3s_input.checksum_md5,
|
||||
&mut s3s_input.checksum_sha1,
|
||||
&mut s3s_input.checksum_sha256,
|
||||
&mut s3s_input.checksum_sha512,
|
||||
&mut s3s_input.checksum_xxhash128,
|
||||
&mut s3s_input.checksum_xxhash3,
|
||||
&mut s3s_input.checksum_xxhash64,
|
||||
] {
|
||||
*checksum = None;
|
||||
}
|
||||
let err = match complete_multipart_upload::input_from_s3s(s3s_input) {
|
||||
Err(error) => crate::app::dto_values::seam_error(error),
|
||||
Ok(mut owned) => {
|
||||
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
|
||||
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
|
||||
}
|
||||
let taken = std::mem::take(&mut owned.multipart_upload);
|
||||
let parts = has_upload.then_some(taken);
|
||||
let result = match parts {
|
||||
Some(parts) => {
|
||||
owned.multipart_upload = parts;
|
||||
Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
|
||||
}
|
||||
None => {
|
||||
Box::pin(make_usecase().execute_complete_multipart_upload_parts(
|
||||
owned_envelope(Method::POST),
|
||||
owned,
|
||||
None,
|
||||
))
|
||||
.await
|
||||
}
|
||||
};
|
||||
match result {
|
||||
Err(error) => error,
|
||||
Ok(_output) => panic!("duplicate part numbers must not succeed before the order check"),
|
||||
}
|
||||
}
|
||||
};
|
||||
assert_ne!(err.code(), &S3ErrorCode::InvalidPartOrder);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_complete_multipart_upload_rejects_out_of_order_parts() {
|
||||
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
|
||||
|
||||
let multipart_upload = CompletedMultipartUpload {
|
||||
parts: Some(vec![
|
||||
CompletedPart {
|
||||
@@ -2197,9 +2474,60 @@ mod tests {
|
||||
.multipart_upload(Some(multipart_upload))
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::POST);
|
||||
|
||||
let err = Box::pin(make_usecase().complete_for_s3s_request(req)).await.unwrap_err();
|
||||
let mut s3s_input = input;
|
||||
let has_upload = s3s_input.multipart_upload.is_some();
|
||||
s3s_input.multipart_upload.get_or_insert_with(Default::default);
|
||||
let tags: Vec<Option<String>> = s3s_input
|
||||
.multipart_upload
|
||||
.iter_mut()
|
||||
.flat_map(|upload| upload.parts.iter_mut().flatten())
|
||||
.map(|part| {
|
||||
part.part_number.get_or_insert(0);
|
||||
part.e_tag.take().map(|tag| tag.value().to_owned())
|
||||
})
|
||||
.collect();
|
||||
for checksum in [
|
||||
&mut s3s_input.checksum_crc32,
|
||||
&mut s3s_input.checksum_crc32c,
|
||||
&mut s3s_input.checksum_crc64nvme,
|
||||
&mut s3s_input.checksum_md5,
|
||||
&mut s3s_input.checksum_sha1,
|
||||
&mut s3s_input.checksum_sha256,
|
||||
&mut s3s_input.checksum_sha512,
|
||||
&mut s3s_input.checksum_xxhash128,
|
||||
&mut s3s_input.checksum_xxhash3,
|
||||
&mut s3s_input.checksum_xxhash64,
|
||||
] {
|
||||
*checksum = None;
|
||||
}
|
||||
let err = match complete_multipart_upload::input_from_s3s(s3s_input) {
|
||||
Err(error) => crate::app::dto_values::seam_error(error),
|
||||
Ok(mut owned) => {
|
||||
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
|
||||
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
|
||||
}
|
||||
let taken = std::mem::take(&mut owned.multipart_upload);
|
||||
let parts = has_upload.then_some(taken);
|
||||
let result = match parts {
|
||||
Some(parts) => {
|
||||
owned.multipart_upload = parts;
|
||||
Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
|
||||
}
|
||||
None => {
|
||||
Box::pin(make_usecase().execute_complete_multipart_upload_parts(
|
||||
owned_envelope(Method::POST),
|
||||
owned,
|
||||
None,
|
||||
))
|
||||
.await
|
||||
}
|
||||
};
|
||||
match result {
|
||||
Err(error) => error,
|
||||
Ok(_output) => panic!("out-of-order parts must be rejected"),
|
||||
}
|
||||
}
|
||||
};
|
||||
assert_eq!(err.code(), &S3ErrorCode::InvalidPartOrder);
|
||||
}
|
||||
|
||||
@@ -2368,10 +2696,60 @@ mod tests {
|
||||
}))
|
||||
.build()
|
||||
.expect("complete input");
|
||||
let error = DefaultMultipartUsecase::from_global()
|
||||
.complete_for_s3s_request(build_request(input, Method::POST))
|
||||
.await
|
||||
.expect_err("absent upload cannot complete");
|
||||
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
|
||||
|
||||
let usecase = DefaultMultipartUsecase::from_global();
|
||||
let mut s3s_input = input;
|
||||
let has_upload = s3s_input.multipart_upload.is_some();
|
||||
s3s_input.multipart_upload.get_or_insert_with(Default::default);
|
||||
let tags: Vec<Option<String>> = s3s_input
|
||||
.multipart_upload
|
||||
.iter_mut()
|
||||
.flat_map(|upload| upload.parts.iter_mut().flatten())
|
||||
.map(|part| {
|
||||
part.part_number.get_or_insert(0);
|
||||
part.e_tag.take().map(|tag| tag.value().to_owned())
|
||||
})
|
||||
.collect();
|
||||
for checksum in [
|
||||
&mut s3s_input.checksum_crc32,
|
||||
&mut s3s_input.checksum_crc32c,
|
||||
&mut s3s_input.checksum_crc64nvme,
|
||||
&mut s3s_input.checksum_md5,
|
||||
&mut s3s_input.checksum_sha1,
|
||||
&mut s3s_input.checksum_sha256,
|
||||
&mut s3s_input.checksum_sha512,
|
||||
&mut s3s_input.checksum_xxhash128,
|
||||
&mut s3s_input.checksum_xxhash3,
|
||||
&mut s3s_input.checksum_xxhash64,
|
||||
] {
|
||||
*checksum = None;
|
||||
}
|
||||
let rejected = match complete_multipart_upload::input_from_s3s(s3s_input) {
|
||||
Err(error) => Err(crate::app::dto_values::seam_error(error)),
|
||||
Ok(mut owned) => {
|
||||
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
|
||||
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
|
||||
}
|
||||
let taken = std::mem::take(&mut owned.multipart_upload);
|
||||
let parts = has_upload.then_some(taken);
|
||||
match parts {
|
||||
Some(parts) => {
|
||||
owned.multipart_upload = parts;
|
||||
Box::pin(usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
|
||||
}
|
||||
None => {
|
||||
Box::pin(usecase.execute_complete_multipart_upload_parts(
|
||||
owned_envelope(Method::POST),
|
||||
owned,
|
||||
None,
|
||||
))
|
||||
.await
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
let error = rejected.expect_err("absent upload cannot complete");
|
||||
assert_eq!(probe.audits.lock().expect("audits").len(), 0, "{shape}/{label}");
|
||||
assert_eq!(probe.events.lock().expect("events").len(), 0, "{shape}/{label}");
|
||||
let (code, status, message, storage_cause) = if raw_id.is_some() {
|
||||
|
||||
@@ -545,10 +545,17 @@ mod tests {
|
||||
.object_lock_retain_until_date(date.map(Timestamp::from))
|
||||
.build()
|
||||
.expect("direct fixture DTO");
|
||||
let error = make_usecase()
|
||||
.execute_create_multipart_upload_from_s3s(build_request(input, Method::POST))
|
||||
let error = match make_usecase()
|
||||
.execute_create_multipart_upload(
|
||||
owned_envelope(Method::POST),
|
||||
CreateMultipartUploadFields::from_legacy(input),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.expect_err("direct fixture does not create an upload");
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("direct fixture does not create an upload"),
|
||||
};
|
||||
assert_eq!(
|
||||
(error.code().as_str(), error.message()),
|
||||
(expected.0, Some(expected.1)),
|
||||
@@ -590,12 +597,13 @@ mod tests {
|
||||
.storage_class(Some(StorageClass::from("invalid".to_string())))
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::POST);
|
||||
|
||||
let err = make_usecase()
|
||||
.execute_create_multipart_upload_from_s3s(req)
|
||||
let err = match make_usecase()
|
||||
.execute_create_multipart_upload(owned_envelope(Method::POST), CreateMultipartUploadFields::from_legacy(input), None)
|
||||
.await
|
||||
.unwrap_err();
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("invalid storage class must be rejected"),
|
||||
};
|
||||
assert_eq!(err.code(), &S3ErrorCode::InvalidStorageClass);
|
||||
}
|
||||
|
||||
|
||||
@@ -295,7 +295,7 @@ mod tests {
|
||||
|
||||
async fn list_uploads(input: gateway_dto::ListMultipartUploadsInput) -> rustfs_s3_types::S3Error {
|
||||
make_usecase()
|
||||
.execute_list_multipart_uploads(RequestEnvelope::from_s3s(&build_request((), Method::GET)), input)
|
||||
.execute_list_multipart_uploads(owned_envelope(Method::GET), input)
|
||||
.await
|
||||
.expect_err("refused")
|
||||
}
|
||||
@@ -393,7 +393,7 @@ mod tests {
|
||||
max_parts,
|
||||
};
|
||||
make_usecase()
|
||||
.execute_list_parts(RequestEnvelope::from_s3s(&build_request((), Method::GET)), fields)
|
||||
.execute_list_parts(owned_envelope(Method::GET), fields)
|
||||
.await
|
||||
.expect_err("refused")
|
||||
}
|
||||
|
||||
@@ -14,7 +14,7 @@
|
||||
|
||||
//! ListParts execution against real multipart metadata and the native claim exchange.
|
||||
|
||||
use super::super::test_support::{Method, build_request};
|
||||
use super::super::test_support::{Method, build_request, owned_envelope};
|
||||
use super::*;
|
||||
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient, shared_gating_ecstore_and_disk_paths};
|
||||
use crate::app::storage_api::multipart_usecase::access::{AuthorizationRequest, load_bucket_generation_from_store};
|
||||
@@ -81,7 +81,7 @@ fn list_parts_resolves_real_owners_and_retains_storage_errors() {
|
||||
let key = "fixture/one";
|
||||
let foreign_key = "fixture/two";
|
||||
let opts = ObjectOptions::default();
|
||||
let envelope = || RequestEnvelope::from_s3s(&build_request((), Method::GET));
|
||||
let envelope = || owned_envelope(Method::GET);
|
||||
for name in [&bucket, &foreign_bucket] {
|
||||
store
|
||||
.make_bucket(name, &MakeBucketOptions::default())
|
||||
|
||||
@@ -18,6 +18,7 @@ use super::*;
|
||||
use crate::app::storage_api::s3::S3Request;
|
||||
pub(super) use crate::app::storage_api::s3::dto::CompletedMultipartUpload;
|
||||
pub(super) use crate::app::storage_api::s3::dto::StorageClass;
|
||||
use crate::app::{RequestEnvelope, RequestHead};
|
||||
pub(super) use http::Extensions;
|
||||
pub(super) use http::Method;
|
||||
pub(super) use rustfs_filemeta::ObjectPartInfo;
|
||||
@@ -50,6 +51,21 @@ pub(super) fn build_request<T>(input: T, method: Method) -> S3Request<T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// The envelope of a request that carries nothing but `method`.
|
||||
pub(super) fn owned_envelope(method: Method) -> RequestEnvelope {
|
||||
RequestEnvelope::from_parts(
|
||||
RequestHead {
|
||||
method,
|
||||
uri: Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
Extensions::new(),
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn make_usecase() -> DefaultMultipartUsecase {
|
||||
DefaultMultipartUsecase::without_context()
|
||||
}
|
||||
|
||||
@@ -382,7 +382,8 @@ impl DefaultMultipartUsecase {
|
||||
content_size: actual_size,
|
||||
principal: None,
|
||||
}
|
||||
.validate_multipart_ssec(&fi.user_defined)?;
|
||||
.validate_multipart_ssec(&fi.user_defined)
|
||||
.map_err(ApiError::from)?;
|
||||
}
|
||||
let (requested_sse, requested_kms_key_id) = if has_ssec {
|
||||
let ssec_material = sse_decryption(DecryptionRequest {
|
||||
@@ -741,9 +742,13 @@ mod tests {
|
||||
.part_number(1)
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::PUT);
|
||||
|
||||
let err = make_usecase().execute_upload_part(req).await.unwrap_err();
|
||||
let err = match make_usecase()
|
||||
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
|
||||
.await
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("missing body must be rejected"),
|
||||
};
|
||||
assert_eq!(err.code(), &LegacyErrorCode::IncompleteBody);
|
||||
}
|
||||
|
||||
@@ -765,9 +770,13 @@ mod tests {
|
||||
.content_length(Some(declared))
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::PUT);
|
||||
|
||||
let err = make_usecase().execute_upload_part(req).await.unwrap_err();
|
||||
let err = match make_usecase()
|
||||
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
|
||||
.await
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("declared part must be rejected"),
|
||||
};
|
||||
if expect_too_large {
|
||||
assert_eq!(err.code(), &LegacyErrorCode::EntityTooLarge, "declared {declared}");
|
||||
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 0, "body must not be polled");
|
||||
@@ -787,9 +796,13 @@ mod tests {
|
||||
.part_number(part_number)
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::PUT);
|
||||
|
||||
let err = make_usecase().execute_upload_part(req).await.unwrap_err();
|
||||
let err = match make_usecase()
|
||||
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
|
||||
.await
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("invalid part number must be rejected"),
|
||||
};
|
||||
assert_eq!(err.code(), &LegacyErrorCode::InvalidArgument);
|
||||
assert_eq!(err.message(), Some("partNumber must be between 1 and 10000"));
|
||||
}
|
||||
@@ -971,10 +984,13 @@ mod tests {
|
||||
.build()
|
||||
.expect("upload part input should build");
|
||||
|
||||
let err = usecase
|
||||
.execute_upload_part(build_request(input, Method::PUT))
|
||||
let err = match usecase
|
||||
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
|
||||
.await
|
||||
.expect_err("full foreground write admission should reject before body ingest");
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("full foreground write admission should reject before body ingest"),
|
||||
};
|
||||
assert_eq!(err.code(), &LegacyErrorCode::SlowDown);
|
||||
drop(held);
|
||||
}
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
|
||||
//! Upload target ownership and refusal order against real multipart state.
|
||||
|
||||
use super::super::super::test_support::owned_envelope;
|
||||
use super::*;
|
||||
use crate::app::storage_api::test::contract::bucket::{BucketOperations as _, MakeBucketOptions};
|
||||
use rustfs_gateway_types::{BucketName, ObjectKey, UploadIdClaim};
|
||||
@@ -101,7 +102,7 @@ async fn native_claim_checks_order_ownership_and_one_active_lookup() {
|
||||
Body::from(Bytes::from_static(b"abc"))
|
||||
}
|
||||
});
|
||||
let envelope = RequestEnvelope::from_s3s(&build_request((), Method::PUT));
|
||||
let envelope = owned_envelope(Method::PUT);
|
||||
LOOKUP
|
||||
.scope((Cell::new(0), mode), async {
|
||||
let result = usecase.execute_upload_part_with_audit(envelope, input).await;
|
||||
@@ -211,7 +212,7 @@ fn native_copy_part_rejects_unproved_owner_without_changing_parts() {
|
||||
copy_source_sse_customer_key: None,
|
||||
copy_source_sse_customer_key_md5: None,
|
||||
};
|
||||
let envelope = RequestEnvelope::from_s3s(&build_request((), Method::PUT));
|
||||
let envelope = owned_envelope(Method::PUT);
|
||||
LOOKUP
|
||||
.scope((Cell::new(0), mode), async {
|
||||
let result = Box::pin(usecase.execute_upload_part_copy_with_audit(envelope, input)).await;
|
||||
|
||||
@@ -313,7 +313,8 @@ impl DefaultMultipartUsecase {
|
||||
content_size: 0,
|
||||
principal: None,
|
||||
}
|
||||
.validate_multipart_ssec(&mp_info.user_defined)?;
|
||||
.validate_multipart_ssec(&mp_info.user_defined)
|
||||
.map_err(ApiError::from)?;
|
||||
|
||||
let src_versioned = BucketVersioningSys::prefix_enabled(&src_bucket, &src_key).await;
|
||||
let src_version_suspended = BucketVersioningSys::prefix_suspended(&src_bucket, &src_key).await;
|
||||
@@ -561,6 +562,9 @@ impl DefaultMultipartUsecase {
|
||||
mod tests {
|
||||
use super::super::test_support::*;
|
||||
use super::*;
|
||||
use crate::app::multipart_usecase::UploadPartTarget;
|
||||
use crate::app::object_usecase::CopySourceCondition;
|
||||
use crate::app::storage_api::s3::dto::ETag;
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_upload_part_copy_returns_internal_error_when_store_uninitialized() {
|
||||
@@ -576,9 +580,37 @@ mod tests {
|
||||
.upload_id("upload-id".to_string())
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::PUT);
|
||||
|
||||
let err = Box::pin(make_usecase().execute_upload_part_copy(req)).await.unwrap_err();
|
||||
let condition = |value| match value {
|
||||
crate::app::storage_api::s3::dto::ETagCondition::Any => CopySourceCondition::Any,
|
||||
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Strong(value)) => CopySourceCondition::Strong(value),
|
||||
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Weak(_)) => CopySourceCondition::Weak,
|
||||
};
|
||||
let err = match Box::pin(make_usecase().execute_upload_part_copy_with_audit(
|
||||
owned_envelope(Method::PUT),
|
||||
UploadPartCopyWriteInput {
|
||||
target: UploadPartTarget::Legacy {
|
||||
bucket: input.bucket,
|
||||
key: input.key,
|
||||
upload_id: input.upload_id,
|
||||
},
|
||||
part_number: input.part_number,
|
||||
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(input.copy_source),
|
||||
copy_source_range: input.copy_source_range,
|
||||
copy_source_if_match: input.copy_source_if_match.map(&condition),
|
||||
copy_source_if_none_match: input.copy_source_if_none_match.map(&condition),
|
||||
sse_customer_algorithm: input.sse_customer_algorithm,
|
||||
sse_customer_key: input.sse_customer_key,
|
||||
sse_customer_key_md5: input.sse_customer_key_md5,
|
||||
copy_source_sse_customer_algorithm: input.copy_source_sse_customer_algorithm,
|
||||
copy_source_sse_customer_key: input.copy_source_sse_customer_key,
|
||||
copy_source_sse_customer_key_md5: input.copy_source_sse_customer_key_md5,
|
||||
},
|
||||
))
|
||||
.await
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("uninitialized store must be an internal error"),
|
||||
};
|
||||
assert_eq!(err.code(), &crate::app::storage_api::s3::S3ErrorCode::InternalError);
|
||||
}
|
||||
|
||||
@@ -597,9 +629,37 @@ mod tests {
|
||||
.upload_id("upload-id".to_string())
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::PUT);
|
||||
|
||||
let err = Box::pin(make_usecase().execute_upload_part_copy(req)).await.unwrap_err();
|
||||
let condition = |value| match value {
|
||||
crate::app::storage_api::s3::dto::ETagCondition::Any => CopySourceCondition::Any,
|
||||
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Strong(value)) => CopySourceCondition::Strong(value),
|
||||
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Weak(_)) => CopySourceCondition::Weak,
|
||||
};
|
||||
let err = match Box::pin(make_usecase().execute_upload_part_copy_with_audit(
|
||||
owned_envelope(Method::PUT),
|
||||
UploadPartCopyWriteInput {
|
||||
target: UploadPartTarget::Legacy {
|
||||
bucket: input.bucket,
|
||||
key: input.key,
|
||||
upload_id: input.upload_id,
|
||||
},
|
||||
part_number: input.part_number,
|
||||
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(input.copy_source),
|
||||
copy_source_range: input.copy_source_range,
|
||||
copy_source_if_match: input.copy_source_if_match.map(&condition),
|
||||
copy_source_if_none_match: input.copy_source_if_none_match.map(&condition),
|
||||
sse_customer_algorithm: input.sse_customer_algorithm,
|
||||
sse_customer_key: input.sse_customer_key,
|
||||
sse_customer_key_md5: input.sse_customer_key_md5,
|
||||
copy_source_sse_customer_algorithm: input.copy_source_sse_customer_algorithm,
|
||||
copy_source_sse_customer_key: input.copy_source_sse_customer_key,
|
||||
copy_source_sse_customer_key_md5: input.copy_source_sse_customer_key_md5,
|
||||
},
|
||||
))
|
||||
.await
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("invalid part number must be rejected"),
|
||||
};
|
||||
assert_eq!(err.code(), &crate::app::storage_api::s3::S3ErrorCode::InvalidArgument);
|
||||
assert_eq!(err.message(), Some("partNumber must be between 1 and 10000"));
|
||||
}
|
||||
|
||||
@@ -76,9 +76,38 @@ fn upload_part_copy_shares_foreground_admission_with_upload_part() {
|
||||
.any(|label| label.key() == "size_bucket" && label.value() == source_size_bucket)
|
||||
})
|
||||
};
|
||||
let error = Box::pin(usecase.execute_upload_part_copy(build_request(input.clone(), Method::PUT)))
|
||||
.await
|
||||
.expect_err("copy must not bypass the occupied UploadPart pool");
|
||||
let saturated = input.clone();
|
||||
let condition = |value| match value {
|
||||
crate::app::storage_api::s3::dto::ETagCondition::Any => CopySourceCondition::Any,
|
||||
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Strong(value)) => CopySourceCondition::Strong(value),
|
||||
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Weak(_)) => CopySourceCondition::Weak,
|
||||
};
|
||||
let error = match Box::pin(usecase.execute_upload_part_copy_with_audit(
|
||||
owned_envelope(Method::PUT),
|
||||
UploadPartCopyWriteInput {
|
||||
target: UploadPartTarget::Legacy {
|
||||
bucket: saturated.bucket,
|
||||
key: saturated.key,
|
||||
upload_id: saturated.upload_id,
|
||||
},
|
||||
part_number: saturated.part_number,
|
||||
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(saturated.copy_source),
|
||||
copy_source_range: saturated.copy_source_range,
|
||||
copy_source_if_match: saturated.copy_source_if_match.map(&condition),
|
||||
copy_source_if_none_match: saturated.copy_source_if_none_match.map(&condition),
|
||||
sse_customer_algorithm: saturated.sse_customer_algorithm,
|
||||
sse_customer_key: saturated.sse_customer_key,
|
||||
sse_customer_key_md5: saturated.sse_customer_key_md5,
|
||||
copy_source_sse_customer_algorithm: saturated.copy_source_sse_customer_algorithm,
|
||||
copy_source_sse_customer_key: saturated.copy_source_sse_customer_key,
|
||||
copy_source_sse_customer_key_md5: saturated.copy_source_sse_customer_key_md5,
|
||||
},
|
||||
))
|
||||
.await
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("copy must not bypass the occupied UploadPart pool"),
|
||||
};
|
||||
assert_eq!(error.code(), &S3ErrorCode::SlowDown);
|
||||
assert!(!source_reader_observed(), "saturated copy must not construct a source body reader");
|
||||
let parts = store
|
||||
@@ -165,9 +194,37 @@ fn upload_part_copy_shares_foreground_admission_with_upload_part() {
|
||||
.upload_id(deleted_upload.upload_id.clone())
|
||||
.build()
|
||||
.expect("deleted-source copy request");
|
||||
let error = Box::pin(usecase.execute_upload_part_copy(build_request(input, Method::PUT)))
|
||||
.await
|
||||
.expect_err("deleted source must fail before conditions or admission");
|
||||
let condition = |value| match value {
|
||||
crate::app::storage_api::s3::dto::ETagCondition::Any => CopySourceCondition::Any,
|
||||
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Strong(value)) => CopySourceCondition::Strong(value),
|
||||
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Weak(_)) => CopySourceCondition::Weak,
|
||||
};
|
||||
let error = match Box::pin(usecase.execute_upload_part_copy_with_audit(
|
||||
owned_envelope(Method::PUT),
|
||||
UploadPartCopyWriteInput {
|
||||
target: UploadPartTarget::Legacy {
|
||||
bucket: input.bucket,
|
||||
key: input.key,
|
||||
upload_id: input.upload_id,
|
||||
},
|
||||
part_number: input.part_number,
|
||||
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(input.copy_source),
|
||||
copy_source_range: input.copy_source_range,
|
||||
copy_source_if_match: input.copy_source_if_match.map(&condition),
|
||||
copy_source_if_none_match: input.copy_source_if_none_match.map(&condition),
|
||||
sse_customer_algorithm: input.sse_customer_algorithm,
|
||||
sse_customer_key: input.sse_customer_key,
|
||||
sse_customer_key_md5: input.sse_customer_key_md5,
|
||||
copy_source_sse_customer_algorithm: input.copy_source_sse_customer_algorithm,
|
||||
copy_source_sse_customer_key: input.copy_source_sse_customer_key,
|
||||
copy_source_sse_customer_key_md5: input.copy_source_sse_customer_key_md5,
|
||||
},
|
||||
))
|
||||
.await
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("deleted source must fail before conditions or admission"),
|
||||
};
|
||||
assert_eq!(error.code(), &expected);
|
||||
}
|
||||
});
|
||||
@@ -211,7 +268,32 @@ fn upload_part_copy_range_error_and_cancellation_release_foreground_permit() {
|
||||
.upload_id(cancelled_upload.upload_id.clone())
|
||||
.build()
|
||||
.expect("cancelled copy request");
|
||||
let mut cancelled_copy = Box::pin(usecase.execute_upload_part_copy(build_request(cancelled_input, Method::PUT)));
|
||||
let condition = |value| match value {
|
||||
crate::app::storage_api::s3::dto::ETagCondition::Any => CopySourceCondition::Any,
|
||||
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Strong(value)) => CopySourceCondition::Strong(value),
|
||||
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Weak(_)) => CopySourceCondition::Weak,
|
||||
};
|
||||
let mut cancelled_copy = Box::pin(usecase.execute_upload_part_copy_with_audit(
|
||||
owned_envelope(Method::PUT),
|
||||
UploadPartCopyWriteInput {
|
||||
target: UploadPartTarget::Legacy {
|
||||
bucket: cancelled_input.bucket,
|
||||
key: cancelled_input.key,
|
||||
upload_id: cancelled_input.upload_id,
|
||||
},
|
||||
part_number: cancelled_input.part_number,
|
||||
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(cancelled_input.copy_source),
|
||||
copy_source_range: cancelled_input.copy_source_range,
|
||||
copy_source_if_match: cancelled_input.copy_source_if_match.map(&condition),
|
||||
copy_source_if_none_match: cancelled_input.copy_source_if_none_match.map(&condition),
|
||||
sse_customer_algorithm: cancelled_input.sse_customer_algorithm,
|
||||
sse_customer_key: cancelled_input.sse_customer_key,
|
||||
sse_customer_key_md5: cancelled_input.sse_customer_key_md5,
|
||||
copy_source_sse_customer_algorithm: cancelled_input.copy_source_sse_customer_algorithm,
|
||||
copy_source_sse_customer_key: cancelled_input.copy_source_sse_customer_key,
|
||||
copy_source_sse_customer_key_md5: cancelled_input.copy_source_sse_customer_key_md5,
|
||||
},
|
||||
));
|
||||
tokio::time::timeout(Duration::from_secs(10), async {
|
||||
tokio::select! {
|
||||
biased;
|
||||
@@ -220,7 +302,10 @@ fn upload_part_copy_range_error_and_cancellation_release_foreground_permit() {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
} => {}
|
||||
result = &mut cancelled_copy => panic!("copy completed before cancellation: {result:?}"),
|
||||
result = &mut cancelled_copy => match result {
|
||||
Ok(_) => panic!("copy completed before cancellation"),
|
||||
Err(error) => panic!("copy completed before cancellation: {error:?}"),
|
||||
},
|
||||
}
|
||||
})
|
||||
.await
|
||||
@@ -260,17 +345,39 @@ fn upload_part_copy_range_error_and_cancellation_release_foreground_permit() {
|
||||
.upload_id(upload.upload_id.clone())
|
||||
.build()
|
||||
.expect("range request");
|
||||
let response = Box::pin(usecase.execute_upload_part_copy(build_request(input, Method::PUT))).await;
|
||||
let response = Box::pin(usecase.execute_upload_part_copy_with_audit(
|
||||
owned_envelope(Method::PUT),
|
||||
UploadPartCopyWriteInput {
|
||||
target: UploadPartTarget::Legacy {
|
||||
bucket: input.bucket,
|
||||
key: input.key,
|
||||
upload_id: input.upload_id,
|
||||
},
|
||||
part_number: input.part_number,
|
||||
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(input.copy_source),
|
||||
copy_source_range: input.copy_source_range,
|
||||
copy_source_if_match: input.copy_source_if_match.map(&condition),
|
||||
copy_source_if_none_match: input.copy_source_if_none_match.map(&condition),
|
||||
sse_customer_algorithm: input.sse_customer_algorithm,
|
||||
sse_customer_key: input.sse_customer_key,
|
||||
sse_customer_key_md5: input.sse_customer_key_md5,
|
||||
copy_source_sse_customer_algorithm: input.copy_source_sse_customer_algorithm,
|
||||
copy_source_sse_customer_key: input.copy_source_sse_customer_key,
|
||||
copy_source_sse_customer_key_md5: input.copy_source_sse_customer_key_md5,
|
||||
},
|
||||
))
|
||||
.await;
|
||||
assert_eq!(
|
||||
manager.put_object_admission_snapshot().active,
|
||||
Some(0),
|
||||
"copy releases its permit on every outcome"
|
||||
);
|
||||
if capped {
|
||||
assert_eq!(
|
||||
response.expect_err("range exceeds destination size limit").code(),
|
||||
&S3ErrorCode::EntityTooLarge
|
||||
);
|
||||
let error = match response {
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("range exceeds destination size limit"),
|
||||
};
|
||||
assert_eq!(error.code(), &S3ErrorCode::EntityTooLarge);
|
||||
let parts = store
|
||||
.list_object_parts(&bucket, "object", &upload.upload_id, None, 1000, &ObjectOptions::default())
|
||||
.await
|
||||
@@ -281,16 +388,16 @@ fn upload_part_copy_range_error_and_cancellation_release_foreground_permit() {
|
||||
.await
|
||||
.expect("abort capped session");
|
||||
} else {
|
||||
let copied = response.expect("range copy after failed request released its source and permit");
|
||||
let copied = match response {
|
||||
Ok(output) => output,
|
||||
Err(error) => panic!("range copy after failed request released its source and permit: {error:?}"),
|
||||
};
|
||||
let etag = copied
|
||||
.output
|
||||
.copy_part_result
|
||||
.expect("range result")
|
||||
.e_tag
|
||||
.expect("range ETag")
|
||||
.value()
|
||||
.trim_matches('"')
|
||||
.to_owned();
|
||||
.as_deref()
|
||||
.map(crate::storage::storage_api::to_s3s_xml_etag)
|
||||
.expect("range ETag");
|
||||
let etag = etag.value().trim_matches('"').to_owned();
|
||||
Arc::clone(&store)
|
||||
.complete_multipart_upload(
|
||||
&bucket,
|
||||
|
||||
@@ -258,8 +258,17 @@ mod tests {
|
||||
sse_customer_key: None,
|
||||
sse_customer_key_md5: None,
|
||||
};
|
||||
let request = build_request((), http::Method::GET);
|
||||
let envelope = RequestEnvelope::from_s3s(&request);
|
||||
let envelope = RequestEnvelope::from_parts(
|
||||
crate::app::RequestHead {
|
||||
method: http::Method::GET,
|
||||
uri: http::Uri::from_static("/"),
|
||||
headers: http::HeaderMap::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
http::Extensions::new(),
|
||||
);
|
||||
let error = DefaultObjectUsecase::without_context()
|
||||
.execute_get_object_attributes(envelope, fields)
|
||||
.await
|
||||
|
||||
@@ -108,11 +108,11 @@ use super::storage_api::object_usecase::set_disk::{
|
||||
get_lock_acquire_timeout, get_object_disk_read_timeout, is_valid_storage_class,
|
||||
};
|
||||
use super::storage_api::object_usecase::sse::{
|
||||
DecryptionRequest, EncryptionRequest, SseKmsPrincipal, apply_bucket_default_lock_retention, authorize_sse_kms_object_read,
|
||||
bucket_default_write_sse, build_ssec_read_headers, classify_sse_read_response, encryption_material_to_metadata,
|
||||
extract_server_side_encryption_from_headers, extract_ssec_params_from_headers, extract_ssekms_context_from_headers,
|
||||
get_buffer_size_opt_in, load_bucket_object_lock_config_state, map_get_object_reader_error, sse_encryption,
|
||||
validate_bucket_object_lock_enabled_state,
|
||||
DecryptionRequest, EncryptionMaterialExt, EncryptionRequest, SseKmsPrincipal, SseKmsPrincipalExt,
|
||||
apply_bucket_default_lock_retention, authorize_sse_kms_object_read, bucket_default_write_sse, build_ssec_read_headers,
|
||||
classify_sse_read_response, encryption_material_to_metadata, extract_server_side_encryption_from_headers,
|
||||
extract_ssec_params_from_headers, extract_ssekms_context_from_headers, get_buffer_size_opt_in,
|
||||
load_bucket_object_lock_config_state, map_get_object_reader_error, sse_encryption, validate_bucket_object_lock_enabled_state,
|
||||
};
|
||||
use super::storage_api::object_usecase::storage_class as storageclass;
|
||||
use super::storage_api::object_usecase::timeout_wrapper::{GetObjectTimeoutPolicy, RequestTimeoutWrapper};
|
||||
|
||||
@@ -2,7 +2,9 @@
|
||||
use super::storage_api::select_object::StorageError;
|
||||
use super::storage_api::select_object::options::get_opts;
|
||||
use super::storage_api::select_object::request_context::spawn_traced;
|
||||
use super::storage_api::select_object::sse::{SseKmsPrincipal, authorize_sse_kms_object_read, project_sse_read_response_headers};
|
||||
use super::storage_api::select_object::sse::{
|
||||
SseKmsPrincipal, SseKmsPrincipalExt, authorize_sse_kms_object_read, project_sse_read_response_headers,
|
||||
};
|
||||
use super::storage_api::select_object::{
|
||||
StoragePrepareSelectObjectSnapshotError, StorageSelectObjectSnapshot, get_validated_store, validate_sse_headers_for_read,
|
||||
validate_ssec_for_read,
|
||||
|
||||
@@ -1675,9 +1675,9 @@ pub(crate) mod sse {
|
||||
validate_bucket_object_lock_enabled_state,
|
||||
};
|
||||
pub(crate) use crate::storage::storage_api::sse_consumer::{
|
||||
EncryptionKeyKind, bucket_default_write_sse, build_ssec_read_headers, encryption_material_to_metadata,
|
||||
extract_ssec_params_from_headers, extract_ssekms_context_from_headers, map_get_object_reader_error,
|
||||
mark_encrypted_multipart_metadata, multipart_completion_authorization, stored_ssec_metadata,
|
||||
EncryptionKeyKind, EncryptionMaterialExt, SseKmsPrincipalExt, bucket_default_write_sse, build_ssec_read_headers,
|
||||
encryption_material_to_metadata, extract_ssec_params_from_headers, extract_ssekms_context_from_headers,
|
||||
map_get_object_reader_error, mark_encrypted_multipart_metadata, multipart_completion_authorization, stored_ssec_metadata,
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
+13
-72
@@ -18,6 +18,7 @@ use http::StatusCode;
|
||||
use rustfs_kms::KmsUnavailableError;
|
||||
use rustfs_lock::LockError;
|
||||
use rustfs_s3_types::S3ErrorCode;
|
||||
use rustfs_sse::{SseError, data_plane_kms_error};
|
||||
use s3s::S3Error as LegacyS3Error;
|
||||
use s3s::stream::{aws_chunked_stream::AwsChunkedStreamError, upload_stream::UploadStreamError};
|
||||
|
||||
@@ -51,7 +52,7 @@ pub(crate) fn rpc_replay_admission_exhausted_status() -> tonic::Status {
|
||||
const UNSUPPORTED_PARTICIPANT_MESSAGE: &str = "A storage participant does not support this operation's protocol version. If the cluster is being upgraded, finish upgrading every node and retry.";
|
||||
|
||||
/// S3 error code for a request that names a KMS key the KMS does not hold.
|
||||
pub const KMS_KEY_NOT_FOUND_ERROR_CODE: &str = "KMS.NotFoundException";
|
||||
pub use rustfs_sse::KMS_KEY_NOT_FOUND_ERROR_CODE;
|
||||
|
||||
fn lock_resource_class(resource: Option<&str>) -> &'static str {
|
||||
let Some(resource) = resource else {
|
||||
@@ -122,77 +123,6 @@ fn record_s3_lock_failure(err: &StorageError) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Map a KMS failure that surfaced on the S3 data path to its S3 error code.
|
||||
///
|
||||
/// The contract deliberately differs from the admin lifecycle handlers
|
||||
/// (`kms_key_lifecycle::lifecycle_error_status`): there a key id is the
|
||||
/// resource being addressed, so a missing key is `404`. Here the key id
|
||||
/// arrives inside a request header or a bucket default, so a key that is
|
||||
/// missing, disabled, or otherwise unusable is configuration the caller has to
|
||||
/// correct — AWS answers `400`, and reporting `500` instead both misfiles the
|
||||
/// failure as a server fault and makes SDKs back off and retry a request that
|
||||
/// cannot succeed.
|
||||
///
|
||||
/// `None` keeps the caller's fallthrough, which is the `500` that integrity
|
||||
/// faults — damaged, unreadable, or unknown-format key material — must keep.
|
||||
///
|
||||
/// Messages either name what the caller asked for or stay generic; detail that
|
||||
/// belongs to the deployment rather than the request stays in `source`, which
|
||||
/// the caller attaches and the logs retain.
|
||||
fn data_plane_kms_error(error: &rustfs_kms::KmsError) -> Option<(S3ErrorCode, String)> {
|
||||
use rustfs_kms::KmsError as Kms;
|
||||
|
||||
let generic = |code: S3ErrorCode| {
|
||||
let message = ApiError::error_code_to_message(&code);
|
||||
Some((code, message))
|
||||
};
|
||||
|
||||
match error {
|
||||
Kms::KeyNotFound { key_id } => Some((
|
||||
S3ErrorCode::Custom(KMS_KEY_NOT_FOUND_ERROR_CODE.into()),
|
||||
format!("KMS key not found: {key_id}"),
|
||||
)),
|
||||
Kms::KeyVersionNotFound { key_id, version } => Some((
|
||||
S3ErrorCode::Custom(KMS_KEY_NOT_FOUND_ERROR_CODE.into()),
|
||||
format!("KMS key version {version} not found for key {key_id}"),
|
||||
)),
|
||||
// The key exists but its state forbids the operation (disabled,
|
||||
// pending deletion). AWS treats an invalid key state as a request
|
||||
// error, not a server fault.
|
||||
Kms::InvalidOperation { .. } => Some((S3ErrorCode::InvalidRequest, error.to_string())),
|
||||
// A policy decision needs a human, so it must be distinguishable from
|
||||
// the transient classes an SDK retries.
|
||||
Kms::AccessDenied { .. } => generic(S3ErrorCode::AccessDenied),
|
||||
// Request-side faults: what was asked for cannot be served as asked.
|
||||
Kms::ContextMismatch { .. }
|
||||
| Kms::InvalidKey { .. }
|
||||
| Kms::ValidationError { .. }
|
||||
| Kms::UnsupportedAlgorithm { .. }
|
||||
| Kms::InvalidKeySize { .. } => Some((S3ErrorCode::InvalidRequest, error.to_string())),
|
||||
// A deployment whose KMS configuration cannot serve the request (for
|
||||
// example no key named and no default). Actionable, but the detail
|
||||
// describes the deployment, so it stays out of the response body.
|
||||
Kms::ConfigurationError { .. } => {
|
||||
Some((S3ErrorCode::InvalidRequest, "The KMS configuration cannot serve this request".to_string()))
|
||||
}
|
||||
// Transient: worth retrying, and must be counted against availability
|
||||
// rather than against the caller. `IoError` belongs here because it is
|
||||
// how a backend reports that its key store itself was unreachable —
|
||||
// rustfs/rustfs#7470 separated that from a missing key precisely so the
|
||||
// two stop looking alike, and leaving it on the 500 fallthrough would
|
||||
// erase that distinction again at the S3 boundary.
|
||||
Kms::BackendError { .. }
|
||||
| Kms::IoError { .. }
|
||||
| Kms::OperationTimedOut { .. }
|
||||
| Kms::OperationCancelled { .. }
|
||||
| Kms::CredentialsUnavailable { .. }
|
||||
| Kms::CacheError { .. } => generic(S3ErrorCode::ServiceUnavailable),
|
||||
// A permanent gap in the configured backend, never a missing resource.
|
||||
Kms::UnsupportedCapability { .. } => Some((S3ErrorCode::NotImplemented, error.to_string())),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// HTTP status of the error codes s3s cannot derive on its own.
|
||||
///
|
||||
/// s3s answers `None` for every `Custom` code, which the response layer turns
|
||||
@@ -763,6 +693,17 @@ impl From<crate::table_catalog::TableCatalogStoreError> for ApiError {
|
||||
}
|
||||
}
|
||||
|
||||
/// An SSE failure arrives already classified for the S3 data path; carry it over as is.
|
||||
impl From<SseError> for ApiError {
|
||||
fn from(err: SseError) -> Self {
|
||||
ApiError {
|
||||
code: err.code,
|
||||
message: err.message,
|
||||
source: err.source,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<StorageError> for ApiError {
|
||||
fn from(err: StorageError) -> Self {
|
||||
record_s3_lock_failure(&err);
|
||||
|
||||
+4
-2
@@ -25,7 +25,7 @@ use crate::storage_api::startup::init::{
|
||||
use crate::storage_api::startup::services::ECStore;
|
||||
#[cfg(any(feature = "ftps", feature = "webdav", feature = "sftp"))]
|
||||
use crate::storage_api::startup::services::ServerContextSlot;
|
||||
use crate::storage_api::startup::sse::log_sse_kms_key_policy_mode;
|
||||
use crate::storage_api::startup::sse::init_sse_startup;
|
||||
use crate::{admin, config, startup_runtime_sources, version};
|
||||
use rustfs_config::{
|
||||
DEFAULT_BUFFER_MAX_SIZE, DEFAULT_BUFFER_MIN_SIZE, DEFAULT_BUFFER_PROFILE, DEFAULT_BUFFER_UNKNOWN_SIZE, DEFAULT_UPDATE_CHECK,
|
||||
@@ -539,7 +539,9 @@ pub async fn init_kms_system(config: &config::Config, store: Arc<ECStore>) -> st
|
||||
// Initialize global KMS service manager (starts in NotConfigured state)
|
||||
let service_manager = startup_runtime_sources::init_kms_service_manager();
|
||||
|
||||
log_sse_kms_key_policy_mode();
|
||||
// Settles what SSE reads from the environment. Idempotent, so a second
|
||||
// embedded server in this process reports nothing new.
|
||||
init_sse_startup();
|
||||
|
||||
// A key referenced by any bucket's encryption configuration must never be
|
||||
// deleted. Register the gate before the service can start so every
|
||||
|
||||
@@ -15,13 +15,14 @@
|
||||
//! PutObject edge authorization and native frame tests against real storage.
|
||||
|
||||
use super::*;
|
||||
use crate::app::RequestHead;
|
||||
use crate::runtime_sources::ServerContextSlot;
|
||||
use crate::storage_api::server::http::access::test_support::{
|
||||
AuthorizationRequest, BucketOperations as _, CompletePart, DeleteBucketOptions, MakeBucketOptions, MultipartOperations as _,
|
||||
ObjectIO as _, ObjectOperations as _, ObjectOptions, ReqInfo, S3Request, get_bucket_metadata, set_bucket_metadata,
|
||||
ObjectIO as _, ObjectOperations as _, ObjectOptions, ReqInfo, get_bucket_metadata, set_bucket_metadata,
|
||||
};
|
||||
use bytes::Bytes;
|
||||
use http::{HeaderMap, HeaderValue, Method};
|
||||
use http::{Extensions, HeaderMap, HeaderValue, Method, Uri};
|
||||
use rustfs_gateway::{Limits, MetaView, SseConfig, TargetKind, TransportSecurity, WireRequest};
|
||||
use rustfs_gateway_stream::{ByteStream, PayloadCaps, PayloadRead, PayloadStream, StreamError, TrailingHeaders};
|
||||
use serial_test::serial;
|
||||
@@ -74,11 +75,20 @@ async fn set_policy(bucket: &str, statement: serde_json::Value) {
|
||||
}
|
||||
|
||||
fn envelope(server: &Arc<ServerContextSlot>, headers: HeaderMap) -> RequestEnvelope {
|
||||
let mut legacy = build_request((), Method::PUT);
|
||||
legacy.extensions.insert(Arc::clone(server));
|
||||
legacy.extensions.insert(ReqInfo::default());
|
||||
legacy.headers = headers;
|
||||
RequestEnvelope::from_s3s(&legacy)
|
||||
let mut extensions = Extensions::new();
|
||||
extensions.insert(Arc::clone(server));
|
||||
extensions.insert(ReqInfo::default());
|
||||
RequestEnvelope::from_parts(
|
||||
RequestHead {
|
||||
method: Method::PUT,
|
||||
uri: Uri::from_static("/"),
|
||||
headers,
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
extensions,
|
||||
)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
@@ -375,20 +385,6 @@ async fn native_put_frames_reach_checksum_validation_and_storage() {
|
||||
}
|
||||
}
|
||||
|
||||
fn build_request<T>(input: T, method: Method) -> S3Request<T> {
|
||||
S3Request {
|
||||
input,
|
||||
method,
|
||||
uri: http::Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
extensions: http::Extensions::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
trailing_headers: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[serial]
|
||||
async fn put_source_version_selects_versioned_read_permission() {
|
||||
@@ -397,16 +393,26 @@ async fn put_source_version_selects_versioned_read_permission() {
|
||||
for (read, allowed) in [("s3:GetObject", false), ("s3:GetObjectVersion", true)] {
|
||||
let (server, bucket) = fixture(&["s3:PutObject", read, "s3:ReplicateObject"]).await;
|
||||
let mut headers = HeaderMap::new();
|
||||
let mut legacy = build_request((), Method::PUT);
|
||||
legacy.extensions.insert(Arc::clone(&server));
|
||||
legacy.extensions.insert(ReqInfo::default());
|
||||
if query {
|
||||
legacy.uri = format!("/?versionId={VERSION}").parse().unwrap();
|
||||
let uri = if query {
|
||||
format!("/?versionId={VERSION}").parse().unwrap()
|
||||
} else {
|
||||
headers.insert("x-minio-source-version-id", HeaderValue::from_static(VERSION));
|
||||
}
|
||||
legacy.headers = headers;
|
||||
let mut envelope = RequestEnvelope::from_s3s(&legacy);
|
||||
Uri::from_static("/")
|
||||
};
|
||||
let mut extensions = Extensions::new();
|
||||
extensions.insert(Arc::clone(&server));
|
||||
extensions.insert(ReqInfo::default());
|
||||
let mut envelope = RequestEnvelope::from_parts(
|
||||
RequestHead {
|
||||
method: Method::PUT,
|
||||
uri,
|
||||
headers,
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
extensions,
|
||||
);
|
||||
let req = request(dto::PutObjectInput {
|
||||
bucket: rustfs_gateway_types::BucketName::new(bucket).unwrap(),
|
||||
key: rustfs_gateway_types::ObjectKey::new("allowed").unwrap(),
|
||||
|
||||
@@ -12,7 +12,9 @@ Applies to `rustfs/src/storage/`.
|
||||
|
||||
- Never log plaintext customer keys, decrypted key material, or sensitive SSE request payloads.
|
||||
- Keep SSE behavior aligned with KMS and admin handler integrations.
|
||||
- SSE key resolution lives in `crates/sse/`; `sse.rs` here only binds it to the running server (`RustfsSseHost`) and translates across the storage-engine boundary. Put new SSE logic in the crate unless it needs ecstore, IAM, or request types.
|
||||
- Coordinate related changes with:
|
||||
- `crates/sse/`
|
||||
- `crates/kms/`
|
||||
- `rustfs/src/admin/handlers/kms*.rs`
|
||||
- `crates/ecstore/`
|
||||
|
||||
@@ -1,22 +0,0 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Authorization shapes that only migration batch A2 (rustfs/backlog#2765) uses: bucket policy, policy status, versioning, notification and ACL.
|
||||
//!
|
||||
//! Responsible for: the owned authorization function of each such operation, generic over
|
||||
//! `AuthorizationRequest`, so the legacy `S3Access` hook and `Served::authorize` call the same code.
|
||||
//! Not responsible for: shapes more than one batch shares (those stay in `storage/access.rs`), the
|
||||
//! policy evaluation itself (`authorize_request`), or the operation's use case.
|
||||
//! Upstream: the legacy hook in `storage/access.rs` and the batch's `server/gateway_handlers/bucket_access.rs`.
|
||||
//! Downstream: the shared shapes in `storage/access.rs`.
|
||||
@@ -1,22 +0,0 @@
|
||||
// Copyright 2024 RustFS Team
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Authorization shapes that only migration batch A1 (rustfs/backlog#2765) uses: bucket CORS, tagging, public access block and encryption.
|
||||
//!
|
||||
//! Responsible for: the owned authorization function of each such operation, generic over
|
||||
//! `AuthorizationRequest`, so the legacy `S3Access` hook and `Served::authorize` call the same code.
|
||||
//! Not responsible for: shapes more than one batch shares (those stay in `storage/access.rs`), the
|
||||
//! policy evaluation itself (`authorize_request`), or the operation's use case.
|
||||
//! Upstream: the legacy hook in `storage/access.rs` and the batch's `server/gateway_handlers/bucket_configs.rs`.
|
||||
//! Downstream: the shared shapes in `storage/access.rs`.
|
||||
@@ -15,8 +15,6 @@
|
||||
//! The authorization shapes one migration batch owns (rustfs/backlog#2765), one file per batch so
|
||||
//! parallel batches edit disjoint files. Shapes several batches share stay in `storage/access.rs`.
|
||||
|
||||
pub(crate) mod bucket_access;
|
||||
pub(crate) mod bucket_configs;
|
||||
pub(crate) mod bucket_core;
|
||||
pub(crate) mod bucket_replication_lifecycle;
|
||||
pub(crate) mod listing_multipart;
|
||||
|
||||
@@ -1954,6 +1954,7 @@ mod tests {
|
||||
// Drive the real data path: the principal built from this request is
|
||||
// what carries the audit slot into the SSE code.
|
||||
let metadata = unreadable_sse_kms_metadata();
|
||||
use crate::storage::sse::SseKmsPrincipalExt as _;
|
||||
let envelope = crate::app::RequestEnvelope::from_s3s(&req);
|
||||
let principal =
|
||||
crate::storage::sse::SseKmsPrincipal::from_request(&envelope).expect("authenticated request has a principal");
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user