本文整理汇总了Golang中crypto/ecdsa.PrivateKey.D方法的典型用法代码示例。如果您正苦于以下问题:Golang PrivateKey.D方法的具体用法?Golang PrivateKey.D怎么用?Golang PrivateKey.D使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类crypto/ecdsa.PrivateKey
的用法示例。
在下文中一共展示了PrivateKey.D方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: parseECPrivateKey
// parseECPrivateKey parses an ASN.1 Elliptic Curve Private Key Structure.
// The OID for the named curve may be provided from another source (such as
// the PKCS8 container) - if it is provided then use this instead of the OID
// that may exist in the EC private key structure.
func parseECPrivateKey(namedCurveOID *asn1.ObjectIdentifier, der []byte) (key *ecdsa.PrivateKey, err error) {
var privKey ecPrivateKey
if _, err := asn1.Unmarshal(der, &privKey); err != nil {
return nil, errors.New("x509: failed to parse EC private key: " + err.Error())
}
if privKey.Version != ecPrivKeyVersion {
return nil, fmt.Errorf("x509: unknown EC private key version %d", privKey.Version)
}
var curve elliptic.Curve
if namedCurveOID != nil {
curve = namedCurveFromOID(*namedCurveOID)
} else {
curve = namedCurveFromOID(privKey.NamedCurveOID)
}
if curve == nil {
return nil, errors.New("x509: unknown elliptic curve")
}
k := new(big.Int).SetBytes(privKey.PrivateKey)
if k.Cmp(curve.Params().N) >= 0 {
return nil, errors.New("x509: invalid elliptic curve private key value")
}
priv := new(ecdsa.PrivateKey)
priv.Curve = curve
priv.D = k
priv.X, priv.Y = curve.ScalarBaseMult(privKey.PrivateKey)
return priv, nil
}
示例2: VerifyKeyPair
// Verify the secret key's range and if a test message signed with it verifies OK
// Returns nil if averything looks OK
func VerifyKeyPair(priv []byte, publ []byte) error {
const TestMessage = "Just some test message..."
hash := Sha2Sum([]byte(TestMessage))
pub_key, e := NewPublicKey(publ)
if e != nil {
return e
}
var key ecdsa.PrivateKey
key.D = new(big.Int).SetBytes(priv)
key.PublicKey = pub_key.PublicKey
if key.D.Cmp(big.NewInt(0)) == 0 {
return errors.New("pubkey value is zero")
}
if key.D.Cmp(secp256k1.N) != -1 {
return errors.New("pubkey value is too big")
}
r, s, err := ecdsa.Sign(rand.Reader, &key, hash[:])
if err != nil {
return errors.New("ecdsa.Sign failed: " + err.Error())
}
ok := ecdsa.Verify(&key.PublicKey, hash[:], r, s)
if !ok {
return errors.New("ecdsa.Sign Verify")
}
return nil
}
示例3: Sign
// Signs a specified transaction input
func (tx *Tx) Sign(in int, pk_script []byte, hash_type byte, pubkey, priv_key []byte) error {
if in >= len(tx.TxIn) {
return errors.New("tx.Sign() - input index overflow")
}
pub_key, er := NewPublicKey(pubkey)
if er != nil {
return er
}
// Load the key (private and public)
var key ecdsa.PrivateKey
key.D = new(big.Int).SetBytes(priv_key)
key.PublicKey = pub_key.PublicKey
//Calculate proper transaction hash
h := tx.SignatureHash(pk_script, in, hash_type)
// Sign
r, s, er := EcdsaSign(&key, h)
if er != nil {
return er
}
rb := r.Bytes()
sb := s.Bytes()
if rb[0] >= 0x80 {
rb = append([]byte{0x00}, rb...)
}
if sb[0] >= 0x80 {
sb = append([]byte{0x00}, sb...)
}
// Output the signing result into a buffer, in format expected by bitcoin protocol
busig := new(bytes.Buffer)
busig.WriteByte(0x30)
busig.WriteByte(byte(4 + len(rb) + len(sb)))
busig.WriteByte(0x02)
busig.WriteByte(byte(len(rb)))
busig.Write(rb)
busig.WriteByte(0x02)
busig.WriteByte(byte(len(sb)))
busig.Write(sb)
busig.WriteByte(0x01) // hash type
// Output the signature and the public key into tx.ScriptSig
buscr := new(bytes.Buffer)
buscr.WriteByte(byte(busig.Len()))
buscr.Write(busig.Bytes())
buscr.WriteByte(byte(len(pubkey)))
buscr.Write(pubkey)
// assign sign script ot the tx:
tx.TxIn[in].ScriptSig = buscr.Bytes()
return nil // no error
}
示例4: ToECDSA
// New methods using proper ecdsa keys from the stdlib
func ToECDSA(prv []byte) *ecdsa.PrivateKey {
if len(prv) == 0 {
return nil
}
priv := new(ecdsa.PrivateKey)
priv.PublicKey.Curve = secp256k1.S256()
priv.D = common.BigD(prv)
priv.PublicKey.X, priv.PublicKey.Y = secp256k1.S256().ScalarBaseMult(prv)
return priv
}
示例5: UnmarshalCertificate
func UnmarshalCertificate(data []byte) Certificate {
priv := new(big.Int).SetBytes(data[:28])
pub := UnmarshalPublicCertificate(data[28:])
cert := new(ecdsa.PrivateKey)
cert.D = priv
cert.PublicKey = *pub
return cert
}
示例6: DecodeECDSAPrivateKey
func DecodeECDSAPrivateKey(b []byte) (*ecdsa.PrivateKey, error) {
var p []big.Int
buf := bytes.NewBuffer(b)
dec := gob.NewDecoder(buf)
err := dec.Decode(&p)
if err != nil {
return nil, err
}
privateKey := new(ecdsa.PrivateKey)
privateKey.PublicKey.Curve = btcec.S256()
privateKey.PublicKey.X = &p[0]
privateKey.PublicKey.Y = &p[1]
privateKey.D = &p[2]
return privateKey, nil
}
示例7: parseECPrivateKey
// parseECPrivateKey parses an ASN.1 Elliptic Curve Private Key Structure.
// The OID for the named curve may be provided from another source (such as
// the PKCS8 container) - if it is provided then use this instead of the OID
// that may exist in the EC private key structure.
func parseECPrivateKey(namedCurveOID *asn1.ObjectIdentifier, der []byte) (key *ecdsa.PrivateKey, err error) {
var privKey ecPrivateKey
if _, err := asn1.Unmarshal(der, &privKey); err != nil {
return nil, errors.New("x509: failed to parse EC private key: " + err.Error())
}
if privKey.Version != ecPrivKeyVersion {
return nil, fmt.Errorf("x509: unknown EC private key version %d", privKey.Version)
}
var curve elliptic.Curve
if namedCurveOID != nil {
curve = namedCurveFromOID(*namedCurveOID)
} else {
curve = namedCurveFromOID(privKey.NamedCurveOID)
}
if curve == nil {
return nil, errors.New("x509: unknown elliptic curve")
}
k := new(big.Int).SetBytes(privKey.PrivateKey)
curveOrder := curve.Params().N
if k.Cmp(curveOrder) >= 0 {
return nil, errors.New("x509: invalid elliptic curve private key value")
}
priv := new(ecdsa.PrivateKey)
priv.Curve = curve
priv.D = k
privateKey := make([]byte, (curveOrder.BitLen()+7)/8)
// Some private keys have leading zero padding. This is invalid
// according to [SEC1], but this code will ignore it.
for len(privKey.PrivateKey) > len(privateKey) {
if privKey.PrivateKey[0] != 0 {
return nil, errors.New("x509: invalid private key length")
}
privKey.PrivateKey = privKey.PrivateKey[1:]
}
// Some private keys remove all leading zeros, this is also invalid
// according to [SEC1] but since OpenSSL used to do this, we ignore
// this too.
copy(privateKey[len(privateKey)-len(privKey.PrivateKey):], privKey.PrivateKey)
priv.X, priv.Y = curve.ScalarBaseMult(privateKey)
return priv, nil
}
示例8: readPrivateKeyECDSA
func readPrivateKeyECDSA(m map[string]string) (PrivateKey, error) {
p := new(ecdsa.PrivateKey)
p.D = big.NewInt(0)
// TODO: validate that the required flags are present
for k, v := range m {
switch k {
case "privatekey":
v1, err := fromBase64([]byte(v))
if err != nil {
return nil, err
}
p.D.SetBytes(v1)
case "created", "publish", "activate":
/* not used in Go (yet) */
}
}
return p, nil
}
示例9: parseECDSAPrivateKey
func (pk *PrivateKey) parseECDSAPrivateKey(data []byte) (err error) {
ecdsaPub := pk.PublicKey.PublicKey.(*ecdsa.PublicKey)
ecdsaPriv := new(ecdsa.PrivateKey)
ecdsaPriv.PublicKey = *ecdsaPub
buf := bytes.NewBuffer(data)
d, _, err := readMPI(buf)
if err != nil {
return
}
ecdsaPriv.D = new(big.Int).SetBytes(d)
pk.PrivateKey = ecdsaPriv
pk.Encrypted = false
pk.encryptedData = nil
return nil
}
示例10: readPrivateKeyECDSA
func (k *RR_DNSKEY) readPrivateKeyECDSA(kv map[string]string) (PrivateKey, os.Error) {
p := new(ecdsa.PrivateKey)
p.D = big.NewInt(0)
// Need to check if we have everything
for k, v := range kv {
switch k {
case "privatekey:":
v1, err := packBase64([]byte(v))
if err != nil {
return nil, err
}
p.D.SetBytes(v1)
case "created:", "publish:", "activate:":
/* not used in Go (yet) */
}
}
return p, nil
}
示例11: verify_key
// Verify the secret key's range and al if a test message signed with it verifies OK
func verify_key(priv []byte, publ []byte) bool {
const TestMessage = "Just some test message..."
hash := btc.Sha2Sum([]byte(TestMessage))
pub_key, e := btc.NewPublicKey(publ)
if e != nil {
println("NewPublicKey:", e.Error(), "\007")
os.Exit(1)
}
var key ecdsa.PrivateKey
key.D = new(big.Int).SetBytes(priv)
key.PublicKey = pub_key.PublicKey
if key.D.Cmp(big.NewInt(0)) == 0 {
println("pubkey value is zero")
return false
}
if key.D.Cmp(maxKeyVal) != -1 {
println("pubkey value is too big", hex.EncodeToString(publ))
return false
}
r, s, err := ecdsa.Sign(rand.Reader, &key, hash[:])
if err != nil {
println("ecdsa.Sign:", err.Error())
return false
}
ok := ecdsa.Verify(&key.PublicKey, hash[:], r, s)
if !ok {
println("The key pair does not verify!")
return false
}
return true
}
示例12: main
func main() {
id1 := "99375318-11c4-4a77-ba42-f7c08ca7b9d0"
id2 := "ff375318-11c4-4a77-ba42-f7c08ca7b9d0"
privkeyHex, err := ioutil.ReadFile(".gn_ecdsa")
if err != nil {
panic(err)
}
privkey, err := hex.DecodeString(string(privkeyHex[:len(privkeyHex)-1]))
if err != nil {
panic(err)
}
key := new(ecdsa.PrivateKey)
key.D = big.NewInt(0)
key.D.SetBytes(privkey)
key.PublicKey.Curve = elliptic.P256()
xb, _ := hex.DecodeString("212d26c6744803803e2f81fa117630a72eaf8a7c12f16e4e1b0188785a57c783256")
x := big.NewInt(0)
x.SetBytes(xb)
key.PublicKey.X = x
yb, _ := hex.DecodeString("b0802aac16e521569f549092c41c1b295e9ff627534d1b28fe050a37f5280ac9255")
y := big.NewInt(0)
y.SetBytes(yb)
key.PublicKey.Y = y
ids := map[string]*ecdsa.PublicKey{
id1: &key.PublicKey,
id2: &key.PublicKey,
}
node1 := gophernet.NewNode(id1, key, 100, ids)
node2 := gophernet.NewNode(id2, key, 100, ids)
errChan := make(chan error)
stopChan := make(chan struct{})
msgChan1 := make(chan *gophernet.Message, 1)
msgChan2 := make(chan *gophernet.Message, 1)
go gophernet.Listen(node1, ":7890", errChan, stopChan, msgChan1)
go gophernet.Listen(node2, ":7891", errChan, stopChan, msgChan2)
{
log.Printf("MAIN: Giving listeners a couple seconds to start.")
var err error
select {
case err = <-errChan:
log.Printf("MAIN: Error: %v", err)
case <-time.After(2 * time.Second):
}
if err != nil {
log.Printf("MAIN: At least one error, stopping")
close(stopChan)
for err := range errChan {
log.Print("MAIN: Error: %v", err)
}
}
}
c, err := net.Dial("tcp", "0.0.0.0:7891")
if err != nil {
panic(err)
}
p := node2.AddPeer(c)
go gophernet.Handle(node2.ID, p, node2.DropPeer, node2.GetKey, stopChan, msgChan2)
node2.Broadcast(&gophernet.Message{})
select {
case err = <-errChan:
log.Printf("MAIN: Error: %v", err)
case msg := <-msgChan1:
log.Printf("MAIN: msgChan1: %#v", msg)
case msg := <-msgChan2:
log.Printf("MAIN: msgChan2: %#v", msg)
}
}
示例13: sign_message
// this function signs either a message or a raw transaction hash
func sign_message() {
var hash []byte
if *signhash != "" {
var er error
hash, er = hex.DecodeString(*signhash)
if er != nil {
println("Incorrect content of -hash parameter")
println(er.Error())
return
}
}
ad2s, e := btc.NewAddrFromString(*signaddr)
if e != nil {
println(e.Error())
if *signhash != "" {
println("Always use -sign <addr> along with -hash <msghash>")
}
return
}
var privkey *ecdsa.PrivateKey
var compr bool
for i := range publ_addrs {
if publ_addrs[i].Hash160 == ad2s.Hash160 {
privkey = new(ecdsa.PrivateKey)
pub, e := btc.NewPublicKey(publ_addrs[i].Pubkey)
if e != nil {
println(e.Error())
return
}
privkey.PublicKey = pub.PublicKey
privkey.D = new(big.Int).SetBytes(priv_keys[i][:])
compr = compressed_key[i]
// Sign raw hash?
if hash != nil {
txsig := new(btc.Signature)
txsig.HashType = 0x01
txsig.R, txsig.S, e = btc.EcdsaSign(privkey, hash)
if e != nil {
println(e.Error())
return
}
fmt.Println("PublicKey:", hex.EncodeToString(publ_addrs[i].Pubkey))
fmt.Println(hex.EncodeToString(txsig.Bytes()))
return
}
break
}
}
if privkey == nil {
println("You do not have a private key for", ad2s.String())
return
}
var msg []byte
if *message == "" {
msg, _ = ioutil.ReadAll(os.Stdin)
} else {
msg = []byte(*message)
}
hash = make([]byte, 32)
btc.HashFromMessage(msg, hash)
btcsig := new(btc.Signature)
var sb [65]byte
sb[0] = 27
if compr {
sb[0] += 4
}
btcsig.R, btcsig.S, e = btc.EcdsaSign(privkey, hash)
if e != nil {
println(e.Error())
return
}
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(compr), ad2s.Version)
if sa.Hash160 == ad2s.Hash160 {
fmt.Println(base64.StdEncoding.EncodeToString(sb[:]))
return
}
rpk = btcsig.RecoverPublicKey(hash[:], 1)
sa = btc.NewAddrFromPubkey(rpk.Bytes(compr), ad2s.Version)
if sa.Hash160 == ad2s.Hash160 {
sb[0]++
fmt.Println(base64.StdEncoding.EncodeToString(sb[:]))
//.........这里部分代码省略.........
示例14: sign_message
func sign_message() {
ad2s, e := btc.NewAddrFromString(*signaddr)
if e != nil {
println(e.Error())
return
}
var privkey *ecdsa.PrivateKey
for i := range publ_addrs {
if publ_addrs[i].Hash160 == ad2s.Hash160 {
privkey = new(ecdsa.PrivateKey)
pub, e := btc.NewPublicKey(publ_addrs[i].Pubkey)
if e != nil {
println(e.Error())
return
}
privkey.PublicKey = pub.PublicKey
privkey.D = new(big.Int).SetBytes(priv_keys[i][:])
break
}
}
if privkey == nil {
println("You do not have a private key for", ad2s.String())
return
}
var msg []byte
if *message == "" {
msg, _ = ioutil.ReadAll(os.Stdin)
} else {
msg = []byte(*message)
}
hash := make([]byte, 32)
btc.HashFromMessage(msg, hash)
btcsig := new(btc.Signature)
var sb [65]byte
sb[0] = 27
if !*uncompressed {
sb[0] += 4
}
btcsig.R, btcsig.S, e = ecdsa_Sign(privkey, hash)
if e != nil {
println(e.Error())
return
}
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(!*uncompressed), ad2s.Version)
if sa.Hash160 == ad2s.Hash160 {
fmt.Println(base64.StdEncoding.EncodeToString(sb[:]))
return
}
rpk = btcsig.RecoverPublicKey(hash[:], 1)
sa = btc.NewAddrFromPubkey(rpk.Bytes(!*uncompressed), ad2s.Version)
if sa.Hash160 == ad2s.Hash160 {
sb[0]++
fmt.Println(base64.StdEncoding.EncodeToString(sb[:]))
return
}
println("Something went wrong. The message has not been signed.")
}
示例15: make_signed_tx
// prepare a signed transaction
func make_signed_tx() {
// Make an empty transaction
tx := new(btc.Tx)
tx.Version = 1
tx.Lock_time = 0
// Select as many inputs as we need to pay the full amount (with the fee)
var btcsofar uint64
var inpcnt uint
for inpcnt = 0; inpcnt < uint(len(unspentOuts)); inpcnt++ {
uo := UO(unspentOuts[inpcnt])
// add the input to our transaction:
tin := new(btc.TxIn)
tin.Input = *unspentOuts[inpcnt]
tin.Sequence = 0xffffffff
tx.TxIn = append(tx.TxIn, tin)
btcsofar += uo.Value
if btcsofar >= spendBtc+feeBtc {
break
}
}
changeBtc = btcsofar - (spendBtc + feeBtc)
fmt.Printf("Spending %d out of %d outputs...\n", inpcnt+1, len(unspentOuts))
// Build transaction outputs:
tx.TxOut = make([]*btc.TxOut, len(sendTo))
for o := range sendTo {
tx.TxOut[o] = &btc.TxOut{Value: sendTo[o].amount, Pk_script: sendTo[o].addr.OutScript()}
}
if changeBtc > 0 {
// Add one more output (with the change)
tx.TxOut = append(tx.TxOut, &btc.TxOut{Value: changeBtc, Pk_script: get_change_addr().OutScript()})
}
//fmt.Println("Unsigned:", hex.EncodeToString(tx.Serialize()))
for in := range tx.TxIn {
uo := UO(unspentOuts[in])
var found bool
for j := range publ_addrs {
if publ_addrs[j].Owns(uo.Pk_script) {
pub_key, e := btc.NewPublicKey(publ_addrs[j].Pubkey)
if e != nil {
println("NewPublicKey:", e.Error(), "\007")
os.Exit(1)
}
// Load the key (private and public)
var key ecdsa.PrivateKey
key.D = new(big.Int).SetBytes(priv_keys[j][:])
key.PublicKey = pub_key.PublicKey
//Calculate proper transaction hash
h := tx.SignatureHash(uo.Pk_script, in, btc.SIGHASH_ALL)
//fmt.Println("SignatureHash:", btc.NewUint256(h).String())
// Sign
r, s, err := ecdsa.Sign(rand.Reader, &key, h)
if err != nil {
println("Sign:", err.Error(), "\007")
os.Exit(1)
}
rb := r.Bytes()
sb := s.Bytes()
if rb[0] >= 0x80 { // I thinnk this is needed, thought I am not quite sure... :P
rb = append([]byte{0x00}, rb...)
}
if sb[0] >= 0x80 { // I thinnk this is needed, thought I am not quite sure... :P
sb = append([]byte{0x00}, sb...)
}
// Output the signing result into a buffer, in format expected by bitcoin protocol
busig := new(bytes.Buffer)
busig.WriteByte(0x30)
busig.WriteByte(byte(4 + len(rb) + len(sb)))
busig.WriteByte(0x02)
busig.WriteByte(byte(len(rb)))
busig.Write(rb)
busig.WriteByte(0x02)
busig.WriteByte(byte(len(sb)))
busig.Write(sb)
busig.WriteByte(0x01) // hash type
// Output the signature and the public key into tx.ScriptSig
buscr := new(bytes.Buffer)
buscr.WriteByte(byte(busig.Len()))
buscr.Write(busig.Bytes())
buscr.WriteByte(byte(len(publ_addrs[j].Pubkey)))
buscr.Write(publ_addrs[j].Pubkey)
// assign:
tx.TxIn[in].ScriptSig = buscr.Bytes()
found = true
//.........这里部分代码省略.........