78e3abb0d8
* Naming
* If this is not some OpenPGP standard I follow rule that `DES` should be
upper case as it is abreviation and `Triple` should be camel-case as it
is normal word hence `TripleDES`
* rename `errors2` -> `errorsPGP`
* long lines
* https://github.com/golang/go/wiki/CodeReviewComments#line-length
* I bit improved long lines based on my folding
* reuse type in definition if possible i.e. `a string, b string, c string` -> `a,b,c string`
* `if long_statetent(); err!=nil {` -> `long_statement;↵ if err!=nil {`
* spaces around operators (e.g. `a + b` -> `a+b`)
* removing empty lines on start and end of scope
* comments
* on all exported functions
* start with function name
* import:
* order in alphabet
* separate native, golang.org/x/ and our libs
113 lines
2.7 KiB
Go
113 lines
2.7 KiB
Go
package crypto
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"io/ioutil"
|
|
"strings"
|
|
"testing"
|
|
|
|
"golang.org/x/crypto/openpgp/armor"
|
|
|
|
"github.com/ProtonMail/go-pm-crypto/constants"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
var decodedSymmetricKey, _ = base64.StdEncoding.DecodeString("ExXmnSiQ2QCey20YLH6qlLhkY3xnIBC1AwlIXwK/HvY=")
|
|
|
|
var testSymmetricKey = &SymmetricKey{
|
|
Key: decodedSymmetricKey,
|
|
Algo: constants.AES256,
|
|
}
|
|
|
|
// Corresponding key in testdata/keyring_privateKey
|
|
const testMailboxPassword = "apple"
|
|
|
|
// Corresponding key in testdata/keyring_privateKeyLegacy
|
|
// const testMailboxPasswordLegacy = "123"
|
|
|
|
const testToken = "d79ca194a22810a5363eeddfdef7dfbc327c6229"
|
|
|
|
var (
|
|
testPrivateKeyRing *KeyRing
|
|
testPublicKeyRing *KeyRing
|
|
)
|
|
|
|
// var testIdentity = &Identity{
|
|
// Name: "UserID",
|
|
// Email: "",
|
|
// }
|
|
|
|
func init() {
|
|
var err error
|
|
testPrivateKeyRing, err = ReadArmoredKeyRing(strings.NewReader(readTestFile("keyring_privateKey")))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
testPublicKeyRing, err = ReadArmoredKeyRing(strings.NewReader(readTestFile("keyring_publicKey")))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
err = testPrivateKeyRing.Unlock([]byte(testMailboxPassword))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func TestKeyRing_Decrypt(t *testing.T) {
|
|
ss, err := testPrivateKeyRing.DecryptString(readTestFile("keyring_token"))
|
|
if err != nil {
|
|
t.Fatal("Cannot decrypt token:", err)
|
|
}
|
|
|
|
assert.Exactly(t, testToken, ss.String)
|
|
}
|
|
|
|
func TestKeyRing_Encrypt(t *testing.T) {
|
|
encrypted, err := testPublicKeyRing.EncryptString(testToken, nil)
|
|
if err != nil {
|
|
t.Fatal("Cannot encrypt token:", err)
|
|
}
|
|
|
|
// We can't just check if encrypted == testEncryptedToken
|
|
// Decrypt instead
|
|
ss, err := testPrivateKeyRing.DecryptString(encrypted)
|
|
if err != nil {
|
|
t.Fatal("Cannot decrypt token:", err)
|
|
}
|
|
|
|
assert.Exactly(t, testToken, ss.String)
|
|
}
|
|
|
|
func TestKeyRing_ArmoredPublicKeyString(t *testing.T) {
|
|
s, err := testPrivateKeyRing.GetArmoredPublicKey()
|
|
if err != nil {
|
|
t.Fatal("Expected no error while getting armored public key, got:", err)
|
|
}
|
|
|
|
// Decode armored keys
|
|
block, err := armor.Decode(strings.NewReader(s))
|
|
if err != nil {
|
|
t.Fatal("Expected no error while decoding armored public key, got:", err)
|
|
}
|
|
|
|
expected, err := armor.Decode(strings.NewReader(readTestFile("keyring_publicKey")))
|
|
if err != nil {
|
|
t.Fatal("Expected no error while decoding expected armored public key, got:", err)
|
|
}
|
|
|
|
assert.Exactly(t, expected.Type, block.Type)
|
|
|
|
b, err := ioutil.ReadAll(block.Body)
|
|
if err != nil {
|
|
t.Fatal("Expected no error while reading armored public key body, got:", err)
|
|
}
|
|
|
|
eb, err := ioutil.ReadAll(expected.Body)
|
|
if err != nil {
|
|
t.Fatal("Expected no error while reading expected armored public key body, got:", err)
|
|
}
|
|
|
|
assert.Exactly(t, eb, b)
|
|
}
|