vendor/golang.org/x/crypto/openpgp/write_test.go

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