github.com/pavlo67/common@v0.5.3/common/encrlib/ecdsa_test.go (about)

     1  package encrlib
     2  
     3  import (
     4  	"crypto/ecdsa"
     5  	"crypto/elliptic"
     6  	"crypto/rand"
     7  	"log"
     8  	"testing"
     9  
    10  	"github.com/btcsuite/btcutil/base58"
    11  
    12  	"fmt"
    13  
    14  	"github.com/stretchr/testify/require"
    15  )
    16  
    17  var keyToSignature = "test data"
    18  
    19  func TestECDSASign(t *testing.T) {
    20  	privKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    21  	require.NoError(t, err)
    22  	require.NotNil(t, privKey)
    23  
    24  	signature, err := ECDSASign(keyToSignature, *privKey)
    25  	require.NoError(t, err)
    26  
    27  	// publKey := append(privKey.PublicKey.X.Bytes(), privKey.PublicKey.Y.Bytes()...)
    28  	publKey := ECDSAPublicKey(*privKey)
    29  	fmt.Print("ADDRESS: ", base58.Encode(publKey), "\n\n")
    30  
    31  	ok := ECDSAVerify(keyToSignature, publKey, signature)
    32  	require.True(t, ok)
    33  
    34  	publKeyBad := append(privKey.PublicKey.Y.Bytes(), privKey.PublicKey.X.Bytes()...)
    35  	ok = ECDSAVerify(keyToSignature, publKeyBad, signature)
    36  	require.False(t, ok)
    37  	ok = ECDSAVerify(keyToSignature, []byte{}, signature)
    38  	require.False(t, ok)
    39  
    40  	ok = ECDSAVerify(keyToSignature+" ", publKey, signature)
    41  	require.False(t, ok)
    42  	ok = ECDSAVerify(keyToSignature[:len(keyToSignature)-1], publKey, signature)
    43  	require.False(t, ok)
    44  	ok = ECDSAVerify(keyToSignature[:len(keyToSignature)-1]+" ", publKey, signature)
    45  	require.False(t, ok)
    46  	ok = ECDSAVerify("", publKey, signature)
    47  	require.False(t, ok)
    48  
    49  	ok = ECDSAVerify(keyToSignature, publKey, []byte(string(signature)+" "))
    50  	require.False(t, ok)
    51  	ok = ECDSAVerify(keyToSignature, publKey, signature[:len(keyToSignature)-1])
    52  	require.False(t, ok)
    53  	signatureBad := make([]byte, len(signature))
    54  	for i, s := range signature[:len(signature)-1] {
    55  		signatureBad[i] = s
    56  	}
    57  	signatureBad[len(signatureBad)-1] = byte(uint8(signatureBad[len(signatureBad)-1]) + 1%256)
    58  
    59  	ok = ECDSAVerify(keyToSignature, publKey, signatureBad)
    60  	require.False(t, ok)
    61  }
    62  
    63  func TestECDSASignPredefinedPair(t *testing.T) {
    64  	privKeyPredefined, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    65  	require.NoError(t, err)
    66  	require.NotNil(t, privKeyPredefined)
    67  
    68  	publKeyPredefined := ECDSAPublicKey(*privKeyPredefined)
    69  	publicKeyBase58 := base58.Encode(publKeyPredefined)
    70  
    71  	privKeySerialization, err := ECDSASerialize(*privKeyPredefined)
    72  	require.NoError(t, err)
    73  
    74  	// log.Printf("private key privKeySerialization: %s", privKeySerialization)
    75  
    76  	privKey, err := ECDSADeserialize(privKeySerialization)
    77  	require.NoError(t, err)
    78  	require.NotNil(t, privKey)
    79  
    80  	signature, err := ECDSASign(keyToSignature, *privKey)
    81  	require.NoError(t, err)
    82  
    83  	// publKey := ECDSAPublicKey(*privKey)
    84  
    85  	publKey := base58.Decode(publicKeyBase58)
    86  	require.Equal(t, publKeyPredefined, publKey)
    87  
    88  	//log.Printf("predefined address: %s", Base58Encode(publKeyPredefined))
    89  	log.Printf("     private key: %s", privKeySerialization)
    90  	log.Printf("         address: %s", publicKeyBase58)
    91  	log.Printf("key to signature: %s", keyToSignature)
    92  	log.Printf("       signature: %s", base58.Encode(signature))
    93  
    94  	ok := ECDSAVerify(keyToSignature, publKey, signature)
    95  	require.True(t, ok)
    96  }
    97  
    98  func TestECDSASerialize(t *testing.T) {
    99  	privKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
   100  	require.NoError(t, err)
   101  	require.NotNil(t, privKey)
   102  
   103  	signature, err := ECDSASign(keyToSignature, *privKey)
   104  	require.NoError(t, err)
   105  	require.NotEmpty(t, signature)
   106  
   107  	log.Printf("signature 1: %s\n\n", string(signature))
   108  
   109  	publKey := append(privKey.PublicKey.X.Bytes(), privKey.PublicKey.Y.Bytes()...)
   110  	ok := ECDSAVerify(keyToSignature, publKey, signature)
   111  	require.True(t, ok)
   112  
   113  	serialization, err := ECDSASerialize(*privKey)
   114  	require.NoError(t, err)
   115  
   116  	// log.Printf("private key serialization: %s", serialization)
   117  
   118  	privKeyRestored, err := ECDSADeserialize(serialization)
   119  	require.NoError(t, err)
   120  	require.NotNil(t, privKeyRestored)
   121  
   122  	signatureRestored, err := ECDSASign(keyToSignature, *privKeyRestored)
   123  	require.NoError(t, err)
   124  
   125  	log.Printf("signature 2: %s\n\n", string(signatureRestored))
   126  
   127  	publKeyRestored := append(privKeyRestored.PublicKey.X.Bytes(), privKeyRestored.PublicKey.Y.Bytes()...)
   128  	ok = ECDSAVerify(keyToSignature, publKeyRestored, signature)
   129  	require.True(t, ok)
   130  }