

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Oracle Secure Sockets Layer
<a name="Appendix.Oracle.Options.SSL"></a>

Um die SSL-Verschlüsselung für eine DB-Instance von RDS für Oracle zu aktivieren, fügen Sie der Optionsgruppe die Option „Oracle SSL“ hinzu, die der DB-Instance zugeordnet ist. Amazon RDS verwendet einen zweiten Port, wie von Oracle gefordert, für SSL-Verbindungen. Dank dieser Herangehensweise ist gleichzeitig sowohl Klartext- als auch SSL-verschlüsselte Kommunikation zwischen einer DB-Instance und SQL\$1Plus möglich. Sie können z. B. den Port mit Klartext-Kommunikation verwenden, um mit anderen Ressourcen innerhalb einer VPC zu kommunizieren, und den Port mit SSL-verschlüsselter Kommunikation, um mit Ressourcen außerhalb der VPC zu kommunizieren.

**Anmerkung**  
Sie können entweder SSL oder Native Network Encryption (NNE) in derselben DB-Instance von RDS für Oracle verwenden, aber nicht beide. Bei Nutzung der SSL-Verschlüsselung müssen alle anderen Optionen für die Verbindungsverschlüsselung deaktiviert werden. Weitere Informationen finden Sie unter [Oracle Native Network Encryption](Appendix.Oracle.Options.NetworkEncryption.md).

SSL/TLS und NNE sind nicht mehr Teil von Oracle Advanced Security. In RDS für Oracle können Sie die SSL-Verschlüsselung mit allen lizensierten Editionen der folgenden Oracle-Datenbankversionen verwenden:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)

**Topics**
+ [

## TLS-Versionen für die Oracle SSL-Option
](#Appendix.Oracle.Options.SSL.TLS)
+ [

## Cipher Suites für die Oracle SSL-Option
](#Appendix.Oracle.Options.SSL.CipherSuites)
+ [

## FIPS-Unterstützung
](#Appendix.Oracle.Options.SSL.FIPS)
+ [

## Kompatibilität von Zertifikaten mit Cipher Suites
](#Appendix.Oracle.Options.SSL.CertificateCompatibility)
+ [

# Hinzufügen der SSL-Option
](Appendix.Oracle.Options.SSL.OptionGroup.md)
+ [

# Konfigurieren von SQL\$1Plus für die Verwendung von SSL mit einer DB-Instance von RDS für Oracle
](Appendix.Oracle.Options.SSL.ClientConfiguration.md)
+ [

# Herstellen der Verbindung mit einer DB-Instance von RDS für Oracle mit SSL
](Appendix.Oracle.Options.SSL.Connecting.md)
+ [

# Einrichten einer SSL-Verbindung über JDBC
](Appendix.Oracle.Options.SSL.JDBC.md)
+ [

# Erzwingen einer DN-Übereinstimmung mit einer SSL-Verbindung
](Appendix.Oracle.Options.SSL.DNMatch.md)
+ [

# Fehlerbehebung bei SSL-Verbindungen
](Appendix.Oracle.Options.SSL.troubleshooting.md)

## TLS-Versionen für die Oracle SSL-Option
<a name="Appendix.Oracle.Options.SSL.TLS"></a>

Amazon RDS für Oracle unterstützt jetzt Transport Layer Security (TLS) in den Versionen 1.0 und 1.2. Wenn Sie eine neue Oracle-SSL-Option hinzufügen, weisen Sie `SQLNET.SSL_VERSION` ausdrücklich einen gültigen Wert zu. Die folgenden Werte sind für diese Optionseinstellung zulässig:
+ `"1.0"`: Clients können die Verbindung zur DB-Instance nur mit TLS-Version 1.0 herstellen. Für vorhandene Oracle SSL-Optionen wird `SQLNET.SSL_VERSION` automatisch auf `"1.0"` eingestellt. Sie können die Einstellung bei Bedarf ändern.
+ `"1.2"`: Clients können die Verbindung zur DB-Instance nur mit TLS 1.2 herstellen.
+ `"1.2 or 1.0"`: Clients können die Verbindung zur DB-Instance mit TLS 1.2 oder 1.0 herstellen.

## Cipher Suites für die Oracle SSL-Option
<a name="Appendix.Oracle.Options.SSL.CipherSuites"></a>

Amazon RDS für Oracle unterstützt mehrere SSL Cipher Suites. Standardmäßig ist die Oracle SSL-Option für die Verwendung der `SSL_RSA_WITH_AES_256_CBC_SHA` Cipher Suite konfiguriert. Verwenden Sie zum Angeben einer andere Cipher Suite für SSL-Verbindungen die Optionseinstellung `SQLNET.CIPHER_SUITE`.

Sie können mehrere Werte für `SQLNET.CIPHER_SUITE` angeben. Diese Technik ist hilfreich, wenn sich Datenbanklinks zwischen Ihren DB-Instances befinden und Sie beschließen, Ihre Cipher Suites zu aktualisieren.

In der folgenden Tabelle wird die SSL-Unterstützung für RDS für Oracle in allen Editionen von Oracle Database 19c und 21c zusammengefasst.


| Verschlüsselungssuite (SQLNET.CIPHER\$1SUITE) | Unterstützung für TLS-Versionen (SQLNET.SSL\$1VERSION) | FIPS-Unterstützung | FedRAMP-konform | 
| --- | --- | --- | --- | 
| SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA (Standard) | 1.0 und 1.2 | Ja | Nein | 
| SSL\$1RSA\$1MIT\$1AES\$1256\$1CBC\$1 SHA256 | 1.2 | Ja | Nein | 
| SSL\$1RSA\$1MIT\$1AES\$1256\$1GCM\$1 SHA384 | 1.2 | Ja | Nein | 
| TLS\$1ECDHE\$1RSA\$1MIT\$1AES\$1256\$1GCM\$1 SHA384 | 1.2 | Ja | Ja | 
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1GCM\$1 SHA256 | 1.2 | Ja | Ja | 
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384 | 1.2 | Ja | Ja | 
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 | 1.2 | Ja | Ja | 
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA | 1.2 | Ja | Ja | 
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | 1.2 | Ja | Ja | 
| TLS\$1ECDHE\$1ECDSA\$1MIT\$1AES\$1256\$1GCM\$1 SHA384 | 1.2 | Ja | Ja | 
| TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384 | 1.2 | Ja | Ja | 

## FIPS-Unterstützung
<a name="Appendix.Oracle.Options.SSL.FIPS"></a>

RDS für Oracle ermöglicht es Ihnen, den Federal Information Processing Standard (FIPS)-Standard für 140-2 zu verwenden. Bei FIPS 140-2 handelt es sich um einen Standard der Regierung der Vereinigten Staaten, der die Sicherheitsanforderungen für kryptografische Module definiert. Sie aktivieren den FIPS-Standard, indem Sie die Einstellung `FIPS.SSLFIPS_140` für die Oracle-SSL-Option auf `TRUE` festlegen. Wenn FIPS 140-2 für SSL konfiguriert ist, verschlüsseln die kryptografischen Bibliotheken die Daten zwischen dem Client und der DB-Instance von RDS für Oracle.

Clients müssen die Verschlüsselungssammlung verwenden, die FIPS-konform ist. Beim Herstellen einer Verbindung verhandeln der Client und die DB-Instance von RDS für Oracle, welche Verschlüsselungssammlung verwendet werden soll, wenn Nachrichten hin und her übertragen werden. Die Tabelle in [Cipher Suites für die Oracle SSL-Option](#Appendix.Oracle.Options.SSL.CipherSuites) zeigt die FIPS-konformen SSL-Verschlüsselungssuites für jede TLS-Version. Weitere Informationen finden Sie unter [Oracle Database FIPS 140-2-Einstellungen](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/dbseg/oracle-database-fips-140-settings.html#GUID-DDBEB3F9-B216-44BB-8C18-43B5E468CBBB) in der Oracle Database-Dokumentation.

## Kompatibilität von Zertifikaten mit Cipher Suites
<a name="Appendix.Oracle.Options.SSL.CertificateCompatibility"></a>

RDS für Oracle unterstützt sowohl RSA- als auch ECDSA-Zertifikate (Elliptic Curve Digital Signature Algorithm) für DSA-Zertifikate (Elliptic Curve Digital Signature Algorithm) Wenn Sie SSL für Ihre DB-Instance konfigurieren, müssen Sie sicherstellen, dass die Verschlüsselungssammlungen, die Sie in der Optionseinstellung `SQLNET.CIPHER_SUITE` angeben, mit dem von Ihrer DB-Instance verwendeten Zertifikatstyp kompatibel sind.

In der folgenden Tabelle wird die Kompatibilität zwischen Zertifikatstypen und Verschlüsselungssammlungen dargestellt:


| Zertifikatstyp | Kompatible Verschlüsselungs-Suiten | Inkompatible Verschlüsselungssammlungen | 
| --- | --- | --- | 
| RSA-Zertifikate (rds-ca-2019, 2048-g1, 4096-g1) rds-ca-rsa rds-ca-rsa |  SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA256 SSL\$1RSA\$1MIT\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1RSA\$1MIT\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1GCM\$1 SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA  |  TLS\$1ECDHE\$1ECDSA\$1MIT\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384  | 
| ECDSA-Zertifikate (384-g1) rds-ca-ecc |  TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384  |  SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA SSL\$1RSA\$1MIT\$1AES\$1256\$1CBC\$1 SHA256 SSL\$1RSA\$1MIT\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1RSA\$1MIT\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1GCM\$1 SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA  | 

Wenn Sie in der Optionseinstellung `SQLNET.CIPHER_SUITE` mehrere Verschlüsselungssammlungen angeben, müssen Sie sicherstellen, dass Sie mindestens eine Verschlüsselungssammlung angeben, die mit dem von Ihrer DB-Instance verwendeten Zertifikatstyp kompatibel ist. Wenn Sie eine Optionsgruppe mit mehreren DB-Instances mit unterschiedlichen Zertifikatstypen verwenden, fügen Sie mindestens eine Verschlüsselungssammlung für jeden Zertifikatstyp hinzu.

Wenn Sie versuchen, eine Optionsgruppe mit einer SSL-Option zu verknüpfen, die nur Verschlüsselungssammlungen enthält, die mit dem Zertifikatstyp einer DB-Instance nicht kompatibel sind, schlägt der Vorgang fehl und es wird eine Fehlermeldung angezeigt, die auf die Inkompatibilität hinweist.

# Hinzufügen der SSL-Option
<a name="Appendix.Oracle.Options.SSL.OptionGroup"></a>

Um SSL verwenden zu können, muss Ihre DB-Instance von RDS für Oracle einer Optionsgruppe zugeordnet sein, die die Option `SSL` enthält.

## Konsole
<a name="Appendix.Oracle.Options.SSL.OptionGroup.Console"></a>

**So fügen Sie die SSL-Option zu einer Optionsgruppe hinzu:**

1. Erstellen Sie eine neue Optionsgruppe oder identifizieren Sie eine vorhandene Optionsgruppe, der Sie die Option `SSL` hinzufügen können.

   Weitere Informationen zum Erstellen einer Optionsgruppe finden Sie unter [Erstellen einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).

1. Fügen Sie die Option `SSL` zur Optionsgruppe hinzu.

   Wenn Sie nur FIPS-verifizierte Verschlüsselungssammlungen für SSL-Verbindungen verwenden möchten, setzen Sie die Option `FIPS.SSLFIPS_140` auf `TRUE`. Hinweise zum FIPS-Standard finden Sie unter [FIPS-Unterstützung](Appendix.Oracle.Options.SSL.md#Appendix.Oracle.Options.SSL.FIPS).

   Weitere Informationen zum Hinzufügen einer Option zu einer Optionsgruppe finden Sie unter [Hinzufügen einer Option zu einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).

1. Erstellen Sie eine neue DB-Instance von RDS für Oracle und ordnen Sie ihr die Optionsgruppe zu oder ändern Sie eine DB-Instance von RDS für Oracle, sodass ihr die Optionsgruppe zugeordnet wird.

   Informationen zum Erstellen einer DB-Instance finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).

   Informationen zum Ändern einer DB-Instance finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).

## AWS CLI
<a name="Appendix.Oracle.Options.SSL.OptionGroup.CLI"></a>

**So fügen Sie die SSL-Option zu einer Optionsgruppe hinzu:**

1. Erstellen Sie eine neue Optionsgruppe oder identifizieren Sie eine vorhandene Optionsgruppe, der Sie die Option `SSL` hinzufügen können.

   Weitere Informationen zum Erstellen einer Optionsgruppe finden Sie unter [Erstellen einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).

1. Fügen Sie die Option `SSL` zur Optionsgruppe hinzu.

   Geben Sie die folgenden Einstellungen für die Option an:
   + `Port` – Die Nummer des SSL-Ports.
   + `VpcSecurityGroupMemberships` – Die VPC-Sicherheitsgruppe, für die die Option aktiviert ist.
   + `SQLNET.SSL_VERSION` – Die TLS-Version, mit der der Client eine Verbindung zur DB-Instance herstellen kann.

   Der folgende AWS CLI-Befehl fügt beispielsweise die Option `SSL` zur Optionsgruppe `ora-option-group` hinzu.  
**Example**  

   Für Linux, macOS oder Unix:

   ```
   aws rds add-option-to-option-group --option-group-name ora-option-group \
     --options 'OptionName=SSL,Port=2484,VpcSecurityGroupMemberships="sg-68184619",OptionSettings=[{Name=SQLNET.SSL_VERSION,Value=1.0}]'
   ```

   Für Windows:

   ```
   aws rds add-option-to-option-group --option-group-name ora-option-group ^
     --options 'OptionName=SSL,Port=2484,VpcSecurityGroupMemberships="sg-68184619",OptionSettings=[{Name=SQLNET.SSL_VERSION,Value=1.0}]'
   ```

1. Erstellen Sie eine neue DB-Instance von RDS für Oracle und ordnen Sie ihr die Optionsgruppe zu oder ändern Sie eine DB-Instance von RDS für Oracle, sodass ihr die Optionsgruppe zugeordnet wird.

   Informationen zum Erstellen einer DB-Instance finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).

   Informationen zum Ändern einer DB-Instance finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).

# Konfigurieren von SQL\$1Plus für die Verwendung von SSL mit einer DB-Instance von RDS für Oracle
<a name="Appendix.Oracle.Options.SSL.ClientConfiguration"></a>

Bevor Sie eine Verbindung mit einer DB-Instance von RDS für Oracle herstellen können, die die Oracle-SSL-Option verwendet, müssen Sie SQL\$1Plus konfigurieren.

**Anmerkung**  
Stellen Sie sicher, dass die Sicherheitsgruppen korrekt konfiguriert sind, um Zugriff auf die DB-Instance durch entsprechende Clients zu erlauben. Weitere Informationen finden Sie unter [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md). Diese Anweisungen gelten auch für SQL\$1Plus und andere Clients, die direkt ein Oracle-Stammverzeichnis verwenden. Weitere Informationen zu JDBC-Verbindungen finden Sie unter [Einrichten einer SSL-Verbindung über JDBC](Appendix.Oracle.Options.SSL.JDBC.md).

**So konfigurieren Sie SQL\$1Plus für die Verwendung einer SSL-Verbindung mit einer DB-Instance von RDS für Oracle**

1. Legen Sie in der Umgebungsvariablen `ORACLE_HOME` den Speicherort des Oracle-Stammverzeichnisses fest.

   Der Pfad zu Ihrem Oracle-Stammverzeichnis hängt von Ihrer Installation ab. Im folgenden Beispiel wird die Umgebungsvariable `ORACLE_HOME` festgelegt.

   ```
   prompt>export ORACLE_HOME=/home/user/app/user/product/19.0.0/dbhome_1
   ```

   Weitere Informationen zum Einrichten der Oracle-Umgebungsvariablen finden Sie unter [SQL\$1Plus Environment Variables](http://docs.oracle.com/database/121/SQPUG/ch_two.htm#SQPUG331) in der Oracle-Dokumentation und auch im Oracle-Installationshandbuch für das jeweilige Betriebssystem.

1. Fügen Sie `$ORACLE_HOME/lib` an die Umgebungsvariable `LD_LIBRARY_PATH` an.

   Im folgenden Beispiel wird die Umgebungsvariable LD\$1LIBRARY\$1PATH festgelegt.

   ```
   prompt>export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME/lib 
   ```

1. Erstellen Sie ein Oracle Wallet unter `$ORACLE_HOME/ssl_wallet`.

   Im folgenden Beispiel wird das Oracle Wallet-Verzeichnis erstellt.

   ```
   prompt>mkdir $ORACLE_HOME/ssl_wallet
   ```

1. Laden Sie die Zertifikatspaket-Datei (.pem) herunter, die für alle funktioniert, AWS-Regionen und legen Sie die Datei im Verzeichnis ssl\$1wallet ab. Weitere Informationen finden Sie unter [](UsingWithRDS.SSL.md).

1. Ändern oder erstellen Sie im Verzeichnis `$ORACLE_HOME/network/admin` die Datei `tnsnames.ora`, die folgenden Eintrag enthalten muss.

   ```
   net_service_name = 
     (DESCRIPTION = 
       (ADDRESS_LIST = 
         (ADDRESS = 
           (PROTOCOL = TCPS) 
           (HOST = endpoint) 
           (PORT = ssl_port_number)
         )
       )
       (CONNECT_DATA = 
         (SID = database_name)
       )
       (SECURITY = 
         (SSL_SERVER_CERT_DN = "C=US,ST=Washington,L=Seattle,O=Amazon.com,OU=RDS,CN=endpoint")
       )
     )
   ```

1. Ändern oder erstellen Sie im selben Verzeichnis die Datei sqlnet.ora und binden Sie folgende Parameter ein.
**Anmerkung**  
Zur Kommunikation mit Entitäten über eine sichere TLS-Verbindung benötigt Oracle ein Wallet mit den erforderlichen Zertifikaten für die Authentifizierung. Sie können das ORAPKI-Dienstprogramm von Oracle zum Erstellen und Verwalten von Oracle-Wallets verwenden, wie in Schritt 7 beschrieben. Weitere Informationen finden Sie unter [Setting Up Oracle Wallet Using ORAPKI](https://docs.oracle.com/cd/E92519_02/pt856pbr3/eng/pt/tsvt/task_SettingUpOracleWalletUsingORAPKI.html) in der Oracle-Dokumentation.

   ```
   WALLET_LOCATION = (SOURCE = (METHOD = FILE) (METHOD_DATA = (DIRECTORY = $ORACLE_HOME/ssl_wallet))) 
   SSL_CLIENT_AUTHENTICATION = FALSE 
   SSL_VERSION = 1.0 
   SSL_CIPHER_SUITES = (SSL_RSA_WITH_AES_256_CBC_SHA) 
   SSL_SERVER_DN_MATCH = ON
   ```
**Anmerkung**  
Sie können für `SSL_VERSION` einen höheren Wert einstellen, sofern er von Ihrer DB-Instance unterstützt wird.

1. Führen Sie den folgenden Befehl aus, um das Oracle Wallet zu erstellen.

   ```
   prompt>orapki wallet create -wallet $ORACLE_HOME/ssl_wallet -auto_login_only
   ```

1. Extrahieren Sie jedes Zertifikat in der .pem-Bundle-Datei mithilfe eines Betriebssystemdienstprogramms in eine separate .pem-Datei.

1. Fügen Sie Ihrem Wallet jedes Zertifikat mit separaten `orapki`-Befehlen hinzu und ersetzen Sie `certificate-pem-file` durch den absoluten Dateinamen der PEM-Datei.

   ```
   prompt>orapki wallet add -wallet $ORACLE_HOME/ssl_wallet -trusted_cert -cert
         certificate-pem-file -auto_login_only
   ```

   Weitere Informationen finden Sie unter [Ihr SSL/TLS Zertifikat rotieren](UsingWithRDS.SSL-certificate-rotation.md).

# Herstellen der Verbindung mit einer DB-Instance von RDS für Oracle mit SSL
<a name="Appendix.Oracle.Options.SSL.Connecting"></a>

Nachdem Sie SQL\$1Plus wie zuvor beschrieben für die Verwendung von SSL konfiguriert haben, können Sie die Verbindung mit der DB-Instance von RDS für Oracle mit der SSL-Option herstellen. Optional können Sie zuerst den `TNS_ADMIN`-Wert importieren, der auf das Verzeichnis mit den tnsnames.ora- und sqlnet.ora-Dateien verweist. Dadurch wird sichergestellt, dass SQL\$1Plus diese Dateien konsistent finden kann. Das folgende Beispiel exportiert den `TNS_ADMIN`-Wert.

```
export TNS_ADMIN=${ORACLE_HOME}/network/admin
```

Stellen Sie eine Verbindung mit der DB-Instance her. Beispielsweise können Sie eine Verbindung mit SQL\$1Plus und einem *<net\$1service\$1name>* in einer tnsnames.ora-Datei einrichten.

```
sqlplus mydbuser@net_service_name          
```

Sie können die Verbindung mit einer DB-Instance auch unter Verwendung von SQL\$1Plus ohne eine tnsnames.ora-Datei einrichten, indem Sie den folgenden Befehl ausführen.

```
sqlplus 'mydbuser@(DESCRIPTION = (ADDRESS = (PROTOCOL = TCPS)(HOST = endpoint) (PORT = ssl_port_number))(CONNECT_DATA = (SID = database_name)))'          
```

Sie können auch ohne SSL eine Verbindung mit der DB-Instance von RDS für Oracle aufbauen. Mit diesem Befehl kann beispielsweise eine Verbindung zur DB-Instance über den Clear-Text-Port ohne SSL-Verschlüsselung hergestellt werden.

```
sqlplus 'mydbuser@(DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = endpoint) (PORT = port_number))(CONNECT_DATA = (SID = database_name)))'          
```

Wenn der TCP (Transmission Control Protocol)-Portzugriff beendet werden soll, erstellen Sie eine Sicherheitsgruppe ohne IP-Adresszugänge und fügen sie zur Instance hinzu. Dadurch werden Verbindungen über den TCP-Port geschlossen, wohingegen Verbindungen über den SSL-Port von IP-Adressen, die aus dem von der SSL-Option der Sicherheitsgruppe definierten Adressbereich stammen, weiterhin möglich sind.

# Einrichten einer SSL-Verbindung über JDBC
<a name="Appendix.Oracle.Options.SSL.JDBC"></a>

Sie müssen einen Schlüsselspeicher erstellen, dem Amazon-RDS-Stammzertifizierungsstellenzertifikat vertrauen und das folgende Code-Snippet verwenden, um eine SSL-Verbindung über JDBC herzustellen.

Führen Sie folgenden Befehl aus, um einen Schlüsselspeicher im JKS-Format zu erstellen. Weitere Informationen zum Erstellen des Schlüsselspeichers finden Sie in der Oracle-Dokumentation unter [Erstellen eines Schlüsselspeichers](https://docs.oracle.com/cd/E35822_01/server.740/es_admin/src/tadm_ssl_jetty_keystore.html). Referenzinformationen finden Sie unter [keytool](https://docs.oracle.com/javase/8/docs/technotes/tools/windows/keytool.html) in der *Referenz zu Java Platform, Standard Edition Tools.*

```
keytool -genkey -alias client -validity 365 -keyalg RSA -keystore clientkeystore         
```

Führen Sie die folgenden Schritte aus, um dem Amazon-RDS-Stammzertifizierungsstellenzertifikat zu vertrauen:

**So vertrauen Sie dem Amazon-RDS-Stammzertifizierungsstellenzertifikat**

1. Laden Sie die .pem-Datei des Zertifikatpakets herunter, das für alle AWS-Regionen funktioniert, und legen Sie die Datei im Verzeichnis „ssl\$1wallet“ ab.

   Informationen zum Herunterladen von Zertifikaten finden Sie unter [](UsingWithRDS.SSL.md).

1. Extrahieren Sie jedes Zertifikat in der .pem-Datei mithilfe eines Betriebssystemdienstprogramms in eine separate Datei.

1. Konvertieren Sie jedes Zertifikat mithilfe eines separaten `openssl`-Befehls in das .der-Format und ersetzen Sie *certificate-pem-file* durch den Namen der .pem-Datei des Zertifikats (ohne die .pem-Erweiterung).

   ```
   openssl x509 -outform der -in certificate-pem-file.pem -out certificate-pem-file.der                
   ```

1. Importieren Sie jedes Zertifikat mit folgendem Befehl in den Schlüsselspeicher.

   ```
   keytool -import -alias rds-root -keystore clientkeystore.jks -file certificate-pem-file.der                
   ```

   Weitere Informationen finden Sie unter [Ihr SSL/TLS Zertifikat rotieren](UsingWithRDS.SSL-certificate-rotation.md).

1. Bestätigen Sie, das der Schlüsselspeicher erfolgreich erstellt wurde.

   ```
   keytool -list -v -keystore clientkeystore.jks                                            
   ```

   Geben Sie das Passwort des Schlüsselspeichers an, wenn Sie dazu aufgefordert werden.

Das folgende Code-Beispiel zeigt, wie die SSL-Verbindung mit JDBC eingerichtet wird.

```
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
 
public class OracleSslConnectionTest {
    private static final String DB_SERVER_NAME = "dns-name-provided-by-amazon-rds";
    private static final Integer SSL_PORT = "ssl-option-port-configured-in-option-group";
    private static final String DB_SID = "oracle-sid";
    private static final String DB_USER = "user-name";
    private static final String DB_PASSWORD = "password";
    // This key store has only the prod root ca.
    private static final String KEY_STORE_FILE_PATH = "file-path-to-keystore";
    private static final String KEY_STORE_PASS = "keystore-password";
 
    public static void main(String[] args) throws SQLException {
        final Properties properties = new Properties();
        final String connectionString = String.format(
                "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=%s)(PORT=%d))(CONNECT_DATA=(SID=%s)))",
                DB_SERVER_NAME, SSL_PORT, DB_SID);
        properties.put("user", DB_USER);
        properties.put("password", DB_PASSWORD);
        properties.put("oracle.jdbc.J2EE13Compliant", "true");
        properties.put("javax.net.ssl.trustStore", KEY_STORE_FILE_PATH);
        properties.put("javax.net.ssl.trustStoreType", "JKS");
        properties.put("javax.net.ssl.trustStorePassword", KEY_STORE_PASS);
        final Connection connection = DriverManager.getConnection(connectionString, properties);
        // If no exception, that means handshake has passed, and an SSL connection can be opened
    }
}
```

**Anmerkung**  
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.

# Erzwingen einer DN-Übereinstimmung mit einer SSL-Verbindung
<a name="Appendix.Oracle.Options.SSL.DNMatch"></a>

Sie können den Oracle-Parameter `SSL_SERVER_DN_MATCH` verwenden, um eine Übereinstimmung des eindeutigen Namens (DN) für den Datenbank-Server mit dem Service-Namen zu erzwingen. Sofern Sie die Verifizierung erzwingen, stellt SSL sicher, dass das Zertifikat vom Server kommt. Wenn Sie die Verifizierung nicht erzwingen, führt SSL die Überprüfung zwar durch, lässt aber die Verbindung unabhängig von einer Übereinstimmung zu. Falls Sie die Übereinstimmung nicht erzwingen, lassen Sie eine potenzielle Identitätsfälschung des Servers zu.

Fügen Sie die Eigenschaft für die DN-Übereinstimmung hinzu und verwenden Sie unten angegebene Verbindungszeichenfolge, um eine DN-Übereinstimmung zu erzwingen.

Fügen Sie der Clientverbindung die Eigenschaft zum Erzwingen der DN-Übereinstimmung hinzu.

```
properties.put("oracle.net.ssl_server_dn_match", "TRUE");            
```

Verwenden Sie die folgende Verbindungszeichenfolge, um bei Verwendung von SSL eine DN-Übereinstimmung zu erzwingen.

```
final String connectionString = String.format(
    "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=%s)(PORT=%d))" +
    "(CONNECT_DATA=(SID=%s))" +
    "(SECURITY = (SSL_SERVER_CERT_DN = 
\"C=US,ST=Washington,L=Seattle,O=Amazon.com,OU=RDS,CN=%s\")))",
    DB_SERVER_NAME, SSL_PORT, DB_SID, DB_SERVER_NAME);
```

# Fehlerbehebung bei SSL-Verbindungen
<a name="Appendix.Oracle.Options.SSL.troubleshooting"></a>

Möglicherweise erhalten Sie beim Abfragen Ihrer Datenbank den Fehler `ORA-28860`.

```
ORA-28860: Fatal SSL error
28860. 00000 - "Fatal SSL error"
*Cause: An error occurred during the SSL connection to the peer. It is likely that this side sent data which the peer rejected.
*Action: Enable tracing to determine the exact cause of this error.
```

Dieser Fehler tritt auf, wenn der Client versucht, eine Verbindung mithilfe einer TLS-Version herzustellen, die der Server nicht unterstützt. Um diesen Fehler zu vermeiden, bearbeiten Sie die Datei sqlnet.ora und legen Sie `SSL_VERSION` auf die richtige TLS-Version fest. Weitere Informationen finden Sie im [Oracle-Supportdokument 2748438.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2748438.1) auf der My Oracle Support Site.