347 lines
7.9 KiB
Go
347 lines
7.9 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"math/big"
|
|
"encoding/hex"
|
|
"github.com/obscuren/sha3"
|
|
"testing"
|
|
)
|
|
|
|
//For use in benchmarking
|
|
const tree_depth = 5
|
|
const tape_width = 32 //int(math.Pow(2,tree_depth)) < would be nice, but go won't recognize as const
|
|
const tape_depth = 500
|
|
|
|
const Report_Zeros = true
|
|
|
|
//Number of operations that are drawn from to form the tape and the tree
|
|
const num_ops = 7
|
|
//This is the number of times the PoW algorithm is run
|
|
const sample_size = 100
|
|
|
|
func Bytes2Hex(d []byte) string {
|
|
return hex.EncodeToString(d)
|
|
}
|
|
|
|
func Hex2Bytes(str string) []byte {
|
|
h, _ := hex.DecodeString(str)
|
|
return h
|
|
}
|
|
|
|
func plus(z *big.Int, x *big.Int, y *big.Int) *big.Int {
|
|
var lim big.Int
|
|
lim.Exp(big.NewInt(2),big.NewInt(256), big.NewInt(0))
|
|
z.Add(x,y)
|
|
return z.Mod(z,&lim)
|
|
|
|
}
|
|
|
|
func times(z *big.Int, x *big.Int, y *big.Int) *big.Int {
|
|
var lim, x1, y1, z1 big.Int
|
|
lim.Exp(big.NewInt(2),big.NewInt(256), big.NewInt(0))
|
|
x1.Set(x)
|
|
y1.Set(y)
|
|
z.Mul(x,y)
|
|
z.Mod(z,&lim)
|
|
z1 = *big.NewInt(0)
|
|
if Report_Zeros {
|
|
if (z.Cmp(&z1) == 0 && x1.Cmp(&z1) != 0 && y1.Cmp(&z1) != 0) {
|
|
fmt.Printf("-------getting zero---------\n")
|
|
fmt.Println(Bytes2Hex(x1.Bytes()))
|
|
fmt.Println(Bytes2Hex(y1.Bytes()))
|
|
fmt.Println(Bytes2Hex(z.Bytes()))
|
|
}
|
|
}
|
|
return z
|
|
}
|
|
|
|
func mod(z *big.Int, x *big.Int, y *big.Int) *big.Int {
|
|
|
|
if (x.Cmp(big.NewInt(0)) == 0 || y.Cmp(big.NewInt(0)) == 0) {
|
|
return big.NewInt(0)
|
|
}
|
|
if x.Cmp(y) == -1 { //if x < y
|
|
z.Mod(y,x)
|
|
} else if x.Cmp(y) == 1 { //if x > y
|
|
z.Mod(x,y)
|
|
}
|
|
return z
|
|
}
|
|
|
|
func xor(z *big.Int, x *big.Int, y *big.Int) *big.Int {return z.Xor(x,y)}
|
|
func and(z *big.Int, x *big.Int, y *big.Int) *big.Int {return z.And(x,y)}
|
|
func or(z *big.Int, x *big.Int, y *big.Int) *big.Int {return z.Or(x,y)}
|
|
|
|
func rshift(z *big.Int, x *big.Int, y *big.Int) *big.Int {
|
|
var lim big.Int
|
|
lim.Exp(big.NewInt(2),big.NewInt(256), big.NewInt(0))
|
|
z.Rsh(x,7)
|
|
return z.Mod(z,&lim)
|
|
}
|
|
|
|
|
|
func GetOp(i int) func(z *big.Int, x *big.Int, y *big.Int) *big.Int{
|
|
switch i {
|
|
case 0:
|
|
return plus
|
|
case 1:
|
|
return rshift
|
|
case 2:
|
|
return mod
|
|
case 3:
|
|
return xor
|
|
case 4:
|
|
return and
|
|
case 5:
|
|
return or
|
|
case 6:
|
|
return times
|
|
}
|
|
return plus
|
|
}
|
|
|
|
type Tapelink struct {
|
|
I int64
|
|
J int64
|
|
op func(z *big.Int, x *big.Int, y *big.Int) *big.Int
|
|
}
|
|
|
|
func Sha3Bin(data []byte) []byte {
|
|
d := sha3.NewKeccak256()
|
|
d.Write(data)
|
|
return d.Sum(nil)
|
|
}
|
|
|
|
func BenchmarkSha3Bin(b *testing.B){
|
|
for i:= 0; i < b.N; i++ {
|
|
Sha3Bin([]byte(string(i)))
|
|
}
|
|
}
|
|
|
|
//generates a tape of operations that is w*d long
|
|
func gen_tape(seed int64, w int, d int) []Tapelink {
|
|
var X = big.NewInt(0)
|
|
var Y = big.NewInt(int64(math.Pow(2,32)))
|
|
var M = big.NewInt(0)
|
|
var T []Tapelink
|
|
for i := 0; i < w*d; i++{
|
|
// add empty link to tape
|
|
T = append(T, *new(Tapelink))
|
|
|
|
// generate new entropy as needed
|
|
if (int64(X.Cmp(Y)) == -1) {X = X.SetBytes(Sha3Bin([]byte(string(seed + int64(i)))))}
|
|
|
|
// Pick random index I
|
|
T[i].I = M.Mod(X,big.NewInt(int64(w))).Int64()
|
|
M = big.NewInt(int64(w))
|
|
X = X.Div(X,M)
|
|
|
|
// Pick random index J
|
|
mm := big.NewInt(M.Mod(X,big.NewInt(int64(w-1))).Int64() + int64(1) + T[i].I)
|
|
T[i].J = M.Mod(mm, big.NewInt(int64(w))).Int64()
|
|
M = big.NewInt(int64(w-1))
|
|
X = X.Div(X,M)
|
|
|
|
// Pick random operation
|
|
T[i].op = GetOp(int(M.Mod(X, big.NewInt(int64(num_ops))).Int64()))
|
|
M = big.NewInt(int64(num_ops))
|
|
X = X.Div(X,M)
|
|
}
|
|
return T
|
|
}
|
|
|
|
func BenchmarkGen_tape(b *testing.B){
|
|
var X big.Int
|
|
var s int64
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
b.StopTimer()
|
|
X.SetBytes(Sha3Bin([]byte(string(i))))
|
|
s = X.Int64()
|
|
b.StartTimer()
|
|
gen_tape(s, tape_width, tape_depth)
|
|
}
|
|
|
|
}
|
|
|
|
func gen_inputs(seed int64, w int) []big.Int {
|
|
var A []big.Int
|
|
X := big.NewInt(0)
|
|
for i := 0; i < w; i++ {
|
|
var B big.Int
|
|
A = append(A,B)
|
|
if (i % 256 == 0) {
|
|
A[i].Set(X.SetBytes(Sha3Bin([]byte(string(seed + int64(i))))))
|
|
} else {
|
|
A[i].Set(X.Lsh(X, 1))
|
|
}
|
|
}
|
|
return A
|
|
}
|
|
|
|
func BenchmarkGen_inputs(b *testing.B){
|
|
var X big.Int
|
|
var s int64
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
b.StopTimer()
|
|
X.SetBytes(Sha3Bin([]byte(string(i))))
|
|
s = X.Int64()
|
|
b.StartTimer()
|
|
gen_inputs(s, tape_width)
|
|
}
|
|
}
|
|
|
|
//this changes the inputs as it goes through a tape with d links
|
|
func run_tape(tape []Tapelink, inputs []big.Int, d int) {
|
|
var X *big.Int
|
|
X = big.NewInt(0)
|
|
for i := 0; i < d; i++ {
|
|
X = tape[i].op(X, &inputs[tape[i].I], &inputs[tape[i].J])
|
|
inputs[tape[i].I].Set(X)
|
|
}
|
|
}
|
|
|
|
func BenchmarkRun_tape(b *testing.B){
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
b.StopTimer()
|
|
T := gen_tape(int64(i), tape_width, tape_depth)
|
|
I := gen_inputs(int64(i), tape_width)
|
|
b.StartTimer()
|
|
run_tape(T,I,tape_width*tape_depth)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//returns a 2^d - 1 length tape of operations (no I or J's in the Tapelinks)
|
|
func gen_tree(seed int64, d int) []Tapelink {
|
|
M := big.NewInt(0) // dummy variable
|
|
X := big.NewInt(0) // entropy variable
|
|
Y := big.NewInt(int64(math.Pow(2,32))) // entropy buffer size
|
|
var T []Tapelink // the tree will be stored here
|
|
|
|
for i := 0; i < int(math.Pow(2, float64(d))) - 1; i++{
|
|
|
|
T = append(T, *new(Tapelink))
|
|
|
|
//giving it more entropy, if X < 2^32
|
|
if (X.Cmp(Y) == -1) {X = X.SetBytes(Sha3Bin([]byte(string(seed + int64(i)))))}
|
|
|
|
//filling the tape with random ops
|
|
T[i].op = GetOp(int(M.Mod(X, big.NewInt(num_ops)).Int64()))
|
|
M = big.NewInt(num_ops)
|
|
X = X.Div(X,M)
|
|
}
|
|
return T
|
|
}
|
|
|
|
func BenchmarkGen_tree(b *testing.B) {
|
|
var X big.Int
|
|
var s int64
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
b.StopTimer()
|
|
X.SetBytes(Sha3Bin([]byte(string(i))))
|
|
s = X.Int64()
|
|
b.StartTimer()
|
|
gen_tree(s, tree_depth)
|
|
}
|
|
}
|
|
|
|
//there should be 2^d inputs and 2^d - 1 links in the tape. not complying is an unhandled exception
|
|
func run_tree(inputs []big.Int, tree []Tapelink, d int) *big.Int {
|
|
X := big.NewInt(0)
|
|
counter := 0
|
|
for j := 0; j < d; j++ {
|
|
for i := 0; i < int(math.Pow(2,float64(d - j - 1))); i++ {
|
|
X = tree[counter].op(X, &inputs[2*i], &inputs[2*i + 1])
|
|
inputs[i].Set(X)
|
|
counter += 1
|
|
}
|
|
}
|
|
|
|
return &inputs[0]
|
|
}
|
|
|
|
func BenchmarkRun_tree(b *testing.B) {
|
|
var X big.Int
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
b.StopTimer()
|
|
var inputs []big.Int
|
|
for j := 0; j < tape_width; j++ {
|
|
X.SetBytes(Sha3Bin([]byte(string(j + i*tape_width))))
|
|
inputs = append(inputs, X)
|
|
}
|
|
tree := gen_tree(X.Int64(), tree_depth)
|
|
b.StartTimer()
|
|
run_tree(inputs, tree, tree_depth)
|
|
}
|
|
}
|
|
|
|
func sha_cap(s []string, n int) []byte{
|
|
var feed string
|
|
feed = ""
|
|
for i := 0; i < n; i++ {
|
|
feed += s[i]
|
|
}
|
|
return Sha3Bin([]byte(feed))
|
|
}
|
|
|
|
|
|
//benchmarked with only one string in the slice, s
|
|
func BenchmarkSha_cap(b *testing.B){
|
|
var X big.Int
|
|
var s []string
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
b.StopTimer()
|
|
X.SetBytes(Sha3Bin([]byte(string(i))))
|
|
s = append(s, X.String())
|
|
b.StartTimer()
|
|
sha_cap(s,1)
|
|
}
|
|
}
|
|
|
|
|
|
|
|
func main(){
|
|
var seed int64
|
|
|
|
var sample []big.Int
|
|
for i := 0; i < sample_size; i++ {
|
|
|
|
if i%5 == 0 {
|
|
fmt.Printf("i: %d\n",i)
|
|
}
|
|
|
|
seed = int64(i)
|
|
T := gen_tape(seed, tape_width, tape_depth)
|
|
I := gen_inputs(seed, tape_width)
|
|
run_tape(T,I, tape_depth*tape_width)
|
|
T = gen_tree(seed, tree_depth)
|
|
var output big.Int = *run_tree(I,T,tree_depth)
|
|
var blockhashes []string
|
|
blockhashes = append(blockhashes, output.String())
|
|
H := sha_cap(blockhashes,1)
|
|
|
|
output.SetBytes(H)
|
|
sample = append(sample, output)
|
|
}
|
|
|
|
var collisions int = 0
|
|
for i := 0; i < sample_size; i++ {
|
|
for j:=0; j < i; j++ {
|
|
if(sample[i].Cmp(&sample[j]) == 0) {
|
|
collisions += 1
|
|
}
|
|
}
|
|
}
|
|
fmt.Printf("Collisions: %d out of %d\n", (1+int(math.Pow(float64(1+8*collisions),0.5)))/2 - 1, sample_size)
|
|
}
|
|
|