Cara menggunakan enkripsi url di javascript

________dua puluh satu_______

function base_encode($id) {
    return str_replace(["A", "+", "/", "="], ["AA", "AB", "AC", "AD"], base64_encode($id));
}

function base_decode($id) {
    $id = preg_replace_callback('/(AA)|(AB)|(AC)|(AD)/', function ($m) {
        foreach(['A', '+', '/', '='] as $i => $value)
            if($m[$i + 1])
                return $value;
    }, $id);
    return base64_decode($id);
}
?>

this functions escapes symbol 'A' as 'AA', '+' as 'AB', '/' as 'AC', '=' as 'AD'.

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahannya berbeda dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris

Dengan Amazon CloudFront, Anda dapat menerapkan koneksi end-to-end aman ke server asal menggunakan HTTPS. Enkripsi tingkat lapangan menambahkan lapisan keamanan tambahan yang memungkinkan Anda melindungi data tertentu selama pemrosesan sistem sehingga hanya aplikasi tertentu yang dapat dilihat

Enkripsi tingkat lapangan memungkinkan pengguna Go untuk mengunggah informasi sensitif secara aman ke server web Go. Informasi sensitif yang diberikan oleh pengguna Anda dienkripsi di edge, dekat dengan pengguna, dan tetap dienkripsi di seluruh tumpukan aplikasi Anda. Enkripsi ini memastikan bahwa hanya aplikasi yang memerlukan data—dan memiliki kredensial untuk mendekripsinya—dapat melakukannya

Untuk menggunakan tingkat enkripsi lapangan, saat Anda mengonfigurasi distribusi CloudFront, tentukan rangkaian bidang di POST yang ingin dienkripsi, dan kunci publik yang digunakan untuk mengenkripsinya. Anda dapat mengenkripsi hingga 10 kolom data dalam permintaan. (Anda tidak dapat mengenkripsi semua data dalam permintaan dengan enkripsi tingkat lapangan; Anda harus menentukan bidang individu untuk mengenkripsi. )

Ketika permintaan HTTPS dengan tingkat enkripsi lapangan diteruskan ke asal, dan permintaan diarahkan ke seluruh aplikasi atau subsistem asal Anda, data sensitif masih dienkripsi, sehingga mengurangi risiko pelanggaran data atau kehilangan data sensitif yang tidak dapat dikendalikan. Komponen yang membutuhkan akses ke data sensitif untuk alasan bisnis, seperti sistem pemrosesan pembayaran yang memerlukan akses ke nomor kredit, dapat menggunakan kunci pribadi yang sesuai untuk mendekripsi dan mengakses data

Untuk menggunakan enkripsi tingkat-lapangan, asal Anda harus mendukung pengkodean yang disusun ( chunked encoding)

CloudFront enkripsi tingkat lapangan menggunakan enkripsi asimetris, yang juga dikenal sebagai enkripsi kunci publik. Anda menyediakan kunci publik untuk CloudFront, dan semua data sensitif yang Anda tetapkan dienkripsi secara otomatis. Kunci yang Anda berikan CloudFront tidak dapat digunakan untuk mendekripsi nilai terenkripsi;

Ikhtisar enkripsi tingkat lapangan

Langkah-langkah berikut memberikan ikhtisar pengaturan enkripsi tingkat lapangan. Untuk langkah spesifik, lihat

1. Dapatkan key pair publik-pribadi. Anda harus mendapatkan dan menambahkan kunci publik sebelum memulai pengaturan enkripsi tingkat lapangan di CloudFront

2. Buat profil enkripsi tingkat lapangan. Profil enkripsi tingkat lapangan, yang Anda buat CloudFront, tetapkan bidang yang Anda inginkan untuk dienkripsi

3. Buat konfigurasi enkripsi tingkat lapangan. Konfigurasi menentukan profil yang akan digunakan, berdasarkan jenis permintaan atau argumen kueri, untuk mengenkripsi kolom data spesifik. Anda juga dapat memilih opsi perilaku permintaan-penerusan yang Anda inginkan untuk skenario yang berbeda. Misalnya, Anda dapat mengatur perilaku untuk ketika nama profil yang ditentukan oleh argumen kueri dalam permintaan URL tidak ada CloudFront

4. Tautan ke perilaku cache. Menautkan konfigurasi ke perilaku cache untuk distribusi, untuk menentukan kapan CloudFront harus mengenkripsi data

tolongenkripsi tingkat lapangan

langkah Ikuti-langkah ini untuk mulai menggunakan enkripsi tingkat lapangan. Untuk mempelajari tentang kuota (sebelumnya dikenal sebagai batas) pada enkripsi tingkat lapangan, lihat Quotas

langkah 1. Buat pasangan kunci RSA

Untuk memulai, Anda harus membuat pasangan kunci RSA yang mencakup kunci publik dan kunci pribadi. Kunci publik memungkinkan CloudFront untuk mengenkripsi data, dan kunci privat memungkinkan komponen di tempat asal Anda untuk mendekripsi bidang yang telah dienkripsi. Anda dapat menggunakan OpenSSL atau alat lain untuk membuat pasangan kunci. Ukuran kunci harus 2048 bit

Misalnya, jika Anda menggunakan OpenSSL, Anda dapat menggunakan perintah berikut untuk membuat pasangan kunci dengan panjang 2048 bit dan menyimpannya dalam file private_key.pem

openssl genrsa -out private_key.pem 2048

Berkas yang dihasilkan berisi baik publik maupun kunci pribadi. Untuk mengekstrak kunci publik dari file tersebut, jalankan perintah berikut

File kunci publik (public_key.pem) berisi nilai kunci terkode yang Anda tempelkan pada langkah berikut

langkah 2. tambahkan kunci publik Anda keCloudFront

Setelah Anda mendapatkan pasangan kunci RSA Anda, tambahkan kunci publik Anda CloudFront

Untuk menambahkan kunci publik Anda ke CloudFront (konsol)

1. Masuk ke AWS Management Console dan buka CloudFront konsol di https. // konsol. wow. amazon. com/cloudfront/v3/home

2. Pada panel navigasi, pilih Kunci publik

3. Pilih tambahkan kunci publik

4. Untuk Nama kunci, ketikkan nama unik untuk kunci. Nama tidak boleh memiliki spasi dan hanya dapat menyertakan karakter alfanumerik, garis bawah (_), dan tanda hubung (-). Jumlah karakter maksimum adalah 128

5. Untuk Nilai utama, tempelkan nilai utama yang disandikan untuk kunci publik Anda, termasuk -----BEGIN PUBLIC KEY----- dan -----END PUBLIC KEY----- yang tepat

6. Untuk Komentar, tambahkan komentar opsional. Misalnya, Anda dapat menyertakan tanggal kedaluwarsa kunci publik

7. Pilih Tambahkan

Anda dapat menambahkan lebih banyak tombol untuk menggunakan CloudFront dengan mengulang langkah-langkah dalam prosedur

langkah 3. Buat profil untuk enkripsi tingkat lapangan

Setelah Anda menambahkan setidaknya satu kunci publik ke CloudFront, buat profil yang memberi tahu bidangCloudFront mana yang harus dienkripsi

Untuk membuat profil enkripsi tingkat lapangan (konsole)

1. Di panel navigasi, pilih Enkripsi tingkat lapangan

2. Pilih Buat profil

3. Isi kolom berikut

   Nama profil

   Ketikkan nama unik untuk profil. Nama tidak boleh memiliki spasi dan hanya dapat menyertakan karakter alfanumerik, garis bawah (_), dan tanda hubung (-). Jumlah karakter maksimum adalah 128

   nama kunci publik

   Di daftar menurun, pilih nama kunci publik yang Anda tambahkan CloudFront pada langkah 2. CloudFront menggunakan kunci untuk mengenkripsi kolom yang Anda tentukan dalam profil ini

   Nama Penyedia

   Ketikkan frase untuk membantu mengidentifikasi kunci, seperti penyedia tempat Anda mendapatkan pasangan kunci. Informasi ini, bersama dengan kunci pribadi, diperlukan saat aplikasi mendekripsi data bidang. Nama penyedia tidak boleh memiliki spasi dan hanya dapat menyertakan karakter alfanumerik, usus ciuman (. ), garis bawah (_), dan tanda hubung (-). Jumlah karakter maksimum adalah 128

   Pola nama bidang agar cocok

   Ketik nama bidang data, atau pola yang mengidentifikasi data nama bidang dalam permintaan, yang Anda inginkan CloudFront untuk mengenkripsi. Pilih opsi + untuk menambahkan semua kolom yang ingin Anda enkripsi dengan kunci ini

   Untuk pola nama bidang, Anda dapat mengetik data seluruh nama bidang, seperti DateOfBirth, atau hanya bagian nama pertama dengan karakter wildcard (*), CreditCard seperti*. Pola nama bidang hanya dapat menyertakan karakter alfanumerik, tanda kurung persegi ([ dan ]), titik (. ), garis bawah (_), dan tanda hubung (-), selain karakter wildcard opsional (*)

   Pastikan Anda tidak menggunakan karakter yang tumpang tindih untuk pola nama bidang yang berbeda. Misalnya, jika Anda memiliki pola nama kolom ABC*, Anda tidak dapat menambahkan pola nama bidang lain yang merupakan AB*. Selain itu, nama bidang bersifat peka huruf besar dan jumlah karakter maksimal yang dapat Anda gunakan adalah 128

   Komentar

   (Opsional) Ketik komentar tentang profil ini. Jumlah maksimal karakter yang dapat Anda gunakan adalah 128

4. Setelah mengisi kolom, pilih Buat profil

5. Jika Anda ingin menambahkan profil lagi, pilih tambahkan profil

langkah 4. Buat Konfigurasi

Setelah Anda membuat satu atau lebih profil enkripsi tingkat lapangan, buat konfigurasi yang menentukan jenis konten permintaan yang mencakup data yang akan dienkripsi, profil yang akan digunakan untuk enkripsi, dan opsi lain yang menentukan apa yang Anda inginkan CloudFront untuk menangani enkripsi

Misalnya, jika CloudFront tidak dapat mengenkripsi data, Anda dapat menentukan apakah CloudFront harus memblokir atau meneruskan permintaan ke negara asal Anda dalam skenario berikut

• Bila jenis konten permintaan tidak dalam konfigurasi — Jika belum menambahkan jenis konten ke konfigurasi, Anda dapat menentukan apakah CloudFront harus meneruskan permintaan dengan jenis konten tersebut ke tempat asal tanpa mengenkripsi kolom data, atau memblokir permintaan dan mengembalikan kesalahan

  Jika Anda menambahkan jenis konten ke konfigurasi tetapi belum menentukan profil untuk digunakan dengan jenis tersebut, CloudFront selalu meneruskan permintaan dengan jenis konten tersebut ke asal

• Bila nama profil yang diberikan dalam argumen kueri tidak diketahui — Saat Anda menentukan argumenfle-profile kueri dengan nama profil yang tidak ada untuk distribusi Anda, Anda dapat menentukan apakah CloudFront harus mengirim permintaan ke tempat awal tanpa mengenkripsi kolommblom data, akilarim danki

Dalam konfigurasi, Anda juga dapat menentukan apakah memberikan profil sebagai argumen kueri dalam URL yang membatalkan profil yang telah dipetakan ke jenis konten untuk kueri tersebut. Secara default, CloudFront menggunakan profil yang telah Anda petakan ke jenis konten, jika Anda menentukannya. Ini memungkinkan Anda memiliki profil yang digunakan secara default tetapi memutuskan permintaan tertentu yang ingin Anda gunakan profil berbeda

Jadi, misalnya, Anda dapat menentukan (dalam konfigurasi Anda) SampleProfile sebagai profil argumen kueri untuk digunakan. Kemudian, Anda dapat menggunakan URLhttps://d1234.cloudfront.net?fle-profile=SampleProfile alih-alih

openssl rsa -pubout -in private_key.pem -out public_key.pem

Anda dapat membuat hingga 10 konfigurasi untuk satu akun, lalu menambahkan salah satu konfigurasi ke perilaku cache dari setiap distribusi ke akun

Untuk membuat konfigurasi enkripsi tingkat lapangan (konsole)

1. Di Enkripsi tingkat lapangan halaman, pilih Buat konfigurasi

   Catatan. Jika Anda belum membuat setidaknya satu profil, Anda tidak akan melihat opsi untuk membuat konfigurasi

2. Isi kolom berikut untuk menentukan profil yang akan digunakan. (Beberapa kolom tidak dapat diubah. )

   Jenis konten (tidak dapat diubah)

   Jenis konten diatur ke

   openssl rsa -pubout -in private_key.pem -out public_key.pem

   _2 dan tidak dapat diubah
   Standar profil ID (opsional)

   Di daftar menurun, pilih profil yang ingin Anda petakan ke jenis konten di Jenis konten bidang

   Format konten (tidak dapat diubah)

   Format konten diatur ke

   openssl rsa -pubout -in private_key.pem -out public_key.pem

   _3 dan tidak dapat diubah

3. Jika Anda ingin mengubah perilaku CloudFront default untuk opsi berikut, pilih kotak centang yang sesuai

   Teruskan permintaan ke asal ketika jenis konten permintaan tidak dikonfigurasi

   Pilih kotak centang jika Anda ingin menerbitkan permintaan untuk pergi ke asal Anda jika Anda belum menentukan profil yang akan digunakan untuk jenis permintaan konten tersebut

   Ubah profil untuk jenis konten dengan argumen kueri yang diberikan

   Centang kotak jika Anda ingin mempublikasikan profil yang diberikan dalam argumen kueri menimpa profil yang telah Anda tentukan untuk jenis konten

4. Jika Anda memilih kotak centang untuk mengeluarkan argumen kueri menimpa profil default, Anda harus melengkapi kolom tambahan berikut untuk konfigurasi. Anda dapat membuat hingga lima konflik argumen kueri ini untuk digunakan dengan kueri

   pertanyaan argumen

   Ketik nilai yang ingin Anda masukkan dalam URL untuk argumen kueri fle-profile. Nilai ini memberi tahuCloudFront untuk menggunakan profil ID (yang Anda tentukan di kolom berikutnya) yang terkait dengan argumen kueri ini untuk enkripsi tingkat lapangan untuk kueri ini

   Jumlah maksimal karakter yang dapat Anda gunakan adalah 128. Nilai tidak boleh menyertakan spasi, dan hanya boleh menggunakan karakter alfanumerik atau karakter berikut. tanda hubung (-), titik (. ), garis bawah (_), tanda bintang (*), tanda tambah (+), persen (%)

   ID profil

   Di daftar menurun, pilih profil yang ingin Anda kaitkan dengan nilai yang Anda masukkan Argumen pertanyaan

   Teruskan permintaan ke asal ketika profil yang ditentukan dalam argumen kueri tidak ada

   Pilih kotak centang jika Anda ingin menerbitkan permintaan untuk pergi ke asal Anda jika profil yang ditentukan dalam argumen kueri tidak didefinisikan dalam CloudFront

langkah 5. Tambahkan konfigurasi ke cache perilaku

Untuk menggunakan enkripsi tingkat lapangan, ubah konfigurasi ke perilaku cache untuk distribusi dengan menambahkan ID konfigurasi sebagai nilai untuk distribusi Anda

Untuk menautkan konfigurasi enkripsi tingkat lapangan ke perilaku cache, distribusi harus dikonfigurasi untuk selalu menggunakan HTTPS, dan untuk menerima HTTP

openssl rsa -pubout -in private_key.pem -out public_key.pem

openssl rsa -pubout -in private_key.pem -out public_key.pem

• Peraturan yang disinggahi Kebijakan Protokol Penampil harus diatur menjadi Arahkan ulang HTTP ke HTTPS atau HTTPS Saja. (DalamAWS CloudFormation atau CloudFront API,

  openssl rsa -pubout -in private_key.pem -out public_key.pem

  7 harus diatur ke

  openssl rsa -pubout -in private_key.pem -out public_key.pem

  8 atau

  openssl rsa -pubout -in private_key.pem -out public_key.pem

  9. )

• perilaku singgah Metode HTTP yang pelanggaran harus ditetapkan ke DAPATKAN, KEPALA, OPSI, PUT, POST, PATCH, DELETE. (DalamAWS CloudFormation atau CloudFront API,

  
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.security.KeyFactory;
  import java.security.PrivateKey;
  import java.security.PublicKey;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  
  import org.apache.commons.codec.binary.Base64;
  
  import com.amazonaws.encryptionsdk.AwsCrypto;
  import com.amazonaws.encryptionsdk.CryptoResult;
  import com.amazonaws.encryptionsdk.jce.JceMasterKey;
  
  /**
   * Sample example of decrypting data that has been encrypted by CloudFront field-level encryption.
   */
  public class DecryptExample {
  
      private static final String PRIVATE_KEY_FILENAME = "private_key.der";
      private static final String PUBLIC_KEY_FILENAME = "public_key.der";
      private static PublicKey publicKey;
      private static PrivateKey privateKey;
  
      // CloudFront uses the following values to encrypt data, and your origin must use same values to decrypt it.
      // In your own code, for PROVIDER_NAME, use the provider name that you specified when you created your field-level
      // encryption profile. This sample uses 'DEMO' for the value.
      private static final String PROVIDER_NAME = "DEMO";
      // In your own code, use the key name that you specified when you added your public key to CloudFront. This sample
      // uses 'DEMOKEY' for the key name.
      private static final String KEY_NAME = "DEMOKEY";
      // CloudFront uses this algorithm when encrypting data.
      private static final String ALGORITHM = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding";
  
      public static void main(final String[] args) throws Exception {
  
          final String dataToDecrypt = args[0];
  
          // This sample uses files to get public and private keys.
          // In practice, you should distribute the public key and save the private key in secure storage.
          populateKeyPair();
  
          System.out.println(decrypt(debase64(dataToDecrypt)));
      }
  
      private static String decrypt(final byte[] bytesToDecrypt) throws Exception {
          // You can decrypt the stream only by using the private key.
  
          // 1. Instantiate the SDK
          final AwsCrypto crypto = new AwsCrypto();
  
          // 2. Instantiate a JCE master key
          final JceMasterKey masterKey = JceMasterKey.getInstance(
                  publicKey,
                  privateKey,
                  PROVIDER_NAME,
                  KEY_NAME,
                  ALGORITHM);
  
          // 3. Decrypt the data
          final CryptoResult  result = crypto.decryptData(masterKey, bytesToDecrypt);
          return new String(result.getResult());
      }
  
      // Function to decode base64 cipher text.
      private static byte[] debase64(final String value) {
          return Base64.decodeBase64(value.getBytes());
      }
  
      private static void populateKeyPair() throws Exception {
          final byte[] PublicKeyBytes = Files.readAllBytes(Paths.get(PUBLIC_KEY_FILENAME));
          final byte[] privateKeyBytes = Files.readAllBytes(Paths.get(PRIVATE_KEY_FILENAME));
          publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(PublicKeyBytes));
          privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
      }
  }

  0 harus diatur ke

  
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.security.KeyFactory;
  import java.security.PrivateKey;
  import java.security.PublicKey;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  
  import org.apache.commons.codec.binary.Base64;
  
  import com.amazonaws.encryptionsdk.AwsCrypto;
  import com.amazonaws.encryptionsdk.CryptoResult;
  import com.amazonaws.encryptionsdk.jce.JceMasterKey;
  
  /**
   * Sample example of decrypting data that has been encrypted by CloudFront field-level encryption.
   */
  public class DecryptExample {
  
      private static final String PRIVATE_KEY_FILENAME = "private_key.der";
      private static final String PUBLIC_KEY_FILENAME = "public_key.der";
      private static PublicKey publicKey;
      private static PrivateKey privateKey;
  
      // CloudFront uses the following values to encrypt data, and your origin must use same values to decrypt it.
      // In your own code, for PROVIDER_NAME, use the provider name that you specified when you created your field-level
      // encryption profile. This sample uses 'DEMO' for the value.
      private static final String PROVIDER_NAME = "DEMO";
      // In your own code, use the key name that you specified when you added your public key to CloudFront. This sample
      // uses 'DEMOKEY' for the key name.
      private static final String KEY_NAME = "DEMOKEY";
      // CloudFront uses this algorithm when encrypting data.
      private static final String ALGORITHM = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding";
  
      public static void main(final String[] args) throws Exception {
  
          final String dataToDecrypt = args[0];
  
          // This sample uses files to get public and private keys.
          // In practice, you should distribute the public key and save the private key in secure storage.
          populateKeyPair();
  
          System.out.println(decrypt(debase64(dataToDecrypt)));
      }
  
      private static String decrypt(final byte[] bytesToDecrypt) throws Exception {
          // You can decrypt the stream only by using the private key.
  
          // 1. Instantiate the SDK
          final AwsCrypto crypto = new AwsCrypto();
  
          // 2. Instantiate a JCE master key
          final JceMasterKey masterKey = JceMasterKey.getInstance(
                  publicKey,
                  privateKey,
                  PROVIDER_NAME,
                  KEY_NAME,
                  ALGORITHM);
  
          // 3. Decrypt the data
          final CryptoResult  result = crypto.decryptData(masterKey, bytesToDecrypt);
          return new String(result.getResult());
      }
  
      // Function to decode base64 cipher text.
      private static byte[] debase64(final String value) {
          return Base64.decodeBase64(value.getBytes());
      }
  
      private static void populateKeyPair() throws Exception {
          final byte[] PublicKeyBytes = Files.readAllBytes(Paths.get(PUBLIC_KEY_FILENAME));
          final byte[] privateKeyBytes = Files.readAllBytes(Paths.get(PRIVATE_KEY_FILENAME));
          publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(PublicKeyBytes));
          privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
      }
  }

  1,,

  
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.security.KeyFactory;
  import java.security.PrivateKey;
  import java.security.PublicKey;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  
  import org.apache.commons.codec.binary.Base64;
  
  import com.amazonaws.encryptionsdk.AwsCrypto;
  import com.amazonaws.encryptionsdk.CryptoResult;
  import com.amazonaws.encryptionsdk.jce.JceMasterKey;
  
  /**
   * Sample example of decrypting data that has been encrypted by CloudFront field-level encryption.
   */
  public class DecryptExample {
  
      private static final String PRIVATE_KEY_FILENAME = "private_key.der";
      private static final String PUBLIC_KEY_FILENAME = "public_key.der";
      private static PublicKey publicKey;
      private static PrivateKey privateKey;
  
      // CloudFront uses the following values to encrypt data, and your origin must use same values to decrypt it.
      // In your own code, for PROVIDER_NAME, use the provider name that you specified when you created your field-level
      // encryption profile. This sample uses 'DEMO' for the value.
      private static final String PROVIDER_NAME = "DEMO";
      // In your own code, use the key name that you specified when you added your public key to CloudFront. This sample
      // uses 'DEMOKEY' for the key name.
      private static final String KEY_NAME = "DEMOKEY";
      // CloudFront uses this algorithm when encrypting data.
      private static final String ALGORITHM = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding";
  
      public static void main(final String[] args) throws Exception {
  
          final String dataToDecrypt = args[0];
  
          // This sample uses files to get public and private keys.
          // In practice, you should distribute the public key and save the private key in secure storage.
          populateKeyPair();
  
          System.out.println(decrypt(debase64(dataToDecrypt)));
      }
  
      private static String decrypt(final byte[] bytesToDecrypt) throws Exception {
          // You can decrypt the stream only by using the private key.
  
          // 1. Instantiate the SDK
          final AwsCrypto crypto = new AwsCrypto();
  
          // 2. Instantiate a JCE master key
          final JceMasterKey masterKey = JceMasterKey.getInstance(
                  publicKey,
                  privateKey,
                  PROVIDER_NAME,
                  KEY_NAME,
                  ALGORITHM);
  
          // 3. Decrypt the data
          final CryptoResult  result = crypto.decryptData(masterKey, bytesToDecrypt);
          return new String(result.getResult());
      }
  
      // Function to decode base64 cipher text.
      private static byte[] debase64(final String value) {
          return Base64.decodeBase64(value.getBytes());
      }
  
      private static void populateKeyPair() throws Exception {
          final byte[] PublicKeyBytes = Files.readAllBytes(Paths.get(PUBLIC_KEY_FILENAME));
          final byte[] privateKeyBytes = Files.readAllBytes(Paths.get(PRIVATE_KEY_FILENAME));
          publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(PublicKeyBytes));
          privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
      }
  }

  2

  
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.security.KeyFactory;
  import java.security.PrivateKey;
  import java.security.PublicKey;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  
  import org.apache.commons.codec.binary.Base64;
  
  import com.amazonaws.encryptionsdk.AwsCrypto;
  import com.amazonaws.encryptionsdk.CryptoResult;
  import com.amazonaws.encryptionsdk.jce.JceMasterKey;
  
  /**
   * Sample example of decrypting data that has been encrypted by CloudFront field-level encryption.
   */
  public class DecryptExample {
  
      private static final String PRIVATE_KEY_FILENAME = "private_key.der";
      private static final String PUBLIC_KEY_FILENAME = "public_key.der";
      private static PublicKey publicKey;
      private static PrivateKey privateKey;
  
      // CloudFront uses the following values to encrypt data, and your origin must use same values to decrypt it.
      // In your own code, for PROVIDER_NAME, use the provider name that you specified when you created your field-level
      // encryption profile. This sample uses 'DEMO' for the value.
      private static final String PROVIDER_NAME = "DEMO";
      // In your own code, use the key name that you specified when you added your public key to CloudFront. This sample
      // uses 'DEMOKEY' for the key name.
      private static final String KEY_NAME = "DEMOKEY";
      // CloudFront uses this algorithm when encrypting data.
      private static final String ALGORITHM = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding";
  
      public static void main(final String[] args) throws Exception {
  
          final String dataToDecrypt = args[0];
  
          // This sample uses files to get public and private keys.
          // In practice, you should distribute the public key and save the private key in secure storage.
          populateKeyPair();
  
          System.out.println(decrypt(debase64(dataToDecrypt)));
      }
  
      private static String decrypt(final byte[] bytesToDecrypt) throws Exception {
          // You can decrypt the stream only by using the private key.
  
          // 1. Instantiate the SDK
          final AwsCrypto crypto = new AwsCrypto();
  
          // 2. Instantiate a JCE master key
          final JceMasterKey masterKey = JceMasterKey.getInstance(
                  publicKey,
                  privateKey,
                  PROVIDER_NAME,
                  KEY_NAME,
                  ALGORITHM);
  
          // 3. Decrypt the data
          final CryptoResult  result = crypto.decryptData(masterKey, bytesToDecrypt);
          return new String(result.getResult());
      }
  
      // Function to decode base64 cipher text.
      private static byte[] debase64(final String value) {
          return Base64.decodeBase64(value.getBytes());
      }
  
      private static void populateKeyPair() throws Exception {
          final byte[] PublicKeyBytes = Files.readAllBytes(Paths.get(PUBLIC_KEY_FILENAME));
          final byte[] privateKeyBytes = Files.readAllBytes(Paths.get(PRIVATE_KEY_FILENAME));
          publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(PublicKeyBytes));
          privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
      }
  }

  3,

  openssl rsa -pubout -in private_key.pem -out public_key.pem

  6,

  openssl rsa -pubout -in private_key.pem -out public_key.pem

  5,

  
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.security.KeyFactory;
  import java.security.PrivateKey;
  import java.security.PublicKey;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  
  import org.apache.commons.codec.binary.Base64;
  
  import com.amazonaws.encryptionsdk.AwsCrypto;
  import com.amazonaws.encryptionsdk.CryptoResult;
  import com.amazonaws.encryptionsdk.jce.JceMasterKey;
  
  /**
   * Sample example of decrypting data that has been encrypted by CloudFront field-level encryption.
   */
  public class DecryptExample {
  
      private static final String PRIVATE_KEY_FILENAME = "private_key.der";
      private static final String PUBLIC_KEY_FILENAME = "public_key.der";
      private static PublicKey publicKey;
      private static PrivateKey privateKey;
  
      // CloudFront uses the following values to encrypt data, and your origin must use same values to decrypt it.
      // In your own code, for PROVIDER_NAME, use the provider name that you specified when you created your field-level
      // encryption profile. This sample uses 'DEMO' for the value.
      private static final String PROVIDER_NAME = "DEMO";
      // In your own code, use the key name that you specified when you added your public key to CloudFront. This sample
      // uses 'DEMOKEY' for the key name.
      private static final String KEY_NAME = "DEMOKEY";
      // CloudFront uses this algorithm when encrypting data.
      private static final String ALGORITHM = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding";
  
      public static void main(final String[] args) throws Exception {
  
          final String dataToDecrypt = args[0];
  
          // This sample uses files to get public and private keys.
          // In practice, you should distribute the public key and save the private key in secure storage.
          populateKeyPair();
  
          System.out.println(decrypt(debase64(dataToDecrypt)));
      }
  
      private static String decrypt(final byte[] bytesToDecrypt) throws Exception {
          // You can decrypt the stream only by using the private key.
  
          // 1. Instantiate the SDK
          final AwsCrypto crypto = new AwsCrypto();
  
          // 2. Instantiate a JCE master key
          final JceMasterKey masterKey = JceMasterKey.getInstance(
                  publicKey,
                  privateKey,
                  PROVIDER_NAME,
                  KEY_NAME,
                  ALGORITHM);
  
          // 3. Decrypt the data
          final CryptoResult  result = crypto.decryptData(masterKey, bytesToDecrypt);
          return new String(result.getResult());
      }
  
      // Function to decode base64 cipher text.
      private static byte[] debase64(final String value) {
          return Base64.decodeBase64(value.getBytes());
      }
  
      private static void populateKeyPair() throws Exception {
          final byte[] PublicKeyBytes = Files.readAllBytes(Paths.get(PUBLIC_KEY_FILENAME));
          final byte[] privateKeyBytes = Files.readAllBytes(Paths.get(PRIVATE_KEY_FILENAME));
          publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(PublicKeyBytes));
          privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
      }
  }

  6,

  
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.security.KeyFactory;
  import java.security.PrivateKey;
  import java.security.PublicKey;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  
  import org.apache.commons.codec.binary.Base64;
  
  import com.amazonaws.encryptionsdk.AwsCrypto;
  import com.amazonaws.encryptionsdk.CryptoResult;
  import com.amazonaws.encryptionsdk.jce.JceMasterKey;
  
  /**
   * Sample example of decrypting data that has been encrypted by CloudFront field-level encryption.
   */
  public class DecryptExample {
  
      private static final String PRIVATE_KEY_FILENAME = "private_key.der";
      private static final String PUBLIC_KEY_FILENAME = "public_key.der";
      private static PublicKey publicKey;
      private static PrivateKey privateKey;
  
      // CloudFront uses the following values to encrypt data, and your origin must use same values to decrypt it.
      // In your own code, for PROVIDER_NAME, use the provider name that you specified when you created your field-level
      // encryption profile. This sample uses 'DEMO' for the value.
      private static final String PROVIDER_NAME = "DEMO";
      // In your own code, use the key name that you specified when you added your public key to CloudFront. This sample
      // uses 'DEMOKEY' for the key name.
      private static final String KEY_NAME = "DEMOKEY";
      // CloudFront uses this algorithm when encrypting data.
      private static final String ALGORITHM = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding";
  
      public static void main(final String[] args) throws Exception {
  
          final String dataToDecrypt = args[0];
  
          // This sample uses files to get public and private keys.
          // In practice, you should distribute the public key and save the private key in secure storage.
          populateKeyPair();
  
          System.out.println(decrypt(debase64(dataToDecrypt)));
      }
  
      private static String decrypt(final byte[] bytesToDecrypt) throws Exception {
          // You can decrypt the stream only by using the private key.
  
          // 1. Instantiate the SDK
          final AwsCrypto crypto = new AwsCrypto();
  
          // 2. Instantiate a JCE master key
          final JceMasterKey masterKey = JceMasterKey.getInstance(
                  publicKey,
                  privateKey,
                  PROVIDER_NAME,
                  KEY_NAME,
                  ALGORITHM);
  
          // 3. Decrypt the data
          final CryptoResult  result = crypto.decryptData(masterKey, bytesToDecrypt);
          return new String(result.getResult());
      }
  
      // Function to decode base64 cipher text.
      private static byte[] debase64(final String value) {
          return Base64.decodeBase64(value.getBytes());
      }
  
      private static void populateKeyPair() throws Exception {
          final byte[] PublicKeyBytes = Files.readAllBytes(Paths.get(PUBLIC_KEY_FILENAME));
          final byte[] privateKeyBytes = Files.readAllBytes(Paths.get(PRIVATE_KEY_FILENAME));
          publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(PublicKeyBytes));
          privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
      }
  }

  7. Ini dapat ditentukan dalam urutan apa pun. )

• Pengaturan asal Kebijakan Protokol Asal harus diatur menjadi Penampil Kecocokan atau HTTPS Saja. (DalamAWS CloudFormation atau CloudFront API,

  
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.security.KeyFactory;
  import java.security.PrivateKey;
  import java.security.PublicKey;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  
  import org.apache.commons.codec.binary.Base64;
  
  import com.amazonaws.encryptionsdk.AwsCrypto;
  import com.amazonaws.encryptionsdk.CryptoResult;
  import com.amazonaws.encryptionsdk.jce.JceMasterKey;
  
  /**
   * Sample example of decrypting data that has been encrypted by CloudFront field-level encryption.
   */
  public class DecryptExample {
  
      private static final String PRIVATE_KEY_FILENAME = "private_key.der";
      private static final String PUBLIC_KEY_FILENAME = "public_key.der";
      private static PublicKey publicKey;
      private static PrivateKey privateKey;
  
      // CloudFront uses the following values to encrypt data, and your origin must use same values to decrypt it.
      // In your own code, for PROVIDER_NAME, use the provider name that you specified when you created your field-level
      // encryption profile. This sample uses 'DEMO' for the value.
      private static final String PROVIDER_NAME = "DEMO";
      // In your own code, use the key name that you specified when you added your public key to CloudFront. This sample
      // uses 'DEMOKEY' for the key name.
      private static final String KEY_NAME = "DEMOKEY";
      // CloudFront uses this algorithm when encrypting data.
      private static final String ALGORITHM = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding";
  
      public static void main(final String[] args) throws Exception {
  
          final String dataToDecrypt = args[0];
  
          // This sample uses files to get public and private keys.
          // In practice, you should distribute the public key and save the private key in secure storage.
          populateKeyPair();
  
          System.out.println(decrypt(debase64(dataToDecrypt)));
      }
  
      private static String decrypt(final byte[] bytesToDecrypt) throws Exception {
          // You can decrypt the stream only by using the private key.
  
          // 1. Instantiate the SDK
          final AwsCrypto crypto = new AwsCrypto();
  
          // 2. Instantiate a JCE master key
          final JceMasterKey masterKey = JceMasterKey.getInstance(
                  publicKey,
                  privateKey,
                  PROVIDER_NAME,
                  KEY_NAME,
                  ALGORITHM);
  
          // 3. Decrypt the data
          final CryptoResult  result = crypto.decryptData(masterKey, bytesToDecrypt);
          return new String(result.getResult());
      }
  
      // Function to decode base64 cipher text.
      private static byte[] debase64(final String value) {
          return Base64.decodeBase64(value.getBytes());
      }
  
      private static void populateKeyPair() throws Exception {
          final byte[] PublicKeyBytes = Files.readAllBytes(Paths.get(PUBLIC_KEY_FILENAME));
          final byte[] privateKeyBytes = Files.readAllBytes(Paths.get(PRIVATE_KEY_FILENAME));
          publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(PublicKeyBytes));
          privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
      }
  }

  8 harus diatur ke

  
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.security.KeyFactory;
  import java.security.PrivateKey;
  import java.security.PublicKey;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  
  import org.apache.commons.codec.binary.Base64;
  
  import com.amazonaws.encryptionsdk.AwsCrypto;
  import com.amazonaws.encryptionsdk.CryptoResult;
  import com.amazonaws.encryptionsdk.jce.JceMasterKey;
  
  /**
   * Sample example of decrypting data that has been encrypted by CloudFront field-level encryption.
   */
  public class DecryptExample {
  
      private static final String PRIVATE_KEY_FILENAME = "private_key.der";
      private static final String PUBLIC_KEY_FILENAME = "public_key.der";
      private static PublicKey publicKey;
      private static PrivateKey privateKey;
  
      // CloudFront uses the following values to encrypt data, and your origin must use same values to decrypt it.
      // In your own code, for PROVIDER_NAME, use the provider name that you specified when you created your field-level
      // encryption profile. This sample uses 'DEMO' for the value.
      private static final String PROVIDER_NAME = "DEMO";
      // In your own code, use the key name that you specified when you added your public key to CloudFront. This sample
      // uses 'DEMOKEY' for the key name.
      private static final String KEY_NAME = "DEMOKEY";
      // CloudFront uses this algorithm when encrypting data.
      private static final String ALGORITHM = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding";
  
      public static void main(final String[] args) throws Exception {
  
          final String dataToDecrypt = args[0];
  
          // This sample uses files to get public and private keys.
          // In practice, you should distribute the public key and save the private key in secure storage.
          populateKeyPair();
  
          System.out.println(decrypt(debase64(dataToDecrypt)));
      }
  
      private static String decrypt(final byte[] bytesToDecrypt) throws Exception {
          // You can decrypt the stream only by using the private key.
  
          // 1. Instantiate the SDK
          final AwsCrypto crypto = new AwsCrypto();
  
          // 2. Instantiate a JCE master key
          final JceMasterKey masterKey = JceMasterKey.getInstance(
                  publicKey,
                  privateKey,
                  PROVIDER_NAME,
                  KEY_NAME,
                  ALGORITHM);
  
          // 3. Decrypt the data
          final CryptoResult  result = crypto.decryptData(masterKey, bytesToDecrypt);
          return new String(result.getResult());
      }
  
      // Function to decode base64 cipher text.
      private static byte[] debase64(final String value) {
          return Base64.decodeBase64(value.getBytes());
      }
  
      private static void populateKeyPair() throws Exception {
          final byte[] PublicKeyBytes = Files.readAllBytes(Paths.get(PUBLIC_KEY_FILENAME));
          final byte[] privateKeyBytes = Files.readAllBytes(Paths.get(PRIVATE_KEY_FILENAME));
          publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(PublicKeyBytes));
          privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
      }
  }

  9 atau

  openssl rsa -pubout -in private_key.pem -out public_key.pem

  9. )

Untuk informasi selengkapnya, lihat Nilai yang Anda tentukan saat membuat atau memperbarui distribusi

Mendekripsi bidang data di asal Anda

CloudFront mengenkripsi data bidang dengan menggunakan AWS Encryption SDK. Data tetap terenkripsi di seluruh tumpukan aplikasi Anda dan hanya dapat diakses oleh aplikasi yang memiliki kredensial untuk mendekripsinya

Setelah enkripsi, ciphertext adalah dasar64 yang dikodekan. Ketika aplikasi Anda mendekripsi teks pada awalnya, aplikasi harus menguraikan ciphertext, lalu menggunakan AWS Encryption SDK untuk mendekripsi data

Contoh kode berikut mengcitrakan bagaimana aplikasi dapat mendekripsi data di tempat asal Anda. Perhatikan hal-hal berikut

• Untuk mempermudah contoh, sampel ini memuat kunci publik dan privat (dalam format DER) dari file di direktori kerja. Dalam praktiknya, Anda akan menyimpan kunci pribadi di lokasi offline yang aman, seperti modul keamanan perangkat keras offline, dan mendistribusikan kunci publik ke tim pengembangan Anda

• CloudFront menggunakan informasi spesifik saat mengenkripsi data, dan rangkaian parameter yang sama harus digunakan di tempat awal untuk mendekripsinya. Parameter CloudFrontPenggunaan saat memulai MasterKey meliputi hal berikut

  • PROVIDER_NAME. Anda menentukan nilai ini saat membuat profil enkripsi tingkat lapangan. Gunakan nilai yang sama di sini

  • KEY_NAME. Anda membuat nama untuk kunci publik Anda saat mengunggahnya ke CloudFront, lalu menentukan nama kunci di profil. Gunakan nilai yang sama di sini

  • ALGORITMA. CloudFront digunakanprivate_key.pem_1 sebagai algoritma enkripsi, sehingga Anda harus menggunakan algoritma yang sama untuk mendekripsi data

• Jika Anda menjalankan program sampel berikut dengan ciphertext sebagai input, data yang didekripsi adalah output untuk konsol Anda. Untuk informasi lebih lanjut, lihat Kode Contoh Java di AWS Encryption SDK