Zum Inhalt springen

Verwenden Sie SSE-C im Object Storage mit dem Secrets Manager

Zuletzt aktualisiert am

Generieren und speichern Sie einen Verschlüsselungsschlüssel

Abschnitt betitelt „Generieren und speichern Sie einen Verschlüsselungsschlüssel“

Erstellen Sie zunächst einen sicheren Zufallsschlüssel und den entsprechenden MD5-Hash und speichern Sie dann beide Werte im Secrets Manager.
Öffnen Sie ein Terminal und führen Sie die folgenden Befehle aus. Die Befehle generieren die Werte und schreiben sie direkt an den Secrets Manager.

  1. Erzeugen Sie einen 32-Byte-Zufallsschlüssel (256 Bit) und kodieren Sie diesen mit Base64

    Terminal-Fenster
    KEY_B64=$(openssl rand 32 | base64)
  2. Erzeugen Sie den MD5-Hash des RAW-Schlüssels und kodieren Sie diesen Hash in Base64.

    Terminal-Fenster
    KEY_MD5_B64=$(echo -n "$KEY_B64" | base64 --decode | openssl dgst -md5 -binary | base64)
  3. Key anzeigen

    Terminal-Fenster
    echo "Base64 Key: $KEY_B64"
    echo "Base64 MD5: $KEY_MD5_B64"

Installieren Sie die Anforderungen für das Python-Skript

Abschnitt betitelt „Installieren Sie die Anforderungen für das Python-Skript“

Um die erforderlichen Abhängigkeiten zu installieren, erstellen Sie eine Datei mit dem Namen „requirements.txt“ im Stammverzeichnis Ihres Projekts Verzeichnis und fügen Sie die folgenden Zeilen hinzu:

Terminal-Fenster
boto3 hvac

Führen Sie dann den folgenden Befehl in Ihrem Terminal aus:

Terminal-Fenster
pip install -r requirements.txt

Speichern Sie den in diesem Tutorial bereitgestellten Python-Code in einer Datei auf Ihrem lokalen Computer. Zum Beispiel Name die Datei ssec_secrets_manager_example.py.

Konfigurieren Sie als Nächstes das Skript entsprechend Ihrer Umgebung.

Öffnen Sie die Datei ssec_secrets_manager_example.py in einem Texteditor und aktualisieren Sie die Konfiguration Variablen oben in der Datei. Stellen Sie sicher, dass die folgenden Werte richtig eingestellt sind:

import os
import boto3
import hvac
from botocore.exceptions import ClientError
# --- CONFIGURATION ---
# Please change the following values to match your setup
S3_ENDPOINT_URL = "https://object.storage.eu01.onstackit.cloud"
# This is the name of your bucket.
S3_BUCKET_NAME = "YOUR-BUCKET-NAME"
# This is the name of the file in the object storage.
OBJECT_KEY = "my-secret-object.txt"
# This is the name of the local file that will be created and uploaded in this example.
FILE_TO_UPLOAD = "secret-upload.txt"
# This is the name of the local file where the downloaded content will be saved.
DOWNLOAD_FILE_PATH = "secret-download.txt"
# Secrets Manager configuration
# We are compatible with the Secrets Manager to HashiCorp Vault. That is why we use the official Hashicorp Python Library
# See the following Documentation for the Basics of the Secret Manager https://support.docs.stackit.cloud/display/STACKIT/Vault+CLI+Basics+of+Secrets+Manager
VAULT_ADDR = "https://prod.sm.eu01.stackit.cloud"
VAULT_MOUNT_POINT = "YOUR-SECRETS-MANAGER-MOUNT-POINT"
VAULT_SECRET_PATH = "YOUR-SECRETS-MANAGER-SECRET-PATH"
"""
Following Variables need to be set in env:
# For Secrets Manager
export VAULT_USERNAME="secret-manager-username"
export VAULT_PASSWORD="seceret-manager-password"
# We are compatible with the Object Storage to AWS S3. That is why we use the official AWS SDK for python.
# For Object Storage or save it in (e.g., ~/.aws/credentials)
export AWS_ACCESS_KEY_ID="YOUR_S3_ACCESS_KEY"
export AWS_SECRET_ACCESS_KEY="YOUR_S3_SECRET_KEY"
"""
def get_ssec_keys_from_secrets_manager(vault_addr):
"""
Connects to Secrets Manager using env variables, authenticates via user/pass,
and fetches the SSE-C keys.
"""
print("Attempting to fetch secrets from Secrets Manager")
try:
vault_user = os.environ["VAULT_USERNAME"]
vault_pass = os.environ["VAULT_PASSWORD"]
except KeyError as e:
print(f"Error: Environment variable {e} not set.")
return None, None
# Initialize the HVAC Client
client = hvac.Client(url=vault_addr)
try:
# Authenticate using User/Pass method
client.auth.userpass.login(username=vault_user, password=vault_pass)
if not client.is_authenticated():
print("Secrets Manager authentication failed.")
return None, None
print("Secrets Manager authentication successfull.")
# Read the secrets from the Secrets Manager
secret_response = client.secrets.kv.v2.read_secret_version(
path=VAULT_SECRET_PATH, mount_point=VAULT_MOUNT_POINT
)
# Extract the key Data
secret_data = secret_response["data"]["data"]
key_b64 = secret_data.get("KEY_B64")
key_md5_b64 = secret_data.get("KEY_MD5_B64")
print("Successfully fetched SSE-C keys from Secrets Manager.")
return key_b64, key_md5_b64
except Exception as e:
print(f"An error occurred while communicating with the Secrets Manager: {e}")
return None, None
def s3_put_object(s3_client, bucket, object_key, file_path, ssec_key, ssec_key_md5):
"""
Example: Uploads a file to Object Storage using SSE-C
"""
print(f"\nUploading '{file_path}' to '{bucket}/{object_key} using SSE-C...")
try:
with open(file_path, "rb") as f:
response = s3_client.put_object(
Bucket=bucket,
Key=object_key,
Body=f,
SSECustomerAlgorithm="AES256",
SSECustomerKey=ssec_key,
SSECustomerKeyMD5=ssec_key_md5,
)
print("Upload successful.")
print(f"ETag: {response.get('ETag')}")
print(f"SSE-C Algorithm: {response.get('SSECustomerAlgorithm')}")
except ClientError as e:
print(f"Error uploading object: {e}")
def s3_get_object(s3_client, bucket, object_key, download_path, ssec_key, ssec_key_md5):
"""
Example: Downloads and decrypts an object from Object Storage using SSE-C.
"""
print(f"\nDownloading '{bucket}/{object_key} to '{download_path}' using SSE-C...")
try:
response = s3_client.get_object(
Bucket=bucket,
Key=object_key,
SSECustomerAlgorithm="AES256",
SSECustomerKey=ssec_key,
SSECustomerKeyMD5=ssec_key_md5,
)
# Stream the decrypted content to a local file
with open(download_path, "wb") as f:
f.write(response["Body"].read())
print("Download successful.")
print(f"File saved to: '{download_path}'")
print(f"Content-Length: {response.get('ContentLength')} bytes")
except ClientError as e:
print(f"Error downloading object: {e}")
if __name__ == "__main__":
# 1. Fetch keys from Secret-Manager
key_b64, key_md5_b64 = get_ssec_keys_from_secrets_manager(VAULT_ADDR)
# 2. Check if we got both key values
if not key_b64 or not key_md5_b64:
print("\nCould not retrieve one or both keys from Secrets Manager. Exiting.")
else:
# 3. Create a dummy file to upload
with open(FILE_TO_UPLOAD, "w") as f:
f.write(
"This is a highly confidential message encrypted with a customer key."
)
# 4. Initialize Boto3 S3 client for Object-Storage
s3 = boto3.client("s3", endpoint_url=S3_ENDPOINT_URL)
# 5. Perform the PUT and GET operations
s3_put_object(
s3, S3_BUCKET_NAME, OBJECT_KEY, FILE_TO_UPLOAD, key_b64, key_md5_b64
)
s3_get_object(
s3, S3_BUCKET_NAME, OBJECT_KEY, DOWNLOAD_FILE_PATH, key_b64, key_md5_b64
)
# 6. Print the downloaded Data
print(f"\nVerifying content of '{DOWNLOAD_FILE_PATH}'")
with open(DOWNLOAD_FILE_PATH, "r") as f:
print(f"Content: '{f.read()}'")

Umgebungsvariablen festlegen

Exportieren Sie als Nächstes die folgenden Umgebungsvariablen in Ihr Terminal. Das Skript verwendet sie auf sichere Weise Greifen Sie auf Ihre Anmeldeinformationen zu, ohne sensible Werte hart zu codieren. Ersetzen Sie die Platzhalter durch Ihre tatsächliche Zeugnisse.

Terminal-Fenster
## For Secrets Manager
export VAULT_USERNAME='secret-manager-username'
export VAULT_PASSWORD='secret-manager-password'
# For Object Storage or save it in (e.g., \~/.aws/credentials)
export AWS_ACCESS_KEY_ID='YOUR_S3_ACCESS_KEY'
export AWS_SECRET_ACCESS_KEY='YOUR_S3_SECRET_KEY'

Führen Sie nach Abschluss der Konfiguration das Skript aus:

Terminal-Fenster
python ssec_secrets_manager_example.py

Überprüfen Sie nach Abschluss des Skripts seine Aktionen an zwei Stellen:

  • Lokaler Ordner: Es sollten zwei identische Dateien vorhanden sein:
    • secret-upload.txt: Die vom Skript erstellte und hochgeladene Originaldatei.
    • secret-download.txt: Die entschlüsselte Kopie, die vom Object Storage heruntergeladen wurde.
  • Object Storage-Bucket: Das verschlüsselte Objekt (my-secret-object.txt) wird jetzt in Ihrem gespeichert Eimer. Bestätigen Sie dies mit der AWS CLI:
Terminal-Fenster
aws s3 ls s3://<your-bucket-name>/ --endpoint-url <your-endpoint-url>

Um zu beweisen, dass das Objekt verschlüsselt ist und ohne den Schlüssel nicht darauf zugegriffen werden kann, versuchen Sie, es herunterzuladen mit standardmäßigen AWS CLI-Befehlen.
Diese Versuche scheitern, was die Wirksamkeit von SSE-C zeigt.

  1. Versuch mit AWS s3 cp (fehlschlägt)

    Der High-Level-Befehl s3 cp unterstützt die erforderlichen SSE-C-Header nicht.

    Terminal-Fenster
    ## This command will fail
    aws s3 cp s3://<your-bucket-name>/my-secret-object.txt ./download-fail-1.txt --endpoint-url <your-endpoint-url>

    Erwarteter Fehler:

    Terminal-Fenster
    An error occurred (400) when calling the HeadObject operation: Bad Request.
  2. Versuch mit AWS s3api get-object ohne Schlüssel (fehlschlägt)

    Der Low-Level-Befehl s3api schlägt auch fehl, wenn Sie den Verschlüsselungsschlüssel nicht angeben.

    Terminal-Fenster
    ## This command will fail
    aws s3api get-object --bucket <your-bucket-name> --key my-secret-object.txt ./download-fail-2.txt --endpoint-url <your-endpoint-url>

    Erwarteter Fehler:

    Terminal-Fenster
    An error occurred (InvalidRequest) when calling the GetObject operation:
    The object was stored using a form of Server Side Encryption.
    The correct parameters must be provided to retrieve the object.
  3. Download mit AWS s3api get-object und dem Verschlüsselungsschlüssel (erfolgreich)

    Um die Datei erfolgreich mit der AWS CLI herunterzuladen, müssen Sie denselben Schlüssel und MD5-Hash angeben wurden im Python-Skript verwendet.

    Exportieren Sie zunächst die Werte als Umgebungsvariablen:

    Terminal-Fenster
    export KEY_B64="YOUR-B64-KEY"
    export KEY_MD5_B64="YOUR-MD5-B64-KEY"

    Führen Sie anschließend den Befehl get-object mit den erforderlichen SSE-C-Parametern aus:

    Terminal-Fenster
    ## This command will succeed
    aws s3api get-object \
    --bucket \
    --key my-secret-object.txt \
    --sse-customer-algorithm AES256 \
    --sse-customer-key "$KEY_B64" \
    --sse-customer-key-md5 "$KEY_MD5_B64" \
    --endpoint-url \
    ./download-success.txt

Dieser Befehl lädt das Objekt herunter und entschlüsselt es. Dadurch wird bewiesen, dass der Zugriff nur dann gewährt wird, wenn das richtige Objekt vorliegt Der Verschlüsselungsschlüssel wird bereitgestellt.