libgo/go/asn1/asn1_test.go

   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         "reflect"
  10         "testing"
  11         "time"
  12 )
  13
  14 type int64Test struct {
  15         in  []byte
  16         ok  bool
  17         out int64
  18 }
  19
  20 var int64TestData = []int64Test{
  21         {[]byte{0x00}, true, 0},
  22         {[]byte{0x7f}, true, 127},
  23         {[]byte{0x00, 0x80}, true, 128},
  24         {[]byte{0x01, 0x00}, true, 256},
  25         {[]byte{0x80}, true, -128},
  26         {[]byte{0xff, 0x7f}, true, -129},
  27         {[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, true, -1},
  28         {[]byte{0xff}, true, -1},
  29         {[]byte{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, true, -9223372036854775808},
  30         {[]byte{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, false, 0},
  31 }
  32
  33 func TestParseInt64(t *testing.T) {
  34         for i, test := range int64TestData {
  35                 ret, err := parseInt64(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 bitStringTest struct {
  46         in        []byte
  47         ok        bool
  48         out       []byte
  49         bitLength int
  50 }
  51
  52 var bitStringTestData = []bitStringTest{
  53         {[]byte{}, false, []byte{}, 0},
  54         {[]byte{0x00}, true, []byte{}, 0},
  55         {[]byte{0x07, 0x00}, true, []byte{0x00}, 1},
  56         {[]byte{0x07, 0x01}, false, []byte{}, 0},
  57         {[]byte{0x07, 0x40}, false, []byte{}, 0},
  58         {[]byte{0x08, 0x00}, false, []byte{}, 0},
  59 }
  60
  61 func TestBitString(t *testing.T) {
  62         for i, test := range bitStringTestData {
  63                 ret, err := parseBitString(test.in)
  64                 if (err == nil) != test.ok {
  65                         t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
  66                 }
  67                 if err == nil {
  68                         if test.bitLength != ret.BitLength || bytes.Compare(ret.Bytes, test.out) != 0 {
  69                                 t.Errorf("#%d: Bad result: %v (expected %v %v)", i, ret, test.out, test.bitLength)
  70                         }
  71                 }
  72         }
  73 }
  74
  75 func TestBitStringAt(t *testing.T) {
  76         bs := BitString{[]byte{0x82, 0x40}, 16}
  77         if bs.At(0) != 1 {
  78                 t.Error("#1: Failed")
  79         }
  80         if bs.At(1) != 0 {
  81                 t.Error("#2: Failed")
  82         }
  83         if bs.At(6) != 1 {
  84                 t.Error("#3: Failed")
  85         }
  86         if bs.At(9) != 1 {
  87                 t.Error("#4: Failed")
  88         }
  89 }
  90
  91 type bitStringRightAlignTest struct {
  92         in    []byte
  93         inlen int
  94         out   []byte
  95 }
  96
  97 var bitStringRightAlignTests = []bitStringRightAlignTest{
  98         {[]byte{0x80}, 1, []byte{0x01}},
  99         {[]byte{0x80, 0x80}, 9, []byte{0x01, 0x01}},
 100         {[]byte{}, 0, []byte{}},
 101         {[]byte{0xce}, 8, []byte{0xce}},
 102         {[]byte{0xce, 0x47}, 16, []byte{0xce, 0x47}},
 103         {[]byte{0x34, 0x50}, 12, []byte{0x03, 0x45}},
 104 }
 105
 106 func TestBitStringRightAlign(t *testing.T) {
 107         for i, test := range bitStringRightAlignTests {
 108                 bs := BitString{test.in, test.inlen}
 109                 out := bs.RightAlign()
 110                 if bytes.Compare(out, test.out) != 0 {
 111                         t.Errorf("#%d got: %x want: %x", i, out, test.out)
 112                 }
 113         }
 114 }
 115
 116 type objectIdentifierTest struct {
 117         in  []byte
 118         ok  bool
 119         out []int
 120 }
 121
 122 var objectIdentifierTestData = []objectIdentifierTest{
 123         {[]byte{}, false, []int{}},
 124         {[]byte{85}, true, []int{2, 5}},
 125         {[]byte{85, 0x02}, true, []int{2, 5, 2}},
 126         {[]byte{85, 0x02, 0xc0, 0x00}, true, []int{2, 5, 2, 0x2000}},
 127         {[]byte{85, 0x02, 0xc0, 0x80, 0x80, 0x80, 0x80}, false, []int{}},
 128 }
 129
 130 func TestObjectIdentifier(t *testing.T) {
 131         for i, test := range objectIdentifierTestData {
 132                 ret, err := parseObjectIdentifier(test.in)
 133                 if (err == nil) != test.ok {
 134                         t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
 135                 }
 136                 if err == nil {
 137                         if !reflect.DeepEqual(test.out, ret) {
 138                                 t.Errorf("#%d: Bad result: %v (expected %v)", i, ret, test.out)
 139                         }
 140                 }
 141         }
 142 }
 143
 144 type timeTest struct {
 145         in  string
 146         ok  bool
 147         out *time.Time
 148 }
 149
 150 var utcTestData = []timeTest{
 151         {"910506164540-0700", true, &time.Time{1991, 05, 06, 16, 45, 40, 0, -7 * 60 * 60, ""}},
 152         {"910506164540+0730", true, &time.Time{1991, 05, 06, 16, 45, 40, 0, 7*60*60 + 30*60, ""}},
 153         {"910506234540Z", true, &time.Time{1991, 05, 06, 23, 45, 40, 0, 0, "UTC"}},
 154         {"9105062345Z", true, &time.Time{1991, 05, 06, 23, 45, 0, 0, 0, "UTC"}},
 155         {"a10506234540Z", false, nil},
 156         {"91a506234540Z", false, nil},
 157         {"9105a6234540Z", false, nil},
 158         {"910506a34540Z", false, nil},
 159         {"910506334a40Z", false, nil},
 160         {"91050633444aZ", false, nil},
 161         {"910506334461Z", false, nil},
 162         {"910506334400Za", false, nil},
 163 }
 164
 165 func TestUTCTime(t *testing.T) {
 166         for i, test := range utcTestData {
 167                 ret, err := parseUTCTime([]byte(test.in))
 168                 if (err == nil) != test.ok {
 169                         t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
 170                 }
 171                 if err == nil {
 172                         if !reflect.DeepEqual(test.out, ret) {
 173                                 t.Errorf("#%d: Bad result: %v (expected %v)", i, ret, test.out)
 174                         }
 175                 }
 176         }
 177 }
 178
 179 var generalizedTimeTestData = []timeTest{
 180         {"20100102030405Z", true, &time.Time{2010, 01, 02, 03, 04, 05, 0, 0, "UTC"}},
 181         {"20100102030405", false, nil},
 182         {"20100102030405+0607", true, &time.Time{2010, 01, 02, 03, 04, 05, 0, 6*60*60 + 7*60, ""}},
 183         {"20100102030405-0607", true, &time.Time{2010, 01, 02, 03, 04, 05, 0, -6*60*60 - 7*60, ""}},
 184 }
 185
 186 func TestGeneralizedTime(t *testing.T) {
 187         for i, test := range generalizedTimeTestData {
 188                 ret, err := parseGeneralizedTime([]byte(test.in))
 189                 if (err == nil) != test.ok {
 190                         t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
 191                 }
 192                 if err == nil {
 193                         if !reflect.DeepEqual(test.out, ret) {
 194                                 t.Errorf("#%d: Bad result: %v (expected %v)", i, ret, test.out)
 195                         }
 196                 }
 197         }
 198 }
 199
 200 type tagAndLengthTest struct {
 201         in  []byte
 202         ok  bool
 203         out tagAndLength
 204 }
 205
 206 var tagAndLengthData = []tagAndLengthTest{
 207         {[]byte{0x80, 0x01}, true, tagAndLength{2, 0, 1, false}},
 208         {[]byte{0xa0, 0x01}, true, tagAndLength{2, 0, 1, true}},
 209         {[]byte{0x02, 0x00}, true, tagAndLength{0, 2, 0, false}},
 210         {[]byte{0xfe, 0x00}, true, tagAndLength{3, 30, 0, true}},
 211         {[]byte{0x1f, 0x01, 0x00}, true, tagAndLength{0, 1, 0, false}},
 212         {[]byte{0x1f, 0x81, 0x00, 0x00}, true, tagAndLength{0, 128, 0, false}},
 213         {[]byte{0x1f, 0x81, 0x80, 0x01, 0x00}, true, tagAndLength{0, 0x4001, 0, false}},
 214         {[]byte{0x00, 0x81, 0x01}, true, tagAndLength{0, 0, 1, false}},
 215         {[]byte{0x00, 0x82, 0x01, 0x00}, true, tagAndLength{0, 0, 256, false}},
 216         {[]byte{0x00, 0x83, 0x01, 0x00}, false, tagAndLength{}},
 217         {[]byte{0x1f, 0x85}, false, tagAndLength{}},
 218         {[]byte{0x30, 0x80}, false, tagAndLength{}},
 219 }
 220
 221 func TestParseTagAndLength(t *testing.T) {
 222         for i, test := range tagAndLengthData {
 223                 tagAndLength, _, err := parseTagAndLength(test.in, 0)
 224                 if (err == nil) != test.ok {
 225                         t.Errorf("#%d: Incorrect error result (did pass? %v, expected: %v)", i, err == nil, test.ok)
 226                 }
 227                 if err == nil && !reflect.DeepEqual(test.out, tagAndLength) {
 228                         t.Errorf("#%d: Bad result: %v (expected %v)", i, tagAndLength, test.out)
 229                 }
 230         }
 231 }
 232
 233 type parseFieldParametersTest struct {
 234         in  string
 235         out fieldParameters
 236 }
 237
 238 func newInt(n int) *int { return &n }
 239
 240 func newInt64(n int64) *int64 { return &n }
 241
 242 func newString(s string) *string { return &s }
 243
 244 func newBool(b bool) *bool { return &b }
 245
 246 var parseFieldParametersTestData []parseFieldParametersTest = []parseFieldParametersTest{
 247         {"", fieldParameters{}},
 248         {"ia5", fieldParameters{stringType: tagIA5String}},
 249         {"printable", fieldParameters{stringType: tagPrintableString}},
 250         {"optional", fieldParameters{optional: true}},
 251         {"explicit", fieldParameters{explicit: true, tag: new(int)}},
 252         {"optional,explicit", fieldParameters{optional: true, explicit: true, tag: new(int)}},
 253         {"default:42", fieldParameters{defaultValue: newInt64(42)}},
 254         {"tag:17", fieldParameters{tag: newInt(17)}},
 255         {"optional,explicit,default:42,tag:17", fieldParameters{optional: true, explicit: true, defaultValue: newInt64(42), tag: newInt(17)}},
 256         {"optional,explicit,default:42,tag:17,rubbish1", fieldParameters{true, true, newInt64(42), newInt(17), 0, false}},
 257         {"set", fieldParameters{set: true}},
 258 }
 259
 260 func TestParseFieldParameters(t *testing.T) {
 261         for i, test := range parseFieldParametersTestData {
 262                 f := parseFieldParameters(test.in)
 263                 if !reflect.DeepEqual(f, test.out) {
 264                         t.Errorf("#%d: Bad result: %v (expected %v)", i, f, test.out)
 265                 }
 266         }
 267 }
 268
 269 type unmarshalTest struct {
 270         in  []byte
 271         out interface{}
 272 }
 273
 274 type TestObjectIdentifierStruct struct {
 275         OID ObjectIdentifier
 276 }
 277
 278 type TestContextSpecificTags struct {
 279         A int "tag:1"
 280 }
 281
 282 type TestContextSpecificTags2 struct {
 283         A int "explicit,tag:1"
 284         B int
 285 }
 286
 287 type TestElementsAfterString struct {
 288         S    string
 289         A, B int
 290 }
 291
 292 var unmarshalTestData []unmarshalTest = []unmarshalTest{
 293         {[]byte{0x02, 0x01, 0x42}, newInt(0x42)},
 294         {[]byte{0x30, 0x08, 0x06, 0x06, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d}, &TestObjectIdentifierStruct{[]int{1, 2, 840, 113549}}},
 295         {[]byte{0x03, 0x04, 0x06, 0x6e, 0x5d, 0xc0}, &BitString{[]byte{110, 93, 192}, 18}},
 296         {[]byte{0x30, 0x09, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02, 0x02, 0x01, 0x03}, &[]int{1, 2, 3}},
 297         {[]byte{0x02, 0x01, 0x10}, newInt(16)},
 298         {[]byte{0x13, 0x04, 't', 'e', 's', 't'}, newString("test")},
 299         {[]byte{0x16, 0x04, 't', 'e', 's', 't'}, newString("test")},
 300         {[]byte{0x16, 0x04, 't', 'e', 's', 't'}, &RawValue{0, 22, false, []byte("test"), []byte("\x16\x04test")}},
 301         {[]byte{0x04, 0x04, 1, 2, 3, 4}, &RawValue{0, 4, false, []byte{1, 2, 3, 4}, []byte{4, 4, 1, 2, 3, 4}}},
 302         {[]byte{0x30, 0x03, 0x81, 0x01, 0x01}, &TestContextSpecificTags{1}},
 303         {[]byte{0x30, 0x08, 0xa1, 0x03, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02}, &TestContextSpecificTags2{1, 2}},
 304         {[]byte{0x01, 0x01, 0x00}, newBool(false)},
 305         {[]byte{0x01, 0x01, 0x01}, newBool(true)},
 306         {[]byte{0x30, 0x0b, 0x13, 0x03, 0x66, 0x6f, 0x6f, 0x02, 0x01, 0x22, 0x02, 0x01, 0x33}, &TestElementsAfterString{"foo", 0x22, 0x33}},
 307 }
 308
 309 func TestUnmarshal(t *testing.T) {
 310         for i, test := range unmarshalTestData {
 311                 pv := reflect.MakeZero(reflect.NewValue(test.out).Type())
 312                 zv := reflect.MakeZero(pv.Type().(*reflect.PtrType).Elem())
 313                 pv.(*reflect.PtrValue).PointTo(zv)
 314                 val := pv.Interface()
 315                 _, err := Unmarshal(test.in, val)
 316                 if err != nil {
 317                         t.Errorf("Unmarshal failed at index %d %v", i, err)
 318                 }
 319                 if !reflect.DeepEqual(val, test.out) {
 320                         t.Errorf("#%d:\nhave %#v\nwant %#v", i, val, test.out)
 321                 }
 322         }
 323 }
 324
 325 type Certificate struct {
 326         TBSCertificate     TBSCertificate
 327         SignatureAlgorithm AlgorithmIdentifier
 328         SignatureValue     BitString
 329 }
 330
 331 type TBSCertificate struct {
 332         Version            int "optional,explicit,default:0,tag:0"
 333         SerialNumber       RawValue
 334         SignatureAlgorithm AlgorithmIdentifier
 335         Issuer             RDNSequence
 336         Validity           Validity
 337         Subject            RDNSequence
 338         PublicKey          PublicKeyInfo
 339 }
 340
 341 type AlgorithmIdentifier struct {
 342         Algorithm ObjectIdentifier
 343 }
 344
 345 type RDNSequence []RelativeDistinguishedNameSET
 346
 347 type RelativeDistinguishedNameSET []AttributeTypeAndValue
 348
 349 type AttributeTypeAndValue struct {
 350         Type  ObjectIdentifier
 351         Value interface{}
 352 }
 353
 354 type Validity struct {
 355         NotBefore, NotAfter *time.Time
 356 }
 357
 358 type PublicKeyInfo struct {
 359         Algorithm AlgorithmIdentifier
 360         PublicKey BitString
 361 }
 362
 363 func TestCertificate(t *testing.T) {
 364         // This is a minimal, self-signed certificate that should parse correctly.
 365         var cert Certificate
 366         if _, err := Unmarshal(derEncodedSelfSignedCertBytes, &cert); err != nil {
 367                 t.Errorf("Unmarshal failed: %v", err)
 368         }
 369         if !reflect.DeepEqual(cert, derEncodedSelfSignedCert) {
 370                 t.Errorf("Bad result:\ngot: %+v\nwant: %+v", cert, derEncodedSelfSignedCert)
 371         }
 372 }
 373
 374 func TestCertificateWithNUL(t *testing.T) {
 375         // This is the paypal NUL-hack certificate. It should fail to parse because
 376         // NUL isn't a permitted character in a PrintableString.
 377
 378         var cert Certificate
 379         if _, err := Unmarshal(derEncodedPaypalNULCertBytes, &cert); err == nil {
 380                 t.Error("Unmarshal succeeded, should not have")
 381         }
 382 }
 383
 384 type rawStructTest struct {
 385         Raw RawContent
 386         A   int
 387 }
 388
 389 func TestRawStructs(t *testing.T) {
 390         var s rawStructTest
 391         input := []byte{0x30, 0x03, 0x02, 0x01, 0x50}
 392
 393         rest, err := Unmarshal(input, &s)
 394         if len(rest) != 0 {
 395                 t.Errorf("incomplete parse: %x", rest)
 396                 return
 397         }
 398         if err != nil {
 399                 t.Error(err)
 400                 return
 401         }
 402         if s.A != 0x50 {
 403                 t.Errorf("bad value for A: got %d want %d", s.A, 0x50)
 404         }
 405         if bytes.Compare([]byte(s.Raw), input) != 0 {
 406                 t.Errorf("bad value for Raw: got %x want %x", s.Raw, input)
 407         }
 408 }
 409
 410 var derEncodedSelfSignedCert = Certificate{
 411         TBSCertificate: TBSCertificate{
 412                 Version:            0,
 413                 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}},
 414                 SignatureAlgorithm: AlgorithmIdentifier{Algorithm: ObjectIdentifier{1, 2, 840, 113549, 1, 1, 5}},
 415                 Issuer: RDNSequence{
 416                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 6}, Value: "XX"}},
 417                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 8}, Value: "Some-State"}},
 418                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 7}, Value: "City"}},
 419                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 10}, Value: "Internet Widgits Pty Ltd"}},
 420                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 3}, Value: "false.example.com"}},
 421                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{1, 2, 840, 113549, 1, 9, 1}, Value: "false@example.com"}},
 422                 },
 423                 Validity: Validity{NotBefore: &time.Time{Year: 2009, Month: 10, Day: 8, Hour: 0, Minute: 25, Second: 53, Weekday: 0, ZoneOffset: 0, Zone: "UTC"}, NotAfter: &time.Time{Year: 2010, Month: 10, Day: 8, Hour: 0, Minute: 25, Second: 53, Weekday: 0, ZoneOffset: 0, Zone: "UTC"}},
 424                 Subject: RDNSequence{
 425                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 6}, Value: "XX"}},
 426                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 8}, Value: "Some-State"}},
 427                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 7}, Value: "City"}},
 428                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 10}, Value: "Internet Widgits Pty Ltd"}},
 429                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{2, 5, 4, 3}, Value: "false.example.com"}},
 430                         RelativeDistinguishedNameSET{AttributeTypeAndValue{Type: ObjectIdentifier{1, 2, 840, 113549, 1, 9, 1}, Value: "false@example.com"}},
 431                 },
 432                 PublicKey: PublicKeyInfo{
 433                         Algorithm: AlgorithmIdentifier{Algorithm: ObjectIdentifier{1, 2, 840, 113549, 1, 1, 1}},
 434                         PublicKey: BitString{
 435                                 Bytes: []uint8{
 436                                         0x30, 0x48, 0x2, 0x41, 0x0, 0xcd, 0xb7,
 437                                         0x63, 0x9c, 0x32, 0x78, 0xf0, 0x6, 0xaa, 0x27, 0x7f, 0x6e, 0xaf, 0x42,
 438                                         0x90, 0x2b, 0x59, 0x2d, 0x8c, 0xbc, 0xbe, 0x38, 0xa1, 0xc9, 0x2b, 0xa4,
 439                                         0x69, 0x5a, 0x33, 0x1b, 0x1d, 0xea, 0xde, 0xad, 0xd8, 0xe9, 0xa5, 0xc2,
 440                                         0x7e, 0x8c, 0x4c, 0x2f, 0xd0, 0xa8, 0x88, 0x96, 0x57, 0x72, 0x2a, 0x4f,
 441                                         0x2a, 0xf7, 0x58, 0x9c, 0xf2, 0xc7, 0x70, 0x45, 0xdc, 0x8f, 0xde, 0xec,
 442                                         0x35, 0x7d, 0x2, 0x3, 0x1, 0x0, 0x1,
 443                                 },
 444                                 BitLength: 592,
 445                         },
 446                 },
 447         },
 448         SignatureAlgorithm: AlgorithmIdentifier{Algorithm: ObjectIdentifier{1, 2, 840, 113549, 1, 1, 5}},
 449         SignatureValue: BitString{
 450                 Bytes: []uint8{
 451                         0xa6, 0x7b, 0x6, 0xec, 0x5e, 0xce,
 452                         0x92, 0x77, 0x2c, 0xa4, 0x13, 0xcb, 0xa3, 0xca, 0x12, 0x56, 0x8f, 0xdc, 0x6c,
 453                         0x7b, 0x45, 0x11, 0xcd, 0x40, 0xa7, 0xf6, 0x59, 0x98, 0x4, 0x2, 0xdf, 0x2b,
 454                         0x99, 0x8b, 0xb9, 0xa4, 0xa8, 0xcb, 0xeb, 0x34, 0xc0, 0xf0, 0xa7, 0x8c, 0xf8,
 455                         0xd9, 0x1e, 0xde, 0x14, 0xa5, 0xed, 0x76, 0xbf, 0x11, 0x6f, 0xe3, 0x60, 0xaa,
 456                         0xfa, 0x88, 0x21, 0x49, 0x4, 0x35,
 457                 },
 458                 BitLength: 512,
 459         },
 460 }
 461
 462 var derEncodedSelfSignedCertBytes = []byte{
 463         0x30, 0x82, 0x02, 0x18, 0x30,
 464         0x82, 0x01, 0xc2, 0x02, 0x09, 0x00, 0x8c, 0xc3, 0x37, 0x92, 0x10, 0xec, 0x2c,
 465         0x98, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
 466         0x05, 0x05, 0x00, 0x30, 0x81, 0x92, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
 467         0x04, 0x06, 0x13, 0x02, 0x58, 0x58, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55,
 468         0x04, 0x08, 0x13, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74,
 469         0x65, 0x31, 0x0d, 0x30, 0x0b, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x04, 0x43,
 470         0x69, 0x74, 0x79, 0x31, 0x21, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13,
 471         0x18, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64,
 472         0x67, 0x69, 0x74, 0x73, 0x20, 0x50, 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64, 0x31,
 473         0x1a, 0x30, 0x18, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x11, 0x66, 0x61, 0x6c,
 474         0x73, 0x65, 0x2e, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f,
 475         0x6d, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
 476         0x01, 0x09, 0x01, 0x16, 0x11, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x40, 0x65, 0x78,
 477         0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x1e, 0x17, 0x0d,
 478         0x30, 0x39, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x32, 0x35, 0x35, 0x33, 0x5a,
 479         0x17, 0x0d, 0x31, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x32, 0x35, 0x35,
 480         0x33, 0x5a, 0x30, 0x81, 0x92, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
 481         0x06, 0x13, 0x02, 0x58, 0x58, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04,
 482         0x08, 0x13, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65,
 483         0x31, 0x0d, 0x30, 0x0b, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x04, 0x43, 0x69,
 484         0x74, 0x79, 0x31, 0x21, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x18,
 485         0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64, 0x67,
 486         0x69, 0x74, 0x73, 0x20, 0x50, 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64, 0x31, 0x1a,
 487         0x30, 0x18, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x11, 0x66, 0x61, 0x6c, 0x73,
 488         0x65, 0x2e, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d,
 489         0x31, 0x20, 0x30, 0x1e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01,
 490         0x09, 0x01, 0x16, 0x11, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x40, 0x65, 0x78, 0x61,
 491         0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x5c, 0x30, 0x0d, 0x06,
 492         0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03,
 493         0x4b, 0x00, 0x30, 0x48, 0x02, 0x41, 0x00, 0xcd, 0xb7, 0x63, 0x9c, 0x32, 0x78,
 494         0xf0, 0x06, 0xaa, 0x27, 0x7f, 0x6e, 0xaf, 0x42, 0x90, 0x2b, 0x59, 0x2d, 0x8c,
 495         0xbc, 0xbe, 0x38, 0xa1, 0xc9, 0x2b, 0xa4, 0x69, 0x5a, 0x33, 0x1b, 0x1d, 0xea,
 496         0xde, 0xad, 0xd8, 0xe9, 0xa5, 0xc2, 0x7e, 0x8c, 0x4c, 0x2f, 0xd0, 0xa8, 0x88,
 497         0x96, 0x57, 0x72, 0x2a, 0x4f, 0x2a, 0xf7, 0x58, 0x9c, 0xf2, 0xc7, 0x70, 0x45,
 498         0xdc, 0x8f, 0xde, 0xec, 0x35, 0x7d, 0x02, 0x03, 0x01, 0x00, 0x01, 0x30, 0x0d,
 499         0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00,
 500         0x03, 0x41, 0x00, 0xa6, 0x7b, 0x06, 0xec, 0x5e, 0xce, 0x92, 0x77, 0x2c, 0xa4,
 501         0x13, 0xcb, 0xa3, 0xca, 0x12, 0x56, 0x8f, 0xdc, 0x6c, 0x7b, 0x45, 0x11, 0xcd,
 502         0x40, 0xa7, 0xf6, 0x59, 0x98, 0x04, 0x02, 0xdf, 0x2b, 0x99, 0x8b, 0xb9, 0xa4,
 503         0xa8, 0xcb, 0xeb, 0x34, 0xc0, 0xf0, 0xa7, 0x8c, 0xf8, 0xd9, 0x1e, 0xde, 0x14,
 504         0xa5, 0xed, 0x76, 0xbf, 0x11, 0x6f, 0xe3, 0x60, 0xaa, 0xfa, 0x88, 0x21, 0x49,
 505         0x04, 0x35,
 506 }
 507
 508 var derEncodedPaypalNULCertBytes = []byte{
 509         0x30, 0x82, 0x06, 0x44, 0x30,
 510         0x82, 0x05, 0xad, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x03, 0x00, 0xf0, 0x9b,
 511         0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05,
 512         0x05, 0x00, 0x30, 0x82, 0x01, 0x12, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
 513         0x04, 0x06, 0x13, 0x02, 0x45, 0x53, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55,
 514         0x04, 0x08, 0x13, 0x09, 0x42, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x6f, 0x6e, 0x61,
 515         0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x09, 0x42, 0x61,
 516         0x72, 0x63, 0x65, 0x6c, 0x6f, 0x6e, 0x61, 0x31, 0x29, 0x30, 0x27, 0x06, 0x03,
 517         0x55, 0x04, 0x0a, 0x13, 0x20, 0x49, 0x50, 0x53, 0x20, 0x43, 0x65, 0x72, 0x74,
 518         0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x75, 0x74,
 519         0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x73, 0x2e, 0x6c, 0x2e, 0x31, 0x2e,
 520         0x30, 0x2c, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x14, 0x25, 0x67, 0x65, 0x6e, 0x65,
 521         0x72, 0x61, 0x6c, 0x40, 0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d,
 522         0x20, 0x43, 0x2e, 0x49, 0x2e, 0x46, 0x2e, 0x20, 0x20, 0x42, 0x2d, 0x42, 0x36,
 523         0x32, 0x32, 0x31, 0x30, 0x36, 0x39, 0x35, 0x31, 0x2e, 0x30, 0x2c, 0x06, 0x03,
 524         0x55, 0x04, 0x0b, 0x13, 0x25, 0x69, 0x70, 0x73, 0x43, 0x41, 0x20, 0x43, 0x4c,
 525         0x41, 0x53, 0x45, 0x41, 0x31, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69,
 526         0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72,
 527         0x69, 0x74, 0x79, 0x31, 0x2e, 0x30, 0x2c, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
 528         0x25, 0x69, 0x70, 0x73, 0x43, 0x41, 0x20, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41,
 529         0x31, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69,
 530         0x6f, 0x6e, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x31,
 531         0x20, 0x30, 0x1e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09,
 532         0x01, 0x16, 0x11, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x40, 0x69, 0x70,
 533         0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x1e, 0x17, 0x0d, 0x30, 0x39,
 534         0x30, 0x32, 0x32, 0x34, 0x32, 0x33, 0x30, 0x34, 0x31, 0x37, 0x5a, 0x17, 0x0d,
 535         0x31, 0x31, 0x30, 0x32, 0x32, 0x34, 0x32, 0x33, 0x30, 0x34, 0x31, 0x37, 0x5a,
 536         0x30, 0x81, 0x94, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
 537         0x02, 0x55, 0x53, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13,
 538         0x0a, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x31, 0x16,
 539         0x30, 0x14, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x0d, 0x53, 0x61, 0x6e, 0x20,
 540         0x46, 0x72, 0x61, 0x6e, 0x63, 0x69, 0x73, 0x63, 0x6f, 0x31, 0x11, 0x30, 0x0f,
 541         0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x08, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69,
 542         0x74, 0x79, 0x31, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x0b,
 543         0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x55, 0x6e, 0x69, 0x74, 0x31, 0x2f,
 544         0x30, 0x2d, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x26, 0x77, 0x77, 0x77, 0x2e,
 545         0x70, 0x61, 0x79, 0x70, 0x61, 0x6c, 0x2e, 0x63, 0x6f, 0x6d, 0x00, 0x73, 0x73,
 546         0x6c, 0x2e, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x6e, 0x65,
 547         0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x63, 0x63, 0x30, 0x81, 0x9f, 0x30, 0x0d,
 548         0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00,
 549         0x03, 0x81, 0x8d, 0x00, 0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xd2, 0x69,
 550         0xfa, 0x6f, 0x3a, 0x00, 0xb4, 0x21, 0x1b, 0xc8, 0xb1, 0x02, 0xd7, 0x3f, 0x19,
 551         0xb2, 0xc4, 0x6d, 0xb4, 0x54, 0xf8, 0x8b, 0x8a, 0xcc, 0xdb, 0x72, 0xc2, 0x9e,
 552         0x3c, 0x60, 0xb9, 0xc6, 0x91, 0x3d, 0x82, 0xb7, 0x7d, 0x99, 0xff, 0xd1, 0x29,
 553         0x84, 0xc1, 0x73, 0x53, 0x9c, 0x82, 0xdd, 0xfc, 0x24, 0x8c, 0x77, 0xd5, 0x41,
 554         0xf3, 0xe8, 0x1e, 0x42, 0xa1, 0xad, 0x2d, 0x9e, 0xff, 0x5b, 0x10, 0x26, 0xce,
 555         0x9d, 0x57, 0x17, 0x73, 0x16, 0x23, 0x38, 0xc8, 0xd6, 0xf1, 0xba, 0xa3, 0x96,
 556         0x5b, 0x16, 0x67, 0x4a, 0x4f, 0x73, 0x97, 0x3a, 0x4d, 0x14, 0xa4, 0xf4, 0xe2,
 557         0x3f, 0x8b, 0x05, 0x83, 0x42, 0xd1, 0xd0, 0xdc, 0x2f, 0x7a, 0xe5, 0xb6, 0x10,
 558         0xb2, 0x11, 0xc0, 0xdc, 0x21, 0x2a, 0x90, 0xff, 0xae, 0x97, 0x71, 0x5a, 0x49,
 559         0x81, 0xac, 0x40, 0xf3, 0x3b, 0xb8, 0x59, 0xb2, 0x4f, 0x02, 0x03, 0x01, 0x00,
 560         0x01, 0xa3, 0x82, 0x03, 0x21, 0x30, 0x82, 0x03, 0x1d, 0x30, 0x09, 0x06, 0x03,
 561         0x55, 0x1d, 0x13, 0x04, 0x02, 0x30, 0x00, 0x30, 0x11, 0x06, 0x09, 0x60, 0x86,
 562         0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x01, 0x04, 0x04, 0x03, 0x02, 0x06, 0x40,
 563         0x30, 0x0b, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x04, 0x04, 0x03, 0x02, 0x03, 0xf8,
 564         0x30, 0x13, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x04, 0x0c, 0x30, 0x0a, 0x06, 0x08,
 565         0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01, 0x30, 0x1d, 0x06, 0x03, 0x55,
 566         0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x61, 0x8f, 0x61, 0x34, 0x43, 0x55, 0x14,
 567         0x7f, 0x27, 0x09, 0xce, 0x4c, 0x8b, 0xea, 0x9b, 0x7b, 0x19, 0x25, 0xbc, 0x6e,
 568         0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14,
 569         0x0e, 0x07, 0x60, 0xd4, 0x39, 0xc9, 0x1b, 0x5b, 0x5d, 0x90, 0x7b, 0x23, 0xc8,
 570         0xd2, 0x34, 0x9d, 0x4a, 0x9a, 0x46, 0x39, 0x30, 0x09, 0x06, 0x03, 0x55, 0x1d,
 571         0x11, 0x04, 0x02, 0x30, 0x00, 0x30, 0x1c, 0x06, 0x03, 0x55, 0x1d, 0x12, 0x04,
 572         0x15, 0x30, 0x13, 0x81, 0x11, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x40,
 573         0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x72, 0x06, 0x09,
 574         0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x0d, 0x04, 0x65, 0x16, 0x63,
 575         0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20,
 576         0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x4e,
 577         0x4f, 0x54, 0x20, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x41, 0x54, 0x45, 0x44, 0x2e,
 578         0x20, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41, 0x31, 0x20, 0x53, 0x65, 0x72, 0x76,
 579         0x65, 0x72, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74,
 580         0x65, 0x20, 0x69, 0x73, 0x73, 0x75, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x68,
 581         0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x70,
 582         0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x30, 0x2f, 0x06, 0x09, 0x60,
 583         0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x02, 0x04, 0x22, 0x16, 0x20, 0x68,
 584         0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x70,
 585         0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61,
 586         0x32, 0x30, 0x30, 0x32, 0x2f, 0x30, 0x43, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
 587         0x86, 0xf8, 0x42, 0x01, 0x04, 0x04, 0x36, 0x16, 0x34, 0x68, 0x74, 0x74, 0x70,
 588         0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x70, 0x73, 0x63, 0x61,
 589         0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61, 0x32, 0x30, 0x30,
 590         0x32, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61, 0x32, 0x30, 0x30, 0x32, 0x43, 0x4c,
 591         0x41, 0x53, 0x45, 0x41, 0x31, 0x2e, 0x63, 0x72, 0x6c, 0x30, 0x46, 0x06, 0x09,
 592         0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x03, 0x04, 0x39, 0x16, 0x37,
 593         0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69,
 594         0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63,
 595         0x61, 0x32, 0x30, 0x30, 0x32, 0x2f, 0x72, 0x65, 0x76, 0x6f, 0x63, 0x61, 0x74,
 596         0x69, 0x6f, 0x6e, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41, 0x31, 0x2e, 0x68, 0x74,
 597         0x6d, 0x6c, 0x3f, 0x30, 0x43, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8,
 598         0x42, 0x01, 0x07, 0x04, 0x36, 0x16, 0x34, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a,
 599         0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63,
 600         0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61, 0x32, 0x30, 0x30, 0x32, 0x2f,
 601         0x72, 0x65, 0x6e, 0x65, 0x77, 0x61, 0x6c, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41,
 602         0x31, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x3f, 0x30, 0x41, 0x06, 0x09, 0x60, 0x86,
 603         0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x08, 0x04, 0x34, 0x16, 0x32, 0x68, 0x74,
 604         0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x70, 0x73,
 605         0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61, 0x32,
 606         0x30, 0x30, 0x32, 0x2f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x43, 0x4c, 0x41,
 607         0x53, 0x45, 0x41, 0x31, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x30, 0x81, 0x83, 0x06,
 608         0x03, 0x55, 0x1d, 0x1f, 0x04, 0x7c, 0x30, 0x7a, 0x30, 0x39, 0xa0, 0x37, 0xa0,
 609         0x35, 0x86, 0x33, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
 610         0x2e, 0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70,
 611         0x73, 0x63, 0x61, 0x32, 0x30, 0x30, 0x32, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61,
 612         0x32, 0x30, 0x30, 0x32, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41, 0x31, 0x2e, 0x63,
 613         0x72, 0x6c, 0x30, 0x3d, 0xa0, 0x3b, 0xa0, 0x39, 0x86, 0x37, 0x68, 0x74, 0x74,
 614         0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x62, 0x61, 0x63, 0x6b, 0x2e, 0x69,
 615         0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x70, 0x73, 0x63,
 616         0x61, 0x32, 0x30, 0x30, 0x32, 0x2f, 0x69, 0x70, 0x73, 0x63, 0x61, 0x32, 0x30,
 617         0x30, 0x32, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41, 0x31, 0x2e, 0x63, 0x72, 0x6c,
 618         0x30, 0x32, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04,
 619         0x26, 0x30, 0x24, 0x30, 0x22, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07,
 620         0x30, 0x01, 0x86, 0x16, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6f, 0x63,
 621         0x73, 0x70, 0x2e, 0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
 622         0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05,
 623         0x05, 0x00, 0x03, 0x81, 0x81, 0x00, 0x68, 0xee, 0x79, 0x97, 0x97, 0xdd, 0x3b,
 624         0xef, 0x16, 0x6a, 0x06, 0xf2, 0x14, 0x9a, 0x6e, 0xcd, 0x9e, 0x12, 0xf7, 0xaa,
 625         0x83, 0x10, 0xbd, 0xd1, 0x7c, 0x98, 0xfa, 0xc7, 0xae, 0xd4, 0x0e, 0x2c, 0x9e,
 626         0x38, 0x05, 0x9d, 0x52, 0x60, 0xa9, 0x99, 0x0a, 0x81, 0xb4, 0x98, 0x90, 0x1d,
 627         0xae, 0xbb, 0x4a, 0xd7, 0xb9, 0xdc, 0x88, 0x9e, 0x37, 0x78, 0x41, 0x5b, 0xf7,
 628         0x82, 0xa5, 0xf2, 0xba, 0x41, 0x25, 0x5a, 0x90, 0x1a, 0x1e, 0x45, 0x38, 0xa1,
 629         0x52, 0x58, 0x75, 0x94, 0x26, 0x44, 0xfb, 0x20, 0x07, 0xba, 0x44, 0xcc, 0xe5,
 630         0x4a, 0x2d, 0x72, 0x3f, 0x98, 0x47, 0xf6, 0x26, 0xdc, 0x05, 0x46, 0x05, 0x07,
 631         0x63, 0x21, 0xab, 0x46, 0x9b, 0x9c, 0x78, 0xd5, 0x54, 0x5b, 0x3d, 0x0c, 0x1e,
 632         0xc8, 0x64, 0x8c, 0xb5, 0x50, 0x23, 0x82, 0x6f, 0xdb, 0xb8, 0x22, 0x1c, 0x43,
 633         0x96, 0x07, 0xa8, 0xbb,
 634 }