git.sr.ht/~pingoo/stdx@v0.0.0-20240218134121-094174641f6e/crypto/curve25519_test.go (about)

     1  package crypto
     2  
     3  import (
     4  	"testing"
     5  
     6  	"golang.org/x/crypto/curve25519"
     7  )
     8  
     9  func TestCurve25519EncryptDecrypt(t *testing.T) {
    10  	message := []byte("this is a simple message")
    11  	nonce, err := RandBytes(AEADNonceSize)
    12  	if err != nil {
    13  		t.Error(err)
    14  	}
    15  
    16  	toPublicKey, toPrivateKey, err := GenerateCurve25519KeyPair()
    17  	if err != nil {
    18  		t.Error(err)
    19  	}
    20  
    21  	fromPublicKey, fromPrivateKey, err := GenerateCurve25519KeyPair()
    22  	if err != nil {
    23  		t.Error(err)
    24  	}
    25  
    26  	ciphertext, err := toPublicKey.Encrypt(fromPrivateKey, nonce, message)
    27  	if err != nil {
    28  		t.Error(err)
    29  	}
    30  
    31  	plaintext, err := toPrivateKey.Decrypt(fromPublicKey, nonce, ciphertext)
    32  	if err != nil {
    33  		t.Error(err)
    34  	}
    35  
    36  	if !ConstantTimeCompare(message, plaintext) {
    37  		t.Errorf("Message (%s) and plaintext (%s) don't match", string(message), string(plaintext))
    38  	}
    39  }
    40  
    41  func TestCurve25519EncryptDecryptEphemeral(t *testing.T) {
    42  	message := []byte("this is a simple message")
    43  
    44  	toPublicKey, toPrivateKey, err := GenerateCurve25519KeyPair()
    45  	if err != nil {
    46  		t.Error(err)
    47  	}
    48  
    49  	ciphertext, ephemeralPublicKey, err := toPublicKey.EncryptEphemeral(message)
    50  	if err != nil {
    51  		t.Error(err)
    52  	}
    53  
    54  	plaintext, err := toPrivateKey.DecryptEphemeral(ephemeralPublicKey, ciphertext)
    55  	if err != nil {
    56  		t.Error(err)
    57  	}
    58  
    59  	if !ConstantTimeCompare(message, plaintext) {
    60  		t.Errorf("Message (%s) and plaintext (%s) don't match", string(message), string(plaintext))
    61  	}
    62  }
    63  
    64  func TestCurve25519KeyExchanges(t *testing.T) {
    65  	publicKey1, privateKey1, err := GenerateCurve25519KeyPair()
    66  	if err != nil {
    67  		t.Error(err)
    68  	}
    69  
    70  	publicKey2, privateKey2, err := GenerateCurve25519KeyPair()
    71  	if err != nil {
    72  		t.Error(err)
    73  	}
    74  
    75  	sharedSecret1, err := privateKey1.KeyExchange(publicKey2)
    76  	if err != nil {
    77  		t.Error(err)
    78  	}
    79  
    80  	sharedSecret2, err := privateKey2.KeyExchange(publicKey1)
    81  	if err != nil {
    82  		t.Error(err)
    83  	}
    84  
    85  	if !ConstantTimeCompare(sharedSecret1, sharedSecret2) {
    86  		t.Error("SharedSecret1 != SharedSecret2")
    87  	}
    88  }
    89  
    90  func TestCurve25519KeyExchange(t *testing.T) {
    91  	publicKey1, privateKey1, err := GenerateCurve25519KeyPair()
    92  	if err != nil {
    93  		t.Error(err)
    94  	}
    95  
    96  	publicKey2, privateKey2, err := GenerateCurve25519KeyPair()
    97  	if err != nil {
    98  		t.Error(err)
    99  	}
   100  
   101  	sharedSecret1, err := privateKey1.KeyExchange(publicKey2)
   102  	if err != nil {
   103  		t.Error(err)
   104  	}
   105  
   106  	sharedSecret2, err := curve25519.X25519(privateKey1, publicKey2)
   107  	if err != nil {
   108  		t.Error(err)
   109  	}
   110  
   111  	if !ConstantTimeCompare(sharedSecret1, sharedSecret2) {
   112  		t.Error("SharedSecret1 != SharedSecret2")
   113  	}
   114  
   115  	sharedSecret3, err := curve25519.X25519(privateKey2, publicKey1)
   116  	if err != nil {
   117  		t.Error(err)
   118  	}
   119  
   120  	if !ConstantTimeCompare(sharedSecret1, sharedSecret3) {
   121  		t.Error("SharedSecret1 != SharedSecret3")
   122  	}
   123  }
   124  
   125  func TestCurve25519PrivateKeyPublic(t *testing.T) {
   126  	publicKey, privateKey, err := GenerateCurve25519KeyPair()
   127  	if err != nil {
   128  		t.Error(err)
   129  	}
   130  
   131  	publicKey2, err := privateKey.Public()
   132  	if err != nil {
   133  		t.Error(err)
   134  	}
   135  
   136  	if !ConstantTimeCompare(publicKey, publicKey2) {
   137  		t.Error("publicKey != publicKey2")
   138  	}
   139  }
   140  
   141  func TestCurve25519GenerateNonce(t *testing.T) {
   142  	publicKey, _, err := GenerateCurve25519KeyPair()
   143  	if err != nil {
   144  		t.Error(err)
   145  	}
   146  
   147  	ephemeralPublicKey, _, err := GenerateCurve25519KeyPair()
   148  	if err != nil {
   149  		t.Error(err)
   150  	}
   151  
   152  	nonce, err := generateNonce(ephemeralPublicKey, publicKey)
   153  	if err != nil {
   154  		t.Error(err)
   155  	}
   156  
   157  	nonce2, err := generateNonce(ephemeralPublicKey, publicKey)
   158  	if err != nil {
   159  		t.Error(err)
   160  	}
   161  
   162  	if !ConstantTimeCompare(nonce, nonce2) {
   163  		t.Error("nonce != nonce2")
   164  	}
   165  }