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

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

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

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

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

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

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

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

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

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

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

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

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

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

  • כדי ליצור קובץ snapshot של דיסק:
    • compute.snapshots.create בפרויקט
    • compute.disks.createSnapshot בדיסק
    • iam.serviceAccounts.actAs בחשבון השירות של המכונה, אם הדיסק הוא דיסק האתחול של מכונה שמצורף אליה חשבון שירות
  • כדי ליצור תמונה:
    • compute.images.create בפרויקט
    • compute.disks.useReadOnly בדיסק
    • iam.serviceAccounts.actAs בחשבון השירות של המכונה, אם הדיסק הוא דיסק האתחול של מכונה שמצורף אליה חשבון שירות
  • כדי ליצור דיסק מ-snapshot רגיל:
    • ‫compute.disks.create בפרויקט היעד של הדיסק החדש
    • compute.snapshots.useReadOnly בתמונת המצב
  • כדי ליצור דיסק מתמונה:
    • ‫compute.disks.create בפרויקט היעד של הדיסק החדש
    • compute.images.useReadOnly בתמונה
  • כדי ליצור דיסק מ-snapshot מיידי:
    • ‫compute.disks.create בפרויקט היעד של הדיסק החדש
    • compute.instantSnapshots.useReadOnly בקובץ ה-snapshot המואץ של המקור
    • ‫iam.serviceAccounts.actAs בחשבון השירות של המופע, אם קובץ snapshot מואץ הוא של דיסק האתחול של מופע שמחובר אליו חשבון שירות

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

הגבלות

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

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

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

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

  • ברזיל
  • הודו

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

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

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

  • מפתחות הצפנה לא מאוחסנים ב-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 יכולים לפענח את המפתח ולהשתמש בו כדי להגן על הנתונים. Google Cloud

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

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

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

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

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

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

דוגמה 1

בהוראות הבאות נעשה שימוש בכלי שורת הפקודה openssl כדי לבצע RSA-wrap ולבצע קידוד של מפתח.

  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 במהלך יצירת מכונת ה-VM. אם משתמשים במפתח שעטוף ב-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).

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

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

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

המסוף

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

    כניסה לדף Snapshots

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

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

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

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

REST

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

שולחים בקשה ל-API מגרסה 1 כדי לקבל מפתח גולמי (לא מוצפן ב-RSA), או ל-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 צריך להיות זהה למפתח שמשמש להצפנה של הדיסק הקשיח. אחרת, הבקשה תיכשל.

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

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

אתם יכולים ליצור תמונות בהתאמה אישית מדיסקים מוצפנים של אחסון מתמיד או להעתיק תמונות מוצפנות. אי אפשר להשתמש במסוף כדי להעתיק תמונות. אפשר להשתמש ב-Google Cloud CLI או ב-REST כדי להעתיק תמונות.

המסוף

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

    כניסה לדף Images

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

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

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

  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 בגרסה v1 לקבלת מפתח גולמי (לא מוצפן ב-RSA), או ל-API בגרסת בטא לקבלת מפתח מוצפן ב-RSA. בדוגמה הבאה, דיסק מתמשך מוצפן שעטוף ב-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 מאפשר לספק מפתח להצפנת התמונה, כך שכשהתמונה משמשת ליצירת דיסקים קבועים חדשים, צריך לספק מפתח תואם. המפתח הזה צריך להיות בפורמט המפתח שתיארנו קודם. אפשר גם להשאיר את המאפיין הזה לא מוגדר, ואז אפשר להשתמש בתמונה כדי ליצור דיסקים קשיחים חדשים בלי צורך במפתח.

הצפנה של תמונה מיובאת באמצעות 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 בגרסה v1 כדי לקבל מפתח גולמי (לא עטוף ב-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 רגילים
  • תמונות

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

המסוף

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

    לפתיחת הדף Disks

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

  3. בקטע Source type (סוג המקור), בוחרים באפשרות Snapshot (קובץ snapshot).

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

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

gcloud

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

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

REST

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

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=="
  }
}

יצירת דיסק מתמונה מוצפנת באמצעות 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 למכונה וירטואלית חדשה

המסוף

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

    כניסה לדף Create an instance

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

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

    3. מזינים את מפתח ההצפנה בשדה מפתח לפענוח דיסק המקור. אם המפתח עבר הצפנה באמצעות מפתח RSA ציבורי, בוחרים באפשרות Wrapped key (מפתח מוצפן).

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

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

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 בגרסה v1 כדי לקבל מפתח גולמי (לא מוצפן ב-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"
  }
]

אפשר ליצור שני מופעים בו-זמנית, אחד עם דיסק אתחול שמוצפן באמצעות מפתח הצפנה מצד הלקוח והשני עם דיסק אתחול שמוצפן באמצעות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. משתמשים בתמונה החדשה כדי ליצור דיסק קשיח חדש.

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