more pr ethersphere#1731 comments

Author: kortatu

pss/crypto/crypto.go

@@ -372,7 +372,7 @@ func (crypto *defaultCryptoBackend) GenerateSymKey() (string, error) {
 		return "", fmt.Errorf("error in GenerateSymKey: crypto/rand failed to generate random data")
 	}
 
-	id, err := generateRandomID()
+	id, err := generateRandomKeyID()
 	if err != nil {
 		return "", fmt.Errorf("failed to generate ID: %s", err)
 	}
@@ -387,13 +387,13 @@ func (crypto *defaultCryptoBackend) GenerateSymKey() (string, error) {
 	return id, nil
 }
 
-// Add a symmetric key ti the store generating an id and returning it
+// Add a symmetric key to the store generating an id and returning it
 func (crypto *defaultCryptoBackend) AddSymKey(key []byte) (string, error) {
 	if len(key) != aesKeyLength {
 		return "", fmt.Errorf("wrong key size: %d", len(key))
 	}
 
-	id, err := generateRandomID()
+	id, err := generateRandomKeyID()
 	if err != nil {
 		return "", fmt.Errorf("failed to generate ID: %s", err)
 	}
@@ -460,7 +460,7 @@ func (crypto *defaultCryptoBackend) encryptAsymmetric(rawBytes []byte, key *ecds
 	if !validatePublicKey(key) {
 		return nil, errInvalidPubkey
 	}
-	encrypted, err := ecies.Encrypt(crand.Reader, crypto.importECDSAPublic(key), rawBytes, nil, nil)
+	encrypted, err := ecies.Encrypt(crand.Reader, crypto.fromECDSAtoECIESPublic(key), rawBytes, nil, nil)
 	if err == nil {
 		return encrypted, nil
 	}
@@ -497,25 +497,26 @@ func (crypto *defaultCryptoBackend) signHash(hash []byte, prv *ecdsa.PrivateKey)
 	return ethCrypto.Sign(hash, prv)
 }
 
-// Obtain public key from the signed message and the signature
+// sigToPub obtains public key from the signed message and the signature
 func (crypto *defaultCryptoBackend) sigToPub(signed, sig []byte) (*ecdsa.PublicKey, error) {
 	defer func() { recover() }() // in case of invalid signature
 	hash := crypto.keccak256(signed)
 	return ethCrypto.SigToPub(hash, sig)
 }
 
-func (crypto *defaultCryptoBackend) importECDSAPublic(key *ecdsa.PublicKey) *ecies.PublicKey {
+// fromECDSAtoECIESPublic converts a ecdsa public key to the format needed by the crypti/ecies package
+func (crypto *defaultCryptoBackend) fromECDSAtoECIESPublic(key *ecdsa.PublicKey) *ecies.PublicKey {
 	return ecies.ImportECDSAPublic(key)
 }
 
-// GenerateRandomID generates a random string, which is then returned to be used as a key id
-func generateRandomID() (id string, err error) {
+// generateRandomKeyID generates a random string, which is then returned to be used as a key id
+func generateRandomKeyID() (id string, err error) {
 	buf, err := generateSecureRandomData(keyIDSize)
 	if err != nil {
 		return "", err
 	}
 	if !validateDataIntegrity(buf, keyIDSize) {
-		return "", fmt.Errorf("error in generateRandomID: crypto/rand failed to generate random data")
+		return "", fmt.Errorf("error in generateRandomKeyID: crypto/rand failed to generate random data")
 	}
 	id = common.Bytes2Hex(buf)
 	return id, err

pss/crypto/utils.go

@@ -18,12 +18,12 @@ package crypto
 import (
 	"crypto/ecdsa"
 	"fmt"
-	"sync"
-
 	ethCrypto "github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/whisper/whisperv6"
+	"sync"
 )
 
-// Utils contains utility methods for tests. Generates and stores asymmetric keys
+// Utils contains utility methods only for testing. Generates and stores asymmetric keys
 type Utils interface {
 	GenerateKey() (*ecdsa.PrivateKey, error)
 	NewKeyPair() (string, error)
@@ -32,7 +32,7 @@ type Utils interface {
 
 type utils struct {
 	privateKeys map[string]*ecdsa.PrivateKey // Private key storage
-	keyMu       sync.RWMutex                 // Mutex associated with private key storage1111111111111111111111111111111
+	keyMu       sync.RWMutex                 // Mutex associated with private key storage
 }
 
 func NewUtils() Utils {
@@ -60,7 +60,7 @@ func (utils *utils) NewKeyPair() (string, error) {
 		return "", fmt.Errorf("failed to generate valid key")
 	}
 
-	id, err := generateRandomID()
+	id, err := generateRandomKeyID()
 	if err != nil {
 		return "", fmt.Errorf("failed to generate ID: %s", err)
 	}
@@ -77,6 +77,7 @@ func (utils *utils) NewKeyPair() (string, error) {
 
 // GetPrivateKey return a PrivateKey previously generated in NewKeyPair by id
 func (utils *utils) GetPrivateKey(id string) (*ecdsa.PrivateKey, error) {
+	whisperv6.NewSentMessage()
 	utils.keyMu.RLock()
 	defer utils.keyMu.RUnlock()
 	key := utils.privateKeys[id]

pss/keystore.go

@@ -143,10 +143,9 @@ func (ks *KeyStore) getPeerAddress(keyid string, topic Topic) (PssAddress, error
 }
 
 // Attempt to decrypt, validate and unpack a symmetrically encrypted message.
-// If successful, returns the unpacked receivedMessage struct
-// encapsulating the decrypted message, and the id
+// If successful, returns the payload of the message and the id
 // of the symmetric key used to decrypt the message.
-// It fails if decryption of the message fails or if the message is corrupted.
+// It fails if decryption of the message fails or if the message is corrupted/not valid.
 func (ks *KeyStore) processSym(pssMsg *PssMsg) ([]byte, string, PssAddress, error) {
 	metrics.GetOrRegisterCounter("pss.process.sym", nil).Inc(1)
 
@@ -182,8 +181,7 @@ func (ks *KeyStore) processSym(pssMsg *PssMsg) ([]byte, string, PssAddress, erro
 }
 
 // Attempt to decrypt, validate and unpack an asymmetrically encrypted message.
-// If successful, returns the unpacked receivedMessage struct
-// encapsulating the decrypted message, and the byte representation of
+// If successful, returns the payload of the message and the hex representation of
 // the public key used to decrypt the message.
 // It fails if decryption of message fails, or if the message is corrupted.
 func (p *Pss) processAsym(pssMsg *PssMsg) ([]byte, string, PssAddress, error) {