lysann/passforios-gopenpgp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename PmCrypto to GopenPGP

Browse source
This commit is contained in:
Daniel Huigens 2019-05-14 18:05:01 +02:00
parent 37cbb276fd
commit bb1be4a43b
19 changed files with 125 additions and 126 deletions
Download patch file Download diff file Expand all files Collapse all files

16
README.md
View file

@ -49,15 +49,15 @@ Encryption and decryption will use the AES256 algorithm by default.
#### Encrypt / Decrypt with password #### Encrypt / Decrypt with password
``` ```
var pmCrypto = PmCrypto{} var pgp = GopenPGP{}
const password = "my secret password" const password = "my secret password"
// Encrypt data with password // Encrypt data with password
armor, err := pmCrypto.EncryptMessageWithPassword("my message", password) armor, err := pgp.EncryptMessageWithPassword("my message", password)
// Decrypt data with password // Decrypt data with password
message, err := pmCrypto.DecryptMessageWithPassword(armor, password) message, err := pgp.DecryptMessageWithPassword(armor, password)
``` ```
#### Encrypt / Decrypt with PGP keys #### Encrypt / Decrypt with PGP keys
@ -77,13 +77,13 @@ privateKeyRing, err := crypto.ReadArmoredKeyRing(strings.NewReader(privkey))
publicKeyRing, err := crypto.ReadArmoredKeyRing(strings.NewReader(pubkey)) publicKeyRing, err := crypto.ReadArmoredKeyRing(strings.NewReader(pubkey))
// encrypt message using public key and can be optionally signed using private key and passphrase // encrypt message using public key and can be optionally signed using private key and passphrase
armor, err := pmCrypto.EncryptMessage("plain text", publicKeyRing, privateKeyRing, passphrase, false) armor, err := pgp.EncryptMessage("plain text", publicKeyRing, privateKeyRing, passphrase, false)
// OR // OR
privateKeyRing.Unlock([]byte(passphrase)) // if private key is locked with passphrase privateKeyRing.Unlock([]byte(passphrase)) // if private key is locked with passphrase
armor, err := publicKeyRing.EncryptString("plain text", privateKeyRing) armor, err := publicKeyRing.EncryptString("plain text", privateKeyRing)
// decrypt armored encrypted message using the private key and the passphrase of the private key // decrypt armored encrypted message using the private key and the passphrase of the private key
plainText, err := pmCrypto.DecryptMessage(armor, privateKeyRing, passphrase) plainText, err := pgp.DecryptMessage(armor, privateKeyRing, passphrase)
// OR // OR
signedText, err := privateKeyRing.DecryptString(armor) signedText, err := privateKeyRing.DecryptString(armor)
plainText = signedText.String plainText = signedText.String
@ -94,7 +94,7 @@ plainText = signedText.String
Keys are generated with the `GenerateKey` function, that returns the armored key as a string and a potential error. Keys are generated with the `GenerateKey` function, that returns the armored key as a string and a potential error.
The library supports RSA with different key lengths or Curve25519 keys. The library supports RSA with different key lengths or Curve25519 keys.
``` ```
var pmCrypto = PmCrypto{} var pgp = GopenPGP{}
var ( var (
localPart = "name.surname" localPart = "name.surname"
@ -105,10 +105,10 @@ var (
) )
// RSA // RSA
rsaKey, err := pmCrypto.GenerateKey(localPart, domain, passphrase, "rsa", rsaBits) rsaKey, err := pgp.GenerateKey(localPart, domain, passphrase, "rsa", rsaBits)
// Curve 25519 // Curve 25519
ecKey, err := pmCrypto.GenerateKey(localPart, domain, passphrase, "x25519", ecBits) ecKey, err := pgp.GenerateKey(localPart, domain, passphrase, "x25519", ecBits)
``` ```
### Sign ### Sign

2
build.sh
View file

@ -16,7 +16,7 @@ gomobile bind -target ios -o ${IOS_OUT}/Crypto.framework $PACKAGE_PATH/crypto $P
printf "\e[0;32mStart Building Android lib .. Location: ${ANDROID_OUT} \033[0m\n\n" printf "\e[0;32mStart Building Android lib .. Location: ${ANDROID_OUT} \033[0m\n\n"
gomobile bind -target android -javapkg com.proton.pmcrypto -o ${ANDROID_OUT}/pmcrypto.aar $PACKAGE_PATH/crypto $PACKAGE_PATH/armor $PACKAGE_PATH/constants $PACKAGE_PATH/key $PACKAGE_PATH/models gomobile bind -target android -javapkg com.proton.gopenpgp -o ${ANDROID_OUT}/gopenpgp.aar $PACKAGE_PATH/crypto $PACKAGE_PATH/armor $PACKAGE_PATH/constants $PACKAGE_PATH/key $PACKAGE_PATH/models
printf "\e[0;32mInstalling frameworks. \033[0m\n\n" printf "\e[0;32mInstalling frameworks. \033[0m\n\n"

16
crypto/attachment.go
View file

@ -47,7 +47,7 @@ func (ap *AttachmentProcessor) Finish() (*models.EncryptedSplit, error) {
} }
// encryptAttachment takes input data from file // encryptAttachment takes input data from file
func (pm *PmCrypto) encryptAttachment( func (pgp *GopenPGP) encryptAttachment(
estimatedSize int, fileName string, publicKey *KeyRing, garbageCollector int, estimatedSize int, fileName string, publicKey *KeyRing, garbageCollector int,
) (*AttachmentProcessor, error) { ) (*AttachmentProcessor, error) {
attachmentProc := &AttachmentProcessor{} attachmentProc := &AttachmentProcessor{}
@ -61,7 +61,7 @@ func (pm *PmCrypto) encryptAttachment(
config := &packet.Config{ config := &packet.Config{
DefaultCipher: packet.CipherAES256, DefaultCipher: packet.CipherAES256,
Time: pm.getTimeGenerator(), Time: pgp.getTimeGenerator(),
} }
reader, writer := io.Pipe() reader, writer := io.Pipe()
@ -90,10 +90,10 @@ func (pm *PmCrypto) encryptAttachment(
// EncryptAttachment encrypts attachment. Takes input data and key data in // EncryptAttachment encrypts attachment. Takes input data and key data in
// binary form // binary form
func (pm *PmCrypto) EncryptAttachment( func (pgp *GopenPGP) EncryptAttachment(
plainData []byte, fileName string, publicKey *KeyRing, plainData []byte, fileName string, publicKey *KeyRing,
) (*models.EncryptedSplit, error) { ) (*models.EncryptedSplit, error) {
ap, err := pm.encryptAttachment(len(plainData), fileName, publicKey, -1) ap, err := pgp.encryptAttachment(len(plainData), fileName, publicKey, -1)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -106,10 +106,10 @@ func (pm *PmCrypto) EncryptAttachment(
} }
// EncryptAttachmentLowMemory with garbage collected every megabyte // EncryptAttachmentLowMemory with garbage collected every megabyte
func (pm *PmCrypto) EncryptAttachmentLowMemory( func (pgp *GopenPGP) EncryptAttachmentLowMemory(
estimatedSize int, fileName string, publicKey *KeyRing, estimatedSize int, fileName string, publicKey *KeyRing,
) (*AttachmentProcessor, error) { ) (*AttachmentProcessor, error) {
return pm.encryptAttachment(estimatedSize, fileName, publicKey, 1<<20) return pgp.encryptAttachment(estimatedSize, fileName, publicKey, 1<<20)
} }
// SplitArmor is a Helper method. Splits armored pgp session into key and packet data // SplitArmor is a Helper method. Splits armored pgp session into key and packet data
@ -128,7 +128,7 @@ func SplitArmor(encrypted string) (*models.EncryptedSplit, error) {
// DecryptAttachment takes input data and key data in binary form. The // DecryptAttachment takes input data and key data in binary form. The
// privateKeys can contains more keys. The passphrase is used to unlock keys // privateKeys can contains more keys. The passphrase is used to unlock keys
func (pm *PmCrypto) DecryptAttachment( func (pgp *GopenPGP) DecryptAttachment(
keyPacket, dataPacket []byte, keyPacket, dataPacket []byte,
kr *KeyRing, passphrase string, kr *KeyRing, passphrase string,
) ([]byte, error) { ) ([]byte, error) {
@ -144,7 +144,7 @@ func (pm *PmCrypto) DecryptAttachment(
encryptedReader := io.MultiReader(keyReader, dataReader) encryptedReader := io.MultiReader(keyReader, dataReader)
config := &packet.Config{Time: pm.getTimeGenerator()} config := &packet.Config{Time: pgp.getTimeGenerator()}
md, err := openpgp.ReadMessage(encryptedReader, privKeyEntries, nil, config) md, err := openpgp.ReadMessage(encryptedReader, privKeyEntries, nil, config)
if err != nil { if err != nil {

4
crypto/attachment_test.go
View file

@ -58,12 +58,12 @@ func TestAttachmentSetKey(t *testing.T) {
func TestAttachnentEncryptDecrypt(t *testing.T) { func TestAttachnentEncryptDecrypt(t *testing.T) {
var testAttachmentCleartext = "cc,\ndille." var testAttachmentCleartext = "cc,\ndille."
encSplit, err := pmCrypto.EncryptAttachment([]byte(testAttachmentCleartext), "s.txt", testPrivateKeyRing) encSplit, err := pgp.EncryptAttachment([]byte(testAttachmentCleartext), "s.txt", testPrivateKeyRing)
if err != nil { if err != nil {
t.Fatal("Expected no error while encrypting attachment, got:", err) t.Fatal("Expected no error while encrypting attachment, got:", err)
} }
redecData, err := pmCrypto.DecryptAttachment(encSplit.KeyPacket, encSplit.DataPacket, testPrivateKeyRing, "") redecData, err := pgp.DecryptAttachment(encSplit.KeyPacket, encSplit.DataPacket, testPrivateKeyRing, "")
if err != nil { if err != nil {
t.Fatal("Expected no error while decrypting attachment, got:", err) t.Fatal("Expected no error while decrypting attachment, got:", err)
} }

24
crypto/key.go
View file

@ -275,8 +275,8 @@ func SetKey(kr *KeyRing, symKey *SymmetricKey) (packets string, err error) {
} }
// IsKeyExpiredBin checks if the given key is expired. Input in binary format // IsKeyExpiredBin checks if the given key is expired. Input in binary format
func (pm *PmCrypto) IsKeyExpiredBin(publicKey []byte) (bool, error) { func (pgp *GopenPGP) IsKeyExpiredBin(publicKey []byte) (bool, error) {
now := pm.getNow() now := pgp.getNow()
pubKeyReader := bytes.NewReader(publicKey) pubKeyReader := bytes.NewReader(publicKey)
pubKeyEntries, err := openpgp.ReadKeyRing(pubKeyReader) pubKeyEntries, err := openpgp.ReadKeyRing(pubKeyReader)
if err != nil { if err != nil {
@ -334,15 +334,15 @@ const (
) )
// IsKeyExpired checks if the given key is expired. Input in armored format // IsKeyExpired checks if the given key is expired. Input in armored format
func (pm *PmCrypto) IsKeyExpired(publicKey string) (bool, error) { func (pgp *GopenPGP) IsKeyExpired(publicKey string) (bool, error) {
rawPubKey, err := armor.Unarmor(publicKey) rawPubKey, err := armor.Unarmor(publicKey)
if err != nil { if err != nil {
return false, err return false, err
} }
return pm.IsKeyExpiredBin(rawPubKey) return pgp.IsKeyExpiredBin(rawPubKey)
} }
func (pm *PmCrypto) generateKey( func (pgp *GopenPGP) generateKey(
userName, domain, passphrase, keyType string, userName, domain, passphrase, keyType string,
bits int, bits int,
prime1, prime2, prime3, prime4 []byte, prime1, prime2, prime3, prime4 []byte,
@ -361,7 +361,7 @@ func (pm *PmCrypto) generateKey(
cfg := &packet.Config{ cfg := &packet.Config{
Algorithm: packet.PubKeyAlgoRSA, Algorithm: packet.PubKeyAlgoRSA,
RSABits: bits, RSABits: bits,
Time: pm.getTimeGenerator(), Time: pgp.getTimeGenerator(),
DefaultHash: crypto.SHA256, DefaultHash: crypto.SHA256,
DefaultCipher: packet.CipherAES256, DefaultCipher: packet.CipherAES256,
} }
@ -417,22 +417,22 @@ func (pm *PmCrypto) generateKey(
} }
// GenerateRSAKeyWithPrimes generates RSA key with given primes. // GenerateRSAKeyWithPrimes generates RSA key with given primes.
func (pm *PmCrypto) GenerateRSAKeyWithPrimes( func (pgp *GopenPGP) GenerateRSAKeyWithPrimes(
userName, domain, passphrase string, userName, domain, passphrase string,
bits int, bits int,
primeone, primetwo, primethree, primefour []byte, primeone, primetwo, primethree, primefour []byte,
) (string, error) { ) (string, error) {
return pm.generateKey(userName, domain, passphrase, "rsa", bits, primeone, primetwo, primethree, primefour) return pgp.generateKey(userName, domain, passphrase, "rsa", bits, primeone, primetwo, primethree, primefour)
} }
// GenerateKey and generate primes // GenerateKey and generate primes
func (pm *PmCrypto) GenerateKey(userName, domain, passphrase, keyType string, bits int) (string, error) { func (pgp *GopenPGP) GenerateKey(userName, domain, passphrase, keyType string, bits int) (string, error) {
return pm.generateKey(userName, domain, passphrase, keyType, bits, nil, nil, nil, nil) return pgp.generateKey(userName, domain, passphrase, keyType, bits, nil, nil, nil, nil)
} }
// UpdatePrivateKeyPassphrase decrypts the given private key with oldPhrase and // UpdatePrivateKeyPassphrase decrypts the given private key with oldPhrase and
// re-encrypts with the newPassphrase // re-encrypts with the newPassphrase
func (pm *PmCrypto) UpdatePrivateKeyPassphrase( func (pgp *GopenPGP) UpdatePrivateKeyPassphrase(
privateKey string, oldPassphrase string, newPassphrase string, privateKey string, oldPassphrase string, newPassphrase string,
) (string, error) { ) (string, error) {
privKey := strings.NewReader(privateKey) privKey := strings.NewReader(privateKey)
@ -478,7 +478,7 @@ func (pm *PmCrypto) UpdatePrivateKeyPassphrase(
} }
// CheckKey prints out the key and subkey fingerprint // CheckKey prints out the key and subkey fingerprint
func (pm *PmCrypto) CheckKey(pubKey string) (string, error) { func (pgp *GopenPGP) CheckKey(pubKey string) (string, error) {
pubKeyReader := strings.NewReader(pubKey) pubKeyReader := strings.NewReader(pubKey)
entries, err := openpgp.ReadArmoredKeyRing(pubKeyReader) entries, err := openpgp.ReadArmoredKeyRing(pubKeyReader)
if err != nil { if err != nil {

20
crypto/key_test.go
View file

@ -24,12 +24,12 @@ var (
) )
func TestGenerateKeys(t *testing.T) { func TestGenerateKeys(t *testing.T) {
rsaKey, err = pmCrypto.GenerateKey(name, domain, passphrase, "rsa", 1024) rsaKey, err = pgp.GenerateKey(name, domain, passphrase, "rsa", 1024)
if err != nil { if err != nil {
t.Fatal("Cannot generate RSA key:", err) t.Fatal("Cannot generate RSA key:", err)
} }
ecKey, err = pmCrypto.GenerateKey(name, domain, passphrase, "x25519", 256) ecKey, err = pgp.GenerateKey(name, domain, passphrase, "x25519", 256)
if err != nil { if err != nil {
t.Fatal("Cannot generate EC key:", err) t.Fatal("Cannot generate EC key:", err)
} }
@ -111,12 +111,12 @@ func TestEncryptDecryptKeys(t *testing.T) {
func TestUpdatePrivateKeysPassphrase(t *testing.T) { func TestUpdatePrivateKeysPassphrase(t *testing.T) {
newPassphrase := "I like GNU" newPassphrase := "I like GNU"
rsaKey, err = pmCrypto.UpdatePrivateKeyPassphrase(rsaKey, passphrase, newPassphrase) rsaKey, err = pgp.UpdatePrivateKeyPassphrase(rsaKey, passphrase, newPassphrase)
if err != nil { if err != nil {
t.Fatal("Error in changing RSA key's passphrase:", err) t.Fatal("Error in changing RSA key's passphrase:", err)
} }
ecKey, err = pmCrypto.UpdatePrivateKeyPassphrase(ecKey, passphrase, newPassphrase) ecKey, err = pgp.UpdatePrivateKeyPassphrase(ecKey, passphrase, newPassphrase)
if err != nil { if err != nil {
t.Fatal("Error in changing EC key's passphrase:", err) t.Fatal("Error in changing EC key's passphrase:", err)
} }
@ -125,19 +125,19 @@ func TestUpdatePrivateKeysPassphrase(t *testing.T) {
} }
func ExampleCheckKeys() { func ExampleCheckKeys() {
_, _ = pmCrypto.CheckKey(readTestFile("keyring_publicKey", false)) _, _ = pgp.CheckKey(readTestFile("keyring_publicKey", false))
// Output: // Output:
// SubKey:37e4bcf09b36e34012d10c0247dc67b5cb8267f6 // SubKey:37e4bcf09b36e34012d10c0247dc67b5cb8267f6
// PrimaryKey:6e8ba229b0cccaf6962f97953eb6259edf21df24 // PrimaryKey:6e8ba229b0cccaf6962f97953eb6259edf21df24
} }
func TestIsKeyExpired(t *testing.T) { func TestIsKeyExpired(t *testing.T) {
rsaRes, err := pmCrypto.IsKeyExpired(rsaPublicKey) rsaRes, err := pgp.IsKeyExpired(rsaPublicKey)
if err != nil { if err != nil {
t.Fatal("Error in checking expiration of RSA key:", err) t.Fatal("Error in checking expiration of RSA key:", err)
} }
ecRes, err := pmCrypto.IsKeyExpired(ecPublicKey) ecRes, err := pgp.IsKeyExpired(ecPublicKey)
if err != nil { if err != nil {
t.Fatal("Error in checking expiration of EC key:", err) t.Fatal("Error in checking expiration of EC key:", err)
} }
@ -145,10 +145,10 @@ func TestIsKeyExpired(t *testing.T) {
assert.Exactly(t, false, rsaRes) assert.Exactly(t, false, rsaRes)
assert.Exactly(t, false, ecRes) assert.Exactly(t, false, ecRes)
pmCrypto.UpdateTime(1557754627) // 2019-05-13T13:37:07+00:00 pgp.UpdateTime(1557754627) // 2019-05-13T13:37:07+00:00
expRes, expErr := pmCrypto.IsKeyExpired(readTestFile("key_expiredKey", false)) expRes, expErr := pgp.IsKeyExpired(readTestFile("key_expiredKey", false))
futureRes, futureErr := pmCrypto.IsKeyExpired(readTestFile("key_futureKey", false)) futureRes, futureErr := pgp.IsKeyExpired(readTestFile("key_futureKey", false))
assert.Exactly(t, true, expRes) assert.Exactly(t, true, expRes)
assert.Exactly(t, true, futureRes) assert.Exactly(t, true, futureRes)

14
crypto/keyring.go
View file

@ -131,7 +131,7 @@ func (kr *KeyRing) GetSigningEntity(passphrase string) (*openpgp.Entity, error)
} }
} }
if signEntity == nil { if signEntity == nil {
err := errors.New("pmcrypto: cannot sign message, unable to unlock signer key") err := errors.New("gopenpgp: cannot sign message, unable to unlock signer key")
return signEntity, err return signEntity, err
} }
@ -172,7 +172,7 @@ func (kr *KeyRing) Encrypt(w io.Writer, sign *KeyRing, filename string, canonica
signEntity, signEntity,
filename, filename,
canonicalizeText, canonicalizeText,
func() time.Time { return GetPmCrypto().GetTime() }) func() time.Time { return GetGopenPGP().GetTime() })
} }
// EncryptCore is common encryption method for desktop and mobile clients // EncryptCore is common encryption method for desktop and mobile clients
@ -332,7 +332,7 @@ func (kr *KeyRing) DetachedSign(w io.Writer, toSign io.Reader, canonicalizeText
config := &packet.Config{DefaultCipher: packet.CipherAES256, config := &packet.Config{DefaultCipher: packet.CipherAES256,
Time: func() time.Time { Time: func() time.Time {
return GetPmCrypto().GetTime() return GetGopenPGP().GetTime()
}, },
} }
@ -588,7 +588,7 @@ func (kr *KeyRing) readFrom(r io.Reader, armored bool) error {
} }
// BuildKeyRing reads keyring from binary data // BuildKeyRing reads keyring from binary data
func (pm *PmCrypto) BuildKeyRing(binKeys []byte) (kr *KeyRing, err error) { func (pgp *GopenPGP) BuildKeyRing(binKeys []byte) (kr *KeyRing, err error) {
kr = &KeyRing{} kr = &KeyRing{}
entriesReader := bytes.NewReader(binKeys) entriesReader := bytes.NewReader(binKeys)
err = kr.readFrom(entriesReader, false) err = kr.readFrom(entriesReader, false)
@ -597,13 +597,13 @@ func (pm *PmCrypto) BuildKeyRing(binKeys []byte) (kr *KeyRing, err error) {
} }
// BuildKeyRingNoError does not return error on fail // BuildKeyRingNoError does not return error on fail
func (pm *PmCrypto) BuildKeyRingNoError(binKeys []byte) (kr *KeyRing) { func (pgp *GopenPGP) BuildKeyRingNoError(binKeys []byte) (kr *KeyRing) {
kr, _ = pm.BuildKeyRing(binKeys) kr, _ = pgp.BuildKeyRing(binKeys)
return return
} }
// BuildKeyRingArmored reads armored string and returns keyring // BuildKeyRingArmored reads armored string and returns keyring
func (pm *PmCrypto) BuildKeyRingArmored(key string) (kr *KeyRing, err error) { func (pgp *GopenPGP) BuildKeyRingArmored(key string) (kr *KeyRing, err error) {
keyRaw, err := armorUtils.Unarmor(key) keyRaw, err := armorUtils.Unarmor(key)
if err != nil { if err != nil {
return nil, err return nil, err

22
crypto/message.go
View file

@ -24,7 +24,7 @@ import (
// encryptedText : string armored encrypted // encryptedText : string armored encrypted
// privateKey : armored private use to decrypt message // privateKey : armored private use to decrypt message
// passphrase : match with private key to decrypt message // passphrase : match with private key to decrypt message
func (pm *PmCrypto) DecryptMessageStringKey( func (pgp *GopenPGP) DecryptMessageStringKey(
encryptedText, privateKey, passphrase string, encryptedText, privateKey, passphrase string,
) (string, error) { ) (string, error) {
privKeyRaw, err := armorUtils.Unarmor(privateKey) privKeyRaw, err := armorUtils.Unarmor(privateKey)
@ -37,15 +37,15 @@ func (pm *PmCrypto) DecryptMessageStringKey(
return "", err return "", err
} }
return pm.DecryptMessage(encryptedText, &KeyRing{entities: privKeyEntries}, passphrase) return pgp.DecryptMessage(encryptedText, &KeyRing{entities: privKeyEntries}, passphrase)
} }
// DecryptMessage decrypts encrypted string using keyring // DecryptMessage decrypts encrypted string using keyring
// encryptedText : string armored encrypted // encryptedText : string armored encrypted
// privateKey : keyring with private key to decrypt message, could be multiple keys // privateKey : keyring with private key to decrypt message, could be multiple keys
// passphrase : match with private key to decrypt message // passphrase : match with private key to decrypt message
func (pm *PmCrypto) DecryptMessage(encryptedText string, privateKey *KeyRing, passphrase string) (string, error) { func (pgp *GopenPGP) DecryptMessage(encryptedText string, privateKey *KeyRing, passphrase string) (string, error) {
md, err := decryptCore(encryptedText, nil, privateKey, passphrase, pm.getTimeGenerator()) md, err := decryptCore(encryptedText, nil, privateKey, passphrase, pgp.getTimeGenerator())
if err != nil { if err != nil {
return "", err return "", err
} }
@ -92,7 +92,7 @@ func decryptCore(
// verifierKey []byte: unarmored verifier keys // verifierKey []byte: unarmored verifier keys
// privateKeyRing []byte: unarmored private key to decrypt. could be multiple // privateKeyRing []byte: unarmored private key to decrypt. could be multiple
// passphrase: match with private key to decrypt message // passphrase: match with private key to decrypt message
func (pm *PmCrypto) DecryptMessageVerify( func (pgp *GopenPGP) DecryptMessageVerify(
encryptedText string, verifierKey, privateKeyRing *KeyRing, encryptedText string, verifierKey, privateKeyRing *KeyRing,
passphrase string, verifyTime int64, passphrase string, verifyTime int64,
) (*models.DecryptSignedVerify, error) { ) (*models.DecryptSignedVerify, error) {
@ -171,14 +171,14 @@ func processSignatureExpiration(md *openpgp.MessageDetails, verifyTime int64) {
// EncryptMessageWithPassword encrypts a plain text to pgp message with a password // EncryptMessageWithPassword encrypts a plain text to pgp message with a password
// plainText string: clear text // plainText string: clear text
// output string: armored pgp message // output string: armored pgp message
func (pm *PmCrypto) EncryptMessageWithPassword(plainText string, password string) (string, error) { func (pgp *GopenPGP) EncryptMessageWithPassword(plainText string, password string) (string, error) {
var outBuf bytes.Buffer var outBuf bytes.Buffer
w, err := armor.Encode(&outBuf, constants.PGPMessageHeader, internal.ArmorHeaders) w, err := armor.Encode(&outBuf, constants.PGPMessageHeader, internal.ArmorHeaders)
if err != nil { if err != nil {
return "", err return "", err
} }
config := &packet.Config{Time: pm.getTimeGenerator()} config := &packet.Config{Time: pgp.getTimeGenerator()}
plaintext, err := openpgp.SymmetricallyEncrypt(w, []byte(password), nil, config) plaintext, err := openpgp.SymmetricallyEncrypt(w, []byte(password), nil, config)
if err != nil { if err != nil {
return "", err return "", err
@ -204,7 +204,7 @@ func (pm *PmCrypto) EncryptMessageWithPassword(plainText string, password string
// privateKey : optional required when you want to sign // privateKey : optional required when you want to sign
// passphrase : optional required when you pass the private key and this passphrase should decrypt the private key // passphrase : optional required when you pass the private key and this passphrase should decrypt the private key
// trim : bool true if need to trim new lines // trim : bool true if need to trim new lines
func (pm *PmCrypto) EncryptMessage( func (pgp *GopenPGP) EncryptMessage(
plainText string, publicKey, privateKey *KeyRing, plainText string, publicKey, privateKey *KeyRing,
passphrase string, trim bool, passphrase string, trim bool,
) (string, error) { ) (string, error) {
@ -227,7 +227,7 @@ func (pm *PmCrypto) EncryptMessage(
} }
} }
ew, err := EncryptCore(w, publicKey.entities, signEntity, "", false, pm.getTimeGenerator()) ew, err := EncryptCore(w, publicKey.entities, signEntity, "", false, pgp.getTimeGenerator())
if err != nil { if err != nil {
return "", err return "", err
} }
@ -241,7 +241,7 @@ func (pm *PmCrypto) EncryptMessage(
// DecryptMessageWithPassword decrypts a pgp message with a password // DecryptMessageWithPassword decrypts a pgp message with a password
// encrypted string : armored pgp message // encrypted string : armored pgp message
// output string : clear text // output string : clear text
func (pm *PmCrypto) DecryptMessageWithPassword(encrypted string, password string) (string, error) { func (pgp *GopenPGP) DecryptMessageWithPassword(encrypted string, password string) (string, error) {
encryptedio, err := internal.Unarmor(encrypted) encryptedio, err := internal.Unarmor(encrypted)
if err != nil { if err != nil {
return "", err return "", err
@ -256,7 +256,7 @@ func (pm *PmCrypto) DecryptMessageWithPassword(encrypted string, password string
return nil, errors.New("password incorrect") return nil, errors.New("password incorrect")
} }
config := &packet.Config{Time: pm.getTimeGenerator()} config := &packet.Config{Time: pgp.getTimeGenerator()}
md, err := openpgp.ReadMessage(encryptedio.Body, nil, prompt, config) md, err := openpgp.ReadMessage(encryptedio.Body, nil, prompt, config)
if err != nil { if err != nil {
return "", err return "", err

14
crypto/message_test.go
View file

@ -7,20 +7,20 @@ import (
) )
func TestMessageEncryptionWithPassword(t *testing.T) { func TestMessageEncryptionWithPassword(t *testing.T) {
var pmCrypto = PmCrypto{} var pgp = GopenPGP{}
const password = "my secret password" const password = "my secret password"
// Encrypt data with password // Encrypt data with password
armor, err := pmCrypto.EncryptMessageWithPassword("my message", password) armor, err := pgp.EncryptMessageWithPassword("my message", password)
if err != nil { if err != nil {
t.Fatal("Expected no error when encrypting, got:", err) t.Fatal("Expected no error when encrypting, got:", err)
} }
// Decrypt data with wrong password // Decrypt data with wrong password
_, err = pmCrypto.DecryptMessageWithPassword(armor, "wrong password") _, err = pgp.DecryptMessageWithPassword(armor, "wrong password")
assert.NotNil(t, err) assert.NotNil(t, err)
// Decrypt data with the good password // Decrypt data with the good password
text, err := pmCrypto.DecryptMessageWithPassword(armor, password) text, err := pgp.DecryptMessageWithPassword(armor, password)
if err != nil { if err != nil {
t.Fatal("Expected no error when decrypting, got:", err) t.Fatal("Expected no error when decrypting, got:", err)
} }
@ -28,7 +28,7 @@ func TestMessageEncryptionWithPassword(t *testing.T) {
} }
func TestMessageEncryption(t *testing.T) { func TestMessageEncryption(t *testing.T) {
var pmCrypto = PmCrypto{} var pgp = GopenPGP{}
var ( var (
message = "plain text" message = "plain text"
) )
@ -37,11 +37,11 @@ func TestMessageEncryption(t *testing.T) {
_ = testPrivateKeyRing.Unlock([]byte(testMailboxPassword)) _ = testPrivateKeyRing.Unlock([]byte(testMailboxPassword))
testPublicKeyRing, _ = ReadArmoredKeyRing(strings.NewReader(readTestFile("keyring_publicKey", false))) testPublicKeyRing, _ = ReadArmoredKeyRing(strings.NewReader(readTestFile("keyring_publicKey", false)))
armor, err := pmCrypto.EncryptMessage(message, testPublicKeyRing, testPrivateKeyRing, testMailboxPassword, false) armor, err := pgp.EncryptMessage(message, testPublicKeyRing, testPrivateKeyRing, testMailboxPassword, false)
if err != nil { if err != nil {
t.Fatal("Expected no error when encrypting, got:", err) t.Fatal("Expected no error when encrypting, got:", err)
} }
plainText, err := pmCrypto.DecryptMessage(armor, testPrivateKeyRing, testMailboxPassword) plainText, err := pgp.DecryptMessage(armor, testPrivateKeyRing, testMailboxPassword)
if err != nil { if err != nil {
t.Fatal("Expected no error when decrypting, got:", err) t.Fatal("Expected no error when decrypting, got:", err)
} }

10
crypto/mime.go
View file

@ -13,14 +13,14 @@ import (
"golang.org/x/crypto/openpgp/packet" "golang.org/x/crypto/openpgp/packet"
) )
func (pm PmCrypto) parseMIME( func (pgp GopenPGP) parseMIME(
mimeBody string, verifierKey *KeyRing, mimeBody string, verifierKey *KeyRing,
) (*pmmime.BodyCollector, int, []string, []string, error) { ) (*pmmime.BodyCollector, int, []string, []string, error) {
mm, err := mail.ReadMessage(strings.NewReader(mimeBody)) mm, err := mail.ReadMessage(strings.NewReader(mimeBody))
if err != nil { if err != nil {
return nil, 0, nil, nil, err return nil, 0, nil, nil, err
} }
config := &packet.Config{DefaultCipher: packet.CipherAES256, Time: pm.getTimeGenerator()} config := &packet.Config{DefaultCipher: packet.CipherAES256, Time: pgp.getTimeGenerator()}
h := textproto.MIMEHeader(mm.Header) h := textproto.MIMEHeader(mm.Header)
mmBodyData, err := ioutil.ReadAll(mm.Body) mmBodyData, err := ioutil.ReadAll(mm.Body)
@ -61,17 +61,17 @@ type MIMECallbacks interface {
} }
// DecryptMIMEMessage decrypts a MIME message // DecryptMIMEMessage decrypts a MIME message
func (pm *PmCrypto) DecryptMIMEMessage( func (pgp *GopenPGP) DecryptMIMEMessage(
encryptedText string, verifierKey, privateKeyRing *KeyRing, encryptedText string, verifierKey, privateKeyRing *KeyRing,
passphrase string, callbacks MIMECallbacks, verifyTime int64, passphrase string, callbacks MIMECallbacks, verifyTime int64,
) { ) {
decsignverify, err := pm.DecryptMessageVerify(encryptedText, verifierKey, privateKeyRing, passphrase, verifyTime) decsignverify, err := pgp.DecryptMessageVerify(encryptedText, verifierKey, privateKeyRing, passphrase, verifyTime)
if err != nil { if err != nil {
callbacks.OnError(err) callbacks.OnError(err)
return return
} }
body, verified, attachments, attachmentHeaders, err := pm.parseMIME(decsignverify.Plaintext, verifierKey) body, verified, attachments, attachmentHeaders, err := pgp.parseMIME(decsignverify.Plaintext, verifierKey)
if err != nil { if err != nil {
callbacks.OnError(err) callbacks.OnError(err)
return return

10
crypto/mime_test.go
View file

@ -53,17 +53,17 @@ func TestDecrypt(t *testing.T) {
privateKeyUnarmored, _ := ioutil.ReadAll(block.Body) privateKeyUnarmored, _ := ioutil.ReadAll(block.Body)
pmCrypto.DecryptMIMEMessage( pgp.DecryptMIMEMessage(
readTestFile("mime_pgpMessage", false), readTestFile("mime_pgpMessage", false),
pmCrypto.BuildKeyRingNoError(publicKeyUnarmored), pgp.BuildKeyRingNoError(publicKeyUnarmored),
pmCrypto.BuildKeyRingNoError(privateKeyUnarmored), pgp.BuildKeyRingNoError(privateKeyUnarmored),
privateKeyPassword, privateKeyPassword,
&callbacks, &callbacks,
pmCrypto.GetTimeUnix()) pgp.GetTimeUnix())
} }
func TestParse(t *testing.T) { func TestParse(t *testing.T) {
body, _, atts, attHeaders, err := pmCrypto.parseMIME(readTestFile("mime_testMessage", false), nil) body, _, atts, attHeaders, err := pgp.parseMIME(readTestFile("mime_testMessage", false), nil)
if err != nil { if err != nil {
t.Error("Expected no error while parsing message, got:", err) t.Error("Expected no error while parsing message, got:", err)

4
crypto/pmcrypto.go
View file

@ -6,9 +6,9 @@ package crypto
import "time" import "time"
// PmCrypto structure is used to manage server time shift. It should be also used for any // GopenPGP structure is used to manage server time shift. It should be also used for any
// other specific general cryptographic entities. // other specific general cryptographic entities.
type PmCrypto struct { type GopenPGP struct {
//latestServerTime unix time cache //latestServerTime unix time cache
latestServerTime int64 latestServerTime int64
latestClientTime time.Time latestClientTime time.Time

16
crypto/session.go
View file

@ -14,7 +14,7 @@ import (
) )
// RandomToken with a default key size // RandomToken with a default key size
func (pm *PmCrypto) RandomToken() ([]byte, error) { func (pgp *GopenPGP) RandomToken() ([]byte, error) {
config := &packet.Config{DefaultCipher: packet.CipherAES256} config := &packet.Config{DefaultCipher: packet.CipherAES256}
keySize := config.DefaultCipher.KeySize() keySize := config.DefaultCipher.KeySize()
symKey := make([]byte, keySize) symKey := make([]byte, keySize)
@ -25,7 +25,7 @@ func (pm *PmCrypto) RandomToken() ([]byte, error) {
} }
// RandomTokenWith a given key size // RandomTokenWith a given key size
func (pm *PmCrypto) RandomTokenWith(size int) ([]byte, error) { func (pgp *GopenPGP) RandomTokenWith(size int) ([]byte, error) {
config := &packet.Config{DefaultCipher: packet.CipherAES256} config := &packet.Config{DefaultCipher: packet.CipherAES256}
symKey := make([]byte, size) symKey := make([]byte, size)
if _, err := io.ReadFull(config.Random(), symKey); err != nil { if _, err := io.ReadFull(config.Random(), symKey); err != nil {
@ -35,7 +35,7 @@ func (pm *PmCrypto) RandomTokenWith(size int) ([]byte, error) {
} }
// GetSessionFromKeyPacket gets session key no encoding in and out // GetSessionFromKeyPacket gets session key no encoding in and out
func (pm *PmCrypto) GetSessionFromKeyPacket( func (pgp *GopenPGP) GetSessionFromKeyPacket(
keyPackage []byte, privateKey *KeyRing, passphrase string, keyPackage []byte, privateKey *KeyRing, passphrase string,
) (*SymmetricKey, ) (*SymmetricKey,
error) { error) {
@ -73,16 +73,16 @@ func (pm *PmCrypto) GetSessionFromKeyPacket(
} }
// KeyPacketWithPublicKey returns binary packet from symmetric key and armored public key // KeyPacketWithPublicKey returns binary packet from symmetric key and armored public key
func (pm *PmCrypto) KeyPacketWithPublicKey(sessionSplit *SymmetricKey, publicKey string) ([]byte, error) { func (pgp *GopenPGP) KeyPacketWithPublicKey(sessionSplit *SymmetricKey, publicKey string) ([]byte, error) {
pubkeyRaw, err := armor.Unarmor(publicKey) pubkeyRaw, err := armor.Unarmor(publicKey)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return pm.KeyPacketWithPublicKeyBin(sessionSplit, pubkeyRaw) return pgp.KeyPacketWithPublicKeyBin(sessionSplit, pubkeyRaw)
} }
// KeyPacketWithPublicKeyBin returns binary packet from symmetric key and binary public key // KeyPacketWithPublicKeyBin returns binary packet from symmetric key and binary public key
func (pm *PmCrypto) KeyPacketWithPublicKeyBin(sessionSplit *SymmetricKey, publicKey []byte) ([]byte, error) { func (pgp *GopenPGP) KeyPacketWithPublicKeyBin(sessionSplit *SymmetricKey, publicKey []byte) ([]byte, error) {
publicKeyReader := bytes.NewReader(publicKey) publicKeyReader := bytes.NewReader(publicKey)
pubKeyEntries, err := openpgp.ReadKeyRing(publicKeyReader) pubKeyEntries, err := openpgp.ReadKeyRing(publicKeyReader)
if err != nil { if err != nil {
@ -130,7 +130,7 @@ func (pm *PmCrypto) KeyPacketWithPublicKeyBin(sessionSplit *SymmetricKey, public
} }
// GetSessionFromSymmetricPacket extracts symmentric key from binary packet // GetSessionFromSymmetricPacket extracts symmentric key from binary packet
func (pm *PmCrypto) GetSessionFromSymmetricPacket(keyPackage []byte, password string) (*SymmetricKey, error) { func (pgp *GopenPGP) GetSessionFromSymmetricPacket(keyPackage []byte, password string) (*SymmetricKey, error) {
keyReader := bytes.NewReader(keyPackage) keyReader := bytes.NewReader(keyPackage)
packets := packet.NewReader(keyReader) packets := packet.NewReader(keyReader)
@ -168,7 +168,7 @@ func (pm *PmCrypto) GetSessionFromSymmetricPacket(keyPackage []byte, password st
} }
// SymmetricKeyPacketWithPassword return binary packet from symmetric key and password // SymmetricKeyPacketWithPassword return binary packet from symmetric key and password
func (pm *PmCrypto) SymmetricKeyPacketWithPassword(sessionSplit *SymmetricKey, password string) ([]byte, error) { func (pgp *GopenPGP) SymmetricKeyPacketWithPassword(sessionSplit *SymmetricKey, password string) ([]byte, error) {
outbuf := &bytes.Buffer{} outbuf := &bytes.Buffer{}
cf := sessionSplit.GetCipherFunc() cf := sessionSplit.GetCipherFunc()

14
crypto/sign_detached.go
View file

@ -15,7 +15,7 @@ import (
) )
// SignTextDetached signs detached text type // SignTextDetached signs detached text type
func (pm *PmCrypto) SignTextDetached( func (pgp *GopenPGP) SignTextDetached(
plainText string, privateKey *KeyRing, passphrase string, trim bool, plainText string, privateKey *KeyRing, passphrase string, trim bool,
) (string, error) { ) (string, error) {
//sign with 0x01 text //sign with 0x01 text
@ -28,7 +28,7 @@ func (pm *PmCrypto) SignTextDetached(
return "", err return "", err
} }
config := &packet.Config{DefaultCipher: packet.CipherAES256, Time: pm.getTimeGenerator()} config := &packet.Config{DefaultCipher: packet.CipherAES256, Time: pgp.getTimeGenerator()}
att := strings.NewReader(plainText) att := strings.NewReader(plainText)
@ -42,14 +42,14 @@ func (pm *PmCrypto) SignTextDetached(
} }
// SignBinDetached Signs detached bin data using string key // SignBinDetached Signs detached bin data using string key
func (pm *PmCrypto) SignBinDetached(plainData []byte, privateKey *KeyRing, passphrase string) (string, error) { func (pgp *GopenPGP) SignBinDetached(plainData []byte, privateKey *KeyRing, passphrase string) (string, error) {
//sign with 0x00 //sign with 0x00
signEntity, err := privateKey.GetSigningEntity(passphrase) signEntity, err := privateKey.GetSigningEntity(passphrase)
if err != nil { if err != nil {
return "", err return "", err
} }
config := &packet.Config{DefaultCipher: packet.CipherAES256, Time: pm.getTimeGenerator()} config := &packet.Config{DefaultCipher: packet.CipherAES256, Time: pgp.getTimeGenerator()}
att := bytes.NewReader(plainData) att := bytes.NewReader(plainData)
@ -64,7 +64,7 @@ func (pm *PmCrypto) SignBinDetached(plainData []byte, privateKey *KeyRing, passp
// VerifyTextDetachedSig verifies detached text // VerifyTextDetachedSig verifies detached text
// - check if signature is valid using a given publicKey in binary format // - check if signature is valid using a given publicKey in binary format
func (pm *PmCrypto) VerifyTextDetachedSig( func (pgp *GopenPGP) VerifyTextDetachedSig(
signature string, plainText string, publicKey *KeyRing, verifyTime int64, signature string, plainText string, publicKey *KeyRing, verifyTime int64,
) (bool, error) { ) (bool, error) {
plainText = internal.TrimNewlines(plainText) plainText = internal.TrimNewlines(plainText)
@ -112,7 +112,7 @@ func verifySignature(
} }
if signer == nil { if signer == nil {
return false, errors.New("pmcrypto: signer is empty") return false, errors.New("gopenpgp: signer is empty")
} }
// if signer.PrimaryKey.KeyId != signed.PrimaryKey.KeyId { // if signer.PrimaryKey.KeyId != signed.PrimaryKey.KeyId {
// // t.Errorf("wrong signer got:%x want:%x", signer.PrimaryKey.KeyId, 0) // // t.Errorf("wrong signer got:%x want:%x", signer.PrimaryKey.KeyId, 0)
@ -123,7 +123,7 @@ func verifySignature(
// VerifyBinDetachedSig verifies detached text in binary format // VerifyBinDetachedSig verifies detached text in binary format
// - check if signature is valid using a given publicKey in binary format // - check if signature is valid using a given publicKey in binary format
func (pm *PmCrypto) VerifyBinDetachedSig( func (pgp *GopenPGP) VerifyBinDetachedSig(
signature string, plainData []byte, publicKey *KeyRing, verifyTime int64, signature string, plainData []byte, publicKey *KeyRing, verifyTime int64,
) (bool, error) { ) (bool, error) {
origText := bytes.NewReader(plainData) origText := bytes.NewReader(plainData)

25
crypto/signature_test.go
View file

@ -1,8 +1,8 @@
package crypto package crypto
import ( import (
"strings"
"regexp" "regexp"
"strings"
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
@ -20,11 +20,11 @@ func TestSignTextDetached(t *testing.T) {
t.Fatal("Cannot read private key:", err) t.Fatal("Cannot read private key:", err)
} }
signature, err = pmCrypto.SignTextDetached(signedPlainText, signingKeyRing, "", true) signature, err = pgp.SignTextDetached(signedPlainText, signingKeyRing, "", true)
assert.EqualError(t, err, "pmcrypto: cannot sign message, unable to unlock signer key") assert.EqualError(t, err, "gopenpgp: cannot sign message, unable to unlock signer key")
// Password defined in keyring_test // Password defined in keyring_test
signature, err = pmCrypto.SignTextDetached(signedPlainText, signingKeyRing, testMailboxPassword, true) signature, err = pgp.SignTextDetached(signedPlainText, signingKeyRing, testMailboxPassword, true)
if err != nil { if err != nil {
t.Fatal("Cannot generate signature with encrypted key:", err) t.Fatal("Cannot generate signature with encrypted key:", err)
} }
@ -37,7 +37,7 @@ func TestSignTextDetached(t *testing.T) {
t.Fatal("Cannot decrypt private key:", err) t.Fatal("Cannot decrypt private key:", err)
} }
signatureDec, err := pmCrypto.SignTextDetached(signedPlainText, signingKeyRing, "", true) signatureDec, err := pgp.SignTextDetached(signedPlainText, signingKeyRing, "", true)
if err != nil { if err != nil {
t.Fatal("Cannot generate signature with decrypted key:", err) t.Fatal("Cannot generate signature with decrypted key:", err)
} }
@ -52,11 +52,11 @@ func TestSignBinDetached(t *testing.T) {
// Reset keyring to locked state // Reset keyring to locked state
signingKeyRing, _ = ReadArmoredKeyRing(strings.NewReader(readTestFile("keyring_privateKey", false))) signingKeyRing, _ = ReadArmoredKeyRing(strings.NewReader(readTestFile("keyring_privateKey", false)))
signatureBin, err = pmCrypto.SignBinDetached([]byte(signedPlainText), signingKeyRing, "") signatureBin, err = pgp.SignBinDetached([]byte(signedPlainText), signingKeyRing, "")
assert.EqualError(t, err, "pmcrypto: cannot sign message, unable to unlock signer key") assert.EqualError(t, err, "gopenpgp: cannot sign message, unable to unlock signer key")
// Password defined in keyring_test // Password defined in keyring_test
signatureBin, err = pmCrypto.SignBinDetached([]byte(signedPlainText), signingKeyRing, testMailboxPassword) signatureBin, err = pgp.SignBinDetached([]byte(signedPlainText), signingKeyRing, testMailboxPassword)
if err != nil { if err != nil {
t.Fatal("Cannot generate signature with encrypted key:", err) t.Fatal("Cannot generate signature with encrypted key:", err)
} }
@ -66,7 +66,7 @@ func TestSignBinDetached(t *testing.T) {
} }
func TestVerifyTextDetachedSig(t *testing.T) { func TestVerifyTextDetachedSig(t *testing.T) {
verified, err := pmCrypto.VerifyTextDetachedSig(signature, signedPlainText, signingKeyRing, testTime) verified, err := pgp.VerifyTextDetachedSig(signature, signedPlainText, signingKeyRing, testTime)
if err != nil { if err != nil {
t.Fatal("Cannot verify plaintext signature:", err) t.Fatal("Cannot verify plaintext signature:", err)
} }
@ -75,15 +75,14 @@ func TestVerifyTextDetachedSig(t *testing.T) {
} }
func TestVerifyTextDetachedSigWrong(t *testing.T) { func TestVerifyTextDetachedSigWrong(t *testing.T) {
verified, err := pmCrypto.VerifyTextDetachedSig(signature, "wrong text", signingKeyRing, testTime) verified, err := pgp.VerifyTextDetachedSig(signature, "wrong text", signingKeyRing, testTime)
assert.EqualError(t, err, "pmcrypto: signer is empty") assert.EqualError(t, err, "gopenpgp: signer is empty")
assert.Exactly(t, false, verified) assert.Exactly(t, false, verified)
} }
func TestVerifyBinDetachedSig(t *testing.T) { func TestVerifyBinDetachedSig(t *testing.T) {
verified, err := pmCrypto.VerifyBinDetachedSig(signatureBin, []byte(signedPlainText), signingKeyRing, testTime) verified, err := pgp.VerifyBinDetachedSig(signatureBin, []byte(signedPlainText), signingKeyRing, testTime)
if err != nil { if err != nil {
t.Fatal("Cannot verify binary signature:", err) t.Fatal("Cannot verify binary signature:", err)
} }

2
crypto/testdata/mime_privateKey vendored
View file

@ -1,5 +1,5 @@
-----BEGIN PGP PRIVATE KEY BLOCK----- -----BEGIN PGP PRIVATE KEY BLOCK-----
Version: PmCrypto.js v3.1.2 Version: GopenPGP.js v3.1.2
Comment: https://openpgpjs.org Comment: https://openpgpjs.org
xcaGBFtq/A4BEAC0VKmsQb6HKMWwcpBNaPdEDYTUOQRdA9MvaOgRqJRmxYAG xcaGBFtq/A4BEAC0VKmsQb6HKMWwcpBNaPdEDYTUOQRdA9MvaOgRqJRmxYAG

2
crypto/testdata/mime_testMessage vendored
View file

@ -98,7 +98,7 @@ QkxPQ0stLS0tLQ0KDQo=
-----------------------f0e64db835d0f5c3674df52a164b06bb-- -----------------------f0e64db835d0f5c3674df52a164b06bb--
-----------------------4a9ea9f4dad3f36079bdb3f1e7b75bd0 -----------------------4a9ea9f4dad3f36079bdb3f1e7b75bd0
Content-Type: application/pgp-signature; name="signature.asc" Content-Type: application/pgp-signature; name="signature.asc"
Content-Description: PmCrypto digital signature Content-Description: GopenPGP digital signature
Content-Disposition: attachment; filename="signature.asc" Content-Disposition: attachment; filename="signature.asc"
-----BEGIN PGP SIGNATURE----- -----BEGIN PGP SIGNATURE-----

34
crypto/time.go
View file

@ -4,41 +4,41 @@ import (
"time" "time"
) )
var pmCrypto = PmCrypto{} var pgp = GopenPGP{}
// GetPmCrypto return global PmCrypto // GetGopenPGP return global GopenPGP
func GetPmCrypto() *PmCrypto { func GetGopenPGP() *GopenPGP {
return &pmCrypto return &pgp
} }
// UpdateTime updates cached time // UpdateTime updates cached time
func (pm *PmCrypto) UpdateTime(newTime int64) { func (pgp *GopenPGP) UpdateTime(newTime int64) {
pm.latestServerTime = newTime pgp.latestServerTime = newTime
pm.latestClientTime = time.Now() pgp.latestClientTime = time.Now()
} }
// GetTimeUnix gets latest cached time // GetTimeUnix gets latest cached time
func (pm *PmCrypto) GetTimeUnix() int64 { func (pgp *GopenPGP) GetTimeUnix() int64 {
return pm.getNow().Unix() return pgp.getNow().Unix()
} }
// GetTime gets latest cached time // GetTime gets latest cached time
func (pm *PmCrypto) GetTime() time.Time { func (pgp *GopenPGP) GetTime() time.Time {
return pm.getNow() return pgp.getNow()
} }
func (pm *PmCrypto) getNow() time.Time { func (pgp *GopenPGP) getNow() time.Time {
if pm.latestServerTime > 0 && !pm.latestClientTime.IsZero() { if pgp.latestServerTime > 0 && !pgp.latestClientTime.IsZero() {
// Until is monotonic, it uses a monotonic clock in this case instead of the wall clock // Until is monotonic, it uses a monotonic clock in this case instead of the wall clock
extrapolate := int64(time.Until(pm.latestClientTime).Seconds()) extrapolate := int64(time.Until(pgp.latestClientTime).Seconds())
return time.Unix(pm.latestServerTime+extrapolate, 0) return time.Unix(pgp.latestServerTime+extrapolate, 0)
} }
return time.Now() return time.Now()
} }
func (pm *PmCrypto) getTimeGenerator() func() time.Time { func (pgp *GopenPGP) getTimeGenerator() func() time.Time {
return func() time.Time { return func() time.Time {
return pm.getNow() return pgp.getNow()
} }
} }

2
glide.yaml
View file

@ -1,4 +1,4 @@
package: proton/pmcrypto package: proton/gopenpgp
import: import:
- package: golang.org/x/crypto - package: golang.org/x/crypto
version: master version: master