155 строки
3.2 KiB
Go
155 строки
3.2 KiB
Go
// Copyright 2012 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package secretbox
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"testing"
|
|
)
|
|
|
|
func TestSealOpen(t *testing.T) {
|
|
var key [32]byte
|
|
var nonce [24]byte
|
|
|
|
rand.Reader.Read(key[:])
|
|
rand.Reader.Read(nonce[:])
|
|
|
|
var box, opened []byte
|
|
|
|
for msgLen := 0; msgLen < 128; msgLen += 17 {
|
|
message := make([]byte, msgLen)
|
|
rand.Reader.Read(message)
|
|
|
|
box = Seal(box[:0], message, &nonce, &key)
|
|
var ok bool
|
|
opened, ok = Open(opened[:0], box, &nonce, &key)
|
|
if !ok {
|
|
t.Errorf("%d: failed to open box", msgLen)
|
|
continue
|
|
}
|
|
|
|
if !bytes.Equal(opened, message) {
|
|
t.Errorf("%d: got %x, expected %x", msgLen, opened, message)
|
|
continue
|
|
}
|
|
}
|
|
|
|
for i := range box {
|
|
box[i] ^= 0x20
|
|
_, ok := Open(opened[:0], box, &nonce, &key)
|
|
if ok {
|
|
t.Errorf("box was opened after corrupting byte %d", i)
|
|
}
|
|
box[i] ^= 0x20
|
|
}
|
|
}
|
|
|
|
func TestSecretBox(t *testing.T) {
|
|
var key [32]byte
|
|
var nonce [24]byte
|
|
var message [64]byte
|
|
|
|
for i := range key[:] {
|
|
key[i] = 1
|
|
}
|
|
for i := range nonce[:] {
|
|
nonce[i] = 2
|
|
}
|
|
for i := range message[:] {
|
|
message[i] = 3
|
|
}
|
|
|
|
box := Seal(nil, message[:], &nonce, &key)
|
|
// expected was generated using the C implementation of NaCl.
|
|
expected, _ := hex.DecodeString("8442bc313f4626f1359e3b50122b6ce6fe66ddfe7d39d14e637eb4fd5b45beadab55198df6ab5368439792a23c87db70acb6156dc5ef957ac04f6276cf6093b84be77ff0849cc33e34b7254d5a8f65ad")
|
|
|
|
if !bytes.Equal(box, expected) {
|
|
t.Fatalf("box didn't match, got\n%x\n, expected\n%x", box, expected)
|
|
}
|
|
}
|
|
|
|
func TestAppend(t *testing.T) {
|
|
var key [32]byte
|
|
var nonce [24]byte
|
|
var message [8]byte
|
|
|
|
out := make([]byte, 4)
|
|
box := Seal(out, message[:], &nonce, &key)
|
|
if !bytes.Equal(box[:4], out[:4]) {
|
|
t.Fatalf("Seal didn't correctly append")
|
|
}
|
|
|
|
out = make([]byte, 4, 100)
|
|
box = Seal(out, message[:], &nonce, &key)
|
|
if !bytes.Equal(box[:4], out[:4]) {
|
|
t.Fatalf("Seal didn't correctly append with sufficient capacity.")
|
|
}
|
|
}
|
|
|
|
func benchmarkSealSize(b *testing.B, size int) {
|
|
message := make([]byte, size)
|
|
out := make([]byte, size+Overhead)
|
|
var nonce [24]byte
|
|
var key [32]byte
|
|
|
|
b.SetBytes(int64(size))
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
out = Seal(out[:0], message, &nonce, &key)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSeal8Bytes(b *testing.B) {
|
|
benchmarkSealSize(b, 8)
|
|
}
|
|
|
|
func BenchmarkSeal100Bytes(b *testing.B) {
|
|
benchmarkSealSize(b, 100)
|
|
}
|
|
|
|
func BenchmarkSeal1K(b *testing.B) {
|
|
benchmarkSealSize(b, 1024)
|
|
}
|
|
|
|
func BenchmarkSeal8K(b *testing.B) {
|
|
benchmarkSealSize(b, 8192)
|
|
}
|
|
|
|
func benchmarkOpenSize(b *testing.B, size int) {
|
|
msg := make([]byte, size)
|
|
result := make([]byte, size)
|
|
var nonce [24]byte
|
|
var key [32]byte
|
|
box := Seal(nil, msg, &nonce, &key)
|
|
|
|
b.SetBytes(int64(size))
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
if _, ok := Open(result[:0], box, &nonce, &key); !ok {
|
|
panic("Open failed")
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkOpen8Bytes(b *testing.B) {
|
|
benchmarkOpenSize(b, 8)
|
|
}
|
|
|
|
func BenchmarkOpen100Bytes(b *testing.B) {
|
|
benchmarkOpenSize(b, 100)
|
|
}
|
|
|
|
func BenchmarkOpen1K(b *testing.B) {
|
|
benchmarkOpenSize(b, 1024)
|
|
}
|
|
|
|
func BenchmarkOpen8K(b *testing.B) {
|
|
benchmarkOpenSize(b, 8192)
|
|
}
|