parasol_cpu 0.10.0

This crate contains the Parasol CPU, which runs programs over a mix of encrypted and plaintext data.
Documentation 
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use std::sync::Arc;

use crate::{
    ArgsBuilder, Error, IsaOp, Memory, RunProgramOptionsBuilder,
    register_names::{RP, SP, T0, T1, T2, T3},
    test_utils::make_computer_128,
};
use parasol_runtime::{fluent::UInt32, test_utils::get_secret_keys_128};

#[test]
fn fault_while_instruction_in_flight() {
    let (mut proc, enc) = make_computer_128();
    let sk = get_secret_keys_128();

    let memory = Memory::new_default_stack();
    let program = memory.allocate_program(&[
        IsaOp::Load(T0, SP, 32, 0),
        IsaOp::Load(T1, SP, 32, 4),
        IsaOp::Add(T2, T0, T1),   // Kick this add off so it's in-flight.
        IsaOp::Trunc(T0, T0, 16), // Truncate T0 to 16-bit because...
        IsaOp::Add(T0, T0, T1),   // ...adding a 16 and 32-bit value is illegal.
        IsaOp::Store(RP, T2, 32, 0),
        IsaOp::Ret(),
    ]);

    let args = ArgsBuilder::new()
        .arg(UInt32::encrypt_secret(42, &enc, &sk))
        .arg(UInt32::encrypt_secret(25, &enc, &sk))
        .return_value::<UInt32>();

    let result = proc.run_program(program, &Arc::new(memory), args);

    assert!(result.is_err());
}

#[test]
fn fault_while_two_instructions_in_flight() {
    let (mut proc, enc) = make_computer_128();
    let sk = get_secret_keys_128();

    let memory = Memory::new_default_stack();
    let program = memory.allocate_program(&[
        IsaOp::Load(T0, SP, 32, 0),
        IsaOp::Load(T1, SP, 32, 4),
        IsaOp::Add(T2, T0, T1),   // Kick this add off so it's in-flight.
        IsaOp::Add(T2, T0, T1),   // Kick this add off so it's in-flight.
        IsaOp::Trunc(T0, T0, 16), // Truncate T0 to 16-bit because...
        IsaOp::Add(T0, T0, T1),   // ...adding a 16 and 32-bit value is illegal.
        IsaOp::Store(RP, T2, 32, 0),
        IsaOp::Ret(),
    ]);

    let args = ArgsBuilder::new()
        .arg(UInt32::encrypt_secret(42, &enc, &sk))
        .arg(UInt32::encrypt_secret(25, &enc, &sk))
        .return_value::<UInt32>();

    let result = proc.run_program(program, &Arc::new(memory), args);

    assert!(result.is_err());
}

#[test]
fn async_faulting_instruction() {
    let (mut proc, enc) = make_computer_128();
    let sk = get_secret_keys_128();

    let memory = Memory::new_default_stack();
    let program = memory.allocate_program(&[
        IsaOp::Load(T0, SP, 32, 0),
        IsaOp::Load(T1, SP, 32, 4),
        IsaOp::Add(T2, T0, T1),   // Kick this add off so it's in-flight.
        IsaOp::Trunc(T0, T0, 16), // Truncate T0 to 16-bit because...
        // ...adding a 16 and 32-bit value is illegal. This instruction is async due to T2 dependency.
        IsaOp::Add(T3, T0, T2),
        IsaOp::Store(RP, T2, 32, 0),
        IsaOp::Ret(),
    ]);

    let args = ArgsBuilder::new()
        .arg(UInt32::encrypt_secret(42, &enc, &sk))
        .arg(UInt32::encrypt_secret(25, &enc, &sk))
        .return_value::<UInt32>();

    let result = proc.run_program(program, &Arc::new(memory), args);

    assert!(result.is_err());
}

#[test]
fn async_and_sync_faulting_instruction() {
    let (mut proc, enc) = make_computer_128();
    let sk = get_secret_keys_128();

    let memory = Memory::new_default_stack();
    let program = memory.allocate_program(&[
        IsaOp::Load(T0, SP, 32, 0),
        IsaOp::Load(T1, SP, 32, 4),
        IsaOp::Add(T2, T0, T1),   // Kick this add off so it's in-flight.
        IsaOp::Trunc(T0, T0, 16), // Truncate T0 to 16-bit because...
        // ...adding a 16 and 32-bit value is illegal. Instruction is async due to T2.
        IsaOp::Add(T3, T0, T2),
        // ...adding a 16 and 32-bit value is illegal. Instruction's deps are ready.
        IsaOp::Add(T3, T0, T1),
        IsaOp::Store(RP, T2, 32, 0),
        IsaOp::Ret(),
    ]);

    let args = ArgsBuilder::new()
        .arg(UInt32::encrypt_secret(42, &enc, &sk))
        .arg(UInt32::encrypt_secret(25, &enc, &sk))
        .return_value::<UInt32>();

    let result = proc.run_program(program, &Arc::new(memory), args);

    assert!(result.is_err());
}

#[test]
fn out_of_gas_execution() {
    let (mut proc, enc) = make_computer_128();
    let sk = get_secret_keys_128();

    let memory = Memory::new_default_stack();
    let program = memory.allocate_program(&[
        IsaOp::Load(T0, SP, 32, 0),
        IsaOp::Load(T1, SP, 32, 4),
        IsaOp::Add(T2, T0, T1),
        IsaOp::Load(T3, SP, 32, 8),
        IsaOp::Add(T2, T2, T3),
        IsaOp::Store(RP, T2, 32, 0),
        IsaOp::Ret(),
    ]);

    let args = ArgsBuilder::new()
        .arg(UInt32::encrypt_secret(42, &enc, &sk))
        .arg(UInt32::encrypt_secret(25, &enc, &sk))
        .arg(UInt32::encrypt_secret(37, &enc, &sk))
        .return_value::<UInt32>();

    let result = proc.run_program_with_options(
        program,
        &Arc::new(memory),
        args,
        &RunProgramOptionsBuilder::new()
            .gas_limit(Some(110_000)) // This gas covers any instruction above but not total
            .build(),
    );

    assert!(matches!(result, Err(Error::OutOfGas(..))));
}