vendor
This commit is contained in:
Mikaël Cluseau
355
vendor/github.com/google/certificate-transparency-go/tls/tls_test.go
generated
vendored
Normal file
355
vendor/github.com/google/certificate-transparency-go/tls/tls_test.go
generated
vendored
Normal file
@ -0,0 +1,355 @@
|
||||
// Copyright 2016 Google Inc. All Rights Reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package tls
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
type testStruct struct {
|
||||
Data []byte `tls:"minlen:2,maxlen:4"`
|
||||
IntVal uint16
|
||||
Other [4]byte
|
||||
Enum Enum `tls:"size:2"`
|
||||
}
|
||||
|
||||
type testVariant struct {
|
||||
Which Enum `tls:"size:1"`
|
||||
Val16 *uint16 `tls:"selector:Which,val:0"`
|
||||
Val32 *uint32 `tls:"selector:Which,val:1"`
|
||||
}
|
||||
|
||||
type testTwoVariants struct {
|
||||
Which Enum `tls:"size:1"`
|
||||
Val16 *uint16 `tls:"selector:Which,val:0"`
|
||||
Val32 *uint32 `tls:"selector:Which,val:1"`
|
||||
Second Enum `tls:"size:1"`
|
||||
Second16 *uint16 `tls:"selector:Second,val:0"`
|
||||
Second32 *uint32 `tls:"selector:Second,val:1"`
|
||||
}
|
||||
|
||||
// Check that library users can define their own Enum types.
|
||||
type aliasEnum Enum
|
||||
type testAliasEnum struct {
|
||||
Val aliasEnum `tls:"size:1"`
|
||||
Val16 *uint16 `tls:"selector:Val,val:1"`
|
||||
Val32 *uint32 `tls:"selector:Val,val:2"`
|
||||
}
|
||||
|
||||
type testNonByteSlice struct {
|
||||
Vals []uint16 `tls:"minlen:2,maxlen:6"`
|
||||
}
|
||||
|
||||
type testSliceOfStructs struct {
|
||||
Vals []testVariant `tls:"minlen:0,maxlen:100"`
|
||||
}
|
||||
|
||||
type testInnerType struct {
|
||||
Val []byte `tls:"minlen:0,maxlen:65535"`
|
||||
}
|
||||
|
||||
type testSliceOfSlices struct {
|
||||
Inners []testInnerType `tls:"minlen:0,maxlen:65535"`
|
||||
}
|
||||
|
||||
func TestMarshalUnmarshalRoundTrip(t *testing.T) {
|
||||
thing := testStruct{Data: []byte{0x01, 0x02, 0x03}, IntVal: 42, Other: [4]byte{1, 2, 3, 4}, Enum: 17}
|
||||
data, err := Marshal(thing)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to Marshal(%+v): %s", thing, err.Error())
|
||||
}
|
||||
var other testStruct
|
||||
rest, err := Unmarshal(data, &other)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to Unmarshal(%s)", hex.EncodeToString(data))
|
||||
}
|
||||
if len(rest) > 0 {
|
||||
t.Errorf("Data left over after Unmarshal(%s): %s", hex.EncodeToString(data), hex.EncodeToString(rest))
|
||||
}
|
||||
}
|
||||
|
||||
func TestFieldTagToFieldInfo(t *testing.T) {
|
||||
var tests = []struct {
|
||||
tag string
|
||||
want *fieldInfo
|
||||
errstr string
|
||||
}{
|
||||
{"", nil, ""},
|
||||
{"bogus", nil, ""},
|
||||
{"also,bogus", nil, ""},
|
||||
{"also,bogus:99", nil, ""},
|
||||
{"maxval:1xyz", nil, ""},
|
||||
{"maxval:1", &fieldInfo{count: 1, countSet: true}, ""},
|
||||
{"maxval:255", &fieldInfo{count: 1, countSet: true}, ""},
|
||||
{"maxval:256", &fieldInfo{count: 2, countSet: true}, ""},
|
||||
{"maxval:65535", &fieldInfo{count: 2, countSet: true}, ""},
|
||||
{"maxval:65536", &fieldInfo{count: 3, countSet: true}, ""},
|
||||
{"maxval:16777215", &fieldInfo{count: 3, countSet: true}, ""},
|
||||
{"maxval:16777216", &fieldInfo{count: 4, countSet: true}, ""},
|
||||
{"maxval:16777216", &fieldInfo{count: 4, countSet: true}, ""},
|
||||
{"maxval:4294967295", &fieldInfo{count: 4, countSet: true}, ""},
|
||||
{"maxval:4294967296", &fieldInfo{count: 5, countSet: true}, ""},
|
||||
{"maxval:1099511627775", &fieldInfo{count: 5, countSet: true}, ""},
|
||||
{"maxval:1099511627776", &fieldInfo{count: 6, countSet: true}, ""},
|
||||
{"maxval:281474976710655", &fieldInfo{count: 6, countSet: true}, ""},
|
||||
{"maxval:281474976710656", &fieldInfo{count: 7, countSet: true}, ""},
|
||||
{"maxval:72057594037927935", &fieldInfo{count: 7, countSet: true}, ""},
|
||||
{"maxval:72057594037927936", &fieldInfo{count: 8, countSet: true}, ""},
|
||||
{"minlen:1x", nil, ""},
|
||||
{"maxlen:1x", nil, ""},
|
||||
{"maxlen:1", &fieldInfo{count: 1, countSet: true, maxlen: 1}, ""},
|
||||
{"maxlen:255", &fieldInfo{count: 1, countSet: true, maxlen: 255}, ""},
|
||||
{"maxlen:65535", &fieldInfo{count: 2, countSet: true, maxlen: 65535}, ""},
|
||||
{"minlen:65530,maxlen:65535", &fieldInfo{count: 2, countSet: true, minlen: 65530, maxlen: 65535}, ""},
|
||||
{"maxlen:65535,minlen:65530", &fieldInfo{count: 2, countSet: true, minlen: 65530, maxlen: 65535}, ""},
|
||||
{"minlen:65536,maxlen:65535", nil, "inverted"},
|
||||
{"maxlen:16777215", &fieldInfo{count: 3, countSet: true, maxlen: 16777215}, ""},
|
||||
{"maxlen:281474976710655", &fieldInfo{count: 6, countSet: true, maxlen: 281474976710655}, ""},
|
||||
{"maxlen:72057594037927936", &fieldInfo{count: 8, countSet: true, maxlen: 72057594037927936}, ""},
|
||||
{"size:0", nil, "unknown size"},
|
||||
{"size:1", &fieldInfo{count: 1, countSet: true}, ""},
|
||||
{"size:2", &fieldInfo{count: 2, countSet: true}, ""},
|
||||
{"size:3", &fieldInfo{count: 3, countSet: true}, ""},
|
||||
{"size:4", &fieldInfo{count: 4, countSet: true}, ""},
|
||||
{"size:5", &fieldInfo{count: 5, countSet: true}, ""},
|
||||
{"size:6", &fieldInfo{count: 6, countSet: true}, ""},
|
||||
{"size:7", &fieldInfo{count: 7, countSet: true}, ""},
|
||||
{"size:8", &fieldInfo{count: 8, countSet: true}, ""},
|
||||
{"size:9", nil, "too large"},
|
||||
{"size:1x", nil, ""},
|
||||
{"size:1,val:9", nil, "selector value"},
|
||||
{"selector:Bob,val:x9", &fieldInfo{selector: "Bob"}, ""},
|
||||
{"selector:Fred,val:1", &fieldInfo{selector: "Fred", val: 1}, ""},
|
||||
{"val:9,selector:Fred,val:1", &fieldInfo{selector: "Fred", val: 1}, ""},
|
||||
}
|
||||
for _, test := range tests {
|
||||
got, err := fieldTagToFieldInfo(test.tag, "")
|
||||
if test.errstr != "" {
|
||||
if err == nil {
|
||||
t.Errorf("fieldTagToFieldInfo('%v')=%+v,nil; want error %q", test.tag, got, test.errstr)
|
||||
} else if !strings.Contains(err.Error(), test.errstr) {
|
||||
t.Errorf("fieldTagToFieldInfo('%v')=nil,%q; want error %q", test.tag, err.Error(), test.errstr)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
t.Errorf("fieldTagToFieldInfo('%v')=nil,%q; want %+v", test.tag, err.Error(), test.want)
|
||||
} else if !reflect.DeepEqual(got, test.want) {
|
||||
t.Errorf("fieldTagToFieldInfo('%v')=%+v,nil; want %+v", test.tag, got, test.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Can't take the address of a numeric constant so use helper functions
|
||||
func newByte(n byte) *byte { return &n }
|
||||
func newUint8(n uint8) *uint8 { return &n }
|
||||
func newUint16(n uint16) *uint16 { return &n }
|
||||
func newUint24(n Uint24) *Uint24 { return &n }
|
||||
func newUint32(n uint32) *uint32 { return &n }
|
||||
func newUint64(n uint64) *uint64 { return &n }
|
||||
func newInt16(n int16) *int16 { return &n }
|
||||
func newEnum(n Enum) *Enum { return &n }
|
||||
|
||||
func TestUnmarshalMarshalWithParamsRoundTrip(t *testing.T) {
|
||||
var tests = []struct {
|
||||
data string // hex encoded
|
||||
params string
|
||||
item interface{}
|
||||
}{
|
||||
{"00", "", newUint8(0)},
|
||||
{"03", "", newByte(3)},
|
||||
{"0101", "", newUint16(0x0101)},
|
||||
{"010203", "", newUint24(0x010203)},
|
||||
{"000000", "", newUint24(0x00)},
|
||||
{"00000009", "", newUint32(0x09)},
|
||||
{"0000000901020304", "", newUint64(0x0901020304)},
|
||||
{"030405", "", &[3]byte{3, 4, 5}},
|
||||
{"03", "", &[1]byte{3}},
|
||||
{"0001", "size:2", newEnum(1)},
|
||||
{"0100000001", "size:5", newEnum(0x100000001)},
|
||||
{"12", "maxval:18", newEnum(18)},
|
||||
// Note that maxval is just used to give enum size; it's not policed
|
||||
{"20", "maxval:18", newEnum(32)},
|
||||
{"020a0b", "minlen:1,maxlen:5", &[]byte{0xa, 0xb}},
|
||||
{"020a0b0101010203040011", "", &testStruct{Data: []byte{0xa, 0xb}, IntVal: 0x101, Other: [4]byte{1, 2, 3, 4}, Enum: 17}},
|
||||
{"000102", "", &testVariant{Which: 0, Val16: newUint16(0x0102)}},
|
||||
{"0101020304", "", &testVariant{Which: 1, Val32: newUint32(0x01020304)}},
|
||||
{"0001020104030201", "", &testTwoVariants{Which: 0, Val16: newUint16(0x0102), Second: 1, Second32: newUint32(0x04030201)}},
|
||||
{"06010102020303", "", &testNonByteSlice{Vals: []uint16{0x101, 0x202, 0x303}}},
|
||||
{"00", "", &testSliceOfStructs{Vals: []testVariant{}}},
|
||||
{"080001020101020304", "",
|
||||
&testSliceOfStructs{
|
||||
Vals: []testVariant{
|
||||
{Which: 0, Val16: newUint16(0x0102)},
|
||||
{Which: 1, Val32: newUint32(0x01020304)},
|
||||
},
|
||||
},
|
||||
},
|
||||
{"000a00030102030003040506", "",
|
||||
&testSliceOfSlices{
|
||||
Inners: []testInnerType{
|
||||
{Val: []byte{1, 2, 3}},
|
||||
{Val: []byte{4, 5, 6}},
|
||||
},
|
||||
},
|
||||
},
|
||||
{"011011", "", &testAliasEnum{Val: 1, Val16: newUint16(0x1011)}},
|
||||
{"0403", "", &SignatureAndHashAlgorithm{Hash: SHA256, Signature: ECDSA}},
|
||||
{"04030003010203", "",
|
||||
&DigitallySigned{
|
||||
Algorithm: SignatureAndHashAlgorithm{Hash: SHA256, Signature: ECDSA},
|
||||
Signature: []byte{1, 2, 3},
|
||||
},
|
||||
},
|
||||
}
|
||||
for _, test := range tests {
|
||||
inVal := reflect.ValueOf(test.item).Elem()
|
||||
pv := reflect.New(reflect.TypeOf(test.item).Elem())
|
||||
val := pv.Interface()
|
||||
inData, _ := hex.DecodeString(test.data)
|
||||
if _, err := UnmarshalWithParams(inData, val, test.params); err != nil {
|
||||
t.Errorf("Unmarshal(%s)=nil,%q; want %+v", test.data, err.Error(), inVal)
|
||||
} else if !reflect.DeepEqual(val, test.item) {
|
||||
t.Errorf("Unmarshal(%s)=%+v,nil; want %+v", test.data, reflect.ValueOf(val).Elem(), inVal)
|
||||
}
|
||||
|
||||
if data, err := MarshalWithParams(inVal.Interface(), test.params); err != nil {
|
||||
t.Errorf("Marshal(%+v)=nil,%q; want %s", inVal, err.Error(), test.data)
|
||||
} else if !bytes.Equal(data, inData) {
|
||||
t.Errorf("Marshal(%+v)=%s,nil; want %s", inVal, hex.EncodeToString(data), test.data)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type testInvalidFieldTag struct {
|
||||
Data []byte `tls:"minlen:3,maxlen:2"`
|
||||
}
|
||||
|
||||
type testDuplicateSelectorVal struct {
|
||||
Which Enum `tls:"size:1"`
|
||||
Val *uint16 `tls:"selector:Which,val:0"`
|
||||
DupVal *uint32 `tls:"selector:Which"` // implicit val:0
|
||||
}
|
||||
|
||||
type testMissingSelector struct {
|
||||
Val *uint16 `tls:"selector:Missing,val:0"`
|
||||
}
|
||||
|
||||
type testChoiceNotPointer struct {
|
||||
Which Enum `tls:"size:1"`
|
||||
Val uint16 `tls:"selector:Which,val:0"`
|
||||
}
|
||||
|
||||
type nonEnumAlias uint16
|
||||
|
||||
func newNonEnumAlias(n nonEnumAlias) *nonEnumAlias { return &n }
|
||||
|
||||
func TestUnmarshalWithParamsFailures(t *testing.T) {
|
||||
var tests = []struct {
|
||||
data string // hex encoded
|
||||
params string
|
||||
item interface{}
|
||||
errstr string
|
||||
}{
|
||||
{"", "", newUint8(0), "truncated"},
|
||||
{"0x01", "", newUint16(0x0101), "truncated"},
|
||||
{"0103", "", newUint24(0x010203), "truncated"},
|
||||
{"00", "", newUint24(0x00), "truncated"},
|
||||
{"000009", "", newUint32(0x09), "truncated"},
|
||||
{"00000901020304", "", newUint64(0x0901020304), "truncated"},
|
||||
{"0102", "", newInt16(0x0102), "unsupported type"}, // TLS encoding only supports unsigned integers
|
||||
{"0607", "", &[3]byte{6, 7, 8}, "truncated array"},
|
||||
{"01010202", "", &[3]uint16{0x101, 0x202}, "unsupported array"},
|
||||
{"01", "", newEnum(1), "no field size"},
|
||||
{"00", "size:2", newEnum(0), "truncated"},
|
||||
{"00", "size:9", newEnum(0), "too large"},
|
||||
{"020a0b", "minlen:4,maxlen:8", &[]byte{0x0a, 0x0b}, "too small"},
|
||||
{"040a0b0c0d", "minlen:1,maxlen:3", &[]byte{0x0a, 0x0b, 0x0c, 0x0d}, "too large"},
|
||||
{"020a0b", "minlen:8,maxlen:6", &[]byte{0x0a, 0x0b}, "inverted"},
|
||||
{"020a", "minlen:0,maxlen:6", &[]byte{0x0a, 0x0b}, "truncated"},
|
||||
{"02", "minlen:0,maxlen:6", &[]byte{0x0a, 0x0b}, "truncated"},
|
||||
{"0001", "minlen:0,maxlen:256", &[]byte{0x0a, 0x0b}, "truncated"},
|
||||
{"020a", "minlen:0", &[]byte{0x0a, 0x0b}, "unknown size"},
|
||||
{"020a", "", &[]byte{0x0a, 0x0b}, "no field size information"},
|
||||
{"020a0b", "", &testInvalidFieldTag{}, "range inverted"},
|
||||
{"020a0b01010102030400", "",
|
||||
&testStruct{Data: []byte{0xa, 0xb}, IntVal: 0x101, Other: [4]byte{1, 2, 3, 4}, Enum: 17}, "truncated"},
|
||||
{"010102", "", &testVariant{Which: 1, Val32: newUint32(0x01020304)}, "truncated"},
|
||||
{"092122", "", &testVariant{Which: 0, Val16: newUint16(0x2122)}, "unhandled value for selector"},
|
||||
{"0001020304", "", &testDuplicateSelectorVal{Which: 0, Val: newUint16(0x0102)}, "duplicate selector value"},
|
||||
{"0102", "", &testMissingSelector{Val: newUint16(1)}, "selector not seen"},
|
||||
{"000007", "", &testChoiceNotPointer{Which: 0, Val: 7}, "choice field not a pointer type"},
|
||||
{"05010102020303", "", &testNonByteSlice{Vals: []uint16{0x101, 0x202, 0x303}}, "truncated"},
|
||||
{"0101", "size:2", newNonEnumAlias(0x0102), "unsupported type"},
|
||||
{"0403010203", "",
|
||||
&DigitallySigned{
|
||||
Algorithm: SignatureAndHashAlgorithm{Hash: SHA256, Signature: ECDSA},
|
||||
Signature: []byte{1, 2, 3}}, "truncated"},
|
||||
}
|
||||
for _, test := range tests {
|
||||
pv := reflect.New(reflect.TypeOf(test.item).Elem())
|
||||
val := pv.Interface()
|
||||
in, _ := hex.DecodeString(test.data)
|
||||
if _, err := UnmarshalWithParams(in, val, test.params); err == nil {
|
||||
t.Errorf("Unmarshal(%s)=%+v,nil; want error %q", test.data, reflect.ValueOf(val).Elem(), test.errstr)
|
||||
} else if !strings.Contains(err.Error(), test.errstr) {
|
||||
t.Errorf("Unmarshal(%s)=nil,%q; want error %q", test.data, err.Error(), test.errstr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMarshalWithParamsFailures(t *testing.T) {
|
||||
var tests = []struct {
|
||||
item interface{}
|
||||
params string
|
||||
errstr string
|
||||
}{
|
||||
{Uint24(0x1000000), "", "overflow"},
|
||||
{int16(0x0102), "", "unsupported type"}, // All TLS ints are unsigned
|
||||
{Enum(1), "", "field tag missing"},
|
||||
{Enum(256), "size:1", "too large"},
|
||||
{Enum(256), "maxval:255", "too large"},
|
||||
{Enum(2), "", "field tag missing"},
|
||||
{Enum(256), "size:9", "too large"},
|
||||
{[]byte{0xa, 0xb, 0xc, 0xd}, "minlen:1,maxlen:3", "too large"},
|
||||
{[]byte{0xa, 0xb, 0xc, 0xd}, "minlen:6,maxlen:13", "too small"},
|
||||
{[]byte{0xa, 0xb, 0xc, 0xd}, "minlen:6,maxlen:3", "inverted"},
|
||||
{[]byte{0xa, 0xb, 0xc, 0xd}, "minlen:6", "unknown size"},
|
||||
{[]byte{0xa, 0xb, 0xc, 0xd}, "", "field tag missing"},
|
||||
{[3]uint16{0x101, 0x202}, "", "unsupported array"},
|
||||
{testInvalidFieldTag{}, "", "inverted"},
|
||||
{testStruct{Data: []byte{0xa}, IntVal: 0x101, Other: [4]byte{1, 2, 3, 4}, Enum: 17}, "", "too small"},
|
||||
{testVariant{Which: 0, Val32: newUint32(0x01020304)}, "", "chosen field is nil"},
|
||||
{testVariant{Which: 0, Val16: newUint16(11), Val32: newUint32(0x01020304)}, "", "unchosen field is non-nil"},
|
||||
{testVariant{Which: 3}, "", "unhandled value for selector"},
|
||||
{testMissingSelector{Val: newUint16(1)}, "", "selector not seen"},
|
||||
{testChoiceNotPointer{Which: 0, Val: 7}, "", "choice field not a pointer"},
|
||||
{testDuplicateSelectorVal{Which: 0, Val: newUint16(1)}, "", "duplicate selector value"},
|
||||
{testNonByteSlice{Vals: []uint16{1, 2, 3, 4}}, "", "too large"},
|
||||
{testSliceOfStructs{[]testVariant{{Which: 3}}}, "", "unhandled value for selector"},
|
||||
{nonEnumAlias(0x0102), "", "unsupported type"},
|
||||
}
|
||||
for _, test := range tests {
|
||||
if data, err := MarshalWithParams(test.item, test.params); err == nil {
|
||||
t.Errorf("Marshal(%+v)=%x,nil; want error %q", test.item, data, test.errstr)
|
||||
} else if !strings.Contains(err.Error(), test.errstr) {
|
||||
t.Errorf("Marshal(%+v)=nil,%q; want error %q", test.item, err.Error(), test.errstr)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user