4d00656c41
* Refactor tidy of waku package
* Added deprecation warning on whisper README.md
* Appeasing the lint gods and testing is good
* Place Whisper deprecation warning in the correct package README
:facepalm
* Implementing changes after team feedback
* More offerings to the lint gods
* Remove apparently redundant context params
* Correctly handle concurrent HandlePeer err
* Revert "Remove apparently redundant context params"
This reverts commit 557dbd0d64.
* Added note to waku/api.go about context
* renamed statusoptions and removed unused global
* Removed OnNewP2PEnvelopes() from WakuHost interface
* Matched v1 Peer with new interface sig
Also changed common/helper.go to common/helpers.go
* Formatting of waku tests and some additional error handling
* Changed version to 0.53.0
* Removed redundant type declaration
* Moved TopicToBloom function into a Topic{} method
* Moved GenerateSecureRandomData() into helpers.go
112 lines
3 KiB
Go
112 lines
3 KiB
Go
package common
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
crand "crypto/rand"
|
|
"errors"
|
|
"fmt"
|
|
mrand "math/rand"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
)
|
|
|
|
// IsPubKeyEqual checks that two public keys are equal
|
|
func IsPubKeyEqual(a, b *ecdsa.PublicKey) bool {
|
|
if !ValidatePublicKey(a) {
|
|
return false
|
|
} else if !ValidatePublicKey(b) {
|
|
return false
|
|
}
|
|
// the curve is always the same, just compare the points
|
|
return a.X.Cmp(b.X) == 0 && a.Y.Cmp(b.Y) == 0
|
|
}
|
|
|
|
// ValidatePublicKey checks the format of the given public key.
|
|
func ValidatePublicKey(k *ecdsa.PublicKey) bool {
|
|
return k != nil && k.X != nil && k.Y != nil && k.X.Sign() != 0 && k.Y.Sign() != 0
|
|
}
|
|
|
|
// BytesToUintLittleEndian converts the slice to 64-bit unsigned integer.
|
|
func BytesToUintLittleEndian(b []byte) (res uint64) {
|
|
mul := uint64(1)
|
|
for i := 0; i < len(b); i++ {
|
|
res += uint64(b[i]) * mul
|
|
mul *= 256
|
|
}
|
|
return res
|
|
}
|
|
|
|
// BytesToUintBigEndian converts the slice to 64-bit unsigned integer.
|
|
func BytesToUintBigEndian(b []byte) (res uint64) {
|
|
for i := 0; i < len(b); i++ {
|
|
res *= 256
|
|
res += uint64(b[i])
|
|
}
|
|
return res
|
|
}
|
|
|
|
// ContainsOnlyZeros checks if the data contain only zeros.
|
|
func ContainsOnlyZeros(data []byte) bool {
|
|
for _, b := range data {
|
|
if b != 0 {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// GenerateSecureRandomData generates random data where extra security is required.
|
|
// The purpose of this function is to prevent some bugs in software or in hardware
|
|
// from delivering not-very-random data. This is especially useful for AES nonce,
|
|
// where true randomness does not really matter, but it is very important to have
|
|
// a unique nonce for every message.
|
|
func GenerateSecureRandomData(length int) ([]byte, error) {
|
|
x := make([]byte, length)
|
|
y := make([]byte, length)
|
|
res := make([]byte, length)
|
|
|
|
_, err := crand.Read(x)
|
|
if err != nil {
|
|
return nil, err
|
|
} else if !ValidateDataIntegrity(x, length) {
|
|
return nil, errors.New("crypto/rand failed to generate secure random data")
|
|
}
|
|
_, err = mrand.Read(y) // nolint: gosec
|
|
if err != nil {
|
|
return nil, err
|
|
} 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 !ValidateDataIntegrity(res, length) {
|
|
return nil, errors.New("failed to generate secure random data")
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
// GenerateRandomID generates a random string, which is then returned to be used as a key id
|
|
func GenerateRandomID() (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")
|
|
}
|
|
id = common.Bytes2Hex(buf)
|
|
return id, err
|
|
}
|
|
|
|
// 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 > 3 && ContainsOnlyZeros(k) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|