本文整理汇总了Golang中github.com/decred/dcrd/dcrec/secp256k1.S256函数的典型用法代码示例。如果您正苦于以下问题:Golang S256函数的具体用法?Golang S256怎么用?Golang S256使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了S256函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: TestPublicKeyIsEqual
func TestPublicKeyIsEqual(t *testing.T) {
pubKey1, err := secp256k1.ParsePubKey(
[]byte{0x03, 0x26, 0x89, 0xc7, 0xc2, 0xda, 0xb1, 0x33,
0x09, 0xfb, 0x14, 0x3e, 0x0e, 0x8f, 0xe3, 0x96, 0x34,
0x25, 0x21, 0x88, 0x7e, 0x97, 0x66, 0x90, 0xb6, 0xb4,
0x7f, 0x5b, 0x2a, 0x4b, 0x7d, 0x44, 0x8e,
},
secp256k1.S256(),
)
if err != nil {
t.Fatalf("failed to parse raw bytes for pubKey1: %v", err)
}
pubKey2, err := secp256k1.ParsePubKey(
[]byte{0x02, 0xce, 0x0b, 0x14, 0xfb, 0x84, 0x2b, 0x1b,
0xa5, 0x49, 0xfd, 0xd6, 0x75, 0xc9, 0x80, 0x75, 0xf1,
0x2e, 0x9c, 0x51, 0x0f, 0x8e, 0xf5, 0x2b, 0xd0, 0x21,
0xa9, 0xa1, 0xf4, 0x80, 0x9d, 0x3b, 0x4d,
},
secp256k1.S256(),
)
if err != nil {
t.Fatalf("failed to parse raw bytes for pubKey2: %v", err)
}
if !pubKey1.IsEqual(pubKey1) {
t.Fatalf("value of IsEqual is incorrect, %v is "+
"equal to %v", pubKey1, pubKey1)
}
if pubKey1.IsEqual(pubKey2) {
t.Fatalf("value of IsEqual is incorrect, %v is not "+
"equal to %v", pubKey1, pubKey2)
}
}
示例2: TestGenerateSharedSecret
func TestGenerateSharedSecret(t *testing.T) {
c := secp256k1.S256()
privKey1, err := secp256k1.GeneratePrivateKey(secp256k1.S256())
if err != nil {
t.Errorf("private key generation error: %s", err)
return
}
privKey2, err := secp256k1.GeneratePrivateKey(secp256k1.S256())
if err != nil {
t.Errorf("private key generation error: %s", err)
return
}
pk1x, pk1y := privKey1.Public()
pk1 := secp256k1.NewPublicKey(c, pk1x, pk1y)
pk2x, pk2y := privKey2.Public()
pk2 := secp256k1.NewPublicKey(c, pk2x, pk2y)
secret1 := secp256k1.GenerateSharedSecret(privKey1, pk2)
secret2 := secp256k1.GenerateSharedSecret(privKey2, pk1)
if !bytes.Equal(secret1, secret2) {
t.Errorf("ECDH failed, secrets mismatch - first: %x, second: %x",
secret1, secret2)
}
}
示例3: TestCipheringBasic
// Test 1: Encryption and decryption
func TestCipheringBasic(t *testing.T) {
c := secp256k1.S256()
privkey, err := secp256k1.GeneratePrivateKey(secp256k1.S256())
if err != nil {
t.Fatal("failed to generate private key")
}
in := []byte("Hey there dude. How are you doing? This is a test.")
pk1x, pk1y := privkey.Public()
pk1 := secp256k1.NewPublicKey(c, pk1x, pk1y)
out, err := secp256k1.Encrypt(pk1, in)
if err != nil {
t.Fatal("failed to encrypt:", err)
}
dec, err := secp256k1.Decrypt(privkey, out)
if err != nil {
t.Fatal("failed to decrypt:", err)
}
if !bytes.Equal(in, dec) {
t.Error("decrypted data doesn't match original")
}
}
示例4: TestScalarMult
func TestScalarMult(t *testing.T) {
// Strategy for this test:
// Get a random exponent from the generator point at first
// This creates a new point which is used in the next iteration
// Use another random exponent on the new point.
// We use BaseMult to verify by multiplying the previous exponent
// and the new random exponent together (mod N)
s256 := secp256k1.S256()
x, y := s256.Gx, s256.Gy
exponent := big.NewInt(1)
for i := 0; i < 1024; i++ {
data := make([]byte, 32)
_, err := rand.Read(data)
if err != nil {
t.Fatalf("failed to read random data at %d", i)
break
}
x, y = s256.ScalarMult(x, y, data)
exponent.Mul(exponent, new(big.Int).SetBytes(data))
xWant, yWant := s256.ScalarBaseMult(exponent.Bytes())
if x.Cmp(xWant) != 0 || y.Cmp(yWant) != 0 {
t.Fatalf("%d: bad output for %X: got (%X, %X), want (%X, %X)", i, data, x, y, xWant, yWant)
break
}
}
}
示例5: benchmarkSigning
func benchmarkSigning(b *testing.B) {
curve := secp256k1.S256()
r := rand.New(rand.NewSource(54321))
msg := []byte{
0xbe, 0x13, 0xae, 0xf4,
0xe8, 0xa2, 0x00, 0xb6,
0x45, 0x81, 0xc4, 0xd1,
0x0c, 0xf4, 0x1b, 0x5b,
0xe1, 0xd1, 0x81, 0xa7,
0xd3, 0xdc, 0x37, 0x55,
0x58, 0xc1, 0xbd, 0xa2,
0x98, 0x2b, 0xd9, 0xfb,
}
numKeys := 1024
privKeyList := randPrivKeyList(curve, numKeys)
for n := 0; n < b.N; n++ {
randIndex := r.Intn(numKeys - 1)
_, _, err := Sign(curve, privKeyList[randIndex], msg)
if err != nil {
panic("sign failure")
}
}
}
示例6: Example_decryptMessage
// This example demonstrates decrypting a message using a private key that is
// first parsed from raw bytes.
func Example_decryptMessage() {
// Decode the hex-encoded private key.
pkBytes, err := hex.DecodeString("a11b0a4e1a132305652ee7a8eb7848f6ad" +
"5ea381e3ce20a2c086a2e388230811")
if err != nil {
fmt.Println(err)
return
}
privKey, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), pkBytes)
ciphertext, err := hex.DecodeString("35f644fbfb208bc71e57684c3c8b437402ca" +
"002047a2f1b38aa1a8f1d5121778378414f708fe13ebf7b4a7bb74407288c1958969" +
"00207cf4ac6057406e40f79961c973309a892732ae7a74ee96cd89823913b8b8d650" +
"a44166dc61ea1c419d47077b748a9c06b8d57af72deb2819d98a9d503efc59fc8307" +
"d14174f8b83354fac3ff56075162")
// Try decrypting the message.
plaintext, err := secp256k1.Decrypt(privKey, ciphertext)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(plaintext))
// Output:
// test message
}
示例7: TestPubKeys
func TestPubKeys(t *testing.T) {
for _, test := range pubKeyTests {
pk, err := secp256k1.ParsePubKey(test.key, secp256k1.S256())
if err != nil {
if test.isValid {
t.Errorf("%s pubkey failed when shouldn't %v",
test.name, err)
}
continue
}
if !test.isValid {
t.Errorf("%s counted as valid when it should fail",
test.name)
continue
}
var pkStr []byte
switch test.format {
case secp256k1.TstPubkeyUncompressed:
pkStr = (*secp256k1.PublicKey)(pk).SerializeUncompressed()
case secp256k1.TstPubkeyCompressed:
pkStr = (*secp256k1.PublicKey)(pk).SerializeCompressed()
case secp256k1.TstPubkeyHybrid:
pkStr = (*secp256k1.PublicKey)(pk).SerializeHybrid()
}
if !bytes.Equal(test.key, pkStr) {
t.Errorf("%s pubkey: serialized keys do not match.",
test.name)
spew.Dump(test.key)
spew.Dump(pkStr)
}
}
}
示例8: Example_signMessage
// This example demonstrates signing a message with a secp256k1 private key that
// is first parsed form raw bytes and serializing the generated signature.
func Example_signMessage() {
// Decode a hex-encoded private key.
pkBytes, err := hex.DecodeString("22a47fa09a223f2aa079edf85a7c2d4f87" +
"20ee63e502ee2869afab7de234b80c")
if err != nil {
fmt.Println(err)
return
}
privKey, pubKey := secp256k1.PrivKeyFromBytes(secp256k1.S256(), pkBytes)
// Sign a message using the private key.
message := "test message"
messageHash := chainhash.HashFuncB([]byte(message))
signature, err := privKey.Sign(messageHash)
if err != nil {
fmt.Println(err)
return
}
// Serialize and display the signature.
fmt.Printf("Serialized Signature: %x\n", signature.Serialize())
// Verify the signature for the message using the public key.
verified := signature.Verify(messageHash, pubKey)
fmt.Printf("Signature Verified? %v\n", verified)
// Output:
// Serialized Signature: 3045022100fcc0a8768cfbcefcf2cadd7cfb0fb18ed08dd2e2ae84bef1a474a3d351b26f0302200fc1a350b45f46fa00101391302818d748c2b22615511a3ffd5bb638bd777207
// Signature Verified? true
}
示例9: Example_encryptMessage
// This example demonstrates encrypting a message for a public key that is first
// parsed from raw bytes, then decrypting it using the corresponding private key.
func Example_encryptMessage() {
// Decode the hex-encoded pubkey of the recipient.
pubKeyBytes, err := hex.DecodeString("04115c42e757b2efb7671c578530ec191a1" +
"359381e6a71127a9d37c486fd30dae57e76dc58f693bd7e7010358ce6b165e483a29" +
"21010db67ac11b1b51b651953d2") // uncompressed pubkey
if err != nil {
fmt.Println(err)
return
}
pubKey, err := secp256k1.ParsePubKey(pubKeyBytes, secp256k1.S256())
if err != nil {
fmt.Println(err)
return
}
// Encrypt a message decryptable by the private key corresponding to pubKey
message := "test message"
ciphertext, err := secp256k1.Encrypt(pubKey, []byte(message))
if err != nil {
fmt.Println(err)
return
}
// Decode the hex-encoded private key.
pkBytes, err := hex.DecodeString("a11b0a4e1a132305652ee7a8eb7848f6ad" +
"5ea381e3ce20a2c086a2e388230811")
if err != nil {
fmt.Println(err)
return
}
// note that we already have corresponding pubKey
privKey, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), pkBytes)
// Try decrypting and verify if it's the same message.
plaintext, err := secp256k1.Decrypt(privKey, ciphertext)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(plaintext))
// Output:
// test message
}
示例10: TestPrivKeys
func TestPrivKeys(t *testing.T) {
tests := []struct {
name string
key []byte
}{
{
name: "check curve",
key: []byte{
0xea, 0xf0, 0x2c, 0xa3, 0x48, 0xc5, 0x24, 0xe6,
0x39, 0x26, 0x55, 0xba, 0x4d, 0x29, 0x60, 0x3c,
0xd1, 0xa7, 0x34, 0x7d, 0x9d, 0x65, 0xcf, 0xe9,
0x3c, 0xe1, 0xeb, 0xff, 0xdc, 0xa2, 0x26, 0x94,
},
},
}
for _, test := range tests {
priv, pub := secp256k1.PrivKeyFromBytes(secp256k1.S256(), test.key)
_, err := secp256k1.ParsePubKey(
pub.SerializeUncompressed(), secp256k1.S256())
if err != nil {
t.Errorf("%s privkey: %v", test.name, err)
continue
}
hash := []byte{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}
sig, err := priv.Sign(hash)
if err != nil {
t.Errorf("%s could not sign: %v", test.name, err)
continue
}
if !sig.Verify(hash, pub) {
t.Errorf("%s could not verify: %v", test.name, err)
continue
}
serializedKey := priv.Serialize()
if !bytes.Equal(serializedKey, test.key) {
t.Errorf("%s unexpected serialized bytes - got: %x, "+
"want: %x", test.name, serializedKey, test.key)
}
}
}
示例11: TestSignaturesAndRecovery
// Use our actual hashing algorithm here.
func TestSignaturesAndRecovery(t *testing.T) {
curve := secp256k1.S256()
r := rand.New(rand.NewSource(54321))
numSigs := 128
sigList := randSigList(curve, numSigs)
for _, tv := range sigList {
pubkey := tv.pubkey
sig := tv.sig
// Make sure we can verify the original signature.
_, err := schnorrVerify(curve, sig.Serialize(), pubkey, tv.msg,
chainhash.HashFuncB)
assert.NoError(t, err)
ok := Verify(curve, pubkey, tv.msg, sig.R, sig.S)
assert.Equal(t, true, ok)
// See if we can recover the public keys OK.
var pkRecover *secp256k1.PublicKey
pkRecover, _, err = schnorrRecover(curve, sig.Serialize(), tv.msg,
chainhash.HashFuncB)
assert.NoError(t, err)
if err == nil {
assert.Equal(t, pubkey.Serialize(), pkRecover.Serialize())
}
// Screw up the signature at some random bits and make sure
// that breaks it.
numBadBits := r.Intn(2)
sigBad := sig.Serialize()
// (numBadBits*2)+1 --> always odd so at least one bit is different
for i := 0; i < (numBadBits*2)+1; i++ {
pos := r.Intn(63)
bitPos := r.Intn(7)
sigBad[pos] ^= 1 << uint8(bitPos)
}
_, err = schnorrVerify(curve, sigBad, pubkey, tv.msg,
chainhash.HashFuncB)
assert.Error(t, err)
// Make sure it breaks pubkey recovery too.
valid := false
pkRecover, valid, err = schnorrRecover(curve, sigBad, tv.msg,
testSchnorrHash)
if valid {
assert.NotEqual(t, pubkey.Serialize(), pkRecover.Serialize())
} else {
assert.Error(t, err)
}
}
}
示例12: TestSignCompact
func TestSignCompact(t *testing.T) {
for i := 0; i < 256; i++ {
name := fmt.Sprintf("test %d", i)
data := make([]byte, 32)
_, err := rand.Read(data)
if err != nil {
t.Errorf("failed to read random data for %s", name)
continue
}
compressed := i%2 != 0
testSignCompact(t, name, secp256k1.S256(), data, compressed)
}
}
示例13: Example_verifySignature
// This example demonstrates verifying a secp256k1 signature against a public
// key that is first parsed from raw bytes. The signature is also parsed from
// raw bytes.
func Example_verifySignature() {
// Decode hex-encoded serialized public key.
pubKeyBytes, err := hex.DecodeString("02a673638cb9587cb68ea08dbef685c" +
"6f2d2a751a8b3c6f2a7e9a4999e6e4bfaf5")
if err != nil {
fmt.Println(err)
return
}
pubKey, err := secp256k1.ParsePubKey(pubKeyBytes, secp256k1.S256())
if err != nil {
fmt.Println(err)
return
}
// Decode hex-encoded serialized signature.
sigBytes, err := hex.DecodeString("3045022100fcc0a8768cfbcefcf2cadd7cfb0" +
"fb18ed08dd2e2ae84bef1a474a3d351b26f0302200fc1a350b45f46fa0010139130" +
"2818d748c2b22615511a3ffd5bb638bd777207")
if err != nil {
fmt.Println(err)
return
}
signature, err := secp256k1.ParseSignature(sigBytes, secp256k1.S256())
if err != nil {
fmt.Println(err)
return
}
// Verify the signature for the message using the public key.
message := "test message"
messageHash := chainhash.HashFuncB([]byte(message))
verified := signature.Verify(messageHash, pubKey)
fmt.Println("Signature Verified?", verified)
// Output:
// Signature Verified? true
}
示例14: TestSignatures
func TestSignatures(t *testing.T) {
for _, test := range signatureTests {
var err error
if test.der {
_, err = secp256k1.ParseDERSignature(test.sig, secp256k1.S256())
} else {
_, err = secp256k1.ParseSignature(test.sig, secp256k1.S256())
}
if err != nil {
if test.isValid {
t.Errorf("%s signature failed when shouldn't %v",
test.name, err)
} /* else {
t.Errorf("%s got error %v", test.name, err)
} */
continue
}
if !test.isValid {
t.Errorf("%s counted as valid when it should fail",
test.name)
}
}
}
示例15: TestSchnorrSigning
func TestSchnorrSigning(t *testing.T) {
tRand := rand.New(rand.NewSource(54321))
curve := secp256k1.S256()
tvs := GetSigningTestVectors()
for _, tv := range tvs {
_, pubkey := secp256k1.PrivKeyFromBytes(curve, tv.priv)
sig, err :=
schnorrSign(curve, tv.msg, tv.priv, tv.nonce, nil, nil,
testSchnorrHash)
assert.NoError(t, err)
assert.Equal(t, sig.Serialize(), tv.sig)
// Make sure they verify too while we're at it.
_, err = schnorrVerify(curve, sig.Serialize(), pubkey, tv.msg,
testSchnorrHash)
assert.NoError(t, err)
// See if we can recover the public keys OK.
var pkRecover *secp256k1.PublicKey
pkRecover, _, err = schnorrRecover(curve, sig.Serialize(), tv.msg,
testSchnorrHash)
assert.NoError(t, err)
if err == nil {
assert.Equal(t, pubkey.Serialize(), pkRecover.Serialize())
}
// Screw up the signature at a random bit and make sure that breaks it.
sigBad := sig.Serialize()
pos := tRand.Intn(63)
bitPos := tRand.Intn(7)
sigBad[pos] ^= 1 << uint8(bitPos)
_, err = schnorrVerify(curve, sigBad, pubkey, tv.msg,
testSchnorrHash)
assert.Error(t, err)
// Make sure it breaks pubkey recovery too.
valid := false
pkRecover, valid, err = schnorrRecover(curve, sigBad, tv.msg,
testSchnorrHash)
if valid {
assert.NotEqual(t, pubkey.Serialize(), pkRecover.Serialize())
} else {
assert.Error(t, err)
}
}
}