// 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")
}
}
// 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
}
// newSecSchnorrDSA instatiates a function DSA subsystem over the secp256k1
// curve. A caveat for the functions below is that they're all routed through
// interfaces, and nil returns from the library itself for interfaces must
// ALWAYS be checked by checking the return value by attempted dereference
// (== nil).
func newSecSchnorrDSA() DSA {
var secp DSA = &secSchnorrDSA{
// Constants
getP: func() *big.Int {
return secp256k1Curve.P
},
getN: func() *big.Int {
return secp256k1Curve.N
},
// EC Math
add: func(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int) {
return secp256k1Curve.Add(x1, y1, x2, y2)
},
isOnCurve: func(x, y *big.Int) bool {
return secp256k1Curve.IsOnCurve(x, y)
},
scalarMult: func(x, y *big.Int, k []byte) (*big.Int, *big.Int) {
return secp256k1Curve.ScalarMult(x, y, k)
},
scalarBaseMult: func(k []byte) (*big.Int, *big.Int) {
return secp256k1Curve.ScalarBaseMult(k)
},
// Private keys
newPrivateKey: func(d *big.Int) PrivateKey {
pk := secp256k1.NewPrivateKey(secp256k1Curve, d)
if pk != nil {
return PrivateKey(pk)
}
return nil
},
privKeyFromBytes: func(pk []byte) (PrivateKey, PublicKey) {
priv, pub := secp256k1.PrivKeyFromBytes(secp256k1Curve, pk)
if priv == nil {
return nil, nil
}
if pub == nil {
return nil, nil
}
tpriv := PrivateKey(priv)
tpub := PublicKey(pub)
return tpriv, tpub
},
privKeyFromScalar: func(pk []byte) (PrivateKey, PublicKey) {
priv, pub := secp256k1.PrivKeyFromScalar(secp256k1Curve, pk)
if priv == nil {
return nil, nil
}
if pub == nil {
return nil, nil
}
tpriv := PrivateKey(priv)
tpub := PublicKey(pub)
return tpriv, tpub
},
privKeyBytesLen: func() int {
return secp256k1.PrivKeyBytesLen
},
// Public keys
// Note that Schnorr only allows 33 byte public keys, however
// as they are secp256k1 you still have access to the other
// serialization types.
newPublicKey: func(x *big.Int, y *big.Int) PublicKey {
pk := secp256k1.NewPublicKey(secp256k1Curve, x, y)
tpk := PublicKey(pk)
return tpk
},
parsePubKey: func(pubKeyStr []byte) (PublicKey, error) {
pk, err := schnorr.ParsePubKey(secp256k1Curve, pubKeyStr)
if err != nil {
return nil, err
}
tpk := PublicKey(pk)
return tpk, err
},
pubKeyBytesLen: func() int {
return schnorr.PubKeyBytesLen
},
pubKeyBytesLenUncompressed: func() int {
return schnorr.PubKeyBytesLen
},
pubKeyBytesLenCompressed: func() int {
return schnorr.PubKeyBytesLen
},
pubKeyBytesLenHybrid: func() int {
return schnorr.PubKeyBytesLen
},
// Signatures
newSignature: func(r *big.Int, s *big.Int) Signature {
sig := schnorr.NewSignature(r, s)
ts := Signature(sig)
return ts
},
parseDERSignature: func(sigStr []byte) (Signature, error) {
sig, err := schnorr.ParseSignature(sigStr)
ts := Signature(sig)
return ts, err
},
parseSignature: func(sigStr []byte) (Signature, error) {
sig, err := schnorr.ParseSignature(sigStr)
ts := Signature(sig)
return ts, err
},
recoverCompact: func(signature, hash []byte) (PublicKey, bool, error) {
pk, bl, err := schnorr.RecoverPubkey(secp256k1Curve, signature,
hash)
tpk := PublicKey(pk)
return tpk, bl, err
},
// ECDSA
generateKey: func(rand io.Reader) ([]byte, *big.Int, *big.Int, error) {
return secp256k1.GenerateKey(secp256k1Curve, rand)
},
sign: func(priv PrivateKey, hash []byte) (r, s *big.Int, err error) {
spriv := secp256k1.NewPrivateKey(secp256k1Curve, priv.GetD())
return schnorr.Sign(secp256k1Curve, spriv, hash)
},
verify: func(pub PublicKey, hash []byte, r, s *big.Int) bool {
spub := secp256k1.NewPublicKey(secp256k1Curve, pub.GetX(), pub.GetY())
return schnorr.Verify(secp256k1Curve, spub, hash, r, s)
},
// Symmetric cipher encryption
generateSharedSecret: func(privkey []byte, x, y *big.Int) []byte {
sprivkey, _ := secp256k1.PrivKeyFromBytes(secp256k1Curve, privkey)
if sprivkey == nil {
return nil
}
spubkey := secp256k1.NewPublicKey(secp256k1Curve, x, y)
return secp256k1.GenerateSharedSecret(sprivkey, spubkey)
},
encrypt: func(x, y *big.Int, in []byte) ([]byte, error) {
spubkey := secp256k1.NewPublicKey(secp256k1Curve, x, y)
return secp256k1.Encrypt(spubkey, in)
},
decrypt: func(privkey []byte, in []byte) ([]byte, error) {
sprivkey, _ := secp256k1.PrivKeyFromBytes(secp256k1Curve, privkey)
if sprivkey == nil {
return nil, fmt.Errorf("failure deserializing privkey")
}
return secp256k1.Decrypt(sprivkey, in)
},
}
return secp.(DSA)
}
// newSecp256k1DSA instatiates a function DSA subsystem over the secp256k1
// curve. A caveat for the functions below is that they're all routed through
// interfaces, and nil returns from the library itself for interfaces must
// ALWAYS be checked by checking the return value by attempted dereference
// (== nil).
func newSecp256k1DSA() DSA {
var secp DSA = &secp256k1DSA{
// Constants
getP: func() *big.Int {
return secp256k1Curve.P
},
getN: func() *big.Int {
return secp256k1Curve.N
},
// EC Math
add: func(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int) {
return secp256k1Curve.Add(x1, y1, x2, y2)
},
isOnCurve: func(x, y *big.Int) bool {
return secp256k1Curve.IsOnCurve(x, y)
},
scalarMult: func(x, y *big.Int, k []byte) (*big.Int, *big.Int) {
return secp256k1Curve.ScalarMult(x, y, k)
},
scalarBaseMult: func(k []byte) (*big.Int, *big.Int) {
return secp256k1Curve.ScalarBaseMult(k)
},
// Private keys
newPrivateKey: func(d *big.Int) PrivateKey {
if d == nil {
return nil
}
pk := secp256k1.NewPrivateKey(secp256k1Curve, d)
if pk != nil {
return PrivateKey(pk)
}
return nil
},
privKeyFromBytes: func(pk []byte) (PrivateKey, PublicKey) {
priv, pub := secp256k1.PrivKeyFromBytes(secp256k1Curve, pk)
if priv == nil {
return nil, nil
}
if pub == nil {
return nil, nil
}
tpriv := PrivateKey(priv)
tpub := PublicKey(pub)
return tpriv, tpub
},
privKeyFromScalar: func(pk []byte) (PrivateKey, PublicKey) {
priv, pub := secp256k1.PrivKeyFromScalar(secp256k1Curve, pk)
if priv == nil {
return nil, nil
}
if pub == nil {
return nil, nil
}
tpriv := PrivateKey(priv)
tpub := PublicKey(pub)
return tpriv, tpub
},
privKeyBytesLen: func() int {
return secp256k1.PrivKeyBytesLen
},
// Public keys
newPublicKey: func(x *big.Int, y *big.Int) PublicKey {
pk := secp256k1.NewPublicKey(secp256k1Curve, x, y)
tpk := PublicKey(pk)
return tpk
},
parsePubKey: func(pubKeyStr []byte) (PublicKey, error) {
pk, err := secp256k1.ParsePubKey(pubKeyStr, secp256k1Curve)
if err != nil {
return nil, err
}
tpk := PublicKey(pk)
return tpk, err
},
pubKeyBytesLen: func() int {
return secp256k1.PubKeyBytesLenCompressed
},
pubKeyBytesLenUncompressed: func() int {
return secp256k1.PubKeyBytesLenUncompressed
},
pubKeyBytesLenCompressed: func() int {
return secp256k1.PubKeyBytesLenCompressed
},
pubKeyBytesLenHybrid: func() int {
return secp256k1.PubKeyBytesLenHybrid
},
// Signatures
newSignature: func(r *big.Int, s *big.Int) Signature {
sig := secp256k1.NewSignature(r, s)
ts := Signature(sig)
return ts
},
parseDERSignature: func(sigStr []byte) (Signature, error) {
sig, err := secp256k1.ParseDERSignature(sigStr, secp256k1Curve)
if err != nil {
return nil, err
}
ts := Signature(sig)
return ts, err
},
parseSignature: func(sigStr []byte) (Signature, error) {
sig, err := secp256k1.ParseSignature(sigStr, secp256k1Curve)
if err != nil {
return nil, err
}
ts := Signature(sig)
return ts, err
},
recoverCompact: func(signature, hash []byte) (PublicKey, bool, error) {
pk, bl, err := secp256k1.RecoverCompact(secp256k1Curve, signature,
hash)
tpk := PublicKey(pk)
return tpk, bl, err
},
// ECDSA
generateKey: func(rand io.Reader) ([]byte, *big.Int, *big.Int, error) {
return secp256k1.GenerateKey(secp256k1Curve, rand)
},
sign: func(priv PrivateKey, hash []byte) (r, s *big.Int, err error) {
if priv.GetType() != ECTypeSecp256k1 {
return nil, nil, errors.New("wrong type")
}
spriv, ok := priv.(*secp256k1.PrivateKey)
if !ok {
return nil, nil, errors.New("wrong type")
}
sig, err := spriv.Sign(hash)
if sig != nil {
r = sig.GetR()
s = sig.GetS()
}
return
},
verify: func(pub PublicKey, hash []byte, r, s *big.Int) bool {
spub := secp256k1.NewPublicKey(secp256k1Curve, pub.GetX(), pub.GetY())
ssig := secp256k1.NewSignature(r, s)
return ssig.Verify(hash, spub)
},
// Symmetric cipher encryption
generateSharedSecret: func(privkey []byte, x, y *big.Int) []byte {
sprivkey, _ := secp256k1.PrivKeyFromBytes(secp256k1Curve, privkey)
if sprivkey == nil {
return nil
}
spubkey := secp256k1.NewPublicKey(secp256k1Curve, x, y)
return secp256k1.GenerateSharedSecret(sprivkey, spubkey)
},
encrypt: func(x, y *big.Int, in []byte) ([]byte, error) {
spubkey := secp256k1.NewPublicKey(secp256k1Curve, x, y)
return secp256k1.Encrypt(spubkey, in)
},
decrypt: func(privkey []byte, in []byte) ([]byte, error) {
sprivkey, _ := secp256k1.PrivKeyFromBytes(secp256k1Curve, privkey)
if sprivkey == nil {
return nil, fmt.Errorf("failure deserializing privkey")
}
return secp256k1.Decrypt(sprivkey, in)
},
}
return secp.(DSA)
}