|
- // Copyright 2016 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 chacha20
-
- import (
- "encoding/hex"
- "fmt"
- "math/rand"
- "testing"
- )
-
- func TestCore(t *testing.T) {
- // This is just a smoke test that checks the example from
- // https://tools.ietf.org/html/rfc7539#section-2.3.2. The
- // chacha20poly1305 package contains much more extensive tests of this
- // code.
- var key [32]byte
- for i := range key {
- key[i] = byte(i)
- }
-
- var input [16]byte
- input[0] = 1
- input[7] = 9
- input[11] = 0x4a
-
- var out [64]byte
- XORKeyStream(out[:], out[:], &input, &key)
- const expected = "10f1e7e4d13b5915500fdd1fa32071c4c7d1f4c733c068030422aa9ac3d46c4ed2826446079faa0914c2d705d98b02a2b5129cd1de164eb9cbd083e8a2503c4e"
- if result := hex.EncodeToString(out[:]); result != expected {
- t.Errorf("wanted %x but got %x", expected, result)
- }
- }
-
- // Run the test cases with the input and output in different buffers.
- func TestNoOverlap(t *testing.T) {
- for _, c := range testVectors {
- s := New(c.key, c.nonce)
- input, err := hex.DecodeString(c.input)
- if err != nil {
- t.Fatalf("cannot decode input %#v: %v", c.input, err)
- }
- output := make([]byte, c.length)
- s.XORKeyStream(output, input)
- got := hex.EncodeToString(output)
- if got != c.output {
- t.Errorf("length=%v: got %#v, want %#v", c.length, got, c.output)
- }
- }
- }
-
- // Run the test cases with the input and output overlapping entirely.
- func TestOverlap(t *testing.T) {
- for _, c := range testVectors {
- s := New(c.key, c.nonce)
- data, err := hex.DecodeString(c.input)
- if err != nil {
- t.Fatalf("cannot decode input %#v: %v", c.input, err)
- }
- s.XORKeyStream(data, data)
- got := hex.EncodeToString(data)
- if got != c.output {
- t.Errorf("length=%v: got %#v, want %#v", c.length, got, c.output)
- }
- }
- }
-
- // Run the test cases with various source and destination offsets.
- func TestUnaligned(t *testing.T) {
- const max = 8 // max offset (+1) to test
- for _, c := range testVectors {
- input := make([]byte, c.length+max)
- output := make([]byte, c.length+max)
- for i := 0; i < max; i++ { // input offsets
- for j := 0; j < max; j++ { // output offsets
- s := New(c.key, c.nonce)
-
- input := input[i : i+c.length]
- output := output[j : j+c.length]
-
- data, err := hex.DecodeString(c.input)
- if err != nil {
- t.Fatalf("cannot decode input %#v: %v", c.input, err)
- }
- copy(input, data)
- s.XORKeyStream(output, input)
- got := hex.EncodeToString(output)
- if got != c.output {
- t.Errorf("length=%v: got %#v, want %#v", c.length, got, c.output)
- }
- }
- }
- }
- }
-
- // Run the test cases by calling XORKeyStream multiple times.
- func TestStep(t *testing.T) {
- // wide range of step sizes to try and hit edge cases
- steps := [...]int{1, 3, 4, 7, 8, 17, 24, 30, 64, 256}
- rnd := rand.New(rand.NewSource(123))
- for _, c := range testVectors {
- s := New(c.key, c.nonce)
- input, err := hex.DecodeString(c.input)
- if err != nil {
- t.Fatalf("cannot decode input %#v: %v", c.input, err)
- }
- output := make([]byte, c.length)
-
- // step through the buffers
- i, step := 0, steps[rnd.Intn(len(steps))]
- for i+step < c.length {
- s.XORKeyStream(output[i:i+step], input[i:i+step])
- if i+step < c.length && output[i+step] != 0 {
- t.Errorf("length=%v, i=%v, step=%v: output overwritten", c.length, i, step)
- }
- i += step
- step = steps[rnd.Intn(len(steps))]
- }
- // finish the encryption
- s.XORKeyStream(output[i:], input[i:])
-
- got := hex.EncodeToString(output)
- if got != c.output {
- t.Errorf("length=%v: got %#v, want %#v", c.length, got, c.output)
- }
- }
- }
-
- // Test that Advance() discards bytes until a block boundary is hit.
- func TestAdvance(t *testing.T) {
- for _, c := range testVectors {
- for i := 0; i < 63; i++ {
- s := New(c.key, c.nonce)
- z := New(c.key, c.nonce)
- input, err := hex.DecodeString(c.input)
- if err != nil {
- t.Fatalf("cannot decode input %#v: %v", c.input, err)
- }
- zeros, discard := make([]byte, 64), make([]byte, 64)
- so, zo := make([]byte, c.length), make([]byte, c.length)
- for j := 0; j < c.length; j += 64 {
- lim := j + i
- if lim > c.length {
- lim = c.length
- }
- s.XORKeyStream(so[j:lim], input[j:lim])
- // calling s.Advance() multiple times should have no effect
- for k := 0; k < i%3+1; k++ {
- s.Advance()
- }
- z.XORKeyStream(zo[j:lim], input[j:lim])
- if lim < c.length {
- end := 64 - i
- if c.length-lim < end {
- end = c.length - lim
- }
- z.XORKeyStream(discard[:], zeros[:end])
- }
- }
-
- got := hex.EncodeToString(so)
- want := hex.EncodeToString(zo)
- if got != want {
- t.Errorf("length=%v: got %#v, want %#v", c.length, got, want)
- }
- }
- }
- }
-
- func BenchmarkChaCha20(b *testing.B) {
- sizes := []int{32, 63, 64, 256, 1024, 1350, 65536}
- for _, size := range sizes {
- s := size
- b.Run(fmt.Sprint(s), func(b *testing.B) {
- k := [32]byte{}
- c := [16]byte{}
- src := make([]byte, s)
- dst := make([]byte, s)
- b.SetBytes(int64(s))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- XORKeyStream(dst, src, &c, &k)
- }
- })
- }
- }
|