Source file src/encoding/asn1/asn1_test.go

Documentation: encoding/asn1

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package asn1
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"encoding/hex"
		10  	"fmt"
		11  	"math"
		12  	"math/big"
		13  	"reflect"
		14  	"strings"
		15  	"testing"
		16  	"time"
		17  )
		18  
		19  type boolTest struct {
		20  	in	[]byte
		21  	ok	bool
		22  	out bool
		23  }
		24  
		25  var boolTestData = []boolTest{
		26  	{[]byte{0x00}, true, false},
		27  	{[]byte{0xff}, true, true},
		28  	{[]byte{0x00, 0x00}, false, false},
		29  	{[]byte{0xff, 0xff}, false, false},
		30  	{[]byte{0x01}, false, false},
		31  }
		32  
		33  func TestParseBool(t *testing.T) {
		34  	for i, test := range boolTestData {
		35  		ret, err := parseBool(test.in)
		36  		if (err == nil) != test.ok {
		37  			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
		38  		}
		39  		if test.ok && ret != test.out {
		40  			t.Errorf("#%d: Bad result: %v (expected %v)", i, ret, test.out)
		41  		}
		42  	}
		43  }
		44  
		45  type int64Test struct {
		46  	in	[]byte
		47  	ok	bool
		48  	out int64
		49  }
		50  
		51  var int64TestData = []int64Test{
		52  	{[]byte{0x00}, true, 0},
		53  	{[]byte{0x7f}, true, 127},
		54  	{[]byte{0x00, 0x80}, true, 128},
		55  	{[]byte{0x01, 0x00}, true, 256},
		56  	{[]byte{0x80}, true, -128},
		57  	{[]byte{0xff, 0x7f}, true, -129},
		58  	{[]byte{0xff}, true, -1},
		59  	{[]byte{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, true, -9223372036854775808},
		60  	{[]byte{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, false, 0},
		61  	{[]byte{}, false, 0},
		62  	{[]byte{0x00, 0x7f}, false, 0},
		63  	{[]byte{0xff, 0xf0}, false, 0},
		64  }
		65  
		66  func TestParseInt64(t *testing.T) {
		67  	for i, test := range int64TestData {
		68  		ret, err := parseInt64(test.in)
		69  		if (err == nil) != test.ok {
		70  			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
		71  		}
		72  		if test.ok && ret != test.out {
		73  			t.Errorf("#%d: Bad result: %v (expected %v)", i, ret, test.out)
		74  		}
		75  	}
		76  }
		77  
		78  type int32Test struct {
		79  	in	[]byte
		80  	ok	bool
		81  	out int32
		82  }
		83  
		84  var int32TestData = []int32Test{
		85  	{[]byte{0x00}, true, 0},
		86  	{[]byte{0x7f}, true, 127},
		87  	{[]byte{0x00, 0x80}, true, 128},
		88  	{[]byte{0x01, 0x00}, true, 256},
		89  	{[]byte{0x80}, true, -128},
		90  	{[]byte{0xff, 0x7f}, true, -129},
		91  	{[]byte{0xff}, true, -1},
		92  	{[]byte{0x80, 0x00, 0x00, 0x00}, true, -2147483648},
		93  	{[]byte{0x80, 0x00, 0x00, 0x00, 0x00}, false, 0},
		94  	{[]byte{}, false, 0},
		95  	{[]byte{0x00, 0x7f}, false, 0},
		96  	{[]byte{0xff, 0xf0}, false, 0},
		97  }
		98  
		99  func TestParseInt32(t *testing.T) {
	 100  	for i, test := range int32TestData {
	 101  		ret, err := parseInt32(test.in)
	 102  		if (err == nil) != test.ok {
	 103  			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
	 104  		}
	 105  		if test.ok && int32(ret) != test.out {
	 106  			t.Errorf("#%d: Bad result: %v (expected %v)", i, ret, test.out)
	 107  		}
	 108  	}
	 109  }
	 110  
	 111  var bigIntTests = []struct {
	 112  	in		 []byte
	 113  	ok		 bool
	 114  	base10 string
	 115  }{
	 116  	{[]byte{0xff}, true, "-1"},
	 117  	{[]byte{0x00}, true, "0"},
	 118  	{[]byte{0x01}, true, "1"},
	 119  	{[]byte{0x00, 0xff}, true, "255"},
	 120  	{[]byte{0xff, 0x00}, true, "-256"},
	 121  	{[]byte{0x01, 0x00}, true, "256"},
	 122  	{[]byte{}, false, ""},
	 123  	{[]byte{0x00, 0x7f}, false, ""},
	 124  	{[]byte{0xff, 0xf0}, false, ""},
	 125  }
	 126  
	 127  func TestParseBigInt(t *testing.T) {
	 128  	for i, test := range bigIntTests {
	 129  		ret, err := parseBigInt(test.in)
	 130  		if (err == nil) != test.ok {
	 131  			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
	 132  		}
	 133  		if test.ok {
	 134  			if ret.String() != test.base10 {
	 135  				t.Errorf("#%d: bad result from %x, got %s want %s", i, test.in, ret.String(), test.base10)
	 136  			}
	 137  			e, err := makeBigInt(ret)
	 138  			if err != nil {
	 139  				t.Errorf("%d: err=%q", i, err)
	 140  				continue
	 141  			}
	 142  			result := make([]byte, e.Len())
	 143  			e.Encode(result)
	 144  			if !bytes.Equal(result, test.in) {
	 145  				t.Errorf("#%d: got %x from marshaling %s, want %x", i, result, ret, test.in)
	 146  			}
	 147  		}
	 148  	}
	 149  }
	 150  
	 151  type bitStringTest struct {
	 152  	in				[]byte
	 153  	ok				bool
	 154  	out			 []byte
	 155  	bitLength int
	 156  }
	 157  
	 158  var bitStringTestData = []bitStringTest{
	 159  	{[]byte{}, false, []byte{}, 0},
	 160  	{[]byte{0x00}, true, []byte{}, 0},
	 161  	{[]byte{0x07, 0x00}, true, []byte{0x00}, 1},
	 162  	{[]byte{0x07, 0x01}, false, []byte{}, 0},
	 163  	{[]byte{0x07, 0x40}, false, []byte{}, 0},
	 164  	{[]byte{0x08, 0x00}, false, []byte{}, 0},
	 165  }
	 166  
	 167  func TestBitString(t *testing.T) {
	 168  	for i, test := range bitStringTestData {
	 169  		ret, err := parseBitString(test.in)
	 170  		if (err == nil) != test.ok {
	 171  			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
	 172  		}
	 173  		if err == nil {
	 174  			if test.bitLength != ret.BitLength || !bytes.Equal(ret.Bytes, test.out) {
	 175  				t.Errorf("#%d: Bad result: %v (expected %v %v)", i, ret, test.out, test.bitLength)
	 176  			}
	 177  		}
	 178  	}
	 179  }
	 180  
	 181  func TestBitStringAt(t *testing.T) {
	 182  	bs := BitString{[]byte{0x82, 0x40}, 16}
	 183  	if bs.At(0) != 1 {
	 184  		t.Error("#1: Failed")
	 185  	}
	 186  	if bs.At(1) != 0 {
	 187  		t.Error("#2: Failed")
	 188  	}
	 189  	if bs.At(6) != 1 {
	 190  		t.Error("#3: Failed")
	 191  	}
	 192  	if bs.At(9) != 1 {
	 193  		t.Error("#4: Failed")
	 194  	}
	 195  	if bs.At(-1) != 0 {
	 196  		t.Error("#5: Failed")
	 197  	}
	 198  	if bs.At(17) != 0 {
	 199  		t.Error("#6: Failed")
	 200  	}
	 201  }
	 202  
	 203  type bitStringRightAlignTest struct {
	 204  	in		[]byte
	 205  	inlen int
	 206  	out	 []byte
	 207  }
	 208  
	 209  var bitStringRightAlignTests = []bitStringRightAlignTest{
	 210  	{[]byte{0x80}, 1, []byte{0x01}},
	 211  	{[]byte{0x80, 0x80}, 9, []byte{0x01, 0x01}},
	 212  	{[]byte{}, 0, []byte{}},
	 213  	{[]byte{0xce}, 8, []byte{0xce}},
	 214  	{[]byte{0xce, 0x47}, 16, []byte{0xce, 0x47}},
	 215  	{[]byte{0x34, 0x50}, 12, []byte{0x03, 0x45}},
	 216  }
	 217  
	 218  func TestBitStringRightAlign(t *testing.T) {
	 219  	for i, test := range bitStringRightAlignTests {
	 220  		bs := BitString{test.in, test.inlen}
	 221  		out := bs.RightAlign()
	 222  		if !bytes.Equal(out, test.out) {
	 223  			t.Errorf("#%d got: %x want: %x", i, out, test.out)
	 224  		}
	 225  	}
	 226  }
	 227  
	 228  type objectIdentifierTest struct {
	 229  	in	[]byte
	 230  	ok	bool
	 231  	out ObjectIdentifier // has base type[]int
	 232  }
	 233  
	 234  var objectIdentifierTestData = []objectIdentifierTest{
	 235  	{[]byte{}, false, []int{}},
	 236  	{[]byte{85}, true, []int{2, 5}},
	 237  	{[]byte{85, 0x02}, true, []int{2, 5, 2}},
	 238  	{[]byte{85, 0x02, 0xc0, 0x00}, true, []int{2, 5, 2, 0x2000}},
	 239  	{[]byte{0x81, 0x34, 0x03}, true, []int{2, 100, 3}},
	 240  	{[]byte{85, 0x02, 0xc0, 0x80, 0x80, 0x80, 0x80}, false, []int{}},
	 241  }
	 242  
	 243  func TestObjectIdentifier(t *testing.T) {
	 244  	for i, test := range objectIdentifierTestData {
	 245  		ret, err := parseObjectIdentifier(test.in)
	 246  		if (err == nil) != test.ok {
	 247  			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
	 248  		}
	 249  		if err == nil {
	 250  			if !reflect.DeepEqual(test.out, ret) {
	 251  				t.Errorf("#%d: Bad result: %v (expected %v)", i, ret, test.out)
	 252  			}
	 253  		}
	 254  	}
	 255  
	 256  	if s := ObjectIdentifier([]int{1, 2, 3, 4}).String(); s != "1.2.3.4" {
	 257  		t.Errorf("bad ObjectIdentifier.String(). Got %s, want 1.2.3.4", s)
	 258  	}
	 259  }
	 260  
	 261  type timeTest struct {
	 262  	in	string
	 263  	ok	bool
	 264  	out time.Time
	 265  }
	 266  
	 267  var utcTestData = []timeTest{
	 268  	{"910506164540-0700", true, time.Date(1991, 05, 06, 16, 45, 40, 0, time.FixedZone("", -7*60*60))},
	 269  	{"910506164540+0730", true, time.Date(1991, 05, 06, 16, 45, 40, 0, time.FixedZone("", 7*60*60+30*60))},
	 270  	{"910506234540Z", true, time.Date(1991, 05, 06, 23, 45, 40, 0, time.UTC)},
	 271  	{"9105062345Z", true, time.Date(1991, 05, 06, 23, 45, 0, 0, time.UTC)},
	 272  	{"5105062345Z", true, time.Date(1951, 05, 06, 23, 45, 0, 0, time.UTC)},
	 273  	{"a10506234540Z", false, time.Time{}},
	 274  	{"91a506234540Z", false, time.Time{}},
	 275  	{"9105a6234540Z", false, time.Time{}},
	 276  	{"910506a34540Z", false, time.Time{}},
	 277  	{"910506334a40Z", false, time.Time{}},
	 278  	{"91050633444aZ", false, time.Time{}},
	 279  	{"910506334461Z", false, time.Time{}},
	 280  	{"910506334400Za", false, time.Time{}},
	 281  	/* These are invalid times. However, the time package normalises times
	 282  	 * and they were accepted in some versions. See #11134. */
	 283  	{"000100000000Z", false, time.Time{}},
	 284  	{"101302030405Z", false, time.Time{}},
	 285  	{"100002030405Z", false, time.Time{}},
	 286  	{"100100030405Z", false, time.Time{}},
	 287  	{"100132030405Z", false, time.Time{}},
	 288  	{"100231030405Z", false, time.Time{}},
	 289  	{"100102240405Z", false, time.Time{}},
	 290  	{"100102036005Z", false, time.Time{}},
	 291  	{"100102030460Z", false, time.Time{}},
	 292  	{"-100102030410Z", false, time.Time{}},
	 293  	{"10-0102030410Z", false, time.Time{}},
	 294  	{"10-0002030410Z", false, time.Time{}},
	 295  	{"1001-02030410Z", false, time.Time{}},
	 296  	{"100102-030410Z", false, time.Time{}},
	 297  	{"10010203-0410Z", false, time.Time{}},
	 298  	{"1001020304-10Z", false, time.Time{}},
	 299  }
	 300  
	 301  func TestUTCTime(t *testing.T) {
	 302  	for i, test := range utcTestData {
	 303  		ret, err := parseUTCTime([]byte(test.in))
	 304  		if err != nil {
	 305  			if test.ok {
	 306  				t.Errorf("#%d: parseUTCTime(%q) = error %v", i, test.in, err)
	 307  			}
	 308  			continue
	 309  		}
	 310  		if !test.ok {
	 311  			t.Errorf("#%d: parseUTCTime(%q) succeeded, should have failed", i, test.in)
	 312  			continue
	 313  		}
	 314  		const format = "Jan _2 15:04:05 -0700 2006" // ignore zone name, just offset
	 315  		have := ret.Format(format)
	 316  		want := test.out.Format(format)
	 317  		if have != want {
	 318  			t.Errorf("#%d: parseUTCTime(%q) = %s, want %s", i, test.in, have, want)
	 319  		}
	 320  	}
	 321  }
	 322  
	 323  var generalizedTimeTestData = []timeTest{
	 324  	{"20100102030405Z", true, time.Date(2010, 01, 02, 03, 04, 05, 0, time.UTC)},
	 325  	{"20100102030405", false, time.Time{}},
	 326  	{"20100102030405+0607", true, time.Date(2010, 01, 02, 03, 04, 05, 0, time.FixedZone("", 6*60*60+7*60))},
	 327  	{"20100102030405-0607", true, time.Date(2010, 01, 02, 03, 04, 05, 0, time.FixedZone("", -6*60*60-7*60))},
	 328  	/* These are invalid times. However, the time package normalises times
	 329  	 * and they were accepted in some versions. See #11134. */
	 330  	{"00000100000000Z", false, time.Time{}},
	 331  	{"20101302030405Z", false, time.Time{}},
	 332  	{"20100002030405Z", false, time.Time{}},
	 333  	{"20100100030405Z", false, time.Time{}},
	 334  	{"20100132030405Z", false, time.Time{}},
	 335  	{"20100231030405Z", false, time.Time{}},
	 336  	{"20100102240405Z", false, time.Time{}},
	 337  	{"20100102036005Z", false, time.Time{}},
	 338  	{"20100102030460Z", false, time.Time{}},
	 339  	{"-20100102030410Z", false, time.Time{}},
	 340  	{"2010-0102030410Z", false, time.Time{}},
	 341  	{"2010-0002030410Z", false, time.Time{}},
	 342  	{"201001-02030410Z", false, time.Time{}},
	 343  	{"20100102-030410Z", false, time.Time{}},
	 344  	{"2010010203-0410Z", false, time.Time{}},
	 345  	{"201001020304-10Z", false, time.Time{}},
	 346  }
	 347  
	 348  func TestGeneralizedTime(t *testing.T) {
	 349  	for i, test := range generalizedTimeTestData {
	 350  		ret, err := parseGeneralizedTime([]byte(test.in))
	 351  		if (err == nil) != test.ok {
	 352  			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
	 353  		}
	 354  		if err == nil {
	 355  			if !reflect.DeepEqual(test.out, ret) {
	 356  				t.Errorf("#%d: Bad result: %q → %v (expected %v)", i, test.in, ret, test.out)
	 357  			}
	 358  		}
	 359  	}
	 360  }
	 361  
	 362  type tagAndLengthTest struct {
	 363  	in	[]byte
	 364  	ok	bool
	 365  	out tagAndLength
	 366  }
	 367  
	 368  var tagAndLengthData = []tagAndLengthTest{
	 369  	{[]byte{0x80, 0x01}, true, tagAndLength{2, 0, 1, false}},
	 370  	{[]byte{0xa0, 0x01}, true, tagAndLength{2, 0, 1, true}},
	 371  	{[]byte{0x02, 0x00}, true, tagAndLength{0, 2, 0, false}},
	 372  	{[]byte{0xfe, 0x00}, true, tagAndLength{3, 30, 0, true}},
	 373  	{[]byte{0x1f, 0x1f, 0x00}, true, tagAndLength{0, 31, 0, false}},
	 374  	{[]byte{0x1f, 0x81, 0x00, 0x00}, true, tagAndLength{0, 128, 0, false}},
	 375  	{[]byte{0x1f, 0x81, 0x80, 0x01, 0x00}, true, tagAndLength{0, 0x4001, 0, false}},
	 376  	{[]byte{0x00, 0x81, 0x80}, true, tagAndLength{0, 0, 128, false}},
	 377  	{[]byte{0x00, 0x82, 0x01, 0x00}, true, tagAndLength{0, 0, 256, false}},
	 378  	{[]byte{0x00, 0x83, 0x01, 0x00}, false, tagAndLength{}},
	 379  	{[]byte{0x1f, 0x85}, false, tagAndLength{}},
	 380  	{[]byte{0x30, 0x80}, false, tagAndLength{}},
	 381  	// Superfluous zeros in the length should be an error.
	 382  	{[]byte{0xa0, 0x82, 0x00, 0xff}, false, tagAndLength{}},
	 383  	// Lengths up to the maximum size of an int should work.
	 384  	{[]byte{0xa0, 0x84, 0x7f, 0xff, 0xff, 0xff}, true, tagAndLength{2, 0, 0x7fffffff, true}},
	 385  	// Lengths that would overflow an int should be rejected.
	 386  	{[]byte{0xa0, 0x84, 0x80, 0x00, 0x00, 0x00}, false, tagAndLength{}},
	 387  	// Long length form may not be used for lengths that fit in short form.
	 388  	{[]byte{0xa0, 0x81, 0x7f}, false, tagAndLength{}},
	 389  	// Tag numbers which would overflow int32 are rejected. (The value below is 2^31.)
	 390  	{[]byte{0x1f, 0x88, 0x80, 0x80, 0x80, 0x00, 0x00}, false, tagAndLength{}},
	 391  	// Tag numbers that fit in an int32 are valid. (The value below is 2^31 - 1.)
	 392  	{[]byte{0x1f, 0x87, 0xFF, 0xFF, 0xFF, 0x7F, 0x00}, true, tagAndLength{tag: math.MaxInt32}},
	 393  	// Long tag number form may not be used for tags that fit in short form.
	 394  	{[]byte{0x1f, 0x1e, 0x00}, false, tagAndLength{}},
	 395  }
	 396  
	 397  func TestParseTagAndLength(t *testing.T) {
	 398  	for i, test := range tagAndLengthData {
	 399  		tagAndLength, _, err := parseTagAndLength(test.in, 0)
	 400  		if (err == nil) != test.ok {
	 401  			t.Errorf("#%d: Incorrect error result (did pass? %v, expected: %v)", i, err == nil, test.ok)
	 402  		}
	 403  		if err == nil && !reflect.DeepEqual(test.out, tagAndLength) {
	 404  			t.Errorf("#%d: Bad result: %v (expected %v)", i, tagAndLength, test.out)
	 405  		}
	 406  	}
	 407  }
	 408  
	 409  type parseFieldParametersTest struct {
	 410  	in	string
	 411  	out fieldParameters
	 412  }
	 413  
	 414  func newInt(n int) *int { return &n }
	 415  
	 416  func newInt64(n int64) *int64 { return &n }
	 417  
	 418  func newString(s string) *string { return &s }
	 419  
	 420  func newBool(b bool) *bool { return &b }
	 421  
	 422  var parseFieldParametersTestData []parseFieldParametersTest = []parseFieldParametersTest{
	 423  	{"", fieldParameters{}},
	 424  	{"ia5", fieldParameters{stringType: TagIA5String}},
	 425  	{"generalized", fieldParameters{timeType: TagGeneralizedTime}},
	 426  	{"utc", fieldParameters{timeType: TagUTCTime}},
	 427  	{"printable", fieldParameters{stringType: TagPrintableString}},
	 428  	{"numeric", fieldParameters{stringType: TagNumericString}},
	 429  	{"optional", fieldParameters{optional: true}},
	 430  	{"explicit", fieldParameters{explicit: true, tag: new(int)}},
	 431  	{"application", fieldParameters{application: true, tag: new(int)}},
	 432  	{"private", fieldParameters{private: true, tag: new(int)}},
	 433  	{"optional,explicit", fieldParameters{optional: true, explicit: true, tag: new(int)}},
	 434  	{"default:42", fieldParameters{defaultValue: newInt64(42)}},
	 435  	{"tag:17", fieldParameters{tag: newInt(17)}},
	 436  	{"optional,explicit,default:42,tag:17", fieldParameters{optional: true, explicit: true, defaultValue: newInt64(42), tag: newInt(17)}},
	 437  	{"optional,explicit,default:42,tag:17,rubbish1", fieldParameters{optional: true, explicit: true, application: false, defaultValue: newInt64(42), tag: newInt(17), stringType: 0, timeType: 0, set: false, omitEmpty: false}},
	 438  	{"set", fieldParameters{set: true}},
	 439  }
	 440  
	 441  func TestParseFieldParameters(t *testing.T) {
	 442  	for i, test := range parseFieldParametersTestData {
	 443  		f := parseFieldParameters(test.in)
	 444  		if !reflect.DeepEqual(f, test.out) {
	 445  			t.Errorf("#%d: Bad result: %v (expected %v)", i, f, test.out)
	 446  		}
	 447  	}
	 448  }
	 449  
	 450  type TestObjectIdentifierStruct struct {
	 451  	OID ObjectIdentifier
	 452  }
	 453  
	 454  type TestContextSpecificTags struct {
	 455  	A int `asn1:"tag:1"`
	 456  }
	 457  
	 458  type TestContextSpecificTags2 struct {
	 459  	A int `asn1:"explicit,tag:1"`
	 460  	B int
	 461  }
	 462  
	 463  type TestContextSpecificTags3 struct {
	 464  	S string `asn1:"tag:1,utf8"`
	 465  }
	 466  
	 467  type TestElementsAfterString struct {
	 468  	S		string
	 469  	A, B int
	 470  }
	 471  
	 472  type TestBigInt struct {
	 473  	X *big.Int
	 474  }
	 475  
	 476  type TestSet struct {
	 477  	Ints []int `asn1:"set"`
	 478  }
	 479  
	 480  var unmarshalTestData = []struct {
	 481  	in	[]byte
	 482  	out interface{}
	 483  }{
	 484  	{[]byte{0x02, 0x01, 0x42}, newInt(0x42)},
	 485  	{[]byte{0x05, 0x00}, &RawValue{0, 5, false, []byte{}, []byte{0x05, 0x00}}},
	 486  	{[]byte{0x30, 0x08, 0x06, 0x06, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d}, &TestObjectIdentifierStruct{[]int{1, 2, 840, 113549}}},
	 487  	{[]byte{0x03, 0x04, 0x06, 0x6e, 0x5d, 0xc0}, &BitString{[]byte{110, 93, 192}, 18}},
	 488  	{[]byte{0x30, 0x09, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02, 0x02, 0x01, 0x03}, &[]int{1, 2, 3}},
	 489  	{[]byte{0x02, 0x01, 0x10}, newInt(16)},
	 490  	{[]byte{0x13, 0x04, 't', 'e', 's', 't'}, newString("test")},
	 491  	{[]byte{0x16, 0x04, 't', 'e', 's', 't'}, newString("test")},
	 492  	// Ampersand is allowed in PrintableString due to mistakes by major CAs.
	 493  	{[]byte{0x13, 0x05, 't', 'e', 's', 't', '&'}, newString("test&")},
	 494  	{[]byte{0x16, 0x04, 't', 'e', 's', 't'}, &RawValue{0, 22, false, []byte("test"), []byte("\x16\x04test")}},
	 495  	{[]byte{0x04, 0x04, 1, 2, 3, 4}, &RawValue{0, 4, false, []byte{1, 2, 3, 4}, []byte{4, 4, 1, 2, 3, 4}}},
	 496  	{[]byte{0x30, 0x03, 0x81, 0x01, 0x01}, &TestContextSpecificTags{1}},
	 497  	{[]byte{0x30, 0x08, 0xa1, 0x03, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02}, &TestContextSpecificTags2{1, 2}},
	 498  	{[]byte{0x30, 0x03, 0x81, 0x01, '@'}, &TestContextSpecificTags3{"@"}},
	 499  	{[]byte{0x01, 0x01, 0x00}, newBool(false)},
	 500  	{[]byte{0x01, 0x01, 0xff}, newBool(true)},
	 501  	{[]byte{0x30, 0x0b, 0x13, 0x03, 0x66, 0x6f, 0x6f, 0x02, 0x01, 0x22, 0x02, 0x01, 0x33}, &TestElementsAfterString{"foo", 0x22, 0x33}},
	 502  	{[]byte{0x30, 0x05, 0x02, 0x03, 0x12, 0x34, 0x56}, &TestBigInt{big.NewInt(0x123456)}},
	 503  	{[]byte{0x30, 0x0b, 0x31, 0x09, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02, 0x02, 0x01, 0x03}, &TestSet{Ints: []int{1, 2, 3}}},
	 504  	{[]byte{0x12, 0x0b, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ' '}, newString("0123456789 ")},
	 505  }
	 506  
	 507  func TestUnmarshal(t *testing.T) {
	 508  	for i, test := range unmarshalTestData {
	 509  		pv := reflect.New(reflect.TypeOf(test.out).Elem())
	 510  		val := pv.Interface()
	 511  		_, err := Unmarshal(test.in, val)
	 512  		if err != nil {
	 513  			t.Errorf("Unmarshal failed at index %d %v", i, err)
	 514  		}
	 515  		if !reflect.DeepEqual(val, test.out) {
	 516  			t.Errorf("#%d:\nhave %#v\nwant %#v", i, val, test.out)
	 517  		}
	 518  	}
	 519  }
	 520  
	 521  func TestUnmarshalWithNilOrNonPointer(t *testing.T) {
	 522  	tests := []struct {
	 523  		b		[]byte
	 524  		v		interface{}
	 525  		want string
	 526  	}{
	 527  		{b: []byte{0x05, 0x00}, v: nil, want: "asn1: Unmarshal recipient value is nil"},
	 528  		{b: []byte{0x05, 0x00}, v: RawValue{}, want: "asn1: Unmarshal recipient value is non-pointer asn1.RawValue"},
	 529  		{b: []byte{0x05, 0x00}, v: (*RawValue)(nil), want: "asn1: Unmarshal recipient value is nil *asn1.RawValue"},
	 530  	}
	 531  
	 532  	for _, test := range tests {
	 533  		_, err := Unmarshal(test.b, test.v)
	 534  		if err == nil {
	 535  			t.Errorf("Unmarshal expecting error, got nil")
	 536  			continue
	 537  		}
	 538  		if g, w := err.Error(), test.want; g != w {
	 539  			t.Errorf("InvalidUnmarshalError mismatch\nGot:	%q\nWant: %q", g, w)
	 540  		}
	 541  	}
	 542  }
	 543  
	 544  type Certificate struct {
	 545  	TBSCertificate		 TBSCertificate
	 546  	SignatureAlgorithm AlgorithmIdentifier
	 547  	SignatureValue		 BitString
	 548  }
	 549  
	 550  type TBSCertificate struct {
	 551  	Version						int `asn1:"optional,explicit,default:0,tag:0"`
	 552  	SerialNumber			 RawValue
	 553  	SignatureAlgorithm AlgorithmIdentifier
	 554  	Issuer						 RDNSequence
	 555  	Validity					 Validity
	 556  	Subject						RDNSequence
	 557  	PublicKey					PublicKeyInfo
	 558  }
	 559  
	 560  type AlgorithmIdentifier struct {
	 561  	Algorithm ObjectIdentifier
	 562  }
	 563  
	 564  type RDNSequence []RelativeDistinguishedNameSET
	 565  
	 566  type RelativeDistinguishedNameSET []AttributeTypeAndValue
	 567  
	 568  type AttributeTypeAndValue struct {
	 569  	Type	ObjectIdentifier
	 570  	Value interface{}
	 571  }
	 572  
	 573  type Validity struct {
	 574  	NotBefore, NotAfter time.Time
	 575  }
	 576  
	 577  type PublicKeyInfo struct {
	 578  	Algorithm AlgorithmIdentifier
	 579  	PublicKey BitString
	 580  }
	 581  
	 582  func TestCertificate(t *testing.T) {
	 583  	// This is a minimal, self-signed certificate that should parse correctly.
	 584  	var cert Certificate
	 585  	if _, err := Unmarshal(derEncodedSelfSignedCertBytes, &cert); err != nil {
	 586  		t.Errorf("Unmarshal failed: %v", err)
	 587  	}
	 588  	if !reflect.DeepEqual(cert, derEncodedSelfSignedCert) {
	 589  		t.Errorf("Bad result:\ngot: %+v\nwant: %+v", cert, derEncodedSelfSignedCert)
	 590  	}
	 591  }
	 592  
	 593  func TestCertificateWithNUL(t *testing.T) {
	 594  	// This is the paypal NUL-hack certificate. It should fail to parse because
	 595  	// NUL isn't a permitted character in a PrintableString.
	 596  
	 597  	var cert Certificate
	 598  	if _, err := Unmarshal(derEncodedPaypalNULCertBytes, &cert); err == nil {
	 599  		t.Error("Unmarshal succeeded, should not have")
	 600  	}
	 601  }
	 602  
	 603  type rawStructTest struct {
	 604  	Raw RawContent
	 605  	A	 int
	 606  }
	 607  
	 608  func TestRawStructs(t *testing.T) {
	 609  	var s rawStructTest
	 610  	input := []byte{0x30, 0x03, 0x02, 0x01, 0x50}
	 611  
	 612  	rest, err := Unmarshal(input, &s)
	 613  	if len(rest) != 0 {
	 614  		t.Errorf("incomplete parse: %x", rest)
	 615  		return
	 616  	}
	 617  	if err != nil {
	 618  		t.Error(err)
	 619  		return
	 620  	}
	 621  	if s.A != 0x50 {
	 622  		t.Errorf("bad value for A: got %d want %d", s.A, 0x50)
	 623  	}
	 624  	if !bytes.Equal([]byte(s.Raw), input) {
	 625  		t.Errorf("bad value for Raw: got %x want %x", s.Raw, input)
	 626  	}
	 627  }
	 628  
	 629  type oiEqualTest struct {
	 630  	first	ObjectIdentifier
	 631  	second ObjectIdentifier
	 632  	same	 bool
	 633  }
	 634  
	 635  var oiEqualTests = []oiEqualTest{
	 636  	{
	 637  		ObjectIdentifier{1, 2, 3},
	 638  		ObjectIdentifier{1, 2, 3},
	 639  		true,
	 640  	},
	 641  	{
	 642  		ObjectIdentifier{1},
	 643  		ObjectIdentifier{1, 2, 3},
	 644  		false,
	 645  	},
	 646  	{
	 647  		ObjectIdentifier{1, 2, 3},
	 648  		ObjectIdentifier{10, 11, 12},
	 649  		false,
	 650  	},
	 651  }
	 652  
	 653  func TestObjectIdentifierEqual(t *testing.T) {
	 654  	for _, o := range oiEqualTests {
	 655  		if s := o.first.Equal(o.second); s != o.same {
	 656  			t.Errorf("ObjectIdentifier.Equal: got: %t want: %t", s, o.same)
	 657  		}
	 658  	}
	 659  }
	 660  
	 661  var derEncodedSelfSignedCert = Certificate{
	 662  	TBSCertificate: TBSCertificate{
	 663  		Version:						0,
	 664  		SerialNumber:			 RawValue{Class: 0, Tag: 2, IsCompound: false, Bytes: []uint8{0x0, 0x8c, 0xc3, 0x37, 0x92, 0x10, 0xec, 0x2c, 0x98}, FullBytes: []byte{2, 9, 0x0, 0x8c, 0xc3, 0x37, 0x92, 0x10, 0xec, 0x2c, 0x98}},
	 665  		SignatureAlgorithm: AlgorithmIdentifier{Algorithm: ObjectIdentifier{1, 2, 840, 113549, 1, 1, 5}},
	 666  		Issuer: RDNSequence{
	 667  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 6}, Value: "XX"}},
	 668  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 8}, Value: "Some-State"}},
	 669  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 7}, Value: "City"}},
	 670  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 10}, Value: "Internet Widgits Pty Ltd"}},
	 671  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 3}, Value: "false.example.com"}},
	 672  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{1, 2, 840, 113549, 1, 9, 1}, Value: "[email protected]"}},
	 673  		},
	 674  		Validity: Validity{
	 675  			NotBefore: time.Date(2009, 10, 8, 00, 25, 53, 0, time.UTC),
	 676  			NotAfter:	time.Date(2010, 10, 8, 00, 25, 53, 0, time.UTC),
	 677  		},
	 678  		Subject: RDNSequence{
	 679  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 6}, Value: "XX"}},
	 680  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 8}, Value: "Some-State"}},
	 681  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 7}, Value: "City"}},
	 682  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 10}, Value: "Internet Widgits Pty Ltd"}},
	 683  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 3}, Value: "false.example.com"}},
	 684  			RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{1, 2, 840, 113549, 1, 9, 1}, Value: "[email protected]"}},
	 685  		},
	 686  		PublicKey: PublicKeyInfo{
	 687  			Algorithm: AlgorithmIdentifier{Algorithm: ObjectIdentifier{1, 2, 840, 113549, 1, 1, 1}},
	 688  			PublicKey: BitString{
	 689  				Bytes: []uint8{
	 690  					0x30, 0x48, 0x2, 0x41, 0x0, 0xcd, 0xb7,
	 691  					0x63, 0x9c, 0x32, 0x78, 0xf0, 0x6, 0xaa, 0x27, 0x7f, 0x6e, 0xaf, 0x42,
	 692  					0x90, 0x2b, 0x59, 0x2d, 0x8c, 0xbc, 0xbe, 0x38, 0xa1, 0xc9, 0x2b, 0xa4,
	 693  					0x69, 0x5a, 0x33, 0x1b, 0x1d, 0xea, 0xde, 0xad, 0xd8, 0xe9, 0xa5, 0xc2,
	 694  					0x7e, 0x8c, 0x4c, 0x2f, 0xd0, 0xa8, 0x88, 0x96, 0x57, 0x72, 0x2a, 0x4f,
	 695  					0x2a, 0xf7, 0x58, 0x9c, 0xf2, 0xc7, 0x70, 0x45, 0xdc, 0x8f, 0xde, 0xec,
	 696  					0x35, 0x7d, 0x2, 0x3, 0x1, 0x0, 0x1,
	 697  				},
	 698  				BitLength: 592,
	 699  			},
	 700  		},
	 701  	},
	 702  	SignatureAlgorithm: AlgorithmIdentifier{Algorithm: ObjectIdentifier{1, 2, 840, 113549, 1, 1, 5}},
	 703  	SignatureValue: BitString{
	 704  		Bytes: []uint8{
	 705  			0xa6, 0x7b, 0x6, 0xec, 0x5e, 0xce,
	 706  			0x92, 0x77, 0x2c, 0xa4, 0x13, 0xcb, 0xa3, 0xca, 0x12, 0x56, 0x8f, 0xdc, 0x6c,
	 707  			0x7b, 0x45, 0x11, 0xcd, 0x40, 0xa7, 0xf6, 0x59, 0x98, 0x4, 0x2, 0xdf, 0x2b,
	 708  			0x99, 0x8b, 0xb9, 0xa4, 0xa8, 0xcb, 0xeb, 0x34, 0xc0, 0xf0, 0xa7, 0x8c, 0xf8,
	 709  			0xd9, 0x1e, 0xde, 0x14, 0xa5, 0xed, 0x76, 0xbf, 0x11, 0x6f, 0xe3, 0x60, 0xaa,
	 710  			0xfa, 0x88, 0x21, 0x49, 0x4, 0x35,
	 711  		},
	 712  		BitLength: 512,
	 713  	},
	 714  }
	 715  
	 716  var derEncodedSelfSignedCertBytes = []byte{
	 717  	0x30, 0x82, 0x02, 0x18, 0x30,
	 718  	0x82, 0x01, 0xc2, 0x02, 0x09, 0x00, 0x8c, 0xc3, 0x37, 0x92, 0x10, 0xec, 0x2c,
	 719  	0x98, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
	 720  	0x05, 0x05, 0x00, 0x30, 0x81, 0x92, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
	 721  	0x04, 0x06, 0x13, 0x02, 0x58, 0x58, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55,
	 722  	0x04, 0x08, 0x13, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74,
	 723  	0x65, 0x31, 0x0d, 0x30, 0x0b, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x04, 0x43,
	 724  	0x69, 0x74, 0x79, 0x31, 0x21, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13,
	 725  	0x18, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64,
	 726  	0x67, 0x69, 0x74, 0x73, 0x20, 0x50, 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64, 0x31,
	 727  	0x1a, 0x30, 0x18, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x11, 0x66, 0x61, 0x6c,
	 728  	0x73, 0x65, 0x2e, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f,
	 729  	0x6d, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
	 730  	0x01, 0x09, 0x01, 0x16, 0x11, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x40, 0x65, 0x78,
	 731  	0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x1e, 0x17, 0x0d,
	 732  	0x30, 0x39, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x32, 0x35, 0x35, 0x33, 0x5a,
	 733  	0x17, 0x0d, 0x31, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x32, 0x35, 0x35,
	 734  	0x33, 0x5a, 0x30, 0x81, 0x92, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
	 735  	0x06, 0x13, 0x02, 0x58, 0x58, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04,
	 736  	0x08, 0x13, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65,
	 737  	0x31, 0x0d, 0x30, 0x0b, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x04, 0x43, 0x69,
	 738  	0x74, 0x79, 0x31, 0x21, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x18,
	 739  	0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64, 0x67,
	 740  	0x69, 0x74, 0x73, 0x20, 0x50, 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64, 0x31, 0x1a,
	 741  	0x30, 0x18, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x11, 0x66, 0x61, 0x6c, 0x73,
	 742  	0x65, 0x2e, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d,
	 743  	0x31, 0x20, 0x30, 0x1e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01,
	 744  	0x09, 0x01, 0x16, 0x11, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x40, 0x65, 0x78, 0x61,
	 745  	0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x5c, 0x30, 0x0d, 0x06,
	 746  	0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03,
	 747  	0x4b, 0x00, 0x30, 0x48, 0x02, 0x41, 0x00, 0xcd, 0xb7, 0x63, 0x9c, 0x32, 0x78,
	 748  	0xf0, 0x06, 0xaa, 0x27, 0x7f, 0x6e, 0xaf, 0x42, 0x90, 0x2b, 0x59, 0x2d, 0x8c,
	 749  	0xbc, 0xbe, 0x38, 0xa1, 0xc9, 0x2b, 0xa4, 0x69, 0x5a, 0x33, 0x1b, 0x1d, 0xea,
	 750  	0xde, 0xad, 0xd8, 0xe9, 0xa5, 0xc2, 0x7e, 0x8c, 0x4c, 0x2f, 0xd0, 0xa8, 0x88,
	 751  	0x96, 0x57, 0x72, 0x2a, 0x4f, 0x2a, 0xf7, 0x58, 0x9c, 0xf2, 0xc7, 0x70, 0x45,
	 752  	0xdc, 0x8f, 0xde, 0xec, 0x35, 0x7d, 0x02, 0x03, 0x01, 0x00, 0x01, 0x30, 0x0d,
	 753  	0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00,
	 754  	0x03, 0x41, 0x00, 0xa6, 0x7b, 0x06, 0xec, 0x5e, 0xce, 0x92, 0x77, 0x2c, 0xa4,
	 755  	0x13, 0xcb, 0xa3, 0xca, 0x12, 0x56, 0x8f, 0xdc, 0x6c, 0x7b, 0x45, 0x11, 0xcd,
	 756  	0x40, 0xa7, 0xf6, 0x59, 0x98, 0x04, 0x02, 0xdf, 0x2b, 0x99, 0x8b, 0xb9, 0xa4,
	 757  	0xa8, 0xcb, 0xeb, 0x34, 0xc0, 0xf0, 0xa7, 0x8c, 0xf8, 0xd9, 0x1e, 0xde, 0x14,
	 758  	0xa5, 0xed, 0x76, 0xbf, 0x11, 0x6f, 0xe3, 0x60, 0xaa, 0xfa, 0x88, 0x21, 0x49,
	 759  	0x04, 0x35,
	 760  }
	 761  
	 762  var derEncodedPaypalNULCertBytes = []byte{
	 763  	0x30, 0x82, 0x06, 0x44, 0x30,
	 764  	0x82, 0x05, 0xad, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x03, 0x00, 0xf0, 0x9b,
	 765  	0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05,
	 766  	0x05, 0x00, 0x30, 0x82, 0x01, 0x12, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
	 767  	0x04, 0x06, 0x13, 0x02, 0x45, 0x53, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55,
	 768  	0x04, 0x08, 0x13, 0x09, 0x42, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x6f, 0x6e, 0x61,
	 769  	0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x09, 0x42, 0x61,
	 770  	0x72, 0x63, 0x65, 0x6c, 0x6f, 0x6e, 0x61, 0x31, 0x29, 0x30, 0x27, 0x06, 0x03,
	 771  	0x55, 0x04, 0x0a, 0x13, 0x20, 0x49, 0x50, 0x53, 0x20, 0x43, 0x65, 0x72, 0x74,
	 772  	0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x75, 0x74,
	 773  	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x73, 0x2e, 0x6c, 0x2e, 0x31, 0x2e,
	 774  	0x30, 0x2c, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x14, 0x25, 0x67, 0x65, 0x6e, 0x65,
	 775  	0x72, 0x61, 0x6c, 0x40, 0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d,
	 776  	0x20, 0x43, 0x2e, 0x49, 0x2e, 0x46, 0x2e, 0x20, 0x20, 0x42, 0x2d, 0x42, 0x36,
	 777  	0x32, 0x32, 0x31, 0x30, 0x36, 0x39, 0x35, 0x31, 0x2e, 0x30, 0x2c, 0x06, 0x03,
	 778  	0x55, 0x04, 0x0b, 0x13, 0x25, 0x69, 0x70, 0x73, 0x43, 0x41, 0x20, 0x43, 0x4c,
	 779  	0x41, 0x53, 0x45, 0x41, 0x31, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69,
	 780  	0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72,
	 781  	0x69, 0x74, 0x79, 0x31, 0x2e, 0x30, 0x2c, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
	 782  	0x25, 0x69, 0x70, 0x73, 0x43, 0x41, 0x20, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41,
	 783  	0x31, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69,
	 784  	0x6f, 0x6e, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x31,
	 785  	0x20, 0x30, 0x1e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09,
	 786  	0x01, 0x16, 0x11, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x40, 0x69, 0x70,
	 787  	0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x1e, 0x17, 0x0d, 0x30, 0x39,
	 788  	0x30, 0x32, 0x32, 0x34, 0x32, 0x33, 0x30, 0x34, 0x31, 0x37, 0x5a, 0x17, 0x0d,
	 789  	0x31, 0x31, 0x30, 0x32, 0x32, 0x34, 0x32, 0x33, 0x30, 0x34, 0x31, 0x37, 0x5a,
	 790  	0x30, 0x81, 0x94, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
	 791  	0x02, 0x55, 0x53, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13,
	 792  	0x0a, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x31, 0x16,
	 793  	0x30, 0x14, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x0d, 0x53, 0x61, 0x6e, 0x20,
	 794  	0x46, 0x72, 0x61, 0x6e, 0x63, 0x69, 0x73, 0x63, 0x6f, 0x31, 0x11, 0x30, 0x0f,
	 795  	0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x08, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69,
	 796  	0x74, 0x79, 0x31, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x0b,
	 797  	0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x55, 0x6e, 0x69, 0x74, 0x31, 0x2f,
	 798  	0x30, 0x2d, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x26, 0x77, 0x77, 0x77, 0x2e,
	 799  	0x70, 0x61, 0x79, 0x70, 0x61, 0x6c, 0x2e, 0x63, 0x6f, 0x6d, 0x00, 0x73, 0x73,
	 800  	0x6c, 0x2e, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x6e, 0x65,
	 801  	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x63, 0x63, 0x30, 0x81, 0x9f, 0x30, 0x0d,
	 802  	0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00,
	 803  	0x03, 0x81, 0x8d, 0x00, 0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xd2, 0x69,
	 804  	0xfa, 0x6f, 0x3a, 0x00, 0xb4, 0x21, 0x1b, 0xc8, 0xb1, 0x02, 0xd7, 0x3f, 0x19,
	 805  	0xb2, 0xc4, 0x6d, 0xb4, 0x54, 0xf8, 0x8b, 0x8a, 0xcc, 0xdb, 0x72, 0xc2, 0x9e,
	 806  	0x3c, 0x60, 0xb9, 0xc6, 0x91, 0x3d, 0x82, 0xb7, 0x7d, 0x99, 0xff, 0xd1, 0x29,
	 807  	0x84, 0xc1, 0x73, 0x53, 0x9c, 0x82, 0xdd, 0xfc, 0x24, 0x8c, 0x77, 0xd5, 0x41,
	 808  	0xf3, 0xe8, 0x1e, 0x42, 0xa1, 0xad, 0x2d, 0x9e, 0xff, 0x5b, 0x10, 0x26, 0xce,
	 809  	0x9d, 0x57, 0x17, 0x73, 0x16, 0x23, 0x38, 0xc8, 0xd6, 0xf1, 0xba, 0xa3, 0x96,
	 810  	0x5b, 0x16, 0x67, 0x4a, 0x4f, 0x73, 0x97, 0x3a, 0x4d, 0x14, 0xa4, 0xf4, 0xe2,
	 811  	0x3f, 0x8b, 0x05, 0x83, 0x42, 0xd1, 0xd0, 0xdc, 0x2f, 0x7a, 0xe5, 0xb6, 0x10,
	 812  	0xb2, 0x11, 0xc0, 0xdc, 0x21, 0x2a, 0x90, 0xff, 0xae, 0x97, 0x71, 0x5a, 0x49,
	 813  	0x81, 0xac, 0x40, 0xf3, 0x3b, 0xb8, 0x59, 0xb2, 0x4f, 0x02, 0x03, 0x01, 0x00,
	 814  	0x01, 0xa3, 0x82, 0x03, 0x21, 0x30, 0x82, 0x03, 0x1d, 0x30, 0x09, 0x06, 0x03,
	 815  	0x55, 0x1d, 0x13, 0x04, 0x02, 0x30, 0x00, 0x30, 0x11, 0x06, 0x09, 0x60, 0x86,
	 816  	0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x01, 0x04, 0x04, 0x03, 0x02, 0x06, 0x40,
	 817  	0x30, 0x0b, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x04, 0x04, 0x03, 0x02, 0x03, 0xf8,
	 818  	0x30, 0x13, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x04, 0x0c, 0x30, 0x0a, 0x06, 0x08,
	 819  	0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01, 0x30, 0x1d, 0x06, 0x03, 0x55,
	 820  	0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x61, 0x8f, 0x61, 0x34, 0x43, 0x55, 0x14,
	 821  	0x7f, 0x27, 0x09, 0xce, 0x4c, 0x8b, 0xea, 0x9b, 0x7b, 0x19, 0x25, 0xbc, 0x6e,
	 822  	0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14,
	 823  	0x0e, 0x07, 0x60, 0xd4, 0x39, 0xc9, 0x1b, 0x5b, 0x5d, 0x90, 0x7b, 0x23, 0xc8,
	 824  	0xd2, 0x34, 0x9d, 0x4a, 0x9a, 0x46, 0x39, 0x30, 0x09, 0x06, 0x03, 0x55, 0x1d,
	 825  	0x11, 0x04, 0x02, 0x30, 0x00, 0x30, 0x1c, 0x06, 0x03, 0x55, 0x1d, 0x12, 0x04,
	 826  	0x15, 0x30, 0x13, 0x81, 0x11, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x40,
	 827  	0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x72, 0x06, 0x09,
	 828  	0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x0d, 0x04, 0x65, 0x16, 0x63,
	 829  	0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20,
	 830  	0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x4e,
	 831  	0x4f, 0x54, 0x20, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x41, 0x54, 0x45, 0x44, 0x2e,
	 832  	0x20, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41, 0x31, 0x20, 0x53, 0x65, 0x72, 0x76,
	 833  	0x65, 0x72, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74,
	 834  	0x65, 0x20, 0x69, 0x73, 0x73, 0x75, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x68,
	 835  	0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x70,
	 836  	0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x30, 0x2f, 0x06, 0x09, 0x60,
	 837  	0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x02, 0x04, 0x22, 0x16, 0x20, 0x68,
	 838  	0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x70,
	 839  	0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61,
	 840  	0x32, 0x30, 0x30, 0x32, 0x2f, 0x30, 0x43, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
	 841  	0x86, 0xf8, 0x42, 0x01, 0x04, 0x04, 0x36, 0x16, 0x34, 0x68, 0x74, 0x74, 0x70,
	 842  	0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x70, 0x73, 0x63, 0x61,
	 843  	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61, 0x32, 0x30, 0x30,
	 844  	0x32, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61, 0x32, 0x30, 0x30, 0x32, 0x43, 0x4c,
	 845  	0x41, 0x53, 0x45, 0x41, 0x31, 0x2e, 0x63, 0x72, 0x6c, 0x30, 0x46, 0x06, 0x09,
	 846  	0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x03, 0x04, 0x39, 0x16, 0x37,
	 847  	0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69,
	 848  	0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63,
	 849  	0x61, 0x32, 0x30, 0x30, 0x32, 0x2f, 0x72, 0x65, 0x76, 0x6f, 0x63, 0x61, 0x74,
	 850  	0x69, 0x6f, 0x6e, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41, 0x31, 0x2e, 0x68, 0x74,
	 851  	0x6d, 0x6c, 0x3f, 0x30, 0x43, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8,
	 852  	0x42, 0x01, 0x07, 0x04, 0x36, 0x16, 0x34, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a,
	 853  	0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63,
	 854  	0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61, 0x32, 0x30, 0x30, 0x32, 0x2f,
	 855  	0x72, 0x65, 0x6e, 0x65, 0x77, 0x61, 0x6c, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41,
	 856  	0x31, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x3f, 0x30, 0x41, 0x06, 0x09, 0x60, 0x86,
	 857  	0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x08, 0x04, 0x34, 0x16, 0x32, 0x68, 0x74,
	 858  	0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x70, 0x73,
	 859  	0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61, 0x32,
	 860  	0x30, 0x30, 0x32, 0x2f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x43, 0x4c, 0x41,
	 861  	0x53, 0x45, 0x41, 0x31, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x30, 0x81, 0x83, 0x06,
	 862  	0x03, 0x55, 0x1d, 0x1f, 0x04, 0x7c, 0x30, 0x7a, 0x30, 0x39, 0xa0, 0x37, 0xa0,
	 863  	0x35, 0x86, 0x33, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
	 864  	0x2e, 0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70,
	 865  	0x73, 0x63, 0x61, 0x32, 0x30, 0x30, 0x32, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61,
	 866  	0x32, 0x30, 0x30, 0x32, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41, 0x31, 0x2e, 0x63,
	 867  	0x72, 0x6c, 0x30, 0x3d, 0xa0, 0x3b, 0xa0, 0x39, 0x86, 0x37, 0x68, 0x74, 0x74,
	 868  	0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x62, 0x61, 0x63, 0x6b, 0x2e, 0x69,
	 869  	0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63,
	 870  	0x61, 0x32, 0x30, 0x30, 0x32, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61, 0x32, 0x30,
	 871  	0x30, 0x32, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41, 0x31, 0x2e, 0x63, 0x72, 0x6c,
	 872  	0x30, 0x32, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04,
	 873  	0x26, 0x30, 0x24, 0x30, 0x22, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07,
	 874  	0x30, 0x01, 0x86, 0x16, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6f, 0x63,
	 875  	0x73, 0x70, 0x2e, 0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
	 876  	0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05,
	 877  	0x05, 0x00, 0x03, 0x81, 0x81, 0x00, 0x68, 0xee, 0x79, 0x97, 0x97, 0xdd, 0x3b,
	 878  	0xef, 0x16, 0x6a, 0x06, 0xf2, 0x14, 0x9a, 0x6e, 0xcd, 0x9e, 0x12, 0xf7, 0xaa,
	 879  	0x83, 0x10, 0xbd, 0xd1, 0x7c, 0x98, 0xfa, 0xc7, 0xae, 0xd4, 0x0e, 0x2c, 0x9e,
	 880  	0x38, 0x05, 0x9d, 0x52, 0x60, 0xa9, 0x99, 0x0a, 0x81, 0xb4, 0x98, 0x90, 0x1d,
	 881  	0xae, 0xbb, 0x4a, 0xd7, 0xb9, 0xdc, 0x88, 0x9e, 0x37, 0x78, 0x41, 0x5b, 0xf7,
	 882  	0x82, 0xa5, 0xf2, 0xba, 0x41, 0x25, 0x5a, 0x90, 0x1a, 0x1e, 0x45, 0x38, 0xa1,
	 883  	0x52, 0x58, 0x75, 0x94, 0x26, 0x44, 0xfb, 0x20, 0x07, 0xba, 0x44, 0xcc, 0xe5,
	 884  	0x4a, 0x2d, 0x72, 0x3f, 0x98, 0x47, 0xf6, 0x26, 0xdc, 0x05, 0x46, 0x05, 0x07,
	 885  	0x63, 0x21, 0xab, 0x46, 0x9b, 0x9c, 0x78, 0xd5, 0x54, 0x5b, 0x3d, 0x0c, 0x1e,
	 886  	0xc8, 0x64, 0x8c, 0xb5, 0x50, 0x23, 0x82, 0x6f, 0xdb, 0xb8, 0x22, 0x1c, 0x43,
	 887  	0x96, 0x07, 0xa8, 0xbb,
	 888  }
	 889  
	 890  var stringSliceTestData = [][]string{
	 891  	{"foo", "bar"},
	 892  	{"foo", "\\bar"},
	 893  	{"foo", "\"bar\""},
	 894  	{"foo", "åäö"},
	 895  }
	 896  
	 897  func TestStringSlice(t *testing.T) {
	 898  	for _, test := range stringSliceTestData {
	 899  		bs, err := Marshal(test)
	 900  		if err != nil {
	 901  			t.Error(err)
	 902  		}
	 903  
	 904  		var res []string
	 905  		_, err = Unmarshal(bs, &res)
	 906  		if err != nil {
	 907  			t.Error(err)
	 908  		}
	 909  
	 910  		if fmt.Sprintf("%v", res) != fmt.Sprintf("%v", test) {
	 911  			t.Errorf("incorrect marshal/unmarshal; %v != %v", res, test)
	 912  		}
	 913  	}
	 914  }
	 915  
	 916  type explicitTaggedTimeTest struct {
	 917  	Time time.Time `asn1:"explicit,tag:0"`
	 918  }
	 919  
	 920  var explicitTaggedTimeTestData = []struct {
	 921  	in	[]byte
	 922  	out explicitTaggedTimeTest
	 923  }{
	 924  	{[]byte{0x30, 0x11, 0xa0, 0xf, 0x17, 0xd, '9', '1', '0', '5', '0', '6', '1', '6', '4', '5', '4', '0', 'Z'},
	 925  		explicitTaggedTimeTest{time.Date(1991, 05, 06, 16, 45, 40, 0, time.UTC)}},
	 926  	{[]byte{0x30, 0x17, 0xa0, 0xf, 0x18, 0x13, '2', '0', '1', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '+', '0', '6', '0', '7'},
	 927  		explicitTaggedTimeTest{time.Date(2010, 01, 02, 03, 04, 05, 0, time.FixedZone("", 6*60*60+7*60))}},
	 928  }
	 929  
	 930  func TestExplicitTaggedTime(t *testing.T) {
	 931  	// Test that a time.Time will match either tagUTCTime or
	 932  	// tagGeneralizedTime.
	 933  	for i, test := range explicitTaggedTimeTestData {
	 934  		var got explicitTaggedTimeTest
	 935  		_, err := Unmarshal(test.in, &got)
	 936  		if err != nil {
	 937  			t.Errorf("Unmarshal failed at index %d %v", i, err)
	 938  		}
	 939  		if !got.Time.Equal(test.out.Time) {
	 940  			t.Errorf("#%d: got %v, want %v", i, got.Time, test.out.Time)
	 941  		}
	 942  	}
	 943  }
	 944  
	 945  type implicitTaggedTimeTest struct {
	 946  	Time time.Time `asn1:"tag:24"`
	 947  }
	 948  
	 949  func TestImplicitTaggedTime(t *testing.T) {
	 950  	// An implicitly tagged time value, that happens to have an implicit
	 951  	// tag equal to a GENERALIZEDTIME, should still be parsed as a UTCTime.
	 952  	// (There's no "timeType" in fieldParameters to determine what type of
	 953  	// time should be expected when implicitly tagged.)
	 954  	der := []byte{0x30, 0x0f, 0x80 | 24, 0xd, '9', '1', '0', '5', '0', '6', '1', '6', '4', '5', '4', '0', 'Z'}
	 955  	var result implicitTaggedTimeTest
	 956  	if _, err := Unmarshal(der, &result); err != nil {
	 957  		t.Fatalf("Error while parsing: %s", err)
	 958  	}
	 959  	if expected := time.Date(1991, 05, 06, 16, 45, 40, 0, time.UTC); !result.Time.Equal(expected) {
	 960  		t.Errorf("Wrong result. Got %v, want %v", result.Time, expected)
	 961  	}
	 962  }
	 963  
	 964  type truncatedExplicitTagTest struct {
	 965  	Test int `asn1:"explicit,tag:0"`
	 966  }
	 967  
	 968  func TestTruncatedExplicitTag(t *testing.T) {
	 969  	// This crashed Unmarshal in the past. See #11154.
	 970  	der := []byte{
	 971  		0x30, // SEQUENCE
	 972  		0x02, // two bytes long
	 973  		0xa0, // context-specific, tag 0
	 974  		0x30, // 48 bytes long
	 975  	}
	 976  
	 977  	var result truncatedExplicitTagTest
	 978  	if _, err := Unmarshal(der, &result); err == nil {
	 979  		t.Error("Unmarshal returned without error")
	 980  	}
	 981  }
	 982  
	 983  type invalidUTF8Test struct {
	 984  	Str string `asn1:"utf8"`
	 985  }
	 986  
	 987  func TestUnmarshalInvalidUTF8(t *testing.T) {
	 988  	data := []byte("0\x05\f\x03a\xc9c")
	 989  	var result invalidUTF8Test
	 990  	_, err := Unmarshal(data, &result)
	 991  
	 992  	const expectedSubstring = "UTF"
	 993  	if err == nil {
	 994  		t.Fatal("Successfully unmarshaled invalid UTF-8 data")
	 995  	} else if !strings.Contains(err.Error(), expectedSubstring) {
	 996  		t.Fatalf("Expected error to mention %q but error was %q", expectedSubstring, err.Error())
	 997  	}
	 998  }
	 999  
	1000  func TestMarshalNilValue(t *testing.T) {
	1001  	nilValueTestData := []interface{}{
	1002  		nil,
	1003  		struct{ V interface{} }{},
	1004  	}
	1005  	for i, test := range nilValueTestData {
	1006  		if _, err := Marshal(test); err == nil {
	1007  			t.Fatalf("#%d: successfully marshaled nil value", i)
	1008  		}
	1009  	}
	1010  }
	1011  
	1012  type unexported struct {
	1013  	X int
	1014  	y int
	1015  }
	1016  
	1017  type exported struct {
	1018  	X int
	1019  	Y int
	1020  }
	1021  
	1022  func TestUnexportedStructField(t *testing.T) {
	1023  	want := StructuralError{"struct contains unexported fields"}
	1024  
	1025  	_, err := Marshal(unexported{X: 5, y: 1})
	1026  	if err != want {
	1027  		t.Errorf("got %v, want %v", err, want)
	1028  	}
	1029  
	1030  	bs, err := Marshal(exported{X: 5, Y: 1})
	1031  	if err != nil {
	1032  		t.Fatal(err)
	1033  	}
	1034  	var u unexported
	1035  	_, err = Unmarshal(bs, &u)
	1036  	if err != want {
	1037  		t.Errorf("got %v, want %v", err, want)
	1038  	}
	1039  }
	1040  
	1041  func TestNull(t *testing.T) {
	1042  	marshaled, err := Marshal(NullRawValue)
	1043  	if err != nil {
	1044  		t.Fatal(err)
	1045  	}
	1046  	if !bytes.Equal(NullBytes, marshaled) {
	1047  		t.Errorf("Expected Marshal of NullRawValue to yield %x, got %x", NullBytes, marshaled)
	1048  	}
	1049  
	1050  	unmarshaled := RawValue{}
	1051  	if _, err := Unmarshal(NullBytes, &unmarshaled); err != nil {
	1052  		t.Fatal(err)
	1053  	}
	1054  
	1055  	unmarshaled.FullBytes = NullRawValue.FullBytes
	1056  	if len(unmarshaled.Bytes) == 0 {
	1057  		// DeepEqual considers a nil slice and an empty slice to be different.
	1058  		unmarshaled.Bytes = NullRawValue.Bytes
	1059  	}
	1060  
	1061  	if !reflect.DeepEqual(NullRawValue, unmarshaled) {
	1062  		t.Errorf("Expected Unmarshal of NullBytes to yield %v, got %v", NullRawValue, unmarshaled)
	1063  	}
	1064  }
	1065  
	1066  func TestExplicitTagRawValueStruct(t *testing.T) {
	1067  	type foo struct {
	1068  		A RawValue `asn1:"optional,explicit,tag:5"`
	1069  		B []byte	 `asn1:"optional,explicit,tag:6"`
	1070  	}
	1071  	before := foo{B: []byte{1, 2, 3}}
	1072  	derBytes, err := Marshal(before)
	1073  	if err != nil {
	1074  		t.Fatal(err)
	1075  	}
	1076  
	1077  	var after foo
	1078  	if rest, err := Unmarshal(derBytes, &after); err != nil || len(rest) != 0 {
	1079  		t.Fatal(err)
	1080  	}
	1081  
	1082  	got := fmt.Sprintf("%#v", after)
	1083  	want := fmt.Sprintf("%#v", before)
	1084  	if got != want {
	1085  		t.Errorf("got %s, want %s (DER: %x)", got, want, derBytes)
	1086  	}
	1087  }
	1088  
	1089  func TestTaggedRawValue(t *testing.T) {
	1090  	type taggedRawValue struct {
	1091  		A RawValue `asn1:"tag:5"`
	1092  	}
	1093  	type untaggedRawValue struct {
	1094  		A RawValue
	1095  	}
	1096  	const isCompound = 0x20
	1097  	const tag = 5
	1098  
	1099  	tests := []struct {
	1100  		shouldMatch bool
	1101  		derBytes		[]byte
	1102  	}{
	1103  		{false, []byte{0x30, 3, TagInteger, 1, 1}},
	1104  		{true, []byte{0x30, 3, (ClassContextSpecific << 6) | tag, 1, 1}},
	1105  		{true, []byte{0x30, 3, (ClassContextSpecific << 6) | tag | isCompound, 1, 1}},
	1106  		{false, []byte{0x30, 3, (ClassApplication << 6) | tag | isCompound, 1, 1}},
	1107  		{false, []byte{0x30, 3, (ClassPrivate << 6) | tag | isCompound, 1, 1}},
	1108  	}
	1109  
	1110  	for i, test := range tests {
	1111  		var tagged taggedRawValue
	1112  		if _, err := Unmarshal(test.derBytes, &tagged); (err == nil) != test.shouldMatch {
	1113  			t.Errorf("#%d: unexpected result parsing %x: %s", i, test.derBytes, err)
	1114  		}
	1115  
	1116  		// An untagged RawValue should accept anything.
	1117  		var untagged untaggedRawValue
	1118  		if _, err := Unmarshal(test.derBytes, &untagged); err != nil {
	1119  			t.Errorf("#%d: unexpected failure parsing %x with untagged RawValue: %s", i, test.derBytes, err)
	1120  		}
	1121  	}
	1122  }
	1123  
	1124  var bmpStringTests = []struct {
	1125  	decoded		string
	1126  	encodedHex string
	1127  }{
	1128  	{"", "0000"},
	1129  	// Example from https://tools.ietf.org/html/rfc7292#appendix-B.
	1130  	{"Beavis", "0042006500610076006900730000"},
	1131  	// Some characters from the "Letterlike Symbols Unicode block".
	1132  	{"\u2115 - Double-struck N", "21150020002d00200044006f00750062006c0065002d00730074007200750063006b0020004e0000"},
	1133  }
	1134  
	1135  func TestBMPString(t *testing.T) {
	1136  	for i, test := range bmpStringTests {
	1137  		encoded, err := hex.DecodeString(test.encodedHex)
	1138  		if err != nil {
	1139  			t.Fatalf("#%d: failed to decode from hex string", i)
	1140  		}
	1141  
	1142  		decoded, err := parseBMPString(encoded)
	1143  
	1144  		if err != nil {
	1145  			t.Errorf("#%d: decoding output gave an error: %s", i, err)
	1146  			continue
	1147  		}
	1148  
	1149  		if decoded != test.decoded {
	1150  			t.Errorf("#%d: decoding output resulted in %q, but it should have been %q", i, decoded, test.decoded)
	1151  			continue
	1152  		}
	1153  	}
	1154  }
	1155  
	1156  func TestNonMinimalEncodedOID(t *testing.T) {
	1157  	h, err := hex.DecodeString("060a2a80864886f70d01010b")
	1158  	if err != nil {
	1159  		t.Fatalf("failed to decode from hex string: %s", err)
	1160  	}
	1161  	var oid ObjectIdentifier
	1162  	_, err = Unmarshal(h, &oid)
	1163  	if err == nil {
	1164  		t.Fatalf("accepted non-minimally encoded oid")
	1165  	}
	1166  }
	1167  

View as plain text