APISIX: FIPS 140-2-konform sein

Jinhua Luo

January 6, 2023

Products

Was ist FIPS 140-2?

FIPS steht für Federal Information Processing Standards, eine Reihe von Computersicherheitsstandards, die vom US-Bundesministerium für Handel, dem National Institute of Standards and Technology (NIST), festgelegt wurden.

Das Ziel von FIPS ist es, ein einheitliches Sicherheitsniveau für alle Bundesbehörden zu schaffen, um sensible, aber nicht klassifizierte Informationen zu schützen – einen großen Teil elektronischer Daten, die nicht als geheim oder höher eingestuft sind.

Sicherheitsstufen von FIPS 140-2

FIPS 140-2/3 sind häufig verwendete Standards im Kontext der Cybersicherheit. Beide beziehen sich auf die standardmäßigen Sicherheitsanforderungen für kryptografische Module. FIPS 140-3 wird schließlich FIPS 140-2 ersetzen, und dieser Übergang ist derzeit im Gange.

  • Stufe 1 – Die niedrigste Sicherheitsstufe, die minimale Anforderungen stellt und verlangt, dass alle Komponenten „produktionsreif“ sind. FIPS 140-2 Stufe 1 bezieht sich speziell auf Software-Kryptografiemodule und trifft Vorgaben zu den kryptografischen Algorithmen, die verwendet werden dürfen, sowie zu den Selbsttests, die durchgeführt werden müssen, um deren Integrität zu überprüfen.
  • Stufe 2 – Zusätzliche Anforderungen für physische Manipulationssicherheit sowie rollenbasierte Authentifizierung.
  • Stufe 3 – Weitere Verpflichtung zur Stärkung der Sicherheit gegen Angreifer, die Verwendung von identitätsbasierter Authentifizierung sowie physische Trennung zwischen Schnittstellen.
  • Stufe 4 – Die strengste Stufe, die robuste physische Sicherheitsmaßnahmen gegen Umgebungsangriffe erfordert.

Beispielsweise bietet ein kryptografisches Modul, das nach FIPS 140-2 Stufe 1 validiert ist, dieses grundlegende Sicherheitsniveau, indem es Daten, die durch es hindurchgehen, auf dem durch AES bereitgestellten Schutzlevel verschlüsselt. Ein kryptografisches Modul, das nach FIPS 140-2 Stufe 2 validiert ist, bietet jedoch nicht nur AES-Verschlüsselung, sondern auch physische Sicherheit des Geräts selbst.

Das bedeutet, dass ein nach FIPS 140-2 Stufe 2 validiertes kryptografisches Modul nicht manipuliert werden kann, es sei denn, die Siegel am Gehäuse der Lösung werden gebrochen. In diesem Fall würde der sogenannte kryptografische Offizier sofort wissen, dass die Informationssicherheit kompromittiert wurde, und könnte dann umgehend Maßnahmen ergreifen, um etwaige Datenverletzungen zu beheben.

Warum ist FIPS wichtig?

FIPS 140-2 validierte kryptografische Module sind gesetzlich für alle US-Bundesbehörden vorgeschrieben, die sensible, aber nicht klassifizierte Informationen verarbeiten. Und andere Branchen machen FIPS 140-2 Stufe 2 zu einem unverzichtbaren Element für ihre Backhaul-Sicherheit, darunter Finanzen, Gesundheitswesen, Rechtsdienstleistungen, Mobilfunkbetreiber und öffentliche Sicherheitsbranchen.

APISIX konform mit FIPS 140-2

Wie kann man FIPS 140-2-konform sein?

Wenn APISIX mit einer FIPS 140-2 validierten Version von OpenSSL 3.0 verwendet wird, die im FIPS-Modus betrieben wird, ist APISIX mit den Anforderungen von FIPS 140-2 (Stufe 1) in Bezug auf die Entschlüsselung und Verschlüsselung von SSL/TLS-verschlüsseltem Netzwerkverkehr konform.

Auswirkungen

Der FIPS-Modus deaktiviert die folgenden Verschlüsselungsverfahren:

  • TLS_ECDH_anon_WITH_RC4_128_SHA
  • TLS_ECDHE_RSA_WITH_RC4_128_SHA
  • TLS_RSA_WITH_CAMELLIA_128_CBC_SHA
  • TLS_RSA_WITH_CAMELLIA_256_CBC_SHA
  • TLS_RSA_WITH_IDEA_CBC_SHA
  • TLS_RSA_WITH_RC4_128_MD5
  • TLS_RSA_WITH_RC4_128_SHA
  • TLS_RSA_WITH_SEED_CBC_SHA

Außerdem unterstützt FIPS keine RSA-Schlüssel, die kleiner als 2048 Bit sind.

OpenSSL erstellen

OpenSSL mit aktiviertem FIPS erstellen und installieren

apt install -y build-essential
git clone https://github.com/openssl/openssl
cd openssl
./Configure --prefix=/usr/local/openssl-3.0 enable-fips
make install
bash -c "echo /usr/local/openssl-3.0/lib64 > /etc/ld.so.conf.d/openssl3.conf"
ldconfig
/usr/local/openssl-3.0/bin/openssl fipsinstall -out /usr/local/openssl-3.0/ssl/fipsmodule.cnf \
-module /usr/local/openssl-3.0/lib64/ossl-modules/fips.so
sed_expr='s@# .include fipsmodule.cnf@.include /usr/local/openssl-3.0/ssl/fipsmodule.cnf@g;'
sed_expr+=' s/# \(fips = fips_sect\)/\1\nbase = base_sect\n\n[base_sect]\nactivate=1\n/g'
sed -i "$sed_expr" /usr/local/openssl-3.0/ssl/openssl.cnf

bash -c "echo /usr/local/openssl-3.0/lib64 > /etc/ld.so.conf.d/openssl3.conf"
ldconfig

OpenSSL überprüfen

Überprüfen Sie die Konfigurationsdatei (/usr/local/openssl-3.0/ssl/openssl.cnf).

Stellen Sie sicher, dass sie dem folgenden Ausschnitt entspricht:

config_diagnostics = 1
openssl_conf = openssl_init

.include /usr/local/ssl/fipsmodule.cnf

[openssl_init]
providers = provider_sect

[provider_sect]
fips = fips_sect
base = base_sect

[base_sect]
activate = 1

Überprüfen Sie, ob OpenSSL SHA1-Hashes durchführen kann: Dieser Test überprüft den korrekten Betrieb von OpenSSL. Der SHA1-Hash-Algorithmus ist in allen Modi erlaubt, sodass ein Fehler bei diesem Befehl darauf hinweist, dass die OpenSSL-Implementierung nicht korrekt funktioniert:

# openssl sha1 /dev/null
SHA1(/dev/null)= da39a3ee5e6b4b0d3255bfef95601890afd80709

Überprüfen Sie, ob OpenSSL MD5-Hashes durchführen kann: Dieser Test überprüft, ob OpenSSL im FIPS-Modus läuft. MD5 ist kein erlaubter Hash-Algorithmus im FIPS-Modus, sodass ein Versuch, ihn zu verwenden, fehlschlägt:

# openssl md5 /dev/null
Error setting digest
80920FA8DA7F0000:error:0308010C:digital envelope routines:
inner_evp_generic_fetch:unsupported:crypto/evp/evp_fetch.c:341:
Global default library context, Algorithm (MD5 : 100), Properties ()

Wenn OpenSSL nicht im FIPS-Modus läuft, funktioniert der MD5-Hash normal:

# /usr/bin/openssl md5 /dev/null
MD5(/dev/null)= d41d8cd98f00b204e9800998ecf8427e

APISIX mit FIPS erstellen

# install pcre and zlib dependencies
wget -O - https://openresty.org/package/pubkey.gpg | apt-key add -
echo "deb http://openresty.org/package/${arch_path}ubuntu $(lsb_release -sc) main" | \
tee /etc/apt/sources.list.d/openresty.list
apt-get update
apt-get install -y openresty-pcre-dev openresty-zlib-dev

# specify compile and link options
export zlib_prefix=/usr/local/openresty/zlib
export pcre_prefix=/usr/local/openresty/pcre
export cc_opt="-DNGX_LUA_ABORT_AT_PANIC -I${zlib_prefix}/include -I${pcre_prefix}/include"
cc_opt+="-I/usr/local/openssl-3.0/include"
export ld_opt="-L${zlib_prefix}/lib -L${pcre_prefix}/lib -L/usr/local/openssl-3.0/lib64"
ld_opt+="-Wl,-rpath,${zlib_prefix}/lib:${pcre_prefix}/lib:/usr/local/openssl-3.0/lib64"

# build and install apisix-base
wget https://raw.githubusercontent.com/api7/apisix-build-tools/master/build-apisix-base.sh
bash build-apisix-base.sh latest

Eine Testroute konfigurieren

curl http://127.0.0.1:9180/apisix/admin/routes/httpbin -H 'X-API-KEY: YOUR-KEY' -X PUT -i -d '
{
    "uri": "/anything",
    "hosts": ["*.httpbin.org"],
    "methods": ["GET"],
    "upstream": {
        "type": "roundrobin",
        "nodes": {
            "httpbin.org": 1
        }
    }
}'

Testen Sie den privaten Schlüssel

Testen Sie den normalen Fall, wir erwarten, dass er erfolgreich ist.

Erstellen Sie ein Python-Hilfsskript zum Hochladen des Zertifikats:

cfg_ssl.py

import sys
import requests

if len(sys.argv) <= 3:
    print("bad argument")
    sys.exit(1)

with open(sys.argv[1]) as f:
    cert = f.read()

with open(sys.argv[2]) as f:
    key = f.read()

sni = sys.argv[3]
api_key = "edd1c9f034335f136f87ad84b625c8f1"

resp = requests.put("http://127.0.0.1:9180/apisix/admin/ssls/1", json={
    "cert": cert,
    "key": key,
    "snis": [sni],
}, headers={
    "X-API-KEY": api_key,
})
print(resp.status_code)
print(resp.text)

Erstellen Sie eine Bash-Funktion, um die Schlüsselgenerierung zu vereinfachen:

genkey() {
    keylen=${1:-4096}
    /usr/bin/openssl genrsa -out apisix.key $keylen
    /usr/bin/openssl req -key apisix.key -new -out apisix.csr -subj '/C=/ST=/L=/O=/OU=web/CN=*.httpbin.org'
    /usr/bin/openssl x509 -req -in apisix.csr -signkey apisix.key -out apisix.crt -days 3650 -sha256
}

Test:

cd $(mktemp -d)
genkey 2048
python3 ssl.py apisix.crt apisix.key '*.httpbin.org'
curl --resolve 'www.httpbin.org:9443:127.0.0.1' https://www.httpbin.org:9443/uuid -vvv -k

Ausgabe:

...
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN, server accepted to use h2
* Server certificate:
*  subject: OU=web; CN=*.httpbin.org
*  start date: Dec 22 05:52:58 2022 GMT
*  expire date: Dec 19 05:52:58 2032 GMT
*  issuer: OU=web; CN=*.httpbin.org
*  SSL certificate verify result: self signed certificate (18), continuing anyway.
* Using HTTP2, server supports multi-use
* Connection state changed (HTTP/2 confirmed)
* Copying HTTP/2 data in stream buffer to connection buffer after upgrade: len=0
* Using Stream ID: 1 (easy handle 0x55e125a24e30)
> GET /uuid HTTP/2
> Host: www.httpbin.org:9443
> user-agent: curl/7.68.0
> accept: */*
>
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* old SSL session ID is stale, removing
* Connection state changed (MAX_CONCURRENT_STREAMS == 128)!
< HTTP/2 200
< content-type: application/json
< content-length: 53
< date: Thu, 22 Dec 2022 06:35:04 GMT
< access-control-allow-origin: *
< access-control-allow-credentials: true
< server: APISIX/3.0.0
<
{
  "uuid": "1827f239-376f-47ec-9b54-d5addaa8c7f9"
}

Testen Sie Schlüssel kleiner als 2048 Bit

FIPS unterstützt keine RSA-Schlüssel, die kleiner als 2048 Bit sind. Lassen Sie uns also testen, ob es mit einem kleinen Schlüssel fehlschlägt.

genkey 1024
python3 cfg_ssl.py apisix.crt apisix.key '*.httpbin.org'
curl --resolve 'www.httpbin.org:9443:127.0.0.1' https://www.httpbin.org:9443/uuid -vvv -k

Ausgabe:

...
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.3 (IN), TLS alert, internal error (592):
* error:14094438:SSL routines:ssl3_read_bytes:tlsv1 alert internal error
* Closing connection 0
curl: (35) error:14094438:SSL routines:ssl3_read_bytes:tlsv1 alert internal error

Fazit

Angesichts der strengen Tests, die FIPS mit sich bringen, gelten sie als ein zuverlässiger Sicherheitsstandard. Darüber hinaus sind sie eine nützliche Grundlage für alle Organisationen, die Sicherheitsstandards in ihrer Infrastruktur implementieren müssen.

Es ist einfach, FIPS-Unterstützung in APISIX hinzuzufügen. APISIX kann verwendet werden, um SSL/TLS-verschlüsselten Netzwerkverkehr in Bereitstellungen zu entschlüsseln und zu verschlüsseln, die FIPS 140-2 Stufe 1-Konformität erfordern.

Weitere Informationen über API-Gateways finden Sie in unseren Blogs oder kontaktieren Sie uns.

Tags:
APISIX Basics
API Security
Data Management