12583319996

Committed 02 Jan 2025 01:38PM UTC coverage: 57.522% (-1.1%) from 58.598%

Build # 12583319996

Build Type

Pull #9361

github

Committed by

starius

Commit Message

fn/ContextGuard: use context.AfterFunc to wait

Simplifies context cancellation handling by using context.AfterFunc instead of a
goroutine to wait for context cancellation. This approach avoids the overhead of
a goroutine during the waiting period.

For ctxQuitUnsafe, since g.quit is closed only in the Quit method (which also
cancels all associated contexts), waiting on context cancellation ensures the
same behavior without unnecessary dependency on g.quit.

Added a test to ensure that the Create method does not launch any goroutines.

Pull Request Pull Request #9361: fn: optimize context guard

Run Details

102587 of 178344 relevant lines covered (57.52%)

24734.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.89

/keychain/ecdh.go

package keychain

import (
        "crypto/sha256"

        "github.com/btcsuite/btcd/btcec/v2"
)

// NewPubKeyECDH wraps the given key of the key ring so it adheres to the
// SingleKeyECDH interface.
func NewPubKeyECDH(keyDesc KeyDescriptor, ecdh ECDHRing) *PubKeyECDH {
        return &PubKeyECDH{
                keyDesc: keyDesc,
                ecdh:    ecdh,
        }
}

// PubKeyECDH is an implementation of the SingleKeyECDH interface. It wraps an
// ECDH key ring so it can perform ECDH shared key generation against a single
// abstracted away private key.
type PubKeyECDH struct {
        keyDesc KeyDescriptor
        ecdh    ECDHRing
}

// PubKey returns the public key of the private key that is abstracted away by
// the interface.
//
// NOTE: This is part of the SingleKeyECDH interface.
func (p *PubKeyECDH) PubKey() *btcec.PublicKey {
        return p.keyDesc.PubKey
}

// ECDH performs a scalar multiplication (ECDH-like operation) between the
// abstracted private key and a remote public key. The output returned will be
// the sha256 of the resulting shared point serialized in compressed format. If
// k is our private key, and P is the public key, we perform the following
// operation:
//
//        sx := k*P
//        s := sha256(sx.SerializeCompressed())
//
// NOTE: This is part of the SingleKeyECDH interface.
func (p *PubKeyECDH) ECDH(pubKey *btcec.PublicKey) ([32]byte, error) {
        return p.ecdh.ECDH(p.keyDesc, pubKey)
}

// PrivKeyECDH is an implementation of the SingleKeyECDH in which we do have the
// full private key. This can be used to wrap a temporary key to conform to the
// SingleKeyECDH interface.
type PrivKeyECDH struct {
        // PrivKey is the private key that is used for the ECDH operation.
        PrivKey *btcec.PrivateKey
}

// PubKey returns the public key of the private key that is abstracted away by
// the interface.
//
// NOTE: This is part of the SingleKeyECDH interface.
func (p *PrivKeyECDH) PubKey() *btcec.PublicKey {
        return p.PrivKey.PubKey()
}

// ECDH performs a scalar multiplication (ECDH-like operation) between the
// abstracted private key and a remote public key. The output returned will be
// the sha256 of the resulting shared point serialized in compressed format. If
// k is our private key, and P is the public key, we perform the following
// operation:
//
//        sx := k*P
//        s := sha256(sx.SerializeCompressed())
//
// NOTE: This is part of the SingleKeyECDH interface.
func (p *PrivKeyECDH) ECDH(pub *btcec.PublicKey) ([32]byte, error) {
        var (
                pubJacobian btcec.JacobianPoint
                s           btcec.JacobianPoint
        )
        pub.AsJacobian(&pubJacobian)

        btcec.ScalarMultNonConst(&p.PrivKey.Key, &pubJacobian, &s)
        s.ToAffine()
        sPubKey := btcec.NewPublicKey(&s.X, &s.Y)
        return sha256.Sum256(sPubKey.SerializeCompressed()), nil
}

var _ SingleKeyECDH = (*PubKeyECDH)(nil)
var _ SingleKeyECDH = (*PrivKeyECDH)(nil)

1	package keychain
2
3	import (
4	"crypto/sha256"
5
6	"github.com/btcsuite/btcd/btcec/v2"
7	)
8
9	// NewPubKeyECDH wraps the given key of the key ring so it adheres to the
10	// SingleKeyECDH interface.
11	func NewPubKeyECDH(keyDesc KeyDescriptor, ecdh ECDHRing) *PubKeyECDH {	137✔
12	return &PubKeyECDH{	137✔
13	keyDesc: keyDesc,	137✔
14	ecdh: ecdh,	137✔
15	}	137✔
16	}	137✔
17
18	// PubKeyECDH is an implementation of the SingleKeyECDH interface. It wraps an
19	// ECDH key ring so it can perform ECDH shared key generation against a single
20	// abstracted away private key.
21	type PubKeyECDH struct {
22	keyDesc KeyDescriptor
23	ecdh ECDHRing
24	}
25
26	// PubKey returns the public key of the private key that is abstracted away by
27	// the interface.
28	//
29	// NOTE: This is part of the SingleKeyECDH interface.
30	func (p PubKeyECDH) PubKey() btcec.PublicKey {	517✔
31	return p.keyDesc.PubKey	517✔
32	}	517✔
33
34	// ECDH performs a scalar multiplication (ECDH-like operation) between the
35	// abstracted private key and a remote public key. The output returned will be
36	// the sha256 of the resulting shared point serialized in compressed format. If
37	// k is our private key, and P is the public key, we perform the following
38	// operation:
39	//
40	// sx := k*P
41	// s := sha256(sx.SerializeCompressed())
42	//
43	// NOTE: This is part of the SingleKeyECDH interface.
44	func (p PubKeyECDH) ECDH(pubKey btcec.PublicKey) ([32]byte, error) {	×
45	return p.ecdh.ECDH(p.keyDesc, pubKey)	×
46	}	×
47
48	// PrivKeyECDH is an implementation of the SingleKeyECDH in which we do have the
49	// full private key. This can be used to wrap a temporary key to conform to the
50	// SingleKeyECDH interface.
51	type PrivKeyECDH struct {
52	// PrivKey is the private key that is used for the ECDH operation.
53	PrivKey *btcec.PrivateKey
54	}
55
56	// PubKey returns the public key of the private key that is abstracted away by
57	// the interface.
58	//
59	// NOTE: This is part of the SingleKeyECDH interface.
60	func (p PrivKeyECDH) PubKey() btcec.PublicKey {	768✔
61	return p.PrivKey.PubKey()	768✔
62	}	768✔
63
64	// ECDH performs a scalar multiplication (ECDH-like operation) between the
65	// abstracted private key and a remote public key. The output returned will be
66	// the sha256 of the resulting shared point serialized in compressed format. If
67	// k is our private key, and P is the public key, we perform the following
68	// operation:
69	//
70	// sx := k*P
71	// s := sha256(sx.SerializeCompressed())
72	//
73	// NOTE: This is part of the SingleKeyECDH interface.
74	func (p PrivKeyECDH) ECDH(pub btcec.PublicKey) ([32]byte, error) {	2,027✔
75	var (	2,027✔
76	pubJacobian btcec.JacobianPoint	2,027✔
77	s btcec.JacobianPoint	2,027✔
78	)	2,027✔
79	pub.AsJacobian(&pubJacobian)	2,027✔
80		2,027✔
81	btcec.ScalarMultNonConst(&p.PrivKey.Key, &pubJacobian, &s)	2,027✔
82	s.ToAffine()	2,027✔
83	sPubKey := btcec.NewPublicKey(&s.X, &s.Y)	2,027✔
84	return sha256.Sum256(sPubKey.SerializeCompressed()), nil	2,027✔
85	}	2,027✔
86
87	var _ SingleKeyECDH = (*PubKeyECDH)(nil)
88	var _ SingleKeyECDH = (*PrivKeyECDH)(nil)

lightningnetwork / lnd / 12583319996

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous