func main() {
var testnet bool
if len(os.Args) < 3 {
fmt.Println("Specify secret, public_key and optionaly number of addresses you want.")
fmt.Println("Use a negative value for number of addresses, to work with Testnet addresses.")
return
}
public_key, er := hex.DecodeString(os.Args[2])
if er != nil {
println("Error parsing public_key:", er.Error())
os.Exit(1)
}
if len(public_key) == 33 && (public_key[0] == 2 || public_key[0] == 3) {
fmt.Println("Compressed")
} else if len(public_key) == 65 && (public_key[0] == 4) {
fmt.Println("Uncompressed")
} else {
println("Incorrect public key")
}
secret, er := hex.DecodeString(os.Args[1])
if er != nil {
println("Error parsing secret:", er.Error())
os.Exit(1)
}
n := int64(25)
if len(os.Args) > 3 {
n, er = strconv.ParseInt(os.Args[3], 10, 32)
if er != nil {
println("Error parsing number of keys value:", er.Error())
os.Exit(1)
}
if n == 0 {
return
}
if n < 0 {
n = -n
testnet = true
}
}
fmt.Println("# Type-2")
fmt.Println("#", hex.EncodeToString(public_key))
fmt.Println("#", hex.EncodeToString(secret))
for i := 1; i <= int(n); i++ {
fmt.Println(btc.NewAddrFromPubkey(public_key, btc.AddrVerPubkey(testnet)).String(), "TypB", i)
if i >= int(n) {
break
}
public_key = btc.DeriveNextPublic(public_key, secret)
}
}
func listarmkeys(p string) {
if p != "seed" {
if len(wallet.StealthSecrets) > 0 {
fmt.Println("Persistent secret scan keys:")
for i := range wallet.StealthSecrets {
pk := btc.PublicFromPrivate(wallet.StealthSecrets[i], true)
fmt.Print(" #", i, " ", hex.EncodeToString(pk))
if p == "addr" {
fmt.Print(" ", btc.NewAddrFromPubkey(pk, btc.AddrVerPubkey(common.Testnet)).String())
}
fmt.Println()
}
} else {
fmt.Println("You have no persistent secret scan keys")
}
}
if p != "file" {
if len(wallet.ArmedStealthSecrets) > 0 {
fmt.Println("Volatile secret scan keys:")
for i := range wallet.ArmedStealthSecrets {
pk := btc.PublicFromPrivate(wallet.ArmedStealthSecrets[i], true)
fmt.Print(" #", i, " ", hex.EncodeToString(pk))
if p == "addr" {
fmt.Print(" ", btc.NewAddrFromPubkey(pk, btc.AddrVerPubkey(common.Testnet)).String())
}
if p == "save" {
fn := common.GocoinHomeDir + "wallet/stealth/" + hex.EncodeToString(pk)
if fi, er := os.Stat(fn); er == nil && fi.Size() >= 32 {
fmt.Print(" already on disk")
} else {
ioutil.WriteFile(fn, wallet.ArmedStealthSecrets[i], 0600)
fmt.Print(" saved")
}
sys.ClearBuffer(wallet.ArmedStealthSecrets[i])
}
fmt.Println()
}
} else {
fmt.Println("You have no volatile secret scan keys")
}
}
if p == "save" {
wallet.ArmedStealthSecrets = nil
wallet.FetchStealthKeys()
}
}
func main() {
if len(os.Args) < 3 {
fmt.Println("Specify secret and public_key to get the next Type-2 deterministic address")
fmt.Println("Add -t as the third argument to work with Testnet addresses.")
return
}
public_key, er := hex.DecodeString(os.Args[2])
if er != nil {
println("Error parsing public_key:", er.Error())
os.Exit(1)
}
if len(public_key) == 33 && (public_key[0] == 2 || public_key[0] == 3) {
fmt.Println("Compressed")
} else if len(public_key) == 65 && (public_key[0] == 4) {
fmt.Println("Uncompressed")
} else {
println("Incorrect public key")
}
secret, er := hex.DecodeString(os.Args[1])
if er != nil {
println("Error parsing secret:", er.Error())
os.Exit(1)
}
testnet := len(os.Args) > 3 && os.Args[3] == "-t"
// Old address
public_key = btc.DeriveNextPublic(public_key, secret)
// New address
fmt.Println(btc.NewAddrFromPubkey(public_key, btc.AddrVerPubkey(testnet)).String())
// New key
fmt.Println(hex.EncodeToString(public_key))
}
func main() {
var msg []byte
flag.Parse()
if *help || *addr == "" || *sign == "" {
flag.PrintDefaults()
return
}
ad, er := btc.NewAddrFromString(*addr)
if !*litecoin && ad != nil && ad.Version == ltc.AddrVerPubkey(false) {
*litecoin = true
}
if er != nil {
println("Address:", er.Error())
flag.PrintDefaults()
return
}
nv, btcsig, er := btc.ParseMessageSignature(*sign)
if er != nil {
println("ParseMessageSignature:", er.Error())
return
}
if *mess != "" {
msg = []byte(*mess)
} else if *mfil != "" {
msg, er = ioutil.ReadFile(*mfil)
if er != nil {
println(er.Error())
return
}
} else {
if *verb {
fmt.Println("Enter the message:")
}
msg, _ = ioutil.ReadAll(os.Stdin)
}
if *unix {
if *verb {
fmt.Println("Enforcing Unix text format")
}
msg = bytes.Replace(msg, []byte{'\r'}, nil, -1)
}
hash := make([]byte, 32)
if *litecoin {
ltc.HashFromMessage(msg, hash)
} else {
btc.HashFromMessage(msg, hash)
}
compressed := false
if nv >= 31 {
if *verb {
fmt.Println("compressed key")
}
nv -= 4
compressed = true
}
pub := btcsig.RecoverPublicKey(hash[:], int(nv-27))
if pub != nil {
pk := pub.Bytes(compressed)
ok := btc.EcdsaVerify(pk, btcsig.Bytes(), hash)
if ok {
sa := btc.NewAddrFromPubkey(pk, ad.Version)
if ad.Hash160 != sa.Hash160 {
fmt.Println("BAD signature for", ad.String())
if bytes.IndexByte(msg, '\r') != -1 {
fmt.Println("You have CR chars in the message. Try to verify with -u switch.")
}
os.Exit(1)
} else {
fmt.Println("Signature OK")
}
} else {
println("BAD signature")
os.Exit(1)
}
} else {
println("BAD, BAD, BAD signature")
os.Exit(1)
}
}
/*
{
"address" : "2NAHUDSC1EmbTBwQQp4VQ2FNzWDqHtmk1i6",
"redeemScript" : "512102cdc4fff0ad031ea5f2d0d4337e2bf976b84334f8f80b08fe3f69886d58bc5a8a2102ebf54926d3edaae51bde71f2976948559a8d43fce52f5e7ed9ed85dbaa449d7f52ae"
}
*/
func main() {
var testnet bool
if len(os.Args) < 3 {
fmt.Println("Specify one integer and at least one public key.")
fmt.Println("For Testent, make the integer negative.")
return
}
cnt, er := strconv.ParseInt(os.Args[1], 10, 32)
if er != nil {
println("Count value:", er.Error())
return
}
if cnt < 0 {
testnet = true
cnt = -cnt
}
if cnt < 1 || cnt > 16 {
println("The integer (required number of keys) must be between 1 and 16")
return
}
buf := new(bytes.Buffer)
buf.WriteByte(byte(0x50 + cnt))
fmt.Println("Trying to prepare multisig address for", cnt, "out of", len(os.Args)-2, "public keys ...")
var pkeys byte
var ads string
for i := 2; i < len(os.Args); i++ {
if pkeys == 16 {
println("Oh, give me a break. You don't need more than 16 public keys - stopping here!")
break
}
d, er := hex.DecodeString(os.Args[i])
if er != nil {
println("pubkey", i, er.Error())
}
_, er = btc.NewPublicKey(d)
if er != nil {
println("pubkey", i, er.Error())
return
}
pkeys++
buf.WriteByte(byte(len(d)))
buf.Write(d)
if ads != "" {
ads += ", "
}
ads += "\"" + btc.NewAddrFromPubkey(d, btc.AddrVerPubkey(testnet)).String() + "\""
}
buf.WriteByte(0x50 + pkeys)
buf.WriteByte(0xae)
p2sh := buf.Bytes()
addr := btc.NewAddrFromPubkey(p2sh, btc.AddrVerScript(testnet))
rec := "{\n"
rec += fmt.Sprintf("\t\"multiAddress\" : \"%s\",\n", addr.String())
rec += fmt.Sprintf("\t\"scriptPubKey\" : \"a914%s87\",\n", hex.EncodeToString(addr.Hash160[:]))
rec += fmt.Sprintf("\t\"keysRequired\" : %d,\n", cnt)
rec += fmt.Sprintf("\t\"keysProvided\" : %d,\n", pkeys)
rec += fmt.Sprintf("\t\"redeemScript\" : \"%s\",\n", hex.EncodeToString(p2sh))
rec += fmt.Sprintf("\t\"listOfAddres\" : [%s]\n", ads)
rec += "}\n"
fname := addr.String() + ".json"
ioutil.WriteFile(fname, []byte(rec), 0666)
fmt.Println("The address record stored in", fname)
}
// this function signs either a message or a raw hash
func sign_message() {
var hash []byte
var signkey *btc.PrivateAddr
signkey = address_to_key(*signaddr)
if signkey == nil {
println("You do not have a private key for", *signaddr)
return
}
if *signhash != "" {
hash, er := hex.DecodeString(*signhash)
if er != nil {
println("Incorrect content of -hash parameter")
println(er.Error())
return
} else if len(hash) > 0 {
txsig := new(btc.Signature)
txsig.HashType = 0x01
r, s, e := btc.EcdsaSign(signkey.Key, hash)
if e != nil {
println(e.Error())
return
}
txsig.R.Set(r)
txsig.S.Set(s)
fmt.Println("PublicKey:", hex.EncodeToString(signkey.BtcAddr.Pubkey))
fmt.Println(hex.EncodeToString(txsig.Bytes()))
return
}
}
var msg []byte
if *message == "" {
msg, _ = ioutil.ReadAll(os.Stdin)
} else {
msg = []byte(*message)
}
hash = make([]byte, 32)
if litecoin {
ltc.HashFromMessage(msg, hash)
} else {
btc.HashFromMessage(msg, hash)
}
btcsig := new(btc.Signature)
var sb [65]byte
sb[0] = 27
if signkey.IsCompressed() {
sb[0] += 4
}
r, s, e := btc.EcdsaSign(signkey.Key, hash)
if e != nil {
println(e.Error())
return
}
btcsig.R.Set(r)
btcsig.S.Set(s)
rd := btcsig.R.Bytes()
sd := btcsig.S.Bytes()
copy(sb[1+32-len(rd):], rd)
copy(sb[1+64-len(sd):], sd)
rpk := btcsig.RecoverPublicKey(hash[:], 0)
sa := btc.NewAddrFromPubkey(rpk.Bytes(signkey.IsCompressed()), signkey.BtcAddr.Version)
if sa.Hash160 == signkey.BtcAddr.Hash160 {
fmt.Println(base64.StdEncoding.EncodeToString(sb[:]))
return
}
rpk = btcsig.RecoverPublicKey(hash[:], 1)
sa = btc.NewAddrFromPubkey(rpk.Bytes(signkey.IsCompressed()), signkey.BtcAddr.Version)
if sa.Hash160 == signkey.BtcAddr.Hash160 {
sb[0]++
fmt.Println(base64.StdEncoding.EncodeToString(sb[:]))
return
}
println("Something went wrong. The message has not been signed.")
}