d4055d7830
Add validation functions and include validation checks in the annoncement process function.
133 lines
4.0 KiB
Go
133 lines
4.0 KiB
Go
package discovery
|
|
|
|
import (
|
|
"encoding/binary"
|
|
|
|
"github.com/go-errors/errors"
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
|
"github.com/lightningnetwork/lnd/lnwallet"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
"github.com/roasbeef/btcd/btcec"
|
|
)
|
|
|
|
// newProofKey constructs new announcement signature message key.
|
|
func newProofKey(chanID uint64, isRemote bool) waitingProofKey {
|
|
return waitingProofKey{
|
|
chanID: chanID,
|
|
isRemote: isRemote,
|
|
}
|
|
}
|
|
|
|
// ToBytes represents the key in the byte format.
|
|
func (k waitingProofKey) ToBytes() []byte {
|
|
var key [10]byte
|
|
|
|
var b uint8
|
|
if k.isRemote {
|
|
b = 0
|
|
} else {
|
|
b = 1
|
|
}
|
|
|
|
binary.BigEndian.PutUint64(key[:], k.chanID)
|
|
key[9] = b
|
|
|
|
return key[:]
|
|
}
|
|
|
|
// createChanAnnouncement helper function which creates the channel announcement
|
|
// by the given channeldb objects.
|
|
func createChanAnnouncement(chanProof *channeldb.ChannelAuthProof,
|
|
chanInfo *channeldb.ChannelEdgeInfo,
|
|
e1, e2 *channeldb.ChannelEdgePolicy) (
|
|
*lnwire.ChannelAnnouncement,
|
|
*lnwire.ChannelUpdateAnnouncement,
|
|
*lnwire.ChannelUpdateAnnouncement) {
|
|
// First, using the parameters of the channel, along with the
|
|
// channel authentication chanProof, we'll create re-create the
|
|
// original authenticated channel announcement.
|
|
chanID := lnwire.NewShortChanIDFromInt(chanInfo.ChannelID)
|
|
chanAnn := &lnwire.ChannelAnnouncement{
|
|
NodeSig1: chanProof.NodeSig1,
|
|
NodeSig2: chanProof.NodeSig2,
|
|
ShortChannelID: chanID,
|
|
BitcoinSig1: chanProof.BitcoinSig1,
|
|
BitcoinSig2: chanProof.BitcoinSig2,
|
|
NodeID1: chanInfo.NodeKey1,
|
|
NodeID2: chanInfo.NodeKey2,
|
|
BitcoinKey1: chanInfo.BitcoinKey1,
|
|
BitcoinKey2: chanInfo.BitcoinKey2,
|
|
}
|
|
|
|
// We'll unconditionally queue the channel's existence chanProof as
|
|
// it will need to be processed before either of the channel
|
|
// update networkMsgs.
|
|
|
|
// Since it's up to a node's policy as to whether they
|
|
// advertise the edge in dire direction, we don't create an
|
|
// advertisement if the edge is nil.
|
|
var edge1Ann, edge2Ann *lnwire.ChannelUpdateAnnouncement
|
|
if e1 != nil {
|
|
edge1Ann = &lnwire.ChannelUpdateAnnouncement{
|
|
Signature: e1.Signature,
|
|
ShortChannelID: chanID,
|
|
Timestamp: uint32(e1.LastUpdate.Unix()),
|
|
Flags: 0,
|
|
TimeLockDelta: e1.TimeLockDelta,
|
|
HtlcMinimumMsat: uint32(e1.MinHTLC),
|
|
FeeBaseMsat: uint32(e1.FeeBaseMSat),
|
|
FeeProportionalMillionths: uint32(e1.FeeProportionalMillionths),
|
|
}
|
|
}
|
|
if e2 != nil {
|
|
edge2Ann = &lnwire.ChannelUpdateAnnouncement{
|
|
Signature: e2.Signature,
|
|
ShortChannelID: chanID,
|
|
Timestamp: uint32(e2.LastUpdate.Unix()),
|
|
Flags: 1,
|
|
TimeLockDelta: e2.TimeLockDelta,
|
|
HtlcMinimumMsat: uint32(e2.MinHTLC),
|
|
FeeBaseMsat: uint32(e2.FeeBaseMSat),
|
|
FeeProportionalMillionths: uint32(e2.FeeProportionalMillionths),
|
|
}
|
|
}
|
|
|
|
return chanAnn, edge1Ann, edge2Ann
|
|
}
|
|
|
|
// copyPubKey is copying the public key and setting curve.
|
|
// NOTE: At the moment of creation the function was need only because we are
|
|
// setting the curve to nil in the read message function and in order to
|
|
// properly validate the signatures we need to set the curve again.
|
|
func copyPubKey(pub *btcec.PublicKey) *btcec.PublicKey {
|
|
return &btcec.PublicKey{
|
|
Curve: btcec.S256(),
|
|
X: pub.X,
|
|
Y: pub.Y,
|
|
}
|
|
}
|
|
|
|
// SignAnnouncement helper function which is used for signing the announce
|
|
// messages.
|
|
func SignAnnouncement(signer *lnwallet.MessageSigner,
|
|
msg lnwire.Message) (*btcec.Signature, error) {
|
|
var data []byte
|
|
var err error
|
|
switch m := msg.(type) {
|
|
case *lnwire.ChannelAnnouncement:
|
|
data, err = m.DataToSign()
|
|
case *lnwire.ChannelUpdateAnnouncement:
|
|
data, err = m.DataToSign()
|
|
case *lnwire.NodeAnnouncement:
|
|
data, err = m.DataToSign()
|
|
default:
|
|
return nil, errors.New("can't sign message " +
|
|
"of this format")
|
|
}
|
|
if err != nil {
|
|
return nil, errors.Errorf("can't get data to sign: %v", err)
|
|
}
|
|
|
|
return signer.SignData(data)
|
|
}
|