github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/crypto/openpgp/write_test.go (about)

     1  // Copyright 2011 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 openpgp
     6  
     7  import (
     8  	"bytes"
     9  	"io"
    10  	"io/ioutil"
    11  	"testing"
    12  	"time"
    13  
    14  	"golang.org/x/crypto/openpgp/packet"
    15  )
    16  
    17  func TestSignDetached(t *testing.T) {
    18  	kring, _ := ReadKeyRing(readerFromHex(testKeys1And2PrivateHex))
    19  	out := bytes.NewBuffer(nil)
    20  	message := bytes.NewBufferString(signedInput)
    21  	err := DetachSign(out, kring[0], message, nil)
    22  	if err != nil {
    23  		t.Error(err)
    24  	}
    25  
    26  	testDetachedSignature(t, kring, out, signedInput, "check", testKey1KeyId)
    27  }
    28  
    29  func TestSignTextDetached(t *testing.T) {
    30  	kring, _ := ReadKeyRing(readerFromHex(testKeys1And2PrivateHex))
    31  	out := bytes.NewBuffer(nil)
    32  	message := bytes.NewBufferString(signedInput)
    33  	err := DetachSignText(out, kring[0], message, nil)
    34  	if err != nil {
    35  		t.Error(err)
    36  	}
    37  
    38  	testDetachedSignature(t, kring, out, signedInput, "check", testKey1KeyId)
    39  }
    40  
    41  func TestSignDetachedDSA(t *testing.T) {
    42  	kring, _ := ReadKeyRing(readerFromHex(dsaTestKeyPrivateHex))
    43  	out := bytes.NewBuffer(nil)
    44  	message := bytes.NewBufferString(signedInput)
    45  	err := DetachSign(out, kring[0], message, nil)
    46  	if err != nil {
    47  		t.Error(err)
    48  	}
    49  
    50  	testDetachedSignature(t, kring, out, signedInput, "check", testKey3KeyId)
    51  }
    52  
    53  func TestNewEntity(t *testing.T) {
    54  	if testing.Short() {
    55  		return
    56  	}
    57  
    58  	// Check bit-length with no config.
    59  	e, err := NewEntity("Test User", "test", "test@example.com", nil)
    60  	if err != nil {
    61  		t.Errorf("failed to create entity: %s", err)
    62  		return
    63  	}
    64  	bl, err := e.PrimaryKey.BitLength()
    65  	if err != nil {
    66  		t.Errorf("failed to find bit length: %s", err)
    67  	}
    68  	if int(bl) != defaultRSAKeyBits {
    69  		t.Errorf("BitLength %v, expected %v", defaultRSAKeyBits)
    70  	}
    71  
    72  	// Check bit-length with a config.
    73  	cfg := &packet.Config{RSABits: 1024}
    74  	e, err = NewEntity("Test User", "test", "test@example.com", cfg)
    75  	if err != nil {
    76  		t.Errorf("failed to create entity: %s", err)
    77  		return
    78  	}
    79  	bl, err = e.PrimaryKey.BitLength()
    80  	if err != nil {
    81  		t.Errorf("failed to find bit length: %s", err)
    82  	}
    83  	if int(bl) != cfg.RSABits {
    84  		t.Errorf("BitLength %v, expected %v", bl, cfg.RSABits)
    85  	}
    86  
    87  	w := bytes.NewBuffer(nil)
    88  	if err := e.SerializePrivate(w, nil); err != nil {
    89  		t.Errorf("failed to serialize entity: %s", err)
    90  		return
    91  	}
    92  	serialized := w.Bytes()
    93  
    94  	el, err := ReadKeyRing(w)
    95  	if err != nil {
    96  		t.Errorf("failed to reparse entity: %s", err)
    97  		return
    98  	}
    99  
   100  	if len(el) != 1 {
   101  		t.Errorf("wrong number of entities found, got %d, want 1", len(el))
   102  	}
   103  
   104  	w = bytes.NewBuffer(nil)
   105  	if err := e.SerializePrivate(w, nil); err != nil {
   106  		t.Errorf("failed to serialize entity second time: %s", err)
   107  		return
   108  	}
   109  
   110  	if !bytes.Equal(w.Bytes(), serialized) {
   111  		t.Errorf("results differed")
   112  	}
   113  }
   114  
   115  func TestSymmetricEncryption(t *testing.T) {
   116  	buf := new(bytes.Buffer)
   117  	plaintext, err := SymmetricallyEncrypt(buf, []byte("testing"), nil, nil)
   118  	if err != nil {
   119  		t.Errorf("error writing headers: %s", err)
   120  		return
   121  	}
   122  	message := []byte("hello world\n")
   123  	_, err = plaintext.Write(message)
   124  	if err != nil {
   125  		t.Errorf("error writing to plaintext writer: %s", err)
   126  	}
   127  	err = plaintext.Close()
   128  	if err != nil {
   129  		t.Errorf("error closing plaintext writer: %s", err)
   130  	}
   131  
   132  	md, err := ReadMessage(buf, nil, func(keys []Key, symmetric bool) ([]byte, error) {
   133  		return []byte("testing"), nil
   134  	}, nil)
   135  	if err != nil {
   136  		t.Errorf("error rereading message: %s", err)
   137  	}
   138  	messageBuf := bytes.NewBuffer(nil)
   139  	_, err = io.Copy(messageBuf, md.UnverifiedBody)
   140  	if err != nil {
   141  		t.Errorf("error rereading message: %s", err)
   142  	}
   143  	if !bytes.Equal(message, messageBuf.Bytes()) {
   144  		t.Errorf("recovered message incorrect got '%s', want '%s'", messageBuf.Bytes(), message)
   145  	}
   146  }
   147  
   148  var testEncryptionTests = []struct {
   149  	keyRingHex string
   150  	isSigned   bool
   151  }{
   152  	{
   153  		testKeys1And2PrivateHex,
   154  		false,
   155  	},
   156  	{
   157  		testKeys1And2PrivateHex,
   158  		true,
   159  	},
   160  	{
   161  		dsaElGamalTestKeysHex,
   162  		false,
   163  	},
   164  	{
   165  		dsaElGamalTestKeysHex,
   166  		true,
   167  	},
   168  }
   169  
   170  func TestEncryption(t *testing.T) {
   171  	for i, test := range testEncryptionTests {
   172  		kring, _ := ReadKeyRing(readerFromHex(test.keyRingHex))
   173  
   174  		passphrase := []byte("passphrase")
   175  		for _, entity := range kring {
   176  			if entity.PrivateKey != nil && entity.PrivateKey.Encrypted {
   177  				err := entity.PrivateKey.Decrypt(passphrase)
   178  				if err != nil {
   179  					t.Errorf("#%d: failed to decrypt key", i)
   180  				}
   181  			}
   182  			for _, subkey := range entity.Subkeys {
   183  				if subkey.PrivateKey != nil && subkey.PrivateKey.Encrypted {
   184  					err := subkey.PrivateKey.Decrypt(passphrase)
   185  					if err != nil {
   186  						t.Errorf("#%d: failed to decrypt subkey", i)
   187  					}
   188  				}
   189  			}
   190  		}
   191  
   192  		var signed *Entity
   193  		if test.isSigned {
   194  			signed = kring[0]
   195  		}
   196  
   197  		buf := new(bytes.Buffer)
   198  		w, err := Encrypt(buf, kring[:1], signed, nil /* no hints */, nil)
   199  		if err != nil {
   200  			t.Errorf("#%d: error in Encrypt: %s", i, err)
   201  			continue
   202  		}
   203  
   204  		const message = "testing"
   205  		_, err = w.Write([]byte(message))
   206  		if err != nil {
   207  			t.Errorf("#%d: error writing plaintext: %s", i, err)
   208  			continue
   209  		}
   210  		err = w.Close()
   211  		if err != nil {
   212  			t.Errorf("#%d: error closing WriteCloser: %s", i, err)
   213  			continue
   214  		}
   215  
   216  		md, err := ReadMessage(buf, kring, nil /* no prompt */, nil)
   217  		if err != nil {
   218  			t.Errorf("#%d: error reading message: %s", i, err)
   219  			continue
   220  		}
   221  
   222  		testTime, _ := time.Parse("2006-01-02", "2013-07-01")
   223  		if test.isSigned {
   224  			signKey, _ := kring[0].signingKey(testTime)
   225  			expectedKeyId := signKey.PublicKey.KeyId
   226  			if md.SignedByKeyId != expectedKeyId {
   227  				t.Errorf("#%d: message signed by wrong key id, got: %d, want: %d", i, *md.SignedBy, expectedKeyId)
   228  			}
   229  			if md.SignedBy == nil {
   230  				t.Errorf("#%d: failed to find the signing Entity", i)
   231  			}
   232  		}
   233  
   234  		plaintext, err := ioutil.ReadAll(md.UnverifiedBody)
   235  		if err != nil {
   236  			t.Errorf("#%d: error reading encrypted contents: %s", i, err)
   237  			continue
   238  		}
   239  
   240  		encryptKey, _ := kring[0].encryptionKey(testTime)
   241  		expectedKeyId := encryptKey.PublicKey.KeyId
   242  		if len(md.EncryptedToKeyIds) != 1 || md.EncryptedToKeyIds[0] != expectedKeyId {
   243  			t.Errorf("#%d: expected message to be encrypted to %v, but got %#v", i, expectedKeyId, md.EncryptedToKeyIds)
   244  		}
   245  
   246  		if string(plaintext) != message {
   247  			t.Errorf("#%d: got: %s, want: %s", i, string(plaintext), message)
   248  		}
   249  
   250  		if test.isSigned {
   251  			if md.SignatureError != nil {
   252  				t.Errorf("#%d: signature error: %s", i, md.SignatureError)
   253  			}
   254  			if md.Signature == nil {
   255  				t.Error("signature missing")
   256  			}
   257  		}
   258  	}
   259  }