165 lines
3.3 KiB
Go
165 lines
3.3 KiB
Go
package peer
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
"testing"
|
|
|
|
"golang.org/x/crypto/nacl/box"
|
|
"golang.org/x/crypto/nacl/sign"
|
|
)
|
|
|
|
func TestEncryptDecryptPacket(t *testing.T) {
|
|
pubKey1, privKey1, err := box.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
pubKey2, privKey2, err := box.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sharedEncKey := [32]byte{}
|
|
box.Precompute(&sharedEncKey, pubKey2, privKey1)
|
|
|
|
sharedDecKey := [32]byte{}
|
|
box.Precompute(&sharedDecKey, pubKey1, privKey2)
|
|
|
|
original := make([]byte, MTU)
|
|
rand.Read(original)
|
|
|
|
nonce := make([]byte, NONCE_SIZE)
|
|
rand.Read(nonce)
|
|
|
|
encrypted := make([]byte, BUFFER_SIZE)
|
|
encrypted = encryptPacket(sharedEncKey[:], nonce, original, encrypted)
|
|
|
|
decrypted := make([]byte, MTU)
|
|
var ok bool
|
|
decrypted, ok = decryptPacket(sharedDecKey[:], encrypted, decrypted)
|
|
if !ok {
|
|
t.Fatal(ok)
|
|
}
|
|
|
|
if !bytes.Equal(original, decrypted) {
|
|
t.Fatal("mismatch")
|
|
}
|
|
}
|
|
|
|
func BenchmarkEncryptPacket(b *testing.B) {
|
|
_, privKey1, err := box.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
pubKey2, _, err := box.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
sharedEncKey := [32]byte{}
|
|
box.Precompute(&sharedEncKey, pubKey2, privKey1)
|
|
|
|
original := make([]byte, MTU)
|
|
rand.Read(original)
|
|
|
|
nonce := make([]byte, NONCE_SIZE)
|
|
rand.Read(nonce)
|
|
|
|
encrypted := make([]byte, BUFFER_SIZE)
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
encrypted = encryptPacket(sharedEncKey[:], nonce, original, encrypted)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDecryptPacket(b *testing.B) {
|
|
pubKey1, privKey1, err := box.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
pubKey2, privKey2, err := box.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
sharedEncKey := [32]byte{}
|
|
box.Precompute(&sharedEncKey, pubKey2, privKey1)
|
|
|
|
sharedDecKey := [32]byte{}
|
|
box.Precompute(&sharedDecKey, pubKey1, privKey2)
|
|
|
|
original := make([]byte, MTU)
|
|
rand.Read(original)
|
|
|
|
nonce := make([]byte, NONCE_SIZE)
|
|
rand.Read(nonce)
|
|
|
|
encrypted := make([]byte, BUFFER_SIZE)
|
|
encrypted = encryptPacket(sharedEncKey[:], nonce, original, encrypted)
|
|
|
|
decrypted := make([]byte, MTU)
|
|
for i := 0; i < b.N; i++ {
|
|
decrypted, _ = decryptPacket(sharedDecKey[:], encrypted, decrypted)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSignPacket(b *testing.B) {
|
|
_, privKey1, err := sign.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
original := make([]byte, 8192)
|
|
rand.Read(original)
|
|
out := make([]byte, 9000)
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
signPacket(privKey1[:], original, out)
|
|
}
|
|
}
|
|
|
|
func TestSignOpenPacket(t *testing.T) {
|
|
pubKey, privKey, err := sign.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
packet := make([]byte, MTU)
|
|
|
|
rand.Read(packet)
|
|
|
|
signedPacket := signPacket(privKey[:], packet, make([]byte, BUFFER_SIZE))
|
|
|
|
encPacket, ok := openPacket(pubKey[:], signedPacket, make([]byte, BUFFER_SIZE))
|
|
if !ok {
|
|
t.Fatal(ok)
|
|
}
|
|
|
|
if !bytes.Equal(encPacket, packet) {
|
|
t.Fatal("not equal")
|
|
}
|
|
}
|
|
|
|
func BenchmarkOpenPacket(b *testing.B) {
|
|
pubKey, privKey, err := sign.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
packet := make([]byte, MTU)
|
|
|
|
rand.Read(packet)
|
|
|
|
signedPacket := signPacket(privKey[:], packet, make([]byte, 9000))
|
|
out := make([]byte, BUFFER_SIZE)
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
out, _ = openPacket(pubKey[:], signedPacket, out)
|
|
}
|
|
}
|