Verschlüsseln der Kundeneingabe

Sie können vertrauliche Daten verschlüsseln, die von Flowsn gesammelt werden. Dazu müssen Sie eine Kryptografie für öffentliche Schlüssel verwenden.

Bei der Konfiguration von Amazon Connect geben Sie zunächst den öffentlichen Schlüssel an. Dies ist der Schlüssel, der beim Verschlüsseln von Daten verwendet wird. Später stellen Sie das X.509-Zertifikat bereit, das eine Signatur enthält, die beweist, dass Sie den privaten Schlüssel besitzen.

Stellen Sie in einem Flow, der Daten erfasst, ein X.509-Zertifikat bereit, um die mit dem Systemattribut Stored customer input (Gespeicherte Kundeneingabe) erfassten Daten zu verschlüsseln. Sie müssen einen Schlüssel im .pem-Format hochladen, um diese Funktion verwenden zu können. Der Verschlüsselungsschlüssel wird zur Überprüfung der Signatur auf dem Zertifikat genutzt, das im Flow verwendet wird.

Anmerkung

Es können bis zu zwei Verschlüsselungsschlüssel gleichzeitig aktiv sein, um eine Rotation zu ermöglichen.

Zum Entschlüsseln der Daten im Attribut Stored customer input (Gespeicherte Kundeneingabe) verwenden Sie das AWS Encryption SDK. Weitere Informationen finden Sie im AWS Encryption SDK-Entwicklerhandbuch.

Detaillierte Informationen finden Sie unter Erstellen einer sicheren IVR-Lösung mit Amazon Connect. Hier wird Folgendes gezeigt:

• Konfigurieren von Amazon Connect zum Erfassen einer Kreditkartennummer.

• Verschlüsseln der Kreditkartennummern.

• Senden zur Entschlüsselung an unseren Backend AWS Lambda unter Verwendung des vom Kunden bereitgestellten Entschlüsselungsschlüssels.

Es bietet zwei Befehle mit OpenSSL:

• Eine zum Generieren eines RSA-Schlüsselpaars und selbstsignierten X.509-Zertifikats

• Ein weiterer, um den öffentlichen Schlüssel aus dem RSA-Schlüsselpaar zu extrahieren

Verfahrenweise zum Entschlüsseln der von Amazon Connect verschlüsselten Daten

Das folgende Codebeispiel zeigt, wie Daten mit dem AWS Encryption SDK entschlüsselt werden.

package com.amazonaws;
 
import com.amazonaws.encryptionsdk.AwsCrypto;
import com.amazonaws.encryptionsdk.CryptoResult;
import com.amazonaws.encryptionsdk.jce.JceMasterKey;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
 
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.GeneralSecurityException;
import java.security.KeyFactory;
import java.security.Security;
import java.security.interfaces.RSAPrivateKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Base64;
 
public class AmazonConnectDecryptionSample {
 
    // The Provider 'AmazonConnect' is used during encryption, this must be used during decryption for key
    // to be found
    private static final String PROVIDER = "AmazonConnect";
 
    // The wrapping algorithm used during encryption
    private static final String WRAPPING_ALGORITHM = "RSA/ECB/OAEPWithSHA-512AndMGF1Padding";
 
    /**
     * This sample show how to decrypt data encrypted by Amazon Connect.
     * To use, provide the following command line arguments: [path-to-private-key] [key-id] [cyphertext]
     * Where:
     *  path-to-private-key is a file containing the PEM encoded private key to use for decryption
     *  key-id is the key-id specified during encryption in your flow
     *  cyphertext is the result of the encryption operation from Amazon Connect
     */
    public static void main(String[] args) throws IOException, GeneralSecurityException {
        String privateKeyFile = args[0]; // path to PEM encoded private key to use for decryption
        String keyId = args[1]; // this is the id used for key in your flow
        String cypherText = args[2]; // the result from flow
 
        Security.addProvider(new BouncyCastleProvider());
 
        // read the private key from file
        String privateKeyPem = new String(Files.readAllBytes(Paths.get(privateKeyFile)), Charset.forName("UTF-8"));
        RSAPrivateKey privateKey =  getPrivateKey(privateKeyPem);
 
        AwsCrypto awsCrypto = new AwsCrypto();
        JceMasterKey decMasterKey =
                JceMasterKey.getInstance(null,privateKey, PROVIDER, keyId, WRAPPING_ALGORITHM);
        CryptoResult<String, JceMasterKey> result = awsCrypto.decryptString(decMasterKey, cypherText);
 
        System.out.println("Decrypted: " + result.getResult());
    }
 
    public static RSAPrivateKey getPrivateKey(String privateKeyPem) throws IOException, GeneralSecurityException {
        String privateKeyBase64 = privateKeyPem
                .replace("-----BEGIN RSA PRIVATE KEY-----\n", "")
                .replace("-----END RSA PRIVATE KEY-----", "")
                .replaceAll("\n", "");
        byte[] decoded = Base64.getDecoder().decode(privateKeyBase64);
        KeyFactory kf = KeyFactory.getInstance("RSA");
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decoded);
        RSAPrivateKey privKey = (RSAPrivateKey) kf.generatePrivate(keySpec);
        return privKey;
    }
}