github.com/maenmax/kairep@v0.0.0-20210218001208-55bf3df36788/src/golang.org/x/crypto/openpgp/packet/symmetrically_encrypted_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 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  }