src/pkg/crypto/block/xor_test.go

// Copyright 2009 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 block

import (
	"bytes";
	"crypto/block";
	"fmt";
	"io";
	"testing";
	"testing/iotest";
)

// Simple "pseudo-random" stream for testing.
type incStream struct {
	buf []byte;
	n byte;
}

func newIncStream(blockSize int) *incStream {
	x := new(incStream);
	x.buf = make([]byte, blockSize);
	return x;
}

func (x *incStream) Next() []byte {
	x.n++;
	for i := range x.buf {
		x.buf[i] = x.n;
		x.n++;
	}
	return x.buf;
}

func testXorWriter(t *testing.T, maxio int) {
	var plain, crypt [256]byte;
	for i := 0; i < len(plain); i++ {
		plain[i] = byte(i);
	}
	b := new(bytes.Buffer);
	for block := 1; block <= 64 && block <= maxio; block *= 2 {
		// compute encrypted version
		n := byte(0);
		for i := 0; i < len(crypt); i++ {
			if i % block == 0 {
				n++;
			}
			crypt[i] = plain[i] ^ n;
			n++;
		}

		for frag := 0; frag < 2; frag++ {
			test := fmt.Sprintf("block=%d frag=%d maxio=%d", block, frag, maxio);
			b.Reset();
			r := io.NewByteReader(&plain);
			s := newIncStream(block);
			w := newXorWriter(s, b);

			// copy plain into w in increasingly large chunks: 1, 1, 2, 4, 8, ...
			// if frag != 0, move the 1 to the end to cause fragmentation.
			if frag == 0 {
				nn, err := io.Copyn(r, w, 1);
				if err != nil {
					t.Errorf("%s: first Copyn: %s", test, err);
					continue;
				}
			}
			for n := 1; n <= len(plain)/2; n *= 2 {
				nn, err := io.Copyn(r, w, int64(n));
				if err != nil {
					t.Errorf("%s: Copyn %d: %s", test, n, err);
				}
			}

			// check output
			crypt := crypt[0:len(crypt) - frag];
			data := b.Data();
			if len(data) != len(crypt) {
				t.Errorf("%s: want %d bytes, got %d", test, len(crypt), len(data));
				continue;
			}

			if string(data) != string(crypt) {
				t.Errorf("%s: want %x got %x", test, data, crypt);
			}
		}
	}
}


func TestXorWriter(t *testing.T) {
	// Do shorter I/O sizes first; they're easier to debug.
	for n := 1; n <= 256 && !t.Failed(); n *= 2 {
		testXorWriter(t, n);
	}
}

func testXorReader(t *testing.T, maxio int) {
	var readers = []func(io.Reader) io.Reader {
		func (r io.Reader) io.Reader { return r },
		iotest.OneByteReader,
		iotest.HalfReader,
	};
	var plain, crypt [256]byte;
	for i := 0; i < len(plain); i++ {
		plain[i] = byte(255 - i);
	}
	b := new(bytes.Buffer);
	for block := 1; block <= 64 && block <= maxio; block *= 2 {
		// compute encrypted version
		n := byte(0);
		for i := 0; i < len(crypt); i++ {
			if i % block == 0 {
				n++;
			}
			crypt[i] = plain[i] ^ n;
			n++;
		}

		for mode := 0; mode < len(readers); mode++ {
			for frag := 0; frag < 2; frag++ {
				test := fmt.Sprintf("block=%d mode=%d frag=%d maxio=%d", block, mode, frag, maxio);
				s := newIncStream(block);
				b.Reset();
				r := newXorReader(s, readers[mode](io.NewByteReader(crypt[0:maxio])));

				// read from crypt in increasingly large chunks: 1, 1, 2, 4, 8, ...
				// if frag == 1, move the 1 to the end to cause fragmentation.
				if frag == 0 {
					nn, err := io.Copyn(r, b, 1);
					if err != nil {
						t.Errorf("%s: first Copyn: %s", test, err);
						continue;
					}
				}
				for n := 1; n <= maxio/2; n *= 2 {
					nn, err := io.Copyn(r, b, int64(n));
					if err != nil {
						t.Errorf("%s: Copyn %d: %s", test, n, err);
					}
				}

				// check output
				data := b.Data();
				crypt := crypt[0:maxio - frag];
				plain := plain[0:maxio - frag];
				if len(data) != len(plain) {
					t.Errorf("%s: want %d bytes, got %d", test, len(plain), len(data));
					continue;
				}

				if string(data) != string(plain) {
					t.Errorf("%s: input=%x want %x got %x", test, crypt, plain, data);
				}
			}
		}
	}
}

func TestXorReader(t *testing.T) {
	// Do shorter I/O sizes first; they're easier to debug.
	for n := 1; n <= 256 && !t.Failed(); n *= 2 {
		testXorReader(t, n);
	}
}

// TODO(rsc): Test handling of writes after write errors.