gitlab.com/bertrandbenj/politikojj@v0.0.0-20210611181209-822dead29a01/crypto/crypto_test.go (about)

     1  package crypto
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/btcsuite/btcutil/base58"
     6  	"github.com/libp2p/go-libp2p-core/crypto"
     7  	"github.com/stretchr/testify/assert"
     8  	"gitlab.com/bertrandbenj/politikojj/crypto/extra"
     9  	mrand "math/rand"
    10  	"os"
    11  	"testing"
    12  )
    13  
    14  var pgpPair Keypair
    15  
    16  const mySecretString = "this is so very secret!"
    17  const passphrase = "test1"
    18  
    19  func init() {
    20  
    21  	priv, pub := extra.ReadPubAndPrivateArmorKeyFile("../testset/pub.asc", "../testset/priv.asc", "test1")
    22  	pgpPair = Keypair{
    23  		PrivateKey: priv,
    24  		PublicKey:  pub,
    25  	}
    26  }
    27  
    28  func BenchmarkSignature(t *testing.B) {
    29  
    30  	msg := []byte(mySecretString)
    31  
    32  	got, _ := pgpPair.PrivateKey.Sign(msg)
    33  	fmt.Println(got)
    34  
    35  	verify, _ := pgpPair.PublicKey.Verify(msg, got)
    36  
    37  	assert.True(t, verify, "verify signature")
    38  
    39  	t.ReportAllocs()
    40  }
    41  
    42  func BenchmarkEncryption(t *testing.B) {
    43  	enc := pgpPair.PublicKey.(*extra.PGPPublicKey).EncryptMessage(mySecretString)
    44  	fmt.Println(enc)
    45  	dec, _ := pgpPair.PrivateKey.(*extra.PGPPrivateKey).DecryptMessage(enc)
    46  	assert.Equal(t, dec, mySecretString, "decrypted string different")
    47  
    48  }
    49  
    50  func TestReadEntity(t *testing.T) {
    51  	_, err := extra.ReadArmoredPubFile("../testset/pub.asc")
    52  	assert.Nil(t, err, "test armor entity")
    53  
    54  }
    55  
    56  // fileExists checks if a file exists and is not a directory before we
    57  // try using it to prevent further errors.
    58  func fileExists(filename string) bool {
    59  	info, err := os.Stat(filename)
    60  	if os.IsNotExist(err) {
    61  		return false
    62  	}
    63  	return !info.IsDir()
    64  }
    65  
    66  func TestKeypair_Save(t *testing.T) {
    67  	key := GenEd25519()
    68  	fname := "/tmp/testcrypto/" + key.PubID()
    69  
    70  	assert.True(t, key.Save(fname))
    71  
    72  	emptyKey := Keypair{}
    73  	assert.False(t, emptyKey.Save("/tmp/emptyKey"))
    74  
    75  	forbidenPath := Keypair{}
    76  	assert.False(t, forbidenPath.Save("/root/emptyKey"))
    77  
    78  }
    79  
    80  func Test(t *testing.T) {
    81  	pair := GenEd25519()
    82  	genPub := pair.PubID()
    83  
    84  	msg, err := pair.PrivateKey.Sign([]byte(mySecretString))
    85  	assert.Nil(t, err)
    86  
    87  	parsed := ParsePublicKey(genPub)
    88  	assert.NotNil(t, parsed)
    89  
    90  	assert.Nil(t, ParsePublicKey("ABCDEFGH"))
    91  
    92  	ok, err := parsed.Verify([]byte(mySecretString), msg)
    93  	assert.Nil(t, err)
    94  	assert.True(t, ok)
    95  
    96  	assert.NotNil(t, pair.Serialize())
    97  }
    98  
    99  func TestLoadKey(t *testing.T) {
   100  	fname := "../testset/ed25519.priv"
   101  	key := LoadKey(fname)
   102  	assert.NotNil(t, key)
   103  
   104  	assert.Empty(t, LoadKey("/no/file"))
   105  	assert.Empty(t, LoadKey("../docs/constitution.md"))
   106  }
   107  
   108  func TestReadPrivateArmorFile(t *testing.T) {
   109  	entity, _ := extra.ReadArmoredPrivateFile("../testset/priv.asc", passphrase)
   110  	assert.NotNil(t, entity, "test private armor file")
   111  }
   112  
   113  func TestPGPPrivateKey_Sign(t *testing.T) {
   114  	signature, err := pgpPair.PrivateKey.Sign([]byte(mySecretString))
   115  	assert.Nil(t, err, "error should be nil")
   116  	assert.Greater(t, len(signature), 0, "signature should not be empty")
   117  }
   118  
   119  func TestEncryptMessage(t *testing.T) {
   120  
   121  	enc := pgpPair.PublicKey.(*extra.PGPPublicKey).EncryptMessage(mySecretString)
   122  	assert.Greater(t, len(enc), 0, "encrypted message should not be empty")
   123  }
   124  
   125  func TestGeneratePGPKeyPair(t *testing.T) {
   126  	priv, pub, err := extra.GeneratePGPKeyPair("testName", "testComment", "email@email.com")
   127  	assert.Nil(t, err, "Generating key")
   128  	assert.NotNil(t, priv, "Generated private key")
   129  	assert.NotNil(t, pub, "Generated public key")
   130  }
   131  
   132  func TestPGPPrivateKey_DecryptMessage(t *testing.T) {
   133  	encoded := "wcBMA6+EN6Xft2vEAQgAVh0wnKRU3vRk5bY8sxD+jGUY92uX2bzekrjY1j6qfTqV6MM+CFEAaXERg9a81rM0odgG0mrXab2n3pmuDzEHPkpOAY8obz8y5SjnHavc5uV8wZb/aXy/bgCh+9ywRYM7SUpcPi8Rh/IVWMpWqSvj9E1v6Aj+mjS3G4deWJilBG/pQnc3yVQX7W4sqNX5Dkvq+b5NKhZvs03tQ4QtKPX03iwH79JVyghKPWhGlCWicjcMRGLzLcvYKEaDK8HaCK8i0qKxoV9nfE4IEQhZdE2LDDKj0IrIEcV+XwS2kQStO9Rps5vxPbEwONeflUFfWbraCbC6ZINAy3FW7Wz0Pr5IwtLmAQ4+flcidDb52qS0HMx5W0r9Vjrinr2uxPS+Y987VoIYAENPUwaQKF28j6U95oFFnp0d/D20YBUVSaaJeSKBvOPnvuTJnAMtEOKcZ/EjAA=="
   134  	dec, err := pgpPair.PrivateKey.(*extra.PGPPrivateKey).DecryptMessage(encoded)
   135  	assert.Nil(t, err, "Decrypting")
   136  	assert.Equal(t, mySecretString, dec, "Decrypted message should match")
   137  }
   138  
   139  func TestG1Compatibility(t *testing.T) {
   140  	g1raw := "5jf8kATgxw8QxFugnh8cEPYYf8BVzPQLWcEq1vHhQHyUTLL5CHd1qbhJmwEsWEeBQSfLYGQU7dhbuyLizyHb28Kx"
   141  	g1pub := "3LJRrLQCio4GL7Xd48ydnYuuaeWAgqX4qXYFbXDTJpAa"
   142  
   143  	g1Priv, err := crypto.UnmarshalEd25519PrivateKey(base58.Decode(g1raw))
   144  	g1Pub, err := crypto.UnmarshalEd25519PublicKey(base58.Decode(g1pub))
   145  	assert.Nilf(t, err, "Private pgpPair reading %s", g1Priv)
   146  
   147  	assert.Equal(t, g1Priv.GetPublic(), g1Pub, "pgpPair not matching ")
   148  	x, _ := g1Priv.GetPublic().Raw()
   149  	log.Info(base58.Encode(x))
   150  }
   151  
   152  func Test_libP2PCrypto(t *testing.T) {
   153  
   154  	r := mrand.New(mrand.NewSource(1))
   155  
   156  	pr, pk, err := crypto.GenerateEd25519Key(r)
   157  	fmt.Println("Raw ", pr, pk)
   158  
   159  	bpriv, _ := pr.Raw() //crypto.MarshalPrivateKey(pr)
   160  	bpub, _ := pk.Raw()
   161  
   162  	fmt.Println("Marshaled PubKey : ", bpub, "Marshaled PrivateK: ", bpriv, "Type : ", pr.Type().String())
   163  
   164  	priv, err := crypto.UnmarshalEd25519PrivateKey(bpriv)
   165  	assert.Nil(t, err, "Private pgpPair reading")
   166  
   167  	pub, err := crypto.UnmarshalEd25519PublicKey(bpub)
   168  	assert.Nil(t, err, "Private pgpPair reading")
   169  
   170  	log.Infof("UnMarshaled PubKey : %s\nUnMarshaled PrivateK: %s", pub, priv)
   171  
   172  }