Catégorisation de propriétés

Cette section présente des exemples de propriétés pour illustrer les trois catégories. D’autres exemples sont disponibles à l’annexe A.2.

3.5.2.1 Propriétés système

Les propriétés systèmes sont celles qui s’appliquent sur un seul nœud et n’impliquent pas de communication réseau. Considérons la propriété P1 suivante :

1 P1 := boolean Confidentiality_access_control (Type.Passive.Data.File SCFile,

Id.User SCUser) {

2 enforcement {

3 deny_all_read_accesses (SCFile);

4 allow_read_access (SCFile, SCUser);

5 }

6 assurance {

7 boolean c = true;

8 authorized_users = get_users(SCUser);

9 for (SCFileTmp IN get_files(SCFile) {

10 for (SCUserTmp IN get_all_users()) {

11 if (SCUserTmp IN authorized_users) {

12 c &= check_read (SCFileTmp, SCUserTmp);

13 }

14 else {

15 c &= (NOT check_read (SCFileTmp, SCUserTmp));

16 } 17 } 18 } 19 return c; 20 } 21 }

Listing 3.4 – Propriété de confidentialité d’un fichier (contrôle d’accès)

P1 permet de garantir la confidentialité d’un fichier en utilisant un mécanisme de contrôle d’accès. P1 est composée de deux blocs distincts, pour l’application (enforcement) et l’assurance. Le bloc d’application fait appel à deux capacités : la première permet d’em-pêcher les accès en lecture aux fichiers SCFile, tandis que la deuxième autorise ces accès s’ils sont effectués par un utilisateur SCUser. Comme nous l’avons vu précédemment, en fonction des mécanismes qui sont utilisés lors de l’application de la propriété et des ma-trices de compatibilité et de récessivité, le choix d’un mécanisme pour l’une des capacités peut influencer le choix du second mécanisme. Ceci est transparent pour l’administrateur de l’architecture logicielle : la décision est prise par le moteur de projection en fonction du système, des mécanismes disponibles et des différentes matrices (section 4.4, p. 75).

Le bloc d’assurance est, dans le cas de cette propriété, plus complexe. Pour tester l’application de la propriété, le bloc d’assurance itère sur les fichiers confidentiels et sur l’ensemble des utilisateurs du système. Pour chaque combinaison fichier/utilisateur, un test essaye de lire le fichier et vérifie si le résultat de l’accès correspond à celui attendu (i.e. accès autorisé si le contexte SCUser est inclus dans le contexte de l’utilisateur). L’application de la propriété étant dynamique et dépendant du système et des mécanismes disponibles, le bloc d’assurance permet de vérifier que la propriété a bien été appliquée.

P1 permet de s’abstraire des mécanismes de sécurité puisque chacune des capacités utilisées est indépendante des mécanismes. Par conséquent, selon les mécanismes présents sur le nœud, P1 pourra être appliquée en utilisant des mécanismes différents.

Une propriété peut être utilisée par d’autres propriétés afin de simplifier leur expression. Par exemple, considérons la propriété P2 qui garantit la confidentialité d’un fichier à l’aide de mécanismes de chiffrement. P2 fait appel à P1 afin de contrôler les accès à la clef de chiffrement.

1 P2 := boolean Confidentiality_encryption (Type.Passive.Data.File SCFile,

Id.User SCUser) {

2 enforcement {

3 Context SCKey;

4 SCKey = Type.Passive.Data.Key.Symmetric;

5 SCKey += generate_key (SCKey);

6 Confidentiality_access_control (SCKey, SCUser);

7 encrypt_file (SCFile, SCKey);

8 decrypt_on_access(SCFile, SCUser);

9 }

10 assurance {

11 boolean c = true;

12 authorized_users = get_users(SCUser);

13 for (SCFileTmp IN get_files(SCFile) {

14 for (SCUserTmp IN get_all_users()) {

15 if (SCUserTmp IN authorized_users) {

16 c &= check_encrypted (SCFileTmp, SCUserTmp);

17 }

18 else {

19 c &= (NOT check_encrypted (SCFileTmp, SCUserTmp));

20 } 21 } 22 } 23 return c; 24 } 25 }

Listing 3.5 – Propriété de confidentialité d’un fichier (chiffrement)

Le bloc d’application de P2 crée tout d’abord un contexte de clef symétrique SCKey. Une clef est générée et stockée dans ce contexte. L’accès à cette clef est contrôlé grâce à une propriété de contrôle d’accès. Le fichier confidentiel est alors chiffré en utilisant la clef générée. Finalement, le fichier est déchiffré dynamiquement lors d’un accès en lecture par un utilisateur autorisé. Le bloc d’assurance de P2 est similaire à celui de P1 : le test itère sur les fichiers et les utilisateurs, et vérifie si le fichier lu est, ou non, déchiffré à la lecture par un utilisateur légitime.

P1et P2 explicitent comment elles doivent être appliquées, c’est-à-dire en utilisant des mécanismes de contrôle d’accès ou de chiffrement. Le responsable de la définition de la politique doit donc choisir par quel moyen la propriété sera appliquée, même s’il ne spécifie pas les mécanismes exacts. Cela va à l’encontre du principe de notre langage qui est de définir une politique uniquement basée sur les besoins de sécurité. Les définitions de P1 et P2, deux propriétés spécialisées, peuvent donc être utilisées afin de définir une classe de propriété, plus générale, comme cela est détaillé ultérieurement. Il est ainsi possible de s’abstraire du moyen utilisé pour appliquer les besoins de sécurité.

3.5.2.2 Propriétés réseau

Les propriétés de la section précédente s’appliquent à des ressources systèmes. On dé-finit également des propriétés réseaux qui sont appliquées sur les échanges entre plusieurs nœuds, c’est-à-dire des propriétés qui sécurisent les communications et qui sont appliquées sur l’ensemble des nœuds impliqués. Une telle application pose le problème de la

synchro-3.5. PROPRIÉTÉS

nisation des deux applications de la propriété. Ce problème doit donc être adressé par le langage, ce qui est fait en utilisant des capacités internes. On définit ainsi une propriété P3 pour garantir la confidentialité des communications réseau entre un client et un serveur, c’est-à-dire la confidentialité des échanges entre deux adresses IP.

1 P3 := boolean Confidentiality (Net.IP SC1, Net.IP SC2) {

2 enforcement {

3 Type.Passive.Data.Key SCKey;

4 if (SC1.Net.IP == get_local_ip()) {

5 SCKey += generate_key (Type.Passive.Data.Key.[Symmetric|Asymmetric]);

6 publish(SCKey, SC2);

7 Plugin plug = consistent_plugin (SC1, SC2, encrypt_flow, SC1, SC2, SCKey);

8 plug->encrypt_flow (SC1, SC2, SCKey);

9 }

10 else {

11 get_published(SC1, SCKey);

12 Plugin plug = consistent_plugin (SC1, SC2, encrypt_flow, SC1, SC2, SCKey);

13 plug->encrypt_flow (SC1, SC2, SCKey);

14 } 15 } 16 assurance { 17 return check_encrypted_flow (SC1, SC2); 18 } 19 }

Listing 3.6 – Propriété de confidentialité réseau

La propriété P3 étant une propriété réseau, elle est appliquée sur les deux nœuds SC1 et SC2. Cependant, l’application n’est pas identique sur les deux machines. Pour cette raison, le bloc d’application de P3 est séparé en deux parties, l’une dédiée au nœud client, l’autre au nœud serveur.

Le nœud serveur est celui identifié par le premier argument SC1. Par conséquent, la première partie de la propriété (lignes 4 à 9) concerne le serveur. Une clef de chiffrement est tout d’abord générée et est publiée afin que le client y ait accès : il peut s’agir d’une clef symétrique ou asymétrique, ce qui peut influencer le choix de la capacité de chiffrement. Un mécanisme commun aux deux nœuds est alors choisi en utilisant une capacité interne. Le mécanisme sélectionné est ensuite utilisé pour chiffrer les flux réseau entre les nœuds.

La partie cliente de la propriété (lignes 10 à 14) récupère la clef de chiffrement qui a été publiée : cette partie nécessite des mécanismes de synchronisation, fournis par les capacités internes utilisées. Un mécanisme compatible est alors utilisé pour configurer le chiffrement des flux réseaux sur la partie cliente.

Finalement, le bloc d’assurance (lignes 16 à 18) utilise une capacité permettant de vérifier que les communications réseaux entre les deux adresses IP sont bien chiffrées.

Les propriétés peuvent donc être utilisées pour répondre à des besoins de sécurité impliquant plusieurs nœuds.

3.5.2.3 Propriétés hybrides

Comme nous l’avons vu précédemment, les propriétés systèmes et réseaux s’appliquent respectivement à un système donné ou à des communications entre plusieurs systèmes. Cependant, il est utile de pouvoir définir des propriétés s’appliquant à la fois sur des res-sources systèmes et sur des échanges réseaux. En effet, cela permet alors de définir des propriétés de bout-en-bout qui sécurisent les aspects réseaux et systèmes des applications ou services. Nous définissons donc des propriétés hybrides, plus complexes mais protégeant

des cas d’usage plus généraux. Ainsi, la propriété P4 est une propriété hybride de confi-dentialité. Elle utilise les propriétés P1 et P3 pour assurer la confidentialité d’un fichier sur un nœud vis-à-vis d’un utilisateur sur un nœud distant.

1 P4 := boolean Confidentiality (Type.Passive.Data.File SCFile, Net.IP:Net.Port

SC1, Net.IP:Net.Port SC2, Id.User SCUser) {

2 enforcement && assurance {

3 if (SC1.Net.IP == get_local_IP()) {

4 Confidentiality_Access_Control (SCFile:SC1, SCUser:SC1);

5 Confidentiality (SC1, SC2);

6 }

7 else {

8 Confidentiality (SC1, SC2);

9 Confidentiality_Access_Control (SCFile:SC2, SCUser:SC2);

10 }

11 }

12 }

Listing 3.7 – Propriété de confidentialité hybride

P4 attend quatre arguments : SCFile identifie le fichier à protéger. SC1 spécifie le nœud sur lequel est situé le fichier ainsi que le port permettant d’accéder au fichier. SC2 indique le nœud sur lequel est connecté l’utilisateur, et le port par lequel il tente d’accéder au fichier. Finalement, SCUser identifie les utilisateurs autorisés à lire le fichier confidentiel. P4 utilise ensuite des propriétés de confidentialité système et réseau pour sécuriser les différentes parties de cette interaction complexe. La première propriété (appliquée sur le nœud serveur, ligne 4) garantit que le fichier, lorsqu’il est situé sur le serveur, ne peut être lu que par un utilisateur connecté sur cette même machine et ayant un contexte compatible avec SCUser. L’utilisation de la notation :SC1 permet de prendre en compte le port, et donc de sécuriser le lien entre le fichier et le port, si les mécanismes disponibles le permettent. La deuxième propriété (appliquée sur les deux nœuds, lignes 5 et 8) rend confidentielles les communications réseaux entre les machines. Enfin, la dernière propriété (sur le nœud client, ligne 9) vérifie que, lorsqu’une version du fichier est disponible sur la machine cliente, elle ne peut être lue que par un utilisateur autorisé.

Ainsi, en combinant plusieurs propriétés, il est possible de définir des propriétés de sécurité avancées. Il devient alors plus simple de protéger un scénario complet en utilisant ces propriétés hybrides.