הצפנת דיסקים באמצעות מפתחות הצפנה באספקת הלקוח (CSEK)

במאמר הזה נסביר איך להצפין דיסקים באמצעות מפתחות הצפנה באספקת הלקוח (CSEK).

מידע על הצפנת דיסק זמין במאמר מידע על הצפנת דיסק.

מידע על הצפנת דיסקים באמצעות מפתחות הצפנה בניהול הלקוח (CMEK) זמין במאמר הגנה על משאבים באמצעות מפתחות Cloud KMS.

כשמשתמשים במפתחות CSEK, אתם מספקים מפתחות הצפנה משלכם ו-Compute Engine משתמש במפתחות האלה כדי להגן על ה- Google-owned and Google-managed encryption keys שמשמשים להצפנה ולפענוח של הנתונים שלכם. רק משתמשים שיכולים לספק את המפתח הנכון יכולים להשתמש במשאבים שמוגנים על ידי מפתח הצפנה באספקת הלקוח (CSEK).

‫Google לא שומרת את המפתחות שלכם בשרתים שלה ולא יכולה לגשת לנתונים המוגנים שלכם אלא אם אתם מספקים את המפתח. זה גם אומר שאם תשכחו או תאבדו את המפתח, ל-Google לא תהיה אפשרות לשחזר את המפתח או לשחזר נתונים שהוצפנו באמצעות המפתח שאבד.

כשמוחקים נפח של Persistent Disk, ‏ Google משליכה את מפתחות ההצפנה, וכך אי אפשר לאחזר את הנתונים. התהליך הזה הוא בלתי הפיך.

לפני שמתחילים

תפקידים והרשאות נדרשים

כדי לקבל את ההרשאות שדרושות ליצירת תמונות מצב, תמונות ודיסקים מוצפנים באמצעות CSEK, צריך לבקש מהאדמין להקצות לכם את תפקידי ה-IAM הבאים בפרויקט:

להסבר על מתן תפקידים, ראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.

התפקידים המוגדרים מראש האלה מכילים את ההרשאות שנדרשות ליצירת קובצי snapshot, תמונות ודיסקים מוצפנים באמצעות CSEK. כדי לראות בדיוק אילו הרשאות נדרשות, אפשר להרחיב את הקטע ההרשאות הנדרשות:

ההרשאות הנדרשות

כדי ליצור תמונות מצב, תמונות ודיסקים מוצפנים באמצעות CSEK, צריך את ההרשאות הבאות:

  • כדי ליצור קובץ snapshot של דיסק:
    • compute.snapshots.create בפרויקט
    • compute.disks.createSnapshot בדיסק
  • כדי ליצור תמונה:
    • compute.images.create בפרויקט
    • compute.disks.useReadOnly בדיסק
  • כדי ליצור דיסק מ-snapshot רגיל:
    • ‫compute.disks.create בפרויקט היעד של הדיסק החדש
    • compute.snapshots.useReadOnly בתמונת המצב
  • כדי ליצור דיסק מתמונה:
    • compute.disks.create בפרויקט היעד של הדיסק החדש
    • compute.images.useReadOnly בתמונה
  • כדי ליצור דיסק מקובץ snapshot מיידי:
    • compute.disks.create בפרויקט היעד של הדיסק החדש
    • ‫compute.instantSnapshots.useReadOnly ב-instant snapshot של המקור

יכול להיות שתקבלו את ההרשאות האלה באמצעות תפקידים בהתאמה אישית או תפקידים מוגדרים מראש אחרים.

הגבלות

במקרה של CSEK, חלות ההגבלות הבאות:

הגבלות כלליות

הזמינות של מפתחות הצפנה באספקת הלקוח (CSEK) תלויה במיקום של חשבון החיוב, ולא במיקום של המשאב.

מפתחות הצפנה באספקת הלקוח (CSEK) לא זמינים בחשבונות לחיוב שנמצאים במדינות הבאות:

  • ברזיל
  • הודו

מגבלות טכניות

  • אפשר להצפין רק דיסקים קבועים חדשים באמצעות מפתח משלכם. אי אפשר להצפין דיסקים קיימים של Persistent Disk באמצעות מפתח משלכם.

  • אי אפשר להשתמש במפתחות משלכם עם דיסקים של SSD מקומי כי דיסקים של SSD מקומי משתמשים ב- Google-owned and Google-managed encryption keys. המפתחות נמחקים כשהמכונה הווירטואלית מסיימת את הפעולה.

  • ב-Compute Engine לא מאוחסנים מפתחות הצפנה עם תבניות של הגדרות מכונה, לכן צריך לאחסן את המפתחות שלכם ב-KMS כדי להצפין דיסקים בקבוצת מופעי מכונה מנוהלים.

  • אי אפשר להשעות מופעים שמצורפים אליהם דיסקים שמוגנים באמצעות CSEK.

מפרטים

בקטע הזה מתוארים מפרט ההצפנה והפורמט של CSEK.

הצפנה

‫Compute Engine משתמש במפתח ההצפנה שלכם כדי להגן על מפתחות ההצפנה של Google באמצעות הצפנת AES-256.

פורמט המפתח הנדרש

אתם צריכים ליצור את המפתח ולנהל אותו. אתם צריכים לספק ל-Compute Engine מפתח שהוא מחרוזת של 256 ביט בקידוד Base64 סטנדרטי בתקן RFC 4648.

זוהי דוגמה למפתח בקידוד Base64 שנוצר באמצעות המחרוזת Hello from Google Cloud Platform

SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0=

אפשר ליצור אותו באמצעות הסקריפט הבא:

read -sp "String:" ; \
    [[ ${#REPLY} == 32 ]] && \
        echo "$(echo -n "$REPLY" | base64)" || \
        (>&2 echo -e "\nERROR:Wrong Size"; false)

גלישת מפתח RSA

בנוסף לקידוד המפתח ב-base64, אפשר גם לעטוף את המפתח באמצעות אישור של מפתח ציבורי של RSA שסופק על ידי Google, לקודד את המפתח ב-base64 ואז להשתמש במפתח הזה בבקשות.

אריזת RSA היא תהליך שבו משתמשים במפתח ציבורי כדי להצפין את הנתונים. אחרי שהנתונים מוצפנים באמצעות המפתח הציבורי, אפשר לפענח אותם רק באמצעות המפתח הפרטי המתאים. במקרה הזה, המפתח הפרטי ידוע רק לשירותים של Google Cloud . כשעוטפים את המפתח באמצעות אישור RSA, מוודאים שרק שירותי Google Cloud יכולים לפתוח את המפתח ולהשתמש בו כדי להגן על הנתונים.

מידע נוסף זמין במאמר הצפנת RSA.

כדי ליצור מפתח שעטוף ב-RSA ל-Compute Engine:

  1. עוטפים את המפתח באמצעות המפתח הציבורי שמופיע באישור שמנוהל על ידי Compute Engine. חשוב להשתמש ב-OAEP padding ולא ב-PKCS #1 v1.5 padding כדי לעטוף את המפתח.
  2. מקודדים את המפתח שעטוף ב-RSA באמצעות קידוד base64 רגיל.

מורידים את האישור הציבורי שמנוהל על ידי Compute Engine מהכתובת:

https://cloud-certs.storage.googleapis.com/google-cloud-csek-ingress.pem

יש הרבה דרכים ליצור מפתח ולעטוף אותו ב-RSA. השתמשו בשיטה שאתם מכירים. בהמשך מופיעות שתי דוגמאות לשימוש ב-RSA כדי לעטוף את המפתח:

דוגמה 1

בהוראות הבאות משתמשים בכלי שורת הפקודה openssl כדי לעטוף ולקודד מפתח ב-RSA.

  1. אופציונלי: יוצרים מפתח אקראי של 256 ביט (32 בייטים). אם כבר יש לכם מפתח שאתם רוצים להשתמש בו, אתם יכולים לדלג על השלב הזה. יש הרבה דרכים ליצור מפתח. לדוגמה:

    $ head -c 32 /dev/urandom | LC_CTYPE=C tr '\n' = > mykey.txt

  2. מורידים את האישור של המפתח הציבורי:

    $  curl -s -O -L https://cloud-certs.storage.googleapis.com/google-cloud-csek-ingress.pem

  3. מחילוץ המפתח הציבורי מהאישור:

    $ openssl x509 -pubkey -noout -in google-cloud-csek-ingress.pem > pubkey.pem

  4. מצפינים את המפתח באמצעות RSA, ומקפידים להחליף את mykey.txt בקובץ המפתח שלכם.

    $ openssl rsautl -oaep -encrypt -pubin -inkey pubkey.pem -in mykey.txt -out rsawrappedkey.txt

  5. מקודדים את המפתח שעטוף ב-RSA ב-base64.

    $ openssl enc -base64 -in rsawrappedkey.txt | tr -d '\n' | sed -e '$a\' > rsawrapencodedkey.txt

דוגמה 2

הקוד הבא הוא דוגמה לסקריפט Python שיוצר מחרוזת אקראית של 256 ביט (32 בייטים) ויוצר מפתח עטוף ב-RSA בקידוד base64 באמצעות ספריית הקריפטוגרפיה:

import argparse
import base64
import os
from typing import Optional

from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicKey
import requests


GOOGLE_PUBLIC_CERT_URL = (
    "https://cloud-certs.storage.googleapis.com/google-cloud-csek-ingress.pem"
)


def get_google_public_cert_key() -> RSAPublicKey:
    """
    Downloads the Google public certificate.

    Returns:
        RSAPublicKey object with the Google public certificate.
    """
    r = requests.get(GOOGLE_PUBLIC_CERT_URL)
    r.raise_for_status()

    # Load the certificate.
    certificate = x509.load_pem_x509_certificate(r.content, default_backend())

    # Get the certicate's public key.
    public_key = certificate.public_key()

    return public_key


def wrap_rsa_key(public_key: RSAPublicKey, private_key_bytes: bytes) -> bytes:
    """
    Use the Google public key to encrypt the customer private key.

    This means that only the Google private key is capable of decrypting
    the customer private key.

    Args:
        public_key: The public key to use for encrypting.
        private_key_bytes: The private key to be encrypted.

    Returns:
        private_key_bytes encrypted using the public_key. Encoded using
        base64.
    """
    wrapped_key = public_key.encrypt(
        private_key_bytes,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA1()),
            algorithm=hashes.SHA1(),
            label=None,
        ),
    )
    encoded_wrapped_key = base64.b64encode(wrapped_key)
    return encoded_wrapped_key


def main(key_file: Optional[str]) -> None:
    """
    This script will encrypt a private key with Google public key.

    Args:
        key_file: path to a file containing your private key. If not
            provided, a new key will be generated (256 bit).
    """
    # Generate a new 256-bit private key if no key is specified.
    if not key_file:
        customer_key_bytes = os.urandom(32)
    else:
        with open(key_file, "rb") as f:
            customer_key_bytes = f.read()

    google_public_key = get_google_public_cert_key()
    wrapped_rsa_key = wrap_rsa_key(google_public_key, customer_key_bytes)

    b64_key = base64.b64encode(customer_key_bytes).decode("utf-8")

    print(f"Base-64 encoded private key: {b64_key}")
    print(f"Wrapped RSA key: {wrapped_rsa_key.decode('utf-8')}")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument("--key_file", help="File containing your binary private key.")

    args = parser.parse_args()

    main(args.key_file)

המפתח מוכן לשימוש.

שימוש במפתח מוצפן ב-RSA

כשמשתמשים ב-Google Cloud CLI, אפשר לספק מפתח רגיל ומפתח שעטוף ב-RSA באותו אופן.

ב-API, אם רוצים להשתמש במפתח שעטוף ב-RSA, משתמשים במאפיין sha256 במקום במאפיין rawKey.

הצפנת משאבים באמצעות CSEK באמצעות כלי שורת הפקודה

אפשר להשתמש במפתחות הצפנה באמצעות Google Cloud CLI.

הורדה והתקנה של gcloud

קובץ מפתח

כשמשתמשים בכלי gcloud compute של שורת הפקודה כדי להגדיר את המפתחות, צריך לספק מפתחות מקודדים באמצעות קובץ מפתחות שמכיל את המפתחות המקודדים כרשימת JSON. קובץ מפתחות יכול להכיל כמה מפתחות, וכך אתם יכולים לנהל הרבה מפתחות במקום אחד. אפשר גם ליצור קובצי מפתחות נפרדים כדי לטפל בכל מפתח בנפרד. אפשר להשתמש בקובץ מפתח רק עם ה-CLI של gcloud. כשמשתמשים ב-REST, צריך לספק את המפתח ישירות בבקשה.

כל רשומה בקובץ המפתחות צריכה לכלול:

  • ה-URI המלא של המשאב שהמפתח מגן עליו
  • המפתח המתאים
  • סוג המפתח, raw או rsa-encrypted

כשמשתמשים בקובץ המפתח בבקשות, הכלי מחפש משאבים תואמים ומשתמש במפתחות המתאימים. אם לא נמצאים משאבים תואמים, הבקשה נכשלת.

פורמט קובץ המפתח

הנה דוגמה לקובץ מפתח:

[
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks/example-disk",
  "key": "acXTX3rxrKAFTF0tYVLvydU1riRZTvUNC4g5I11NY+c=",
  "key-type": "raw"
  },
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/global/snapshots/my-private-snapshot",
  "key": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA==",
  "key-type": "rsa-encrypted"
  }
]

שיטות מומלצות לניהול קובץ המפתח

אם אתם משתמשים בקובץ מפתח, הגבילו את הגישה לקובץ רק לאנשים שצריכים אותה. חשוב להגדיר הרשאות מתאימות לקבצים האלה, ואולי גם להצפין אותם באמצעות כלים נוספים:

יצירת נפח אחסון מתמיד (persistent disk) מוצפן באמצעות CSEK

אפשר להצפין דיסק קבוע חדש על ידי ציון מפתח במהלך יצירת המכונה הווירטואלית או הדיסק.

המסוף

  1. נכנסים לדף Disks.

    לפתיחת הדף Disks

  2. לוחצים על Create disk (יצירת דיסק) ומזינים את המאפיינים של הדיסק החדש.

  3. בקטע הצפנה, בוחרים באפשרות מפתח באספקת הלקוח.

  4. בשדה מפתח ההצפנה של דיסק המקור, מציינים את מפתח ההצפנה של הדיסק ובוחרים באפשרות מפתח עטוף אם המפתח עטוף במפתח RSA ציבורי.

gcloud

בכלי gcloud compute, מצפינים דיסק באמצעות הדגל --csek-key-file במהלך יצירת המכונה הווירטואלית. אם אתם משתמשים במפתח שעטוף ב-RSA, השתמשו ברכיב gcloud beta:

gcloud (beta) compute instances create example-instance --csek-key-file example-file.json

כדי להצפין דיסק אחסון מתמיד (persistent disk) עצמאי:

gcloud (beta) compute disks create example-disk --csek-key-file example-file.json

REST

אפשר להצפין דיסק באמצעות המאפיין diskEncryptionKey ולשלוח בקשה ל-API בגרסה v1 לקבלת מפתח גולמי (לא מוצפן ב-RSA), או ל-API בגרסת בטא לקבלת מפתח מוצפן ב-RSA. צריך לציין בבקשה אחד מהמאפיינים הבאים:

  • ‫rawKey: אם המפתח שלכם הוא בקידוד base64
  • ‫rsaEncryptedKey: אם המפתח מוצפן ב-RSA ומקודד ב-base64

לדוגמה, כדי להצפין דיסק חדש במהלך יצירת מכונה וירטואלית באמצעות מפתח עטוף ב-RSA:

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/instances

{
"machineType": "zones/us-central1-a/machineTypes/e2-standard-2",
"disks": [
 {
  "type": "PERSISTENT",
  "diskEncryptionKey": {
    "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
  "initializeParams": {
   "sourceImage": "projects/debian-cloud/global/images/debian-9-stretch-v20170619"
  },
  "boot": true
 }
],
...
}

באופן דומה, אפשר גם להשתמש ב-REST כדי ליצור דיסק קבוע עצמאי חדש ולהצפין אותו באמצעות מפתח משלכם:

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/
us-central1-a/disks?sourceImage=https%3A%2F%2Fwww.googleapis.com%2Fcompute%2F
alpha%2Fprojects%2Fdebian-cloud%2Fglobal%2Fimages%2Fdebian-9-stretch-v20170619

{
 "name": "new-encrypted-disk-key",
 "diskEncryptionKey": {
   "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
 "type": "zones/us-central1-a/diskTypes/pd-standard"
}

יצירת snapshot מדיסק מוצפן באמצעות CSEK

אם יוצרים snapshot מדיסק שמוצפן באמצעות CSEK, צריך לספק את מפתח ההצפנה שבו השתמשתם כדי להצפין את הדיסק, ואת המפתח להצפנת ה-snapshot החדש. בנוסף, צריך להצפין את התמונה באמצעות מפתח הצפנה ספציפי ללקוח (CSEK).

כדי להמיר דיסקים או קובצי snapshot שמוצפנים באמצעות CSEK לשימוש ב- Google-owned and Google-managed encryption keys, צריך ליצור דיסק או קובץ snapshot חדשים.

תמונות מצב של דיסקים שמוצפנים באמצעות CSEK הן תמיד תמונות מצב מלאות. ההתנהגות הזו שונה מצילומי מצב של דיסקים שמוצפנים באמצעות מפתחות הצפנה בניהול הלקוח (CMEK), שהם מצטברים. התמחור של קובצי snapshot מבוסס על הגודל הכולל שלהם, ולכן קובץ snapshot מלא עשוי לעלות יותר מקובץ snapshot מצטבר.

לפני שיוצרים קובץ snapshot, כדאי לעיין בשיטות המומלצות ליצירת קובצי snapshot של דיסקים.

המסוף

  1. עוברים לדף תמונות מצב.

    כניסה לדף Snapshots

  2. לוחצים על יצירת תמונת מצב.

  3. בקטע דיסק מקור, בוחרים את הדיסק המוצפן שרוצים ליצור ממנו תמונת מצב.

  4. בשדה מפתח ההצפנה של דיסק המקור מזינים את מפתח ההצפנה של הדיסק, ואם המפתח עבר עטיפה באמצעות מפתח RSA ציבורי, בוחרים באפשרות מפתח עטוף.

  5. כדי להצפין את התמונה החדשה, בוחרים שיטת הצפנה על ידי אספקת מפתח הצפנה נוסף בקטע הצפנה.

REST

כדי לשלוח את הבקשה, צריך לציין את נכס sourceDiskEncryptionKey שאליו רוצים לגשת לדיסק אחסון מתמיד (persistent disk) של המקור. צריך להצפין את קובץ ה-snapshot החדש באמצעות המאפיין snapshotEncryptionKey.

שולחים בקשה ל-v1 API לקבלת מפתח גולמי (לא עטוף ב-RSA), או ל-Beta API לקבלת מפתח עטוף ב-RSA.

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/disks/example-disk/createSnapshot

{
 "snapshotEncryptionKey":  {
   "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
 },
  "sourceDiskEncryptionKey": {
   "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
 "name": "snapshot-encrypted-disk"
}

הערך של המאפיין sourceDiskEncryptionKey צריך להיות זהה למפתח שמשמש להצפנה של הדיסק אחסון מתמיד (persistent disk). אחרת, הבקשה תיכשל.

השדה snapshotEncryptionKey מאפשר לספק מפתח להצפנת תמונת המצב, כך שאם משתמשים בתמונת המצב כדי ליצור דיסקים חדשים מסוג Persistent Disk, צריך לספק מפתח תואם. המפתח הזה צריך להיות בפורמט המפתח הקודם. אפשר גם להשאיר את המאפיין הזה לא מוגדר, ואז אפשר להשתמש בתמונת המצב כדי ליצור דיסקי אחסון מתמידים (persistent disk) חדשים בלי צורך במפתח.

יצירת קובץ אימג' חדש מדיסק או מקובץ אימג' בהתאמה אישית שמוצפן באמצעות CSEK

אתם יכולים ליצור תמונות בהתאמה אישית מדיסקים מוצפנים של Persistent Disk או להעתיק תמונות מוצפנות. אי אפשר להשתמש במסוף כדי להעתיק תמונות. כדי להעתיק קובצי אימג', צריך להשתמש ב-Google Cloud CLI או ב-REST.

המסוף

  1. עוברים לדף Images.

    כניסה לדף Images

  2. לוחצים על יצירת תמונה.

  3. בקטע דיסק מקור, בוחרים את הדיסק המוצפן שרוצים ליצור ממנו תמונה.

  4. בקטע Encryption, בוחרים פתרון לניהול מפתחות הצפנה.

  5. אם המפתח עבר עטיפה באמצעות מפתח RSA ציבורי, בוחרים באפשרות Wrapped key (מפתח עטוף).

gcloud

פועלים לפי ההוראות ליצירת תמונה, ומוסיפים את הדגל --csek-key-file עם נתיב לקובץ מפתח ההצפנה של אובייקט המקור המוצפן. אם משתמשים במפתח שעטוף ב-RSA, צריך להשתמש ברכיב gcloud beta:

gcloud (beta) compute images create .... --csek-key-file example-file.json

אם רוצים להצפין את התמונה החדשה באמצעות המפתח, מוסיפים את המפתח לקובץ המפתח:

[
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks/source-disk",
  "key": "acX3RqzxrKAFTF0tYVLvydU1riRZTvUNC4g5I11NY-c=",
  "key-type": "raw"
  },
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/global/snapshots/the-new-image",
  "key": "TF0t-cSfl7CT7xRF1LTbAgi7U6XXUNC4zU_dNgx0nQc=",
  "key-type": "raw"
  }
]

REST

בקשת ה-API ליצירה חייבת להכיל את מאפיין מפתח ההצפנה של אובייקט המקור. לדוגמה, אפשר לכלול אחד מהמאפיינים הבאים, בהתאם לסוג אובייקט המקור:

  • דיסק אחסון מתמיד (persistent disk): sourceDiskEncryptionKey
  • תמונה: sourceImageEncryptionKey

צריך לכלול גם את המאפיינים rawKey או rsaEncryptedKey בהתאם לסוג המפתח. שליחת בקשה ל-API בגרסה 1 לקבלת מפתח גולמי (לא מוצפן ב-RSA), או ל-API בגרסת בטא לקבלת מפתח מוצפן ב-RSA. בדוגמה הבאה, דיסק אחסון מתמיד (persistent disk) מוצפן שעטוף ב-RSA מומר לאימג' שמשתמש באותו מפתח הצפנה.

POST https://compute.googleapis.com/compute/beta/projects/myproject/global/images

{
 "name": "image-encrypted-disk",
 "sourceDiskEncryptionKey": {
    "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  }
 "imageEncryptionKey": {
    "rsaEncryptedKey":  "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
    },
 "sourceDisk": "projects/myproject/zones/us-central1-a/disks/source-disks"
}

המאפיין האופציונלי imageEncryptionKey מאפשר לספק מפתח להצפנת התמונה, כך שכשהתמונה משמשת ליצירת דיסקים קבועים חדשים, צריך לספק מפתח תואם. המפתח הזה צריך להיות בפורמט המפתח שתיארנו קודם. אפשר גם להשאיר את המאפיין הזה לא מוגדר, ואז אפשר להשתמש בתמונה כדי ליצור דיסקים אחסון מתמידים (persistent disks) חדשים בלי צורך במפתח.

הצפנה של תמונה מיובאת באמצעות CSEK

אפשר להצפין תמונה חדשה כשמייבאים ידנית תמונה בהתאמה אישית ל-Compute Engine. לפני שתוכלו לייבא תמונה, תצטרכו ליצור ולדחוס קובץ אימג' של דיסק ולהעלות את הקובץ הדחוס הזה ל-Cloud Storage.

מייבאים את תמונת Compute Engine המותאמת אישית שרוצים להצפין. מציינים את ה-URI של הקובץ הדחוס וגם את הנתיב לקובץ מפתח ההצפנה.

המסוף

  1. עוברים לדף תמונות.

    כניסה לדף Images

  2. לוחצים על יצירת תמונה.

  3. בקטע מקור, בוחרים באפשרות קובץ Cloud Storage.

  4. בקטע קובץ Cloud Storage, מזינים את ה-URI של Cloud Storage.

  5. בקטע Encryption, בוחרים באפשרות Customer-supplied key ומזינים את מפתח ההצפנה כדי להצפין את התמונה בשדה Source disk encryption key.

gcloud

משתמשים בפקודה compute images create כדי ליצור תמונה חדשה, ומציינים את הדגל --csek-key-file עם קובץ מפתח הצפנה. אם אתם משתמשים במפתח שעטוף ב-RSA, השתמשו ברכיב gcloud beta:

gcloud (beta) compute images create [IMAGE_NAME] \
    --source-uri gs://[BUCKET_NAME]/[COMPRESSED_FILE] \
    --csek-key-file [KEY_FILE]

מחליפים את מה שכתוב בשדות הבאים:

  • ‫[IMAGE_NAME]: השם של התמונה המותאמת אישית החדשה.
  • ‫[BUCKET_NAME]: השם של קטגוריית Cloud Storage שבה מאוחסן קובץ התמונה הדחוס.
  • ‫[COMPRESSED_FILE]: השם של קובץ התמונה הדחוס.
  • ‫[KEY_FILE]: הנתיב לקובץ של מפתח הצפנה בתחנת העבודה המקומית.

REST

כדי להצפין תמונה חדשה שנוצרה מקובץ RAW, מוסיפים את המאפיין החדש imageEncryptionKey לבקשה ליצירת התמונה, ואחריו את הערך rawKey או rsaEncryptedKey. שולחים בקשה ל-API בגרסה 1 למפתח גולמי (לא עטוף ב-RSA), או ל-API בגרסת בטא למפתח עטוף ב-RSA.

POST https://compute.googleapis.com/compute/beta/projects/myproject/global/images

{
"rawDisk": {
 "source": "http://storage.googleapis.com/example-image/example-image.tar.gz"
},
"name": "new-encrypted-image",
"sourceType": "RAW",
"imageEncryptionKey": {
  "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  }
}

יצירת דיסק אחסון מתמיד (persistent disk) ממקור מוצפן באמצעות CSEK

אפשר ליצור דיסק אחסון מתמיד (persistent disk) מהמקורות הבאים שמוצפנים באמצעות CSEK:

  • קובצי snapshot מואצים
  • תמונות מצב רגילות
  • תמונות

יצירת דיסק מקובץ snapshot מוצפן באמצעות CSEK

המסוף

  1. נכנסים לדף Disks.

    לפתיחת הדף Disks

  2. לוחצים על Create disk.

  3. בקטע סוג המקור, בוחרים את סוג התמונה:

    • כדי ליצור תמונת מצב רגילה, בוחרים באפשרות תמונת מצב.
    • כדי ליצור קובץ snapshot מואץ, בוחרים באפשרות קובץ snapshot מואץ.
    • כדי ליצור תמונת מצב רגילה, בוחרים באפשרות תמונת מצב של הארכיון.

  4. מזינים את מפתח ההצפנה של תמונת המצב של המקור. בשדה מפתח ההצפנה של תמונת המצב של המקור, מזינים את מפתח ה-CSEK ששימש להצפנה של תמונת המצב של המקור.

  5. אם המפתח עטוף במפתח הציבורי של RSA, בוחרים באפשרות Wrapped key.

  6. אופציונלי: אם קובץ ה-snapshot של המקור הוא קובץ snapshot רגיל או קובץ snapshot של ארכיון, אתם יכולים להגדיר את ההצפנה של הדיסק החדש.

    1. מרחיבים את הקטע הגדרות מתקדמות.
    2. בקטע Encryption, בוחרים פתרון לניהול מפתחות הצפנה.
      • כדי להשתמש ב Google-owned and Google-managed encryption key, בוחרים באפשרות Google-managed encryption key.
      • כדי להשתמש במפתח שמנוהל על ידי Cloud Key Management Service, בוחרים באפשרות מפתח Cloud KMS.

  7. אופציונלי: מגדירים גיבויים לדיסק בקטע הגנה על נתונים.

  8. לוחצים על Create כדי ליצור את הדיסק.

gcloud

משתמשים בפקודה gcloud compute disks create. מספקים את מפתח ההצפנה של התמונה באמצעות הדגל --csek-key-file.

אם אתם משתמשים במפתח שעטוף ב-RSA, השתמשו בגרסת gcloud beta של הפקודה.

  • יוצרים דיסק מקובץ snapshot רגיל או מקובץ snapshot של ארכיון שמוצפן באמצעות CSEK.
gcloud compute disks create ... --source-snapshot example-snapshot \
 --csek-key-file example-file.json
  • יוצרים דיסק מ-snapshot מיידי שמוצפן באמצעות CSEK:
gcloud compute disks create ... --source-instant-snapshot example-instant-snapshot \
  --csek-key-file example-file.json

REST

יוצרים בקשת POST אל ה-method‏ disks.insert. כדי להשתמש בתמונת מצב מוצפנת, צריך לציין בבקשה את sourceSnapshotEncryptionKey, ואחריו את rawKey או את rsaEncryptedKey.

אם אתם משתמשים במפתחות שעטופים ב-RSA, השתמשו בגרסת הבטא של ה-method‏ disks.insert.

  • כדי ליצור דיסק חדש מקובץ snapshot רגיל או מקובץ snapshot של ארכיון שמשתמש במפתח מוצפן ב-RSA:

    POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/disks

{
"name": "disk-from-encrypted-snapshot",
"sourceSnapshot": "global/snapshots/encrypted-snapshot",
"sourceSnapshotEncryptionKey": {
"rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
}
}

  • כדי ליצור דיסק מ-snapshot מיידי שמשתמש במפתח מוצפן ב-RSA:

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT/zones/SOURCE_ZONE/disks/insert
{
  "name": "NEW_DISK_NAME",
  "sourceInstantSnapshot": "projects/PROJECT/zones/SOURCE_ZONE/instantSnapshots/INSTANT_SNAPSHOT_NAME",
  "diskEncryptionKey": {
     "rsaEncryptedKey": "RSA_ENCRYPTED_KEY"
  }
}

יצירת דיסק מתמונה מוצפנת באמצעות CSEK

המסוף

  1. נכנסים לדף Disks.

    לפתיחת הדף Disks

  2. לוחצים על Create disk.

  3. בקטע סוג המקור, בוחרים באפשרות תמונה.

  4. בקטע הצפנה, בוחרים פתרון לניהול מפתחות הצפנה.

  5. אם המפתח עבר עטיפה באמצעות מפתח RSA ציבורי, בוחרים באפשרות Wrapped key (מפתח עטוף).

gcloud

בכלי gcloud compute, מספקים את מפתח ההצפנה של התמונה באמצעות הדגל --csek-key-file כשיוצרים את הדיסק. אם אתם משתמשים במפתח שעטוף ב-RSA, השתמשו ברכיב gcloud beta:

gcloud (beta) compute disks create ... --image example-image --csek-key-file example-file.json

REST

כדי להשתמש בתמונה מוצפנת, מציינים את התג sourceImageEncryptionKey ואחריו את התג rawKey או rsaEncryptedKey. שולחים בקשה ל-API בגרסה v1 כדי לקבל מפתח גולמי (לא מוצפן ב-RSA), או ל-API בגרסת בטא כדי לקבל מפתח מוצפן ב-RSA.

POST https://compute.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks

{
"name": "disk-from-encrypted-image",
"sourceImageEncryptionKey": {
  "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
"sourceImage": "global/images/encrypted-image"
}

צירוף דיסק שמוצפן באמצעות CSEK ל-VM חדש

המסוף

  1. נכנסים לדף Create an instance.

    כניסה לדף Create an instance

  2. בקטע Boot disk (דיסק אתחול), לוחצים על Change (שינוי) ומבצעים את הפעולות הבאות:

    1. בדף דיסק אתחול, לוחצים על הכרטיסייה Existing disks.
    2. ברשימה Disk, בוחרים דיסק מוצפן קיים כדי לצרף אותו למכונה הווירטואלית.

    3. מזינים את מפתח ההצפנה בשדה Source disk decryption key. אם המפתח עטוף במפתח RSA ציבורי, בוחרים באפשרות מפתח עטוף.

    4. לוחצים על בחירה.

  3. ממשיכים בתהליך יצירת המכונה הווירטואלית.

gcloud

כדי ליצור מכונה וירטואלית ולצרף אליה דיסק מוצפן, יוצרים קובץ מפתח ומספקים את המפתח באמצעות הדגל --csek-key-file כשיוצרים את המכונה הווירטואלית. אם אתם משתמשים במפתח שעטוף ב-RSA, השתמשו ברכיב gcloud beta:

gcloud (beta) compute instances create example-instance \
    --disk name=example-disk,boot=yes \
    --csek-key-file example-file.json

REST

יוצרים מכונה וירטואלית באמצעות Compute Engine API ומספקים את rawKey או את rsaEncryptedKey עם מפרט הדיסק. שולחים בקשה ל-API בגרסה 1 למפתח גולמי (לא עטוף ב-RSA), או ל-API בגרסת בטא למפתח עטוף ב-RSA.

דוגמה לקטע קוד של מפרט דיסק:

"disks": [
{
  "deviceName": "encrypted-disk",
  "source": "projects/myproject/zones/us-central1-f/disks/encrypted-disk",
  "diskEncryptionKey": {
    "rawKey": "SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0="
  }
 }
]

הפעלה או הפעלה מחדש של מכונות וירטואליות עם דיסקים מוצפנים באמצעות CSEK

לפרטים על עצירה או הפעלה של מכונה וירטואלית עם דיסקים מוצפנים, אפשר לקרוא את המאמר הפעלה מחדש של מכונה וירטואלית עם דיסק מוצפן.

יצירת משאבים עם סוגי הצפנה שונים

אתם יכולים ליצור מופעים ומשאבים אחרים שמשתמשים בשילוב של משאבים מוצפנים באמצעות CSEK,‏ CMEK ו-Google-owned and managed key. לדוגמה, אפשר ליצור מכונה שיש לה דיסק אתחול שמוצפן באמצעות CSEK ודיסק נתונים שמוצפן באמצעות CMEK.

כדי ליצור משאבים כאלה בבקשה אחת באמצעות Google Cloud CLI, צריך לכלול את הדגל --no-require-csek-key-create בבקשה.

עדיין צריך לציין את מפתח ה-CSEK לכל המשאבים שמוצפנים באמצעות CSEK עם הדגל --csek-key-file. כשמציינים את שני הדגלים, מערכת Compute Engine יוצרת את כל המשאבים שמוצפנים על ידי הלקוח ומוגדרים במפורש בקובץ המפתחות, וגם את כל המשאבים הרגילים שציינתם.

לדוגמה, נניח שקובץ מפתח מכיל את הנתונים הבאים:

[
  {
  "uri": "https://www.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/disks/example-disk",
  "key": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA==",
  "key-type": "rsa-encrypted"
  }
]

אפשר ליצור בו-זמנית שני מכונים, אחד עם דיסק אתחול שמוצפן באמצעות CSEK והשני עם דיסק אתחול שמוצפן באמצעותGoogle-owned and managed key , באמצעות הפקודה הבאה:

gcloud beta compute instances create example-disk example-disk-2 \
    --csek-key-file mykeyfile.json --no-require-csek-key-create

בדרך כלל, אי אפשר ליצור example-disk-2 אם מציינים את הדגל --csek-key-file כי הכונן לא מוגדר באופן מפורש בקובץ המפתח. כשמוסיפים את --no-require-csek-key-create, שני הדיסקים נוצרים, אחד מוצפן באמצעות קובץ המפתח והשני מוצפן באמצעותGoogle-owned and managed keys.

הסרת מפתח CSEK מדיסק מתמשך

אתם יכולים לפענח את התוכן של דיסק שהוצפן על ידי הלקוח וליצור דיסק חדש שמשתמש ב- Google-owned and managed keys .

  1. יוצרים קובץ אימג' של הדיסק המוצפן ומציינים הצפנה אוטומטית לקובץ האימג' החדש.
  2. משתמשים בתמונה החדשה כדי ליצור דיסק אחסון מתמיד (persistent disk) חדש.

אחרי שיוצרים את הדיסק החדש לאחסון מתמיד, מערכת Compute Engine משתמשת ב-Google-owned and managed keys כדי להגן על תוכן הדיסק. כל קובצי ה-snapshot שיוצרים מהדיסק הזה צריכים להשתמש גם ב-Google-owned and managed keys