zt.go

package main

import (
	"crypto/salsa20"
	"crypto/sha512"
	"encoding/binary"
	"unsafe"
)

const (
	ZT_IDENTITY_GEN_MEMORY                        = 2097152
	ZT_IDENTITY_GEN_HASHCASH_FIRST_BYTE_LESS_THAN = 17
	ZT_C25519_PUBLIC_KEY_LEN                      = 64
	ZT_C25519_PRIVATE_KEY_LEN                     = 64
	ZT_C25519_SIGNATURE_LEN                       = 96
	ZT_ADDRESS_LENGTH                             = 5
	ZT_ADDRESS_RESERVED_PREFIX                    = 0xff
)

type KeyPair struct {
	pub  [ZT_C25519_PUBLIC_KEY_LEN]byte
	priv [ZT_C25519_PRIVATE_KEY_LEN]byte
}

func computeMemoryHardHash(publickey []byte) []byte {
	var idx1 long
	var idx2 long
	s := unsafe.Sizeof(unit64)
	tmp := make([]byte, s)
	digest := sha512.Sum512(publickey)
	intialdigest := digest
	genmem := make([]byte, ZT_IDENTITY_GEN_MEMORY)
	salsa20.XORKeyStream(genmem[:64], genmem[:64], intialdigest[32:32+24], (*intialdigest)[:32])
	for i := 64; i < ZT_IDENTITY_GEN_MEMORY; i += 64 {
		// genmem[i : i+64] = genmem[i-64 : i]
		// salsa20.XORKeyStream(genmem[i:i+64], genmem[i:i+64], digest[32:32+24], (*digest)[:32])
		salsa20.XORKeyStream(genmem[i:i+64], genmem[i-64:i], initialdigest[32:32+24], (*initialdigest)[:32])
	}
	for i := 0; i < ZT_IDENTITY_GEN_MEMORY/s; {
		idx1 = *(*long)(unsafe.Pointer(genmem[i : i+s])) % (64 / s)
		i++
		idx2 = *(*long)(unsafe.Pointer(genmem[i : i+s])) % (ZT_IDENTITY_GEN_MEMORY / s)
		i++
		tmp = genmem[idx2 : idx2+s]
		genmem[idx2 : idx2+s] = digest[idx1 : idx1+s]
		digest[idx1 : idx1+s] = tmp
		salsa20.XORKeyStream(digest, digest, initialdigest[32:32+24], (*initialdigest)[:32])
	}
	return digest
}

func generateSatisfying(fn func(KeyPair) bool) KeyPair {
	kp := new(KeyPair)
	kp.priv = getPriv()
	kp.pub[32:64] = calcPubED(kp.priv)
	kp.pub[0:31] = calcPubDH(kp.priv)
	for !cond(kp) {
		(([]uint64)(unsafe.Pointer(kv.priv)))[0]++
		(([]uint64)(unsafe.Pointer(kv.priv)))[1]--
		kp.pub[0:31] = calcPubDH(kp.priv)
	}
	return kp

}

func getPriv() []byte {
}

func cond(kp KeyPair) bool {
	digest := computeMemoryHardHash(kp.pub)
	if digest[0] > ZT_IDENTITY_GEN_HASHCASH_FIRST_BYTE_LESS_THAN {
		return false
	}
	return !addressReserved(digest[59:64])
}

func addressReserved(address []byte) bool {
	var a unit64
	binary.LittleEndian.PutUint64(address, a)
	return !a || ((a >> 32) == ZT_ADDRESS_RESERVED_PREFIX)
}

func main() {
	fmt.Println(generateSatisfying(cond))
}