BREAKING CHANGE(core): rebrand from smarts3 to smartstorage

- Package renamed from @push.rocks/smarts3 to @push.rocks/smartstorage
- Class: Smarts3 → SmartStorage, Interface: ISmarts3Config → ISmartStorageConfig
- Method: getS3Descriptor → getStorageDescriptor
- Rust binary: rusts3 → ruststorage
- Rust types: S3Error→StorageError, S3Action→StorageAction, S3Config→SmartStorageConfig, S3Server→StorageServer
- On-disk file extension: ._S3_object → ._storage_object
- Default credentials: S3RVER → STORAGE
- All internal S3 branding removed; AWS S3 protocol compatibility fully maintained

rust/src/auth.rs

@@ -4,8 +4,8 @@ use hyper::Request;
 use sha2::{Digest, Sha256};
 use std::collections::HashMap;
 
-use crate::config::{Credential, S3Config};
-use crate::s3_error::S3Error;
+use crate::config::{Credential, SmartStorageConfig};
+use crate::error::StorageError;
 
 type HmacSha256 = Hmac<Sha256>;
 
@@ -27,8 +27,8 @@ struct SigV4Header {
 /// Verify the request's SigV4 signature. Returns the caller identity on success.
 pub fn verify_request(
     req: &Request<Incoming>,
-    config: &S3Config,
-) -> Result<AuthenticatedIdentity, S3Error> {
+    config: &SmartStorageConfig,
+) -> Result<AuthenticatedIdentity, StorageError> {
     let auth_header = req
         .headers()
         .get("authorization")
@@ -37,18 +37,18 @@ pub fn verify_request(
 
     // Reject SigV2
     if auth_header.starts_with("AWS ") {
-        return Err(S3Error::authorization_header_malformed());
+        return Err(StorageError::authorization_header_malformed());
     }
 
     if !auth_header.starts_with("AWS4-HMAC-SHA256") {
-        return Err(S3Error::authorization_header_malformed());
+        return Err(StorageError::authorization_header_malformed());
     }
 
     let parsed = parse_auth_header(auth_header)?;
 
     // Look up credential
     let credential = find_credential(&parsed.access_key_id, config)
-        .ok_or_else(S3Error::invalid_access_key_id)?;
+        .ok_or_else(StorageError::invalid_access_key_id)?;
 
     // Get x-amz-date
     let amz_date = req
@@ -60,7 +60,7 @@ pub fn verify_request(
                 .get("date")
                 .and_then(|v| v.to_str().ok())
         })
-        .ok_or_else(|| S3Error::missing_security_header("Missing x-amz-date header"))?;
+        .ok_or_else(|| StorageError::missing_security_header("Missing x-amz-date header"))?;
 
     // Enforce 15-min clock skew
     check_clock_skew(amz_date)?;
@@ -99,7 +99,7 @@ pub fn verify_request(
 
     // Constant-time comparison
     if !constant_time_eq(computed_hex.as_bytes(), parsed.signature.as_bytes()) {
-        return Err(S3Error::signature_does_not_match());
+        return Err(StorageError::signature_does_not_match());
     }
 
     Ok(AuthenticatedIdentity {
@@ -108,11 +108,11 @@ pub fn verify_request(
 }
 
 /// Parse the Authorization header into its components.
-fn parse_auth_header(header: &str) -> Result<SigV4Header, S3Error> {
+fn parse_auth_header(header: &str) -> Result<SigV4Header, StorageError> {
     // Format: AWS4-HMAC-SHA256 Credential=KEY/YYYYMMDD/region/s3/aws4_request, SignedHeaders=h1;h2, Signature=hex
     let after_algo = header
         .strip_prefix("AWS4-HMAC-SHA256")
-        .ok_or_else(S3Error::authorization_header_malformed)?
+        .ok_or_else(StorageError::authorization_header_malformed)?
         .trim();
 
     let mut credential_str = None;
@@ -131,17 +131,17 @@ fn parse_auth_header(header: &str) -> Result<SigV4Header, S3Error> {
     }
 
     let credential_str = credential_str
-        .ok_or_else(S3Error::authorization_header_malformed)?;
+        .ok_or_else(StorageError::authorization_header_malformed)?;
     let signed_headers_str = signed_headers_str
-        .ok_or_else(S3Error::authorization_header_malformed)?;
+        .ok_or_else(StorageError::authorization_header_malformed)?;
     let signature = signature_str
-        .ok_or_else(S3Error::authorization_header_malformed)?
+        .ok_or_else(StorageError::authorization_header_malformed)?
         .to_string();
 
     // Parse credential: KEY/YYYYMMDD/region/s3/aws4_request
     let cred_parts: Vec<&str> = credential_str.splitn(5, '/').collect();
     if cred_parts.len() < 5 {
-        return Err(S3Error::authorization_header_malformed());
+        return Err(StorageError::authorization_header_malformed());
     }
 
     let access_key_id = cred_parts[0].to_string();
@@ -163,7 +163,7 @@ fn parse_auth_header(header: &str) -> Result<SigV4Header, S3Error> {
 }
 
 /// Find a credential by access key ID.
-fn find_credential<'a>(access_key_id: &str, config: &'a S3Config) -> Option<&'a Credential> {
+fn find_credential<'a>(access_key_id: &str, config: &'a SmartStorageConfig) -> Option<&'a Credential> {
     config
         .auth
         .credentials
@@ -172,17 +172,17 @@ fn find_credential<'a>(access_key_id: &str, config: &'a S3Config) -> Option<&'a
 }
 
 /// Check clock skew (15 minutes max).
-fn check_clock_skew(amz_date: &str) -> Result<(), S3Error> {
+fn check_clock_skew(amz_date: &str) -> Result<(), StorageError> {
     // Parse ISO 8601 basic format: YYYYMMDDTHHMMSSZ
     let parsed = chrono::NaiveDateTime::parse_from_str(amz_date, "%Y%m%dT%H%M%SZ")
-        .map_err(|_| S3Error::authorization_header_malformed())?;
+        .map_err(|_| StorageError::authorization_header_malformed())?;
 
     let request_time = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(parsed, chrono::Utc);
     let now = chrono::Utc::now();
     let diff = (now - request_time).num_seconds().unsigned_abs();
 
     if diff > 15 * 60 {
-        return Err(S3Error::request_time_too_skewed());
+        return Err(StorageError::request_time_too_skewed());
     }
 
     Ok(())