libgo/go/encoding/pem/pem_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 pem
   6
   7 import (
   8         "bytes"
   9         "io"
  10         "reflect"
  11         "strings"
  12         "testing"
  13         "testing/quick"
  14 )
  15
  16 type GetLineTest struct {
  17         in, out1, out2 string
  18 }
  19
  20 var getLineTests = []GetLineTest{
  21         {"abc", "abc", ""},
  22         {"abc\r", "abc\r", ""},
  23         {"abc\n", "abc", ""},
  24         {"abc\r\n", "abc", ""},
  25         {"abc\nd", "abc", "d"},
  26         {"abc\r\nd", "abc", "d"},
  27         {"\nabc", "", "abc"},
  28         {"\r\nabc", "", "abc"},
  29         {"abc\t \nd", "abc", "d"},
  30         {"\t abc\nd", "\t abc", "d"},
  31         {"abc\n\t d", "abc", "\t d"},
  32         {"abc\nd\t ", "abc", "d\t "},
  33 }
  34
  35 func TestGetLine(t *testing.T) {
  36         for i, test := range getLineTests {
  37                 x, y := getLine([]byte(test.in))
  38                 if string(x) != test.out1 || string(y) != test.out2 {
  39                         t.Errorf("#%d got:%+v,%+v want:%s,%s", i, x, y, test.out1, test.out2)
  40                 }
  41         }
  42 }
  43
  44 func TestDecode(t *testing.T) {
  45         result, remainder := Decode([]byte(pemData))
  46         if !reflect.DeepEqual(result, certificate) {
  47                 t.Errorf("#0 got:%#v want:%#v", result, certificate)
  48         }
  49         result, remainder = Decode(remainder)
  50         if !reflect.DeepEqual(result, privateKey) {
  51                 t.Errorf("#1 got:%#v want:%#v", result, privateKey)
  52         }
  53
  54         isEmpty := func(block *Block) bool {
  55                 return block != nil && block.Type == "EMPTY" && len(block.Headers) == 0 && len(block.Bytes) == 0
  56         }
  57         result, remainder = Decode(remainder)
  58         if !isEmpty(result) {
  59                 t.Errorf("#2 should be empty but got:%#v", result)
  60         }
  61         result, remainder = Decode(remainder)
  62         if !isEmpty(result) {
  63                 t.Errorf("#3 should be empty but got:%#v", result)
  64         }
  65         result, remainder = Decode(remainder)
  66         if !isEmpty(result) {
  67                 t.Errorf("#4 should be empty but got:%#v", result)
  68         }
  69
  70         result, remainder = Decode(remainder)
  71         if result == nil || result.Type != "HEADERS" || len(result.Headers) != 1 {
  72                 t.Errorf("#5 expected single header block but got :%v", result)
  73         }
  74
  75         if len(remainder) != 0 {
  76                 t.Errorf("expected nothing remaining of pemData, but found %s", string(remainder))
  77         }
  78
  79         result, _ = Decode([]byte(pemPrivateKey2))
  80         if !reflect.DeepEqual(result, privateKey2) {
  81                 t.Errorf("#2 got:%#v want:%#v", result, privateKey2)
  82         }
  83 }
  84
  85 const pemTooFewEndingDashes = `
  86 -----BEGIN FOO-----
  87 dGVzdA==
  88 -----END FOO----`
  89
  90 const pemTooManyEndingDashes = `
  91 -----BEGIN FOO-----
  92 dGVzdA==
  93 -----END FOO------`
  94
  95 const pemTrailingNonWhitespace = `
  96 -----BEGIN FOO-----
  97 dGVzdA==
  98 -----END FOO----- .`
  99
 100 const pemWrongEndingType = `
 101 -----BEGIN FOO-----
 102 dGVzdA==
 103 -----END BAR-----`
 104
 105 const pemMissingEndingSpace = `
 106 -----BEGIN FOO-----
 107 dGVzdA==
 108 -----ENDBAR-----`
 109
 110 var badPEMTests = []struct {
 111         name  string
 112         input string
 113 }{
 114         {
 115                 "too few trailing dashes",
 116                 pemTooFewEndingDashes,
 117         },
 118         {
 119                 "too many trailing dashes",
 120                 pemTooManyEndingDashes,
 121         },
 122         {
 123                 "trailing non-whitespace",
 124                 pemTrailingNonWhitespace,
 125         },
 126         {
 127                 "incorrect ending type",
 128                 pemWrongEndingType,
 129         },
 130         {
 131                 "missing ending space",
 132                 pemMissingEndingSpace,
 133         },
 134 }
 135
 136 func TestBadDecode(t *testing.T) {
 137         for _, test := range badPEMTests {
 138                 result, _ := Decode([]byte(test.input))
 139                 if result != nil {
 140                         t.Errorf("unexpected success while parsing %q", test.name)
 141                 }
 142         }
 143 }
 144
 145 func TestEncode(t *testing.T) {
 146         r := EncodeToMemory(privateKey2)
 147         if string(r) != pemPrivateKey2 {
 148                 t.Errorf("got:%s want:%s", r, pemPrivateKey2)
 149         }
 150 }
 151
 152 type lineBreakerTest struct {
 153         in, out string
 154 }
 155
 156 const sixtyFourCharString = "0123456789012345678901234567890123456789012345678901234567890123"
 157
 158 var lineBreakerTests = []lineBreakerTest{
 159         {"", ""},
 160         {"a", "a\n"},
 161         {"ab", "ab\n"},
 162         {sixtyFourCharString, sixtyFourCharString + "\n"},
 163         {sixtyFourCharString + "X", sixtyFourCharString + "\nX\n"},
 164         {sixtyFourCharString + sixtyFourCharString, sixtyFourCharString + "\n" + sixtyFourCharString + "\n"},
 165 }
 166
 167 func TestLineBreaker(t *testing.T) {
 168         for i, test := range lineBreakerTests {
 169                 buf := new(bytes.Buffer)
 170                 var breaker lineBreaker
 171                 breaker.out = buf
 172                 _, err := breaker.Write([]byte(test.in))
 173                 if err != nil {
 174                         t.Errorf("#%d: error from Write: %s", i, err)
 175                         continue
 176                 }
 177                 err = breaker.Close()
 178                 if err != nil {
 179                         t.Errorf("#%d: error from Close: %s", i, err)
 180                         continue
 181                 }
 182
 183                 if string(buf.Bytes()) != test.out {
 184                         t.Errorf("#%d: got:%s want:%s", i, string(buf.Bytes()), test.out)
 185                 }
 186         }
 187
 188         for i, test := range lineBreakerTests {
 189                 buf := new(bytes.Buffer)
 190                 var breaker lineBreaker
 191                 breaker.out = buf
 192
 193                 for i := 0; i < len(test.in); i++ {
 194                         _, err := breaker.Write([]byte(test.in[i : i+1]))
 195                         if err != nil {
 196                                 t.Errorf("#%d: error from Write (byte by byte): %s", i, err)
 197                                 continue
 198                         }
 199                 }
 200                 err := breaker.Close()
 201                 if err != nil {
 202                         t.Errorf("#%d: error from Close (byte by byte): %s", i, err)
 203                         continue
 204                 }
 205
 206                 if string(buf.Bytes()) != test.out {
 207                         t.Errorf("#%d: (byte by byte) got:%s want:%s", i, string(buf.Bytes()), test.out)
 208                 }
 209         }
 210 }
 211
 212 func TestFuzz(t *testing.T) {
 213         // PEM is a text-based format. Assume header fields with leading/trailing spaces
 214         // or embedded newlines will not round trip correctly and don't need to be tested.
 215         isBad := func(s string) bool {
 216                 return strings.ContainsAny(s, "\r\n") || strings.TrimSpace(s) != s
 217         }
 218
 219         testRoundtrip := func(block Block) bool {
 220                 // Reject bad Type
 221                 // Type with colons will proceed as key/val pair and cause an error.
 222                 if isBad(block.Type) || strings.Contains(block.Type, ":") {
 223                         return true
 224                 }
 225                 for key, val := range block.Headers {
 226                         // Reject bad key/val.
 227                         // Also, keys with colons cannot be encoded, because : is the key: val separator.
 228                         if isBad(key) || isBad(val) || strings.Contains(key, ":") {
 229                                 return true
 230                         }
 231                 }
 232
 233                 var buf bytes.Buffer
 234                 if err := Encode(&buf, &block); err != nil {
 235                         t.Errorf("Encode of %#v resulted in error: %s", &block, err)
 236                         return false
 237                 }
 238                 decoded, rest := Decode(buf.Bytes())
 239                 if block.Headers == nil {
 240                         // Encoder supports nil Headers but decoder returns initialized.
 241                         block.Headers = make(map[string]string)
 242                 }
 243                 if block.Bytes == nil {
 244                         // Encoder supports nil Bytes but decoder returns initialized.
 245                         block.Bytes = make([]byte, 0)
 246                 }
 247                 if !reflect.DeepEqual(decoded, &block) {
 248                         t.Errorf("Encode of %#v decoded as %#v", &block, decoded)
 249                         return false
 250                 }
 251                 if len(rest) != 0 {
 252                         t.Errorf("Encode of %#v decoded correctly, but with %x left over", block, rest)
 253                         return false
 254                 }
 255                 return true
 256         }
 257
 258         // Explicitly test the empty block.
 259         if !testRoundtrip(Block{
 260                 Type:    "EMPTY",
 261                 Headers: make(map[string]string),
 262                 Bytes:   []byte{},
 263         }) {
 264                 return
 265         }
 266
 267         quick.Check(testRoundtrip, nil)
 268 }
 269
 270 func BenchmarkEncode(b *testing.B) {
 271         data := &Block{Bytes: make([]byte, 65536)}
 272         b.SetBytes(int64(len(data.Bytes)))
 273         for i := 0; i < b.N; i++ {
 274                 Encode(io.Discard, data)
 275         }
 276 }
 277
 278 func BenchmarkDecode(b *testing.B) {
 279         block := &Block{Bytes: make([]byte, 65536)}
 280         data := EncodeToMemory(block)
 281         b.SetBytes(int64(len(data)))
 282         b.ResetTimer()
 283         for i := 0; i < b.N; i++ {
 284                 Decode(data)
 285         }
 286 }
 287
 288 var pemData = testingKey(`verify return:0
 289 -----BEGIN CERTIFICATE-----
 290 sdlfkjskldfj
 291   -----BEGIN CERTIFICATE-----
 292 ---
 293 Certificate chain
 294  0 s:/C=AU/ST=Somewhere/L=Someplace/O=Foo Bar/CN=foo.example.com
 295    i:/C=ZA/O=CA Inc./CN=CA Inc
 296 -----BEGIN CERTIFICATE-----
 297 testing
 298 -----BEGIN CERTIFICATE-----
 299 -----BEGIN CERTIFICATE-----
 300 MIID6TCCA1ICAQEwDQYJKoZIhvcNAQEFBQAwgYsxCzAJBgNVBAYTAlVTMRMwEQYD
 301 VQQIEwpDYWxpZm9ybmlhMRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMRQwEgYDVQQK
 302 EwtHb29nbGUgSW5jLjEMMAoGA1UECxMDRW5nMQwwCgYDVQQDEwNhZ2wxHTAbBgkq
 303 hkiG9w0BCQEWDmFnbEBnb29nbGUuY29tMB4XDTA5MDkwOTIyMDU0M1oXDTEwMDkw
 304 OTIyMDU0M1owajELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUtU3RhdGUxITAf
 305 BgNVBAoTGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEjMCEGA1UEAxMaZXVyb3Bh
 306 LnNmby5jb3JwLmdvb2dsZS5jb20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK
 307 AoICAQC6pgYt7/EibBDumASF+S0qvqdL/f+nouJw2T1Qc8GmXF/iiUcrsgzh/Fd8
 308 pDhz/T96Qg9IyR4ztuc2MXrmPra+zAuSf5bevFReSqvpIt8Duv0HbDbcqs/XKPfB
 309 uMDe+of7a9GCywvAZ4ZUJcp0thqD9fKTTjUWOBzHY1uNE4RitrhmJCrbBGXbJ249
 310 bvgmb7jgdInH2PU7PT55hujvOoIsQW2osXBFRur4pF1wmVh4W4lTLD6pjfIMUcML
 311 ICHEXEN73PDic8KS3EtNYCwoIld+tpIBjE1QOb1KOyuJBNW6Esw9ALZn7stWdYcE
 312 qAwvv20egN2tEXqj7Q4/1ccyPZc3PQgC3FJ8Be2mtllM+80qf4dAaQ/fWvCtOrQ5
 313 pnfe9juQvCo8Y0VGlFcrSys/MzSg9LJ/24jZVgzQved/Qupsp89wVidwIzjt+WdS
 314 fyWfH0/v1aQLvu5cMYuW//C0W2nlYziL5blETntM8My2ybNARy3ICHxCBv2RNtPI
 315 WQVm+E9/W5rwh2IJR4DHn2LHwUVmT/hHNTdBLl5Uhwr4Wc7JhE7AVqb14pVNz1lr
 316 5jxsp//ncIwftb7mZQ3DF03Yna+jJhpzx8CQoeLT6aQCHyzmH68MrHHT4MALPyUs
 317 Pomjn71GNTtDeWAXibjCgdL6iHACCF6Htbl0zGlG0OAK+bdn0QIDAQABMA0GCSqG
 318 SIb3DQEBBQUAA4GBAOKnQDtqBV24vVqvesL5dnmyFpFPXBn3WdFfwD6DzEb21UVG
 319 5krmJiu+ViipORJPGMkgoL6BjU21XI95VQbun5P8vvg8Z+FnFsvRFY3e1CCzAVQY
 320 ZsUkLw2I7zI/dNlWdB8Xp7v+3w9sX5N3J/WuJ1KOO5m26kRlHQo7EzT3974g
 321 -----END CERTIFICATE-----
 322  1 s:/C=ZA/O=Ca Inc./CN=CA Inc
 323
 324 -----BEGIN RSA TESTING KEY-----
 325 Proc-Type: 4,ENCRYPTED
 326 DEK-Info: DES-EDE3-CBC,80C7C7A09690757A
 327
 328 eQp5ZkH6CyHBz7BZfUPxyLCCmftsBJ7HlqGb8Ld21cSwnzWZ4/SIlhyrUtsfw7VR
 329 2TTwA+odo9ex7GdxOTaH8oZFumIRoiEjHsk8U7Bhntp+ekkPP79xunnN7hb7hkhr
 330 yGDQZgA7s2cQHQ71v3gwT2BACAft26jCjbM1wgNzBnJ8M0Rzn68YWqaPtdBu8qb/
 331 zVR5JB1mnqvTSbFsfF5yMc6o2WQ9jJCl6KypnMl+BpL+dlvdjYVK4l9lYsB1Hs3d
 332 +zDBbWxos818zzhS8/y6eIfiSG27cqrbhURbmgiSfDXjncK4m/pLcQ7mmBL6mFOr
 333 3Pj4jepzgOiFRL6MKE//h62fZvI1ErYr8VunHEykgKNhChDvb1RO6LEfqKBu+Ivw
 334 TB6fBhW3TCLMnVPYVoYwA+fHNTmZZm8BEonlIMfI+KktjWUg4Oia+NI6vKcPpFox
 335 hSnlGgCtvfEaq5/H4kHJp95eOpnFsLviw2seHNkz/LxJMRP1X428+DpYW/QD/0JU
 336 tJSuC/q9FUHL6RI3u/Asrv8pCb4+D7i1jW/AMIdJTtycOGsbPxQA7yHMWujHmeb1
 337 BTiHcL3s3KrJu1vDVrshvxfnz71KTeNnZH8UbOqT5i7fPGyXtY1XJddcbI/Q6tXf
 338 wHFsZc20TzSdsVLBtwksUacpbDogcEVMctnNrB8FIrB3vZEv9Q0Z1VeY7nmTpF+6
 339 a+z2P7acL7j6A6Pr3+q8P9CPiPC7zFonVzuVPyB8GchGR2hytyiOVpuD9+k8hcuw
 340 ZWAaUoVtWIQ52aKS0p19G99hhb+IVANC4akkdHV4SP8i7MVNZhfUmg==
 341 -----END RSA TESTING KEY-----
 342
 343
 344 -----BEGIN EMPTY-----
 345 -----END EMPTY-----
 346
 347 -----BEGIN EMPTY-----
 348
 349 -----END EMPTY-----
 350
 351 -----BEGIN EMPTY-----
 352
 353
 354 -----END EMPTY-----
 355
 356 # This shouldn't be recognised because of the missing newline after the
 357 headers.
 358 -----BEGIN HEADERS-----
 359 Header: 1
 360 -----END HEADERS-----
 361
 362 # This should be valid, however.
 363 -----BEGIN HEADERS-----
 364 Header: 1
 365
 366 -----END HEADERS-----`)
 367
 368 var certificate = &Block{Type: "CERTIFICATE",
 369         Headers: map[string]string{},
 370         Bytes: []uint8{0x30, 0x82, 0x3, 0xe9, 0x30, 0x82, 0x3, 0x52, 0x2, 0x1,
 371                 0x1, 0x30, 0xd, 0x6, 0x9, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0xd,
 372                 0x1, 0x1, 0x5, 0x5, 0x0, 0x30, 0x81, 0x8b, 0x31, 0xb, 0x30,
 373                 0x9, 0x6, 0x3, 0x55, 0x4, 0x6, 0x13, 0x2, 0x55, 0x53, 0x31,
 374                 0x13, 0x30, 0x11, 0x6, 0x3, 0x55, 0x4, 0x8, 0x13, 0xa, 0x43,
 375                 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x31,
 376                 0x16, 0x30, 0x14, 0x6, 0x3, 0x55, 0x4, 0x7, 0x13, 0xd, 0x53,
 377                 0x61, 0x6e, 0x20, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x69, 0x73,
 378                 0x63, 0x6f, 0x31, 0x14, 0x30, 0x12, 0x6, 0x3, 0x55, 0x4, 0xa,
 379                 0x13, 0xb, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x20, 0x49,
 380                 0x6e, 0x63, 0x2e, 0x31, 0xc, 0x30, 0xa, 0x6, 0x3, 0x55, 0x4,
 381                 0xb, 0x13, 0x3, 0x45, 0x6e, 0x67, 0x31, 0xc, 0x30, 0xa, 0x6,
 382                 0x3, 0x55, 0x4, 0x3, 0x13, 0x3, 0x61, 0x67, 0x6c, 0x31, 0x1d,
 383                 0x30, 0x1b, 0x6, 0x9, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0xd, 0x1,
 384                 0x9, 0x1, 0x16, 0xe, 0x61, 0x67, 0x6c, 0x40, 0x67, 0x6f, 0x6f,
 385                 0x67, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x1e, 0x17,
 386                 0xd, 0x30, 0x39, 0x30, 0x39, 0x30, 0x39, 0x32, 0x32, 0x30,
 387                 0x35, 0x34, 0x33, 0x5a, 0x17, 0xd, 0x31, 0x30, 0x30, 0x39,
 388                 0x30, 0x39, 0x32, 0x32, 0x30, 0x35, 0x34, 0x33, 0x5a, 0x30,
 389                 0x6a, 0x31, 0xb, 0x30, 0x9, 0x6, 0x3, 0x55, 0x4, 0x6, 0x13,
 390                 0x2, 0x41, 0x55, 0x31, 0x13, 0x30, 0x11, 0x6, 0x3, 0x55, 0x4,
 391                 0x8, 0x13, 0xa, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61,
 392                 0x74, 0x65, 0x31, 0x21, 0x30, 0x1f, 0x6, 0x3, 0x55, 0x4, 0xa,
 393                 0x13, 0x18, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74,
 394                 0x20, 0x57, 0x69, 0x64, 0x67, 0x69, 0x74, 0x73, 0x20, 0x50,
 395                 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64, 0x31, 0x23, 0x30, 0x21,
 396                 0x6, 0x3, 0x55, 0x4, 0x3, 0x13, 0x1a, 0x65, 0x75, 0x72, 0x6f,
 397                 0x70, 0x61, 0x2e, 0x73, 0x66, 0x6f, 0x2e, 0x63, 0x6f, 0x72,
 398                 0x70, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x63,
 399                 0x6f, 0x6d, 0x30, 0x82, 0x2, 0x22, 0x30, 0xd, 0x6, 0x9, 0x2a,
 400                 0x86, 0x48, 0x86, 0xf7, 0xd, 0x1, 0x1, 0x1, 0x5, 0x0, 0x3,
 401                 0x82, 0x2, 0xf, 0x0, 0x30, 0x82, 0x2, 0xa, 0x2, 0x82, 0x2, 0x1,
 402                 0x0, 0xba, 0xa6, 0x6, 0x2d, 0xef, 0xf1, 0x22, 0x6c, 0x10, 0xee,
 403                 0x98, 0x4, 0x85, 0xf9, 0x2d, 0x2a, 0xbe, 0xa7, 0x4b, 0xfd,
 404                 0xff, 0xa7, 0xa2, 0xe2, 0x70, 0xd9, 0x3d, 0x50, 0x73, 0xc1,
 405                 0xa6, 0x5c, 0x5f, 0xe2, 0x89, 0x47, 0x2b, 0xb2, 0xc, 0xe1,
 406                 0xfc, 0x57, 0x7c, 0xa4, 0x38, 0x73, 0xfd, 0x3f, 0x7a, 0x42,
 407                 0xf, 0x48, 0xc9, 0x1e, 0x33, 0xb6, 0xe7, 0x36, 0x31, 0x7a,
 408                 0xe6, 0x3e, 0xb6, 0xbe, 0xcc, 0xb, 0x92, 0x7f, 0x96, 0xde,
 409                 0xbc, 0x54, 0x5e, 0x4a, 0xab, 0xe9, 0x22, 0xdf, 0x3, 0xba,
 410                 0xfd, 0x7, 0x6c, 0x36, 0xdc, 0xaa, 0xcf, 0xd7, 0x28, 0xf7,
 411                 0xc1, 0xb8, 0xc0, 0xde, 0xfa, 0x87, 0xfb, 0x6b, 0xd1, 0x82,
 412                 0xcb, 0xb, 0xc0, 0x67, 0x86, 0x54, 0x25, 0xca, 0x74, 0xb6,
 413                 0x1a, 0x83, 0xf5, 0xf2, 0x93, 0x4e, 0x35, 0x16, 0x38, 0x1c,
 414                 0xc7, 0x63, 0x5b, 0x8d, 0x13, 0x84, 0x62, 0xb6, 0xb8, 0x66,
 415                 0x24, 0x2a, 0xdb, 0x4, 0x65, 0xdb, 0x27, 0x6e, 0x3d, 0x6e,
 416                 0xf8, 0x26, 0x6f, 0xb8, 0xe0, 0x74, 0x89, 0xc7, 0xd8, 0xf5,
 417                 0x3b, 0x3d, 0x3e, 0x79, 0x86, 0xe8, 0xef, 0x3a, 0x82, 0x2c,
 418                 0x41, 0x6d, 0xa8, 0xb1, 0x70, 0x45, 0x46, 0xea, 0xf8, 0xa4,
 419                 0x5d, 0x70, 0x99, 0x58, 0x78, 0x5b, 0x89, 0x53, 0x2c, 0x3e,
 420                 0xa9, 0x8d, 0xf2, 0xc, 0x51, 0xc3, 0xb, 0x20, 0x21, 0xc4, 0x5c,
 421                 0x43, 0x7b, 0xdc, 0xf0, 0xe2, 0x73, 0xc2, 0x92, 0xdc, 0x4b,
 422                 0x4d, 0x60, 0x2c, 0x28, 0x22, 0x57, 0x7e, 0xb6, 0x92, 0x1,
 423                 0x8c, 0x4d, 0x50, 0x39, 0xbd, 0x4a, 0x3b, 0x2b, 0x89, 0x4,
 424                 0xd5, 0xba, 0x12, 0xcc, 0x3d, 0x0, 0xb6, 0x67, 0xee, 0xcb,
 425                 0x56, 0x75, 0x87, 0x4, 0xa8, 0xc, 0x2f, 0xbf, 0x6d, 0x1e, 0x80,
 426                 0xdd, 0xad, 0x11, 0x7a, 0xa3, 0xed, 0xe, 0x3f, 0xd5, 0xc7,
 427                 0x32, 0x3d, 0x97, 0x37, 0x3d, 0x8, 0x2, 0xdc, 0x52, 0x7c, 0x5,
 428                 0xed, 0xa6, 0xb6, 0x59, 0x4c, 0xfb, 0xcd, 0x2a, 0x7f, 0x87,
 429                 0x40, 0x69, 0xf, 0xdf, 0x5a, 0xf0, 0xad, 0x3a, 0xb4, 0x39,
 430                 0xa6, 0x77, 0xde, 0xf6, 0x3b, 0x90, 0xbc, 0x2a, 0x3c, 0x63,
 431                 0x45, 0x46, 0x94, 0x57, 0x2b, 0x4b, 0x2b, 0x3f, 0x33, 0x34,
 432                 0xa0, 0xf4, 0xb2, 0x7f, 0xdb, 0x88, 0xd9, 0x56, 0xc, 0xd0,
 433                 0xbd, 0xe7, 0x7f, 0x42, 0xea, 0x6c, 0xa7, 0xcf, 0x70, 0x56,
 434                 0x27, 0x70, 0x23, 0x38, 0xed, 0xf9, 0x67, 0x52, 0x7f, 0x25,
 435                 0x9f, 0x1f, 0x4f, 0xef, 0xd5, 0xa4, 0xb, 0xbe, 0xee, 0x5c,
 436                 0x31, 0x8b, 0x96, 0xff, 0xf0, 0xb4, 0x5b, 0x69, 0xe5, 0x63,
 437                 0x38, 0x8b, 0xe5, 0xb9, 0x44, 0x4e, 0x7b, 0x4c, 0xf0, 0xcc,
 438                 0xb6, 0xc9, 0xb3, 0x40, 0x47, 0x2d, 0xc8, 0x8, 0x7c, 0x42, 0x6,
 439                 0xfd, 0x91, 0x36, 0xd3, 0xc8, 0x59, 0x5, 0x66, 0xf8, 0x4f,
 440                 0x7f, 0x5b, 0x9a, 0xf0, 0x87, 0x62, 0x9, 0x47, 0x80, 0xc7,
 441                 0x9f, 0x62, 0xc7, 0xc1, 0x45, 0x66, 0x4f, 0xf8, 0x47, 0x35,
 442                 0x37, 0x41, 0x2e, 0x5e, 0x54, 0x87, 0xa, 0xf8, 0x59, 0xce,
 443                 0xc9, 0x84, 0x4e, 0xc0, 0x56, 0xa6, 0xf5, 0xe2, 0x95, 0x4d,
 444                 0xcf, 0x59, 0x6b, 0xe6, 0x3c, 0x6c, 0xa7, 0xff, 0xe7, 0x70,
 445                 0x8c, 0x1f, 0xb5, 0xbe, 0xe6, 0x65, 0xd, 0xc3, 0x17, 0x4d,
 446                 0xd8, 0x9d, 0xaf, 0xa3, 0x26, 0x1a, 0x73, 0xc7, 0xc0, 0x90,
 447                 0xa1, 0xe2, 0xd3, 0xe9, 0xa4, 0x2, 0x1f, 0x2c, 0xe6, 0x1f,
 448                 0xaf, 0xc, 0xac, 0x71, 0xd3, 0xe0, 0xc0, 0xb, 0x3f, 0x25, 0x2c,
 449                 0x3e, 0x89, 0xa3, 0x9f, 0xbd, 0x46, 0x35, 0x3b, 0x43, 0x79,
 450                 0x60, 0x17, 0x89, 0xb8, 0xc2, 0x81, 0xd2, 0xfa, 0x88, 0x70,
 451                 0x2, 0x8, 0x5e, 0x87, 0xb5, 0xb9, 0x74, 0xcc, 0x69, 0x46, 0xd0,
 452                 0xe0, 0xa, 0xf9, 0xb7, 0x67, 0xd1, 0x2, 0x3, 0x1, 0x0, 0x1,
 453                 0x30, 0xd, 0x6, 0x9, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0xd, 0x1,
 454                 0x1, 0x5, 0x5, 0x0, 0x3, 0x81, 0x81, 0x0, 0xe2, 0xa7, 0x40,
 455                 0x3b, 0x6a, 0x5, 0x5d, 0xb8, 0xbd, 0x5a, 0xaf, 0x7a, 0xc2,
 456                 0xf9, 0x76, 0x79, 0xb2, 0x16, 0x91, 0x4f, 0x5c, 0x19, 0xf7,
 457                 0x59, 0xd1, 0x5f, 0xc0, 0x3e, 0x83, 0xcc, 0x46, 0xf6, 0xd5,
 458                 0x45, 0x46, 0xe6, 0x4a, 0xe6, 0x26, 0x2b, 0xbe, 0x56, 0x28,
 459                 0xa9, 0x39, 0x12, 0x4f, 0x18, 0xc9, 0x20, 0xa0, 0xbe, 0x81,
 460                 0x8d, 0x4d, 0xb5, 0x5c, 0x8f, 0x79, 0x55, 0x6, 0xee, 0x9f,
 461                 0x93, 0xfc, 0xbe, 0xf8, 0x3c, 0x67, 0xe1, 0x67, 0x16, 0xcb,
 462                 0xd1, 0x15, 0x8d, 0xde, 0xd4, 0x20, 0xb3, 0x1, 0x54, 0x18,
 463                 0x66, 0xc5, 0x24, 0x2f, 0xd, 0x88, 0xef, 0x32, 0x3f, 0x74,
 464                 0xd9, 0x56, 0x74, 0x1f, 0x17, 0xa7, 0xbb, 0xfe, 0xdf, 0xf,
 465                 0x6c, 0x5f, 0x93, 0x77, 0x27, 0xf5, 0xae, 0x27, 0x52, 0x8e,
 466                 0x3b, 0x99, 0xb6, 0xea, 0x44, 0x65, 0x1d, 0xa, 0x3b, 0x13,
 467                 0x34, 0xf7, 0xf7, 0xbe, 0x20,
 468         },
 469 }
 470
 471 var privateKey = &Block{Type: "RSA PRIVATE KEY",
 472         Headers: map[string]string{"DEK-Info": "DES-EDE3-CBC,80C7C7A09690757A", "Proc-Type": "4,ENCRYPTED"},
 473         Bytes: []uint8{0x79, 0xa, 0x79, 0x66, 0x41, 0xfa, 0xb,
 474                 0x21, 0xc1, 0xcf, 0xb0, 0x59, 0x7d, 0x43, 0xf1, 0xc8, 0xb0,
 475                 0x82, 0x99, 0xfb, 0x6c, 0x4, 0x9e, 0xc7, 0x96, 0xa1, 0x9b,
 476                 0xf0, 0xb7, 0x76, 0xd5, 0xc4, 0xb0, 0x9f, 0x35, 0x99, 0xe3,
 477                 0xf4, 0x88, 0x96, 0x1c, 0xab, 0x52, 0xdb, 0x1f, 0xc3, 0xb5,
 478                 0x51, 0xd9, 0x34, 0xf0, 0x3, 0xea, 0x1d, 0xa3, 0xd7, 0xb1,
 479                 0xec, 0x67, 0x71, 0x39, 0x36, 0x87, 0xf2, 0x86, 0x45, 0xba,
 480                 0x62, 0x11, 0xa2, 0x21, 0x23, 0x1e, 0xc9, 0x3c, 0x53, 0xb0,
 481                 0x61, 0x9e, 0xda, 0x7e, 0x7a, 0x49, 0xf, 0x3f, 0xbf, 0x71,
 482                 0xba, 0x79, 0xcd, 0xee, 0x16, 0xfb, 0x86, 0x48, 0x6b, 0xc8,
 483                 0x60, 0xd0, 0x66, 0x0, 0x3b, 0xb3, 0x67, 0x10, 0x1d, 0xe,
 484                 0xf5, 0xbf, 0x78, 0x30, 0x4f, 0x60, 0x40, 0x8, 0x7, 0xed,
 485                 0xdb, 0xa8, 0xc2, 0x8d, 0xb3, 0x35, 0xc2, 0x3, 0x73, 0x6,
 486                 0x72, 0x7c, 0x33, 0x44, 0x73, 0x9f, 0xaf, 0x18, 0x5a, 0xa6,
 487                 0x8f, 0xb5, 0xd0, 0x6e, 0xf2, 0xa6, 0xff, 0xcd, 0x54, 0x79,
 488                 0x24, 0x1d, 0x66, 0x9e, 0xab, 0xd3, 0x49, 0xb1, 0x6c, 0x7c,
 489                 0x5e, 0x72, 0x31, 0xce, 0xa8, 0xd9, 0x64, 0x3d, 0x8c, 0x90,
 490                 0xa5, 0xe8, 0xac, 0xa9, 0x9c, 0xc9, 0x7e, 0x6, 0x92, 0xfe,
 491                 0x76, 0x5b, 0xdd, 0x8d, 0x85, 0x4a, 0xe2, 0x5f, 0x65, 0x62,
 492                 0xc0, 0x75, 0x1e, 0xcd, 0xdd, 0xfb, 0x30, 0xc1, 0x6d, 0x6c,
 493                 0x68, 0xb3, 0xcd, 0x7c, 0xcf, 0x38, 0x52, 0xf3, 0xfc, 0xba,
 494                 0x78, 0x87, 0xe2, 0x48, 0x6d, 0xbb, 0x72, 0xaa, 0xdb, 0x85,
 495                 0x44, 0x5b, 0x9a, 0x8, 0x92, 0x7c, 0x35, 0xe3, 0x9d, 0xc2,
 496                 0xb8, 0x9b, 0xfa, 0x4b, 0x71, 0xe, 0xe6, 0x98, 0x12, 0xfa,
 497                 0x98, 0x53, 0xab, 0xdc, 0xf8, 0xf8, 0x8d, 0xea, 0x73, 0x80,
 498                 0xe8, 0x85, 0x44, 0xbe, 0x8c, 0x28, 0x4f, 0xff, 0x87, 0xad,
 499                 0x9f, 0x66, 0xf2, 0x35, 0x12, 0xb6, 0x2b, 0xf1, 0x5b, 0xa7,
 500                 0x1c, 0x4c, 0xa4, 0x80, 0xa3, 0x61, 0xa, 0x10, 0xef, 0x6f,
 501                 0x54, 0x4e, 0xe8, 0xb1, 0x1f, 0xa8, 0xa0, 0x6e, 0xf8, 0x8b,
 502                 0xf0, 0x4c, 0x1e, 0x9f, 0x6, 0x15, 0xb7, 0x4c, 0x22, 0xcc,
 503                 0x9d, 0x53, 0xd8, 0x56, 0x86, 0x30, 0x3, 0xe7, 0xc7, 0x35,
 504                 0x39, 0x99, 0x66, 0x6f, 0x1, 0x12, 0x89, 0xe5, 0x20, 0xc7,
 505                 0xc8, 0xf8, 0xa9, 0x2d, 0x8d, 0x65, 0x20, 0xe0, 0xe8, 0x9a,
 506                 0xf8, 0xd2, 0x3a, 0xbc, 0xa7, 0xf, 0xa4, 0x5a, 0x31, 0x85,
 507                 0x29, 0xe5, 0x1a, 0x0, 0xad, 0xbd, 0xf1, 0x1a, 0xab, 0x9f,
 508                 0xc7, 0xe2, 0x41, 0xc9, 0xa7, 0xde, 0x5e, 0x3a, 0x99, 0xc5,
 509                 0xb0, 0xbb, 0xe2, 0xc3, 0x6b, 0x1e, 0x1c, 0xd9, 0x33, 0xfc,
 510                 0xbc, 0x49, 0x31, 0x13, 0xf5, 0x5f, 0x8d, 0xbc, 0xf8, 0x3a,
 511                 0x58, 0x5b, 0xf4, 0x3, 0xff, 0x42, 0x54, 0xb4, 0x94, 0xae,
 512                 0xb, 0xfa, 0xbd, 0x15, 0x41, 0xcb, 0xe9, 0x12, 0x37, 0xbb,
 513                 0xf0, 0x2c, 0xae, 0xff, 0x29, 0x9, 0xbe, 0x3e, 0xf, 0xb8,
 514                 0xb5, 0x8d, 0x6f, 0xc0, 0x30, 0x87, 0x49, 0x4e, 0xdc, 0x9c,
 515                 0x38, 0x6b, 0x1b, 0x3f, 0x14, 0x0, 0xef, 0x21, 0xcc, 0x5a,
 516                 0xe8, 0xc7, 0x99, 0xe6, 0xf5, 0x5, 0x38, 0x87, 0x70, 0xbd,
 517                 0xec, 0xdc, 0xaa, 0xc9, 0xbb, 0x5b, 0xc3, 0x56, 0xbb, 0x21,
 518                 0xbf, 0x17, 0xe7, 0xcf, 0xbd, 0x4a, 0x4d, 0xe3, 0x67, 0x64,
 519                 0x7f, 0x14, 0x6c, 0xea, 0x93, 0xe6, 0x2e, 0xdf, 0x3c, 0x6c,
 520                 0x97, 0xb5, 0x8d, 0x57, 0x25, 0xd7, 0x5c, 0x6c, 0x8f, 0xd0,
 521                 0xea, 0xd5, 0xdf, 0xc0, 0x71, 0x6c, 0x65, 0xcd, 0xb4, 0x4f,
 522                 0x34, 0x9d, 0xb1, 0x52, 0xc1, 0xb7, 0x9, 0x2c, 0x51, 0xa7,
 523                 0x29, 0x6c, 0x3a, 0x20, 0x70, 0x45, 0x4c, 0x72, 0xd9, 0xcd,
 524                 0xac, 0x1f, 0x5, 0x22, 0xb0, 0x77, 0xbd, 0x91, 0x2f, 0xf5,
 525                 0xd, 0x19, 0xd5, 0x57, 0x98, 0xee, 0x79, 0x93, 0xa4, 0x5f,
 526                 0xba, 0x6b, 0xec, 0xf6, 0x3f, 0xb6, 0x9c, 0x2f, 0xb8, 0xfa,
 527                 0x3, 0xa3, 0xeb, 0xdf, 0xea, 0xbc, 0x3f, 0xd0, 0x8f, 0x88,
 528                 0xf0, 0xbb, 0xcc, 0x5a, 0x27, 0x57, 0x3b, 0x95, 0x3f, 0x20,
 529                 0x7c, 0x19, 0xc8, 0x46, 0x47, 0x68, 0x72, 0xb7, 0x28, 0x8e,
 530                 0x56, 0x9b, 0x83, 0xf7, 0xe9, 0x3c, 0x85, 0xcb, 0xb0, 0x65,
 531                 0x60, 0x1a, 0x52, 0x85, 0x6d, 0x58, 0x84, 0x39, 0xd9, 0xa2,
 532                 0x92, 0xd2, 0x9d, 0x7d, 0x1b, 0xdf, 0x61, 0x85, 0xbf, 0x88,
 533                 0x54, 0x3, 0x42, 0xe1, 0xa9, 0x24, 0x74, 0x75, 0x78, 0x48,
 534                 0xff, 0x22, 0xec, 0xc5, 0x4d, 0x66, 0x17, 0xd4, 0x9a,
 535         },
 536 }
 537
 538 var privateKey2 = &Block{
 539         Type: "RSA PRIVATE KEY",
 540         Headers: map[string]string{
 541                 "Proc-Type":      "4,ENCRYPTED",
 542                 "DEK-Info":       "AES-128-CBC,BFCD243FEDBB40A4AA6DDAA1335473A4",
 543                 "Content-Domain": "RFC822",
 544         },
 545         Bytes: []uint8{
 546                 0xa8, 0x35, 0xcc, 0x2b, 0xb9, 0xcb, 0x21, 0xab, 0xc0,
 547                 0x9d, 0x76, 0x61, 0x0, 0xf4, 0x81, 0xad, 0x69, 0xd2,
 548                 0xc0, 0x42, 0x41, 0x3b, 0xe4, 0x3c, 0xaf, 0x59, 0x5e,
 549                 0x6d, 0x2a, 0x3c, 0x9c, 0xa1, 0xa4, 0x5e, 0x68, 0x37,
 550                 0xc4, 0x8c, 0x70, 0x1c, 0xa9, 0x18, 0xe6, 0xc2, 0x2b,
 551                 0x8a, 0x91, 0xdc, 0x2d, 0x1f, 0x8, 0x23, 0x39, 0xf1,
 552                 0x4b, 0x8b, 0x1b, 0x2f, 0x46, 0xb, 0xb2, 0x26, 0xba,
 553                 0x4f, 0x40, 0x80, 0x39, 0xc4, 0xb1, 0xcb, 0x3b, 0xb4,
 554                 0x65, 0x3f, 0x1b, 0xb2, 0xf7, 0x8, 0xd2, 0xc6, 0xd5,
 555                 0xa8, 0x9f, 0x23, 0x69, 0xb6, 0x3d, 0xf9, 0xac, 0x1c,
 556                 0xb3, 0x13, 0x87, 0x64, 0x4, 0x37, 0xdb, 0x40, 0xc8,
 557                 0x82, 0xc, 0xd0, 0xf8, 0x21, 0x7c, 0xdc, 0xbd, 0x9, 0x4,
 558                 0x20, 0x16, 0xb0, 0x97, 0xe2, 0x6d, 0x56, 0x1d, 0xe3,
 559                 0xec, 0xf0, 0xfc, 0xe2, 0x56, 0xad, 0xa4, 0x3, 0x70,
 560                 0x6d, 0x63, 0x3c, 0x1, 0xbe, 0x3e, 0x28, 0x38, 0x6f,
 561                 0xc0, 0xe6, 0xfd, 0x85, 0xd1, 0x53, 0xa8, 0x9b, 0xcb,
 562                 0xd4, 0x4, 0xb1, 0x73, 0xb9, 0x73, 0x32, 0xd6, 0x7a,
 563                 0xc6, 0x29, 0x25, 0xa5, 0xda, 0x17, 0x93, 0x7a, 0x10,
 564                 0xe8, 0x41, 0xfb, 0xa5, 0x17, 0x20, 0xf8, 0x4e, 0xe9,
 565                 0xe3, 0x8f, 0x51, 0x20, 0x13, 0xbb, 0xde, 0xb7, 0x93,
 566                 0xae, 0x13, 0x8a, 0xf6, 0x9, 0xf4, 0xa6, 0x41, 0xe0,
 567                 0x2b, 0x51, 0x1a, 0x30, 0x38, 0xd, 0xb1, 0x3b, 0x67,
 568                 0x87, 0x64, 0xf5, 0xca, 0x32, 0x67, 0xd1, 0xc8, 0xa5,
 569                 0x3d, 0x23, 0x72, 0xc4, 0x6, 0xaf, 0x8f, 0x7b, 0x26,
 570                 0xac, 0x3c, 0x75, 0x91, 0xa1, 0x0, 0x13, 0xc6, 0x5c,
 571                 0x49, 0xd5, 0x3c, 0xe7, 0xb2, 0xb2, 0x99, 0xe0, 0xd5,
 572                 0x25, 0xfa, 0xe2, 0x12, 0x80, 0x37, 0x85, 0xcf, 0x92,
 573                 0xca, 0x1b, 0x9f, 0xf3, 0x4e, 0xd8, 0x80, 0xef, 0x3c,
 574                 0xce, 0xcd, 0xf5, 0x90, 0x9e, 0xf9, 0xa7, 0xb2, 0xc,
 575                 0x49, 0x4, 0xf1, 0x9, 0x8f, 0xea, 0x63, 0xd2, 0x70,
 576                 0xbb, 0x86, 0xbf, 0x34, 0xab, 0xb2, 0x3, 0xb1, 0x59,
 577                 0x33, 0x16, 0x17, 0xb0, 0xdb, 0x77, 0x38, 0xf4, 0xb4,
 578                 0x94, 0xb, 0x25, 0x16, 0x7e, 0x22, 0xd4, 0xf9, 0x22,
 579                 0xb9, 0x78, 0xa3, 0x4, 0x84, 0x4, 0xd2, 0xda, 0x84,
 580                 0x2d, 0x63, 0xdd, 0xf8, 0x50, 0x6a, 0xf6, 0xe3, 0xf5,
 581                 0x65, 0x40, 0x7c, 0xa9,
 582         },
 583 }
 584
 585 var pemPrivateKey2 = testingKey(`-----BEGIN RSA TESTING KEY-----
 586 Proc-Type: 4,ENCRYPTED
 587 Content-Domain: RFC822
 588 DEK-Info: AES-128-CBC,BFCD243FEDBB40A4AA6DDAA1335473A4
 589
 590 qDXMK7nLIavAnXZhAPSBrWnSwEJBO+Q8r1lebSo8nKGkXmg3xIxwHKkY5sIripHc
 591 LR8IIznxS4sbL0YLsia6T0CAOcSxyzu0ZT8bsvcI0sbVqJ8jabY9+awcsxOHZAQ3
 592 20DIggzQ+CF83L0JBCAWsJfibVYd4+zw/OJWraQDcG1jPAG+Pig4b8Dm/YXRU6ib
 593 y9QEsXO5czLWesYpJaXaF5N6EOhB+6UXIPhO6eOPUSATu963k64TivYJ9KZB4CtR
 594 GjA4DbE7Z4dk9coyZ9HIpT0jcsQGr497Jqw8dZGhABPGXEnVPOeyspng1SX64hKA
 595 N4XPksobn/NO2IDvPM7N9ZCe+aeyDEkE8QmP6mPScLuGvzSrsgOxWTMWF7Dbdzj0
 596 tJQLJRZ+ItT5Irl4owSEBNLahC1j3fhQavbj9WVAfKk=
 597 -----END RSA TESTING KEY-----
 598 `)
 599
 600 func TestBadEncode(t *testing.T) {
 601         b := &Block{Type: "BAD", Headers: map[string]string{"X:Y": "Z"}}
 602         var buf bytes.Buffer
 603         if err := Encode(&buf, b); err == nil {
 604                 t.Fatalf("Encode did not report invalid header")
 605         }
 606         if buf.Len() != 0 {
 607                 t.Fatalf("Encode wrote data before reporting invalid header")
 608         }
 609         if data := EncodeToMemory(b); data != nil {
 610                 t.Fatalf("EncodeToMemory returned non-nil data")
 611         }
 612 }
 613
 614 func testingKey(s string) string { return strings.ReplaceAll(s, "TESTING KEY", "PRIVATE KEY") }