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 }