vendor/golang.org/x/crypto/nacl/secretbox/secretbox_test.go

   1 // Copyright 2012 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package secretbox
   6
   7 import (
   8         "bytes"
   9         "crypto/rand"
  10         "encoding/hex"
  11         "testing"
  12 )
  13
  14 func TestSealOpen(t *testing.T) {
  15         var key [32]byte
  16         var nonce [24]byte
  17
  18         rand.Reader.Read(key[:])
  19         rand.Reader.Read(nonce[:])
  20
  21         var box, opened []byte
  22
  23         for msgLen := 0; msgLen < 128; msgLen += 17 {
  24                 message := make([]byte, msgLen)
  25                 rand.Reader.Read(message)
  26
  27                 box = Seal(box[:0], message, &nonce, &key)
  28                 var ok bool
  29                 opened, ok = Open(opened[:0], box, &nonce, &key)
  30                 if !ok {
  31                         t.Errorf("%d: failed to open box", msgLen)
  32                         continue
  33                 }
  34
  35                 if !bytes.Equal(opened, message) {
  36                         t.Errorf("%d: got %x, expected %x", msgLen, opened, message)
  37                         continue
  38                 }
  39         }
  40
  41         for i := range box {
  42                 box[i] ^= 0x20
  43                 _, ok := Open(opened[:0], box, &nonce, &key)
  44                 if ok {
  45                         t.Errorf("box was opened after corrupting byte %d", i)
  46                 }
  47                 box[i] ^= 0x20
  48         }
  49 }
  50
  51 func TestSecretBox(t *testing.T) {
  52         var key [32]byte
  53         var nonce [24]byte
  54         var message [64]byte
  55
  56         for i := range key[:] {
  57                 key[i] = 1
  58         }
  59         for i := range nonce[:] {
  60                 nonce[i] = 2
  61         }
  62         for i := range message[:] {
  63                 message[i] = 3
  64         }
  65
  66         box := Seal(nil, message[:], &nonce, &key)
  67         // expected was generated using the C implementation of NaCl.
  68         expected, _ := hex.DecodeString("8442bc313f4626f1359e3b50122b6ce6fe66ddfe7d39d14e637eb4fd5b45beadab55198df6ab5368439792a23c87db70acb6156dc5ef957ac04f6276cf6093b84be77ff0849cc33e34b7254d5a8f65ad")
  69
  70         if !bytes.Equal(box, expected) {
  71                 t.Fatalf("box didn't match, got\n%x\n, expected\n%x", box, expected)
  72         }
  73 }
  74
  75 func TestAppend(t *testing.T) {
  76         var key [32]byte
  77         var nonce [24]byte
  78         var message [8]byte
  79
  80         out := make([]byte, 4)
  81         box := Seal(out, message[:], &nonce, &key)
  82         if !bytes.Equal(box[:4], out[:4]) {
  83                 t.Fatalf("Seal didn't correctly append")
  84         }
  85
  86         out = make([]byte, 4, 100)
  87         box = Seal(out, message[:], &nonce, &key)
  88         if !bytes.Equal(box[:4], out[:4]) {
  89                 t.Fatalf("Seal didn't correctly append with sufficient capacity.")
  90         }
  91 }
  92
  93 func benchmarkSealSize(b *testing.B, size int) {
  94         message := make([]byte, size)
  95         out := make([]byte, size+Overhead)
  96         var nonce [24]byte
  97         var key [32]byte
  98
  99         b.SetBytes(int64(size))
 100         b.ResetTimer()
 101
 102         for i := 0; i < b.N; i++ {
 103                 out = Seal(out[:0], message, &nonce, &key)
 104         }
 105 }
 106
 107 func BenchmarkSeal8Bytes(b *testing.B) {
 108         benchmarkSealSize(b, 8)
 109 }
 110
 111 func BenchmarkSeal100Bytes(b *testing.B) {
 112         benchmarkSealSize(b, 100)
 113 }
 114
 115 func BenchmarkSeal1K(b *testing.B) {
 116         benchmarkSealSize(b, 1024)
 117 }
 118
 119 func BenchmarkSeal8K(b *testing.B) {
 120         benchmarkSealSize(b, 8192)
 121 }
 122
 123 func benchmarkOpenSize(b *testing.B, size int) {
 124         msg := make([]byte, size)
 125         result := make([]byte, size)
 126         var nonce [24]byte
 127         var key [32]byte
 128         box := Seal(nil, msg, &nonce, &key)
 129
 130         b.SetBytes(int64(size))
 131         b.ResetTimer()
 132
 133         for i := 0; i < b.N; i++ {
 134                 if _, ok := Open(result[:0], box, &nonce, &key); !ok {
 135                         panic("Open failed")
 136                 }
 137         }
 138 }
 139
 140 func BenchmarkOpen8Bytes(b *testing.B) {
 141         benchmarkOpenSize(b, 8)
 142 }
 143
 144 func BenchmarkOpen100Bytes(b *testing.B) {
 145         benchmarkOpenSize(b, 100)
 146 }
 147
 148 func BenchmarkOpen1K(b *testing.B) {
 149         benchmarkOpenSize(b, 1024)
 150 }
 151
 152 func BenchmarkOpen8K(b *testing.B) {
 153         benchmarkOpenSize(b, 8192)
 154 }