Máquina De la Marca De Datos De Fenton`s

Fenton creó una máquina abstracta llamada la máquina de la marca de datos para estudiar la dirección de flujos implícitos en el tiempo de ejecución. Cada uno variable en esta máquina tenía una clase asociada de la seguridad, o etiqueta. Fenton también incluyó una etiqueta para el contador de programa (PC).

La inclusión de la PC permitió que Fenton tratara flujos implícitos como flujos explícitos, porque los ramas son simplemente asignaciones a la PC. Él definió la semántica de la máquina de la marca de datos. En la discusión siguiente, el salto significa que la instrucción no está ejecutada, push(x, x) significa empujar el x variable y su clase de la seguridad x sobre el apilado del programa, y pop(x, x) los medios de hacer estallar el valor y la clase superiores de la seguridad del apilado del programa y de asignarlos a x y a x, respectivamente.

Fenton definió cinco instrucciones. Las relaciones entre la ejecución de las instrucciones y las clases de las variables están como sigue.

La instrucción del incremento

x: = x + 1

es equivalente a

si PC < = x entonces x: = x + 1; salto 
otro

La instrucción condicional
```
si x = 0 entonces n goto x otro: = x 1  
```
es equivalente a
```
si x = 0 entonces {push(PC, PC); PC = 
lub(PC, x); PC: = n; }  {si PC < = x entonces {x: = 
x 1; } salto otro}  
```
Esto ramifica, y empuja la PC y su clase de la seguridad sobre el apilado del programa. (como de costumbre, se incrementa la PC de modo que cuando se hace estallar, el siguiente de la instrucción si se ejecuta la declaración.) Esto captura la PC que contiene la información de x (específicamente, ese x es 0) mientras que sigue el goto.
La vuelta
```
vuelta  
```
es equivalente a
```
pop(PC, PC);  
```
Esto vuelve control a la declaración que sigue el último si declaración. Porque el flujo del control habría llegado esta declaración, la PC contiene no más de largo la información sobre x, y la vieja clase puede ser restaurada.
La instrucción de rama
```
si ' x = 0 entonces n goto x otro: = x 1  
```
es equivalente a
```
si x = 0 entonces {si x < = PC entonces {PC: = 
n; } salto otro}  {si PC < = x entonces {x: = x 1; 
} salto otro}  
```
Esto ramifica sin ahorrar la PC en el apilado. Si ocurre el rama, la PC está en una clase más alta de la seguridad que la variable condicional x, así que la adición de la información de x a la PC no cambia la clase de la seguridad de la PC.
La instrucción del alto
```
alto  
```
es equivalente a
```
si el apilado del programa vacío entonces para la
ejecución  
```
El apilado del programa que es vacío se asegura de que el usuario no puede obtener la información mirando el apilado del programa después de que el programa haya parado (por ejemplo, determinar cuál si la declaración fue tomada por último).

EJEMPLO: Considere el programa siguiente, en el cual x contiene inicialmente 0 o 1.

1. si x = 0 entonces 4 goto x otro: = x 1 2. 
si z = 0 entonces 6 goto z otro: = alto 3. 4 de z 1. 
z: = z + 1 5. vueltas 6. y: = y + 1 7. 
vueltas

Este programa copia el valor de x a el y. suponen ese x = 1 inicialmente. La tabla siguiente demuestra el contenido de la memoria, de la clase de la seguridad de la PC en cada paso, y del cheque correspondiente de la certificación.

x	y	z	PC	PC	apilado	cheque de la certificación
1	0	0	1	Bajo
0	0	0	2	Bajo		Bajo < = x
0	0	0	6	x	(3, bajo)
0	1	0	7	x	(3, bajo)	PC < = y
0	1	0	3	Bajo

La máquina de Fenton maneja errores no haciendo caso de ellos. Suponga eso, en el programa arriba, y < = x. Entonces en el quinto paso, el cheque de la certificación falla (porque PC = x). Así pues, la asignación se salta, y en el extremo y = 0 sin importar el valor de x. Pero si la máquina divulga errores, el mensaje de error que informa al usuario la falta del cheque de la certificación significa que el programa ha procurado ejecutar el paso 6. Podría hacer tan solamente si había tomado el rama en el paso 2, el significar ese z = 0. Si z = 0, entonces el rama otro de la declaración 1 no habría podido ser tomado, el significar ese x = 0 inicialmente.

Para prevenir este tipo de deducción, la máquina de Fenton continúa ejecutándose en la cara de errores, pero no hace caso de la declaración que causaría la violación. Esto satisface los requisitos. Abortar el programa, o crear una excepción visible al usuario, también haría la información fluir contra la política.

El problema con la divulgación de errores es que un usuario con una separación más baja que la información que causa el error puede deducir la información de saber que ha habido un error. Si el error se entra tal manera que las entradas en el registro, y la acción de la registración, sean visibles solamente a las que tengan separación adecuada, después ninguna violación de la política ocurre. Pero si la separación del usuario es suficientemente alta, después el usuario puede ver el error sin una violación de la política. Así, el error se puede registrar para el administrador de sistema (o el otro usuario apropiado), incluso si no puede ser exhibido al usuario que está funcionando el programa. Los comentarios similares se aplican a cualquier acción de la excepción, tal como terminación anormal.

esto es un artículo agregado por Fred Foster