vendor/golang.org/x/crypto/openpgp/packet/symmetrically_encrypted_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 packet
   6
   7 import (
   8         "bytes"
   9         "crypto/sha1"
  10         "encoding/hex"
  11         "golang.org/x/crypto/openpgp/errors"
  12         "io"
  13         "io/ioutil"
  14         "testing"
  15 )
  16
  17 // TestReader wraps a []byte and returns reads of a specific length.
  18 type testReader struct {
  19         data   []byte
  20         stride int
  21 }
  22
  23 func (t *testReader) Read(buf []byte) (n int, err error) {
  24         n = t.stride
  25         if n > len(t.data) {
  26                 n = len(t.data)
  27         }
  28         if n > len(buf) {
  29                 n = len(buf)
  30         }
  31         copy(buf, t.data)
  32         t.data = t.data[n:]
  33         if len(t.data) == 0 {
  34                 err = io.EOF
  35         }
  36         return
  37 }
  38
  39 func testMDCReader(t *testing.T) {
  40         mdcPlaintext, _ := hex.DecodeString(mdcPlaintextHex)
  41
  42         for stride := 1; stride < len(mdcPlaintext)/2; stride++ {
  43                 r := &testReader{data: mdcPlaintext, stride: stride}
  44                 mdcReader := &seMDCReader{in: r, h: sha1.New()}
  45                 body, err := ioutil.ReadAll(mdcReader)
  46                 if err != nil {
  47                         t.Errorf("stride: %d, error: %s", stride, err)
  48                         continue
  49                 }
  50                 if !bytes.Equal(body, mdcPlaintext[:len(mdcPlaintext)-22]) {
  51                         t.Errorf("stride: %d: bad contents %x", stride, body)
  52                         continue
  53                 }
  54
  55                 err = mdcReader.Close()
  56                 if err != nil {
  57                         t.Errorf("stride: %d, error on Close: %s", stride, err)
  58                 }
  59         }
  60
  61         mdcPlaintext[15] ^= 80
  62
  63         r := &testReader{data: mdcPlaintext, stride: 2}
  64         mdcReader := &seMDCReader{in: r, h: sha1.New()}
  65         _, err := ioutil.ReadAll(mdcReader)
  66         if err != nil {
  67                 t.Errorf("corruption test, error: %s", err)
  68                 return
  69         }
  70         err = mdcReader.Close()
  71         if err == nil {
  72                 t.Error("corruption: no error")
  73         } else if _, ok := err.(*errors.SignatureError); !ok {
  74                 t.Errorf("corruption: expected SignatureError, got: %s", err)
  75         }
  76 }
  77
  78 const mdcPlaintextHex = "a302789c3b2d93c4e0eb9aba22283539b3203335af44a134afb800c849cb4c4de10200aff40b45d31432c80cb384299a0655966d6939dfdeed1dddf980"
  79
  80 func TestSerialize(t *testing.T) {
  81         buf := bytes.NewBuffer(nil)
  82         c := CipherAES128
  83         key := make([]byte, c.KeySize())
  84
  85         w, err := SerializeSymmetricallyEncrypted(buf, c, key, nil)
  86         if err != nil {
  87                 t.Errorf("error from SerializeSymmetricallyEncrypted: %s", err)
  88                 return
  89         }
  90
  91         contents := []byte("hello world\n")
  92
  93         w.Write(contents)
  94         w.Close()
  95
  96         p, err := Read(buf)
  97         if err != nil {
  98                 t.Errorf("error from Read: %s", err)
  99                 return
 100         }
 101
 102         se, ok := p.(*SymmetricallyEncrypted)
 103         if !ok {
 104                 t.Errorf("didn't read a *SymmetricallyEncrypted")
 105                 return
 106         }
 107
 108         r, err := se.Decrypt(c, key)
 109         if err != nil {
 110                 t.Errorf("error from Decrypt: %s", err)
 111                 return
 112         }
 113
 114         contentsCopy := bytes.NewBuffer(nil)
 115         _, err = io.Copy(contentsCopy, r)
 116         if err != nil {
 117                 t.Errorf("error from io.Copy: %s", err)
 118                 return
 119         }
 120         if !bytes.Equal(contentsCopy.Bytes(), contents) {
 121                 t.Errorf("contents not equal got: %x want: %x", contentsCopy.Bytes(), contents)
 122         }
 123 }