status-go/protocol/common/crypto.go

142 lines
3.0 KiB
Go
Raw Normal View History

package common
2020-07-03 08:02:28 +00:00
import (
"crypto/aes"
"crypto/cipher"
"crypto/ecdsa"
"crypto/rand"
"errors"
2020-07-03 08:02:28 +00:00
"io"
"math/big"
2020-07-22 07:41:40 +00:00
"golang.org/x/crypto/sha3"
"github.com/ethereum/go-ethereum/crypto/ecies"
2020-07-22 07:41:40 +00:00
"github.com/status-im/status-go/eth-node/crypto"
"github.com/status-im/status-go/eth-node/types"
2020-07-03 08:02:28 +00:00
)
2021-02-17 23:14:48 +00:00
const (
nonceLength = 12
defaultECHDSharedKeyLength = 16
2021-02-17 23:14:48 +00:00
defaultECHDMACLength = 16
)
var (
ErrInvalidCiphertextLength = errors.New("invalid cyphertext length")
letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
numberRunes = []rune("0123456789")
alphanumericRunes = append(numberRunes, letterRunes...)
)
func HashPublicKey(pk *ecdsa.PublicKey) []byte {
return Shake256(crypto.CompressPubkey(pk))
2020-07-03 08:02:28 +00:00
}
func Decrypt(cyphertext []byte, key []byte) ([]byte, error) {
2020-07-03 08:02:28 +00:00
if len(cyphertext) < nonceLength {
return nil, ErrInvalidCiphertextLength
}
c, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(c)
if err != nil {
return nil, err
}
nonce := cyphertext[:nonceLength]
return gcm.Open(nil, nonce, cyphertext[nonceLength:], nil)
}
func Encrypt(plaintext []byte, key []byte, reader io.Reader) ([]byte, error) {
2020-07-03 08:02:28 +00:00
c, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(c)
if err != nil {
return nil, err
}
nonce := make([]byte, gcm.NonceSize())
if _, err = io.ReadFull(reader, nonce); err != nil {
return nil, err
}
return gcm.Seal(nonce, nonce, plaintext, nil), nil
}
func Shake256(buf []byte) []byte {
2020-07-03 08:02:28 +00:00
h := make([]byte, 64)
sha3.ShakeSum256(h, buf)
return h
}
// IsPubKeyEqual checks that two public keys are equal
func IsPubKeyEqual(a, b *ecdsa.PublicKey) bool {
// the curve is always the same, just compare the points
return a.X.Cmp(b.X) == 0 && a.Y.Cmp(b.Y) == 0
}
2024-02-27 10:40:40 +00:00
func PubkeysToHex(keys []*ecdsa.PublicKey) []string {
var result []string
for _, k := range keys {
result = append(result, PubkeyToHex(k))
}
return result
}
func PubkeyToHex(key *ecdsa.PublicKey) string {
return types.EncodeHex(crypto.FromECDSAPub(key))
}
2021-01-11 10:32:51 +00:00
func PubkeyToHexBytes(key *ecdsa.PublicKey) types.HexBytes {
return crypto.FromECDSAPub(key)
}
func HexToPubkey(pk string) (*ecdsa.PublicKey, error) {
bytes, err := types.DecodeHex(pk)
if err != nil {
return nil, err
}
return crypto.UnmarshalPubkey(bytes)
}
func MakeECDHSharedKey(yourPrivateKey *ecdsa.PrivateKey, theirPubKey *ecdsa.PublicKey) ([]byte, error) {
return ecies.ImportECDSA(yourPrivateKey).GenerateShared(
ecies.ImportECDSAPublic(theirPubKey),
defaultECHDSharedKeyLength,
defaultECHDMACLength,
)
}
func randomString(choice []rune, n int) (string, error) {
max := big.NewInt(int64(len(choice)))
rr := rand.Reader
b := make([]rune, n)
for i := range b {
pos, err := rand.Int(rr, max)
if err != nil {
return "", err
}
b[i] = choice[pos.Int64()]
}
return string(b), nil
}
func RandomAlphabeticalString(n int) (string, error) {
return randomString(letterRunes, n)
}
func RandomAlphanumericString(n int) (string, error) {
return randomString(alphanumericRunes, n)
}