Performance

4 Performance

Program Combination (1) Combination (2)

% Overhead Standard Deviation % Overhead Standard Deviation

(% of mean) (% of mean)

tar -1 3 0 5

wu-ftpd 0 1 2 2

gv 0 6 2 7

bison 1 2 8 2

groff -1 1 13 1

gzip -1 2 14 3

gnuplot 0 1 21 1

Figure 5: Performance overhead introduced by address obfuscation.

We have collected performance data on the implementation of randomization of different memory regions. The following randomizations were implemented:

relocating the base of the stack, heap, and code regions
introduction of random gaps within stack frames, and at the end of memory blocks requested by malloc. The stack frame gaps were determined statically for each routine, while the malloc gaps can change with each malloc request.

We studied two different approaches for randomizing the start address of the executable:

Combination 1: static relocation performed at link-time.
Combination 2: dynamic relocation performed at load-time.

Both approaches incorporate all of the transformations mentioned above. Note that dynamic relocation requires the executable be compiled into position-independent code, which introduces additional runtime overheads.

Figure 5 shows the performance overheads due to the two combinations of transformations. All measurements were taken on an 800 MHz, Pentium III, 384 MB RAM machine with Red Hat 7.3 Linux OS. Average execution (system + user) time was computed over 10 runs. The overheads measured were rounded off to the nearest integral percentage. (Further precision was meaningless, given the standard deviations shown in the table.)

From the table, we see that combination (1) incurs essentially no runtime overhead (note that the negative overheads are below the standard deviation and are hence not statistically significant).

Combination (2) has noticeable runtime overhead. This is because it requires position-independent code, which is less efficient, since it performs extra operations before every procedure call, and every access to static data. On the other hand, when code is already being distributed in DLL form, combination (2) provides broad protection against memory error exploits without any additional overhead.

Program	Combination (1)		Combination (2)
	% Overhead	Standard Deviation	% Overhead	Standard Deviation
		(% of mean)		(% of mean)
`tar`	-1	3	0	5
`wu-ftpd`	0	1	2	2
`gv`	0	6	2	7
`bison`	1	2	8	2
`groff`	-1	1	13	1
`gzip`	-1	2	14	3
`gnuplot`	0	1	21	1