Add sbuf.
This commit is contained in:
Kyle Isom
parent
4f2f124707
commit
c2dca76803
|
|
@ -0,0 +1,15 @@
|
|||
My source code has the following license:
|
||||
|
||||
Copyright (c) 2015 Kyle Isom <kyle@tyrfingr.is>
|
||||
|
||||
Permission to use, copy, modify, and distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
copyright notice and this permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
// Package sbuf implements a byte buffer that can be wiped. The underlying
|
||||
// byte slice is wiped on read before being declaimed, and when the
|
||||
// buffer is closed, its storage is zeroised.
|
||||
package sbuf
|
||||
|
||||
import "io"
|
||||
|
||||
func zero(in []byte, n int) {
|
||||
if in == nil {
|
||||
return
|
||||
}
|
||||
|
||||
stop := n
|
||||
if stop > len(in) || stop == 0 {
|
||||
stop = len(in)
|
||||
}
|
||||
|
||||
for i := 0; i < stop; i++ {
|
||||
in[i] ^= in[i]
|
||||
}
|
||||
}
|
||||
|
||||
// A Buffer is a variable-sized buffer of bytes with Read and Write
|
||||
// methods. The zero value for Buffer is an empty buffer ready to use.
|
||||
type Buffer struct {
|
||||
buf []byte
|
||||
}
|
||||
|
||||
// NewBuffer creates a new buffer with the specified capacity.
|
||||
func NewBuffer(n int) *Buffer {
|
||||
return &Buffer{
|
||||
buf: make([]byte, 0, n),
|
||||
}
|
||||
}
|
||||
|
||||
// NewBufferFrom creates a new buffer from the byte slice passed in. The
|
||||
// original data will be wiped.
|
||||
func NewBufferFrom(p []byte) *Buffer {
|
||||
buf := NewBuffer(len(p))
|
||||
buf.Write(p)
|
||||
zero(p, len(p))
|
||||
return buf
|
||||
}
|
||||
|
||||
// Read reads the next len(p) bytes from the buffer or until the buffer
|
||||
// is drained. The return value n is the number of bytes read. If the
|
||||
// buffer has no data to return, err is io.EOF (unless len(p) is zero);
|
||||
// otherwise it is nil.
|
||||
func (buf *Buffer) Read(p []byte) (int, error) {
|
||||
if len(buf.buf) == 0 {
|
||||
if len(p) == 0 {
|
||||
return 0, nil
|
||||
}
|
||||
return 0, io.EOF
|
||||
}
|
||||
|
||||
copyLength := len(p)
|
||||
if copyLength > len(buf.buf) {
|
||||
copyLength = len(buf.buf)
|
||||
}
|
||||
|
||||
copy(p, buf.buf)
|
||||
zero(buf.buf, len(p))
|
||||
buf.buf = buf.buf[copyLength:]
|
||||
return copyLength, nil
|
||||
}
|
||||
|
||||
// ReadByte reads the next byte from the buffer. If the buffer has no
|
||||
// data to return, err is io.EOF; otherwise it is nil.
|
||||
func (buf *Buffer) ReadByte() (byte, error) {
|
||||
if len(buf.buf) == 0 {
|
||||
return 0, io.EOF
|
||||
}
|
||||
|
||||
c := buf.buf[0]
|
||||
buf.buf[0] = 0
|
||||
buf.buf = buf.buf[1:]
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (buf *Buffer) grow(n int) {
|
||||
tmp := make([]byte, len(buf.buf), len(buf.buf)+n)
|
||||
copy(tmp, buf.buf)
|
||||
zero(buf.buf, len(buf.buf))
|
||||
buf.buf = tmp
|
||||
}
|
||||
|
||||
// Write appends the contents of p to the buffer, growing the buffer
|
||||
// as needed. The return value n is the length of p; err is always nil.
|
||||
func (buf *Buffer) Write(p []byte) (int, error) {
|
||||
r := len(buf.buf) + len(p)
|
||||
if cap(buf.buf) < r {
|
||||
l := r
|
||||
for {
|
||||
if l > r {
|
||||
break
|
||||
}
|
||||
l *= 2
|
||||
}
|
||||
buf.grow(l - cap(buf.buf))
|
||||
}
|
||||
buf.buf = append(buf.buf, p...)
|
||||
return len(p), nil
|
||||
}
|
||||
|
||||
// WriteByte adds the byte c to the buffer, growing the buffer as needed.
|
||||
func (buf *Buffer) WriteByte(c byte) error {
|
||||
r := len(buf.buf) + 1
|
||||
if cap(buf.buf) < r {
|
||||
l := r * 2
|
||||
buf.grow(l - cap(buf.buf))
|
||||
}
|
||||
buf.buf = append(buf.buf, c)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Close destroys and zeroises the buffer. The buffer will be re-opened
|
||||
// on the next write.
|
||||
func (buf *Buffer) Close() {
|
||||
zero(buf.buf, len(buf.buf))
|
||||
buf.buf = nil
|
||||
}
|
||||
|
||||
// Len returns the length of the buffer.
|
||||
func (buf *Buffer) Len() int {
|
||||
return len(buf.buf)
|
||||
}
|
||||
|
||||
// Cap returns the capacity of the buffer.
|
||||
func (buf *Buffer) Cap() int {
|
||||
return cap(buf.buf)
|
||||
}
|
||||
|
||||
// Bytes returns the bytes currently in the buffer, and closes itself.
|
||||
func (buf *Buffer) Bytes() []byte {
|
||||
if buf.buf == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
p := make([]byte, buf.Len())
|
||||
buf.Read(p)
|
||||
buf.Close()
|
||||
return p
|
||||
}
|
||||
|
|
@ -0,0 +1,240 @@
|
|||
package sbuf
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/rand"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/crypto/nacl/box"
|
||||
)
|
||||
|
||||
var (
|
||||
buf = &Buffer{}
|
||||
testMessage1 = []byte("round and round and round we go, where we stop, no one knows")
|
||||
testMessage2 = []byte("the deconstruction of falling stars")
|
||||
)
|
||||
|
||||
func TestWrite(t *testing.T) {
|
||||
n, err := buf.Write(testMessage1)
|
||||
if err != nil {
|
||||
t.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
if n != len(testMessage1) {
|
||||
t.Fatalf("expected to write %d bytes, but only wrote %d bytes", len(testMessage1), n)
|
||||
}
|
||||
|
||||
if buf.Len() != len(testMessage1) {
|
||||
t.Fatalf("expected a length of %d, but have a length of %d", len(testMessage1), buf.Len())
|
||||
}
|
||||
|
||||
if buf.Cap() != (len(testMessage1) * 2) {
|
||||
t.Fatalf("expected a capacity of %d, but have a capacity of %d", len(testMessage1)*2, buf.Cap())
|
||||
}
|
||||
|
||||
n, err = buf.Write(testMessage2)
|
||||
if err != nil {
|
||||
t.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
if n != len(testMessage2) {
|
||||
t.Fatalf("expected to write %d bytes, but only wrote %d bytes", len(testMessage2), n)
|
||||
}
|
||||
|
||||
n, err = buf.Write(testMessage2)
|
||||
if err != nil {
|
||||
t.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
if n != len(testMessage2) {
|
||||
t.Fatalf("expected to write %d bytes, but only wrote %d bytes", len(testMessage2), n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRead(t *testing.T) {
|
||||
var p = make([]byte, len(testMessage1))
|
||||
n, err := buf.Read(p)
|
||||
if err != nil {
|
||||
t.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
if n != len(testMessage1) {
|
||||
t.Fatalf("expected to read %d bytes, but only read %d bytes", len(testMessage1), n)
|
||||
}
|
||||
|
||||
if !bytes.Equal(p, testMessage1) {
|
||||
t.Fatalf("expected p='%s', but p='%s'", testMessage1, p)
|
||||
}
|
||||
|
||||
p = make([]byte, len(testMessage2))
|
||||
n, err = buf.Read(p)
|
||||
if err != nil {
|
||||
t.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
if n != len(testMessage2) {
|
||||
t.Fatalf("expected to read %d bytes, but only read %d bytes", len(testMessage2), n)
|
||||
}
|
||||
|
||||
if !bytes.Equal(p, testMessage2) {
|
||||
t.Fatalf("expected p='%s', but p='%s'", testMessage2, p)
|
||||
}
|
||||
|
||||
buf.Close()
|
||||
n, err = buf.Read(p)
|
||||
if err == nil {
|
||||
t.Fatal("expected EOF")
|
||||
} else if n != 0 {
|
||||
t.Fatalf("expect n=0, but n=%d", n)
|
||||
}
|
||||
|
||||
p = nil
|
||||
n, err = buf.Read(p)
|
||||
if err != nil {
|
||||
t.Fatalf("%v", err)
|
||||
} else if n != 0 {
|
||||
t.Fatalf("expect n=0, but n=%d", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestShortRead(t *testing.T) {
|
||||
tmpMessage := []byte("hello, world")
|
||||
buf.Write(tmpMessage)
|
||||
|
||||
var p = make([]byte, len(testMessage1))
|
||||
n, err := buf.Read(p)
|
||||
if err != nil {
|
||||
t.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
if n != len(tmpMessage) {
|
||||
t.Fatalf("expected to read %d bytes, but only read %d bytes", len(testMessage1), n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewBuffer(t *testing.T) {
|
||||
buf := NewBuffer(32)
|
||||
if len(buf.buf) != 0 {
|
||||
t.Fatalf("expected new buffer length to be 0, have %d",
|
||||
len(buf.buf))
|
||||
}
|
||||
|
||||
if cap(buf.buf) != 32 {
|
||||
t.Fatalf("expected new buffer capacity to be 0, have %d",
|
||||
cap(buf.buf))
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewBufferFrom(t *testing.T) {
|
||||
p := make([]byte, len(testMessage1))
|
||||
copy(p, testMessage1)
|
||||
buf := NewBufferFrom(p)
|
||||
if !bytes.Equal(buf.buf, testMessage1) {
|
||||
t.Fatal("new buffer wasn't constructed properly")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBytes(t *testing.T) {
|
||||
p := make([]byte, len(testMessage1))
|
||||
copy(p, testMessage1)
|
||||
buf := NewBufferFrom(p)
|
||||
|
||||
out := buf.Bytes()
|
||||
if buf.buf != nil {
|
||||
t.Fatal("buffer was not closed")
|
||||
}
|
||||
|
||||
if !bytes.Equal(out, testMessage1) {
|
||||
t.Fatal("buffer did not return the right data")
|
||||
}
|
||||
|
||||
out = buf.Bytes()
|
||||
if out != nil {
|
||||
t.Fatal("a closed buffer should return nil for Bytes")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRWByte(t *testing.T) {
|
||||
buf := NewBuffer(0)
|
||||
c := byte(42)
|
||||
err := buf.WriteByte(c)
|
||||
if err != nil {
|
||||
t.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
c, err = buf.ReadByte()
|
||||
if err != nil {
|
||||
t.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
if c != 42 {
|
||||
t.Fatal("Expected 42, have %d", c)
|
||||
}
|
||||
|
||||
_, err = buf.ReadByte()
|
||||
if err == nil {
|
||||
t.Fatal("Expected EOF")
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkRead(b *testing.B) {
|
||||
b.N = 2000
|
||||
pub, priv, err := box.GenerateKey(rand.Reader)
|
||||
if err != nil {
|
||||
b.Fatalf("%v", err)
|
||||
}
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, err := buf.Write(priv[:])
|
||||
if err != nil {
|
||||
b.Fatalf("%v", err)
|
||||
}
|
||||
_, err = buf.Write(pub[:])
|
||||
if err != nil {
|
||||
b.Fatalf("%v", err)
|
||||
}
|
||||
b.SetBytes(64)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkFixed(b *testing.B) {
|
||||
pub, priv, err := box.GenerateKey(rand.Reader)
|
||||
if err != nil {
|
||||
b.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
buf = NewBuffer(64 * b.N)
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, err := buf.Write(priv[:])
|
||||
if err != nil {
|
||||
b.Fatalf("%v", err)
|
||||
}
|
||||
_, err = buf.Write(pub[:])
|
||||
if err != nil {
|
||||
b.Fatalf("%v", err)
|
||||
}
|
||||
b.SetBytes(64)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkWrite(b *testing.B) {
|
||||
var pub = new([32]byte)
|
||||
var priv = new([32]byte)
|
||||
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N && buf.Len() >= 64; i++ {
|
||||
_, err := buf.Read(priv[:])
|
||||
if err != nil {
|
||||
b.Fatalf("%v", err)
|
||||
}
|
||||
_, err = buf.Read(pub[:])
|
||||
if err != nil {
|
||||
b.Fatalf("%v", err)
|
||||
}
|
||||
b.SetBytes(64)
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue