Move all backends into backend directory

backend/crypt/pkcs7/pkcs7.go

@@ -0,0 +1,63 @@
+// Package pkcs7 implements PKCS#7 padding
+//
+// This is a standard way of encoding variable length buffers into
+// buffers which are a multiple of an underlying crypto block size.
+package pkcs7
+
+import "github.com/pkg/errors"
+
+// Errors Unpad can return
+var (
+	ErrorPaddingNotFound      = errors.New("Bad PKCS#7 padding - not padded")
+	ErrorPaddingNotAMultiple  = errors.New("Bad PKCS#7 padding - not a multiple of blocksize")
+	ErrorPaddingTooLong       = errors.New("Bad PKCS#7 padding - too long")
+	ErrorPaddingTooShort      = errors.New("Bad PKCS#7 padding - too short")
+	ErrorPaddingNotAllTheSame = errors.New("Bad PKCS#7 padding - not all the same")
+)
+
+// Pad buf using PKCS#7 to a multiple of n.
+//
+// Appends the padding to buf - make a copy of it first if you don't
+// want it modified.
+func Pad(n int, buf []byte) []byte {
+	if n <= 1 || n >= 256 {
+		panic("bad multiple")
+	}
+	length := len(buf)
+	padding := n - (length % n)
+	for i := 0; i < padding; i++ {
+		buf = append(buf, byte(padding))
+	}
+	if (len(buf) % n) != 0 {
+		panic("padding failed")
+	}
+	return buf
+}
+
+// Unpad buf using PKCS#7 from a multiple of n returning a slice of
+// buf or an error if malformed.
+func Unpad(n int, buf []byte) ([]byte, error) {
+	if n <= 1 || n >= 256 {
+		panic("bad multiple")
+	}
+	length := len(buf)
+	if length == 0 {
+		return nil, ErrorPaddingNotFound
+	}
+	if (length % n) != 0 {
+		return nil, ErrorPaddingNotAMultiple
+	}
+	padding := int(buf[length-1])
+	if padding > n {
+		return nil, ErrorPaddingTooLong
+	}
+	if padding == 0 {
+		return nil, ErrorPaddingTooShort
+	}
+	for i := 0; i < padding; i++ {
+		if buf[length-1-i] != byte(padding) {
+			return nil, ErrorPaddingNotAllTheSame
+		}
+	}
+	return buf[:length-padding], nil
+}

backend/crypt/pkcs7/pkcs7_test.go

@@ -0,0 +1,73 @@
+package pkcs7
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPad(t *testing.T) {
+	for _, test := range []struct {
+		n        int
+		in       string
+		expected string
+	}{
+		{8, "", "\x08\x08\x08\x08\x08\x08\x08\x08"},
+		{8, "1", "1\x07\x07\x07\x07\x07\x07\x07"},
+		{8, "12", "12\x06\x06\x06\x06\x06\x06"},
+		{8, "123", "123\x05\x05\x05\x05\x05"},
+		{8, "1234", "1234\x04\x04\x04\x04"},
+		{8, "12345", "12345\x03\x03\x03"},
+		{8, "123456", "123456\x02\x02"},
+		{8, "1234567", "1234567\x01"},
+		{8, "abcdefgh", "abcdefgh\x08\x08\x08\x08\x08\x08\x08\x08"},
+		{8, "abcdefgh1", "abcdefgh1\x07\x07\x07\x07\x07\x07\x07"},
+		{8, "abcdefgh12", "abcdefgh12\x06\x06\x06\x06\x06\x06"},
+		{8, "abcdefgh123", "abcdefgh123\x05\x05\x05\x05\x05"},
+		{8, "abcdefgh1234", "abcdefgh1234\x04\x04\x04\x04"},
+		{8, "abcdefgh12345", "abcdefgh12345\x03\x03\x03"},
+		{8, "abcdefgh123456", "abcdefgh123456\x02\x02"},
+		{8, "abcdefgh1234567", "abcdefgh1234567\x01"},
+		{8, "abcdefgh12345678", "abcdefgh12345678\x08\x08\x08\x08\x08\x08\x08\x08"},
+		{16, "", "\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10"},
+		{16, "a", "a\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f"},
+	} {
+		actual := Pad(test.n, []byte(test.in))
+		assert.Equal(t, test.expected, string(actual), fmt.Sprintf("Pad %d %q", test.n, test.in))
+		recovered, err := Unpad(test.n, actual)
+		assert.NoError(t, err)
+		assert.Equal(t, []byte(test.in), recovered, fmt.Sprintf("Unpad %d %q", test.n, test.in))
+	}
+	assert.Panics(t, func() { Pad(1, []byte("")) }, "bad multiple")
+	assert.Panics(t, func() { Pad(256, []byte("")) }, "bad multiple")
+}
+
+func TestUnpad(t *testing.T) {
+	// We've tested the OK decoding in TestPad, now test the error cases
+	for _, test := range []struct {
+		n   int
+		in  string
+		err error
+	}{
+		{8, "", ErrorPaddingNotFound},
+		{8, "1", ErrorPaddingNotAMultiple},
+		{8, "12", ErrorPaddingNotAMultiple},
+		{8, "123", ErrorPaddingNotAMultiple},
+		{8, "1234", ErrorPaddingNotAMultiple},
+		{8, "12345", ErrorPaddingNotAMultiple},
+		{8, "123456", ErrorPaddingNotAMultiple},
+		{8, "1234567", ErrorPaddingNotAMultiple},
+		{8, "1234567\xFF", ErrorPaddingTooLong},
+		{8, "1234567\x09", ErrorPaddingTooLong},
+		{8, "1234567\x00", ErrorPaddingTooShort},
+		{8, "123456\x01\x02", ErrorPaddingNotAllTheSame},
+		{8, "\x07\x08\x08\x08\x08\x08\x08\x08", ErrorPaddingNotAllTheSame},
+	} {
+		result, actualErr := Unpad(test.n, []byte(test.in))
+		assert.Equal(t, test.err, actualErr, fmt.Sprintf("Unpad %d %q", test.n, test.in))
+		assert.Equal(t, result, []byte(nil))
+	}
+	assert.Panics(t, func() { _, _ = Unpad(1, []byte("")) }, "bad multiple")
+	assert.Panics(t, func() { _, _ = Unpad(256, []byte("")) }, "bad multiple")
+}