Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Thomas Hoffmann
CryComp
Commits
68974499
Commit
68974499
authored
Sep 19, 2021
by
Anders Jensen Løvig
Browse files
Fix some tests
parents
a5f8aaf0
e229081f
Changes
2
Hide whitespace changes
Inline
Side-by-side
cmd/handin3/main.go
View file @
68974499
...
...
@@ -35,8 +35,8 @@ var BloodTable = [][]bool{
{
true
,
true
,
true
,
true
,
true
,
true
,
true
,
true
},
}
//
EncodeBloodType
return x as a slice containing the binary representation.
func
EncodeBloodType
(
x
,
n
int
)
[]
bool
{
//
Int2Bools
return x as a slice containing the binary representation.
func
Int2Bools
(
x
,
n
int
)
[]
bool
{
output
:=
make
([]
bool
,
0
)
tmp
:=
0
for
i
:=
n
-
1
;
i
>=
0
;
i
--
{
...
...
@@ -54,21 +54,6 @@ func EncodeBloodType(x, n int) []bool {
return
output
}
type
Dealer
struct
{
}
func
NewDealer
()
*
Dealer
{
return
&
Dealer
{}
}
func
(
d
*
Dealer
)
DealA
()
[]
bool
{
return
[]
bool
{}
}
func
(
d
*
Dealer
)
DealB
()
[]
bool
{
return
[]
bool
{}
}
type
Party
struct
{
wires
[]
bool
...
...
@@ -76,10 +61,13 @@ type Party struct {
out
chan
bool
}
func
NewParty
(
bloodType
in
t
,
secrets
[]
bool
)
*
Party
{
func
NewParty
(
in
,
out
chan
bool
)
*
Party
{
return
&
Party
{
wires
:
make
([]
bool
,
0
),
in
:
in
,
out
:
out
,
}
}
// Push v to the wires and return the index of the pushed value.
...
...
@@ -88,9 +76,9 @@ func (p *Party) Push(v bool) int {
return
len
(
p
.
wires
)
-
1
}
//
Share
samples a random value xb, computes xa = x XOR xb and sends xb to the
//
Input
samples a random value xb, computes xa = x XOR xb and sends xb to the
// other party.
func
(
p
*
Party
)
Share
(
x
bool
)
int
{
func
(
p
*
Party
)
Input
(
x
bool
)
int
{
xb
:=
rand
.
Intn
(
2
)
==
1
xa
:=
x
!=
xb
// x XOR xb
...
...
@@ -99,47 +87,48 @@ func (p *Party) Share(x bool) int {
}
func
(
p
*
Party
)
Receive
()
int
{
p
.
wires
=
append
(
p
.
wires
,
<-
p
.
in
)
return
len
(
p
.
wires
)
-
1
return
p
.
Push
(
<-
p
.
in
)
}
func
(
a
*
Party
)
Send
(
wire
int
)
{
a
.
out
<-
a
.
wires
[
wire
]
func
(
p
*
Party
)
Send
(
wire
int
)
{
p
.
out
<-
p
.
wires
[
wire
]
}
func
(
a
*
Party
)
Combine
(
xwire
,
ywire
int
)
int
{
a
.
wires
=
append
(
a
.
wires
,
a
.
wires
[
xwire
]
&&
a
.
wires
[
ywire
])
return
len
(
a
.
wires
)
-
1
func
(
p
*
Party
)
Combine
(
xwire
,
ywire
int
)
int
{
return
p
.
Push
(
p
.
wires
[
xwire
]
&&
p
.
wires
[
ywire
])
}
func
(
a
*
Party
)
XORC
(
xwire
int
,
c
bool
,
mode
bool
)
int
{
var
xa
=
a
.
wires
[
xwire
]
func
(
p
*
Party
)
XORC
(
xwire
int
,
c
bool
,
mode
bool
)
int
{
if
mode
{
//Only one party is supposed to do the XOR
a
.
wires
=
append
(
a
.
wires
,
xa
!=
c
)
return
p
.
Push
(
p
.
wires
[
xwire
]
!=
c
)
}
else
{
a
.
wires
=
append
(
a
.
wires
,
xa
)
return
xwire
}
return
len
(
a
.
wires
)
-
1
}
func
(
a
*
Party
)
ANDC
(
xwire
int
,
c
bool
)
int
{
var
xa
=
a
.
wires
[
xwire
]
a
.
wires
=
append
(
a
.
wires
,
xa
&&
c
)
return
len
(
a
.
wires
)
-
1
func
(
p
*
Party
)
ANDC
(
xwire
int
,
c
bool
)
int
{
return
p
.
Push
(
p
.
wires
[
xwire
]
&&
c
)
}
func
(
a
*
Party
)
XOR2W
(
xwire
,
ywire
int
)
int
{
var
xa
,
xb
=
a
.
wires
[
xwire
],
a
.
wires
[
ywire
]
a
.
wires
=
append
(
a
.
wires
,
xa
!=
xb
)
return
len
(
a
.
wires
)
-
1
func
(
p
*
Party
)
XOR2W
(
xwire
,
ywire
int
)
int
{
return
p
.
Push
(
p
.
wires
[
xwire
]
!=
p
.
wires
[
ywire
])
}
type
Protocol
struct
{
Alice
*
Party
Bob
*
Party
A
*
Party
B
*
Party
}
func
NewProtocol
()
*
Protocol
{
var
a2b
=
make
(
chan
bool
,
1
)
//Directional non-blocking channels
var
b2a
=
make
(
chan
bool
,
1
)
return
&
Protocol
{
A
:
NewParty
(
b2a
,
a2b
),
B
:
NewParty
(
a2b
,
b2a
),
}
}
func
(
P
*
Protocol
)
AND
(
xwire
,
ywire
int
)
int
{
A
,
B
:=
P
.
A
lice
,
P
.
B
ob
A
,
B
:=
P
.
A
,
P
.
B
//1a. Generate [u], [v] and [w]
u
:=
rand
.
Intn
(
2
)
==
1
ua
:=
rand
.
Intn
(
2
)
==
1
...
...
@@ -163,10 +152,10 @@ func (P *Protocol) AND(xwire, ywire int) int {
var
idx_w
,
_
=
A
.
Receive
(),
B
.
Receive
()
//2 compute [d] = [x] XOR [u]
var
idx_d1
,
_
=
A
.
XOR2W
(
xwire
,
idx_u
),
B
.
XOR2W
(
xwire
,
idx_u
)
var
idx_d1
=
P
.
XOR2W
(
xwire
,
idx_u
)
//
A.XOR2W(xwire, idx_u), B.XOR2W(xwire, idx_u)
//3. compute [e] = [y] XOR [v]
var
idx_e1
,
_
=
A
.
XOR2W
(
ywire
,
idx_v
),
B
.
XOR2W
(
ywire
,
idx_v
)
var
idx_e1
=
P
.
XOR2W
(
ywire
,
idx_v
)
//
A.XOR2W(ywire, idx_v), B.XOR2W(ywire, idx_v)
//4. Open d
A
.
Send
(
idx_d1
)
...
...
@@ -179,8 +168,8 @@ func (P *Protocol) AND(xwire, ywire int) int {
var
idx_e2
,
_
=
A
.
Receive
(),
B
.
Receive
()
//6a. Compute d and e
var
idx_d
,
_
=
A
.
XOR2W
(
idx_d1
,
idx_d2
),
B
.
XOR2W
(
idx_d1
,
idx_d2
)
var
idx_e
,
_
=
A
.
XOR2W
(
idx_e1
,
idx_e2
),
B
.
XOR2W
(
idx_e1
,
idx_e2
)
var
idx_d
=
P
.
XOR2W
(
idx_d1
,
idx_d2
)
//
A.XOR2W(idx_d1, idx_d2), B.XOR2W(idx_d1, idx_d2)
var
idx_e
=
P
.
XOR2W
(
idx_e1
,
idx_e2
)
//
A.XOR2W(idx_e1, idx_e2), B.XOR2W(idx_e1, idx_e2)
//6b. Compute [z]-parts
var
idx_z1
,
_
=
A
.
ANDC
(
xwire
,
A
.
wires
[
idx_e
]),
B
.
ANDC
(
xwire
,
B
.
wires
[
idx_e
])
...
...
@@ -190,42 +179,44 @@ func (P *Protocol) AND(xwire, ywire int) int {
//6c. Compute [z]
var
idx_z4
,
_
=
A
.
XOR2W
(
idx_w
,
idx_z1
),
B
.
XOR2W
(
idx_w
,
idx_z1
)
var
idx_z5
,
_
=
A
.
XOR2W
(
idx_z4
,
idx_z2
),
B
.
XOR2W
(
idx_z4
,
idx_z2
)
var
idx_z
,
_
=
A
.
XOR
2W
(
idx_z5
,
idx_z3
),
B
.
XOR
2W
(
idx_z5
,
idx_z3
)
var
idx_z
,
_
=
A
.
XOR
C
(
idx_z5
,
A
.
wires
[
idx_z3
],
true
),
B
.
XOR
C
(
idx_z5
,
B
.
wires
[
idx_z3
],
false
)
return
idx_z
}
// Input the x bit to
func
(
P
*
Protocol
)
Input
(
x
,
y
bool
)
(
int
,
int
)
{
var
idx1
=
P
.
A
lice
.
Share
(
x
)
P
.
B
ob
.
Receive
()
P
.
B
ob
.
Share
(
y
)
var
idx2
=
P
.
A
lice
.
Receive
()
var
idx1
=
P
.
A
.
Input
(
x
)
P
.
B
.
Receive
()
P
.
B
.
Input
(
y
)
var
idx2
=
P
.
A
.
Receive
()
return
idx1
,
idx2
}
func
(
P
*
Protocol
)
XORC
(
wire
int
,
c
bool
)
int
{
var
idx
,
_
=
P
.
A
lice
.
XORC
(
wire
,
c
,
true
),
P
.
B
ob
.
XORC
(
wire
,
c
,
false
)
var
idx
,
_
=
P
.
A
.
XORC
(
wire
,
c
,
true
),
P
.
B
.
XORC
(
wire
,
c
,
false
)
return
idx
}
func
(
P
*
Protocol
)
ANDC
(
wire
int
,
c
bool
)
int
{
var
idx
,
_
=
P
.
A
lice
.
ANDC
(
wire
,
c
),
P
.
B
ob
.
ANDC
(
wire
,
c
)
var
idx
,
_
=
P
.
A
.
ANDC
(
wire
,
c
),
P
.
B
.
ANDC
(
wire
,
c
)
return
idx
}
func
(
P
*
Protocol
)
XOR2W
(
xwire
,
ywire
int
)
int
{
var
idx
,
_
=
P
.
A
lice
.
XOR2W
(
xwire
,
ywire
),
P
.
B
ob
.
XOR2W
(
xwire
,
ywire
)
var
idx
,
_
=
P
.
A
.
XOR2W
(
xwire
,
ywire
),
P
.
B
.
XOR2W
(
xwire
,
ywire
)
return
idx
}
//Only 1 share should be flipped
//NOT A == A XOR 1
func
(
P
*
Protocol
)
NOT
(
xwire
int
)
int
{
i
:=
P
.
A
lice
.
XORC
(
xwire
,
true
,
true
)
_
=
P
.
B
ob
.
XORC
(
xwire
,
true
,
false
)
i
:=
P
.
A
.
XORC
(
xwire
,
true
,
true
)
_
=
P
.
B
.
XORC
(
xwire
,
true
,
false
)
return
i
}
func
(
P
*
Protocol
)
Output
(
wire
int
,
A_Learns
,
B_Learns
bool
)
[]
bool
{
var
A
,
B
=
P
.
A
lice
,
P
.
B
ob
var
A
,
B
=
P
.
A
,
P
.
B
var
output
=
make
([]
bool
,
0
)
if
A_Learns
{
B
.
Send
(
wire
)
...
...
@@ -246,15 +237,6 @@ func (P *Protocol) Output(wire int, A_Learns, B_Learns bool) []bool {
return
output
}
func
NewProtocol
()
*
Protocol
{
// var a2b = make(chan bool, 1) //Directional non-blocking channels
// var b2a = make(chan bool, 1)
return
&
Protocol
{
// Alice: NewParty(b2a, a2b),
// Bob: NewParty(a2b, b2a),
}
}
// Run the protocol for blood type compatibility using a passive secure BeDOZa
// protocol.
//
...
...
@@ -277,29 +259,25 @@ func (P *Protocol) Run(x, y []bool) (bool, error) {
if
lenY
:=
len
(
y
);
lenY
!=
3
{
return
false
,
fmt
.
Errorf
(
"length of y-encoding must be 3, was %d"
,
lenY
)
}
// Input round
// Input round
idx_s
,
_
:=
P
.
Input
(
x
[
0
],
y
[
0
])
idx_A
,
_
:=
P
.
Input
(
x
[
1
],
y
[
1
])
idx_B
,
_
:=
P
.
Input
(
x
[
2
],
y
[
2
])
//Input round
var
idx_xS
,
idx_yS
=
P
.
Input
(
x
[
2
],
y
[
2
])
var
idx_xA
,
idx_yA
=
P
.
Input
(
x
[
1
],
y
[
1
])
var
idx_xB
,
idx_yB
=
P
.
Input
(
x
[
0
],
y
[
0
])
//a. Compute (x_sign OR NOT y_sign) = NOT (NOT x_sign AND y_sign)
//var idx_f1 = alice.XORC(idx_s, true , true) //compute NOT x_sign
var
idx_f1
=
P
.
NOT
(
idx_s
)
idx_f1
=
P
.
AND
(
idx_f1
,
idx_s
)
// NOT x_sign AND y_sign
idx_f1
=
P
.
NOT
(
idx_f1
)
//NOT (NOT x_sign AND y_sign)
var
idx_f1
=
P
.
NOT
(
idx_xS
)
idx_f1
=
P
.
AND
(
idx_f1
,
idx_yS
)
// NOT x_sign AND y_sign
idx_f1
=
P
.
NOT
(
idx_f1
)
//NOT (NOT x_sign AND y_sign)
//b. Compute (x_A OR NOT y_A) = NOT (NOT x_A AND y_A)
var
idx_f2
=
P
.
NOT
(
idx_A
)
//compute NOT x_A
idx_f2
=
P
.
AND
(
idx_f2
,
idx_A
)
// NOT x_A AND y_A
idx_f2
=
P
.
NOT
(
idx_f2
)
//NOT (NOT x_A AND y_A)
var
idx_f2
=
P
.
NOT
(
idx_
x
A
)
//compute NOT x_A
idx_f2
=
P
.
AND
(
idx_f2
,
idx_
y
A
)
// NOT x_A AND y_A
idx_f2
=
P
.
NOT
(
idx_f2
)
//NOT (NOT x_A AND y_A)
//c. Compute (x_B OR NOT y_B) = NOT (NOT x_B AND y_B)
var
idx_f3
=
P
.
NOT
(
idx_B
)
//compute NOT x_B
idx_f3
=
P
.
AND
(
idx_f3
,
idx_B
)
// NOT x_B AND y_B
idx_f3
=
P
.
NOT
(
idx_f3
)
//NOT (NOT x_B AND y_B)
var
idx_f3
=
P
.
NOT
(
idx_
x
B
)
//compute NOT x_B
idx_f3
=
P
.
AND
(
idx_f3
,
idx_
y
B
)
// NOT x_B AND y_B
idx_f3
=
P
.
NOT
(
idx_f3
)
//NOT (NOT x_B AND y_B)
//d. Compute f(x,y)
var
idx_f
=
P
.
AND
(
idx_f1
,
idx_f2
)
...
...
@@ -311,13 +289,8 @@ func (P *Protocol) Run(x, y []bool) (bool, error) {
func
RunProtocol
(
x
,
y
int
)
(
bool
,
error
)
{
protocol
:=
NewProtocol
()
encodingX
:=
EncodeBloodType
(
x
,
3
)
encodingY
:=
EncodeBloodType
(
y
,
3
)
dealer
:=
NewDealer
()
A
:=
NewParty
(
x
,
dealer
.
DealA
())
B
:=
NewParty
(
y
,
dealer
.
DealB
())
encodingX
:=
Int2Bools
(
x
,
3
)
encodingY
:=
Int2Bools
(
y
,
3
)
return
protocol
.
Run
(
encodingX
,
encodingY
)
}
...
...
cmd/handin3/main_test.go
View file @
68974499
...
...
@@ -5,11 +5,281 @@ import (
"testing"
)
func
CheckBloodType
(
t
*
testing
.
T
,
bloodType
int
,
expected
[]
bool
)
{
actual
:=
EncodeBloodType
(
bloodType
,
3
)
func
TestBloodTable
(
t
*
testing
.
T
)
{
// Check the dimensions of BloodTable.
if
len
(
BloodTable
)
!=
8
{
t
.
Fatalf
(
"Expected 8 rows, got %d"
,
len
(
BloodTable
))
}
for
i
:=
range
BloodTable
{
if
len
(
BloodTable
[
i
])
!=
8
{
t
.
Fatalf
(
"Expected columns in row %d, got %d"
,
i
,
len
(
BloodTable
))
}
}
}
////////////////////////////////////////////////////////////////
//// Party Tests ////
////////////////////////////////////////////////////////////////
func
TestPartyWires
(
t
*
testing
.
T
)
{
t
.
Run
(
"WireSize|Input"
,
TestPartyInput
)
t
.
Run
(
"WireSize|Receive"
,
TestPartyReceive
)
}
func
TestPartyInput
(
t
*
testing
.
T
)
{
A
:=
NewProtocol
()
.
A
idx
:=
A
.
Input
(
true
)
if
len
(
A
.
wires
)
!=
1
{
t
.
Errorf
(
"Expected len(A.wires) == %d, was %d"
,
1
,
idx
)
}
if
idx
!=
0
{
t
.
Errorf
(
"Expected idx == %d, was %d"
,
0
,
idx
)
}
}
func
TestPartyReceive
(
t
*
testing
.
T
)
{
p
:=
NewProtocol
()
A
,
B
:=
p
.
A
,
p
.
B
A
.
Input
(
true
)
idx
:=
B
.
Receive
()
if
len
(
B
.
wires
)
!=
1
{
t
.
Errorf
(
"Expected len(A.wires) == %d, was %d"
,
1
,
idx
)
}
if
idx
!=
0
{
t
.
Errorf
(
"Expected idx == %d, was %d"
,
0
,
idx
)
}
}
func
TestPartyCombine
(
t
*
testing
.
T
)
{
// TODO
p
:=
NewProtocol
()
A
,
B
:=
p
.
A
,
p
.
B
a
:=
A
.
Input
(
true
)
B
.
Receive
()
b
:=
A
.
Input
(
false
)
ASizeBefore
,
BSizeBefore
:=
len
(
p
.
A
.
wires
),
len
(
p
.
B
.
wires
)
idx
:=
p
.
A
.
Combine
(
a
,
b
)
if
len
(
p
.
A
.
wires
)
!=
ASizeBefore
+
1
&&
len
(
p
.
B
.
wires
)
!=
BSizeBefore
{
t
.
Error
()
}
if
idx
!=
2
{
t
.
Errorf
(
"Expected idx == %d, was %d"
,
2
,
idx
)
}
}
func
TestPartyXORC
(
t
*
testing
.
T
)
{
A
:=
NewProtocol
()
.
A
A
.
Input
(
true
)
idx1
:=
A
.
XORC
(
0
,
true
,
true
)
if
len
(
A
.
wires
)
!=
2
{
t
.
Errorf
(
"Expected len(A.wires) == %d, was %d"
,
2
,
len
(
A
.
wires
))
}
if
idx1
!=
1
{
t
.
Errorf
(
"Expected idx1 == %d, was %d"
,
1
,
idx1
)
}
idx2
:=
A
.
XORC
(
0
,
true
,
false
)
if
len
(
A
.
wires
)
!=
2
{
t
.
Errorf
(
"Expected len(A.wires) == %d, was %d"
,
2
,
len
(
A
.
wires
))
}
if
idx2
!=
0
{
t
.
Errorf
(
"Expected idx2 == %d, was %d"
,
0
,
idx2
)
}
}
func
TestPartyANDC
(
t
*
testing
.
T
)
{
A
:=
NewProtocol
()
.
A
A
.
Input
(
true
)
idx
:=
A
.
ANDC
(
0
,
true
)
if
len
(
A
.
wires
)
!=
2
{
t
.
Errorf
(
"Expected len(A.wires) == %d, was %d"
,
2
,
len
(
A
.
wires
))
}
if
idx
!=
1
{
t
.
Errorf
(
"Expected idx == %d, was %d"
,
1
,
idx
)
}
}
func
TestPartyXOR
(
t
*
testing
.
T
)
{
p
:=
NewProtocol
()
A
,
B
:=
p
.
A
,
p
.
B
A
.
Input
(
true
)
B
.
Receive
()
A
.
Input
(
false
)
idx
:=
A
.
XOR2W
(
0
,
1
)
if
len
(
A
.
wires
)
!=
3
{
t
.
Errorf
(
"Expected len(A.wires) == %d, was %d"
,
3
,
len
(
A
.
wires
))
}
if
idx
!=
2
{
t
.
Errorf
(
"Expected idx == %d, was %d"
,
2
,
idx
)
}
}
func
TestStackAND
(
t
*
testing
.
T
)
{
p
:=
NewProtocol
()
a
:=
p
.
A
.
Input
(
true
)
p
.
B
.
Receive
()
b
:=
p
.
A
.
Input
(
false
)
p
.
B
.
Receive
()
idx
:=
p
.
AND
(
a
,
b
)
if
len
(
p
.
A
.
wires
)
!=
17
||
len
(
p
.
B
.
wires
)
!=
17
{
t
.
Error
()
}
if
idx
!=
16
{
t
.
Error
()
}
t
.
Log
(
"Success"
)
}
////////////////////////////////////////////////////////////////
//// Protocol Tests ////
////////////////////////////////////////////////////////////////
func
TestProtocolFunctions
(
t
*
testing
.
T
)
{
}
func
TestProtocolInput
(
t
*
testing
.
T
)
{
p
:=
NewProtocol
()
idxA
,
idxB
:=
p
.
Input
(
true
,
false
)
shareA
,
shareB
:=
p
.
A
.
wires
[
idxA
]
!=
p
.
B
.
wires
[
idxA
],
p
.
A
.
wires
[
idxB
]
!=
p
.
B
.
wires
[
idxB
]
if
shareA
!=
true
||
shareB
!=
false
{
t
.
Fatal
(
"Shares has wrong values"
)
}
if
len
(
p
.
A
.
wires
)
!=
len
(
p
.
B
.
wires
)
{
t
.
Fatal
(
"Party stack size is not equal after function call"
)
}
}
func
TestProtocolXORC
(
t
*
testing
.
T
)
{
p
:=
NewProtocol
()
idxTrue
,
idxFalse
:=
p
.
Input
(
true
,
false
)
//True XOR True
idxTT
:=
p
.
XORC
(
idxTrue
,
true
)
idxTF
:=
p
.
XORC
(
idxTrue
,
false
)
idxFT
:=
p
.
XORC
(
idxFalse
,
true
)
idxFF
:=
p
.
XORC
(
idxFalse
,
false
)
resTT
,
resTF
,
resFT
,
resFF
:=
p
.
A
.
wires
[
idxTT
]
!=
p
.
B
.
wires
[
idxTT
],
p
.
A
.
wires
[
idxTF
]
!=
p
.
B
.
wires
[
idxTF
],
p
.
A
.
wires
[
idxFT
]
!=
p
.
B
.
wires
[
idxFT
],
p
.
A
.
wires
[
idxFF
]
!=
p
.
B
.
wires
[
idxFF
]
if
resTT
!=
false
||
resTF
!=
true
||
resFT
!=
true
||
resFF
!=
false
{
t
.
Fatal
(
"Shares has wrong values"
)
}
if
len
(
p
.
A
.
wires
)
!=
len
(
p
.
B
.
wires
)
{
t
.
Fatal
(
"Party stack size is not equal after function call"
)
}
}
func
TestProtocolANDC
(
t
*
testing
.
T
)
{
p
:=
NewProtocol
()
idxTrue
,
idxFalse
:=
p
.
Input
(
true
,
false
)
//True XOR True
idxTT
:=
p
.
ANDC
(
idxTrue
,
true
)
idxTF
:=
p
.
ANDC
(
idxTrue
,
false
)
idxFT
:=
p
.
ANDC
(
idxFalse
,
true
)
idxFF
:=
p
.
ANDC
(
idxFalse
,
false
)
resTT
,
resTF
,
resFT
,
resFF
:=
p
.
A
.
wires
[
idxTT
]
!=
p
.
B
.
wires
[
idxTT
],
p
.
A
.
wires
[
idxTF
]
!=
p
.
B
.
wires
[
idxTF
],
p
.
A
.
wires
[
idxFT
]
!=
p
.
B
.
wires
[
idxFT
],
p
.
A
.
wires
[
idxFF
]
!=
p
.
B
.
wires
[
idxFF
]
if
resTT
!=
true
||
resTF
!=
false
||
resFT
!=
false
||
resFF
!=
false
{
t
.
Fatal
(
"Shares has wrong values"
)
}
if
len
(
p
.
A
.
wires
)
!=
len
(
p
.
B
.
wires
)
{
t
.
Fatal
(
"Party stack size is not equal after function call"
)
}
}
func
TestProtocolXOR2W
(
t
*
testing
.
T
)
{
p
:=
NewProtocol
()
idxTrue
,
idxFalse
:=
p
.
Input
(
true
,
false
)
//True XOR True
idxTT
:=
p
.
XOR2W
(
idxTrue
,
idxTrue
)
idxTF
:=
p
.
XOR2W
(
idxTrue
,
idxFalse
)
idxFT
:=
p
.
XOR2W
(
idxFalse
,
idxTrue
)
idxFF
:=
p
.
XOR2W
(
idxFalse
,
idxFalse
)
resTT
,
resTF
,
resFT
,
resFF
:=
p
.
A
.
wires
[
idxTT
]
!=
p
.
B
.
wires
[
idxTT
],
p
.
A
.
wires
[
idxTF
]
!=
p
.
B
.
wires
[
idxTF
],
p
.
A
.
wires
[
idxFT
]
!=
p
.
B
.
wires
[
idxFT
],
p
.
A
.
wires
[
idxFF
]
!=
p
.
B
.
wires
[
idxFF
]
if
resTT
!=
false
||
resTF
!=
true
||
resFT
!=
true
||
resFF
!=
false
{
t
.
Fatal
(
"Shares has wrong values"
)
}
if
len
(
p
.
A
.
wires
)
!=
len
(
p
.
B
.
wires
)
{
t
.
Fatal
(
"Party stack size is not equal after function call"
)
}
}
func
TestProtocolNOT
(
t
*
testing
.
T
)
{
p
:=
NewProtocol
()
idxTrue
,
idxFalse
:=
p
.
Input
(
true
,
false
)
idxT
:=
p
.
NOT
(
idxTrue
)
idxF
:=
p
.
NOT
(
idxFalse
)
resT
,
resF
:=
p
.
A
.
wires
[
idxT
]
!=
p
.
B
.
wires
[
idxF
],
p
.
A
.
wires
[
idxF
]
!=
p
.
B
.
wires
[
idxF
]
if
resT
!=
false
||
resF
!=
true
{
t
.
Fatal
(
"Shares has wrong values"
)
}
if
len
(
p
.
A
.
wires
)
!=
len
(
p
.
B
.
wires
)
{
t
.
Fatal
(
"Party stack size is not equal after function call"
)
}
}
func
TestProtocolOUTPUT
(
t
*
testing
.
T
)
{
p
:=
NewProtocol
()
idxTrue
,
idxFalse
:=
p
.
Input
(
true
,
false
)
for
i
:=
0
;
i
<
8
;
i
++
{
params
:=
Int2Bools
(
i
,
3
)
var
idx
int
if
params
[
0
]
{
idx
=
idxTrue
}
else
{
idx
=
idxFalse
}
res
:=
p
.
Output
(
idx
,
params
[
1
],
params
[
2
])
if
params
[
1
]
==
false
&&
params
[
2
]
==
false
{
if
len
(
res
)
!=
0
{
t
.
Fatal
(
"output should be empty"
)
}
}
else
if
params
[
1
]
==
true
&&
params
[
2
]
==
true
{
if
len
(
res
)
!=
2
{
t
.
Fatal
(
"output should have 2 values"
)
}
if
res
[
0
]
!=
params
[
0
]
||
res
[
1
]
!=
params
[
0
]
{
t
.
Error
(
"Output does not match input"
)
}
}
else
{
if
len
(
res
)
!=
1
{
t
.
Fatal
(
"output should have 1 value"
)
}
if
res
[
0
]
!=
params
[
0
]
{
t
.
Error
(
"Output does not match input"
)
}
}
}
}
func
AssertBloodType
(
t
*
testing
.
T
,
bloodType
int
,
expected
[]
bool
)
{
actual
:=
Int2Bools
(
bloodType
,
3
)
if
len
(
actual
)
!=
len
(
expected
)
{
t
.
Fatalf
(
"
Expected length to be %d, was %d"
,
len
(
expected
),
len
(
actual
))
t
.
Fatalf
(
"Expected length to be %d, was %d"
,
len
(
expected
),
len
(
actual
))
}
for
i
:=
0
;
i
<
3
;
i
++
{
...
...
@@ -20,14 +290,14 @@ func CheckBloodType(t *testing.T, bloodType int, expected []bool) {
}
func
TestInt2Bools
(
t
*
testing
.
T
)
{
t
.
Run
(
"O-"
,
func
(
t
*
testing
.
T
)
{
Check
BloodType
(
t
,
BloodType_On
,
[]
bool
{
false
,
false
,
false
})
})
t
.
Run
(
"O+"
,
func
(
t
*
testing
.
T
)
{
Check
BloodType
(
t
,
BloodType_Op
,
[]
bool
{
true
,
false
,
false
})
})
t
.
Run
(
"A-"
,
func
(
t
*
testing
.
T
)
{
Check
BloodType
(
t
,
BloodType_An
,
[]
bool
{
false
,
true
,
false
})
})
t
.
Run
(
"A+"
,
func
(
t
*
testing
.
T
)
{
Check
BloodType
(
t
,
BloodType_Ap
,
[]
bool
{
true
,
true
,
false
})
})
t
.
Run
(
"B-"
,
func
(
t
*
testing
.
T
)
{
Check
BloodType
(
t
,
BloodType_Bn
,
[]
bool
{
false
,
false
,
true
})
})
t
.
Run
(
"B+"
,
func
(
t
*
testing
.
T
)
{
Check
BloodType
(
t
,
BloodType_Bp
,
[]
bool
{
true
,
false
,
true
})
})
t
.
Run
(
"AB-"
,
func
(
t
*
testing
.
T
)
{
Check
BloodType
(
t
,
BloodType_ABn
,
[]
bool
{
false
,
true
,
true
})
})
t
.
Run
(
"AB+"
,
func
(
t
*
testing
.
T
)
{
Check
BloodType
(
t
,
BloodType_ABp
,
[]
bool
{
true
,
true
,
true
})
})
t
.
Run
(
"O-"
,
func
(
t
*
testing
.
T
)
{
Assert
BloodType
(
t
,
BloodType_On
,
[]
bool
{
false
,
false
,
false
})
})
t
.
Run
(
"O+"
,
func
(
t
*
testing
.
T
)
{
Assert
BloodType
(
t
,
BloodType_Op
,
[]
bool
{
true
,
false
,
false
})
})
t
.
Run
(
"A-"
,
func
(
t
*
testing
.
T
)
{
Assert
BloodType
(
t
,
BloodType_An
,
[]
bool
{
false
,
true
,
false
})
})
t
.
Run
(
"A+"
,
func
(
t
*
testing
.
T
)
{
Assert
BloodType
(
t
,
BloodType_Ap
,
[]
bool
{
true
,
true
,
false
})
})
t
.
Run
(
"B-"
,
func
(
t
*
testing
.
T
)
{
Assert
BloodType
(
t
,
BloodType_Bn
,
[]
bool
{
false
,
false
,
true
})
})
t
.
Run
(
"B+"
,
func
(
t
*
testing
.
T
)
{
Assert
BloodType
(
t
,
BloodType_Bp
,
[]
bool
{
true
,
false
,
true
})
})
t
.
Run
(
"AB-"
,
func
(
t
*
testing
.
T
)
{
Assert
BloodType
(
t
,
BloodType_ABn
,
[]
bool
{
false
,
true
,
true
})
})
t
.
Run
(
"AB+"
,
func
(
t
*
testing
.
T
)
{
Assert
BloodType
(
t
,
BloodType_ABp
,
[]
bool
{
true
,
true
,
true
})
})
}
func
TestProtocol
(
t
*
testing
.
T
)
{
...
...
Write
Preview