vendor: remove dep and use vndr
Signed-off-by: Antonio Murdaca <runcom@redhat.com>
This commit is contained in:
Antonio Murdaca
parent
16f44674a4
commit
148e72d81e
16131 changed files with 73815 additions and 4235138 deletions
41
vendor/golang.org/x/crypto/openpgp/packet/compressed_test.go
generated
vendored
41
vendor/golang.org/x/crypto/openpgp/packet/compressed_test.go
generated
vendored
|
|
@ -1,41 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestCompressed(t *testing.T) {
|
||||
packet, err := Read(readerFromHex(compressedHex))
|
||||
if err != nil {
|
||||
t.Errorf("failed to read Compressed: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
c, ok := packet.(*Compressed)
|
||||
if !ok {
|
||||
t.Error("didn't find Compressed packet")
|
||||
return
|
||||
}
|
||||
|
||||
contents, err := ioutil.ReadAll(c.Body)
|
||||
if err != nil && err != io.EOF {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
|
||||
expected, _ := hex.DecodeString(compressedExpectedHex)
|
||||
if !bytes.Equal(expected, contents) {
|
||||
t.Errorf("got:%x want:%x", contents, expected)
|
||||
}
|
||||
}
|
||||
|
||||
const compressedHex = "a3013b2d90c4e02b72e25f727e5e496a5e49b11e1700"
|
||||
const compressedExpectedHex = "cb1062004d14c8fe636f6e74656e74732e0a"
|
||||
146
vendor/golang.org/x/crypto/openpgp/packet/encrypted_key_test.go
generated
vendored
146
vendor/golang.org/x/crypto/openpgp/packet/encrypted_key_test.go
generated
vendored
|
|
@ -1,146 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/rsa"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"math/big"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func bigFromBase10(s string) *big.Int {
|
||||
b, ok := new(big.Int).SetString(s, 10)
|
||||
if !ok {
|
||||
panic("bigFromBase10 failed")
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
var encryptedKeyPub = rsa.PublicKey{
|
||||
E: 65537,
|
||||
N: bigFromBase10("115804063926007623305902631768113868327816898845124614648849934718568541074358183759250136204762053879858102352159854352727097033322663029387610959884180306668628526686121021235757016368038585212410610742029286439607686208110250133174279811431933746643015923132833417396844716207301518956640020862630546868823"),
|
||||
}
|
||||
|
||||
var encryptedKeyRSAPriv = &rsa.PrivateKey{
|
||||
PublicKey: encryptedKeyPub,
|
||||
D: bigFromBase10("32355588668219869544751561565313228297765464314098552250409557267371233892496951383426602439009993875125222579159850054973310859166139474359774543943714622292329487391199285040721944491839695981199720170366763547754915493640685849961780092241140181198779299712578774460837139360803883139311171713302987058393"),
|
||||
}
|
||||
|
||||
var encryptedKeyPriv = &PrivateKey{
|
||||
PublicKey: PublicKey{
|
||||
PubKeyAlgo: PubKeyAlgoRSA,
|
||||
},
|
||||
PrivateKey: encryptedKeyRSAPriv,
|
||||
}
|
||||
|
||||
func TestDecryptingEncryptedKey(t *testing.T) {
|
||||
const encryptedKeyHex = "c18c032a67d68660df41c70104005789d0de26b6a50c985a02a13131ca829c413a35d0e6fa8d6842599252162808ac7439c72151c8c6183e76923fe3299301414d0c25a2f06a2257db3839e7df0ec964773f6e4c4ac7ff3b48c444237166dd46ba8ff443a5410dc670cb486672fdbe7c9dfafb75b4fea83af3a204fe2a7dfa86bd20122b4f3d2646cbeecb8f7be8"
|
||||
const expectedKeyHex = "d930363f7e0308c333b9618617ea728963d8df993665ae7be1092d4926fd864b"
|
||||
|
||||
p, err := Read(readerFromHex(encryptedKeyHex))
|
||||
if err != nil {
|
||||
t.Errorf("error from Read: %s", err)
|
||||
return
|
||||
}
|
||||
ek, ok := p.(*EncryptedKey)
|
||||
if !ok {
|
||||
t.Errorf("didn't parse an EncryptedKey, got %#v", p)
|
||||
return
|
||||
}
|
||||
|
||||
if ek.KeyId != 0x2a67d68660df41c7 || ek.Algo != PubKeyAlgoRSA {
|
||||
t.Errorf("unexpected EncryptedKey contents: %#v", ek)
|
||||
return
|
||||
}
|
||||
|
||||
err = ek.Decrypt(encryptedKeyPriv, nil)
|
||||
if err != nil {
|
||||
t.Errorf("error from Decrypt: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
if ek.CipherFunc != CipherAES256 {
|
||||
t.Errorf("unexpected EncryptedKey contents: %#v", ek)
|
||||
return
|
||||
}
|
||||
|
||||
keyHex := fmt.Sprintf("%x", ek.Key)
|
||||
if keyHex != expectedKeyHex {
|
||||
t.Errorf("bad key, got %s want %x", keyHex, expectedKeyHex)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEncryptingEncryptedKey(t *testing.T) {
|
||||
key := []byte{1, 2, 3, 4}
|
||||
const expectedKeyHex = "01020304"
|
||||
const keyId = 42
|
||||
|
||||
pub := &PublicKey{
|
||||
PublicKey: &encryptedKeyPub,
|
||||
KeyId: keyId,
|
||||
PubKeyAlgo: PubKeyAlgoRSAEncryptOnly,
|
||||
}
|
||||
|
||||
buf := new(bytes.Buffer)
|
||||
err := SerializeEncryptedKey(buf, pub, CipherAES128, key, nil)
|
||||
if err != nil {
|
||||
t.Errorf("error writing encrypted key packet: %s", err)
|
||||
}
|
||||
|
||||
p, err := Read(buf)
|
||||
if err != nil {
|
||||
t.Errorf("error from Read: %s", err)
|
||||
return
|
||||
}
|
||||
ek, ok := p.(*EncryptedKey)
|
||||
if !ok {
|
||||
t.Errorf("didn't parse an EncryptedKey, got %#v", p)
|
||||
return
|
||||
}
|
||||
|
||||
if ek.KeyId != keyId || ek.Algo != PubKeyAlgoRSAEncryptOnly {
|
||||
t.Errorf("unexpected EncryptedKey contents: %#v", ek)
|
||||
return
|
||||
}
|
||||
|
||||
err = ek.Decrypt(encryptedKeyPriv, nil)
|
||||
if err != nil {
|
||||
t.Errorf("error from Decrypt: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
if ek.CipherFunc != CipherAES128 {
|
||||
t.Errorf("unexpected EncryptedKey contents: %#v", ek)
|
||||
return
|
||||
}
|
||||
|
||||
keyHex := fmt.Sprintf("%x", ek.Key)
|
||||
if keyHex != expectedKeyHex {
|
||||
t.Errorf("bad key, got %s want %x", keyHex, expectedKeyHex)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSerializingEncryptedKey(t *testing.T) {
|
||||
const encryptedKeyHex = "c18c032a67d68660df41c70104005789d0de26b6a50c985a02a13131ca829c413a35d0e6fa8d6842599252162808ac7439c72151c8c6183e76923fe3299301414d0c25a2f06a2257db3839e7df0ec964773f6e4c4ac7ff3b48c444237166dd46ba8ff443a5410dc670cb486672fdbe7c9dfafb75b4fea83af3a204fe2a7dfa86bd20122b4f3d2646cbeecb8f7be8"
|
||||
|
||||
p, err := Read(readerFromHex(encryptedKeyHex))
|
||||
if err != nil {
|
||||
t.Fatalf("error from Read: %s", err)
|
||||
}
|
||||
ek, ok := p.(*EncryptedKey)
|
||||
if !ok {
|
||||
t.Fatalf("didn't parse an EncryptedKey, got %#v", p)
|
||||
}
|
||||
|
||||
var buf bytes.Buffer
|
||||
ek.Serialize(&buf)
|
||||
|
||||
if bufHex := hex.EncodeToString(buf.Bytes()); bufHex != encryptedKeyHex {
|
||||
t.Fatalf("serialization of encrypted key differed from original. Original was %s, but reserialized as %s", encryptedKeyHex, bufHex)
|
||||
}
|
||||
}
|
||||
46
vendor/golang.org/x/crypto/openpgp/packet/ocfb_test.go
generated
vendored
46
vendor/golang.org/x/crypto/openpgp/packet/ocfb_test.go
generated
vendored
|
|
@ -1,46 +0,0 @@
|
|||
// Copyright 2010 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/aes"
|
||||
"crypto/rand"
|
||||
"testing"
|
||||
)
|
||||
|
||||
var commonKey128 = []byte{0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c}
|
||||
|
||||
func testOCFB(t *testing.T, resync OCFBResyncOption) {
|
||||
block, err := aes.NewCipher(commonKey128)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
|
||||
plaintext := []byte("this is the plaintext, which is long enough to span several blocks.")
|
||||
randData := make([]byte, block.BlockSize())
|
||||
rand.Reader.Read(randData)
|
||||
ocfb, prefix := NewOCFBEncrypter(block, randData, resync)
|
||||
ciphertext := make([]byte, len(plaintext))
|
||||
ocfb.XORKeyStream(ciphertext, plaintext)
|
||||
|
||||
ocfbdec := NewOCFBDecrypter(block, prefix, resync)
|
||||
if ocfbdec == nil {
|
||||
t.Errorf("NewOCFBDecrypter failed (resync: %t)", resync)
|
||||
return
|
||||
}
|
||||
plaintextCopy := make([]byte, len(plaintext))
|
||||
ocfbdec.XORKeyStream(plaintextCopy, ciphertext)
|
||||
|
||||
if !bytes.Equal(plaintextCopy, plaintext) {
|
||||
t.Errorf("got: %x, want: %x (resync: %t)", plaintextCopy, plaintext, resync)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOCFB(t *testing.T) {
|
||||
testOCFB(t, OCFBNoResync)
|
||||
testOCFB(t, OCFBResync)
|
||||
}
|
||||
67
vendor/golang.org/x/crypto/openpgp/packet/opaque_test.go
generated
vendored
67
vendor/golang.org/x/crypto/openpgp/packet/opaque_test.go
generated
vendored
|
|
@ -1,67 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"io"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// Test packet.Read error handling in OpaquePacket.Parse,
|
||||
// which attempts to re-read an OpaquePacket as a supported
|
||||
// Packet type.
|
||||
func TestOpaqueParseReason(t *testing.T) {
|
||||
buf, err := hex.DecodeString(UnsupportedKeyHex)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
or := NewOpaqueReader(bytes.NewBuffer(buf))
|
||||
count := 0
|
||||
badPackets := 0
|
||||
var uid *UserId
|
||||
for {
|
||||
op, err := or.Next()
|
||||
if err == io.EOF {
|
||||
break
|
||||
} else if err != nil {
|
||||
t.Errorf("#%d: opaque read error: %v", count, err)
|
||||
break
|
||||
}
|
||||
// try to parse opaque packet
|
||||
p, err := op.Parse()
|
||||
switch pkt := p.(type) {
|
||||
case *UserId:
|
||||
uid = pkt
|
||||
case *OpaquePacket:
|
||||
// If an OpaquePacket can't re-parse, packet.Read
|
||||
// certainly had its reasons.
|
||||
if pkt.Reason == nil {
|
||||
t.Errorf("#%d: opaque packet, no reason", count)
|
||||
} else {
|
||||
badPackets++
|
||||
}
|
||||
}
|
||||
count++
|
||||
}
|
||||
|
||||
const expectedBad = 3
|
||||
// Test post-conditions, make sure we actually parsed packets as expected.
|
||||
if badPackets != expectedBad {
|
||||
t.Errorf("unexpected # unparseable packets: %d (want %d)", badPackets, expectedBad)
|
||||
}
|
||||
if uid == nil {
|
||||
t.Errorf("failed to find expected UID in unsupported keyring")
|
||||
} else if uid.Id != "Armin M. Warda <warda@nephilim.ruhr.de>" {
|
||||
t.Errorf("unexpected UID: %v", uid.Id)
|
||||
}
|
||||
}
|
||||
|
||||
// This key material has public key and signature packet versions modified to
|
||||
// an unsupported value (1), so that trying to parse the OpaquePacket to
|
||||
// a typed packet will get an error. It also contains a GnuPG trust packet.
|
||||
// (Created with: od -An -t x1 pubring.gpg | xargs | sed 's/ //g')
|
||||
const UnsupportedKeyHex = `988d012e7a18a20000010400d6ac00d92b89c1f4396c243abb9b76d2e9673ad63483291fed88e22b82e255e441c078c6abbbf7d2d195e50b62eeaa915b85b0ec20c225ce2c64c167cacb6e711daf2e45da4a8356a059b8160e3b3628ac0dd8437b31f06d53d6e8ea4214d4a26406a6b63e1001406ef23e0bb3069fac9a99a91f77dfafd5de0f188a5da5e3c9000511b42741726d696e204d2e205761726461203c7761726461406e657068696c696d2e727568722e64653e8900950105102e8936c705d1eb399e58489901013f0e03ff5a0c4f421e34fcfa388129166420c08cd76987bcdec6f01bd0271459a85cc22048820dd4e44ac2c7d23908d540f54facf1b36b0d9c20488781ce9dca856531e76e2e846826e9951338020a03a09b57aa5faa82e9267458bd76105399885ac35af7dc1cbb6aaed7c39e1039f3b5beda2c0e916bd38560509bab81235d1a0ead83b0020000`
|
||||
2
vendor/golang.org/x/crypto/openpgp/packet/packet.go
generated
vendored
2
vendor/golang.org/x/crypto/openpgp/packet/packet.go
generated
vendored
|
|
@ -273,6 +273,8 @@ func consumeAll(r io.Reader) (n int64, err error) {
|
|||
return
|
||||
}
|
||||
}
|
||||
|
||||
panic("unreachable")
|
||||
}
|
||||
|
||||
// packetType represents the numeric ids of the different OpenPGP packet types. See
|
||||
|
|
|
|||
255
vendor/golang.org/x/crypto/openpgp/packet/packet_test.go
generated
vendored
255
vendor/golang.org/x/crypto/openpgp/packet/packet_test.go
generated
vendored
|
|
@ -1,255 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"golang.org/x/crypto/openpgp/errors"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestReadFull(t *testing.T) {
|
||||
var out [4]byte
|
||||
|
||||
b := bytes.NewBufferString("foo")
|
||||
n, err := readFull(b, out[:3])
|
||||
if n != 3 || err != nil {
|
||||
t.Errorf("full read failed n:%d err:%s", n, err)
|
||||
}
|
||||
|
||||
b = bytes.NewBufferString("foo")
|
||||
n, err = readFull(b, out[:4])
|
||||
if n != 3 || err != io.ErrUnexpectedEOF {
|
||||
t.Errorf("partial read failed n:%d err:%s", n, err)
|
||||
}
|
||||
|
||||
b = bytes.NewBuffer(nil)
|
||||
n, err = readFull(b, out[:3])
|
||||
if n != 0 || err != io.ErrUnexpectedEOF {
|
||||
t.Errorf("empty read failed n:%d err:%s", n, err)
|
||||
}
|
||||
}
|
||||
|
||||
func readerFromHex(s string) io.Reader {
|
||||
data, err := hex.DecodeString(s)
|
||||
if err != nil {
|
||||
panic("readerFromHex: bad input")
|
||||
}
|
||||
return bytes.NewBuffer(data)
|
||||
}
|
||||
|
||||
var readLengthTests = []struct {
|
||||
hexInput string
|
||||
length int64
|
||||
isPartial bool
|
||||
err error
|
||||
}{
|
||||
{"", 0, false, io.ErrUnexpectedEOF},
|
||||
{"1f", 31, false, nil},
|
||||
{"c0", 0, false, io.ErrUnexpectedEOF},
|
||||
{"c101", 256 + 1 + 192, false, nil},
|
||||
{"e0", 1, true, nil},
|
||||
{"e1", 2, true, nil},
|
||||
{"e2", 4, true, nil},
|
||||
{"ff", 0, false, io.ErrUnexpectedEOF},
|
||||
{"ff00", 0, false, io.ErrUnexpectedEOF},
|
||||
{"ff0000", 0, false, io.ErrUnexpectedEOF},
|
||||
{"ff000000", 0, false, io.ErrUnexpectedEOF},
|
||||
{"ff00000000", 0, false, nil},
|
||||
{"ff01020304", 16909060, false, nil},
|
||||
}
|
||||
|
||||
func TestReadLength(t *testing.T) {
|
||||
for i, test := range readLengthTests {
|
||||
length, isPartial, err := readLength(readerFromHex(test.hexInput))
|
||||
if test.err != nil {
|
||||
if err != test.err {
|
||||
t.Errorf("%d: expected different error got:%s want:%s", i, err, test.err)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
t.Errorf("%d: unexpected error: %s", i, err)
|
||||
continue
|
||||
}
|
||||
if length != test.length || isPartial != test.isPartial {
|
||||
t.Errorf("%d: bad result got:(%d,%t) want:(%d,%t)", i, length, isPartial, test.length, test.isPartial)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var partialLengthReaderTests = []struct {
|
||||
hexInput string
|
||||
err error
|
||||
hexOutput string
|
||||
}{
|
||||
{"e0", io.ErrUnexpectedEOF, ""},
|
||||
{"e001", io.ErrUnexpectedEOF, ""},
|
||||
{"e0010102", nil, "0102"},
|
||||
{"ff00000000", nil, ""},
|
||||
{"e10102e1030400", nil, "01020304"},
|
||||
{"e101", io.ErrUnexpectedEOF, ""},
|
||||
}
|
||||
|
||||
func TestPartialLengthReader(t *testing.T) {
|
||||
for i, test := range partialLengthReaderTests {
|
||||
r := &partialLengthReader{readerFromHex(test.hexInput), 0, true}
|
||||
out, err := ioutil.ReadAll(r)
|
||||
if test.err != nil {
|
||||
if err != test.err {
|
||||
t.Errorf("%d: expected different error got:%s want:%s", i, err, test.err)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
t.Errorf("%d: unexpected error: %s", i, err)
|
||||
continue
|
||||
}
|
||||
|
||||
got := fmt.Sprintf("%x", out)
|
||||
if got != test.hexOutput {
|
||||
t.Errorf("%d: got:%s want:%s", i, test.hexOutput, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var readHeaderTests = []struct {
|
||||
hexInput string
|
||||
structuralError bool
|
||||
unexpectedEOF bool
|
||||
tag int
|
||||
length int64
|
||||
hexOutput string
|
||||
}{
|
||||
{"", false, false, 0, 0, ""},
|
||||
{"7f", true, false, 0, 0, ""},
|
||||
|
||||
// Old format headers
|
||||
{"80", false, true, 0, 0, ""},
|
||||
{"8001", false, true, 0, 1, ""},
|
||||
{"800102", false, false, 0, 1, "02"},
|
||||
{"81000102", false, false, 0, 1, "02"},
|
||||
{"820000000102", false, false, 0, 1, "02"},
|
||||
{"860000000102", false, false, 1, 1, "02"},
|
||||
{"83010203", false, false, 0, -1, "010203"},
|
||||
|
||||
// New format headers
|
||||
{"c0", false, true, 0, 0, ""},
|
||||
{"c000", false, false, 0, 0, ""},
|
||||
{"c00102", false, false, 0, 1, "02"},
|
||||
{"c0020203", false, false, 0, 2, "0203"},
|
||||
{"c00202", false, true, 0, 2, ""},
|
||||
{"c3020203", false, false, 3, 2, "0203"},
|
||||
}
|
||||
|
||||
func TestReadHeader(t *testing.T) {
|
||||
for i, test := range readHeaderTests {
|
||||
tag, length, contents, err := readHeader(readerFromHex(test.hexInput))
|
||||
if test.structuralError {
|
||||
if _, ok := err.(errors.StructuralError); ok {
|
||||
continue
|
||||
}
|
||||
t.Errorf("%d: expected StructuralError, got:%s", i, err)
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
if len(test.hexInput) == 0 && err == io.EOF {
|
||||
continue
|
||||
}
|
||||
if !test.unexpectedEOF || err != io.ErrUnexpectedEOF {
|
||||
t.Errorf("%d: unexpected error from readHeader: %s", i, err)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if int(tag) != test.tag || length != test.length {
|
||||
t.Errorf("%d: got:(%d,%d) want:(%d,%d)", i, int(tag), length, test.tag, test.length)
|
||||
continue
|
||||
}
|
||||
|
||||
body, err := ioutil.ReadAll(contents)
|
||||
if err != nil {
|
||||
if !test.unexpectedEOF || err != io.ErrUnexpectedEOF {
|
||||
t.Errorf("%d: unexpected error from contents: %s", i, err)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if test.unexpectedEOF {
|
||||
t.Errorf("%d: expected ErrUnexpectedEOF from contents but got no error", i)
|
||||
continue
|
||||
}
|
||||
got := fmt.Sprintf("%x", body)
|
||||
if got != test.hexOutput {
|
||||
t.Errorf("%d: got:%s want:%s", i, got, test.hexOutput)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSerializeHeader(t *testing.T) {
|
||||
tag := packetTypePublicKey
|
||||
lengths := []int{0, 1, 2, 64, 192, 193, 8000, 8384, 8385, 10000}
|
||||
|
||||
for _, length := range lengths {
|
||||
buf := bytes.NewBuffer(nil)
|
||||
serializeHeader(buf, tag, length)
|
||||
tag2, length2, _, err := readHeader(buf)
|
||||
if err != nil {
|
||||
t.Errorf("length %d, err: %s", length, err)
|
||||
}
|
||||
if tag2 != tag {
|
||||
t.Errorf("length %d, tag incorrect (got %d, want %d)", length, tag2, tag)
|
||||
}
|
||||
if int(length2) != length {
|
||||
t.Errorf("length %d, length incorrect (got %d)", length, length2)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPartialLengths(t *testing.T) {
|
||||
buf := bytes.NewBuffer(nil)
|
||||
w := new(partialLengthWriter)
|
||||
w.w = noOpCloser{buf}
|
||||
|
||||
const maxChunkSize = 64
|
||||
|
||||
var b [maxChunkSize]byte
|
||||
var n uint8
|
||||
for l := 1; l <= maxChunkSize; l++ {
|
||||
for i := 0; i < l; i++ {
|
||||
b[i] = n
|
||||
n++
|
||||
}
|
||||
m, err := w.Write(b[:l])
|
||||
if m != l {
|
||||
t.Errorf("short write got: %d want: %d", m, l)
|
||||
}
|
||||
if err != nil {
|
||||
t.Errorf("error from write: %s", err)
|
||||
}
|
||||
}
|
||||
w.Close()
|
||||
|
||||
want := (maxChunkSize * (maxChunkSize + 1)) / 2
|
||||
copyBuf := bytes.NewBuffer(nil)
|
||||
r := &partialLengthReader{buf, 0, true}
|
||||
m, err := io.Copy(copyBuf, r)
|
||||
if m != int64(want) {
|
||||
t.Errorf("short copy got: %d want: %d", m, want)
|
||||
}
|
||||
if err != nil {
|
||||
t.Errorf("error from copy: %s", err)
|
||||
}
|
||||
|
||||
copyBytes := copyBuf.Bytes()
|
||||
for i := 0; i < want; i++ {
|
||||
if copyBytes[i] != uint8(i) {
|
||||
t.Errorf("bad pattern in copy at %d", i)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
20
vendor/golang.org/x/crypto/openpgp/packet/private_key.go
generated
vendored
20
vendor/golang.org/x/crypto/openpgp/packet/private_key.go
generated
vendored
|
|
@ -6,7 +6,6 @@ package packet
|
|||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto"
|
||||
"crypto/cipher"
|
||||
"crypto/dsa"
|
||||
"crypto/ecdsa"
|
||||
|
|
@ -31,7 +30,7 @@ type PrivateKey struct {
|
|||
encryptedData []byte
|
||||
cipher CipherFunction
|
||||
s2k func(out, in []byte)
|
||||
PrivateKey interface{} // An *{rsa|dsa|ecdsa}.PrivateKey or a crypto.Signer.
|
||||
PrivateKey interface{} // An *rsa.PrivateKey or *dsa.PrivateKey.
|
||||
sha1Checksum bool
|
||||
iv []byte
|
||||
}
|
||||
|
|
@ -64,23 +63,6 @@ func NewECDSAPrivateKey(currentTime time.Time, priv *ecdsa.PrivateKey) *PrivateK
|
|||
return pk
|
||||
}
|
||||
|
||||
// NewSignerPrivateKey creates a sign-only PrivateKey from a crypto.Signer that
|
||||
// implements RSA or ECDSA.
|
||||
func NewSignerPrivateKey(currentTime time.Time, signer crypto.Signer) *PrivateKey {
|
||||
pk := new(PrivateKey)
|
||||
switch pubkey := signer.Public().(type) {
|
||||
case rsa.PublicKey:
|
||||
pk.PublicKey = *NewRSAPublicKey(currentTime, &pubkey)
|
||||
pk.PubKeyAlgo = PubKeyAlgoRSASignOnly
|
||||
case ecdsa.PublicKey:
|
||||
pk.PublicKey = *NewECDSAPublicKey(currentTime, &pubkey)
|
||||
default:
|
||||
panic("openpgp: unknown crypto.Signer type in NewSignerPrivateKey")
|
||||
}
|
||||
pk.PrivateKey = signer
|
||||
return pk
|
||||
}
|
||||
|
||||
func (pk *PrivateKey) parse(r io.Reader) (err error) {
|
||||
err = (&pk.PublicKey).parse(r)
|
||||
if err != nil {
|
||||
|
|
|
|||
270
vendor/golang.org/x/crypto/openpgp/packet/private_key_test.go
generated
vendored
270
vendor/golang.org/x/crypto/openpgp/packet/private_key_test.go
generated
vendored
|
|
@ -1,270 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto"
|
||||
"crypto/ecdsa"
|
||||
"crypto/elliptic"
|
||||
"crypto/rand"
|
||||
"crypto/rsa"
|
||||
"crypto/x509"
|
||||
"encoding/hex"
|
||||
"hash"
|
||||
"io"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
var privateKeyTests = []struct {
|
||||
privateKeyHex string
|
||||
creationTime time.Time
|
||||
}{
|
||||
{
|
||||
privKeyRSAHex,
|
||||
time.Unix(0x4cc349a8, 0),
|
||||
},
|
||||
{
|
||||
privKeyElGamalHex,
|
||||
time.Unix(0x4df9ee1a, 0),
|
||||
},
|
||||
}
|
||||
|
||||
func TestPrivateKeyRead(t *testing.T) {
|
||||
for i, test := range privateKeyTests {
|
||||
packet, err := Read(readerFromHex(test.privateKeyHex))
|
||||
if err != nil {
|
||||
t.Errorf("#%d: failed to parse: %s", i, err)
|
||||
continue
|
||||
}
|
||||
|
||||
privKey := packet.(*PrivateKey)
|
||||
|
||||
if !privKey.Encrypted {
|
||||
t.Errorf("#%d: private key isn't encrypted", i)
|
||||
continue
|
||||
}
|
||||
|
||||
err = privKey.Decrypt([]byte("wrong password"))
|
||||
if err == nil {
|
||||
t.Errorf("#%d: decrypted with incorrect key", i)
|
||||
continue
|
||||
}
|
||||
|
||||
err = privKey.Decrypt([]byte("testing"))
|
||||
if err != nil {
|
||||
t.Errorf("#%d: failed to decrypt: %s", i, err)
|
||||
continue
|
||||
}
|
||||
|
||||
if !privKey.CreationTime.Equal(test.creationTime) || privKey.Encrypted {
|
||||
t.Errorf("#%d: bad result, got: %#v", i, privKey)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func populateHash(hashFunc crypto.Hash, msg []byte) (hash.Hash, error) {
|
||||
h := hashFunc.New()
|
||||
if _, err := h.Write(msg); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return h, nil
|
||||
}
|
||||
|
||||
func TestRSAPrivateKey(t *testing.T) {
|
||||
privKeyDER, _ := hex.DecodeString(pkcs1PrivKeyHex)
|
||||
rsaPriv, err := x509.ParsePKCS1PrivateKey(privKeyDER)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var buf bytes.Buffer
|
||||
if err := NewRSAPrivateKey(time.Now(), rsaPriv).Serialize(&buf); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
p, err := Read(&buf)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
priv, ok := p.(*PrivateKey)
|
||||
if !ok {
|
||||
t.Fatal("didn't parse private key")
|
||||
}
|
||||
|
||||
sig := &Signature{
|
||||
PubKeyAlgo: PubKeyAlgoRSA,
|
||||
Hash: crypto.SHA256,
|
||||
}
|
||||
msg := []byte("Hello World!")
|
||||
|
||||
h, err := populateHash(sig.Hash, msg)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := sig.Sign(h, priv, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if h, err = populateHash(sig.Hash, msg); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := priv.VerifySignature(h, sig); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestECDSAPrivateKey(t *testing.T) {
|
||||
ecdsaPriv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var buf bytes.Buffer
|
||||
if err := NewECDSAPrivateKey(time.Now(), ecdsaPriv).Serialize(&buf); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
p, err := Read(&buf)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
priv, ok := p.(*PrivateKey)
|
||||
if !ok {
|
||||
t.Fatal("didn't parse private key")
|
||||
}
|
||||
|
||||
sig := &Signature{
|
||||
PubKeyAlgo: PubKeyAlgoECDSA,
|
||||
Hash: crypto.SHA256,
|
||||
}
|
||||
msg := []byte("Hello World!")
|
||||
|
||||
h, err := populateHash(sig.Hash, msg)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := sig.Sign(h, priv, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if h, err = populateHash(sig.Hash, msg); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := priv.VerifySignature(h, sig); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
type rsaSigner struct {
|
||||
priv *rsa.PrivateKey
|
||||
}
|
||||
|
||||
func (s *rsaSigner) Public() crypto.PublicKey {
|
||||
return s.priv.PublicKey
|
||||
}
|
||||
|
||||
func (s *rsaSigner) Sign(rand io.Reader, msg []byte, opts crypto.SignerOpts) ([]byte, error) {
|
||||
return s.priv.Sign(rand, msg, opts)
|
||||
}
|
||||
|
||||
func TestRSASignerPrivateKey(t *testing.T) {
|
||||
rsaPriv, err := rsa.GenerateKey(rand.Reader, 1024)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
priv := NewSignerPrivateKey(time.Now(), &rsaSigner{rsaPriv})
|
||||
|
||||
if priv.PubKeyAlgo != PubKeyAlgoRSASignOnly {
|
||||
t.Fatal("NewSignerPrivateKey should have made a sign-only RSA private key")
|
||||
}
|
||||
|
||||
sig := &Signature{
|
||||
PubKeyAlgo: PubKeyAlgoRSASignOnly,
|
||||
Hash: crypto.SHA256,
|
||||
}
|
||||
msg := []byte("Hello World!")
|
||||
|
||||
h, err := populateHash(sig.Hash, msg)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := sig.Sign(h, priv, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if h, err = populateHash(sig.Hash, msg); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := priv.VerifySignature(h, sig); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
type ecdsaSigner struct {
|
||||
priv *ecdsa.PrivateKey
|
||||
}
|
||||
|
||||
func (s *ecdsaSigner) Public() crypto.PublicKey {
|
||||
return s.priv.PublicKey
|
||||
}
|
||||
|
||||
func (s *ecdsaSigner) Sign(rand io.Reader, msg []byte, opts crypto.SignerOpts) ([]byte, error) {
|
||||
return s.priv.Sign(rand, msg, opts)
|
||||
}
|
||||
|
||||
func TestECDSASignerPrivateKey(t *testing.T) {
|
||||
ecdsaPriv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
priv := NewSignerPrivateKey(time.Now(), &ecdsaSigner{ecdsaPriv})
|
||||
|
||||
if priv.PubKeyAlgo != PubKeyAlgoECDSA {
|
||||
t.Fatal("NewSignerPrivateKey should have made a ECSDA private key")
|
||||
}
|
||||
|
||||
sig := &Signature{
|
||||
PubKeyAlgo: PubKeyAlgoECDSA,
|
||||
Hash: crypto.SHA256,
|
||||
}
|
||||
msg := []byte("Hello World!")
|
||||
|
||||
h, err := populateHash(sig.Hash, msg)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := sig.Sign(h, priv, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if h, err = populateHash(sig.Hash, msg); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := priv.VerifySignature(h, sig); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIssue11505(t *testing.T) {
|
||||
// parsing a rsa private key with p or q == 1 used to panic due to a divide by zero
|
||||
_, _ = Read(readerFromHex("9c3004303030300100000011303030000000000000010130303030303030303030303030303030303030303030303030303030303030303030303030303030303030"))
|
||||
}
|
||||
|
||||
// Generated with `gpg --export-secret-keys "Test Key 2"`
|
||||
const privKeyRSAHex = "9501fe044cc349a8010400b70ca0010e98c090008d45d1ee8f9113bd5861fd57b88bacb7c68658747663f1e1a3b5a98f32fda6472373c024b97359cd2efc88ff60f77751adfbf6af5e615e6a1408cfad8bf0cea30b0d5f53aa27ad59089ba9b15b7ebc2777a25d7b436144027e3bcd203909f147d0e332b240cf63d3395f5dfe0df0a6c04e8655af7eacdf0011010001fe0303024a252e7d475fd445607de39a265472aa74a9320ba2dac395faa687e9e0336aeb7e9a7397e511b5afd9dc84557c80ac0f3d4d7bfec5ae16f20d41c8c84a04552a33870b930420e230e179564f6d19bb153145e76c33ae993886c388832b0fa042ddda7f133924f3854481533e0ede31d51278c0519b29abc3bf53da673e13e3e1214b52413d179d7f66deee35cac8eacb060f78379d70ef4af8607e68131ff529439668fc39c9ce6dfef8a5ac234d234802cbfb749a26107db26406213ae5c06d4673253a3cbee1fcbae58d6ab77e38d6e2c0e7c6317c48e054edadb5a40d0d48acb44643d998139a8a66bb820be1f3f80185bc777d14b5954b60effe2448a036d565c6bc0b915fcea518acdd20ab07bc1529f561c58cd044f723109b93f6fd99f876ff891d64306b5d08f48bab59f38695e9109c4dec34013ba3153488ce070268381ba923ee1eb77125b36afcb4347ec3478c8f2735b06ef17351d872e577fa95d0c397c88c71b59629a36aec"
|
||||
|
||||
// Generated by `gpg --export-secret-keys` followed by a manual extraction of
|
||||
// the ElGamal subkey from the packets.
|
||||
const privKeyElGamalHex = "9d0157044df9ee1a100400eb8e136a58ec39b582629cdadf830bc64e0a94ed8103ca8bb247b27b11b46d1d25297ef4bcc3071785ba0c0bedfe89eabc5287fcc0edf81ab5896c1c8e4b20d27d79813c7aede75320b33eaeeaa586edc00fd1036c10133e6ba0ff277245d0d59d04b2b3421b7244aca5f4a8d870c6f1c1fbff9e1c26699a860b9504f35ca1d700030503fd1ededd3b840795be6d9ccbe3c51ee42e2f39233c432b831ddd9c4e72b7025a819317e47bf94f9ee316d7273b05d5fcf2999c3a681f519b1234bbfa6d359b4752bd9c3f77d6b6456cde152464763414ca130f4e91d91041432f90620fec0e6d6b5116076c2985d5aeaae13be492b9b329efcaf7ee25120159a0a30cd976b42d7afe030302dae7eb80db744d4960c4df930d57e87fe81412eaace9f900e6c839817a614ddb75ba6603b9417c33ea7b6c93967dfa2bcff3fa3c74a5ce2c962db65b03aece14c96cbd0038fc"
|
||||
|
||||
// pkcs1PrivKeyHex is a PKCS#1, RSA private key.
|
||||
// Generated by `openssl genrsa 1024 | openssl rsa -outform DER | xxd -p`
|
||||
const pkcs1PrivKeyHex = "3082025d02010002818100e98edfa1c3b35884a54d0b36a6a603b0290fa85e49e30fa23fc94fef9c6790bc4849928607aa48d809da326fb42a969d06ad756b98b9c1a90f5d4a2b6d0ac05953c97f4da3120164a21a679793ce181c906dc01d235cc085ddcdf6ea06c389b6ab8885dfd685959e693138856a68a7e5db263337ff82a088d583a897cf2d59e9020301000102818100b6d5c9eb70b02d5369b3ee5b520a14490b5bde8a317d36f7e4c74b7460141311d1e5067735f8f01d6f5908b2b96fbd881f7a1ab9a84d82753e39e19e2d36856be960d05ac9ef8e8782ea1b6d65aee28fdfe1d61451e8cff0adfe84322f12cf455028b581cf60eb9e0e140ba5d21aeba6c2634d7c65318b9a665fc01c3191ca21024100fa5e818da3705b0fa33278bb28d4b6f6050388af2d4b75ec9375dd91ccf2e7d7068086a8b82a8f6282e4fbbdb8a7f2622eb97295249d87acea7f5f816f54d347024100eecf9406d7dc49cdfb95ab1eff4064de84c7a30f64b2798936a0d2018ba9eb52e4b636f82e96c49cc63b80b675e91e40d1b2e4017d4b9adaf33ab3d9cf1c214f024100c173704ace742c082323066226a4655226819a85304c542b9dacbeacbf5d1881ee863485fcf6f59f3a604f9b42289282067447f2b13dfeed3eab7851fc81e0550240741fc41f3fc002b382eed8730e33c5d8de40256e4accee846667f536832f711ab1d4590e7db91a8a116ac5bff3be13d3f9243ff2e976662aa9b395d907f8e9c9024046a5696c9ef882363e06c9fa4e2f5b580906452befba03f4a99d0f873697ef1f851d2226ca7934b30b7c3e80cb634a67172bbbf4781735fe3e09263e2dd723e7"
|
||||
2
vendor/golang.org/x/crypto/openpgp/packet/public_key.go
generated
vendored
2
vendor/golang.org/x/crypto/openpgp/packet/public_key.go
generated
vendored
|
|
@ -540,6 +540,7 @@ func (pk *PublicKey) VerifySignature(signed hash.Hash, sig *Signature) (err erro
|
|||
default:
|
||||
return errors.SignatureError("Unsupported public key algorithm used in signature")
|
||||
}
|
||||
panic("unreachable")
|
||||
}
|
||||
|
||||
// VerifySignatureV3 returns nil iff sig is a valid signature, made by this
|
||||
|
|
@ -584,6 +585,7 @@ func (pk *PublicKey) VerifySignatureV3(signed hash.Hash, sig *SignatureV3) (err
|
|||
default:
|
||||
panic("shouldn't happen")
|
||||
}
|
||||
panic("unreachable")
|
||||
}
|
||||
|
||||
// keySignatureHash returns a Hash of the message that needs to be signed for
|
||||
|
|
|
|||
202
vendor/golang.org/x/crypto/openpgp/packet/public_key_test.go
generated
vendored
202
vendor/golang.org/x/crypto/openpgp/packet/public_key_test.go
generated
vendored
|
|
@ -1,202 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
var pubKeyTests = []struct {
|
||||
hexData string
|
||||
hexFingerprint string
|
||||
creationTime time.Time
|
||||
pubKeyAlgo PublicKeyAlgorithm
|
||||
keyId uint64
|
||||
keyIdString string
|
||||
keyIdShort string
|
||||
}{
|
||||
{rsaPkDataHex, rsaFingerprintHex, time.Unix(0x4d3c5c10, 0), PubKeyAlgoRSA, 0xa34d7e18c20c31bb, "A34D7E18C20C31BB", "C20C31BB"},
|
||||
{dsaPkDataHex, dsaFingerprintHex, time.Unix(0x4d432f89, 0), PubKeyAlgoDSA, 0x8e8fbe54062f19ed, "8E8FBE54062F19ED", "062F19ED"},
|
||||
{ecdsaPkDataHex, ecdsaFingerprintHex, time.Unix(0x5071c294, 0), PubKeyAlgoECDSA, 0x43fe956c542ca00b, "43FE956C542CA00B", "542CA00B"},
|
||||
}
|
||||
|
||||
func TestPublicKeyRead(t *testing.T) {
|
||||
for i, test := range pubKeyTests {
|
||||
packet, err := Read(readerFromHex(test.hexData))
|
||||
if err != nil {
|
||||
t.Errorf("#%d: Read error: %s", i, err)
|
||||
continue
|
||||
}
|
||||
pk, ok := packet.(*PublicKey)
|
||||
if !ok {
|
||||
t.Errorf("#%d: failed to parse, got: %#v", i, packet)
|
||||
continue
|
||||
}
|
||||
if pk.PubKeyAlgo != test.pubKeyAlgo {
|
||||
t.Errorf("#%d: bad public key algorithm got:%x want:%x", i, pk.PubKeyAlgo, test.pubKeyAlgo)
|
||||
}
|
||||
if !pk.CreationTime.Equal(test.creationTime) {
|
||||
t.Errorf("#%d: bad creation time got:%v want:%v", i, pk.CreationTime, test.creationTime)
|
||||
}
|
||||
expectedFingerprint, _ := hex.DecodeString(test.hexFingerprint)
|
||||
if !bytes.Equal(expectedFingerprint, pk.Fingerprint[:]) {
|
||||
t.Errorf("#%d: bad fingerprint got:%x want:%x", i, pk.Fingerprint[:], expectedFingerprint)
|
||||
}
|
||||
if pk.KeyId != test.keyId {
|
||||
t.Errorf("#%d: bad keyid got:%x want:%x", i, pk.KeyId, test.keyId)
|
||||
}
|
||||
if g, e := pk.KeyIdString(), test.keyIdString; g != e {
|
||||
t.Errorf("#%d: bad KeyIdString got:%q want:%q", i, g, e)
|
||||
}
|
||||
if g, e := pk.KeyIdShortString(), test.keyIdShort; g != e {
|
||||
t.Errorf("#%d: bad KeyIdShortString got:%q want:%q", i, g, e)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPublicKeySerialize(t *testing.T) {
|
||||
for i, test := range pubKeyTests {
|
||||
packet, err := Read(readerFromHex(test.hexData))
|
||||
if err != nil {
|
||||
t.Errorf("#%d: Read error: %s", i, err)
|
||||
continue
|
||||
}
|
||||
pk, ok := packet.(*PublicKey)
|
||||
if !ok {
|
||||
t.Errorf("#%d: failed to parse, got: %#v", i, packet)
|
||||
continue
|
||||
}
|
||||
serializeBuf := bytes.NewBuffer(nil)
|
||||
err = pk.Serialize(serializeBuf)
|
||||
if err != nil {
|
||||
t.Errorf("#%d: failed to serialize: %s", i, err)
|
||||
continue
|
||||
}
|
||||
|
||||
packet, err = Read(serializeBuf)
|
||||
if err != nil {
|
||||
t.Errorf("#%d: Read error (from serialized data): %s", i, err)
|
||||
continue
|
||||
}
|
||||
pk, ok = packet.(*PublicKey)
|
||||
if !ok {
|
||||
t.Errorf("#%d: failed to parse serialized data, got: %#v", i, packet)
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestEcc384Serialize(t *testing.T) {
|
||||
r := readerFromHex(ecc384PubHex)
|
||||
var w bytes.Buffer
|
||||
for i := 0; i < 2; i++ {
|
||||
// Public key
|
||||
p, err := Read(r)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
pubkey := p.(*PublicKey)
|
||||
if !bytes.Equal(pubkey.ec.oid, []byte{0x2b, 0x81, 0x04, 0x00, 0x22}) {
|
||||
t.Errorf("Unexpected pubkey OID: %x", pubkey.ec.oid)
|
||||
}
|
||||
if !bytes.Equal(pubkey.ec.p.bytes[:5], []byte{0x04, 0xf6, 0xb8, 0xc5, 0xac}) {
|
||||
t.Errorf("Unexpected pubkey P[:5]: %x", pubkey.ec.p.bytes)
|
||||
}
|
||||
if pubkey.KeyId != 0x098033880F54719F {
|
||||
t.Errorf("Unexpected pubkey ID: %x", pubkey.KeyId)
|
||||
}
|
||||
err = pubkey.Serialize(&w)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
// User ID
|
||||
p, err = Read(r)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
uid := p.(*UserId)
|
||||
if uid.Id != "ec_dsa_dh_384 <openpgp@brainhub.org>" {
|
||||
t.Error("Unexpected UID:", uid.Id)
|
||||
}
|
||||
err = uid.Serialize(&w)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
// User ID Sig
|
||||
p, err = Read(r)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
uidSig := p.(*Signature)
|
||||
err = pubkey.VerifyUserIdSignature(uid.Id, pubkey, uidSig)
|
||||
if err != nil {
|
||||
t.Error(err, ": UID")
|
||||
}
|
||||
err = uidSig.Serialize(&w)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
// Subkey
|
||||
p, err = Read(r)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
subkey := p.(*PublicKey)
|
||||
if !bytes.Equal(subkey.ec.oid, []byte{0x2b, 0x81, 0x04, 0x00, 0x22}) {
|
||||
t.Errorf("Unexpected subkey OID: %x", subkey.ec.oid)
|
||||
}
|
||||
if !bytes.Equal(subkey.ec.p.bytes[:5], []byte{0x04, 0x2f, 0xaa, 0x84, 0x02}) {
|
||||
t.Errorf("Unexpected subkey P[:5]: %x", subkey.ec.p.bytes)
|
||||
}
|
||||
if subkey.ecdh.KdfHash != 0x09 {
|
||||
t.Error("Expected KDF hash function SHA384 (0x09), got", subkey.ecdh.KdfHash)
|
||||
}
|
||||
if subkey.ecdh.KdfAlgo != 0x09 {
|
||||
t.Error("Expected KDF symmetric alg AES256 (0x09), got", subkey.ecdh.KdfAlgo)
|
||||
}
|
||||
if subkey.KeyId != 0xAA8B938F9A201946 {
|
||||
t.Errorf("Unexpected subkey ID: %x", subkey.KeyId)
|
||||
}
|
||||
err = subkey.Serialize(&w)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
// Subkey Sig
|
||||
p, err = Read(r)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
subkeySig := p.(*Signature)
|
||||
err = pubkey.VerifyKeySignature(subkey, subkeySig)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
err = subkeySig.Serialize(&w)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
// Now read back what we've written again
|
||||
r = bytes.NewBuffer(w.Bytes())
|
||||
w.Reset()
|
||||
}
|
||||
}
|
||||
|
||||
const rsaFingerprintHex = "5fb74b1d03b1e3cb31bc2f8aa34d7e18c20c31bb"
|
||||
|
||||
const rsaPkDataHex = "988d044d3c5c10010400b1d13382944bd5aba23a4312968b5095d14f947f600eb478e14a6fcb16b0e0cac764884909c020bc495cfcc39a935387c661507bdb236a0612fb582cac3af9b29cc2c8c70090616c41b662f4da4c1201e195472eb7f4ae1ccbcbf9940fe21d985e379a5563dde5b9a23d35f1cfaa5790da3b79db26f23695107bfaca8e7b5bcd0011010001"
|
||||
|
||||
const dsaFingerprintHex = "eece4c094db002103714c63c8e8fbe54062f19ed"
|
||||
|
||||
const dsaPkDataHex = "9901a2044d432f89110400cd581334f0d7a1e1bdc8b9d6d8c0baf68793632735d2bb0903224cbaa1dfbf35a60ee7a13b92643421e1eb41aa8d79bea19a115a677f6b8ba3c7818ce53a6c2a24a1608bd8b8d6e55c5090cbde09dd26e356267465ae25e69ec8bdd57c7bbb2623e4d73336f73a0a9098f7f16da2e25252130fd694c0e8070c55a812a423ae7f00a0ebf50e70c2f19c3520a551bd4b08d30f23530d3d03ff7d0bf4a53a64a09dc5e6e6e35854b7d70c882b0c60293401958b1bd9e40abec3ea05ba87cf64899299d4bd6aa7f459c201d3fbbd6c82004bdc5e8a9eb8082d12054cc90fa9d4ec251a843236a588bf49552441817436c4f43326966fe85447d4e6d0acf8fa1ef0f014730770603ad7634c3088dc52501c237328417c31c89ed70400b2f1a98b0bf42f11fefc430704bebbaa41d9f355600c3facee1e490f64208e0e094ea55e3a598a219a58500bf78ac677b670a14f4e47e9cf8eab4f368cc1ddcaa18cc59309d4cc62dd4f680e73e6cc3e1ce87a84d0925efbcb26c575c093fc42eecf45135fabf6403a25c2016e1774c0484e440a18319072c617cc97ac0a3bb0"
|
||||
|
||||
const ecdsaFingerprintHex = "9892270b38b8980b05c8d56d43fe956c542ca00b"
|
||||
|
||||
const ecdsaPkDataHex = "9893045071c29413052b8104002304230401f4867769cedfa52c325018896245443968e52e51d0c2df8d939949cb5b330f2921711fbee1c9b9dddb95d15cb0255e99badeddda7cc23d9ddcaacbc290969b9f24019375d61c2e4e3b36953a28d8b2bc95f78c3f1d592fb24499be348656a7b17e3963187b4361afe497bc5f9f81213f04069f8e1fb9e6a6290ae295ca1a92b894396cb4"
|
||||
|
||||
// Source: https://sites.google.com/site/brainhub/pgpecckeys#TOC-ECC-NIST-P-384-key
|
||||
const ecc384PubHex = `99006f044d53059213052b81040022030304f6b8c5aced5b84ef9f4a209db2e4a9dfb70d28cb8c10ecd57674a9fa5a67389942b62d5e51367df4c7bfd3f8e500feecf07ed265a621a8ebbbe53e947ec78c677eba143bd1533c2b350e1c29f82313e1e1108eba063be1e64b10e6950e799c2db42465635f6473615f64685f333834203c6f70656e70677040627261696e6875622e6f72673e8900cb04101309005305024d530592301480000000002000077072656665727265642d656d61696c2d656e636f64696e67407067702e636f6d7067706d696d65040b090807021901051b03000000021602051e010000000415090a08000a0910098033880f54719fca2b0180aa37350968bd5f115afd8ce7bc7b103822152dbff06d0afcda835329510905b98cb469ba208faab87c7412b799e7b633017f58364ea480e8a1a3f253a0c5f22c446e8be9a9fce6210136ee30811abbd49139de28b5bdf8dc36d06ae748579e9ff503b90073044d53059212052b810400220303042faa84024a20b6735c4897efa5bfb41bf85b7eefeab5ca0cb9ffc8ea04a46acb25534a577694f9e25340a4ab5223a9dd1eda530c8aa2e6718db10d7e672558c7736fe09369ea5739a2a3554bf16d41faa50562f11c6d39bbd5dffb6b9a9ec9180301090989008404181309000c05024d530592051b0c000000000a0910098033880f54719f80970180eee7a6d8fcee41ee4f9289df17f9bcf9d955dca25c583b94336f3a2b2d4986dc5cf417b8d2dc86f741a9e1a6d236c0e3017d1c76575458a0cfb93ae8a2b274fcc65ceecd7a91eec83656ba13219969f06945b48c56bd04152c3a0553c5f2f4bd1267`
|
||||
1
vendor/golang.org/x/crypto/openpgp/packet/public_key_v3.go
generated
vendored
1
vendor/golang.org/x/crypto/openpgp/packet/public_key_v3.go
generated
vendored
|
|
@ -216,6 +216,7 @@ func (pk *PublicKeyV3) VerifySignatureV3(signed hash.Hash, sig *SignatureV3) (er
|
|||
// V3 public keys only support RSA.
|
||||
panic("shouldn't happen")
|
||||
}
|
||||
panic("unreachable")
|
||||
}
|
||||
|
||||
// VerifyUserIdSignatureV3 returns nil iff sig is a valid signature, made by this
|
||||
|
|
|
|||
82
vendor/golang.org/x/crypto/openpgp/packet/public_key_v3_test.go
generated
vendored
82
vendor/golang.org/x/crypto/openpgp/packet/public_key_v3_test.go
generated
vendored
|
|
@ -1,82 +0,0 @@
|
|||
// Copyright 2013 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
var pubKeyV3Test = struct {
|
||||
hexFingerprint string
|
||||
creationTime time.Time
|
||||
pubKeyAlgo PublicKeyAlgorithm
|
||||
keyId uint64
|
||||
keyIdString string
|
||||
keyIdShort string
|
||||
}{
|
||||
"103BECF5BD1E837C89D19E98487767F7",
|
||||
time.Unix(779753634, 0),
|
||||
PubKeyAlgoRSA,
|
||||
0xDE0F188A5DA5E3C9,
|
||||
"DE0F188A5DA5E3C9",
|
||||
"5DA5E3C9"}
|
||||
|
||||
func TestPublicKeyV3Read(t *testing.T) {
|
||||
i, test := 0, pubKeyV3Test
|
||||
packet, err := Read(v3KeyReader(t))
|
||||
if err != nil {
|
||||
t.Fatalf("#%d: Read error: %s", i, err)
|
||||
}
|
||||
pk, ok := packet.(*PublicKeyV3)
|
||||
if !ok {
|
||||
t.Fatalf("#%d: failed to parse, got: %#v", i, packet)
|
||||
}
|
||||
if pk.PubKeyAlgo != test.pubKeyAlgo {
|
||||
t.Errorf("#%d: bad public key algorithm got:%x want:%x", i, pk.PubKeyAlgo, test.pubKeyAlgo)
|
||||
}
|
||||
if !pk.CreationTime.Equal(test.creationTime) {
|
||||
t.Errorf("#%d: bad creation time got:%v want:%v", i, pk.CreationTime, test.creationTime)
|
||||
}
|
||||
expectedFingerprint, _ := hex.DecodeString(test.hexFingerprint)
|
||||
if !bytes.Equal(expectedFingerprint, pk.Fingerprint[:]) {
|
||||
t.Errorf("#%d: bad fingerprint got:%x want:%x", i, pk.Fingerprint[:], expectedFingerprint)
|
||||
}
|
||||
if pk.KeyId != test.keyId {
|
||||
t.Errorf("#%d: bad keyid got:%x want:%x", i, pk.KeyId, test.keyId)
|
||||
}
|
||||
if g, e := pk.KeyIdString(), test.keyIdString; g != e {
|
||||
t.Errorf("#%d: bad KeyIdString got:%q want:%q", i, g, e)
|
||||
}
|
||||
if g, e := pk.KeyIdShortString(), test.keyIdShort; g != e {
|
||||
t.Errorf("#%d: bad KeyIdShortString got:%q want:%q", i, g, e)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPublicKeyV3Serialize(t *testing.T) {
|
||||
//for i, test := range pubKeyV3Tests {
|
||||
i := 0
|
||||
packet, err := Read(v3KeyReader(t))
|
||||
if err != nil {
|
||||
t.Fatalf("#%d: Read error: %s", i, err)
|
||||
}
|
||||
pk, ok := packet.(*PublicKeyV3)
|
||||
if !ok {
|
||||
t.Fatalf("#%d: failed to parse, got: %#v", i, packet)
|
||||
}
|
||||
var serializeBuf bytes.Buffer
|
||||
if err = pk.Serialize(&serializeBuf); err != nil {
|
||||
t.Fatalf("#%d: failed to serialize: %s", i, err)
|
||||
}
|
||||
|
||||
if packet, err = Read(bytes.NewBuffer(serializeBuf.Bytes())); err != nil {
|
||||
t.Fatalf("#%d: Read error (from serialized data): %s", i, err)
|
||||
}
|
||||
if pk, ok = packet.(*PublicKeyV3); !ok {
|
||||
t.Fatalf("#%d: failed to parse serialized data, got: %#v", i, packet)
|
||||
}
|
||||
}
|
||||
33
vendor/golang.org/x/crypto/openpgp/packet/signature.go
generated
vendored
33
vendor/golang.org/x/crypto/openpgp/packet/signature.go
generated
vendored
|
|
@ -9,11 +9,10 @@ import (
|
|||
"crypto"
|
||||
"crypto/dsa"
|
||||
"crypto/ecdsa"
|
||||
"encoding/asn1"
|
||||
"crypto/rsa"
|
||||
"encoding/binary"
|
||||
"hash"
|
||||
"io"
|
||||
"math/big"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
|
|
@ -517,8 +516,7 @@ func (sig *Signature) Sign(h hash.Hash, priv *PrivateKey, config *Config) (err e
|
|||
|
||||
switch priv.PubKeyAlgo {
|
||||
case PubKeyAlgoRSA, PubKeyAlgoRSASignOnly:
|
||||
// supports both *rsa.PrivateKey and crypto.Signer
|
||||
sig.RSASignature.bytes, err = priv.PrivateKey.(crypto.Signer).Sign(config.Random(), digest, sig.Hash)
|
||||
sig.RSASignature.bytes, err = rsa.SignPKCS1v15(config.Random(), priv.PrivateKey.(*rsa.PrivateKey), sig.Hash, digest)
|
||||
sig.RSASignature.bitLength = uint16(8 * len(sig.RSASignature.bytes))
|
||||
case PubKeyAlgoDSA:
|
||||
dsaPriv := priv.PrivateKey.(*dsa.PrivateKey)
|
||||
|
|
@ -536,17 +534,7 @@ func (sig *Signature) Sign(h hash.Hash, priv *PrivateKey, config *Config) (err e
|
|||
sig.DSASigS.bitLength = uint16(8 * len(sig.DSASigS.bytes))
|
||||
}
|
||||
case PubKeyAlgoECDSA:
|
||||
var r, s *big.Int
|
||||
if pk, ok := priv.PrivateKey.(*ecdsa.PrivateKey); ok {
|
||||
// direct support, avoid asn1 wrapping/unwrapping
|
||||
r, s, err = ecdsa.Sign(config.Random(), pk, digest)
|
||||
} else {
|
||||
var b []byte
|
||||
b, err = priv.PrivateKey.(crypto.Signer).Sign(config.Random(), digest, nil)
|
||||
if err == nil {
|
||||
r, s, err = unwrapECDSASig(b)
|
||||
}
|
||||
}
|
||||
r, s, err := ecdsa.Sign(config.Random(), priv.PrivateKey.(*ecdsa.PrivateKey), digest)
|
||||
if err == nil {
|
||||
sig.ECDSASigR = fromBig(r)
|
||||
sig.ECDSASigS = fromBig(s)
|
||||
|
|
@ -558,19 +546,6 @@ func (sig *Signature) Sign(h hash.Hash, priv *PrivateKey, config *Config) (err e
|
|||
return
|
||||
}
|
||||
|
||||
// unwrapECDSASig parses the two integer components of an ASN.1-encoded ECDSA
|
||||
// signature.
|
||||
func unwrapECDSASig(b []byte) (r, s *big.Int, err error) {
|
||||
var ecsdaSig struct {
|
||||
R, S *big.Int
|
||||
}
|
||||
_, err = asn1.Unmarshal(b, &ecsdaSig)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
return ecsdaSig.R, ecsdaSig.S, nil
|
||||
}
|
||||
|
||||
// SignUserId computes a signature from priv, asserting that pub is a valid
|
||||
// key for the identity id. On success, the signature is stored in sig. Call
|
||||
// Serialize to write it out.
|
||||
|
|
@ -578,7 +553,7 @@ func unwrapECDSASig(b []byte) (r, s *big.Int, err error) {
|
|||
func (sig *Signature) SignUserId(id string, pub *PublicKey, priv *PrivateKey, config *Config) error {
|
||||
h, err := userIdSignatureHash(id, pub, sig.Hash)
|
||||
if err != nil {
|
||||
return err
|
||||
return nil
|
||||
}
|
||||
return sig.Sign(h, priv, config)
|
||||
}
|
||||
|
|
|
|||
78
vendor/golang.org/x/crypto/openpgp/packet/signature_test.go
generated
vendored
78
vendor/golang.org/x/crypto/openpgp/packet/signature_test.go
generated
vendored
|
|
@ -1,78 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto"
|
||||
"encoding/hex"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestSignatureRead(t *testing.T) {
|
||||
packet, err := Read(readerFromHex(signatureDataHex))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
sig, ok := packet.(*Signature)
|
||||
if !ok || sig.SigType != SigTypeBinary || sig.PubKeyAlgo != PubKeyAlgoRSA || sig.Hash != crypto.SHA1 {
|
||||
t.Errorf("failed to parse, got: %#v", packet)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSignatureReserialize(t *testing.T) {
|
||||
packet, _ := Read(readerFromHex(signatureDataHex))
|
||||
sig := packet.(*Signature)
|
||||
out := new(bytes.Buffer)
|
||||
err := sig.Serialize(out)
|
||||
if err != nil {
|
||||
t.Errorf("error reserializing: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
expected, _ := hex.DecodeString(signatureDataHex)
|
||||
if !bytes.Equal(expected, out.Bytes()) {
|
||||
t.Errorf("output doesn't match input (got vs expected):\n%s\n%s", hex.Dump(out.Bytes()), hex.Dump(expected))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSignUserId(t *testing.T) {
|
||||
sig := &Signature{
|
||||
SigType: SigTypeGenericCert,
|
||||
PubKeyAlgo: PubKeyAlgoRSA,
|
||||
Hash: 0, // invalid hash function
|
||||
}
|
||||
|
||||
packet, err := Read(readerFromHex(rsaPkDataHex))
|
||||
if err != nil {
|
||||
t.Fatalf("failed to deserialize public key: %v", err)
|
||||
}
|
||||
pubKey := packet.(*PublicKey)
|
||||
|
||||
packet, err = Read(readerFromHex(privKeyRSAHex))
|
||||
if err != nil {
|
||||
t.Fatalf("failed to deserialize private key: %v", err)
|
||||
}
|
||||
privKey := packet.(*PrivateKey)
|
||||
|
||||
err = sig.SignUserId("", pubKey, privKey, nil)
|
||||
if err == nil {
|
||||
t.Errorf("did not receive an error when expected")
|
||||
}
|
||||
|
||||
sig.Hash = crypto.SHA256
|
||||
err = privKey.Decrypt([]byte("testing"))
|
||||
if err != nil {
|
||||
t.Fatalf("failed to decrypt private key: %v", err)
|
||||
}
|
||||
|
||||
err = sig.SignUserId("", pubKey, privKey, nil)
|
||||
if err != nil {
|
||||
t.Errorf("failed to sign user id: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
const signatureDataHex = "c2c05c04000102000605024cb45112000a0910ab105c91af38fb158f8d07ff5596ea368c5efe015bed6e78348c0f033c931d5f2ce5db54ce7f2a7e4b4ad64db758d65a7a71773edeab7ba2a9e0908e6a94a1175edd86c1d843279f045b021a6971a72702fcbd650efc393c5474d5b59a15f96d2eaad4c4c426797e0dcca2803ef41c6ff234d403eec38f31d610c344c06f2401c262f0993b2e66cad8a81ebc4322c723e0d4ba09fe917e8777658307ad8329adacba821420741009dfe87f007759f0982275d028a392c6ed983a0d846f890b36148c7358bdb8a516007fac760261ecd06076813831a36d0459075d1befa245ae7f7fb103d92ca759e9498fe60ef8078a39a3beda510deea251ea9f0a7f0df6ef42060f20780360686f3e400e"
|
||||
92
vendor/golang.org/x/crypto/openpgp/packet/signature_v3_test.go
generated
vendored
92
vendor/golang.org/x/crypto/openpgp/packet/signature_v3_test.go
generated
vendored
|
|
@ -1,92 +0,0 @@
|
|||
// Copyright 2013 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto"
|
||||
"encoding/hex"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/crypto/openpgp/armor"
|
||||
)
|
||||
|
||||
func TestSignatureV3Read(t *testing.T) {
|
||||
r := v3KeyReader(t)
|
||||
Read(r) // Skip public key
|
||||
Read(r) // Skip uid
|
||||
packet, err := Read(r) // Signature
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
sig, ok := packet.(*SignatureV3)
|
||||
if !ok || sig.SigType != SigTypeGenericCert || sig.PubKeyAlgo != PubKeyAlgoRSA || sig.Hash != crypto.MD5 {
|
||||
t.Errorf("failed to parse, got: %#v", packet)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSignatureV3Reserialize(t *testing.T) {
|
||||
r := v3KeyReader(t)
|
||||
Read(r) // Skip public key
|
||||
Read(r) // Skip uid
|
||||
packet, err := Read(r)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
sig := packet.(*SignatureV3)
|
||||
out := new(bytes.Buffer)
|
||||
if err = sig.Serialize(out); err != nil {
|
||||
t.Errorf("error reserializing: %s", err)
|
||||
return
|
||||
}
|
||||
expected, err := ioutil.ReadAll(v3KeyReader(t))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
expected = expected[4+141+4+39:] // See pgpdump offsets below, this is where the sig starts
|
||||
if !bytes.Equal(expected, out.Bytes()) {
|
||||
t.Errorf("output doesn't match input (got vs expected):\n%s\n%s", hex.Dump(out.Bytes()), hex.Dump(expected))
|
||||
}
|
||||
}
|
||||
|
||||
func v3KeyReader(t *testing.T) io.Reader {
|
||||
armorBlock, err := armor.Decode(bytes.NewBufferString(keySigV3Armor))
|
||||
if err != nil {
|
||||
t.Fatalf("armor Decode failed: %v", err)
|
||||
}
|
||||
return armorBlock.Body
|
||||
}
|
||||
|
||||
// keySigV3Armor is some V3 public key I found in an SKS dump.
|
||||
// Old: Public Key Packet(tag 6)(141 bytes)
|
||||
// Ver 4 - new
|
||||
// Public key creation time - Fri Sep 16 17:13:54 CDT 1994
|
||||
// Pub alg - unknown(pub 0)
|
||||
// Unknown public key(pub 0)
|
||||
// Old: User ID Packet(tag 13)(39 bytes)
|
||||
// User ID - Armin M. Warda <warda@nephilim.ruhr.de>
|
||||
// Old: Signature Packet(tag 2)(149 bytes)
|
||||
// Ver 4 - new
|
||||
// Sig type - unknown(05)
|
||||
// Pub alg - ElGamal Encrypt-Only(pub 16)
|
||||
// Hash alg - unknown(hash 46)
|
||||
// Hashed Sub: unknown(sub 81, critical)(1988 bytes)
|
||||
const keySigV3Armor = `-----BEGIN PGP PUBLIC KEY BLOCK-----
|
||||
Version: SKS 1.0.10
|
||||
|
||||
mI0CLnoYogAAAQQA1qwA2SuJwfQ5bCQ6u5t20ulnOtY0gykf7YjiK4LiVeRBwHjGq7v30tGV
|
||||
5Qti7qqRW4Ww7CDCJc4sZMFnystucR2vLkXaSoNWoFm4Fg47NiisDdhDezHwbVPW6OpCFNSi
|
||||
ZAamtj4QAUBu8j4LswafrJqZqR9336/V3g8Yil2l48kABRG0J0FybWluIE0uIFdhcmRhIDx3
|
||||
YXJkYUBuZXBoaWxpbS5ydWhyLmRlPoiVAgUQLok2xwXR6zmeWEiZAQE/DgP/WgxPQh40/Po4
|
||||
gSkWZCDAjNdph7zexvAb0CcUWahcwiBIgg3U5ErCx9I5CNVA9U+s8bNrDZwgSIeBzp3KhWUx
|
||||
524uhGgm6ZUTOAIKA6CbV6pfqoLpJnRYvXYQU5mIWsNa99wcu2qu18OeEDnztb7aLA6Ra9OF
|
||||
YFCbq4EjXRoOrYM=
|
||||
=LPjs
|
||||
-----END PGP PUBLIC KEY BLOCK-----`
|
||||
103
vendor/golang.org/x/crypto/openpgp/packet/symmetric_key_encrypted_test.go
generated
vendored
103
vendor/golang.org/x/crypto/openpgp/packet/symmetric_key_encrypted_test.go
generated
vendored
|
|
@ -1,103 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestSymmetricKeyEncrypted(t *testing.T) {
|
||||
buf := readerFromHex(symmetricallyEncryptedHex)
|
||||
packet, err := Read(buf)
|
||||
if err != nil {
|
||||
t.Errorf("failed to read SymmetricKeyEncrypted: %s", err)
|
||||
return
|
||||
}
|
||||
ske, ok := packet.(*SymmetricKeyEncrypted)
|
||||
if !ok {
|
||||
t.Error("didn't find SymmetricKeyEncrypted packet")
|
||||
return
|
||||
}
|
||||
key, cipherFunc, err := ske.Decrypt([]byte("password"))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
|
||||
packet, err = Read(buf)
|
||||
if err != nil {
|
||||
t.Errorf("failed to read SymmetricallyEncrypted: %s", err)
|
||||
return
|
||||
}
|
||||
se, ok := packet.(*SymmetricallyEncrypted)
|
||||
if !ok {
|
||||
t.Error("didn't find SymmetricallyEncrypted packet")
|
||||
return
|
||||
}
|
||||
r, err := se.Decrypt(cipherFunc, key)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
|
||||
contents, err := ioutil.ReadAll(r)
|
||||
if err != nil && err != io.EOF {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
|
||||
expectedContents, _ := hex.DecodeString(symmetricallyEncryptedContentsHex)
|
||||
if !bytes.Equal(expectedContents, contents) {
|
||||
t.Errorf("bad contents got:%x want:%x", contents, expectedContents)
|
||||
}
|
||||
}
|
||||
|
||||
const symmetricallyEncryptedHex = "8c0d04030302371a0b38d884f02060c91cf97c9973b8e58e028e9501708ccfe618fb92afef7fa2d80ddadd93cf"
|
||||
const symmetricallyEncryptedContentsHex = "cb1062004d14c4df636f6e74656e74732e0a"
|
||||
|
||||
func TestSerializeSymmetricKeyEncrypted(t *testing.T) {
|
||||
buf := bytes.NewBuffer(nil)
|
||||
passphrase := []byte("testing")
|
||||
const cipherFunc = CipherAES128
|
||||
config := &Config{
|
||||
DefaultCipher: cipherFunc,
|
||||
}
|
||||
|
||||
key, err := SerializeSymmetricKeyEncrypted(buf, passphrase, config)
|
||||
if err != nil {
|
||||
t.Errorf("failed to serialize: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
p, err := Read(buf)
|
||||
if err != nil {
|
||||
t.Errorf("failed to reparse: %s", err)
|
||||
return
|
||||
}
|
||||
ske, ok := p.(*SymmetricKeyEncrypted)
|
||||
if !ok {
|
||||
t.Errorf("parsed a different packet type: %#v", p)
|
||||
return
|
||||
}
|
||||
|
||||
if ske.CipherFunc != config.DefaultCipher {
|
||||
t.Errorf("SKE cipher function is %d (expected %d)", ske.CipherFunc, config.DefaultCipher)
|
||||
}
|
||||
parsedKey, parsedCipherFunc, err := ske.Decrypt(passphrase)
|
||||
if err != nil {
|
||||
t.Errorf("failed to decrypt reparsed SKE: %s", err)
|
||||
return
|
||||
}
|
||||
if !bytes.Equal(key, parsedKey) {
|
||||
t.Errorf("keys don't match after Decrypt: %x (original) vs %x (parsed)", key, parsedKey)
|
||||
}
|
||||
if parsedCipherFunc != cipherFunc {
|
||||
t.Errorf("cipher function doesn't match after Decrypt: %d (original) vs %d (parsed)", cipherFunc, parsedCipherFunc)
|
||||
}
|
||||
}
|
||||
123
vendor/golang.org/x/crypto/openpgp/packet/symmetrically_encrypted_test.go
generated
vendored
123
vendor/golang.org/x/crypto/openpgp/packet/symmetrically_encrypted_test.go
generated
vendored
|
|
@ -1,123 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/sha1"
|
||||
"encoding/hex"
|
||||
"golang.org/x/crypto/openpgp/errors"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestReader wraps a []byte and returns reads of a specific length.
|
||||
type testReader struct {
|
||||
data []byte
|
||||
stride int
|
||||
}
|
||||
|
||||
func (t *testReader) Read(buf []byte) (n int, err error) {
|
||||
n = t.stride
|
||||
if n > len(t.data) {
|
||||
n = len(t.data)
|
||||
}
|
||||
if n > len(buf) {
|
||||
n = len(buf)
|
||||
}
|
||||
copy(buf, t.data)
|
||||
t.data = t.data[n:]
|
||||
if len(t.data) == 0 {
|
||||
err = io.EOF
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func testMDCReader(t *testing.T) {
|
||||
mdcPlaintext, _ := hex.DecodeString(mdcPlaintextHex)
|
||||
|
||||
for stride := 1; stride < len(mdcPlaintext)/2; stride++ {
|
||||
r := &testReader{data: mdcPlaintext, stride: stride}
|
||||
mdcReader := &seMDCReader{in: r, h: sha1.New()}
|
||||
body, err := ioutil.ReadAll(mdcReader)
|
||||
if err != nil {
|
||||
t.Errorf("stride: %d, error: %s", stride, err)
|
||||
continue
|
||||
}
|
||||
if !bytes.Equal(body, mdcPlaintext[:len(mdcPlaintext)-22]) {
|
||||
t.Errorf("stride: %d: bad contents %x", stride, body)
|
||||
continue
|
||||
}
|
||||
|
||||
err = mdcReader.Close()
|
||||
if err != nil {
|
||||
t.Errorf("stride: %d, error on Close: %s", stride, err)
|
||||
}
|
||||
}
|
||||
|
||||
mdcPlaintext[15] ^= 80
|
||||
|
||||
r := &testReader{data: mdcPlaintext, stride: 2}
|
||||
mdcReader := &seMDCReader{in: r, h: sha1.New()}
|
||||
_, err := ioutil.ReadAll(mdcReader)
|
||||
if err != nil {
|
||||
t.Errorf("corruption test, error: %s", err)
|
||||
return
|
||||
}
|
||||
err = mdcReader.Close()
|
||||
if err == nil {
|
||||
t.Error("corruption: no error")
|
||||
} else if _, ok := err.(*errors.SignatureError); !ok {
|
||||
t.Errorf("corruption: expected SignatureError, got: %s", err)
|
||||
}
|
||||
}
|
||||
|
||||
const mdcPlaintextHex = "a302789c3b2d93c4e0eb9aba22283539b3203335af44a134afb800c849cb4c4de10200aff40b45d31432c80cb384299a0655966d6939dfdeed1dddf980"
|
||||
|
||||
func TestSerialize(t *testing.T) {
|
||||
buf := bytes.NewBuffer(nil)
|
||||
c := CipherAES128
|
||||
key := make([]byte, c.KeySize())
|
||||
|
||||
w, err := SerializeSymmetricallyEncrypted(buf, c, key, nil)
|
||||
if err != nil {
|
||||
t.Errorf("error from SerializeSymmetricallyEncrypted: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
contents := []byte("hello world\n")
|
||||
|
||||
w.Write(contents)
|
||||
w.Close()
|
||||
|
||||
p, err := Read(buf)
|
||||
if err != nil {
|
||||
t.Errorf("error from Read: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
se, ok := p.(*SymmetricallyEncrypted)
|
||||
if !ok {
|
||||
t.Errorf("didn't read a *SymmetricallyEncrypted")
|
||||
return
|
||||
}
|
||||
|
||||
r, err := se.Decrypt(c, key)
|
||||
if err != nil {
|
||||
t.Errorf("error from Decrypt: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
contentsCopy := bytes.NewBuffer(nil)
|
||||
_, err = io.Copy(contentsCopy, r)
|
||||
if err != nil {
|
||||
t.Errorf("error from io.Copy: %s", err)
|
||||
return
|
||||
}
|
||||
if !bytes.Equal(contentsCopy.Bytes(), contents) {
|
||||
t.Errorf("contents not equal got: %x want: %x", contentsCopy.Bytes(), contents)
|
||||
}
|
||||
}
|
||||
109
vendor/golang.org/x/crypto/openpgp/packet/userattribute_test.go
generated
vendored
109
vendor/golang.org/x/crypto/openpgp/packet/userattribute_test.go
generated
vendored
|
|
@ -1,109 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/base64"
|
||||
"image/color"
|
||||
"image/jpeg"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestParseUserAttribute(t *testing.T) {
|
||||
r := base64.NewDecoder(base64.StdEncoding, bytes.NewBufferString(userAttributePacket))
|
||||
for i := 0; i < 2; i++ {
|
||||
p, err := Read(r)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
uat := p.(*UserAttribute)
|
||||
imgs := uat.ImageData()
|
||||
if len(imgs) != 1 {
|
||||
t.Errorf("Unexpected number of images in user attribute packet: %d", len(imgs))
|
||||
}
|
||||
if len(imgs[0]) != 3395 {
|
||||
t.Errorf("Unexpected JPEG image size: %d", len(imgs[0]))
|
||||
}
|
||||
img, err := jpeg.Decode(bytes.NewBuffer(imgs[0]))
|
||||
if err != nil {
|
||||
t.Errorf("Error decoding JPEG image: %v", err)
|
||||
}
|
||||
// A pixel in my right eye.
|
||||
pixel := color.NRGBAModel.Convert(img.At(56, 36))
|
||||
ref := color.NRGBA{R: 157, G: 128, B: 124, A: 255}
|
||||
if pixel != ref {
|
||||
t.Errorf("Unexpected pixel color: %v", pixel)
|
||||
}
|
||||
w := bytes.NewBuffer(nil)
|
||||
err = uat.Serialize(w)
|
||||
if err != nil {
|
||||
t.Errorf("Error writing user attribute: %v", err)
|
||||
}
|
||||
r = bytes.NewBuffer(w.Bytes())
|
||||
}
|
||||
}
|
||||
|
||||
const userAttributePacket = `
|
||||
0cyWzJQBEAABAQAAAAAAAAAAAAAAAP/Y/+AAEEpGSUYAAQIAAAEAAQAA/9sAQwAFAwQEBAMFBAQE
|
||||
BQUFBgcMCAcHBwcPCgsJDBEPEhIRDxEQExYcFxMUGhUQERghGBocHR8fHxMXIiQiHiQcHh8e/9sA
|
||||
QwEFBQUHBgcOCAgOHhQRFB4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4e
|
||||
Hh4eHh4eHh4e/8AAEQgAZABkAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYH
|
||||
CAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHw
|
||||
JDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6
|
||||
g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk
|
||||
5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIB
|
||||
AgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEX
|
||||
GBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKT
|
||||
lJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX2
|
||||
9/j5+v/aAAwDAQACEQMRAD8A5uGP06VehQ4pIox04q5EnHSvAep+hIIl4zVuMHGPWmRrUWtalaaN
|
||||
pU2oXsgSGJSxPr6ClvoitErs0Itqjc7BQOpPAFYmrfEnwjojtHNqaXEynBjtx5hH4jj9a8B8d+Od
|
||||
W8UXZjWR4LJT+7t0Jwfc+prnIdO1CWZEW2mZ3HyDactXXDB3V5s8evm1namj6r0H4weCLtxG+ova
|
||||
ueP30RA/MV6not1bX0Ed1ZzxzwyDKvGwZSPqK+Ff+ES8R8t/ZV2oHUmM10Hgbxp4m8BatEfNnWBH
|
||||
/eWshOxx9Kmpg4te49RUM1kn+8Wh9zQ4P1FaMC7l465rjPh14y0fxnoseoaXOpfaPOgJ+eI98j09
|
||||
67W19M15bi4uzPSqTU480WXkjZkAyAR61DPE6OCSOalWRRgZxjvTb598sfU4FBwx5uY4T4feIm8P
|
||||
TeJbAgc65NIM+8cX+FFeLfF3Vr3SfiNrMFrMypJMJcDPUqP8KK+kpVFyLU+ar037SXqX4hxVpMY7
|
||||
1UhPpVlT2rybKx9smWYz3NeH/EDVLzxt40j8O6bITaQybPlbKkjq39K9O8fasdH8IahfKxWQRFIy
|
||||
Ou9uB/OuE/Z/0y3j1d9TuyoZCMs5xjuea1pLli5nn46q240l13PcfhN8EvDNtpcEl/CklyVBLuMk
|
||||
mvU/Dfwo0BL/AO13FjEDD/qyV7Vn+CvGPg8zRpJrVm8ikLtEg6+1ew2dxZ3EQaJgysuQPasH7eXW
|
||||
1zzsbVhT92kk/PsYieEND+zlPs6c/wCyAPyryH4wfCPRtW0u6j+xRLOxLxSoADkDpXY+MPjJ4c0S
|
||||
9k082d3O8ZKkxw5XI96ytK+IGk+IpFjRpod+Qq3C7QT6A1E6NenaXbqRg6rlLlqS0fRnxjpd1r/w
|
||||
w8afa7GWRPKbZLGeBKmeVNfZngLxNaeKfDdprVjxHcLlkJ5Vh1H5185/tDad9h8XOsqAw3Cb0cjq
|
||||
CfX61P8AsveKf7L8T3fhe5nxa3g324YniQdh9R/KuivTdSmp9TXB1/Z1nRlsfU249QBx1pWfcwI7
|
||||
Cq6u2Ovamb9rYz16V5x7Psz5q/aJhZfibcupIElvE3H+7j+lFbXx9szP45jlUfeso8/99OKK9elL
|
||||
3EeNVopzZVharCtxVRGGMk02S5JyFOB69zWTieypnL/GksfB+0cr9oQt69awPhPpD69Y3Ky3DWth
|
||||
CWluGU4LAdq3vibGs/g68BJygVxjrwRW5+ztoRv/AAs8EeCZnO/J/hzz/Kumi4wp3kePjlOdZKPY
|
||||
ml8Mvo6WM9ppi7J0EkQYMzkb1X0wW+bJHGACa+ivg14huZPCkjXUO6SImIYOQAP6UQ2sGneHmiWF
|
||||
CYoSAAuM8etXfhBpMr+EZ3SSNRcMx6ZxWdes6ytBGSwkMNFuo7pnP614Ut9Zn1C4uLySKcwObGFA
|
||||
Qnm4+XcR71h+CfDHiKCQWuv2YWFtw+bBZQD8rcE8n2Ney+GbGGQSM6I7xvtI681rXdp8hKRRp6t3
|
||||
FYPE1VDlsY1nQjWdl+J8w/tOeDZZ/AMd/EGefTHyxxyYjwfyODXg3waRh8UtEcFh+8Jb8FNfZPxh
|
||||
Ak8J6nbPIsiyW7LnseK+Ofh99ptPHFnf2lu0y2twGcKuSEPB/Q1WHk50miq1o14TXU+xop+On61H
|
||||
NMC6Nis1LgsAcUTSt1APFcXJZn0EqmhyvxA037friTYziBV6f7Tf40Vr3k4aXLx5OMZIzRXZB2ik
|
||||
efJXbPHJJcnaD9aN2R1qoGO8/WkuLlIV+YjdjpXSonQ5lTxfiTwzqCnkeQxx9BWx+zPrQsrBFYja
|
||||
zEfrXL6lfie3khcjY6lSPUGud+G3iA6FrY0uQ/KJsA9gCa0jSvFpnBi6tpKSPu++nsIfDFxeXciR
|
||||
qIicscY4rxTwB8RUkn1axsPEf2LTYx85kTGzqCUP8VcJ47+JOs+I0Hhq1njjt/ufIeSvq1VtE+Gs
|
||||
eoaUbSHUrkHdu3WtuX5Ix81XRh7OL5jirVpV5Whdn0F8C/iX4auVn0i612T7bASoe8wjTAd89K9g
|
||||
vtSt5NMa4t5lkRhgOh3Dn6V8aaz8KZrIR3OlQ6r56LySmSxxz06Vo/CHx34h0rxBP4XvJ5AjK2RP
|
||||
nEbAEj6ZxjPrWM6fMmoswqJxqJ1VZnqHxn1NLPwveqWHmNC2BnnNcD8DfDkGi+CH1m+ijN1qMzNA
|
||||
4GSIiAMf+hVxPxU8Tapc3c0F9MGCn5GU5BX0Pau3+HmrT3XgXSIJCBHDGdgAx1NYSpezha52Yauq
|
||||
1dya2Wh2onAIwTj1p0lxxWWLkhRyCKWa5O3ORXOos9KVQluZm83j0oqi84JyWH50Vdmc7ep43d3I
|
||||
t1Z2Iz2FYdxeSTsxyRnvTdVuDNcNluM9KrKcg817NOnZGNbEXdkNckjrXGeIIprPxFFdRHAlIwem
|
||||
COtdmxrG8Q2cd/ZNExw45RvQ1bVjim+dWNzw7eaTD4mN3dndCQCo6hmI5zXpj/Ea/wBHjkh0kwRW
|
||||
xXEfl4yTxXzXZalJDL9nuWKMmRnHcV2Hh3WreCyYXW2SWQhd5P3F6n+lS43d2cTm6d7Ox9EWPxH1
|
||||
ODQxPqWpCaSU/ukUc4z3/WvKW8UhviAdaMewYZG98gj9c1ymoa8LyWOJHwkTDaVPb0qpr+q2m6Nb
|
||||
cfvNo349az9mou9iZVXNWbub3jm98/Vza2ReV7lsJg/e3dsV654UR9N0K0sZP9ZDGFbHr3rzL4P+
|
||||
H7rXfEEWr3I3W1qf3IYdW9fwqDxf4k8UeH/G95p08kscHmk25dPlZT0we9YTj7SXKjpw1aNG8mj3
|
||||
FLv5ccU959ycnmvKPDnxB82YQarGsZPAlTp+IrvIr1ZIgySKwIyCOhFYTpyg9T0qWIhVV4svzPvf
|
||||
IdhgY4orPachj81FRdmtzxqdiZmJ9aQEgdqZcPtmbJ71DJcAZ5r20kkeXJtsfPIQDwPzrG1a+S3i
|
||||
LyHAHvmp7y7HOD1rlNdm+1T7Acovf3o+J2RMpezjzMvrob67pX9o2ShZlYgg/wAWKxZLLWLZ/Ke3
|
||||
mVh14yK9M+BMC3dre2ko3LHKCB7EV7EngeGQJdQ7HyBkMKS0djgq1W3c+XtK03U522RwzsTwNiEk
|
||||
ntXoHgf4calql9El/G8UZbLfLyfr7V9FeGvh+s+0Lbxxcglu2K1NW1nwN4Gk/wBLuI57tV5jjwzE
|
||||
/QVNS+0dWYRqNvXRFv4eeCodKsY1ggVIY1G3K4z714h+1Jqul3GpwaXYeXJLbzgyyrg4b+6D+HNb
|
||||
vjz436zq9m+naHF/ZdkeGfOZXH17V4Vqt2b29K+ZuOc5bnce5zWdPBShL2lTfojSeJhy+zp/NjVz
|
||||
1Bwa6DSfFGq6fbJFDKrov8DjPFcu97ZxsUe4jVhwVJ5Bpp1mwQiLewJPXacVq6fNpYyjOUXdHoKf
|
||||
EG8VQHsInbuVcgflRXnt5fIs2FYHgcgUVi8LG+xusdW/mN7U2KgEVkTzPt60UVfQ9eHxGHrV1MGi
|
||||
iD4V25x1qvdgLAMd6KK0pbHm4x++dp8FtUubLxJ5EIjMc+A4Za+qfD8pe1JZVOBmiinW3RyRPMfi
|
||||
R8QPE638+k2l6LK0Hylbddhb6nOa80mlkcmWR2kcnlnOSaKK7qCXKcNdu5narcSrAoBxvODWJIga
|
||||
VckjDdqKKwq/EaQ0gUdbjQ6mr7QGBUcd6tPBC6gtGpOOuKKKie5qn7qIpEXd0HSiiimSf//Z`
|
||||
87
vendor/golang.org/x/crypto/openpgp/packet/userid_test.go
generated
vendored
87
vendor/golang.org/x/crypto/openpgp/packet/userid_test.go
generated
vendored
|
|
@ -1,87 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package packet
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
var userIdTests = []struct {
|
||||
id string
|
||||
name, comment, email string
|
||||
}{
|
||||
{"", "", "", ""},
|
||||
{"John Smith", "John Smith", "", ""},
|
||||
{"John Smith ()", "John Smith", "", ""},
|
||||
{"John Smith () <>", "John Smith", "", ""},
|
||||
{"(comment", "", "comment", ""},
|
||||
{"(comment)", "", "comment", ""},
|
||||
{"<email", "", "", "email"},
|
||||
{"<email> sdfk", "", "", "email"},
|
||||
{" John Smith ( Comment ) asdkflj < email > lksdfj", "John Smith", "Comment", "email"},
|
||||
{" John Smith < email > lksdfj", "John Smith", "", "email"},
|
||||
{"(<foo", "", "<foo", ""},
|
||||
{"René Descartes (العربي)", "René Descartes", "العربي", ""},
|
||||
}
|
||||
|
||||
func TestParseUserId(t *testing.T) {
|
||||
for i, test := range userIdTests {
|
||||
name, comment, email := parseUserId(test.id)
|
||||
if name != test.name {
|
||||
t.Errorf("%d: name mismatch got:%s want:%s", i, name, test.name)
|
||||
}
|
||||
if comment != test.comment {
|
||||
t.Errorf("%d: comment mismatch got:%s want:%s", i, comment, test.comment)
|
||||
}
|
||||
if email != test.email {
|
||||
t.Errorf("%d: email mismatch got:%s want:%s", i, email, test.email)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var newUserIdTests = []struct {
|
||||
name, comment, email, id string
|
||||
}{
|
||||
{"foo", "", "", "foo"},
|
||||
{"", "bar", "", "(bar)"},
|
||||
{"", "", "baz", "<baz>"},
|
||||
{"foo", "bar", "", "foo (bar)"},
|
||||
{"foo", "", "baz", "foo <baz>"},
|
||||
{"", "bar", "baz", "(bar) <baz>"},
|
||||
{"foo", "bar", "baz", "foo (bar) <baz>"},
|
||||
}
|
||||
|
||||
func TestNewUserId(t *testing.T) {
|
||||
for i, test := range newUserIdTests {
|
||||
uid := NewUserId(test.name, test.comment, test.email)
|
||||
if uid == nil {
|
||||
t.Errorf("#%d: returned nil", i)
|
||||
continue
|
||||
}
|
||||
if uid.Id != test.id {
|
||||
t.Errorf("#%d: got '%s', want '%s'", i, uid.Id, test.id)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var invalidNewUserIdTests = []struct {
|
||||
name, comment, email string
|
||||
}{
|
||||
{"foo(", "", ""},
|
||||
{"foo<", "", ""},
|
||||
{"", "bar)", ""},
|
||||
{"", "bar<", ""},
|
||||
{"", "", "baz>"},
|
||||
{"", "", "baz)"},
|
||||
{"", "", "baz\x00"},
|
||||
}
|
||||
|
||||
func TestNewUserIdWithInvalidInput(t *testing.T) {
|
||||
for i, test := range invalidNewUserIdTests {
|
||||
if uid := NewUserId(test.name, test.comment, test.email); uid != nil {
|
||||
t.Errorf("#%d: returned non-nil value: %#v", i, uid)
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue