Protocols for Secure Communication in Wireless Sensor Networks

3.4. The Cost of End-to-End Security 87
standard [104] executed on a BTnode (source: [127]). As public exponent, the
value F4 (hex) has been used. The numbers are averaged over 5 measurements
performed for each key size. Gura et al. [74] report on the performance of an
optimized implementation of RSA and an Elliptic Curve Cryptography (ECC)
algorithm on the ATmega128 platform. For RSA, their implementation yields
a 3- to 5-fold improved performance compared to the (more naive) implementation
of [127]. However, the order of magnitude of these operations still prevents
excessive usage of RSA. The ECC algorithm yields an improvement of
one order of magnitude compared to RSA signature generation. This indicates
that ECC seems to have quite some potential for sensor networks; a library for
TinyOS is available [116].
For comparison, Table 2.2 shows figures for different cryptographic primitives,
namely AES encryption and hashing. These numbers show that there is
a vast difference between symmetric key cryptography and hashing, and public
key cryptography. They clearly indicate that symmetric mechanisms have
a significant advantage over public key cryptography from a performance perspective.
Another issue with RSA are the relatively large key lengths. At least the
public key and the accompanying certificate (a signature) have to be exchanged
for key agreement. For a key length of 1024 bit, this yields an additional overhead
of 256 bytes in either direction. Compared to the typically very small size
of data messages in a sensor network, this overhead is significant.
3.4.3 Pairwise Key Distribution
In a fully connected network of n nodes, each node maintains n − 1 connections.
With each connection, a data structure is associated that uses up some
space, say m bytes. Therefore, each node has to store m(n − 1) bytes of state
information. Given M bytes devoted to storing such kind of state information,
the supported network size is determined by n = M m + 1.
As an example, let’s assume that with each node, a 32-bit (4 bytes) identifier
(which may include a unique ID, location information, and possible other data)
and a 128-bit (16 byte) key is associated. Thus, a node has to store m = 20
bytes for each other node in the network. If a sensor node provides M = 100
kbyte for security purposes, this allows a network size of n = 5000 nodes.
Currently, microcontrollers used in sensor node prototypes provide up to
512 Kbyte non-volatile data memory (Flash EEPROM), e.g. the MICA product
line of Crossbow Technology Inc. Much of this space is used by code for
the operating system, network stacks, and applications. We can assume that