125 lines
2.4 KiB
Go
125 lines
2.4 KiB
Go
package node
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
"log"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"golang.org/x/crypto/nacl/box"
|
|
)
|
|
|
|
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)
|
|
}
|
|
|
|
log.Printf("\n%#v\n%#v\n%#v\n%#v\n", pubKey1, privKey1, pubKey2, privKey2)
|
|
|
|
sharedEncKey := [32]byte{}
|
|
box.Precompute(&sharedEncKey, pubKey2, privKey1)
|
|
|
|
sharedDecKey := [32]byte{}
|
|
box.Precompute(&sharedDecKey, pubKey1, privKey2)
|
|
|
|
original := make([]byte, if_mtu-64)
|
|
rand.Read(original)
|
|
|
|
h := header{
|
|
Counter: 2893749238,
|
|
SourceIP: 5,
|
|
ViaIP: 8,
|
|
DestIP: 12,
|
|
PacketType: 32,
|
|
}
|
|
|
|
encrypted := make([]byte, bufferSize)
|
|
encrypted = encryptPacket(&h, sharedEncKey[:], original, encrypted)
|
|
|
|
decrypted := make([]byte, bufferSize)
|
|
var ok bool
|
|
decrypted, ok = decryptPacket(sharedDecKey[:], encrypted, decrypted)
|
|
if !ok {
|
|
t.Fatal(ok)
|
|
}
|
|
|
|
var h2 header
|
|
h2.Parse(encrypted)
|
|
|
|
if !reflect.DeepEqual(h, h2) {
|
|
t.Fatal(h, h2)
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
*/
|