Translate une fonction PL/SQL permettant de contrôler l'accés des donnés
au niveau des lignes.
Chapitre 1 : La problématique de la sûreté : contexte
Définition personnelle : les problèmes
de sécurité et de sûreté sont intimement liés.
Toutes fois ce sont des problèmes qui ont des solutions très
différentes.
La sécurité consiste à
garantir un accès aux données, qu’elle ne soient pas détruites,
et qu’en cas de destruction on puisse les restaurer. On parle ici de sauvegarde
et de haute disponibilité.
La sûreté consiste à garantir
que seuls les utilisateurs habilités aient accès aux donnés.
On parle ici d’authentification, de firewall, de mot de passe …
La gestion de la sûreté commence bien
sur par utiliser les moyens existants. Ce chapitre est plein d’évidence
mais l’utilisation de ces mécanisme permet de résoudre la
plupart des cas simples.
1 Coté Architecture technique
-
Identification par mot de passe dont on force la mise
à jour régulière. Cette mise à jour force les
utilisateurs qui partagent le même mot de passe à se déclarer
-
Authentification par procédé de type carte
à puce pour les accès externes (ces cartes à puces
délivrent un mot de passe généré selon un algorithme
connu du serveur d’authentification, dont la validité ne dépasse
pas la minute).
-
Utilisation d’un mode sécurisé de transfert
de donné (SQL ANO, SSL …)
-
Protection du site par firewall, et zone démilitarisé
pour les accès distants
-
Protection physique de la console du serveur en ne laissant
pas traîner les clés
-
Connaissance approfondie de tous les moyens d’accès
au système : modems, rnis, ftp, cft, ainsi que les points d’accès
aux serveurs : NFS, rsh, rpc, samba.. Ces points d’accès sont un
mal nécessaire à toute exploitation, mais ils doivent être
tous connus, et sécurisé au maximum
2 Coté Serveur Unix
-
Changement régulier également du mot de
passe root
-
Protection des fichiers du serveurs par groupes unix
et ACL si nécessaire. Il faut mieux déclarer qu’un utilisateur
peut accéder à un répertoire en lecture seule via
un ACL que de déclarer ce répertoire partagé en lecture/écriture
pour le monde.
-
Utilisation stricte des shells. Utilisation des shells
restricted (Rsh),
3 Coté Oracle
-
Non utilisation des droits publics
-
Utilisation de rôle avec mot de passe pour l’accès
au table, ce qui garantie qu’un utilisateur ne peut se connecter avec la
base avec son mot de passe en utilisant SQL*Plus.
-
Déclaration minimale des droits strictement nécessaire
au travail de l’application.
-
Contrôle applicatif de l’accès aux menus,
aux transactions critiques.
4 Le besoin de contrôle fin d’accès
aux donnés
Toutefois, le contrôle d’accès aux donnés
via les rôles oracles ne sont pas toujours suffisant. Il est facile
d’empêcher qu’un client n’est accès aux données comptables,
ou au fichier des fournisseurs, mais toutefois comment lui empêcher
d’avoir accès qu’a une vision étroite du stock. En effet,
l’intérêt de l’extranet est de donner au client la possibilité
de commander directement, de consulter sa commande, de consulter la disponibilités
des moyens qu’il a acheté. On ne veut pas non plus que ce même
client vienne consulter les commandes de ces petits copains, de se rendre
compte que tel article n’a pas été commandé depuis
fort longtemps. Si il voyait le stock global, il en viendrai à demander
des réductions.
La seule solution centralisé et simple à
gérer est de définir les droits d’accès différenciés
à chaque ligne de la table.
Chapitre 2 : Présentation
des possibilités du contrôle d’accès aux données
La seule solution centralisé et simple à
gérer est de définir les droits d’accès différenciés
à chaque ligne de la table.
La gestion des droits au niveau des tables est gérée
par il reste une vraie difficulté à les gérer au niveau
des lignes. Certes il existe Trusted Oracle qui fait ce travail mais :
Il n’est pas commercialisé en France pour
des problèmes légaux
Il n’est plus maintenu par Oracle
Il est toutefois possible de le faire en utilisant
une fonction puissante comme "translate" de gérer les droits de
lecture.
Les droits sont gérer selon une matrice à
deux dimensions : Rôle accordé et Niveau de sécurité
accordé.
Ansi on peut définir sur une ligne d’une table
les accès suivants :
| Rôle |
Exploitation |
Administration Technique |
Guichet Commercial |
| Niveau de sûreté
requis |
Utilisateur |
Administrateur |
Utilisateur |
Ces droits sont explicites, si un utilisateur n’a
pas un des rôles exigés, il ne verra pas cette ligne de cette
table (ni en écriture, ni même en lecture).
Par exemple on peut imaginer qu’une application à
besoin des rôles suivants :
Marketing
Vente directe,
Administration des ventes,
Guichet Commercial,
Production,
Hot line,
Rescousses Humaines,
Comptabilité,
Exploitation
D’autres part, on veut pouvoir donner un niveau de sûreté,
de niveau de diffusion.
Public
Client
Interne
Utilisateur
Expert
Administrateur
Super Utilisateur
Un utilisateur se voit attribuer un certain nombre de
rôle et de niveau de sûreté.
Par exemple :
| Rôle |
Marketing |
Ventes directes |
Guichet Commercial |
Production |
Administration des ventes |
Comptabilité |
Ressources Humaines |
| Niveau de sûreté
accordé |
Utilisateur |
Utilisateur |
Expert |
Utilisateur |
Administrateur |
Expert |
Interne |
Chapitre 3 : Translate; une fonction qui peut être utilisée comme opérateur
translate a les propriétés suivantes:
SQL> def x='abefg'
SQL> def y='fbcd'
filtre :
translate(´abc´,´ a´,´ ´) -> ´bc´
permet de retirer le groupe a d’une chaine
SQL> /
old 1: select translate('&&x',' a',' ') from dual
new 1: select translate('abefg',' a',' ') from dual
TRAN
----
befg
minus(x,y)
translate(x,´ ´||y,´ ´)
permet de retirer tous les éléments de l’ensemble y a x
SQL> select translate('&&x',' '||'&&y',' ') from dual;
old 1: select translate('&&x',' '||'&&y',' ') from dual
new 1: select translate('abefg',' '||'fbcd',' ') from dual
TRA
---
aeg
complément(x)
translate(alphabet,’ ‘||x,’ ‘) permet d’extraire le complément de x=>
toutes les lettres de l’alphabet sauf celles contenu dans x.
SQL> def alphabet='abcdefghijklmnopqrstuvwxyz'
SQL> select translate('&&alphabet',' '||'&&x',' ') from dual;
old 1: select translate('&&alphabet',' '||'&&x',' ') from dual
new 1: select translate('abcdefghijklmnopqrstuvwxyz',' '||'abefg',' ') from dual
SQL> col complement_x new_value complement_x
1* select translate('&&alphabet',' '||'&&x',' ') complement_x from dual
SQL> /
old 1: select translate('&&alphabet',' '||'&&x',' ') complement_x from dual
new 1: select translate('abcdefghijklmnopqrstuvwxyz',' '||'abefg',' ') complement_x from dual
COMPLEMENT_X
---------------------
cdhijklmnopqrstuvwxyz
SQL> col complement_y new_value complement_y
SQL> select translate('&&alphabet',' '||'&&y',' ') complement_y from dual;
old 1: select translate('&&alphabet',' '||'&&y',' ') complement_y from dual
new 1: select translate('abcdefghijklmnopqrstuvwxyz',' '||'fbcd',' ') complement_y from dual
COMPLEMENT_Y
----------------------
aeghijklmnopqrstuvwxyz
intersection :
intersection(x,y)= translate(x,y||complément(y),y)
retourne les éléments communs à x et y qui doit pouvoir s’ecrire aussi
intersection(x,y)=translate(x,´ ´||complément(y),´ ´)
SQL> select translate('&&x',' '||'&&complement_y',' ') intersection from dual;
old 1: select translate('&&x',' '||'&&complement_y',' ') intersection from dual
new 1: select translate('abefg',' '||'aeghijklmnopqrstuvwxyz',' ') intersection from dual
IN
--
bf
tri
: Translate permet de remettre les éléments commun dans
le même ordre x et y contenant les mêmes données:
tri(y,x)=translate(x,y||complément(y),y)
- extraction d’un droit
- y est de la forme : ‘acd’
- droit est de la forme : ‘142’
- x est de la forme ‘dae’
translate(tri(x,y),y,droit) donne ‘12’
qui est comparable avec
translate(y,intersection(y,y),droit) qui donne ‘12’
Matching
1) détermination des droits de Y
SQL> select translate('&&intersection','&&y','&&droit_y') from dual;
old 1: select translate('&&intersection','&&y','&&droit_y') from dual
new 1: select translate('bf','fbcd','421') from dual
TR
--
24
SQL> col tri new_value tri
SQL> select translate('&&alphabet',' '||'&&intersection',' ') tri from dual;
old 1: select translate('&&alphabet',' '||'&&intersection',' ') tri from dual
new 1: select translate('abcdefghijklmnopqrstuvwxyz',' '||'bf',' ') tri from dual
TRI
------------------------
acdeghijklmnopqrstuvwxyz
SQL> col intersect_tri_y new_value intersect_tri_y
SQL> c/from/intersect_tri_y from/
1* select translate('&&y',' '||'&&tri',' ') intersect_tri_y from dual
SQL> /
old 1: select translate('&&y',' '||'&&tri',' ') intersect_tri_y from dual
new 1: select translate('fbcd',' '||'acdeghijklmnopqrstuvwxyz',' ') intersect_tri_y from dual
IN
--
fb
SQL> def droit_y='7654'
SQL> col granted_y new_value granted_y
SQL> select translate('&&intersect_tri_y',' '||'&&y',' '||'&&droit_y') granted_y from dual;
old 1: select translate('&&intersect_tri_y',' '||'&&y',' '||'&&droit_y') granted_y from dual
new 1: select translate('fb',' '||'fbcd',' '||'7654') granted_y from dual
GR
--
76
2) détermination des droits de x
SQL> col granted_x new_value granted_x
SQL> select translate('&&intersection',' '||'&&x',' '||'&&droit_x') granted_x from dual;
old 1: select translate('&&intersection',' '||'&&x',' '||'&&droit_x') granted_x from dual
new 1: select translate('bf',' '||'abefg',' '||'93400') granted_x from dual
GR
--
30
3) Résultat final
DEFINE _EDITOR = "/bin/vi" (CHAR)
DEFINE _O_VERSION = "Oracle7
Server Release 7.3.4.0.0 - Production
With the parallel query option
PL/SQL Release 2.3.4.0.0 - Production" (CHAR)
DEFINE _O_RELEASE = "703040000" (CHAR)
DEFINE X = "abefg" (CHAR)
DEFINE Y = "fbcd" (CHAR)
DEFINE _RC = "0" (CHAR)
DEFINE ALPHABET = "abcdefghijklmnopqrstuvwxyz" (CHAR)
DEFINE COMPLEMENT = "cdhijklmnopqrstuvwxyz" (CHAR)
DEFINE INTERSECTION = "bf" (CHAR)
DEFINE COMPLEMENT_Y = "aeghijklmnopqrstuvwxyz" (CHAR)
DEFINE COMPLEMENT_X = "cdhijklmnopqrstuvwxyz" (CHAR)
DEFINE DROIT_X = "93400" (CHAR)
DEFINE DROIT_Y = "7654" (CHAR)
DEFINE TRI = "acdeghijklmnopqrstuvwxyz" (CHAR)
DEFINE INTERSECT_TRI_Y = "fb" (CHAR)
DEFINE GRANTED_X = "30" (CHAR)
DEFINE GRANTED_Y = "76" (CHAR)
Chapitre 4 : L’étape suivante
Il est assez facile d’écrire une fonction
PL/SQL permettant de comparer les droits fournis, de baser une vue sur
l’utilisation de cette fonction et d’associer aux lettres et chiffres les
groupes d’utilisateurs et leurs niveau d’habilitation. Enfin il ne reste
plus qu’a développer les écrans Forms 5 basés sur
des vues. Un écran basé sur une vue sur une table fonctionne
parfaitement en Insert,Update et Delete.
Last Update : $Date: Apr 29 2001 23:48:34 $