139 lines
2.3 KiB
Go
139 lines
2.3 KiB
Go
package goxifrat
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
"testing"
|
|
)
|
|
|
|
func TestKeyAgreement(t *testing.T) {
|
|
ka, err := NewKeyAgreement(rand.Reader)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
kb, err := NewKeyAgreement(rand.Reader)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
i, err := ka.InitPhase(rand.Reader)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
sb, a, err := kb.SharedSecret(i)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
sa, _, err := ka.SharedSecret(a)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !bytes.Equal(sa, sb) {
|
|
t.Error("shared secrets are not equal")
|
|
}
|
|
}
|
|
|
|
func TestSign(t *testing.T) {
|
|
h, err := randomArray(rand.Reader)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
hash := encode(h)
|
|
priv, err := GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
_, err = priv.Sign(rand.Reader, hash)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestVerify(t *testing.T) {
|
|
h, err := randomArray(rand.Reader)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
hash := encode(h)
|
|
priv, err := GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
s, err := priv.Sign(rand.Reader, hash)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !Verify(&priv.PublicKey, hash, s) {
|
|
t.Error("verify failed")
|
|
}
|
|
}
|
|
|
|
func BenchmarkM(b *testing.B) {
|
|
b.ReportAllocs()
|
|
tc, _ := randomArray(rand.Reader)
|
|
tk, _ := randomArray(rand.Reader)
|
|
for i := 0; i < b.N; i++ {
|
|
m(tc, tk)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSign(b *testing.B) {
|
|
b.ReportAllocs()
|
|
h, err := randomArray(rand.Reader)
|
|
if err != nil {
|
|
b.Error(err)
|
|
}
|
|
hash := encode(h)
|
|
priv, err := GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
b.Error(err)
|
|
}
|
|
for i := 0; i < b.N; i++ {
|
|
_, err := priv.Sign(rand.Reader, hash)
|
|
if err != nil {
|
|
b.Error(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkVerify(b *testing.B) {
|
|
b.ReportAllocs()
|
|
h, err := randomArray(rand.Reader)
|
|
if err != nil {
|
|
b.Error(err)
|
|
}
|
|
hash := encode(h)
|
|
priv, err := GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
b.Error(err)
|
|
}
|
|
s, err := priv.Sign(rand.Reader, hash)
|
|
if err != nil {
|
|
b.Error(err)
|
|
}
|
|
for i := 0; i < b.N; i++ {
|
|
Verify(&priv.PublicKey, hash, s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkEncode(b *testing.B) {
|
|
b.ReportAllocs()
|
|
h, err := randomArray(rand.Reader)
|
|
if err != nil {
|
|
b.Error(err)
|
|
}
|
|
for i := 0; i < b.N; i++ {
|
|
encode(h)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDecode(b *testing.B) {
|
|
b.ReportAllocs()
|
|
h, err := randomArray(rand.Reader)
|
|
if err != nil {
|
|
b.Error(err)
|
|
}
|
|
e := encode(h)
|
|
for i := 0; i < b.N; i++ {
|
|
decode(e)
|
|
}
|
|
}
|