mirror of
https://github.com/aljazceru/ark.git
synced 2026-01-10 23:34:19 +01:00
89df461623
* Add bitcoin networks * Refactor client * Refactor explorer * Refactor store * Refactor wallet * Refactor sdk client * Refactor wasm & Update examples * Move common util funcs to internal/utils * Move to constants for service types * Add unit tests * Parallelize tests * Lint * Add job to gh action * go mod tidy * Fixes * Fixes * Fix compose file * Fixes * Fixes after review: * Drop factory pattern * Drop password from ark client methods * Make singlekey wallet manage store and wallet store instead of defining WalletStore as extension of Store * Move constants to arksdk module * Drop config and expect directory store and wallet as ark client factory args * Fix * Add constants for bitcoin/liquid explorer * Fix test * Fix wasm * Rename client.Client to client.ASPClient * Rename store.Store to store.ConfigStore * Rename wallet.Wallet to wallet.WalletService * Renamings * Lint * Fixes * Move everything to internal/utils & move ComputeVtxoTaprootScript to common * Go mod tidy
117 lines
2.7 KiB
Go
117 lines
2.7 KiB
Go
package utils
|
|
|
|
import (
|
|
"crypto/aes"
|
|
"crypto/cipher"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"fmt"
|
|
"runtime/debug"
|
|
|
|
"github.com/btcsuite/btcd/btcec/v2"
|
|
"github.com/decred/dcrd/dcrec/secp256k1/v4"
|
|
"golang.org/x/crypto/scrypt"
|
|
)
|
|
|
|
func GenerateRandomPrivateKey() (*secp256k1.PrivateKey, error) {
|
|
privKey, err := btcec.NewPrivateKey()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return privKey, nil
|
|
}
|
|
|
|
func HashPassword(password []byte) []byte {
|
|
hash := sha256.Sum256(password)
|
|
return hash[:]
|
|
}
|
|
|
|
func EncryptAES128(privateKey, password []byte) ([]byte, error) {
|
|
// Due to https://github.com/golang/go/issues/7168.
|
|
// This call makes sure that memory is freed in case the GC doesn't do that
|
|
// right after the encryption/decryption.
|
|
defer debug.FreeOSMemory()
|
|
|
|
if len(privateKey) == 0 {
|
|
return nil, fmt.Errorf("missing plaintext private key")
|
|
}
|
|
if len(password) == 0 {
|
|
return nil, fmt.Errorf("missing encryption password")
|
|
}
|
|
|
|
key, salt, err := deriveKey(password, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
blockCipher, err := aes.NewCipher(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
gcm, err := cipher.NewGCM(blockCipher)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
nonce := make([]byte, gcm.NonceSize())
|
|
if _, err = rand.Read(nonce); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
ciphertext := gcm.Seal(nonce, nonce, privateKey, nil)
|
|
ciphertext = append(ciphertext, salt...)
|
|
|
|
return ciphertext, nil
|
|
}
|
|
|
|
func DecryptAES128(encrypted, password []byte) ([]byte, error) {
|
|
defer debug.FreeOSMemory()
|
|
|
|
if len(encrypted) == 0 {
|
|
return nil, fmt.Errorf("missing encrypted mnemonic")
|
|
}
|
|
if len(password) == 0 {
|
|
return nil, fmt.Errorf("missing decryption password")
|
|
}
|
|
|
|
salt := encrypted[len(encrypted)-32:]
|
|
data := encrypted[:len(encrypted)-32]
|
|
|
|
key, _, err := deriveKey(password, salt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
blockCipher, err := aes.NewCipher(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
gcm, err := cipher.NewGCM(blockCipher)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
nonce, text := data[:gcm.NonceSize()], data[gcm.NonceSize():]
|
|
plaintext, err := gcm.Open(nil, nonce, text, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid password")
|
|
}
|
|
return plaintext, nil
|
|
}
|
|
|
|
// deriveKey derives a 32 byte array key from a custom passhprase
|
|
func deriveKey(password, salt []byte) ([]byte, []byte, error) {
|
|
if salt == nil {
|
|
salt = make([]byte, 32)
|
|
if _, err := rand.Read(salt); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
}
|
|
// 2^20 = 1048576 recommended length for key-stretching
|
|
// check the doc for other recommended values:
|
|
// https://godoc.org/golang.org/x/crypto/scrypt
|
|
key, err := scrypt.Key(password, salt, 1048576, 8, 1, 32)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return key, salt, nil
|
|
}
|