...
Run Format

Source file src/encoding/pem/pem_test.go

Documentation: encoding/pem

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

View as plain text