Mirroristas/kaspad
2
0
Fork 0
mirror of https://github.com/kaspanet/kaspad.git synced 2025-11-24 14:35:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge 02e9cf6fd62a3eca00a3562ddb798f337f1a4269 into 92574e623f0741d57d6a097498866dd21c5ce6da

Browse Source
This commit is contained in:
Unwired 2023-12-04 12:59:18 +00:00 committed by GitHub
commit cf04a31989
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 41 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
cmd/kaspawallet/daemon/server/send.go
View File

@ -17,7 +17,8 @@ func (s *server) Send(_ context.Context, request *pb.SendRequest) (*pb.SendRespo
return nil, err return nil, err
} }
signedTransactions, err := s.signTransactions(unsignedTransactions, request.Password) //TODO fix passphrase
signedTransactions, err := s.signTransactions(unsignedTransactions, request.Password, "")
if err != nil { if err != nil {
return nil, err return nil, err
} }

7
cmd/kaspawallet/daemon/server/sign.go
View File

@ -12,21 +12,22 @@ func (s *server) Sign(_ context.Context, request *pb.SignRequest) (*pb.SignRespo
s.lock.Lock() s.lock.Lock()
defer s.lock.Unlock() defer s.lock.Unlock()
signedTransactions, err := s.signTransactions(request.UnsignedTransactions, request.Password) //TODO: fix SignRequest pashphrase
signedTransactions, err := s.signTransactions(request.UnsignedTransactions, request.Password, "")
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &pb.SignResponse{SignedTransactions: signedTransactions}, nil return &pb.SignResponse{SignedTransactions: signedTransactions}, nil
} }
func (s *server) signTransactions(unsignedTransactions [][]byte, password string) ([][]byte, error) { func (s *server) signTransactions(unsignedTransactions [][]byte, password string, passphrase string) ([][]byte, error) {
mnemonics, err := s.keysFile.DecryptMnemonics(password) mnemonics, err := s.keysFile.DecryptMnemonics(password)
if err != nil { if err != nil {
return nil, err return nil, err
} }
signedTransactions := make([][]byte, len(unsignedTransactions)) signedTransactions := make([][]byte, len(unsignedTransactions))
for i, unsignedTransaction := range unsignedTransactions { for i, unsignedTransaction := range unsignedTransactions {
signedTransaction, err := libkaspawallet.Sign(s.params, mnemonics, unsignedTransaction, s.keysFile.ECDSA) signedTransaction, err := libkaspawallet.Sign(s.params, mnemonics, []string{passphrase}, unsignedTransaction, s.keysFile.ECDSA)
if err != nil { if err != nil {
return nil, err return nil, err
} }

4
cmd/kaspawallet/daemon/server/split_transaction_test.go
View File

@ -43,12 +43,12 @@ func TestEstimateMassAfterSignatures(t *testing.T) {
t.Fatalf("Error from estimateMassAfterSignatures: %s", err) t.Fatalf("Error from estimateMassAfterSignatures: %s", err)
} }
signedTxStep1Bytes, err := libkaspawallet.Sign(params, mnemonics[:1], unsignedTransactionBytes, false) signedTxStep1Bytes, err := libkaspawallet.Sign(params, mnemonics[:1], []string{""}, unsignedTransactionBytes, false)
if err != nil { if err != nil {
t.Fatalf("Sign: %+v", err) t.Fatalf("Sign: %+v", err)
} }
signedTxStep2Bytes, err := libkaspawallet.Sign(params, mnemonics[1:2], signedTxStep1Bytes, false) signedTxStep2Bytes, err := libkaspawallet.Sign(params, mnemonics[1:2], []string{""}, signedTxStep1Bytes, false)
if err != nil { if err != nil {
t.Fatalf("Sign: %+v", err) t.Fatalf("Sign: %+v", err)
} }

4
cmd/kaspawallet/dump_unencrypted_data.go
View File

@ -33,10 +33,12 @@ func dumpUnencryptedData(conf *dumpUnencryptedDataConfig) error {
return err return err
} }
mnemonicPublicKeys := make(map[string]struct{}) mnemonicPublicKeys := make(map[string]struct{})
for i, mnemonic := range mnemonics { for i, mnemonic := range mnemonics {
passphrase := keys.GetPassphrase("Passphrase:")
fmt.Printf("Mnemonic #%d:\n%s\n\n", i+1, mnemonic) fmt.Printf("Mnemonic #%d:\n%s\n\n", i+1, mnemonic)
publicKey, err := libkaspawallet.MasterPublicKeyFromMnemonic(conf.NetParams(), mnemonic, len(keysFile.ExtendedPublicKeys) > 1) publicKey, err := libkaspawallet.MasterPublicKeyFromMnemonic(conf.NetParams(), mnemonic, passphrase, len(keysFile.ExtendedPublicKeys) > 1)
if err != nil { if err != nil {
return err return err
} }

8
cmd/kaspawallet/keys/create.go
View File

@ -65,7 +65,13 @@ func encryptedMnemonicExtendedPublicKeyPairs(params *dagconfig.Params, mnemonics
extendedPublicKeys = make([]string, 0, len(mnemonics)) extendedPublicKeys = make([]string, 0, len(mnemonics))
for _, mnemonic := range mnemonics { for _, mnemonic := range mnemonics {
extendedPublicKey, err := libkaspawallet.MasterPublicKeyFromMnemonic(params, mnemonic, isMultisig) passphrase := []byte(GetPassword("Enter passphrase for the key file:"))
confirmPassphrase := []byte(GetPassphrase("Confirm passphrase:"))
if subtle.ConstantTimeCompare(passphrase, confirmPassphrase) != 1 {
return nil, nil, errors.New("Passphrases are not identical")
}
extendedPublicKey, err := libkaspawallet.MasterPublicKeyFromMnemonic(params, mnemonic, string(passphrase), isMultisig)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }

4
cmd/kaspawallet/keys/get_password.go
View File

@ -40,3 +40,7 @@ func GetPassword(prompt string) string {
return string(p) return string(p)
} }
func GetPassphrase(prompt string) string {
return GetPassword(prompt);
}

8
cmd/kaspawallet/libkaspawallet/bip39.go
View File

@ -36,9 +36,9 @@ func defaultPath(isMultisig bool) string {
} }
// MasterPublicKeyFromMnemonic returns the master public key with the correct derivation for the given mnemonic. // MasterPublicKeyFromMnemonic returns the master public key with the correct derivation for the given mnemonic.
func MasterPublicKeyFromMnemonic(params *dagconfig.Params, mnemonic string, isMultisig bool) (string, error) { func MasterPublicKeyFromMnemonic(params *dagconfig.Params, mnemonic string, passphrase string, isMultisig bool) (string, error) {
path := defaultPath(isMultisig) path := defaultPath(isMultisig)
extendedKey, err := extendedKeyFromMnemonicAndPath(mnemonic, path, params) extendedKey, err := extendedKeyFromMnemonicAndPath(mnemonic, path, passphrase, params)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -51,8 +51,8 @@ func MasterPublicKeyFromMnemonic(params *dagconfig.Params, mnemonic string, isMu
return extendedPublicKey.String(), nil return extendedPublicKey.String(), nil
} }
func extendedKeyFromMnemonicAndPath(mnemonic string, path string, params *dagconfig.Params) (*bip32.ExtendedKey, error) { func extendedKeyFromMnemonicAndPath(mnemonic string, path string, passphrase string, params *dagconfig.Params) (*bip32.ExtendedKey, error) {
seed := bip39.NewSeed(mnemonic, "") seed := bip39.NewSeed(mnemonic, passphrase)
version, err := versionFromParams(params) version, err := versionFromParams(params)
if err != nil { if err != nil {
return nil, err return nil, err

10
cmd/kaspawallet/libkaspawallet/sign.go
View File

@ -28,14 +28,14 @@ func rawTxInSignature(extendedKey *bip32.ExtendedKey, tx *externalapi.DomainTran
} }
// Sign signs the transaction with the given private keys // Sign signs the transaction with the given private keys
func Sign(params *dagconfig.Params, mnemonics []string, serializedPSTx []byte, ecdsa bool) ([]byte, error) { func Sign(params *dagconfig.Params, mnemonics []string, passphrases []string, serializedPSTx []byte, ecdsa bool) ([]byte, error) {
partiallySignedTransaction, err := serialization.DeserializePartiallySignedTransaction(serializedPSTx) partiallySignedTransaction, err := serialization.DeserializePartiallySignedTransaction(serializedPSTx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
for _, mnemonic := range mnemonics { for i, mnemonic := range mnemonics {
err = sign(params, mnemonic, partiallySignedTransaction, ecdsa) err = sign(params, mnemonic, passphrases[i], partiallySignedTransaction, ecdsa)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -43,7 +43,7 @@ func Sign(params *dagconfig.Params, mnemonics []string, serializedPSTx []byte, e
return serialization.SerializePartiallySignedTransaction(partiallySignedTransaction) return serialization.SerializePartiallySignedTransaction(partiallySignedTransaction)
} }
func sign(params *dagconfig.Params, mnemonic string, partiallySignedTransaction *serialization.PartiallySignedTransaction, ecdsa bool) error { func sign(params *dagconfig.Params, mnemonic string, passphrase string, partiallySignedTransaction *serialization.PartiallySignedTransaction, ecdsa bool) error {
if isTransactionFullySigned(partiallySignedTransaction) { if isTransactionFullySigned(partiallySignedTransaction) {
return nil return nil
} }
@ -64,7 +64,7 @@ func sign(params *dagconfig.Params, mnemonic string, partiallySignedTransaction
for i, partiallySignedInput := range partiallySignedTransaction.PartiallySignedInputs { for i, partiallySignedInput := range partiallySignedTransaction.PartiallySignedInputs {
isMultisig := len(partiallySignedInput.PubKeySignaturePairs) > 1 isMultisig := len(partiallySignedInput.PubKeySignaturePairs) > 1
path := defaultPath(isMultisig) path := defaultPath(isMultisig)
extendedKey, err := extendedKeyFromMnemonicAndPath(mnemonic, path, params) extendedKey, err := extendedKeyFromMnemonicAndPath(mnemonic, path, passphrase, params)
if err != nil { if err != nil {
return err return err
} }

12
cmd/kaspawallet/libkaspawallet/transaction_test.go
View File

@ -125,7 +125,7 @@ func TestMultisig(t *testing.T) {
t.Fatal("Unexpectedly succeed to extract a valid transaction out of unsigned transaction") t.Fatal("Unexpectedly succeed to extract a valid transaction out of unsigned transaction")
} }
signedTxStep1, err := libkaspawallet.Sign(params, mnemonics[:1], unsignedTransaction, ecdsa) signedTxStep1, err := libkaspawallet.Sign(params, mnemonics[:1], []string{""}, unsignedTransaction, ecdsa)
if err != nil { if err != nil {
t.Fatalf("Sign: %+v", err) t.Fatalf("Sign: %+v", err)
} }
@ -139,7 +139,7 @@ func TestMultisig(t *testing.T) {
t.Fatalf("Transaction is not expected to be fully signed") t.Fatalf("Transaction is not expected to be fully signed")
} }
signedTxStep2, err := libkaspawallet.Sign(params, mnemonics[1:2], signedTxStep1, ecdsa) signedTxStep2, err := libkaspawallet.Sign(params, mnemonics[1:2], []string{""}, signedTxStep1, ecdsa)
if err != nil { if err != nil {
t.Fatalf("Sign: %+v", err) t.Fatalf("Sign: %+v", err)
} }
@ -149,7 +149,7 @@ func TestMultisig(t *testing.T) {
t.Fatalf("ExtractTransaction: %+v", err) t.Fatalf("ExtractTransaction: %+v", err)
} }
signedTxOneStep, err := libkaspawallet.Sign(params, mnemonics[:2], unsignedTransaction, ecdsa) signedTxOneStep, err := libkaspawallet.Sign(params, mnemonics[:2], []string{""}, unsignedTransaction, ecdsa)
if err != nil { if err != nil {
t.Fatalf("Sign: %+v", err) t.Fatalf("Sign: %+v", err)
} }
@ -286,7 +286,7 @@ func TestP2PK(t *testing.T) {
t.Fatal("Unexpectedly succeed to extract a valid transaction out of unsigned transaction") t.Fatal("Unexpectedly succeed to extract a valid transaction out of unsigned transaction")
} }
signedTx, err := libkaspawallet.Sign(params, mnemonics, unsignedTransaction, ecdsa) signedTx, err := libkaspawallet.Sign(params, mnemonics, []string{""}, unsignedTransaction, ecdsa)
if err != nil { if err != nil {
t.Fatalf("Sign: %+v", err) t.Fatalf("Sign: %+v", err)
} }
@ -434,7 +434,7 @@ func TestMaxSompi(t *testing.T) {
t.Fatalf("CreateUnsignedTransactions: %+v", err) t.Fatalf("CreateUnsignedTransactions: %+v", err)
} }
signedTxWithLargeInputAmount, err := libkaspawallet.Sign(params, mnemonics, unsignedTxWithLargeInputAmount, false) signedTxWithLargeInputAmount, err := libkaspawallet.Sign(params, mnemonics, []string{""}, unsignedTxWithLargeInputAmount, false)
if err != nil { if err != nil {
t.Fatalf("Sign: %+v", err) t.Fatalf("Sign: %+v", err)
} }
@ -485,7 +485,7 @@ func TestMaxSompi(t *testing.T) {
t.Fatalf("CreateUnsignedTransactions: %+v", err) t.Fatalf("CreateUnsignedTransactions: %+v", err)
} }
signedTxWithLargeInputAndOutputAmount, err := libkaspawallet.Sign(params, mnemonics, unsignedTxWithLargeInputAndOutputAmount, false) signedTxWithLargeInputAndOutputAmount, err := libkaspawallet.Sign(params, mnemonics, []string{""}, unsignedTxWithLargeInputAndOutputAmount, false)
if err != nil { if err != nil {
t.Fatalf("Sign: %+v", err) t.Fatalf("Sign: %+v", err)
} }

3
cmd/kaspawallet/send.go
View File

@ -64,7 +64,8 @@ func send(conf *sendConfig) error {
signedTransactions := make([][]byte, len(createUnsignedTransactionsResponse.UnsignedTransactions)) signedTransactions := make([][]byte, len(createUnsignedTransactionsResponse.UnsignedTransactions))
for i, unsignedTransaction := range createUnsignedTransactionsResponse.UnsignedTransactions { for i, unsignedTransaction := range createUnsignedTransactionsResponse.UnsignedTransactions {
signedTransaction, err := libkaspawallet.Sign(conf.NetParams(), mnemonics, unsignedTransaction, keysFile.ECDSA) passphrase := keys.GetPassphrase("Passphrase:")
signedTransaction, err := libkaspawallet.Sign(conf.NetParams(), mnemonics, []string{passphrase}, unsignedTransaction, keysFile.ECDSA)
if err != nil { if err != nil {
return err return err
} }

3
cmd/kaspawallet/sign.go
View File

@ -47,8 +47,9 @@ func sign(conf *signConfig) error {
updatedPartiallySignedTransactions := make([][]byte, len(partiallySignedTransactions)) updatedPartiallySignedTransactions := make([][]byte, len(partiallySignedTransactions))
for i, partiallySignedTransaction := range partiallySignedTransactions { for i, partiallySignedTransaction := range partiallySignedTransactions {
passphrase := keys.GetPassphrase("Passphrase:")
updatedPartiallySignedTransactions[i], err = updatedPartiallySignedTransactions[i], err =
libkaspawallet.Sign(conf.NetParams(), privateKeys, partiallySignedTransaction, keysFile.ECDSA) libkaspawallet.Sign(conf.NetParams(), privateKeys, []string{passphrase}, partiallySignedTransaction, keysFile.ECDSA)
if err != nil { if err != nil {
return err return err
} }