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