Starting to be S3 compatible

2026-08-06 21:03:13 +00:00 · 2020-04-24 17:46:52 +00:00
parent d8f5e643bc
commit f2e05986c4
8 changed files with 543 additions and 38 deletions
@@ -17,6 +17,10 @@ garage_core = { path = "../core" }
 bytes = "0.4"
 hex = "0.3"
 log = "0.4"
+chrono = "0.4"
+sha2 = "0.8"
+hmac = "0.7"
+crypto-mac = "0.7"

 futures = "0.3"
 futures-util = "0.3"
@@ -24,5 +28,7 @@ tokio = { version = "0.2", default-features = false, features = ["rt-core", "rt-

 http = "0.2"
 hyper = "0.13"
+url = "2.1"
+httpdate = "0.3"


@@ -1,6 +1,7 @@
 use std::collections::VecDeque;
 use std::net::SocketAddr;
 use std::sync::Arc;
+use std::time::{Duration, UNIX_EPOCH};

 use futures::future::Future;
 use futures::stream::*;
@@ -21,6 +22,7 @@ use garage_core::object_table::*;
 use garage_core::version_table::*;

 use crate::http_util::*;
+use crate::signature::check_signature;

 type BodyType = Box<dyn HttpBody<Data = Bytes, Error = Error> + Send + Unpin>;

@@ -28,7 +30,7 @@ pub async fn run_api_server(
 	garage: Arc<Garage>,
 	shutdown_signal: impl Future<Output = ()>,
 ) -> Result<(), Error> {
-	let addr = &garage.config.api_bind_addr;
+	let addr = &garage.config.s3_api.api_bind_addr;

 	let service = make_service_fn(|conn: &AddrStream| {
 		let garage = garage.clone();
@@ -55,12 +57,18 @@ async fn handler(
 	req: Request<Body>,
 	addr: SocketAddr,
 ) -> Result<Response<BodyType>, Error> {
-	match handler_inner(garage, req, addr).await {
-		Ok(x) => Ok(x),
+	info!("{} {} {}", addr, req.method(), req.uri());
+	debug!("{:?}", req);
+	match handler_inner(garage, req).await {
+		Ok(x) => {
+			debug!("{} {:?}", x.status(), x.headers());
+			Ok(x)
+		}
 		Err(e) => {
 			let body: BodyType = Box::new(BytesBody::from(format!("{}\n", e)));
 			let mut http_error = Response::new(body);
 			*http_error.status_mut() = e.http_status_code();
+			warn!("Response: error {}, {}", e.http_status_code(), e);
 			Ok(http_error)
 		}
 	}
@@ -69,38 +77,59 @@ async fn handler(
 async fn handler_inner(
 	garage: Arc<Garage>,
 	req: Request<Body>,
-	addr: SocketAddr,
 ) -> Result<Response<BodyType>, Error> {
-	info!("{} {} {}", addr, req.method(), req.uri());
-
-	let bucket = req
-		.headers()
-		.get(hyper::header::HOST)
-		.map(|x| x.to_str().map_err(Error::from))
-		.unwrap_or(Err(Error::BadRequest(format!("Host: header missing"))))?
-		.to_lowercase();
-	let key = req.uri().path().to_string();
-
-	match req.method() {
-		&Method::GET => Ok(handle_get(garage, &bucket, &key).await?),
-		&Method::PUT => {
-			let mime_type = req
-				.headers()
-				.get(hyper::header::CONTENT_TYPE)
-				.map(|x| x.to_str())
-				.unwrap_or(Ok("blob"))?
-				.to_string();
-			let version_uuid =
-				handle_put(garage, &mime_type, &bucket, &key, req.into_body()).await?;
-			let response = format!("{}\n", hex::encode(version_uuid,));
-			Ok(Response::new(Box::new(BytesBody::from(response))))
+	let path = req.uri().path().to_string();
+	let path = path.trim_start_matches('/');
+	let (bucket, key) = match path.find('/') {
+		Some(i) => {
+			let (bucket, key) = path.split_at(i);
+			(bucket, Some(key))
 		}
-		&Method::DELETE => {
-			let version_uuid = handle_delete(garage, &bucket, &key).await?;
-			let response = format!("{}\n", hex::encode(version_uuid,));
-			Ok(Response::new(Box::new(BytesBody::from(response))))
+		None => (path, None),
+	};
+	if bucket.len() == 0 {
+		return Err(Error::Forbidden(format!(
+			"Operations on buckets not allowed"
+		)));
+	}
+
+	let api_key = check_signature(&garage, &req).await?;
+	let allowed = match req.method() {
+		&Method::HEAD | &Method::GET => api_key.allow_read(&bucket),
+		_ => api_key.allow_write(&bucket),
+	};
+	if !allowed {
+		return Err(Error::Forbidden(format!(
+			"Operation is not allowed for this key."
+		)));
+	}
+
+	if let Some(key) = key {
+		match req.method() {
+			&Method::HEAD => Ok(handle_head(garage, &bucket, &key).await?),
+			&Method::GET => Ok(handle_get(garage, &bucket, &key).await?),
+			&Method::PUT => {
+				let mime_type = req
+					.headers()
+					.get(hyper::header::CONTENT_TYPE)
+					.map(|x| x.to_str())
+					.unwrap_or(Ok("blob"))?
+					.to_string();
+				let version_uuid =
+					handle_put(garage, &mime_type, &bucket, &key, req.into_body()).await?;
+				let response = format!("{}\n", hex::encode(version_uuid,));
+				Ok(Response::new(Box::new(BytesBody::from(response))))
+			}
+			&Method::DELETE => {
+				let version_uuid = handle_delete(garage, &bucket, &key).await?;
+				let response = format!("{}\n", hex::encode(version_uuid,));
+				Ok(Response::new(Box::new(BytesBody::from(response))))
+			}
+			_ => Err(Error::BadRequest(format!("Invalid method"))),
 		}
-		_ => Err(Error::BadRequest(format!("Invalid method"))),
+	} else {
+		// TODO: listing buckets
+		Err(Error::Forbidden("Unimplemented".into()))
 	}
 }

@@ -280,6 +309,49 @@ async fn handle_delete(garage: Arc<Garage>, bucket: &str, key: &str) -> Result<U
 	return Ok(version_uuid);
 }

+fn object_headers(version: &ObjectVersion) -> http::response::Builder {
+	let date = UNIX_EPOCH + Duration::from_millis(version.timestamp);
+	let date_str = httpdate::fmt_http_date(date);
+
+	Response::builder()
+		.header("Content-Type", version.mime_type.to_string())
+		.header("Content-Length", format!("{}", version.size))
+		.header("Last-Modified", date_str)
+}
+
+async fn handle_head(
+	garage: Arc<Garage>,
+	bucket: &str,
+	key: &str,
+) -> Result<Response<BodyType>, Error> {
+	let object = match garage
+		.object_table
+		.get(&bucket.to_string(), &key.to_string())
+		.await?
+	{
+		None => return Err(Error::NotFound),
+		Some(o) => o,
+	};
+
+	let version = match object
+		.versions()
+		.iter()
+		.rev()
+		.filter(|v| v.is_complete && v.data != ObjectVersionData::DeleteMarker)
+		.next()
+	{
+		Some(v) => v,
+		None => return Err(Error::NotFound),
+	};
+
+	let body: BodyType = Box::new(BytesBody::from(vec![]));
+	let response = object_headers(&version)
+		.status(StatusCode::OK)
+		.body(body)
+		.unwrap();
+	Ok(response)
+}
+
 async fn handle_get(
 	garage: Arc<Garage>,
 	bucket: &str,
@@ -305,9 +377,7 @@ async fn handle_get(
 		None => return Err(Error::NotFound),
 	};

-	let resp_builder = Response::builder()
-		.header("Content-Type", last_v.mime_type.to_string())
-		.status(StatusCode::OK);
+	let resp_builder = object_headers(&last_v).status(StatusCode::OK);

 	match &last_v.data {
 		ObjectVersionData::DeleteMarker => Err(Error::NotFound),
@@ -3,3 +3,4 @@ extern crate log;

 pub mod api_server;
 pub mod http_util;
+pub mod signature;
@@ -0,0 +1,307 @@
+use std::collections::HashMap;
+
+use chrono::{DateTime, Duration, NaiveDateTime, Utc};
+use hmac::{Hmac, Mac};
+use hyper::{Body, Method, Request};
+use sha2::{Digest, Sha256};
+
+use garage_table::*;
+use garage_util::error::Error;
+
+use garage_core::garage::Garage;
+use garage_core::key_table::*;
+
+const SHORT_DATE: &str = "%Y%m%d";
+const LONG_DATETIME: &str = "%Y%m%dT%H%M%SZ";
+
+type HmacSha256 = Hmac<Sha256>;
+
+pub async fn check_signature(garage: &Garage, request: &Request<Body>) -> Result<Key, Error> {
+	let mut headers = HashMap::new();
+	for (key, val) in request.headers() {
+		headers.insert(key.to_string(), val.to_str()?.to_string());
+	}
+	if let Some(query) = request.uri().query() {
+		let query_pairs = url::form_urlencoded::parse(query.as_bytes());
+		for (key, val) in query_pairs {
+			headers.insert(key.to_lowercase(), val.to_string());
+		}
+	}
+
+	let authorization = if let Some(authorization) = headers.get("authorization") {
+		parse_authorization(authorization, &headers)?
+	} else {
+		parse_query_authorization(&headers)?
+	};
+
+	let date = headers
+		.get("x-amz-date")
+		.ok_or(Error::BadRequest("Missing X-Amz-Date field".into()))?;
+	let date: NaiveDateTime = NaiveDateTime::parse_from_str(date, LONG_DATETIME)
+		.map_err(|e| Error::BadRequest(format!("Invalid date: {}", e)))?
+		.into();
+	let date: DateTime<Utc> = DateTime::from_utc(date, Utc);
+
+	if Utc::now() - date > Duration::hours(24) {
+		return Err(Error::BadRequest(format!("Date is too old")));
+	}
+
+	let scope = format!(
+		"{}/{}/s3/aws4_request",
+		date.format(SHORT_DATE),
+		garage.config.s3_api.s3_region
+	);
+	if authorization.scope != scope {
+		return Err(Error::BadRequest(format!(
+			"Invalid scope in authorization field, expected: {}",
+			scope
+		)));
+	}
+
+	let key = garage
+		.key_table
+		.get(&EmptyKey, &authorization.key_id)
+		.await?
+		.filter(|k| !k.deleted)
+		.ok_or(Error::Forbidden(format!(
+			"No such key: {}",
+			authorization.key_id
+		)))?;
+
+	let canonical_request = canonical_request(
+		request.method(),
+		&request.uri().path().to_string(),
+		&canonical_query_string(&request.uri()),
+		&headers,
+		&authorization.signed_headers,
+		&authorization.content_sha256,
+	);
+	let string_to_sign = string_to_sign(&date, &scope, &canonical_request);
+
+	let mut hmac = signing_hmac(
+		&date,
+		&key.secret_key,
+		&garage.config.s3_api.s3_region,
+		"s3",
+	)
+	.map_err(|e| Error::Message(format!("Unable to build signing HMAC: {}", e)))?;
+	hmac.input(string_to_sign.as_bytes());
+	let signature = hex::encode(hmac.result().code());
+
+	if authorization.signature != signature {
+		return Err(Error::Forbidden(format!("Invalid signature")));
+	}
+
+	Ok(key)
+}
+
+struct Authorization {
+	key_id: String,
+	scope: String,
+	signed_headers: String,
+	signature: String,
+	content_sha256: String,
+}
+
+fn parse_authorization(
+	authorization: &str,
+	headers: &HashMap<String, String>,
+) -> Result<Authorization, Error> {
+	let first_space = authorization
+		.find(' ')
+		.ok_or(Error::BadRequest("Authorization field too short".into()))?;
+	let (auth_kind, rest) = authorization.split_at(first_space);
+
+	if auth_kind != "AWS4-HMAC-SHA256" {
+		return Err(Error::BadRequest("Unsupported authorization method".into()));
+	}
+
+	let mut auth_params = HashMap::new();
+	for auth_part in rest.split(',') {
+		let auth_part = auth_part.trim();
+		let eq = auth_part.find('=').ok_or(Error::BadRequest(format!(
+			"Missing =value in authorization field {}",
+			auth_part
+		)))?;
+		let (key, value) = auth_part.split_at(eq);
+		auth_params.insert(key.to_string(), value.trim_start_matches('=').to_string());
+	}
+
+	let cred = auth_params
+		.get("Credential")
+		.ok_or(Error::BadRequest(format!(
+			"Could not find Credential in Authorization field"
+		)))?;
+	let (key_id, scope) = parse_credential(cred)?;
+
+	let content_sha256 = headers
+		.get("x-amz-content-sha256")
+		.ok_or(Error::BadRequest(
+			"Missing X-Amz-Content-Sha256 field".into(),
+		))?;
+
+	let auth = Authorization {
+		key_id,
+		scope,
+		signed_headers: auth_params
+			.get("SignedHeaders")
+			.ok_or(Error::BadRequest(format!(
+				"Could not find SignedHeaders in Authorization field"
+			)))?
+			.to_string(),
+		signature: auth_params
+			.get("Signature")
+			.ok_or(Error::BadRequest(format!(
+				"Could not find Signature in Authorization field"
+			)))?
+			.to_string(),
+		content_sha256: content_sha256.to_string(),
+	};
+	Ok(auth)
+}
+
+fn parse_query_authorization(headers: &HashMap<String, String>) -> Result<Authorization, Error> {
+	let algo = headers
+		.get("x-amz-algorithm")
+		.ok_or(Error::BadRequest(format!(
+			"X-Amz-Algorithm not found in query parameters"
+		)))?;
+	if algo != "AWS4-HMAC-SHA256" {
+		return Err(Error::BadRequest(format!(
+			"Unsupported authorization method"
+		)));
+	}
+
+	let cred = headers
+		.get("x-amz-credential")
+		.ok_or(Error::BadRequest(format!(
+			"X-Amz-Credential not found in query parameters"
+		)))?;
+	let (key_id, scope) = parse_credential(cred)?;
+	let signed_headers = headers
+		.get("x-amz-signedheaders")
+		.ok_or(Error::BadRequest(format!(
+			"X-Amz-SignedHeaders not found in query parameters"
+		)))?;
+	let signature = headers
+		.get("x-amz-signature")
+		.ok_or(Error::BadRequest(format!(
+			"X-Amz-Signature not found in query parameters"
+		)))?;
+
+	Ok(Authorization {
+		key_id,
+		scope,
+		signed_headers: signed_headers.to_string(),
+		signature: signature.to_string(),
+		content_sha256: "UNSIGNED-PAYLOAD".to_string(),
+	})
+}
+
+fn parse_credential(cred: &str) -> Result<(String, String), Error> {
+	let first_slash = cred.find('/').ok_or(Error::BadRequest(format!(
+		"Credentials does not contain / in authorization field"
+	)))?;
+	let (key_id, scope) = cred.split_at(first_slash);
+	Ok((
+		key_id.to_string(),
+		scope.trim_start_matches('/').to_string(),
+	))
+}
+
+fn string_to_sign(datetime: &DateTime<Utc>, scope_string: &str, canonical_req: &str) -> String {
+	let mut hasher = Sha256::default();
+	hasher.input(canonical_req.as_bytes());
+	[
+		"AWS4-HMAC-SHA256",
+		&datetime.format(LONG_DATETIME).to_string(),
+		scope_string,
+		&hex::encode(hasher.result().as_slice()),
+	]
+	.join("\n")
+}
+
+fn signing_hmac(
+	datetime: &DateTime<Utc>,
+	secret_key: &str,
+	region: &str,
+	service: &str,
+) -> Result<HmacSha256, crypto_mac::InvalidKeyLength> {
+	let secret = String::from("AWS4") + secret_key;
+	let mut date_hmac = HmacSha256::new_varkey(secret.as_bytes())?;
+	date_hmac.input(datetime.format(SHORT_DATE).to_string().as_bytes());
+	let mut region_hmac = HmacSha256::new_varkey(&date_hmac.result().code())?;
+	region_hmac.input(region.as_bytes());
+	let mut service_hmac = HmacSha256::new_varkey(&region_hmac.result().code())?;
+	service_hmac.input(service.as_bytes());
+	let mut signing_hmac = HmacSha256::new_varkey(&service_hmac.result().code())?;
+	signing_hmac.input(b"aws4_request");
+	let hmac = HmacSha256::new_varkey(&signing_hmac.result().code())?;
+	Ok(hmac)
+}
+
+fn canonical_request(
+	method: &Method,
+	url_path: &str,
+	canonical_query_string: &str,
+	headers: &HashMap<String, String>,
+	signed_headers: &str,
+	content_sha256: &str,
+) -> String {
+	[
+		method.as_str(),
+		url_path,
+		canonical_query_string,
+		&canonical_header_string(&headers, signed_headers),
+		"",
+		signed_headers,
+		content_sha256,
+	]
+	.join("\n")
+}
+
+fn canonical_header_string(headers: &HashMap<String, String>, signed_headers: &str) -> String {
+	let signed_headers_vec = signed_headers.split(';').collect::<Vec<_>>();
+	let mut items = headers
+		.iter()
+		.filter(|(key, _)| signed_headers_vec.contains(&key.as_str()))
+		.map(|(key, value)| key.to_lowercase() + ":" + value.trim())
+		.collect::<Vec<_>>();
+	items.sort();
+	items.join("\n")
+}
+
+fn canonical_query_string(uri: &hyper::Uri) -> String {
+	if let Some(query) = uri.query() {
+		let query_pairs = url::form_urlencoded::parse(query.as_bytes());
+		let mut items = query_pairs
+			.filter(|(key, _)| key != "X-Amz-Signature")
+			.map(|(key, value)| uri_encode(&key, true) + "=" + &uri_encode(&value, true))
+			.collect::<Vec<_>>();
+		items.sort();
+		items.join("&")
+	} else {
+		"".to_string()
+	}
+}
+
+fn uri_encode(string: &str, encode_slash: bool) -> String {
+	let mut result = String::with_capacity(string.len() * 2);
+	for c in string.chars() {
+		match c {
+			'a'..='z' | 'A'..='Z' | '0'..='9' | '_' | '-' | '~' | '.' => result.push(c),
+			'/' if encode_slash => result.push_str("%2F"),
+			'/' if !encode_slash => result.push('/'),
+			_ => {
+				result.push('%');
+				result.push_str(
+					&format!("{}", c)
+						.bytes()
+						.map(|b| format!("{:02X}", b))
+						.collect::<String>(),
+				);
+			}
+		}
+	}
+	result
+}