Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Lakukan operasi offline dengan kunci publik
Dalam kunci KMS asimetris, kunci pribadi dibuat AWS KMS dan tidak pernah dibiarkan tidak terenkripsi. AWS KMS Untuk menggunakan kunci pribadi, Anda harus menelepon AWS KMS. Anda dapat menggunakan kunci publik dalam AWS KMS dengan memanggil operasi AWS KMS API. Atau, Anda dapat [mengunduh kunci publik](download-public-key.md) dan berbagi untuk digunakan di luar AWS KMS.
Anda dapat membagikan kunci publik agar orang lain mengenkripsi data di luar AWS KMS yang dapat Anda dekripsi hanya dengan kunci pribadi Anda. Atau, untuk mengizinkan orang lain memverifikasi tanda tangan digital di luar AWS KMS yang telah Anda hasilkan dengan kunci privat Anda. Atau, untuk berbagi kunci publik Anda dengan rekan untuk mendapatkan rahasia bersama.
Saat Anda menggunakan kunci publik di kunci KMS asimetris di dalamnya AWS KMS, Anda mendapat manfaat dari otentikasi, otorisasi, dan pencatatan yang merupakan bagian dari setiap operasi. AWS KMS Anda juga mengurangi risiko mengenkripsi data yang tidak dapat didekripsi. Fitur-fitur ini tidak efektif di luar AWS KMS. Lihat perinciannya di [Pertimbangan khusus untuk mengunduh kunci publik](#download-public-key-considerations).
**Tip**
Mencari kunci data atau kunci SSH? Topik ini menjelaskan cara mengelola kunci asimetris AWS Key Management Service, di mana kunci pribadi tidak dapat diekspor. Untuk pasangan kunci data yang dapat diekspor di mana kunci pribadi dilindungi oleh kunci KMS enkripsi simetris, lihat. [GenerateDataKeyPair](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyPair.html) [Untuk bantuan mengunduh kunci publik yang terkait dengan instans Amazon EC2, lihat *Mengambil kunci publik di Panduan Pengguna* Amazon EC2 [dan Panduan Pengguna Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/describe-keys.html#retrieving-the-public-key).](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/describe-keys.html#retrieving-the-public-key)
**Topics**
+ [Pertimbangan khusus untuk mengunduh kunci publik](#download-public-key-considerations)
+ [Unduh kunci publik](download-public-key.md)
+ [Contoh operasi offline](offline-operations.md)
## Pertimbangan khusus untuk mengunduh kunci publik
Untuk melindungi kunci KMS Anda, AWS KMS berikan kontrol akses, enkripsi yang diautentikasi, dan log terperinci dari setiap operasi. AWS KMS juga memungkinkan Anda untuk mencegah penggunaan kunci KMS, sementara atau permanen. Akhirnya, AWS KMS operasi dirancang untuk meminimalkan risiko mengenkripsi data yang tidak dapat didekripsi. Fitur-fitur ini tidak tersedia saat Anda menggunakan kunci publik yang diunduh di luar AWS KMS.
**Otorisasi**
[Kebijakan utama dan kebijakan](key-policies.md) [IAM](iam-policies.md) yang mengontrol akses ke kunci KMS di dalamnya tidak AWS KMS berpengaruh pada operasi yang dilakukan di luar. AWS Setiap pengguna yang bisa mendapatkan kunci publik dapat menggunakannya di luar AWS KMS meskipun mereka tidak memiliki izin untuk mengenkripsi data atau memverifikasi tanda tangan dengan kunci KMS.
**Pembatasan penggunaan kunci**
Pembatasan penggunaan utama tidak efektif di luar AWS KMS. Jika Anda memanggil operasi [Enkripsi](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) dengan kunci KMS yang memiliki `KeyUsage` of`SIGN_VERIFY`, AWS KMS operasi gagal. Tetapi jika Anda mengenkripsi data di luar AWS KMS dengan kunci publik dari kunci KMS dengan dari `SIGN_VERIFY` atau`KEY_AGREEMENT`, data tidak dapat didekripsi. `KeyUsage`
**Pembatasan algoritme**
Pembatasan pada enkripsi dan algoritma penandatanganan yang AWS KMS mendukung tidak efektif di luar. AWS KMS Jika Anda mengenkripsi data dengan kunci publik dari kunci KMS di luar AWS KMS, dan menggunakan algoritma enkripsi yang tidak mendukung, data AWS KMS tidak dapat didekripsi.
**Menonaktifkan dan menghapus kunci KMS**
Tindakan yang dapat Anda ambil untuk mencegah penggunaan kunci KMS dalam operasi kriptografi di dalam AWS KMS tidak mencegah siapa pun menggunakan kunci publik di luar. AWS KMS Misalnya, menonaktifkan kunci KMS, menjadwalkan penghapusan kunci KMS, menghapus kunci KMS, atau menghapus materi kunci dari kunci KMS tidak berpengaruh pada kunci publik di luar. AWS KMS Jika Anda menghapus kunci KMS asimetris atau menghapus atau kehilangan materi kuncinya, data yang Anda enkripsi dengan kunci publik di luar tidak dapat dipulihkan. AWS KMS
**Pencatatan log**
AWS CloudTrail log yang mencatat setiap AWS KMS operasi, termasuk permintaan, tanggapan, tanggal, waktu, dan pengguna yang berwenang, tidak mencatat penggunaan kunci publik di luar AWS KMS.
**Verifikasi offline dengan pasangan SM2 kunci (hanya Wilayah Tiongkok)**
Untuk memverifikasi tanda tangan di luar AWS KMS dengan kunci SM2 publik, Anda harus menentukan ID pembeda. Secara default, AWS KMS digunakan `1234567812345678` sebagai ID pembeda. Untuk informasi selengkapnya, lihat [Verifikasi offline dengan pasangan SM2 kunci (hanya Wilayah Tiongkok)](offline-operations.md#key-spec-sm-offline-verification).
# Unduh kunci publik
Anda dapat mengunduh kunci publik dari key pair KMS asimetris di AWS KMS konsol atau dengan menggunakan operasi. [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) Untuk mengunduh kunci publik, Anda harus memiliki `kms:GetPublicKey` izin pada kunci KMS asimetris.
[Kunci publik yang AWS KMS dikembalikan adalah kunci publik X.509 yang dikodekan DER, juga dikenal sebagai `SubjectPublicKeyInfo` (SPKI), sebagaimana didefinisikan dalam RFC 5280.](https://datatracker.ietf.org/doc/html/rfc5280) Bila Anda menggunakan HTTP API atau AWS CLI, nilainya adalah Base64-encoded. Jika tidak, itu tidak dikodekan Base64.
Untuk mengunduh kunci publik dari key pair KMS asimetris, Anda memerlukan `kms:GetPublicKey` izin. Untuk informasi selengkapnya tentang AWS KMS izin, lihat. [Referensi izin](kms-api-permissions-reference.md)
## Menggunakan AWS KMS konsol
Anda dapat menggunakan Konsol Manajemen AWS untuk melihat, menyalin, dan mengunduh kunci publik dari kunci KMS asimetris di kunci Anda. Akun AWS Untuk mengunduh kunci publik dari kunci KMS asimetris secara berbeda Akun AWS, gunakan API. AWS KMS
1. Masuk ke Konsol Manajemen AWS dan buka konsol AWS Key Management Service (AWS KMS) di [https://console.aws.amazon.com/kms](https://console.aws.amazon.com/kms).
1. Untuk mengubah Wilayah AWS, gunakan pemilih Wilayah di sudut kanan atas halaman.
1. Di panel navigasi, pilih **Kunci yang dikelola pelanggan**.
1. Pilih alias atau ID kunci dari kunci KMS asimetris.
1. Pilih tab **Konfigurasi kriptografi**. Catat nilai-nilai dari bidang **Spesifikasi kunci**, **Penggunaan kunci**, dan **Algoritme enkripsi** atau **Penandatanganan Algoritme**. Anda harus menggunakan nilai-nilai ini untuk menggunakan kunci publik di luar AWS KMS. Pastikan untuk membagikan informasi ini ketika Anda membagikan kunci publik.
1. Pilih tab **Kunci publik**.
1. Untuk menyalin kunci publik ke clipboard Anda, pilih **Salin**. Untuk mengunduh kunci publik ke file, pilih **Unduh**.
## Menggunakan AWS KMS API
[GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)Operasi mengembalikan kunci publik dalam kunci KMS asimetris. Ini juga mengembalikan informasi penting yang Anda butuhkan untuk menggunakan kunci publik dengan benar di luar AWS KMS, termasuk penggunaan kunci dan algoritma enkripsi. Pastikan untuk menyimpan nilai-nilai ini dan membagikannya setiap kali Anda berbagi kunci publik.
Contoh-contoh dalam bagian ini menggunakan [AWS Command Line Interface (AWS CLI)](https://aws.amazon.com/cli/), tetapi Anda dapat menggunakan bahasa pemrograman yang didukung.
[Untuk menentukan kunci KMS, gunakan [ID kunci, kunci](concepts.md#key-id-key-id)[ARN](concepts.md#key-id-key-ARN), nama alias[, atau alias](concepts.md#key-id-alias-name) ARN.](concepts.md#key-id-alias-ARN) Bila menggunakan nama alias, beri prefiks dengan **alias/**. Untuk menentukan kunci KMS yang berbeda Akun AWS, Anda harus menggunakan kunci ARN atau alias ARN.
Sebelum menjalankan perintah ini, ganti contoh nama alias dengan identifier yang valid untuk kunci KMS. Untuk menjalankan perintah ini, Anda harus memiliki `kms:GetPublicKey` izin pada kunci KMS.
```
$ aws kms get-public-key --key-id alias/example_RSA_3072
{
"KeySpec": "RSA_3072",
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyUsage": "ENCRYPT_DECRYPT",
"EncryptionAlgorithms": [
"RSAES_OAEP_SHA_1",
"RSAES_OAEP_SHA_256"
],
"PublicKey": "MIIBojANBgkqhkiG..."
}
```
# Contoh operasi offline
Setelah [mengunduh kunci publik dari key](download-public-key.md) pair KMS asimetris Anda, Anda dapat membagikannya dengan orang lain dan menggunakannya untuk melakukan operasi offline.
AWS CloudTrail log yang mencatat setiap AWS KMS operasi, termasuk permintaan, tanggapan, tanggal, waktu, dan pengguna yang berwenang, tidak mencatat penggunaan kunci publik di luar AWS KMS.
Topik ini memberikan contoh operasi offline dan detail yang AWS KMS disediakan alat untuk membuat operasi offline lebih mudah.
**Topics**
+ [Menurunkan rahasia bersama secara offline](#key-spec-ecc-offline)
+ [Verifikasi offline dengan pasangan kunci ML-DSA](#mldsa-offline-verification)
+ [Verifikasi offline dengan pasangan SM2 kunci (hanya Wilayah Tiongkok)](#key-spec-sm-offline-verification)
## Menurunkan rahasia bersama secara offline
Anda dapat [mengunduh kunci publik key](download-public-key.md) pair ECC Anda untuk digunakan dalam operasi offline, yaitu operasi di luar. AWS KMS
Panduan [OpenSSL](https://openssl.org/) berikut menunjukkan salah satu metode untuk memperoleh rahasia bersama di luar AWS KMS menggunakan kunci publik dari key pair ECC KMS dan kunci pribadi yang dibuat dengan OpenSSL.
1. Buat key pair ECC di OpenSSL dan persiapkan untuk digunakan. AWS KMS
```
// Create an ECC key pair in OpenSSL and save the private key in openssl_ecc_key_priv.pem
export OPENSSL_CURVE_NAME="P-256"
export KMS_CURVE_NAME="ECC_NIST_P256"
export OPENSSL_KEY1_PRIV_PEM="openssl_ecc_key1_priv.pem"
openssl ecparam -name ${OPENSSL_CURVE_NAME} -genkey -out ${OPENSSL_KEY1_PRIV_PEM}
// Derive the public key from the private key
export OPENSSL_KEY1_PUB_PEM="openssl_ecc_key1_pub.pem"
openssl ec -in ${OPENSSL_KEY1_PRIV_PEM} -pubout -outform pem \
-out ${OPENSSL_KEY1_PUB_PEM}
// View the PEM file containing the public key and extract the public key as a
// Base64 encoded string into OPENSSL_KEY1_PUB_BASE64 for use with AWS KMS
export OPENSSL_KEY1_PUB_BASE64=`cat ${OPENSSL_KEY1_PUB_PEM} | \
tee /dev/stderr | grep -v "PUBLIC KEY" | tr -d "\n"`
```
1. Buat key pair perjanjian kunci ECC AWS KMS dan persiapkan untuk digunakan dengan OpenSSL.
```
// Create a KMS key on the same curve as the key pair from step 1
// with a key usage of KEY_AGREEMENT
// Save its ARN in KMS_KEY1_ARN.
export KMS_KEY1_ARN=`aws kms create-key --key-spec ${KMS_CURVE_NAME} \
--key-usage KEY_AGREEMENT | tee /dev/stderr | jq -r .KeyMetadata.Arn`
// Download the public key and save the Base64-encoded version in KMS_KEY1_PUB_BASE64
export KMS_KEY1_PUB_BASE64=`aws kms get-public-key --key-id ${KMS_KEY1_ARN} | \
tee /dev/stderr | jq -r .PublicKey`
// Create a PEM file for the public KMS key for use with OpenSSL
export KMS_KEY1_PUB_PEM="aws_kms_ecdh_key1_pub.pem"
echo "-----BEGIN PUBLIC KEY-----" > ${KMS_KEY1_PUB_PEM}
echo ${KMS_KEY1_PUB_BASE64} | fold -w 64 >> ${KMS_KEY1_PUB_PEM}
echo "-----END PUBLIC KEY-----" >> ${KMS_KEY1_PUB_PEM}
```
1. Dapatkan shared secret di OpenSSL menggunakan private key di OpenSSL dan public KMS key.
```
export OPENSSL_SHARED_SECRET1_BIN="openssl_shared_secret1.bin"
openssl pkeyutl -derive -inkey ${OPENSSL_KEY1_PRIV_PEM} \
-peerkey ${KMS_KEY1_PUB_PEM} -out ${OPENSSL_SHARED_SECRET1_BIN}
```
## Verifikasi offline dengan pasangan kunci ML-DSA
AWS KMS mendukung varian lindung nilai penandatanganan ML-DSA, seperti yang dijelaskan dalam [Standar Pemrosesan Informasi Federal (FIPS) 204 bagian standar 3.4](https://csrc.nist.gov/pubs/fips/204/final) untuk pesan hingga 4 KB byte.
Untuk menandatangani pesan yang lebih besar dari 4 KB, Anda melakukan langkah pra-pemrosesan pesan di luar. AWS KMS Langkah hashing ini menciptakan perwakilan pesan 64-byte μ, seperti yang didefinisikan dalam NIST FIPS 204, bagian 6.2.
AWS KMS memiliki jenis pesan yang dipanggil `EXTERNAL_MU` untuk pesan yang lebih besar dari 4 KB. Saat Anda menggunakan ini, bukan jenis `RAW` pesan, AWS KMS:
+ Asumsikan Anda telah melakukan langkah hashing
+ Melewatkan proses hashing internalnya
+ Bekerja dengan pesan dari berbagai ukuran
Saat Anda memverifikasi pesan, metode yang Anda gunakan bergantung pada batasan ukuran sistem eksternal atau pustaka dan apakah itu mendukung perwakilan pesan 64-byte μ:
+ Jika pesan lebih kecil dari batasan ukuran, gunakan jenis `RAW` pesan.
+ Jika pesan lebih besar dari batasan ukuran, gunakan representatif μ di sistem eksternal.
Bagian berikut menunjukkan cara menandatangani pesan menggunakan AWS KMS dan memverifikasi pesan menggunakan OpenSSL. Kami memberikan contoh untuk pesan di bawah dan di atas batas ukuran pesan 4 KB yang diberlakukan oleh AWS KMS. OpenSSL tidak memberlakukan batasan ukuran pesan untuk verifikasi.
Untuk kedua contoh, pertama-tama dapatkan kunci publik dari AWS KMS. Gunakan perintah AWS CLI berikut:
```
aws kms get-public-key \
--key-id _<1234abcd-12ab-34cd-56ef-1234567890ab>_ \
--output text \
--query PublicKey | base64 --decode > public_key.der
```
### Ukuran pesan kurang dari 4KB
Untuk pesan di bawah 4 KB, gunakan jenis `RAW` pesan dengan AWS KMS. Meskipun Anda dapat menggunakan`EXTERNAL_MU`, tidak perlu untuk pesan dalam batas ukuran.
Gunakan AWS CLI perintah berikut untuk menandatangani pesan:
```
aws kms sign \
--key-id _<1234abcd-12ab-34cd-56ef-1234567890ab>_ \
--message 'your message' \
--message-type RAW \
--signing-algorithm ML_DSA_SHAKE_256 \
--output text \
--query Signature | base64 --decode > ExampleSignature.bin
```
Untuk memverifikasi pesan ini menggunakan OpenSSL gunakan perintah berikut:
```
echo -n 'your message' | ./openssl dgst -verify public_key.der -signature ExampleSignature.bin
```
### Ukuran pesan lebih dari 4KB
Untuk menandatangani pesan yang lebih besar dari 4KB, gunakan jenis `EXTERNAL_MU` pesan. Saat Anda menggunakan`EXTERNAL_MU`, Anda melakukan pra-hash pesan secara eksternal ke perwakilan 64-byte μ seperti yang didefinisikan dalam NIST FIPS 204 bagian 6.2 dan meneruskannya ke operasi penandatanganan atau verifikasi. Perhatikan bahwa ini berbeda dari “Pra-hash MLDSA” atau HashML-DSA yang didefinisikan dalam NIST FIPS 204 bagian 5.4.
1. Pertama, buat awalan pesan. Awalan berisi pemisah domain, panjang konteks apa pun, dan konteksnya. Default untuk pemisah domain dan panjang konteks adalah nol.
1. Tambahkan awalan pesan ke pesan.
1. Gunakan SHAKE256 untuk hash kunci publik dan menutupinya ke hasil langkah 2.
1. Akhirnya, hash hasil langkah 3 untuk menghasilkan `EXTERNAL_MU` 64-byte.
Contoh berikut menggunakan OpenSSL 3.5 untuk membangun: `EXTERNAL_MU`
```
{
openssl asn1parse -inform DER -in public_key.der -strparse 17 -noout -out - 2>/dev/null |
openssl dgst -provider default -shake256 -xoflen 64 -binary;
printf '\x00\x00';
echo -n "your message"
} | openssl dgst -provider default -shake256 -xoflen 64 -binary > mu.bin
```
Setelah Anda membuat `mu.bin` file, panggil AWS KMS API dengan perintah berikut untuk menandatangani pesan:
```
aws kms sign \
--key-id _<1234abcd-12ab-34cd-56ef-1234567890ab>_ \
--message fileb://mu.bin \
--message-type EXTERNAL_MU \
--signing-algorithm ML_DSA_SHAKE_256 \
--output text \
--query Signature | base64 --decode > ExampleSignature.bin
```
Tanda tangan yang dihasilkan sama dengan `RAW` tanda tangan pada pesan asli. Anda dapat menggunakan perintah OpenSSL 3.5 yang sama untuk memverifikasi pesan:
```
echo -n 'your message' | ./openssl dgst -verify public_key.der -signature ExampleSignature.bin
```
## Verifikasi offline dengan pasangan SM2 kunci (hanya Wilayah Tiongkok)
Untuk memverifikasi tanda tangan di luar AWS KMS dengan kunci SM2 publik, Anda harus menentukan ID pembeda. Saat Anda meneruskan pesan mentah, ke [Sign](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html) API [https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html#KMS-Sign-request-MessageType](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html#KMS-Sign-request-MessageType), AWS KMS menggunakan ID pembeda default, yang ditentukan oleh OSCCA di 0009-2012. `1234567812345678` GM/T Anda tidak dapat menentukan ID pembeda Anda sendiri di dalamnya AWS KMS.
Namun, jika Anda membuat intisari pesan di luar AWS, Anda dapat menentukan ID pembeda Anda sendiri, lalu meneruskan intisari pesan, [https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html#API_Sign_RequestSyntax](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html#API_Sign_RequestSyntax), untuk AWS KMS menandatangani. Untuk melakukan ini, ubah `DEFAULT_DISTINGUISHING_ID` nilai di `SM2OfflineOperationHelper` kelas. ID pembeda yang Anda tentukan dapat berupa string apa pun hingga 8,192 karakter. Setelah AWS KMS menandatangani intisari pesan, Anda memerlukan intisari pesan atau pesan dan ID pembeda yang digunakan untuk menghitung intisari untuk memverifikasinya secara offline.
**penting**
Kode `SM2OfflineOperationHelper` referensi dirancang agar kompatibel dengan [Bouncy Castle](https://www.bouncycastle.org/documentation/documentation-java/) versi 1.68. Untuk bantuan dengan versi lain, hubungi [bouncycastle.org](https://www.bouncycastle.org).
### `SM2OfflineOperationHelper` kelas
Untuk membantu Anda dengan operasi offline dengan SM2 kunci, `SM2OfflineOperationHelper` kelas untuk Java memiliki metode yang melakukan tugas untuk Anda. Anda dapat menggunakan kelas pembantu ini sebagai model untuk penyedia kriptografi lainnya.
Di dalamnya AWS KMS, konversi ciphertext mentah dan perhitungan intisari pesan SM2 DSA terjadi secara otomatis. Tidak semua penyedia kriptografi menerapkan dengan SM2 cara yang sama. Beberapa pustaka, seperti [OpenSSL](https://openssl.org/) versi 1.1.1 dan yang lebih baru, melakukan tindakan ini secara otomatis. AWS KMS mengkonfirmasi perilaku ini dalam pengujian dengan OpenSSL versi 3.0. Gunakan `SM2OfflineOperationHelper` kelas berikut dengan pustaka, seperti [Bouncy Castle](https://www.bouncycastle.org/java.html), yang mengharuskan Anda melakukan konversi dan perhitungan ini secara manual.
`SM2OfflineOperationHelper`Kelas menyediakan metode untuk operasi offline berikut:
+
**Perhitungan intisari pesan**
Untuk menghasilkan intisari pesan secara offline yang dapat Anda gunakan untuk verifikasi offline, atau yang dapat diteruskan AWS KMS ke tanda tangan, gunakan `calculateSM2Digest` metode ini. `calculateSM2Digest`Metode ini menghasilkan intisari pesan dengan algoritma SM3 hashing. [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API mengembalikan kunci publik Anda dalam format biner. Anda harus mengurai kunci biner menjadi Java PublicKey. Berikan kunci publik yang diurai dengan pesan. Metode ini secara otomatis menggabungkan pesan Anda dengan ID pembeda default`1234567812345678`, tetapi Anda dapat mengatur ID pembeda Anda sendiri dengan mengubah nilainya. `DEFAULT_DISTINGUISHING_ID`
+
**Verifikasi**
Untuk memverifikasi tanda tangan secara offline, gunakan `offlineSM2DSAVerify` metode ini. `offlineSM2DSAVerify`Metode ini menggunakan intisari pesan yang dihitung dari ID pembeda yang ditentukan, dan pesan asli yang Anda berikan untuk memverifikasi tanda tangan digital. [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API mengembalikan kunci publik Anda dalam format biner. Anda harus mengurai kunci biner menjadi Java PublicKey. Berikan kunci publik yang diuraikan dengan pesan asli dan tanda tangan yang ingin Anda verifikasi. Untuk detail selengkapnya, lihat [Verifikasi offline dengan pasangan SM2 kunci](#key-spec-sm-offline-verification).
+
**Enkripsi**
Untuk mengenkripsi plaintext offline, gunakan metode ini. `offlineSM2PKEEncrypt` Metode ini memastikan ciphertext dalam format AWS KMS dapat mendekripsi. `offlineSM2PKEEncrypt`Metode mengenkripsi plaintext, dan kemudian mengonversi ciphertext mentah yang dihasilkan oleh PKE ke format ASN.1. SM2 [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API mengembalikan kunci publik Anda dalam format biner. Anda harus mengurai kunci biner menjadi Java PublicKey. Berikan kunci publik yang diurai dengan plaintext yang ingin Anda enkripsi.
Jika Anda tidak yakin apakah Anda perlu melakukan konversi, gunakan operasi OpenSSL berikut untuk menguji format ciphertext Anda. Jika operasi gagal, Anda perlu mengonversi ciphertext ke format ASN.1.
```
openssl asn1parse -inform DER -in ciphertext.der
```
Secara default, `SM2OfflineOperationHelper` kelas menggunakan ID pembeda default`1234567812345678`, saat menghasilkan intisari pesan untuk operasi SM2 DSA.
```
package com.amazon.kms.utils;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import org.bouncycastle.crypto.CryptoException;
import org.bouncycastle.jce.interfaces.ECPublicKey;
import java.util.Arrays;
import org.bouncycastle.asn1.ASN1EncodableVector;
import org.bouncycastle.asn1.ASN1Integer;
import org.bouncycastle.asn1.DEROctetString;
import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.asn1.gm.GMNamedCurves;
import org.bouncycastle.asn1.x9.X9ECParameters;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.params.ParametersWithID;
import org.bouncycastle.crypto.params.ParametersWithRandom;
import org.bouncycastle.crypto.signers.SM2Signer;
import org.bouncycastle.jcajce.provider.asymmetric.util.ECUtil;
public class SM2OfflineOperationHelper {
// You can change the DEFAULT_DISTINGUISHING_ID value to set your own distinguishing ID,
// the DEFAULT_DISTINGUISHING_ID can be any string up to 8,192 characters long.
private static final byte[] DEFAULT_DISTINGUISHING_ID = "1234567812345678".getBytes(StandardCharsets.UTF_8);
private static final X9ECParameters SM2_X9EC_PARAMETERS = GMNamedCurves.getByName("sm2p256v1");
// ***calculateSM2Digest***
// Calculate message digest
public static byte[] calculateSM2Digest(final PublicKey publicKey, final byte[] message) throws
NoSuchProviderException, NoSuchAlgorithmException {
final ECPublicKey ecPublicKey = (ECPublicKey) publicKey;
// Generate SM3 hash of default distinguishing ID, 1234567812345678
final int entlenA = DEFAULT_DISTINGUISHING_ID.length * 8;
final byte [] entla = new byte[] { (byte) (entlenA & 0xFF00), (byte) (entlenA & 0x00FF) };
final byte [] a = SM2_X9EC_PARAMETERS.getCurve().getA().getEncoded();
final byte [] b = SM2_X9EC_PARAMETERS.getCurve().getB().getEncoded();
final byte [] xg = SM2_X9EC_PARAMETERS.getG().getXCoord().getEncoded();
final byte [] yg = SM2_X9EC_PARAMETERS.getG().getYCoord().getEncoded();
final byte[] xa = ecPublicKey.getQ().getXCoord().getEncoded();
final byte[] ya = ecPublicKey.getQ().getYCoord().getEncoded();
final byte[] za = MessageDigest.getInstance("SM3", "BC")
.digest(ByteBuffer.allocate(entla.length + DEFAULT_DISTINGUISHING_ID.length + a.length + b.length + xg.length + yg.length +
xa.length + ya.length).put(entla).put(DEFAULT_DISTINGUISHING_ID).put(a).put(b).put(xg).put(yg).put(xa).put(ya)
.array());
// Combine hashed distinguishing ID with original message to generate final digest
return MessageDigest.getInstance("SM3", "BC")
.digest(ByteBuffer.allocate(za.length + message.length).put(za).put(message)
.array());
}
// ***offlineSM2DSAVerify***
// Verify digital signature with SM2 public key
public static boolean offlineSM2DSAVerify(final PublicKey publicKey, final byte [] message,
final byte [] signature) throws InvalidKeyException {
final SM2Signer signer = new SM2Signer();
CipherParameters cipherParameters = ECUtil.generatePublicKeyParameter(publicKey);
cipherParameters = new ParametersWithID(cipherParameters, DEFAULT_DISTINGUISHING_ID);
signer.init(false, cipherParameters);
signer.update(message, 0, message.length);
return signer.verifySignature(signature);
}
// ***offlineSM2PKEEncrypt***
// Encrypt data with SM2 public key
public static byte[] offlineSM2PKEEncrypt(final PublicKey publicKey, final byte [] plaintext) throws
NoSuchPaddingException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeyException,
BadPaddingException, IllegalBlockSizeException, IOException {
final Cipher sm2Cipher = Cipher.getInstance("SM2", "BC");
sm2Cipher.init(Cipher.ENCRYPT_MODE, publicKey);
// By default, Bouncy Castle returns raw ciphertext in the c1c2c3 format
final byte [] cipherText = sm2Cipher.doFinal(plaintext);
// Convert the raw ciphertext to the ASN.1 format before passing it to AWS KMS
final ASN1EncodableVector asn1EncodableVector = new ASN1EncodableVector();
final int coordinateLength = (SM2_X9EC_PARAMETERS.getCurve().getFieldSize() + 7) / 8 * 2 + 1;
final int sm3HashLength = 32;
final int xCoordinateInCipherText = 33;
final int yCoordinateInCipherText = 65;
byte[] coords = new byte[coordinateLength];
byte[] sm3Hash = new byte[sm3HashLength];
byte[] remainingCipherText = new byte[cipherText.length - coordinateLength - sm3HashLength];
// Split components out of the ciphertext
System.arraycopy(cipherText, 0, coords, 0, coordinateLength);
System.arraycopy(cipherText, cipherText.length - sm3HashLength, sm3Hash, 0, sm3HashLength);
System.arraycopy(cipherText, coordinateLength, remainingCipherText, 0,cipherText.length - coordinateLength - sm3HashLength);
// Build standard SM2PKE ASN.1 ciphertext vector
asn1EncodableVector.add(new ASN1Integer(new BigInteger(1, Arrays.copyOfRange(coords, 1, xCoordinateInCipherText))));
asn1EncodableVector.add(new ASN1Integer(new BigInteger(1, Arrays.copyOfRange(coords, xCoordinateInCipherText, yCoordinateInCipherText))));
asn1EncodableVector.add(new DEROctetString(sm3Hash));
asn1EncodableVector.add(new DEROctetString(remainingCipherText));
return new DERSequence(asn1EncodableVector).getEncoded("DER");
}
}
```