aboutsummaryrefslogtreecommitdiff
path: root/README.md
blob: 84f1dd71184b3801bd6020ae01ebb3a078246c71 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
# Cloud Storage Assurance Architecture (CSAA) Proof-of-Concept

## Introduction

CSAA is a system first described in [Mohanty et
al.](https://fwei.tk/csass.pdf). It is designed to allow the secure
storage of data with an untrusted service provider, bootstrapping
trust from a "trusted module."

This program is an implementation of CSAA, adapted for use with
storing Docker containers. It should be considered research-quality
code, and does not (and can not!) provide any guarantees to the
trustworthiness of the trusted module, since it executes on a
general-purpose computer, in the same monolithic executable as the
untrusted service.

## Usage

### Prerequisites

You need the following packages for compiling and testing this
program: SQLite3, OpenSSL, GCC, G++, Make, and the `bc` calculator.

On Debian, type:

```
sudo apt-get install libsqlite3-dev libssl-dev sqlite3 make gcc g++ bc
```

Also, graphs require Gnuplot:

```
sudo apt-get install gnuplot
```

### Compiling

```
make
```

This will produce three executables: `client`, `server`, and `postprocess`.

`client` and `server` implement the CSAA architecture; `postprocess`
is for processing timing data and generating graphs -- you should not
use it directly.

### Generating Timing Graphs

#### Prepopulating Databases

Edit `service_provider.c` and `dummy_service.c` to uncomment the
`PREPOPULATE` macro in each one. Also, disable error checking in
main.c (perror() block).

Edit the `prepopulate2.sh` and `prepopulate_dummy.sh` scripts to have
the desired logleaves range (default is 10-12).

Then recompile and run:

```
./prepopulate2.sh
./prepopulate_dummy.sh
```

This should populate the `databases` directory with prepopulated
databases and module states. This step only needs to be done once; the
generated databases can be re-used as needed.

#### Running Tests

Run `testmain_preinit.sh` with the desired logleaves range and number
of trials as its command-line arguments. For example, the following
will run logleaves 10-25 with 5 trials for each logleaves value:

```
./testmain_preinit.sh 10 25 5
```

This script will produce results in the `results` directory.

#### Producing Graphs

Run:

```
cd results
../tabulate.sh 10 25 5
```

Your working directory must be in the `results` directory for the
second command to work. The arguments to `tabulate.sh` must be exactly
the same as those passed to `testmain_preinit.sh`.

This step will produce many files with the prefix `final_` in the
`results` directory. These are the final data.

To use Gnuplot to produce graphs from these, change to the project
root directory and run:

```
./genlabels.sh
./graph.gnu
```

This will generate graphs with the prefix `graph_`.