APISIX : Conformité à la norme FIPS 140-2

Jinhua Luo

January 6, 2023

Products

Qu'est-ce que FIPS 140-2 ?

FIPS signifie Federal Information Processing Standards, un ensemble de normes de sécurité informatique établies par le National Institute of Standards and Technology (NIST) du département du Commerce des États-Unis.

L'objectif de FIPS est de créer un niveau de sécurité uniforme pour toutes les agences fédérales afin de protéger les informations sensibles mais non classifiées - une grande partie des données électroniques qui ne sont pas considérées comme secrètes ou de niveau supérieur.

Niveaux de sécurité de FIPS 140-2

FIPS 140-2/3 sont des normes fréquemment utilisées dans le contexte de la cybersécurité. Elles concernent toutes deux les exigences de sécurité standard pour les modules cryptographiques. FIPS 140-3 finira par remplacer FIPS 140-2, et cette transition est actuellement en cours.

  • Niveau 1 – Le niveau de sécurité le plus bas qui impose des exigences minimales et nécessite que tous les composants soient de qualité de production. FIPS 140-2 Niveau 1 concerne spécifiquement les modules cryptographiques logiciels et stipule les algorithmes cryptographiques qui peuvent être utilisés ainsi que les auto-tests qui doivent être effectués pour vérifier leur intégrité.
  • Niveau 2 – Exigences supplémentaires pour la preuve de manipulation physique ainsi que l'authentification basée sur les rôles.
  • Niveau 3 – Obligation supplémentaire de renforcer la sécurité contre les attaquants, l'utilisation de l'authentification basée sur l'identité, ainsi que la séparation physique entre les interfaces.
  • Niveau 4 – Le niveau le plus strict qui nécessite des mesures de sécurité physique robustes contre les attaques environnementales.

Par exemple, un module cryptographique validé FIPS 140-2 Niveau 1 fournit ce niveau de sécurité de base en chiffrant les données qui le traversent au niveau de protection fourni par AES. Cependant, un module cryptographique validé FIPS 140-2 Niveau 2 fournit non seulement le chiffrement électronique AES mais aussi la sécurité physique de l'appareil lui-même.

Cela signifie qu'un module cryptographique validé FIPS 140-2 Niveau 2 ne peut pas être manipulé à moins que les sceaux sur le boîtier de la solution ne soient brisés, auquel cas le soi-disant officier cryptographique saura immédiatement que la sécurité de l'information a été compromise et pourra alors prendre des mesures immédiates pour remédier à toute violation de données.

Pourquoi FIPS est-il important ?

Les modules cryptographiques validés FIPS 140-2 sont requis par la loi pour toutes les agences fédérales américaines qui traitent des informations sensibles mais non classifiées. Et d'autres secteurs industriels font de FIPS 140-2 Niveau 2 un élément non négociable pour leur sécurité de backhaul, y compris la finance, la santé, les services juridiques, les opérateurs mobiles et les industries de la sécurité publique.

APISIX conforme à FIPS 140-2

Comment être conforme à FIPS 140-2 ?

Lorsqu'il est utilisé avec une version validée FIPS 140-2 d'OpenSSL 3.0 fonctionnant en mode FIPS, APISIX est conforme aux exigences de FIPS 140-2 (Niveau 1) concernant le déchiffrement et le chiffrement du trafic réseau chiffré SSL/TLS.

Influences

Le mode FIPS désactive les chiffrements suivants :

  • 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

De plus, FIPS ne prend pas en charge les clés RSA de moins de 2048 bits.

Construire OpenSSL

Construire et installer OpenSSL avec FIPS activé

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

Vérifier OpenSSL

Vérifiez le fichier de configuration (/usr/local/openssl-3.0/ssl/openssl.cnf).

Assurez-vous qu'il correspond à l'extrait ci-dessous :

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

Déterminez si OpenSSL peut effectuer des hachages SHA1 : Ce test vérifie le bon fonctionnement d'OpenSSL. L'algorithme de hachage SHA1 est autorisé dans tous les modes, donc un échec de cette commande indique que l'implémentation d'OpenSSL ne fonctionne pas correctement :

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

Déterminez si OpenSSL peut effectuer des hachages MD5 : Ce test vérifie qu'OpenSSL fonctionne en mode FIPS. MD5 n'est pas un algorithme de hachage autorisé en mode FIPS, donc une tentative de l'utiliser échoue :

# 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 ()

Si OpenSSL ne fonctionne pas en mode FIPS, la fonction de hachage MD5 fonctionne normalement :

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

Construire APISIX avec FIPS

# 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

Configurer une route de test

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
        }
    }
}'

Tester la validation de la clé privée

Testez un cas normal, nous nous attendons à ce qu'il réussisse.

Créez un script Python auxiliaire pour télécharger le certificat :

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)

Créez une fonction bash pour faciliter la génération de clés :

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
}

Testez :

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

Sortie :

...
* 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"
}

Tester une clé de moins de 2048 bits

FIPS ne prend pas en charge les clés RSA de moins de 2048 bits. Alors, testons si cela échoue avec une petite clé.

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

Sortie :

...
* 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

Conclusion

Compte tenu des tests rigoureux que FIPS implique, elles sont considérées comme une norme de sécurité fiable. De plus, elles constituent une base utile pour toute entité qui doit mettre en œuvre des normes de sécurité dans son infrastructure.

Il est facile d'ajouter la prise en charge de FIPS dans APISIX. APISIX peut être utilisé pour déchiffrer et chiffrer le trafic réseau chiffré SSL/TLS dans les déploiements nécessitant une conformité FIPS 140-2 Niveau 1.

Pour plus d'informations sur la passerelle API, veuillez visiter notre blog ou nous contacter.

Tags:
APISIX Basics
API Security
Data Management