Nouvelle publication
Article
· Jan 28 34m de lecture

Sécurité dans IRIS

#Administration du système #Contrôle d'accès #DevOps #Docker #Sécurité #InterSystems IRIS

La sécurité est fondamentale pour le développement d'applications d'entreprise. InterSystems IRIS fournit un cadre de sécurité complet qui protège les données, contrôle l'accès et garantit la conformité. Ce guide présente les fonctionnalités de sécurité essentielles pour les développeurs novices dans IRIS, couvrant l'authentification, l'autorisation, le chiffrement et les stratégies de mise en œuvre pratiques.

Tout au long de ce guide, nous illustrerons les configurations de sécurité à l'aide de conteneurs Docker dans un environnement pratique et reproductible. Tous les exemples utilisent le registre officiel de conteneurs InterSystems pour déployer InterSystems IRIS et Web Gateway, ce qui facilite le suivi et le test des fonctionnalités de sécurité dans votre propre environnement de développement.

Exécution d'IRIS dans Docker avec une configuration sécurisée

Lors du déploiement d'IRIS dans des conteneurs, il est essentiel de changer les mots de passe par défaut immédiatement après le démarrage. Dans cette section, nous allons voir comment exécuter IRIS avec Web Gateway dans Docker et configurer correctement l'authentification.

Utilisation du registre de conteneurs InterSystems

Tous les exemples de conteneurs dans cet article utilisent le Registre officiel de conteneurs InterSystems. Ce registre fournit des images de conteneurs officielles et prises en charge pour InterSystems IRIS, InterSystems IRIS for Health, Web Gateway et d'autres produits InterSystems.

Exigences d'authentification

Important: Le téléchargement des images de conteneurs InterSystems IRIS non communautaires nécessite un compte WRC (Worldwide Response Center) InterSystems. Pour nos besoins, nous pouvons omettre l'étape d'authentification. Si vous souhaitez utiliser des images IRIS qui ne proviennent pas de la communauté, veuillez d'abord vous authentifier auprès du registre

# Connexion au registre de conteneurs InterSystems
$ docker login containers.intersystems.com
# Saisie de votre nom d'utilisateur et mot de passe du WRC lorsque vous y êtes invité

Recherche des balises d'images disponibles

Les balises d'image changent au fil du temps à mesure que de nouvelles versions sont publiées. Pour trouver les dernières balises disponibles:

Méthode 1 : Portail Web (la plus simple)

  1. Visitez https://containers.intersystems.com/contents
  2. Connectez-vous avec vos identifiants WRC InterSystems (pour les images non communautaires)
  3. Accédez à InterSystems IRIS Community Edition → iris-community (ou webgateway)
  4. Développez le dépôt pour voir toutes les balises disponibles
  5. Copiez la commande docker pull pour la balise souhaitée

Méthode 2 : Ligne de commande avec Skopeo

À l'aide de skopeo, listez les balises disponibles par programmation. Notez qu'un outil auparavant populaire nommé docker-ls était utilisé à cette fin, mais il est désormais archivé et n'est plus maintenu.

Étape 1 : Installation de skopeo

# Sur macOS
$ brew install skopeo

# Sur Ubuntu/Debian
$ sudo apt-get install skopeo

# Sur RHEL/CentOS
$ sudo dnf install skopeo

Étape 2 : Authentification auprès du registre (pour les utilisateurs non membres de la communauté)

# Connectez-vous à l'aide de vos identifiants WRC InterSystems
$ skopeo login containers.intersystems.com
# Vous serez invité à saisir votre nom d'utilisateur et votre mot de passe

Étape 3 : Liste des balises disponibles

# Liste des balises IRIS Community Edition disponibles
$ skopeo list-tags docker://containers.intersystems.com/intersystems/iris-community

# Liste des balises WebGateway
$ skopeo list-tags docker://containers.intersystems.com/intersystems/webgateway

Méthode 3 : Inspection d'une image extraite

Après avoir téléchargé une image avec une balise comme latest-em, vous pouvez vérifier la version exacte:

# Téléchargement de l'image
$ docker pull containers.intersystems.com/intersystems/iris-community:latest-em

# Vérification de la version exacte
$ docker inspect containers.intersystems.com/intersystems/iris-community:latest-em \
  --format '{{ index .Config.Labels "com.intersystems.platform-version"}}'

# Exemple de résultat: 2025.1.0.230.2com

Conventions de nommage des balises

InterSystems utilise les modèles de balises suivants:

  • Versions spécifiques : 2025.1, 2024.3, 2023.2 (au format année.version)
  • Dernière maintenance étendue : latest-em (où em = extended maintenance, ou maintenance étendue)
  • Dernière livraison continue : latest-cd (où cd = continuous delivery, ou livraison continue)
  • Dernière préversion : latest-preview (versions préliminaires)

Remarques importantes :
- InterSystems N'UTILISE PAS de balise générique latest - spécifiez toujours une version
- Les balises contiennent l'année et la version, mais ne mentionnent pas le numéro de build complet
- Pour la production, utilisez des balises de version spécifiques (par exemple, 2025.1) plutôt que des balises latest-*
- InterSystems recommande de conserver votre propre registre privé avec des versions spécifiques

Images utilisées dans cet article

Les exemples ci-dessous utilisent les balises suivantes, qui étaient les dernières disponibles au moment de la rédaction (novembre 2025) :

  • IRIS : 2025.1 (version de maintenance étendue)
  • Passerelle Web : 2025.1

Pour obtenir les versions les plus récentes, consultez le registre comme décrit ci-dessus avant le déploiement.

Docker Compose avec Web Gateway

Selon la documentation officielle d'InterSystems, la passerelle Web doit être déployée séparément des instances IRIS afin de fournir :

  • Équilibrage de charge et basculement - Répartition des requêtes entre plusieurs backends IRIS pour une haute disponibilité
  • Isolement de sécurité - Web Gateway gère les connexions externes tandis qu'IRIS reste dans un niveau réseau protégé
  • Évolutivité - Évoluez indépendamment le niveau web et le niveau base de données en fonction des exigences de charge de travail
  • Routage centralisé - Une seule passerelle peut servir plusieurs instances IRIS ayant des profils d'application différents

Cette séparation est essentielle pour les environnements de production et suit les meilleures pratiques en matière d'architecture multi-niveaux.

Configuration complète de Docker Compose

Créez un fichier docker-compose.yaml avec des conteneurs IRIS et Web Gateway séparés:

services:
  iris:
    image: containers.intersystems.com/intersystems/iris-community:2025.1
    container_name: iris
    environment:
      - ISC_CPF_MERGE_FILE=/merge/merge.cpf
      - ISC_DATA_DIRECTORY=/durable
    volumes:
      - ./merge.cpf:/merge/merge.cpf:ro
      - ./iris-data:/durable
    networks:
      - iris-network
    command: --check-caps false

  webgateway:
    image: containers.intersystems.com/intersystems/webgateway:2025.1
    init: true
    container_name: webgateway
    ports:
      - "8080:80"
      - "8443:443"
    environment:
      - ISC_CSP_INI_FILE=/webgateway-shared/CSP.ini
      - ISC_CSP_CONF_FILE=/webgateway-shared/CSP.conf
    volumes:
      - type: bind
        source: ./webgateway
        target: /webgateway-shared
    depends_on:
      - iris
    networks:
      - iris-network

networks:
  iris-network:
    driver: bridge

Fichiers de configuration

1. Créez le fichier merge.cpf avec la configuration du système

[Startup]
SystemMode=Development
WebServerPort=0

Remarques sur la configuration :
- Fichier CPF : fichier de paramètres de configuration pouvant être utilisé pour configurer certains paramètres IRIS de manière déclarative.
- SystemMode=Development - Étiquette affichée dans l'en-tête du portail de gestion (utilisez DEVELOPMENT, TEST, etc. selon le cas)
- WebServerPort=0 - Désactive le serveur Web interne (puisque nous utilisons un conteneur Web Gateway séparé). Ne concerne que les images IRIS communautaires, les images non communautaires ne contiennent déjà pas de WebGateway interne
- ISC_DATA_DIRECTORY=/durable - Active %SYS durable pour la persistance des données lors des redémarrages du conteneur
- command: --check-caps false - Désactive les vérifications de capacité Linux (requises pour certains environnements)
- Licence : Aucune configuration de clé de licence n'est nécessaire pour ce cas d'utilisation. InterSystems IRIS Community Edition fonctionne sans clé de licence à des fins de développement et d'enseignement.
- Sécurité : après le démarrage, vous serez invité à modifier les mots de passe par défaut "SYS" à l'aide du portail de gestion ou d'ObjectScript.

2. Créez un répertoire webgateway avec les fichiers de configuration:

$ mkdir webgateway

3. Créez le fichier webgateway/CSP.ini en utilisant le mot de passe par défaut (modifiez les mots de passe après la première connexion):

[SYSTEM]
IRISCONNECT_LIBRARY_PATH=/opt/webgateway/bin
System_Manager=*.*.*.*
Default_Server=LOCAL
Username=CSPSystem
Password=SYS

[SYSTEM_INDEX]
LOCAL=Enabled

[LOCAL]
Ip_Address=iris
TCP_Port=1972
Username=CSPSystem
Password=SYS

[APP_PATH_INDEX]
/=Enabled
/csp=Enabled

[APP_PATH:/]
Default_Server=LOCAL

[APP_PATH:/csp]
Default_Server=LOCAL

Remarques importantes concernant la sécurité :
- Le mot de passe est initialement stocké en texte clair dans le fichier CSP.ini
- Lors du premier démarrage, Web Gateway crypte automatiquement le mot de passe à l'aide de DPAPI. Pour plus d'informations, consultez Protection des connexions Web Gateway à InterSystems IRIS
- Après cryptage, le mot de passe apparaîtra sous la forme Password=ENC:AQAAANCMnd...

4. Créez le fichier webgateway/CSP.conf pour configurer Apache (exécuté dans le conteneur Web Gateway) afin d'acheminer les requêtes CSP:

# fichier de configuration CSP

CSPModulePath "${ISC_PACKAGE_INSTALLDIR}/bin/"
CSPConfigPath "${ISC_PACKAGE_INSTALLDIR}/bin/"

# Fournissez tout via Web Gateway
<Location />
    CSP On
</Location>

<Directory />
    Options MultiViews FollowSymLinks
    AllowOverride None
    Require all granted
    <FilesMatch "\.(log|ini|pid|exe|so)$">
        Require all denied
    </FilesMatch>
</Directory>

# Redirigez les liens d'aide
Redirect /csp/docbook/ https://docs.intersystems.com/irislatest/csp/docbook/

Remarques sur la configuration CSP.conf :
- CSPModulePath et CSPConfigPath pointent vers le répertoire binaire Web Gateway
- La directive <Location /> avec CSP On active la gestion CSP pour tous les chemins
- La section <Directory> définit les stratégies de sécurité :
- Require all granted autorise l'accès (authentification gérée par IRIS)
- <FilesMatch> refuse l'accès direct aux fichiers sensibles (journaux, fichiers de configuration, binaires)
- La directive Redirect envoie des liens vers la documentation d'aide vers les documents officiels d'InterSystems
- La variable d'environnement ${ISC_PACKAGE_INSTALLDIR} est automatiquement remplacée par le conteneur Web Gateway

Démarrage de l'environnement

Votre structure de répertoires doit ressembler au modèle suivant :

project/
├── docker-compose.yaml
├── merge.cpf
└── webgateway/
    ├── CSP.ini
    └── CSP.conf

Démarrez l'environment:

# Démarrez les deux conteneurs
$ docker-compose up -d

# Vérifiez l'état du conteneur
$ docker-compose ps

# Affichez les journaux
$ docker-compose logs -f

L'environnement démarrera au moyen de :
- Instance IRIS avec mots de passe par défaut (à modifier immédiatement)
- Passerelle Web configurée pour s'authentifier auprès d'IRIS à l'aide de l'utilisateur CSPSystem
- Configuration Apache chargée automatiquement à partir de CSP.conf
- Stockage persistant activé via ISC_DATA_DIRECTORY pour la durabilité des données
- Isolation réseau avec IRIS et passerelle Web sur un réseau Docker privé

Accès et sécurisation de l'environnement

Après avoir démarré vos conteneurs, vous devrez sécuriser les mots de passe par défaut :

Étape 1 : accédez au portail de gestion et modifiez le mot de passe _SYSTEM

Accédez à http://localhost:8080/csp/sys/UtilHome.csp et connectez-vous au moyen de :
- Nom d'utilisateur : _SYSTEM
- Mot de passe : SYS

IRIS vous invite tout de suite à modifier le mot de passe _SYSTEM défini par défaut. Choisissez un mot de passe fort (12 caractères au moins, mélangeant majuscules, minuscules, chiffres et caractères spéciaux).

Étape 2 : Modifiez les autres mots de passe par défaut

Après vous êtes connecté au moyen de votre nouveau mot de passe _SYSTEM :

  1. Accédez à Administration système > Sécurité > Utilisateurs (System Administration > Security > Users)
  2. Modifiez les mots de passe des autres comptes importants (Admin, CSPSystem, SuperUser)
  3. Utilisez des mots de passe forts et uniques pour chaque compte
  4. Redémarrez les conteneurs au moyen de docker-compose restart pour vous assurer que toutes les sessions CSP sont rétablies.

Étape 2.1 : Configurez le portail de gestion Web Gateway

Prise en compte des deux utilisateurs CSPSystem

Lorsque vous utilisez Web Gateway, il est important de comprendre qu'il existe deux contextes CSPSystem distincts :

  1. Utilisateur CSPSystem dans IRIS : il s'agit d'un compte utilisateur IRIS prédéfini utilisé par Web Gateway à l'aide de l'authentification auprès du service %Service_WebGateway. Cela permet à Web Gateway de communiquer avec les instances IRIS.

  2. Identifiants du portail de gestion Web Gateway - Il s'agit d'identifiants distincts utilisés à l'aide de l'interface de gestion propre à Web Gateway (généralement à l'adresse /csp/bin/Systems/Module.cxw). Ce N'EST PAS le même que le portail de gestion IRIS.

La passerelle Web a sa propre interface de gestion qui doit être sécurisée. Accédez-y à l'adresse http://localhost:8080/csp/bin/Systems/Module.cxw et connectez-vous au moyen de :
- Nom d'utilisateur : CSPSystem
- Mot de passe : SYS

image

1. Changez le mot de passe d'accès au serveur

Accédez à la configuration du serveur et mettez à jour le mot de passe d'accès au serveur :

image

Saisissez le nouveau mot de passe CSPSystem que vous avez défini à l'étape 2.

2. Testez la connexion au serveur

Après avoir mis à jour le mot de passe, testez la connexion pour vous assurer que la passerelle Web peut communiquer avec IRIS :

image

Une connexion réussie confirme que la passerelle Web est correctement authentifiée auprès d'IRIS.

3. Mettez à jour le mot de passe des paramètres par défaut

Mettez à jour le mot de passe par défaut en utilisant les paramètres par défaut :

image

Cela garantit que l'interface utilisateur de la passerelle Web utilise à l'aide des identifiants mis à jour.

Étape 3 : Mettez à jour le fichier de configuration de la passerelle Web

Après avoir modifié les mots de passe via le portail de gestion de la passerelle Web à l'étape 2.1, la passerelle Web a chiffré les nouveaux mots de passe dans son fichier CSP.ini interne. Vous devez copier ces mots de passe chiffrés dans votre fichier de configuration local.

Important : la passerelle Web chiffre les mots de passe à l'aide de DPAPI. Vous devez récupérer les mots de passe chiffrés à l'intérieur du conteneur plutôt que de saisir des mots de passe sous forme de texte brut.

1. Extrayez les mots de passe du conteneur:

# Copiez les mots de passe à partir du fichier CSP.ini du conteneur
$ docker exec webgateway cat /opt/webgateway/bin/CSP.ini | grep -i "password"

Vous verrez s'afficher les mots de passe sous forme cryptée et sous forme de texte brut :

Password=ENC:AQAAANCMnd8BFdERjHoAwE/Cl+sBAAAA...
Password=]]]...

2. Mettez à jour votre fichier local webgateway/CSP.ini :

Copiez les valeurs de mot de passe à partir de la sortie du conteneur et mettez à jour les saisies correspondantes dans votre fichier local ./webgateway/CSP.ini.

[SYSTEM]
IRISCONNECT_LIBRARY_PATH=/opt/webgateway/bin
System_Manager=*.*.*.*
Default_Server=LOCAL
Username=CSPSystem
Password=ENC:AQAAANCMnd8BFdERjHoAwE/Cl+sBAAAA...  # Encrypted password from [SYSTEM] section

[LOCAL]
Ip_Address=iris
TCP_Port=1972
Username=CSPSystem
Password=]]]...  # Password from [LOCAL] section

3. Redémarrez la passerelle Web:

$ docker-compose restart webgateway

Après le redémarrage, vérifiez que la passerelle Web peut toujours se connecter à IRIS en accédant au portail de gestion à l'adresse http://localhost:8080/csp/sys/UtilHome.csp.

Prendre connaissance de l'architecture de sécurité IRIS

IRIS met en œuvre un modèle de sécurité à plusieurs niveaux reposant sur trois composants principaux :

Les ressources représentent les actifs protégés (bases de données, services, applications). Chaque ressource a un nom avec des préfixes de norme tels que %DB_* pour les bases de données, %Service_* pour les services et %Admin_* pour les fonctions administratives.

Les privilèges définissent les autorisations sur les ressources. Les trois types de privilèges sont READ, WRITE et USE, qui contrôlent différents niveaux d'accès aux actifs protégés.

Les rôles sont des ensembles nommés de privilèges. Au lieu d'accorder des autorisations directement aux utilisateurs, vous attribuez des rôles aux utilisateurs, et ces rôles contiennent les privilèges nécessaires. Cette approche de contrôle d'accès basé sur les rôles (RBAC) simplifie la gestion des autorisations et garantit la cohérence.

Gestion des utilisateurs et des mots de passe par défaut

Lorsque vous installez InterSystems IRIS pour la première fois, plusieurs comptes système prédéfinis sont créés. Il est essentiel de comprendre et de sécuriser ces comptes pour garantir la sécurité du système.

Comptes utilisateur prédéfinis

InterSystems IRIS comprend les comptes par défaut suivants :

Nom d'utilisateur Objectif Mot de passe par défaut Risque pour la sécurité
_SYSTEM Compte administrateur système principal SYS Critique - À modifier immédiatement
Admin Compte administratif secondaire SYS Élevé - À désactiver ou à sécuriser
CSPSystem Compte interne CSP/application web SYS Élevé - Utilisé par les applications Web
SuperUser Compte à privilège élevé SYS Élevé - À désactiver si inutile
UnknownUser Utilisateur non authentifié par défaut N/A Moyen - A des privilèges minimaux

Remarque importante concernant la sécurité : le mot de passe par défaut "SYS"" constitue une faille de sécurité bien connue. InterSystems recommande vivement de modifier tous les mots de passe par défaut immédiatement après l'installation.

Modification des mots de passe par défaut

Méthode 1 : Utilisation du portail de gestion

  1. Accédez à Administration système > Sécurité > Utilisateurs (
    System Administration > Security > Users)
  2. Cliquez sur le nom d'utilisateur (par exemple, _SYSTEM)
  3. Cliquez sur Modifier (Edit)
  4. Saisissez un nouveau mot de passe dans le champ Mot de passe (Password)
  5. Confirmez le mot de passe
  6. Cliquez sur Enregistrer (Save)

image

Méthode 2 : Utilisation du terminal (utilitaire ^SECURITY)

Accédez au terminal IRIS et utilisez l'utilitaire interactif ^SECURITY :

$ docker exec -it iris iris session iris -U %SYS
%SYS> do ^SECURITY

1) User setup
2) Role setup
...

Select option: 1

1) Create user
2) Edit user
...

Username to edit? _SYSTEM
Full name? SQL System Manager =>
Comment?
Password? ***** =>
...

La routine ^SECURITY fournit une interface interactive pilotée par menus pour gérer les utilisateurs, les rôles et les ressources.

Authentification : vérification de l'identité de l'utilisateur

IRIS prend en charge plusieurs méthodes d'authentification pour vérifier l'identité de l'utilisateur :

  • Authentification par mot de passe - Vérification traditionnelle du nom d'utilisateur/mot de passe
  • Authentification déléguée - Logique d'authentification personnalisée à l'aide d'ObjectScript
  • LDAP/Active Directory - Intégration de répertoires d'entreprise
  • OAuth 2.0 et OpenID Connect - Authentification fédérée moderne pour l'authentification unique
  • Kerberos - Protocole d'authentification réseau

Pour les applications Web et les services REST, l'authentification est configurée via les définitions d'application dans le portail de gestion. Accédez à Administration système > Sécurité > Applications > Applications Web (System Administration > Security > Applications > Web Applications) pour configurer les méthodes d'authentification pour chaque point de terminaison d'application.

Activation des méthodes d'authentification

Par défaut, les applications Web n'affichent que Non authentifié, Mot de passe et Kerberos comme méthodes d'authentification disponibles. Pour activer LDAP ou OAuth, vous devez d'abord les activer au niveau du système Administration système > Sécurité > Sécurité système > Options d'authentification/session Web (System Administration > Security > System Security > Authentication/Web Session Options) :

image

Activation de l'authentification LDAP

Accédez à Administration système > Sécurité > Sécurité du système > Configurations LDAP/Kerberos (System Administration > Security > System Security > LDAP/Kerberos Configurations) et créez une nouvelle configuration LDAP :

image

Testez la configuration pour vous assurer de la connectivité.

Activation de l'authentification OAuth 2.0

Accédez à Administration système > Sécurité > OAuth 2.0 > Client (System Administration > Security > OAuth 2.0 > Client) et y créez une configuration client.

Exemple pratique : authentification par mot de passe de base

Cet exemple montre comment créer un service REST avec authentification par mot de passe, créer un utilisateur et tester le flux d'authentification.

Étape 1 : Créez un utilisateur pour l'application

Créez un nouvel utilisateur webuser au moyen d'un accès à la base de données USER:

$ docker exec -it iris iris session iris -U %SYS
%SYS> do ^SECURITY

1) User setup
Select option: 1

1) Create user
Select option: 1

Username: webuser
Full name: Web Application User
Password: ********
Confirm password: ********

# N'ajoutez pas de rôles à ce stade, utilisez les valeurs par défaut partout

Username webuser created

Étape 2 : Créer la classe de service REST

Sur votre ordinateur local, créez un fichier SecureService.cls contenant les informations suivantes:

Class MyApp.API.SecureService Extends %CSP.REST
{

XData UrlMap [ XMLNamespace = "http://www.intersystems.com/urlmap" ]
{
<Routes>
  <Route Url="/list" Method="GET" Call="GetUsers" />
</Routes>
}

ClassMethod GetUsers() As %Status
{
    // Obtention de l'utilisateur actuel et de ses rôles (disponible dans n'importe quel espace de noms)
    Set currentUser = $USERNAME
    Set currentRoles = $ROLES

    // Journalisation les informations d'authentification dans la console
    Do ##class(%SYS.System).WriteToConsoleLog("REST API accessed by user: "_currentUser, 0, 0)
    Do ##class(%SYS.System).WriteToConsoleLog("User roles: "_currentRoles, 0, 0)

    // Vérification que l'utilisateur dispose d'une Permission READ sur la base de données USER
    If '$SYSTEM.Security.Check("%DB_USER", "READ") {
        Set %response.Status = "403 Forbidden"
        Do ##class(%SYS.System).WriteToConsoleLog("Access denied for user: "_currentUser, 0, 0)
        Return $$$ERROR($$$AccessDenied)
    }

    // Restitution des informations relatives à l'utilisateur actuellement authentifié
    // Remarque : nous utilisons $USERNAME et $ROLES à l'aide d'interroger Security.Users,
    // car la table Security.Users n'est accessible que dans l'espace de noms %SYS
    // et les utilisateurs normaux ne peuvent pas basculer vers l'espace de noms %SYS
    Set userInfo = {}
    Set userInfo.username = currentUser
    Set userInfo.roles = currentRoles

    Write userInfo.%ToJSON()
    Return $$$OK
}

}

Étape 3 : Copiez etimportez la classe

Copiez le fichier dans le conteneur et importez-le :

# Copiez la classe du fichier dans le conteneur
$ docker cp SecureService.cls iris:/tmp/

# Importez la classe
$ docker exec -it iris iris session iris -U USER
USER> do $system.OBJ.Load("/tmp/SecureService.cls", "ck")

Load started on 11/30/2025 12:23:59
Loading file /tmp/SecureService.cls as udl
Compiling class MyApp.API.SecureService
Compiling routine MyApp.API.SecureService.1
Load finished successfully.

Étape 4 : Créez une application Web à l'aide de la Console

Créez l'application Web par programmation à l'aide du terminal. Les indicateurs d'authentification sont définis dans la documentation de la propriété AutheEnabled.

Prendre connaissance des indicateurs d'authentification (logique binaire)

Les méthodes d'authentification sont représentées par des indicateurs binaires. Chaque méthode correspond à une position binaire spécifique, et la valeur est calculée comme suit : 2^(position binaire):

Méthode d'authentification | Position binaire | Valeur calculée (2^n) | Description |
|-----------------------|--------------|------------------------|-------------|
| Kerberos (K5API) | Bit 2 | 4 | Authentification Kerberos |
| Mot de passe | Bit 5 | 32 | Authentification HTTP de base |
| Non authentifié | Bit 6 | 64 | Aucune authentification requise |

Pour activer plusieurs méthodes, ajoutez leurs valeurs calculées :
- Mot de passe uniquement : 32
- Non authentifié + mot de passe : 64 + 32 = 96
- Mot de passe + Kerberos : 32 + 4 = 36

Exemple : authentification de base (mot de passe)

Pour cet exemple, nous allons activer l'authentification par mot de passe (Bit 5 = 32) :

USER> zn "%SYS"
%SYS> set properties("AutheEnabled") = 32  ; Password (Basic Auth) only
%SYS> set properties("NameSpace") = "USER"
%SYS> set properties("DispatchClass") = "MyApp.API.SecureService"
%SYS> set properties("MatchRoles") = ":%DB_USER"
%SYS> set sc = ##class(Security.Applications).Create("/users", .properties)
%SYS> write sc
1

%SYS> halt

Cette opération crée l'application Web /users avec :
- Espace de noms : USER
- Classe de répartition : MyApp.API.SecureService
- Authentification : mot de passe (authentification de base) uniquement
- Ressource : %DB_USER

Remarque importante concernant MatchRoles :

Le paramètre MatchRoles = ":%DB_USER" accorde **temporairement** le rôle%DB_USER` aux utilisateurs authentifiés lorsqu'ils accèdent à cette application Web. Cela signifie le suivant:

  • Le compte webuser n'a 0 rôle permanent attribué
  • Lors de l'accès au point de terminaison /users, l'application Web accorde le rôle %DB_USER pour cette requête
  • La variable $ROLES affiche les rôles actuellement actifs (y compris les rôles temporaires de MatchRoles)
  • Une fois la requête terminée, le rôle temporaire est supprimé

Il s'agit d'une fonctionnalité de sécurité IRIS puissante qui permet à différentes applications Web d'accorder différentes autorisations au même utilisateur, fournissant ainsi un contrôle d'accès précis basé sur le contexte de l'application.

Étape 5 : Vérification de l'authentification**

Testez le point de terminaison REST au moyen de l'authentification et sans authentification :

# Sans authentification - échec prévu
$ curl -XGET -I http://localhost:8080/users/list
HTTP/1.1 401 Unauthorized
...

# Avec une authentification correcte, réussite prévue
$ curl -XGET -u webuser:YourPassword http://localhost:8080/users/list

# Réponse :
# {"username":"webuser","roles":"%DB_USER"}

Étape 6 : Vérifiez les journaux du conteneur IRIS

Après avoir testé le point de terminaison, vous pouvez consulter les journaux de la console pour voir l'information d'authentification enregistrée par le service REST :

# Affichage des journaux IRIS récents
$ docker logs iris --tail 50

# Ou suivi des journaux en temps réel
$ docker logs iris -f

# Recherche de saisies de journal spécifiques
$ docker logs iris 2>&1 | grep -E "REST API accessed | User"

Le résultat devrait être similaire à celui-ci :

12/01/25-07:51:54:646 (1367) 0 [Utility.Event] REST API accessed by user: webuser
12/01/25-07:51:54:647 (1367) 0 [Utility.Event] User roles: %DB_USER

Remarque : La classe Security.Users n'est disponible que dans l'espace de noms %SYS. Dans notre service REST s'exécutant dans l'espace de noms USER, nous utilisons à l'aide des variables système $USERNAME et $ROLES, qui sont disponibles dans tous les espaces de noms.

Prendre connaissance du flux de sécurité :

  1. L'application Web /users nécessite une authentification par mot de passe
  2. L'utilisateur webuser doit fournir des informations d'identification valides
  3. La fonction $SYSTEM.Security.Check() vérifie à quel point l'utilisateur a l'autorisation READ sur %DB_USER
  4. Si l'authentification ou l'autorisation échoue, la requête est rejetée et renvoie une erreur 401 ou 403

Cet exemple illustre le flux complet d'authentification et d'autorisation dans les services IRIS REST.

Démonstration de l'accès au niveau SQL

Étape 1 : Créez une table Cars

Utilisez le shell SQL pour créer une table Cars simple dans l'espace de noms USER :

$ docker exec -it iris iris session iris -U USER
USER> do $system.SQL.Shell()

[SQL]USER>> CREATE TABLE Cars (ID INT PRIMARY KEY, Make VARCHAR(50), Model VARCHAR(50), Year INT)

[SQL]USER>> INSERT INTO Cars (ID, Make, Model, Year) VALUES (1, 'Toyota', 'Camry', 2023)
[SQL]USER>> INSERT INTO Cars (ID, Make, Model, Year) VALUES (2, 'Honda', 'Accord', 2024)
[SQL]USER>> INSERT INTO Cars (ID, Make, Model, Year) VALUES (3, 'Ford', 'Mustang', 2023)

[SQL]USER>> SELECT * FROM Cars
| ID | Make | Model | Year |
| -- | -- | -- | -- |
| 1 | Toyota | Camry | 2023 |
| 2 | Honda | Accord | 2024 |
| 3 | Ford | Mustang | 2023 |

[SQL]USER>> quit
USER> halt

Étape 2 : Ajoutez le point de terminaison Cars au service REST

Mettez à jour le fichier SecureService.cls pour ajouter un nouveau point de terminaison /cars (en conservant le point de terminaison /list existant) :

Class MyApp.API.SecureService Extends %CSP.REST
{

XData UrlMap [ XMLNamespace = "http://www.intersystems.com/urlmap" ]
{
<Routes>
  <Route Url="/list" Method="GET" Call="GetUsers" />
  <Route Url="/cars" Method="GET" Call="GetCars" />
</Routes>
}

ClassMethod GetUsers() As %Status
{
    // Obtention de l'utilisateur actuel et des rôles (disponible dans n'importe quel espace de noms)
    Set currentUser = $USERNAME
    Set currentRoles = $ROLES

    // Journalisation des informations d'authentification dans la console
    Do ##class(%SYS.System).WriteToConsoleLog("REST API accessed by user: "_currentUser, 0, 0)
    Do ##class(%SYS.System).WriteToConsoleLog("User roles: "_currentRoles, 0, 0)

    // Vérification des droits READ de l'utilisateur pour l'accès à la base de données USER
    If '$SYSTEM.Security.Check("%DB_USER", "READ") {
        Set %response.Status = "403 Forbidden"
        Do ##class(%SYS.System).WriteToConsoleLog("Access denied for user: "_currentUser, 0, 0)
        Return $$$ERROR($$$AccessDenied)
    }

    // Renvoi des informations d'authentification de l'utilisateur
    // Remarque : nous utilisons $USERNAME et $ROLES au lieu d'interroger Security.Users,
    // car la table Security.Users n'est accessible que dans l'espace de noms %SYS
    // et les utilisateurs ordinaires ne peuvent pas basculer vers l'espace de noms %SYS
    Set userInfo = {}
    Set userInfo.username = currentUser
    Set userInfo.roles = currentRoles

    Write userInfo.%ToJSON()
    Return $$$OK
}

ClassMethod GetCars() As %Status
{
    // Obtention de l'utilisateur actuel
    Set currentUser = $USERNAME

    // Une tentative d'accès au journal
    Do ##class(%SYS.System).WriteToConsoleLog("Cars endpoint accessed by: "_currentUser, 0, 0)

    // Vérification des droits READ de l'utilisateur
    If '$SYSTEM.Security.Check("%DB_USER", "READ") {
        Set %response.Status = "403 Forbidden"
        Return $$$ERROR($$$AccessDenied)
    }

    // Requête sur la table des voitures
    Set cars = []
    Set sql = "SELECT ID, Make, Model, Year FROM SQLUser.Cars"
    Set statement = ##class(%SQL.Statement).%New()
    Do statement.%Prepare(sql)
    Set result = statement.%Execute()

    While result.%Next() {
        Set car = {}
        Set car.id = result.ID
        Set car.make = result.Make
        Set car.model = result.Model
        Set car.year = result.Year
        Do cars.%Push(car)
    }

    Write cars.%ToJSON()
    Return $$$OK
}

}

Étape 3 : Réimportez la classe mise à jour

$ docker cp SecureService.cls iris:/tmp/
$ docker exec -it iris iris session iris -U USER
USER> do $system.OBJ.Load("/tmp/SecureService.cls", "ck")

Étape 4 : Testez le point de terminaison Cars

# Test avec webuser (accès %DB_USER via MatchRoles)
$ curl -XGET -u webuser:YourPassword http://localhost:8080/users/cars

# Réponse:
# []

Important : les autorisations SQL sont indépendantes des autorisations relatives aux ressources de la base de données

Bien qu'elle ait un accès à la base de données %DB_USER, la requête renvoie une matrice vide []. Cela s'explique par le fait que les autorisations SQL sont indépendantes des autorisations relatives aux ressources de la base de données. Le rôle %DB_USER accorde un accès READ à la ressource de la base de données, mais n'accorde PAS automatiquement les privilèges SQL SELECT sur les tables individuelles.

Pour interroger la table Cars, il faut explicitement accorder les autorisations SQL à l'utilisateur :

$ docker exec -it iris iris session iris -U USER

USER> do $system.SQL.Shell()
[SQL]USER>>GRANT SELECT ON Cars TO webuser
[SQL]USER>>quit
USER> halt

Vous pouvez également vérifier les autorisations SQL accordées dans le portail de gestion :

image

Maintenant, faites le test encore une fois :

$ curl -XGET -u webuser:YourPassword http://localhost:8080/users/cars

# Réponse:
#[{"id":1,"make":"Toyota","model":"Camry","year":2023},{"id":2,"make":"Honda","model":"Accord","year":2024},{"id":3,"make":"Ford","model":"Mustang","year":2023}]

Cela montre comment fonctionne le RBAC dans IRIS : les utilisateurs ont besoin À LA FOIS de l'accès aux ressources de la base de données (via des rôles tels que %DB_USER) ET de privilèges sur les tables SQL (via des instructions GRANT) pour interroger les tables. Le paramètre MatchRoles de l'application Web accorde temporairement le rôle %DB_USER, mais les autorisations SQL doivent être configurées séparément.

Les privilèges SQL (SELECT, INSERT, UPDATE, DELETE) fonctionnent indépendamment des autorisations d'accès aux ressources de la base de données. Pour une protection complète, les utilisateurs ont généralement besoin à la fois d'un accès aux ressources de la base de données et des privilèges SQL.

Cryptage et protection des données

TLS/SSL pour les données en transit

IRIS prend en charge le cryptage TLS pour protéger les données transmises sur le réseau. Une configuration SSL/TLS dans IRIS est un ensemble nommé de paramètres de sécurité qui spécifient les certificats, les clés privées et les paramètres de cryptage.

Prendre connaissance des configurations SSL/TLS

Il existe deux types de configurations SSL/TLS :

Configurations serveur - Utilisées lorsque IRIS agit en tant que serveur acceptant les connexions cryptées :
- Composants requis : certificat serveur (.crt), clé privée (.key), certificat CA facultatif
- Cas d'utilisation : sécurisation du superserveur pour les clients ODBC/JDBC, connexions miroir, services Web
- Objectif : authentification de l'instance IRIS auprès des clients et cryptage de la connexion

Configurations client - Utilisées lorsque IRIS se connecte à des services externes :
- Composants requis : certificat CA (pour vérifier le serveur), éventuellement certificat client pour TLS mutuel
- Cas d'utilisation : appel d'API HTTPS externes, connexion à des bases de données externes
- Objectif : vérification de l'identité du serveur distant et, éventuellement, authentification d'IRIS auprès du serveur distant

Pourquoi créer une configuration minimale ?

Vous pouvez créer une configuration SSL/TLS avec uniquement un nom pour les appels HTTPS sortants simples qui s'appuient sur le magasin de certificats par défaut du système d'exploitation. Cependant, pour une utilisation en production, vous devez spécifier :

  • Fichier de certificat CA - Pour vérifier l'identité du serveur distant
  • Fichier de certificat - Pour l'authentification TLS mutuelle (lorsque le serveur distant l'exige)
  • Fichier de clé privée - Associé au moyen du fichier de certificat

Cas d'utilisation courants de TLS

Passerelle Web (HTTPS) : configuration des certificats TLS dans Apache/NGINX s'exécutant dans le conteneur de la passerelle Web. La passerelle Web gère le cryptage HTTPS pour tout le trafic HTTP vers les applications Web IRIS.

Superserveur (connexions à la base de données) - Cryptage des connexions à partir des applications clientes (Java, .NET, Python, ODBC/JDBC) :
1. Créez une configuration SSL/TLS du serveur dans Administration système > Sécurité > Configurations SSL/TLS (System Administration > Security > SSL/TLS Configurations)
2. Spécifiez les fichiers de certificat serveur et de clé privée
3. Attribuez la configuration à %Superserveur dans Administration système > Configuration > Connectivité > Paramètres Superserveur (System Administration > Configuration > Connectivity > SuperServer Settings)

Connexions miroir - Activez TLS pour la réplication haute disponibilité entre les instances IRIS principales et de sauvegarde à l'aide des configurations SSL du serveur.

Cryptage de base de données

IRIS prend en charge le cryptage transparent des bases de données pour les données au repos. Lorsqu'il est activé pour une base de données, toutes les données écrites sur le disque sont automatiquement cryptées sans nécessiter de modification du code de l'application.

Configuration du cryptage de base de données

À l'aide du cryptage de base de données, accédez à Administration système > Cryptage (System Administration > Encryption) dans le portail de gestion :

Étape 1 : Créer un nouveau fichier de clé de chiffrement

  1. Sélectionnez Créer un nouveau fichier de clé de chiffrement (Create New Encryption Key File)
  2. Saisissez un chemin d'accès au fichier de clé (par exemple, /durable/encryption.key)
  3. Choisissez le niveau de sécurité (généralement 256 bits)
  4. Définissez le nom d'utilisateur et le mot de passe de l'administrateur
  5. Cliquez sur Enregistrer (Save)

Étape 2 : Activer la clé de cryptage

  1. Sélectionnez Cryptage de la base de données (Database Encryption)
  2. Cliquez sur Activer la clé (Activate Key)
  3. Saisissez le chemin d'accès au fichier de clé, le nom d'administrateur et le mot de passe que vous avez créés à l'étape 1
  4. Cliquez sur Activer (Activate)

Étape 3 : Configurer les paramètres de démarrage (facultatif)

  1. Dans Cryptage de la base de données (Database Encryption), cliquez sur Configurer les paramètres de démarrage (Configure Startup Settings)
  2. Définissez Activation de la clé au démarrage sur Interactif (recommandé pour des raisons de sécurité)
  3. Vous pouvez également activer le cryptage pour certaines bases de données et journaux système
  4. Cliquez sur Enregistrer (Save)

Étape 4 : Créez de nouvelles bases de données cryptées

Lorsque vous créez une nouvelle base de données via Administration système > Configuration > Configuration système > Bases de données locales (System Administration > Configuration > System Configuration > Local Databases), définissez le paramètre Crypter la base de données (Encrypt database) sur Oui (Yes).

Cryptage d'une base de données existante

Pour crypter une base de données qui contient déjà des données, utilisez l'utilitaire ^EncryptionKey à l'aide duquel vous pouvez crypter la base de données :

Important : sauvegardez d'abord votre base de données ! Le processus de cryptage modifie les données sur place, et toute interruption peut rendre la base de données inutilisable.

# Accés au terminal IRIS dans l'espace de noms %SYS
$ docker exec -it iris iris session iris -U %SYS

# Exécution de l'utilitaire de cryptage
%SYS> do ^EncryptionKey

# Sélectiondes options suivantes :
# 3 - Cryptage de la base de données
# 7 - Modification du statut crypté de la base de données existante
# Sélection de la base de données à crypter dans la liste
# Sélection de la clé de cryptage
# Confirmation du cryptage

# L'utilitaire crypte la base de données sur place
# Ce processus peut prendre un certain temps selon la taille de la base de données

Étapes à suivre dans l'utilitaire :

  1. Exécutez do ^EncryptionKey dans l'espace de noms %SYS
  2. Sélectionnez l'option 3 (Chiffrement de la base de données)
  3. Sélectionnez l'option 7 ( Modification de l'état de cryptage de la base de données existante)
  4. Choisissez la base de données dans la liste des bases de données disponibles
  5. Confirmez l'opération
  6. Attendez que le processus de chiffrement soit terminé

Avertissements importants :
- Effectuez toujours une sauvegarde préalable de la base de données - Des pertes de données se sont produites lorsque le processus a été interrompu
- Assurez-vous de disposer d'un espace disque suffisant - Le cryptage utilise l'espace disque à l'aide de ses opérations
- La base de données sera indisponible pendant le cryptage
- Le processus ne peut pas être interrompu - Un cryptage partiel rend la base de données inutilisable

Utilisation du portail de gestion

Le portail de gestion fournit une gestion centralisée de la sécurité. Vous pouvez y accéder via Administration système > Sécurité (System Administration > Security) :

Utilisateurs: créez et gérez des comptes utilisateurs, définissez des mots de passe, activez/désactivez des comptes et attribuez des rôles. Chaque utilisateur peut être configuré au moyen de différents types d'authentification (mot de passe, délégué, LDAP, Kerberos).

Rôles : définissez des rôles d'utilisateur et attribuez des privilèges de ressources. Créez des rôles tels que "AppDeveloper" ou "DataAnalyst" dotés d'autorisations spécifiques, puis attribuez ces rôles à plusieurs utilisateurs.

Ressources - Affichez et créez des ressources qui protègent les bases de données, les services et les fonctions système. Les ressources système utilisent des préfixes tels que %DB_*, %Service_* et %Admin_*.

Applications > Applications Web - Configurez l'authentification et l'autorisation pour les services REST, les applications CSP et les services Web SOAP. Chaque application a un chemin d'accès URL, une méthode d'authentification et une ressource associée pour le contrôle d'accès.

Configurations SSL/TLS - Gérez les certificats TLS et créez des configurations de chiffrement pour différents composants IRIS (passerelle Web, superserveur, connexions miroir, connexions client).

Audit - Activez la journalisation des événements de sécurité pour suivre les tentatives de connexion, les modifications d'autorisation et l'accès aux données sensibles. Configurez les événements à enregistrer et définissez des politiques de rétention.

Audit et surveillance de la sécurité

L'audit de sécurité dans InterSystems IRIS permet de détecter les tentatives d'accès non autorisées, de suivre les événements liés à la sécurité et de maintenir la conformité avec les politiques de sécurité. Le système d'audit enregistre les événements dans la base de données d'audit pour une analyse ultérieure.

Activation de l'audit

L'audit est activé par défaut dans InterSystems IRIS. Pour configurer les événements d'audit dans le portail de gestion :

  1. Accédez à Administration du système > Sécurité > Audit > Configurer les événements système (System Administration > Security > Auditing > Configure System Events)
  2. Passez en revue les événements d'audit disponibles - de nombreux événements sont activés par défaut
  3. Des événements supplémentaires peuvent être activés dans Configurer les événements système selon les besoins (par exemple, Logout, RoutineChange, SuspendResume)
  4. Cliquez sur Enregistrer

image

Remarques importantes :
- La base de données d'audit est stockée dans une base de données dédiée appelée IRISAUDIT
- Les événements d'audit peuvent être consultés via Administration système > Sécurité > Audit > Afficher la base de données d'audit (System Administration > Security > Auditing > View Audit Database)
- Les événements activés par défaut varient en fonction du niveau de sécurité de l'installation (minimal, normal ou verrouillé).

Affichage des événements d'audit

Les événements d'audit tels que les échecs de connexion peuvent être consultés dans Administration du système > Sécurité > Audit > Afficher la base de données d'audit (System Administration > Security > Auditing > View Audit Database) :

image

Conclusion

InterSystems IRIS fournit une sécurité de niveau entreprise grâce à l'authentification, au contrôle d'accès basé sur les rôles, au chiffrement et à l'audit. La clé d'une sécurité efficace réside dans la compréhension du fonctionnement conjoint des ressources, des privilèges et des rôles pour protéger vos données et contrôler l'accès.

Points clés à retenir :

  1. Modifiez immédiatement les mots de passe par défaut - Le mot de passe par défaut « SYS » constitue une vulnérabilité critique. Après avoir déployé les conteneurs IRIS, modifiez immédiatement tous les mots de passe par défaut via le portail de gestion.

  2. Mettez en place un contrôle d'accès basé sur les rôles - Définissez les ressources pour vos bases de données et vos services, créez des rôles dotés des privilèges appropriés et attribuez des rôles aux utilisateurs. N'accordez jamais d'autorisations directement aux utilisateurs.

  3. Activez l'audit des événements de sécurité - Surveillez les événements LoginFailure afin de détecter les tentatives d'accès non autorisées. Consultez régulièrement les journaux d'audit et configurez des alertes automatiques pour les activités suspectes.

  4. Sécurisez toutes les communications du réseau - Configurez TLS/SSL pour les applications web (via Web Gateway), les connexions à la base de données (superserveur) et les appels API externes. Ne transmettez jamais d'identifiants ou de données sensibles via des connexions non cryptées.

  5. Suivez le principe du moindre privilège - N'accordez aux utilisateurs que les autorisations minimales nécessaires à l'accomplissement de leurs tâches. Vérifiez et auditez régulièrement les attributions de rôles.

Lors du déploiement d'IRIS en production, en particulier dans des conteneurs, la configuration de la sécurité doit faire partie de votre approche Infrastructure-as-Code. Utilisez des fichiers de fusion de configuration pour appliquer automatiquement les paramètres de sécurité, conservez des configurations CSP.ini distinctes pour Web Gateway et mettez en place une surveillance des tentatives de connexion échouées et autres événements de sécurité.

En mettant en œuvre ces pratiques de sécurité dès le début, vous pouvez créer des applications IRIS qui protègent les données de votre organisation tout en respectant les politiques et réglementations de sécurité.

Consultez l'article de la documentation InterSystems lié
Discussion (0)1
Connectez-vous ou inscrivez-vous pour continuer