Key Management Service：Impor bahan kunci

Impor bahan kunci di konsol KMS

1. Buat CMK eksternal.

   1. Masuk ke konsol KMS. Di bilah navigasi atas, pilih wilayah tempat Anda ingin membuat CMK eksternal.

   2. Di panel navigasi kiri, pilih Resource > Keys.

   3. Klik Create Key. Di kotak dialog Create Key, konfigurasikan parameter.

      Parameter	Deskripsi
      KMS Instance	Instansi KMS yang ingin Anda gunakan. Pertahankan nilai default Default. Anda tidak dapat mengubah nilai parameter ini.
      Key Type	Tipe CMK. Tetapkan parameter ini ke Aliyun_AES_256. Untuk informasi lebih lanjut tentang tipe CMK simetris, lihat Ikhtisar.
      Key Usage	Penggunaan CMK. Nilai valid: Encrypt/Decrypt: mengenkripsi atau mendekripsi data. Sign/Verify: menandatangani data atau memverifikasi tanda tangan digital.
      Key Alias	Pengenal CMK. Nama dapat berisi huruf, angka, garis bawah (_), tanda hubung (-), dan garis miring (/). Untuk informasi lebih lanjut, lihat Ikhtisar.
      Protection Level	Tingkat perlindungan CMK. Nilai valid: Software: CMK dilindungi menggunakan modul perangkat lunak. Hsm: CMK dikelola di modul keamanan perangkat keras (HSM), dan HSM melindungi CMK.
      Description	Deskripsi CMK.
      Rotation Period	Interval rotasi otomatis CMK. Catatan Anda hanya dapat mengonfigurasi parameter ini jika Anda menetapkan parameter Key Spec ke Aliyun_AES_256.
      Key Material Source	Sumber bahan kunci. Pilih External.

   4. Pilih I understand the implications of using the external key materials dan klik OK.

2. Dapatkan parameter yang digunakan untuk mengimpor bahan kunci.

   Parameter mencakup kunci publik dan token impor. Kunci publik digunakan untuk mengenkripsi bahan kunci.

   1. Klik ID CMK ke dalam mana Anda ingin mengimpor bahan kunci untuk masuk ke halaman manajemen kunci. Di bagian Key Material, klik Obtain Parameters for Import.

   2. Di kotak dialog Obtain Parameters to Import Key Material, konfigurasikan parameter Public Key Type dan parameter Encryption Algorithm dan klik Next.

      Dalam contoh ini, tetapkan parameter Public Key Type ke RSA_2048 dan parameter Encryption Algorithm ke RSAES_OAEP_SHA_1.

      Catatan

      Jika Anda menetapkan parameter Public Key Type ke RSA_2048, Anda dapat menetapkan parameter Algoritma Pembungkus ke RSAES_PKCS1_V1_5, RSAES_OAEP_SHA_1, atau RSAES_OAEP_SHA_256. Nilai default adalah RSAES_PKCS1_V1_5.

   3. Unduh kunci publik dan token impor yang ditampilkan di kotak dialog yang muncul. Lalu, klik Close.

      Sebelum Anda mengunduh kunci publik, Anda harus memilih nilai untuk Public Key Format.

      • Jika Anda memilih DER Format untuk Public Key Format, akhiran file kunci publik yang diunduh adalah .bin. Contoh: publickey_f240b730-7e3e-4bd7-877f-4fe22524****.bin.

      • Jika Anda memilih PEM Format untuk Public Key Format, akhiran file kunci publik yang diunduh adalah .pem. Contoh: publickey_f240b730-7e3e-4bd7-877f-4fe22524****.pem.

3. Enkripsi bahan kunci.

   Setelah Anda mengunduh kunci publik dan kunci impor, Anda dapat menggunakan kunci publik untuk mengenkripsi bahan kunci.

   Prosedur berikut menjelaskan cara menggunakan OpenSSL untuk mengenkripsi bahan kunci. Algoritma enkripsi harus sama dengan algoritma yang Anda tentukan saat mendapatkan parameter yang digunakan untuk mengimpor bahan kunci. Dalam contoh ini, algoritma RSAES_OAEP_SHA_1 digunakan.

   1. Gunakan OpenSSL untuk menghasilkan nomor acak 32-byte. Nomor ini digunakan sebagai bahan kunci.

      openssl rand -out KeyMaterial.bin 32

   2. Gunakan algoritma enkripsi yang ditentukan untuk mengenkripsi bahan kunci.

      Sebelum Anda menjalankan kode sampel berikut, perhatikan item-item berikut:

      • Ganti PublicKey.bin dalam kode sampel dengan nama file kunci publik yang Anda unduh di Dapatkan parameter yang digunakan untuk mengimpor bahan kunci.

      • Dalam kode sampel, file kunci publik yang ditentukan berada dalam format DER format. Jika Anda memilih PEM Format saat mengunduh kunci publik, Anda harus mengganti -keyform DER dalam kode sampel dengan -keyform PEM.

      openssl rsautl -encrypt -in KeyMaterial.bin -oaep -inkey PublicKey.bin  -keyform DER  -pubin -out EncryptedKeyMaterial.bin

   3. Kodekan bahan kunci terenkripsi dalam Base64 dan simpan ke file teks.

      openssl enc -e -base64 -A -in EncryptedKeyMaterial.bin -out EncryptedKeyMaterial_base64.txt

4. Impor bahan kunci.

   Setiap token impor terikat pada kunci publik yang digunakan untuk mengenkripsi bahan kunci. CMK ditentukan saat token impor dihasilkan. Token impor dapat digunakan untuk mengimpor bahan kunci hanya untuk CMK yang ditentukan. Masa berlaku token impor adalah 24 jam. Token dapat digunakan berulang kali dalam periode ini. Setelah token kedaluwarsa, Anda harus mendapatkan token impor baru dan kunci publik baru.

   1. Di panel navigasi kiri, pilih Resource > Keys.

   2. Klik ID CMK untuk mana Anda ingin mengimpor bahan kunci untuk masuk ke halaman manajemen kunci. Di bagian Key Material, klik Import Key Material.

   3. Di kotak dialog Import Wrapped Key Material, konfigurasikan parameter Wrapped Key Material dan Import Token.

      • Wrapped Key Material: Unggah file teks yang dihasilkan di Enkripsi bahan kunci dan berisi bahan kunci.

      • Import Token: Unggah file teks yang diperoleh di Dapatkan parameter yang digunakan untuk mengimpor bahan kunci dan berisi token impor.

   4. Konfigurasikan parameter Key Material Expired On dan klik OK.

      Setelah bahan kunci diimpor, status CMK berubah dari Pending Import menjadi Enabled.

Impor bahan kunci menggunakan CLI Alibaba Cloud

1. Buat CMK eksternal.

   Jalankan perintah aliyun kms CreateKey untuk memanggil operasi CreateKey untuk membuat CMK eksternal sambil menetapkan parameter Origin ke EXTERNAL.

   aliyun kms CreateKey --Origin EXTERNAL --Description "External key"

2. Dapatkan parameter yang digunakan untuk mengimpor bahan kunci.

   Jalankan perintah aliyun kms GetParametersForImport untuk memanggil operasi GetParametersForImport untuk mendapatkan parameter yang digunakan untuk mengimpor bahan kunci.

   aliyun kms GetParametersForImport --KeyId 1339cb7d-54d3-47e0-b595-c7d3dba8**** --WrappingAlgorithm RSAES_OAEP_SHA_1 --WrappingKeySpec RSA_2048

3. Impor bahan kunci.

   1. Gunakan kunci publik untuk mengenkripsi bahan kunci.

      Kunci publik adalah kunci publik Rivest-Shamir-Adleman (RSA) 2.048-bit. Algoritma enkripsi harus sama dengan yang ditentukan saat Anda mendapatkan parameter yang digunakan untuk mengimpor bahan kunci. Kunci publik yang dikembalikan oleh operasi GetParametersForImport dienkripsi dalam Base64. Anda harus mendekode kunci publik terlebih dahulu. KMS mendukung algoritma enkripsi berikut: RSAES_OAEP_SHA_1, RSAES_OAEP_SHA_256, dan RSAES_PKCS1_V1_5.

   2. Kodekan bahan kunci terenkripsi dalam Base64.

   3. Teruskan bahan kunci dan token impor ke operasi ImportKeyMaterial sebagai parameter. Jalankan perintah aliyun kms ImportKeyMaterial untuk mengimpor bahan kunci terenkripsi ke KMS.

      aliyun kms ImportKeyMaterial --KeyId 1339cb7d-54d3-47e0-b595-c7d3dba8**** --EncryptedKeyMaterial xxx --ImportToken xxxx --KeyMaterialExpireUnix xxxx

Impor bahan kunci menggunakan SDK KMS

Kode sampel:

• JAVA SDK

  Catatan

  Pasangan AccessKey akun Alibaba Cloud memiliki izin untuk semua operasi API. Menggunakan pasangan AccessKey untuk melakukan operasi adalah operasi berisiko tinggi. Selain itu, gunakan pengguna RAM untuk memanggil operasi API atau melakukan pemeliharaan rutin. Kami menyarankan agar Anda tidak menyimpan ID AccessKey dan Rahasia AccessKey di kode proyek Anda. Jika Anda melakukannya, pasangan AccessKey mungkin bocor dan keamanan semua sumber daya yang dimiliki oleh akun Anda mungkin terganggu.

  Dalam contoh ini, pasangan AccessKey disimpan dalam variabel lingkungan ALIBABA_CLOUD_ACCESS_KEY_ID dan ALIBABA_CLOUD_ACCESS_KEY_SECRET untuk mengimplementasikan autentikasi identitas.

  • Untuk informasi lebih lanjut tentang cara mengonfigurasi informasi autentikasi, lihat Kelola Kredensial Akses.

  • Metode yang digunakan untuk mengonfigurasi variabel lingkungan bervariasi berdasarkan sistem operasi. Untuk informasi lebih lanjut, lihat Konfigurasikan Variabel Lingkungan di Linux, macOS, dan Windows.

  // Gunakan versi terbaru dari KMS SDK for Java. 
  //KmsClient.java
  
  import com.aliyuncs.kms.model.v20160120.*;
  import com.aliyuncs.profile.DefaultProfile;
  
  // Enkapsulasi operasi CreateKey. 
  public class KmsClient {
          DefaultAcsClient client;
  
          public KmsClient( String region_id, String ak, String secret) {
                  DefaultProfile profile = DefaultProfile.getProfile(region_id, ak, secret);
                  this.client = new DefaultAcsClient(profile);
          }
  
          public CreateKeyResponse createKey() throws Exception {
                  CreateKeyRequest request = new CreateKeyRequest();
                  request.setOrigin("EXTERNAL"); // Buat CMK eksternal. 
                  return this.client.getAcsResponse(request);
          }
          //.Dihilangkan. Metode yang digunakan untuk enkapsulasi operasi lainnya serupa dengan metode yang digunakan untuk enkapsulasi operasi sebelumnya. 
  }
  //example.java
  import com.aliyuncs.kms.model.v20160120.*;
  import KmsClient;
  import java.security.KeyFactory;
  import java.security.PublicKey;
  import java.security.spec.MGF1ParameterSpec;
  import javax.crypto.Cipher;
  import javax.crypto.spec.OAEPParameterSpec;
  import javax.crypto.spec.PSource.PSpecified;
  import java.security.spec.X509EncodedKeySpec;
  import java.util.Random;
  import javax.xml.bind.DatatypeConverter;
  
  public class CreateAndImportExample {
          public static void main(String[] args) {
                  String regionId = "cn-hangzhou";
          String accessKeyId = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID");
          String accessKeySecret = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET");
          KmsClient kmsclient = new KmsClient(regionId,accessKeyId,accessKeySecret);
          // Buat CMK eksternal. 
          try {
                  CreateKeyResponse keyResponse = kmsclient.createKey();
                  String keyId = keyResponse.KeyMetadata.getKeyId();
                  // Hasilkan nomor acak 32-byte. 
                  byte[] keyMaterial = new byte[32];
                  new Random().nextBytes(keyMaterial);
                  // Dapatkan parameter yang digunakan untuk mengimpor bahan kunci. 
                  GetParametersForImportResponse paramResponse = kmsclient.getParametersForImport(keyId,"RSAES_OAEP_SHA_256");
                  String importToekn = paramResponse.getImportToken();
                  String encryptPublicKey = paramResponse.getPublicKey();
                  // Dekode kunci publik dalam Base64. 
                  byte[] publicKeyDer = DatatypeConverter.parseBase64Binary(encryptPublicKey);
                  // Hasilkan kunci publik RSA. 
                  KeyFactory keyFact = KeyFactory.getInstance("RSA");
                  X509EncodedKeySpec spec = new X509EncodedKeySpec(publicKeyDer);
                  PublicKey publicKey = keyFact.generatePublic(spec);
                  // Enkripsi bahan kunci. 
                  Cipher oaepFromAlgo = Cipher.getInstance("RSA/ECB/OAEPWithSHA-1AndMGF1Padding");
                  String hashFunc = "SHA-256";
                  OAEPParameterSpec oaepParams = new OAEPParameterSpec(hashFunc, "MGF1", new MGF1ParameterSpec(hashFunc), PSpecified.DEFAULT);
                  oaepFromAlgo.init(Cipher.ENCRYPT_MODE, publicKey, oaepParams);
                  byte[] cipherDer = oaepFromAlgo.doFinal(keyMaterial);
                  // Kodekan bahan kunci terenkripsi dalam Base64. 
                  String encryptedKeyMaterial = DatatypeConverter.printBase64Binary(cipherDer);
                  // Impor bahan kunci. 
                  Long expireTimestamp = 1546272000L; // Stempel waktu UNIX, yang akurat hingga detik. Nilai 0 menunjukkan bahwa bahan kunci tidak kedaluwarsa. 
                          kmsclient.importKeyMaterial(keyId,encryptedKeyMaterial, expireTimestamp);
          } catch(Exception e) {
                  //... Dihilangkan. 
          }
          }
  }

• Go SDK

  Catatan

  Pasangan AccessKey akun Alibaba Cloud memiliki izin untuk semua operasi API. Menggunakan pasangan AccessKey untuk melakukan operasi adalah operasi berisiko tinggi. Kami menyarankan agar Anda menggunakan pengguna RAM untuk memanggil operasi API atau melakukan pemeliharaan rutin. Kami menyarankan agar Anda tidak menyimpan ID AccessKey dan Rahasia AccessKey di kode proyek Anda. Jika tidak, pasangan AccessKey mungkin bocor dan keamanan semua sumber daya yang dimiliki oleh akun Anda mungkin terganggu.

  Dalam contoh ini, pasangan AccessKey disimpan dalam variabel lingkungan ALIBABA_CLOUD_ACCESS_KEY_ID dan ALIBABA_CLOUD_ACCESS_KEY_SECRET untuk mengimplementasikan autentikasi identitas.

  • Untuk informasi lebih lanjut tentang cara mengonfigurasi informasi autentikasi, lihat Kelola Kredensial Akses.

  • Metode yang digunakan untuk mengonfigurasi variabel lingkungan bervariasi berdasarkan sistem operasi. Untuk informasi lebih lanjut, lihat Konfigurasikan Variabel Lingkungan di Linux, macOS, dan Windows.

  package main
  
  import (
      "crypto/rand"
      "crypto/rsa"
      "crypto/sha256"
      "crypto/x509"
      "encoding/base64"
      "fmt"
      "log"
      random "math/rand"
      "time"
  
      "github.com/aliyun/alibaba-cloud-sdk-go/services/kms"
  )
  
  // Enkapsulasi operasi CreateKey. 
  func kmsCreateKey(client *kms.Client) (string, error) {
      request := kms.CreateCreateKeyRequest()
      request.Scheme = "https"
      request.Origin = "EXTERNAL" // Buat CMK eksternal. 
      response, err := client.CreateKey(request)
      if err != nil {
          return "", fmt.Errorf("CreateKey error:%v", err)
      }
      return response.KeyMetadata.KeyId, nil
  }
  
  // Enkapsulasi operasi GetParametersForImport. 
  func kmsGetParametersForImport(client *kms.Client, keyId, wrappingKeySpec, wrappingAlgorithm string) (string, string, error) {
      request := kms.CreateGetParametersForImportRequest()
      request.Scheme = "https"
      request.KeyId = keyId
      request.WrappingKeySpec = wrappingKeySpec
      request.WrappingAlgorithm = wrappingAlgorithm
      response, err := client.GetParametersForImport(request)
      if err != nil {
          return "", "", fmt.Errorf("GetParametersForImport error:%v", err)
      }
      return response.PublicKey, response.ImportToken, nil
  }
  
  // Enkapsulasi operasi ImportKeyMaterial. 
  func kmsImportKeyMaterial(client *kms.Client, keyId, importToken, encryptedKeyMaterial string) error {
      request := kms.CreateImportKeyMaterialRequest()
      request.Scheme = "https"
      request.KeyId = keyId
      request.ImportToken = importToken
      request.EncryptedKeyMaterial = encryptedKeyMaterial
      _, err := client.ImportKeyMaterial(request)
      if err != nil {
          return fmt.Errorf("ImportKeyMaterial error:%v", err)
      }
      return nil
  }
  
  func randBytes(n int) []byte {
      var r = random.New(random.NewSource(time.Now().UnixNano()))
      bytes := make([]byte, n)
      for i := range bytes {
          bytes[i] = byte(r.Intn(256))
      }
      return bytes
  }
  
  func main() {
      accessKeyId := os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_ID")
      accessKeySecret := os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")
      regionId := "cn-hangzhou"
      client, err := kms.NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret)
      if err != nil {
          log.Fatalf("NewClientWithAccessKey error:%+v\n", err)
      }
      // Buat CMK eksternal. 
      keyId, err := kmsCreateKey(client)
      if err != nil {
          log.Fatalf("kmsCreateKey error:%+v\n", err)
      }
      // Kode sampel berikut digunakan untuk menghasilkan nomor acak 32-byte. Dalam skenario nyata, Anda harus menghasilkan kunci di sistem manajemen kunci Anda sendiri. Lalu, Anda harus menggunakan kunci publik dalam parameter yang digunakan untuk mengimpor bahan kunci untuk mengenkripsi bahan kunci. 
      keyMaterial := randBytes(32)
      // Dapatkan parameter yang digunakan untuk mengimpor bahan kunci. 
      encryptPublicKey, importToken, err := kmsGetParametersForImport(client, keyId, "RSA_2048", "RSAES_OAEP_SHA_256")
      if err != nil {
          log.Fatalf("kmsGetParametersForImport error:%v\n", err)
      }
      // Dekode kunci publik dalam Base64. 
      publicKeyDer, err := base64.StdEncoding.DecodeString(encryptPublicKey)
      if err != nil {
          log.Fatalf("base64.StdEncoding.DecodeString error:%v\n", err)
      }
      // Hasilkan kunci publik RSA. 
      publicKey, err := x509.ParsePKIXPublicKey(publicKeyDer)
      if err != nil {
          log.Fatalf("x509.ParsePKIXPublicKey error:%v\n", err)
      }
      // Enkripsi bahan kunci. 
      cipherDer, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, publicKey.(*rsa.PublicKey), keyMaterial, nil)
      if err != nil {
          log.Fatalf("rsa.EncryptOAEP error:%v\n", err)
      }
      // Kodekan bahan kunci terenkripsi dalam Base64. 
      encryptedKeyMaterial := base64.StdEncoding.EncodeToString(cipherDer)
      // Impor bahan kunci. 
      err = kmsImportKeyMaterial(client, keyId, importToken, encryptedKeyMaterial)
      if err != nil {
          log.Fatalf("ImportKeyMaterial error:%v", err)
      }
  }