func generateFromPrivate(in PrivateKeyDat, Private string) PrivateKeyDat {
var answer PrivateKeyDat
answer.Error = in.Error
answer.Priv2WIF = []string{}
answer.WIF2Priv = in.WIF2Priv
answer.WIFChecksum = in.WIFChecksum
answer.Minikey = in.Minikey
curve := bitelliptic.S256()
if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(Private)) == false {
if answer.Error == "" {
answer.Error = "Private key is not on curve"
}
answer.Priv2WIF = []string{Private, "", "", "", "", "", ""}
return answer
}
priv := append([]byte{0x80}, mymath.Str2Hex(Private)...)
answer.Priv2WIF = append(answer.Priv2WIF, Private)
answer.Priv2WIF = append(answer.Priv2WIF, mymath.Hex2Str(priv))
sha := mymath.SingleSHA(priv)
answer.Priv2WIF = append(answer.Priv2WIF, mymath.Hex2Str(sha))
sha = mymath.SingleSHA(sha)
answer.Priv2WIF = append(answer.Priv2WIF, mymath.Hex2Str(sha))
answer.Priv2WIF = append(answer.Priv2WIF, mymath.Hex2Str(sha[0:4]))
priv = append(priv, sha[0:4]...)
answer.Priv2WIF = append(answer.Priv2WIF, mymath.Hex2Str(priv))
answer.Priv2WIF = append(answer.Priv2WIF, string(mymath.Hex2Base58(priv)))
return answer
}
func brainwalletTest(w http.ResponseWriter, r *http.Request) {
if r.FormValue("passphrase") != "" {
var data BrainwalletDat
data.Passphrase = r.FormValue("passphrase")
data.PrivateKey = mymath.Hex2Str(mymath.SingleSHA(mymath.ASCII2Hex(data.Passphrase)))
address, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(data.PrivateKey))
data.Address = string(address.Base)
BrainwalletTestTemplate.Execute(w, data)
return
}
BrainwalletTestTemplate.Execute(w, DefaultWallet)
}
func (vd *VanityAllData) Calculate() {
if vd.Private1 != "" {
vd.Public1Uncompressed = mymath.PrivateKeyToUncompressedPublicKey(vd.Private1)
}
if vd.Private2 != "" {
vd.Public2Uncompressed = mymath.PrivateKeyToUncompressedPublicKey(vd.Private2)
}
vd.Public1Compressed = mymath.UncompressedKeyToCompressedKey(vd.Public1Uncompressed)
vd.Public2Compressed = mymath.UncompressedKeyToCompressedKey(vd.Public2Uncompressed)
vd.Public1UncompressedAddress = mymath.PublicKeyToAddress(vd.NetByte, vd.Public1Uncompressed)
vd.Public2UncompressedAddress = mymath.PublicKeyToAddress(vd.NetByte, vd.Public2Uncompressed)
vd.Public1CompressedAddress = mymath.PublicKeyToAddress(vd.NetByte, vd.Public1Compressed)
vd.Public2CompressedAddress = mymath.PublicKeyToAddress(vd.NetByte, vd.Public2Compressed)
if vd.Private1 != "" && vd.Private2 != "" {
vd.PrivateSumUncompressed = mymath.AddPrivateKeysReturnString(vd.Private1, vd.Private2)
vd.PrivateMultUncompressed = mymath.MultiplyPrivateKeysReturnString(vd.Private1, vd.Private2)
vd.PrivateSumCompressed = vd.PrivateSumUncompressed + "01"
vd.PrivateMultCompressed = vd.PrivateMultUncompressed + "01"
prefixByte := mymath.Str2Hex(vd.Prefix)[0]
vd.PrivateSumUncompressedWIF = mymath.PrivateKeyToWIFWithPrefixByte(vd.PrivateSumUncompressed, prefixByte)
vd.PrivateMultUncompressedWIF = mymath.PrivateKeyToWIFWithPrefixByte(vd.PrivateMultUncompressed, prefixByte)
vd.PrivateSumCompressedWIF = mymath.PrivateKeyToWIFWithPrefixByte(vd.PrivateSumCompressed, prefixByte)
vd.PrivateMultCompressedWIF = mymath.PrivateKeyToWIFWithPrefixByte(vd.PrivateMultCompressed, prefixByte)
vd.PublicSumUncompressed = mymath.PrivateKeyToUncompressedPublicKey(vd.PrivateSumUncompressed)
vd.PublicMultUncompressed = mymath.PrivateKeyToUncompressedPublicKey(vd.PrivateMultUncompressed)
} else {
vd.PrivateSumUncompressed = "??"
vd.PrivateMultUncompressed = "??"
vd.PrivateSumUncompressedWIF = "??"
vd.PrivateMultUncompressedWIF = "??"
vd.PrivateSumCompressed = "??"
vd.PrivateMultCompressed = "??"
vd.PrivateSumCompressedWIF = "??"
vd.PrivateMultCompressedWIF = "??"
log.Printf("vd.Public1Uncompressed - %v, vd.Public2Uncompressed - %v", vd.Public1Uncompressed, vd.Public2Uncompressed)
vd.PublicSumUncompressed = mymath.AddPublicKeysReturnString(vd.Public1Uncompressed, vd.Public2Uncompressed)
if vd.Private1 != "" {
vd.PublicMultUncompressed = mymath.MultiplyPrivateAndPublicKeyReturnString(vd.Private1, vd.Public2Uncompressed)
}
if vd.Private2 != "" {
vd.PublicMultUncompressed = mymath.MultiplyPrivateAndPublicKeyReturnString(vd.Private2, vd.Public1Uncompressed)
}
}
vd.PublicSumUncompressedAddress = mymath.PublicKeyToAddress(vd.NetByte, vd.PublicSumUncompressed)
vd.PublicSumCompressed = mymath.UncompressedKeyToCompressedKey(vd.PublicSumUncompressed)
vd.PublicSumCompressedAddress = mymath.PublicKeyToAddress(vd.NetByte, vd.PublicSumCompressed)
if vd.PublicMultUncompressed != "" {
vd.PublicMultUncompressedAddress = mymath.PublicKeyToAddress(vd.NetByte, vd.PublicMultUncompressed)
vd.PublicMultCompressed = mymath.UncompressedKeyToCompressedKey(vd.PublicMultUncompressed)
vd.PublicMultCompressedAddress = mymath.PublicKeyToAddress(vd.NetByte, vd.PublicMultCompressed)
} else {
vd.PublicMultUncompressed = "??"
vd.PublicMultUncompressedAddress = "??"
vd.PublicMultCompressed = "??"
vd.PublicMultCompressedAddress = "??"
}
}
func vanityMultTest(w http.ResponseWriter, r *http.Request) {
curve := bitelliptic.S256()
if r.FormValue("Random") != "" {
vd := new(VanityMultData)
priv, gx, gy, _ := curve.GenerateKey(rand.Reader)
vd.Private1 = mymath.Hex2Str(priv)
one, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private1))
vd.Public1 = mymath.Hex2Str(one.PublicKey)
curve2 := curve.Copy()
curve2.Gx = gx
curve2.Gy = gy
priv, _, _, _ = curve2.GenerateKey(rand.Reader)
vd.Private2 = mymath.Hex2Str(priv)
two, _ := mymath.NewAddressFromPrivateKeyWithCurve(mymath.Str2Hex(vd.Private2), curve2)
vd.Public2 = mymath.Hex2Str(two.PublicKey)
vd.Public2Address = string(two.Base)
vd.PrivateMult = mymath.Hex2Str(mymath.Big2Hex(mymath.MultiplyPrivateKeys(vd.Private1, vd.Private2)))
zero, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.PrivateMult))
vd.PrivateMultPublic = mymath.Hex2Str(zero.PublicKey)
vd.PrivateMultAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PrivateMultPublic)).Base)
VanityMultTestTemplate.Execute(w, vd)
return
} else if r.FormValue("Private") != "" {
vd := new(VanityMultData)
if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(r.FormValue("Private1"))) != true {
vd.Error = "Private key 1 is invalid"
} else {
priv1, _ := bitecdsa.GenerateFromPrivateKey(mymath.Str2Big(r.FormValue("Private1")), curve)
vd.Private1 = mymath.Hex2Str(mymath.Big2Hex(priv1.D))
one, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private1))
vd.Public1 = mymath.Hex2Str(one.PublicKey)
curve2 := curve.Copy()
curve2.Gx = priv1.PublicKey.X
curve2.Gy = priv1.PublicKey.Y
if bitecdsa.CheckIsOnCurve(curve2, mymath.Str2Big(r.FormValue("Private2"))) != true {
vd.Error = "Private key 2 is invalid"
} else {
priv2, _ := bitecdsa.GenerateFromPrivateKey(mymath.Str2Big(r.FormValue("Private2")), curve2)
vd.Private2 = mymath.Hex2Str(mymath.Big2Hex(priv2.D))
two, _ := mymath.NewAddressFromPrivateKeyWithCurve(mymath.Str2Hex(vd.Private2), curve2)
vd.Public2 = mymath.Hex2Str(two.PublicKey)
vd.Public2Address = string(two.Base)
vd.PrivateMult = mymath.Hex2Str(mymath.Big2Hex(mymath.MultiplyPrivateKeys(vd.Private1, vd.Private2)))
zero, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.PrivateMult))
vd.PrivateMultPublic = mymath.Hex2Str(zero.PublicKey)
vd.PrivateMultAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PrivateMultPublic)).Base)
}
}
VanityMultTestTemplate.Execute(w, vd)
return
} else if r.FormValue("Public") != "" {
vd := new(VanityMultData)
vd.Public1 = r.FormValue("Public1")
if len(vd.Public1) != 130 {
vd.Error = "Public key is invalid"
} else if vd.Public1[0] != '0' || vd.Public1[1] != '4' {
vd.Error = "Public key is invalid"
} else {
gx, gy := mymath.PublicKeyToPointCoordinates(vd.Public1)
curve2 := curve.Copy()
curve2.Gx = gx
curve2.Gy = gy
vd.Private1 = ""
if bitecdsa.CheckIsOnCurve(curve2, mymath.Str2Big(r.FormValue("Private2"))) != true {
vd.Error = "Private key is invalid"
} else {
priv2, _ := bitecdsa.GenerateFromPrivateKey(mymath.Str2Big(r.FormValue("Private2")), curve2)
vd.Private2 = mymath.Hex2Str(mymath.Big2Hex(priv2.D))
two, _ := mymath.NewAddressFromPrivateKeyWithCurve(mymath.Str2Hex(vd.Private2), curve2)
vd.Public2 = mymath.Hex2Str(two.PublicKey)
vd.Public2Address = string(two.Base)
vd.PrivateMult = "??"
vd.PrivateMultPublic = "??"
vd.PrivateMultAddress = "??"
}
}
VanityMultTestTemplate.Execute(w, vd)
return
} else {
VanityMultTestTemplate.Execute(w, DefaultVanityMultData)
}
}
func vanitySumTest(w http.ResponseWriter, r *http.Request) {
if r.FormValue("Random") != "" {
vd := new(VanitySumData)
curve := bitelliptic.S256()
priv, _, _, _ := curve.GenerateKey(rand.Reader)
vd.Private1 = mymath.Hex2Str(priv)
priv, _, _, _ = curve.GenerateKey(rand.Reader)
vd.Private2 = mymath.Hex2Str(priv)
vd.PrivateSum = mymath.Hex2Str(mymath.Big2Hex(mymath.AddPrivateKeys(vd.Private1, vd.Private2)))
zero, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.PrivateSum))
vd.PrivateSumPublic = mymath.Hex2Str(zero.PublicKey)
vd.PrivateSumAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PrivateSumPublic)).Base)
one, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private1))
two, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private2))
vd.Public1 = mymath.Hex2Str(one.PublicKey)
vd.Public2 = mymath.Hex2Str(two.PublicKey)
a, b := mymath.AddPublicKeys(vd.Public1, vd.Public2)
vd.PublicSum = "04" + mymath.Hex2Str(mymath.Big2HexPadded(a, 32)) + mymath.Hex2Str(mymath.Big2HexPadded(b, 32))
vd.PublicAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PublicSum)).Base)
VanitySumTestTemplate.Execute(w, vd)
} else if r.FormValue("Private") != "" {
vd := new(VanitySumData)
vd.Private1 = r.FormValue("Private1")
vd.Private2 = r.FormValue("Private2")
curve := bitelliptic.S256()
if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private1)) == false || bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private2)) == false {
if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private1)) == false && bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private2)) == false {
vd.Error = "Both private keys appear to be invalid"
} else if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private1)) == false {
vd.Error = fmt.Sprintf("Private key one (%s) appears to be invalid", vd.Private1)
} else if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private2)) == false {
vd.Error = fmt.Sprintf("Private key two (%s) appears to be invalid", vd.Private2)
} else {
vd.Error = "One of the private keys is invalid, but we can't figure out which (this is an unexpected server behaviour)."
}
} else {
vd.PrivateSum = mymath.Hex2Str(mymath.Big2Hex(mymath.AddPrivateKeys(vd.Private1, vd.Private2)))
zero, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.PrivateSum))
vd.PrivateSumPublic = mymath.Hex2Str(zero.PublicKey)
vd.PrivateSumAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PrivateSumPublic)).Base)
one, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private1))
two, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private2))
vd.Public1 = mymath.Hex2Str(one.PublicKey)
vd.Public2 = mymath.Hex2Str(two.PublicKey)
a, b := mymath.AddPublicKeys(vd.Public1, vd.Public2)
vd.PublicSum = "04" + mymath.Hex2Str(mymath.Big2HexPadded(a, 32)) + mymath.Hex2Str(mymath.Big2HexPadded(b, 32))
vd.PublicAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PublicSum)).Base)
}
VanitySumTestTemplate.Execute(w, vd)
} else if r.FormValue("Public") != "" {
vd := new(VanitySumData)
vd.Public1 = r.FormValue("Public1")
vd.Public2 = r.FormValue("Public2")
if len(vd.Public1) != 130 || len(vd.Public2) != 130 {
vd.Error = "Public keys are invalid"
} else if vd.Public1[0] != '0' || vd.Public1[1] != '4' || vd.Public2[0] != '0' || vd.Public2[1] != '4' {
vd.Error = "Public keys are invalid"
} else {
a, b := mymath.AddPublicKeys(vd.Public1, vd.Public2)
vd.PublicSum = "04" + mymath.Hex2Str(mymath.Big2HexPadded(a, 32)) + mymath.Hex2Str(mymath.Big2HexPadded(b, 32))
vd.PublicAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PublicSum)).Base)
}
VanitySumTestTemplate.Execute(w, vd)
} else {
VanitySumTestTemplate.Execute(w, DefaultVanitySumData)
}
}
func addressTest(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
if r.FormValue("Random") != "" {
var address AddressDat
curve := bitelliptic.S256()
priv, x, y, _ := curve.GenerateKey(rand.Reader)
pub := append(append([]byte{0x04}, mymath.Big2HexWithMinimumLength(x, 32)...), mymath.Big2HexWithMinimumLength(y, 32)...)
//pub=mymath.Str2Hex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f")
st2 := mymath.SingleSHA(pub)
st3 := mymath.Ripemd(st2)
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
st8 := append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
address.HashString = []string{
mymath.Hex2Str(priv),
mymath.Hex2Str(pub),
mymath.Hex2Str(st2),
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else if r.FormValue("private") != "" {
var err error
var address AddressDat
curve := bitelliptic.S256()
privs, err := bitecdsa.GenerateFromPrivateKey(mymath.Str2Big(r.FormValue("private")), curve)
if err != nil {
if err.Error() == "Private key is not on curve" {
address = DefaultAddress
address.Error = "Private key is not on curve"
AddressTestTemplate.Execute(w, address)
} else {
c.Errorf("Err ", err)
return
}
} else {
priv := mymath.Big2Hex(privs.D)
x := privs.PublicKey.X
y := privs.PublicKey.Y
//priv, x, y, _:=curve.GenerateKey(rand.Reader)
pub := append(append([]byte{0x04}, mymath.Big2HexWithMinimumLength(x, 32)...), mymath.Big2HexWithMinimumLength(y, 32)...)
st2 := mymath.SingleSHA(pub)
st3 := mymath.Ripemd(st2)
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
st8 := append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
address.HashString = []string{
mymath.Hex2Str(priv),
mymath.Hex2Str(pub),
mymath.Hex2Str(st2),
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
}
} else if r.FormValue("public") != "" {
var address AddressDat
pub := mymath.Str2Hex(r.FormValue("public"))
if len(pub) != 65 {
address.Error = "Invalid public key length"
} else if pub[0] != 0x04 {
address.Error = "Invalid public key format"
}
st2 := mymath.SingleSHA(pub)
st3 := mymath.Ripemd(st2)
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
st8 := append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
address.HashString = []string{
"",
mymath.Hex2Str(pub),
mymath.Hex2Str(st2),
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else if r.FormValue("RIPEMD") != "" {
var address AddressDat
st3 := mymath.Str2Hex(r.FormValue("RIPEMD"))
if len(st3) != 20 {
address.Error = "Invalid RIPEMD-160 length"
}
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
st8 := append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
address.HashString = []string{
"", "", "",
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else if r.FormValue("RIPEMDWithHash") != "" {
var address AddressDat
st4 := mymath.Str2Hex(r.FormValue("RIPEMDWithHash"))
if len(st4) != 21 {
address.Error = "Invalid RIPEMD-160 length"
}
st3 := st4[1:]
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
st8 := append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
address.HashString = []string{
"", "", "",
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else if r.FormValue("FullAddress") != "" {
var address AddressDat
st8 := mymath.Str2Hex(r.FormValue("FullAddress"))
if len(st8) != 25 {
address.Error = "Invalid address length"
c.Debugf("%d", len(st8))
}
st3 := st8[1:21]
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
//st8:=append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
if len(st8) == 25 {
if st7[3] != st8[24] || st7[2] != st8[23] || st7[1] != st8[22] || st7[0] != st8[21] {
address.Error = "Invalid checksum"
}
}
address.HashString = []string{
"", "", "",
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else if r.FormValue("Base58") != "" {
var address AddressDat
st9 := r.FormValue("Base58")
st8 := mymath.Base582Hex(st9)
if len(st8) != 25 {
address.Error = "Invalid address length"
c.Debugf("%d", len(st8))
}
st3 := st8[1:21]
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
//st8:=append(st4[:], st7[:]...)
//st9:=mymath.Hex2Base58(st8)
if len(st8) == 25 {
if st7[3] != st8[24] || st7[2] != st8[23] || st7[1] != st8[22] || st7[0] != st8[21] {
address.Error = "Invalid checksum"
}
}
address.HashString = []string{
"", "", "",
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else {
AddressTestTemplate.Execute(w, DefaultAddress)
}
}