Macchina Del Contrassegno Di Dati Di Fenton`s

Fenton ha generato una macchina astratta denominata la macchina del contrassegno di dati per studiare la manipolazione dei flussi impliciti a tempo di esecuzione. Ciascuno variabile in questa macchina ha avuto un codice categoria collegato di sicurezza, o modifica. Fenton inoltre ha incluso una modifica per il contatore di programma (pc).

L'inclusione del pc ha permesso che Fenton trattasse i flussi impliciti come flussi espliciti, perché i rami sono soltanto assegnazioni al pc. Ha definito la semantica della macchina del contrassegno di dati. Nella seguente discussione, il salto significa che l'istruzione non è eseguita, push(x, x) significa spingere la x variabile ed il relativo codice categoria di sicurezza x sulla pila di programma e pop(x, x) mezzi per schioccare il valore ed il codice categoria superiori di sicurezza fuori della pila di programma ed assegnarli alla x ed alla x, rispettivamente.

Fenton ha definito cinque istruzioni. I rapporti fra l'esecuzione delle istruzioni ed i codici categoria delle variabili sono come segue.

L'istruzione di incremento

x: = x + 1

è equivalente a

se pc < = x allora x: = x + 1; salto 
altro

L'istruzione condizionale
```
se x = 0 allora n di avanzamento x altra: = 
x 1  
```
è equivalente a
```
se x = 0 allora {push(PC, pc); Pc = lub(PC, 
x); Pc: = n; } altrimenti {se pc < = x allora {x: = 
x 1; } salto altro}  
```
Ciò si ramifica e spinge il pc ed il relativo codice categoria di sicurezza sulla pila di programma. (come al solito, il pc incremented in modo che quando è schioccato, seguire di istruzione se la dichiarazione è eseguita.) Ciò blocca il pc che contiene le informazioni dalla x (specificamente, quella x è 0) mentre segue il di avanzamento.
Il ritorno
```
ritorno  
```
è equivalente a
```
pop(PC, pc);  
```
Ciò restituisce il controllo alla dichiarazione che segue l'ultimo se dichiarazione. Poiché il flusso di controllo sarebbe arrivato a questa dichiarazione, il pc più non contiene le informazioni sulla x ed il vecchio codice categoria può essere ristabilito.
L'istruzione di ramo
```
se 'x = 0 allora n di avanzamento x altra: = 
x 1  
```
è equivalente a
```
se x = 0 allora {se x < = pc allora {pc: = 
n; } salto altro} altrimenti {se pc < = x allora {x: = 
x 1; } salto altro}  
```
Ciò si ramifica senza conservare il pc sulla pila. Se il ramo accade, il pc è in un più alto codice categoria di sicurezza che la variabile condizionale x, in modo da aggiungere le informazioni dalla x al pc non cambia il codice categoria di sicurezza del pc.
L'istruzione di fermata
```
fermata  
```
è equivalente a
```
se la pila di programma vuota allora ferma 
l'esecuzione  
```
La pila di programma che è vuota si accerta che l'utente non possa ottenere le informazioni guardando la pila di programma dopo che il programma si sia fermato (per esempio, determinare quale se la dichiarazione fosse presa l'ultima volta).

ESEMPIO: Consideri il seguente programma, in cui la x inizialmente contiene 0 o 1.

1. se x = 0 allora 4 di avanzamento x altra: = 
x 1 2. se z = 0 allora 6 di avanzamento z altra: = 
fermata 3. 4 di z 1. z: = z + 1 5. ritorni 6. 
y: = y + 1 7. ritorni

Questo programma copia il valore della x - il y. suppongono il quel x = 1 inizialmente. La seguente tabella mostra il contenuto della memoria, del codice categoria di sicurezza del pc ad ogni punto e del controllo corrispondente di certificazione.

x	y	z	Pc	Pc	pila	controllo di certificazione
1	0	0	1	Basso
0	0	0	2	Basso		Basso < = x
0	0	0	6	x	(3, minimo)
0	1	0	7	x	(3, minimo)	Pc < = y
0	1	0	3	Basso

La macchina del Fenton maneggia gli errori ignorandoli. Supponga quello, nel programma qui sopra, y < = x. Allora al quinto punto, il controllo di certificazione viene a mancare (perché pc = x). Così, l'assegnazione è saltata ed all'estremità y = 0 senza riguardo al valore della x. Ma se la macchina segnala gli errori, il messaggio di errore che informa l'utente del guasto del controllo di certificazione significa che il programma ha tentato di eseguire punto 6. Potrebbe fare così soltanto se avesse preso il ramo a punto 2, significare quel z = 0. Se la z = 0, allora il ramo altro della dichiarazione 1 non potesse essere presa, significare quel x = 0 inizialmente.

Per impedire questo tipo di deduzione, la macchina del Fenton continua ad eseguire di fronte agli errori, ma ignora la dichiarazione che causerebbe la violazione. Ciò risponde alle esigenze. L'abbandono del programma, o generare un'eccezione visibile all'utente, inoltre indurrebbe le informazioni a fluire contro la politica.

Il problema con la segnalazione degli errori è che un utente con spazio più basso che le informazioni che causano l'errore può dedurre le informazioni dal sapere che ci è stato un errore. Se l'errore è entrato un tal senso che le entrate nel ceppo e l'azione di annotare, sono visibili soltanto a coloro che ha spazio sufficiente, quindi nessuna violazione della politica accade. Ma se la distanza dell'utente è sufficiente alta, quindi l'utente può vedere l'errore senza una violazione della politica. Quindi, l'errore può essere annotato per il coordinatore di sistema (o l'altro utente adatto), anche se non può essere visualizzato all'utente che sta facendo funzionare il programma. Le osservazioni simili si applicano a tutta l'azione di eccezione, quale il termine anormale.

ciò è un articolo aggiunto da Fred Foster