github.com/maenmax/kairep@v0.0.0-20210218001208-55bf3df36788/src/golang.org/x/crypto/openpgp/packet/symmetric_key_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  	"encoding/hex"
    10  	"io"
    11  	"io/ioutil"
    12  	"testing"
    13  )
    14  
    15  func TestSymmetricKeyEncrypted(t *testing.T) {
    16  	buf := readerFromHex(symmetricallyEncryptedHex)
    17  	packet, err := Read(buf)
    18  	if err != nil {
    19  		t.Errorf("failed to read SymmetricKeyEncrypted: %s", err)
    20  		return
    21  	}
    22  	ske, ok := packet.(*SymmetricKeyEncrypted)
    23  	if !ok {
    24  		t.Error("didn't find SymmetricKeyEncrypted packet")
    25  		return
    26  	}
    27  	key, cipherFunc, err := ske.Decrypt([]byte("password"))
    28  	if err != nil {
    29  		t.Error(err)
    30  		return
    31  	}
    32  
    33  	packet, err = Read(buf)
    34  	if err != nil {
    35  		t.Errorf("failed to read SymmetricallyEncrypted: %s", err)
    36  		return
    37  	}
    38  	se, ok := packet.(*SymmetricallyEncrypted)
    39  	if !ok {
    40  		t.Error("didn't find SymmetricallyEncrypted packet")
    41  		return
    42  	}
    43  	r, err := se.Decrypt(cipherFunc, key)
    44  	if err != nil {
    45  		t.Error(err)
    46  		return
    47  	}
    48  
    49  	contents, err := ioutil.ReadAll(r)
    50  	if err != nil && err != io.EOF {
    51  		t.Error(err)
    52  		return
    53  	}
    54  
    55  	expectedContents, _ := hex.DecodeString(symmetricallyEncryptedContentsHex)
    56  	if !bytes.Equal(expectedContents, contents) {
    57  		t.Errorf("bad contents got:%x want:%x", contents, expectedContents)
    58  	}
    59  }
    60  
    61  const symmetricallyEncryptedHex = "8c0d04030302371a0b38d884f02060c91cf97c9973b8e58e028e9501708ccfe618fb92afef7fa2d80ddadd93cf"
    62  const symmetricallyEncryptedContentsHex = "cb1062004d14c4df636f6e74656e74732e0a"
    63  
    64  func TestSerializeSymmetricKeyEncrypted(t *testing.T) {
    65  	buf := bytes.NewBuffer(nil)
    66  	passphrase := []byte("testing")
    67  	const cipherFunc = CipherAES128
    68  	config := &Config{
    69  		DefaultCipher: cipherFunc,
    70  	}
    71  
    72  	key, err := SerializeSymmetricKeyEncrypted(buf, passphrase, config)
    73  	if err != nil {
    74  		t.Errorf("failed to serialize: %s", err)
    75  		return
    76  	}
    77  
    78  	p, err := Read(buf)
    79  	if err != nil {
    80  		t.Errorf("failed to reparse: %s", err)
    81  		return
    82  	}
    83  	ske, ok := p.(*SymmetricKeyEncrypted)
    84  	if !ok {
    85  		t.Errorf("parsed a different packet type: %#v", p)
    86  		return
    87  	}
    88  
    89  	if ske.CipherFunc != config.DefaultCipher {
    90  		t.Errorf("SKE cipher function is %d (expected %d)", ske.CipherFunc, config.DefaultCipher)
    91  	}
    92  	parsedKey, parsedCipherFunc, err := ske.Decrypt(passphrase)
    93  	if err != nil {
    94  		t.Errorf("failed to decrypt reparsed SKE: %s", err)
    95  		return
    96  	}
    97  	if !bytes.Equal(key, parsedKey) {
    98  		t.Errorf("keys don't match after Decrypt: %x (original) vs %x (parsed)", key, parsedKey)
    99  	}
   100  	if parsedCipherFunc != cipherFunc {
   101  		t.Errorf("cipher function doesn't match after Decrypt: %d (original) vs %d (parsed)", cipherFunc, parsedCipherFunc)
   102  	}
   103  }