PROGETTO PER LINGUAGGI DI PROGRAMMAZIONE

			    A.A. 2001-2002


Si chiede di programmare in ML ed in Prolog un SECURITY MONITOR, cioe`
un modulo che riceve l'ID di  un utente, una operazione, ed un oggetto
su cui l'utente chiede  di eseguire l'operazione, e restituisce 'true'
o 'false' a seconda che l'operazione richiesta sia permessa oppure no.
Un esempio di input e` la tripla

	       (bonatti,download,"Journal of the ACM").

Queste triple vengono dette AUTORIZZAZIONI.


La scelta viene presa sulla base di due componenti:

 - una POLITICA, espressa con una sintassi descritta piu` avanti.  Si
   tratta di un insieme di REGOLE che determinano i permessi.  Le
   regole possono dipendere da proprieta` degli utenti.  Ad esempio,
   la richiesta (bonatti,download,"Journal of the ACM") puo` essere
   ammessa se l'utente bonatti e` abbonato al Journal of the ACM, e
   questo fatto puo` essere registrato come una proprieta` dell'utente
   bonatti.

 - Tali proprieta' sono memorizzate in uno STATO che associa ad ogni
   utente un insieme di proprieta' (col rispettivo valore) detto
   PROFILO.  Ad esempio, per l'utente bonatti, potremmo avere
   nel suo profilo la coppia

		   (abbonato,"Journal of the ACM"),

   dove il primo elemento e` il nome della proprieta` ed il secondo e`
   il suo valore.  Se il nome di una proprieta` non compare nel
   profilo diciamo che la proprieta` e` INDEFINITA.  Assumiamo che ci
   possano essere piu` coppie con lo stesso nome (nell'esempio che
   stiamo considerando sarebbe utile per esprimere il fatto che una
   persona e` abbonata a piu` riviste).

Le regole hanno la forma

	     auth( Utente, Operaz, Oggetto, Condizione )

dove (Utente, Operaz, Oggetto) formano l'autorizzazione, e la
condizione stabilisce quando l'autorizzazione e` concessa.  La stessa
tripla (Utente, Operaz, Oggetto) puo` comparire in piu` regole; in
questo caso l'autorizzazione e` concessa se ALMENO UNA delle
condizioni associate alle regole e` soddisfatta (vera).

Le condizioni sono composte da uguaglianze Prop == Valore e dagli
operatori and, or, not.  Ad esempio:

  abbonato == "JACM" or ( staff_member == yes and ruolo == docente).

Il valore di una condizione prop==val rispetto allo stato corrente
puo' essere:

  - vero (t), se la coppia (prop,val) e` nel profilo dell'utente

  - falso (f), se esistono coppie (prop,x) nel profilo utente, ma
    nessuna di queste x e` uguale a val

  - indefinito (u, come undefined), se non esistono coppie con prop
    come primo elemento nel profilo utente.

Inoltre and, or e not hanno le seguenti tabelle di verita'

		    and|t f u|   or|t f u|  not|
		    ---+-----+   --+-----+  ---+-
		      t|t f u|    t|t t t|    t|f
		      f|f f f|    f|t f u|    f|t
		      u|u f u|    u|t u u|    u|u
		    ---+-----+   --+-----+  ---+-

In una regola auth( Utente, Operaz, Oggetto, Condizione ), i campi
Utente, Operaz e Oggetto possono essere variabili logiche, che
compaiono anche nella Condizione.  Ad esempio potremmo avere una
regola

		 auth( X, download, Y, abbonato==Y )

per esprimere che chiunque (variabile libera X) puo` fare download su
un periodico Y se e` abbonato a quel periodico.

In Prolog le variabili logiche sono supportate direttamente dal
linguaggio, quindi il progetto risulterebbe poco corposo.  Quindi
nella versione Prolog si richede di supportare condizioni piu`
complesse, dove ci possono essere condizioni elementari X << classe,
dette condizioni di APPARTENENZA, dove X puo` essere 'user' oppure
'object'.  Le condizioni di appartenenza possono essere combinate con
altre condizioni di appartenenza e con uguaglianze attraverso and, or
e not.

Le condizioni di appartenenza presuppongono due ulteriori elementi
(oltre alla politica e allo stato): una GERARCHIA di utenti ed una di
oggetti.  Ad esempio

	      users				objects
	     /	    \				/     \
	  docenti   studenti		  riviste      libri
	  / | ..\   /...   \		  /      \      / ....
     bonatti       bianchi  zurletti    Wired .. JACM  "Art of Prolog"

Si intende che X << classe e` vera (t) se:

 - X=user e l'utente nella tripla di input sta sotto 'classe'
   nella gerarchia degli utenti, oppure

 - X=object e l'oggetto nella tripla di input sta sotto 'classe' nella
   gerarchia degli oggetti

 - altrimenti X << classe e` falsa (f).