From 80b347d0bc24a6eb7ad001b0519ec49312340189 Mon Sep 17 00:00:00 2001 From: Vlad Date: Mon, 15 Jan 2018 15:41:32 +0200 Subject: [PATCH] whisper: style fixes --- whisper/whisperv6/api.go | 6 +++--- whisper/whisperv6/doc.go | 14 ++++++++------ whisper/whisperv6/message.go | 27 ++++++++++++++------------- whisper/whisperv6/message_test.go | 3 ++- whisper/whisperv6/whisper.go | 12 ++++++------ whisper/whisperv6/whisper_test.go | 4 ++-- 6 files changed, 35 insertions(+), 31 deletions(-) diff --git a/whisper/whisperv6/api.go b/whisper/whisperv6/api.go index 4f38188cd1..628da793d2 100644 --- a/whisper/whisperv6/api.go +++ b/whisper/whisperv6/api.go @@ -277,7 +277,7 @@ func (api *PublicWhisperAPI) Post(ctx context.Context, req NewMessage) (bool, er if params.KeySym, err = api.w.GetSymKey(req.SymKeyID); err != nil { return false, err } - if !validateRandomData(params.KeySym, aesKeyLength) { + if !validateDataIntegrity(params.KeySym, aesKeyLength) { return false, ErrInvalidSymmetricKey } } @@ -383,7 +383,7 @@ func (api *PublicWhisperAPI) Messages(ctx context.Context, crit Criteria) (*rpc. if err != nil { return nil, err } - if !validateRandomData(key, aesKeyLength) { + if !validateDataIntegrity(key, aesKeyLength) { return nil, ErrInvalidSymmetricKey } filter.KeySym = key @@ -555,7 +555,7 @@ func (api *PublicWhisperAPI) NewMessageFilter(req Criteria) (string, error) { if keySym, err = api.w.GetSymKey(req.SymKeyID); err != nil { return "", err } - if !validateRandomData(keySym, aesKeyLength) { + if !validateDataIntegrity(keySym, aesKeyLength) { return "", ErrInvalidSymmetricKey } } diff --git a/whisper/whisperv6/doc.go b/whisper/whisperv6/doc.go index abb8012e45..45f5583b00 100644 --- a/whisper/whisperv6/doc.go +++ b/whisper/whisperv6/doc.go @@ -51,12 +51,14 @@ const ( auxFieldSizeMask = byte(3) // mask used to extract the size of auxiliary field from the flags signatureFlag = byte(4) - TopicLength = 4 // in bytes - signatureLength = 65 // in bytes - aesKeyLength = 32 // in bytes - aesNonceLength = 12 // in bytes; for more info please see cipher.gcmStandardNonceSize & aesgcm.NonceSize() - keyIdSize = 32 // in bytes - bloomFilterSize = 64 // in bytes + TopicLength = 4 // in bytes + signatureLength = 65 // in bytes + aesKeyLength = 32 // in bytes + aesNonceLength = 12 // in bytes; for more info please see cipher.gcmStandardNonceSize & aesgcm.NonceSize() + keyIdSize = 32 // in bytes + bloomFilterSize = 64 // in bytes + flagsLength = 1 + auxiliaryFieldMaxSize = 4 EnvelopeHeaderLength = 20 diff --git a/whisper/whisperv6/message.go b/whisper/whisperv6/message.go index 21849060e2..2406e3062a 100644 --- a/whisper/whisperv6/message.go +++ b/whisper/whisperv6/message.go @@ -90,17 +90,18 @@ func (msg *ReceivedMessage) isAsymmetricEncryption() bool { // NewMessage creates and initializes a non-signed, non-encrypted Whisper message. func NewSentMessage(params *MessageParams) (*sentMessage, error) { msg := sentMessage{} - msg.Raw = make([]byte, 1, 5+len(params.Payload)+len(params.Padding)+signatureLength+padSizeLimit) + msg.Raw = make([]byte, 1, + flagsLength+auxiliaryFieldMaxSize+len(params.Payload)+len(params.Padding)+signatureLength+padSizeLimit) msg.Raw[0] = 0 // set all the flags to zero - msg.addPayloadSizeField(params.Payload) + msg.addAuxiliaryField(params.Payload) msg.Raw = append(msg.Raw, params.Payload...) err := msg.appendPadding(params) return &msg, err } // appendPayloadSizeField appends the auxiliary field containing the size of payload -func (msg *sentMessage) addPayloadSizeField(payload []byte) { - fieldSize := getAuxFieldSize(payload) +func (msg *sentMessage) addAuxiliaryField(payload []byte) { + fieldSize := getAuxiliaryFieldSize(payload) field := make([]byte, 4) binary.LittleEndian.PutUint32(field, uint32(len(payload))) field = field[:fieldSize] @@ -109,7 +110,7 @@ func (msg *sentMessage) addPayloadSizeField(payload []byte) { } // getAuxFieldSize returns the number of bytes necessary to encode the size of payload -func getAuxFieldSize(payload []byte) int { +func getAuxiliaryFieldSize(payload []byte) int { s := 1 for i := len(payload); i >= 256; i /= 256 { s++ @@ -126,8 +127,8 @@ func (msg *sentMessage) appendPadding(params *MessageParams) error { return nil } - auxFieldSize := getAuxFieldSize(params.Payload) - rawSize := 1 + auxFieldSize + len(params.Payload) + auxFieldSize := getAuxiliaryFieldSize(params.Payload) + rawSize := flagsLength + auxFieldSize + len(params.Payload) if params.Src != nil { rawSize += signatureLength } @@ -138,7 +139,7 @@ func (msg *sentMessage) appendPadding(params *MessageParams) error { if err != nil { return err } - if !validateRandomData(pad, paddingSize) { + if !validateDataIntegrity(pad, paddingSize) { return errors.New("failed to generate random padding of size " + strconv.Itoa(paddingSize)) } msg.Raw = append(msg.Raw, pad...) @@ -180,7 +181,7 @@ func (msg *sentMessage) encryptAsymmetric(key *ecdsa.PublicKey) error { // encryptSymmetric encrypts a message with a topic key, using AES-GCM-256. // nonce size should be 12 bytes (see cipher.gcmStandardNonceSize). func (msg *sentMessage) encryptSymmetric(key []byte) (err error) { - if !validateRandomData(key, aesKeyLength) { + if !validateDataIntegrity(key, aesKeyLength) { return errors.New("invalid key provided for symmetric encryption, size: " + strconv.Itoa(len(key))) } block, err := aes.NewCipher(key) @@ -213,19 +214,19 @@ func generateSecureRandomData(length int) ([]byte, error) { _, err := crand.Read(x) if err != nil { return nil, err - } else if !validateRandomData(x, length) { + } else if !validateDataIntegrity(x, length) { return nil, errors.New("crypto/rand failed to generate secure random data") } _, err = mrand.Read(y) if err != nil { return nil, err - } else if !validateRandomData(y, length) { + } else if !validateDataIntegrity(y, length) { return nil, errors.New("math/rand failed to generate secure random data") } for i := 0; i < length; i++ { res[i] = x[i] ^ y[i] } - if !validateRandomData(res, length) { + if !validateDataIntegrity(res, length) { return nil, errors.New("failed to generate secure random data") } return res, nil @@ -294,7 +295,7 @@ func (msg *ReceivedMessage) decryptAsymmetric(key *ecdsa.PrivateKey) error { return err } -// Validate checks the message validity and extracts the fields in case of success. +// ValidateAndParse checks the message validity and extracts the fields in case of success. func (msg *ReceivedMessage) ValidateAndParse() bool { end := len(msg.Raw) if end < 1 { diff --git a/whisper/whisperv6/message_test.go b/whisper/whisperv6/message_test.go index 884bc71d76..0f56fbbaa1 100644 --- a/whisper/whisperv6/message_test.go +++ b/whisper/whisperv6/message_test.go @@ -438,7 +438,8 @@ func TestPaddingAppendedToSymMessagesWithSignature(t *testing.T) { // payload + flag + signature > 256. Check that the result // is padded on the next 256 boundary. msg := sentMessage{} - msg.Raw = make([]byte, 1+1+len(params.Payload)) + const auxiliaryFieldMinSize = 1 + msg.Raw = make([]byte, flagsLength+auxiliaryFieldMinSize+len(params.Payload)) err = msg.appendPadding(params) diff --git a/whisper/whisperv6/whisper.go b/whisper/whisperv6/whisper.go index 859546c671..dd498fd316 100644 --- a/whisper/whisperv6/whisper.go +++ b/whisper/whisperv6/whisper.go @@ -444,7 +444,7 @@ func (w *Whisper) GenerateSymKey() (string, error) { key, err := generateSecureRandomData(aesKeyLength) if err != nil { return "", err - } else if !validateRandomData(key, aesKeyLength) { + } else if !validateDataIntegrity(key, aesKeyLength) { return "", fmt.Errorf("error in GenerateSymKey: crypto/rand failed to generate random data") } @@ -981,13 +981,13 @@ func validatePrivateKey(k *ecdsa.PrivateKey) bool { return ValidatePublicKey(&k.PublicKey) } -// validateSymmetricKey returns false if the key contains all zeros, -// which is a simplest and the most common bug. -func validateRandomData(k []byte, expectedSize int) bool { +// validateDataIntegrity returns false if the data have the wrong or contains all zeros, +// which is the simplest and the most common bug. +func validateDataIntegrity(k []byte, expectedSize int) bool { if len(k) != expectedSize { return false } - if expectedSize > 4 && containsOnlyZeros(k) { + if expectedSize > 3 && containsOnlyZeros(k) { return false } return true @@ -1028,7 +1028,7 @@ func GenerateRandomID() (id string, err error) { if err != nil { return "", err } - if !validateRandomData(buf, keyIdSize) { + if !validateDataIntegrity(buf, keyIdSize) { return "", fmt.Errorf("error in generateRandomID: crypto/rand failed to generate random data") } id = common.Bytes2Hex(buf) diff --git a/whisper/whisperv6/whisper_test.go b/whisper/whisperv6/whisper_test.go index b10c59844e..99e5f0bbb4 100644 --- a/whisper/whisperv6/whisper_test.go +++ b/whisper/whisperv6/whisper_test.go @@ -81,7 +81,7 @@ func TestWhisperBasic(t *testing.T) { } derived := pbkdf2.Key([]byte(peerID), nil, 65356, aesKeyLength, sha256.New) - if !validateRandomData(derived, aesKeyLength) { + if !validateDataIntegrity(derived, aesKeyLength) { t.Fatalf("failed validateSymmetricKey with param = %v.", derived) } if containsOnlyZeros(derived) { @@ -448,7 +448,7 @@ func TestWhisperSymKeyManagement(t *testing.T) { if !w.HasSymKey(id2) { t.Fatalf("HasSymKey(id2) failed.") } - if !validateRandomData(k2, aesKeyLength) { + if !validateDataIntegrity(k2, aesKeyLength) { t.Fatalf("key validation failed.") } if !bytes.Equal(k1, k2) {