def generate_tape(self, size, ctx, secret_key):
indices = [] # Encrypt indices before feeding into VM
for x in range(size):
self.add_cell(Number.from_plaintext(0, ctx, secret_key))
indices.append(Number.from_plaintext(x, ctx, secret_key))
return indices
def setUp(self):
self.context = FakeContext()
self.sk = self.context.generate_keys()
self.one = Number.from_plaintext(1, self.context, self.sk)
self.two = Number.from_plaintext(2, self.context, self.sk)
self.three = Number.from_plaintext(3, self.context, self.sk)
self.zero = Number.from_plaintext(0, self.context, self.sk)
self.two_five_four = Number.from_plaintext(254, self.context, self.sk)
self.two_five_five = Number.from_plaintext(255, self.context, self.sk)
utils.zero = Number.from_plaintext(0, self.context, self.sk, size=1)
utils.one = Number.from_plaintext(1, self.context, self.sk, size=1)
def run():
ctx = nufhe.Context()
secret_key, cloud_key = ctx.make_key_pair()
vm = ctx.make_virtual_machine(cloud_key)
# Create tape
# Create VM
# Execute instruction
# Get output tape encrypted
# Decrypt tape to get execution results
tape = Tape()
# Create tape of size n
n = 2
indices = [] # Encrypt indices before feeding into VM
for x in range(n):
tape.add_cell(Number.from_plaintext(0, ctx, secret_key))
indices.append(Number.from_plaintext(x, ctx, secret_key))
utils.logic = vm
utils.flag = Number.from_plaintext(1, ctx, secret_key,
size=1) # Flag for conditions
utils.one = Number.from_plaintext(1, ctx, secret_key, size=1) # A one
utils.zero = Number.from_plaintext(0, ctx, secret_key, size=1) # A zero
utils.data_ptr = Number.from_plaintext(0, ctx,
secret_key) # Cell to perform op on
blind_machine = VirtualMachine(tape, indices)
# Add 1 instruction
"""for x in range(3):
inc_data_ptr = Number.from_plaintext(0, ctx, secret_key)
inc_data_cell = Number.from_plaintext(1, ctx, secret_key)
blind_machine.step(inc_data_ptr, inc_data_cell)
"""
#print(utils.one + utils.one)
A = 129
B = 5
sum = Number.from_plaintext(A, ctx, secret_key) + Number.from_plaintext(
B, ctx, secret_key)
print(sum.decrypt(ctx, secret_key))
print(A, "+", B, "=", sum.decrypt(ctx, secret_key, decimal=True))
def compile(code, instruction_set, ctx, secret_key):
instructions = []
for char in code:
if char in instruction_set:
instructions.append(instruction_set[char])
instruction_indices = []
for i, _ in enumerate(instructions):
instruction_indices.append(
Number.from_plaintext(i, ctx, secret_key))
return instructions, instruction_indices
def setUp(self):
ctx = FakeContext()
secret_key = ctx.generate_keys()
tape = Tape()
tape_indices = tape.generate_tape(2, ctx, secret_key)
utils.flag = Number.from_plaintext(1, ctx, secret_key, size=1)
utils.one = Number.from_plaintext(1, ctx, secret_key, size=1)
utils.zero = Number.from_plaintext(0, ctx, secret_key, size=1)
# Initial state of machine
data_ptr = Number.from_plaintext(0, ctx, secret_key)
instruction_ptr = Number.from_plaintext(0, ctx, secret_key)
# Defines instructions
inc_data_ptr = Number.from_plaintext(1, ctx, secret_key)
inc_data_cell = Number.from_plaintext(2, ctx, secret_key)
dec_data_ptr = Number.from_plaintext(3, ctx, secret_key)
dec_data_cell = Number.from_plaintext(4, ctx, secret_key)
mark_loop = Number.from_plaintext(5, ctx, secret_key)
loop_back = Number.from_plaintext(6, ctx, secret_key)
instruction_set = {
"+":inc_data_cell,
"-":dec_data_cell,
">":inc_data_ptr,
"<":dec_data_ptr,
"[":mark_loop,
"]":loop_back
}
instructions, instruction_indices = VirtualMachine.compile("++[>+++<-]", instruction_set, ctx, secret_key)
self.blind_machine = VirtualMachine(
tape,
tape_indices,
instruction_indices,
instruction_set,
instructions,
instruction_ptr,
data_ptr
)
self.context = ctx
self.secret_key = secret_key
self.tape = tape
def setUp(self):
self.context = FakeContext()
self.sk = self.context.generate_keys()
self.one = Number.from_plaintext(1, self.context, self.sk)
self.zero = Number.from_plaintext(0, self.context, self.sk)
def test_from_plaintext(self):
one28 = Number.from_plaintext(128, self.context, self.sk)
too_big = Number.from_plaintext(512, self.context, self.sk, size=8)
self.assertEqual(too_big.decrypt(self.sk, decimal=True), 128)
self.assertEqual(one28.decrypt(self.sk, decimal=True), 128)
def run(code, tape_size=2):
ctx = NUFHEContext()
#ctx = FakeContext()
secret_key = ctx.generate_keys()
# Create tape with size of 2
tape = Tape()
tape_indices = tape.generate_tape(tape_size, ctx, secret_key)
utils.flag = Number.from_plaintext(1, ctx, secret_key, size=1)
utils.one = Number.from_plaintext(1, ctx, secret_key, size=1)
utils.zero = Number.from_plaintext(0, ctx, secret_key, size=1)
# Initial state of machine
data_ptr = Number.from_plaintext(0, ctx, secret_key)
instruction_ptr = Number.from_plaintext(0, ctx, secret_key)
# Defines instructions
inc_data_ptr = Number.from_plaintext(1, ctx, secret_key)
inc_data_cell = Number.from_plaintext(2, ctx, secret_key)
dec_data_ptr = Number.from_plaintext(3, ctx, secret_key)
dec_data_cell = Number.from_plaintext(4, ctx, secret_key)
mark_loop = Number.from_plaintext(5, ctx, secret_key)
loop_back = Number.from_plaintext(6, ctx, secret_key)
instruction_set = {
"+": inc_data_cell,
"-": dec_data_cell,
">": inc_data_ptr,
"<": dec_data_ptr,
"[": mark_loop,
"]": loop_back
}
instructions, instruction_indices = VirtualMachine.compile(
code, instruction_set, ctx, secret_key)
blind_machine = VirtualMachine(tape, tape_indices, instruction_indices,
instruction_set, instructions,
instruction_ptr, data_ptr)
blind_machine.run()
pprint.pprint(tape.decrypt_tape(secret_key))
