Security - Telenor

1. Rendering data uninterpretable for all practical
purposes (which is what encryption does),
such that the usual transformation of data to
information through interpretation becomes
practically impossible.
2. Partitioning data into discrete units, and treating
the units as distinct objects in a secret
sharing scheme, or more generally: an access
control scheme.
3. Blocking the release of non-sensitive data A
that could reveal information about other, sensitive
data B due to known or deducible functional
dependencies between A and B. In practice
these are inference controls as those used
in statistical databases.
For platforms the techniques for implementing
these are well-known. The challenge is replicating
those mechanisms in mobile agents. It might
also be of interest to replicate them for embedded
agents.
EXAMPLE 4. An embedded agent might be contained
in a partially encrypted document, with
instructions to only reveal the encrypted parts to
pre-specified platforms. This is something with
typical application to Word documents or similar
document formats.
5.1 Agent Attacks
The agent attacks are fairly well studied. Some
ways of leaking confidential information are
1. attempting unauthorized accesses of other
agents’ code/data areas;
2. installing a payload on the host computer,
executable outside the platform as a “normal”
process (such as word macro viruses with
DOS virus payloads);
3. attempting to manipulate the platform in order
to gain access to confidential information
(attacking crypto-APIs, for example); or
4. using pure information theoretic attacks to
design queries used by agents to collect data
for subsequent tracker-type attacks (see [5])
on collected data, a technique which could
typically be employed in business (or other)
intelligence activities.
The first attack above is fairly effectively halted
by a virtual machine-based platform (as for Java
applets), provided the transformation from an
agent’s implementation language to the code
actually run on the platform is correct, and introduces
no new functionality. For agents somehow
running as native machine code, one needs hard-
Telektronikk 3.2000
ware support for controlling memory access
from the operating system and/or platform such
that agents cannot exploit host-specific architectural
information to mount attacks.
The second attack above is not necessarily
halted by a virtual machine-based platform,
although such a platform still forms a fairly
effective defense. The reason is that if the agent
is allowed to write to a file and can choose part
of or all of its name, it can still attempt the
installation of a Trojan horse.
The third attack represents the typical attack
implemented by a hostile Java applet, where
bugs in the implementation are exploited in
order to execute unauthorized actions. Defending
against this type of attack depends for the
most part on a correct implementation that actually
logically isolates the agent from manipulating
the platform in an unauthorized manner.
The fourth attack is hard to avert. Any investment
spent to defend against these attacks
depends on how information is made available
to the agent.
5.2 Platform Attacks
The complementary case, where the platform is
regarded as a potentially malicious entity resembles
to a great degree the problem outlined in a
paper by Anderson and Needham [1]. The host
has effectively complete control of all plaintext
data, including the agent platform, and any
agents executing on it, along with any of their
code and data stored at the host in question.
The host can under such circumstances achieve
effortless compromise of all information, save
that which somehow is encrypted in such a form
as to still be of use to the agent. This problem is
a difficult one to solve. It appears to be crucial
to enable mobile agents to:
1. use secrets in their data without revealing
them to the platform;
2. securely generate digital signatures; and
3. securely encrypt information extracted from
the host platform or decrypt encrypted information
meant for that platform.
Properties such as these are only possible if one
can encrypt the agent’s code without changing
its properties when viewed from the outside as
a process. In other words, the encrypted agent
must ideally be able to:
1. encrypt/decrypt selected inputs and/or outputs;
39