13211764208

Committed 08 Feb 2025 03:08AM UTC coverage: 49.288% (-9.5%) from 58.815%

Build # 13211764208

Build Type

Pull #9489

github

Committed by

calvinrzachman

Commit Message

itest: verify switchrpc server enforces send then track

We prevent the rpc server from allowing onion dispatches for
attempt IDs which have already been tracked by rpc clients.

This helps protect the client from leaking a duplicate onion
attempt. NOTE: This is not the only method for solving this
issue! The issue could be addressed via careful client side
programming which accounts for the uncertainty and async
nature of dispatching onions to a remote process via RPC.
This would require some lnd ChannelRouter changes for how
we intend to use these RPCs though.

Pull Request Pull Request #9489: multi: add BuildOnion, SendOnion, and TrackOnion RPCs

Run Details

474 of 990 new or added lines in 11 files covered. (47.88%)

27321 existing lines in 435 files now uncovered.

101192 of 205306 relevant lines covered (49.29%)

1.54 hits per line

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

73.33

/chanfitness/rate_limit.go

package chanfitness

import (
        "math"
        "time"
)

const (
        // rateLimitScale is the number of events we allow per rate limited
        // tier. Increasing this value makes our rate limiting more lenient,
        // decreasing it makes us less lenient.
        rateLimitScale = 200

        // flapCountCooldownFactor is the factor by which we decrease a peer's
        // flap count if they have not flapped for the cooldown period.
        flapCountCooldownFactor = 0.95

        // flapCountCooldownPeriod is the amount of time that we require a peer
        // has not flapped for before we reduce their all time flap count using
        // our cooldown factor.
        flapCountCooldownPeriod = time.Hour * 8
)

// rateLimits is the set of rate limit tiers we apply to our peers based on
// their flap count. A peer can be placed in their tier by dividing their flap
// count by the rateLimitScale and returning the value at that index.
var rateLimits = []time.Duration{
        time.Second,
        time.Second * 5,
        time.Second * 30,
        time.Minute,
        time.Minute * 30,
        time.Hour,
}

// getRateLimit returns the value of the rate limited tier that we are on based
// on current flap count. If a peer's flap count exceeds the top tier, we just
// return our highest tier.
func getRateLimit(flapCount int) time.Duration {
        // Figure out the tier we fall into based on our current flap count.
        tier := flapCount / rateLimitScale

        // If we have more events than our number of tiers, we just use the
        // last tier
        tierLen := len(rateLimits)
        if tier >= tierLen {
                tier = tierLen - 1
        }

        return rateLimits[tier]
}

// cooldownFlapCount takes a timestamped flap count, and returns its value
// scaled down by our cooldown factor if at least our cooldown period has
// elapsed since the peer last flapped. We do this because we store all-time
// flap count for peers, and want to allow downgrading of peers that have not
// flapped for a long time.
func cooldownFlapCount(now time.Time, flapCount int,
        lastFlap time.Time) int {

        // Calculate time since our last flap, and the number of times we need
        // to apply our cooldown factor.
        timeSinceFlap := now.Sub(lastFlap)

        // If our cooldown period has not elapsed yet, we just return our flap
        // count. We allow fractional cooldown periods once this period has
        // elapsed, so we do not want to apply a fractional cooldown before the
        // full cooldown period has elapsed.
        if timeSinceFlap < flapCountCooldownPeriod {
                return flapCount
        }

        // Get the factor by which we need to cooldown our flap count. If
        // insufficient time has passed to cooldown our flap count. Use use a
        // float so that we allow fractional cooldown periods.
        cooldownPeriods := float64(timeSinceFlap) /
                float64(flapCountCooldownPeriod)

        effectiveFactor := math.Pow(flapCountCooldownFactor, cooldownPeriods)

        return int(float64(flapCount) * effectiveFactor)
}

1	package chanfitness
2
3	import (
4	"math"
5	"time"
6	)
7
8	const (
9	// rateLimitScale is the number of events we allow per rate limited
10	// tier. Increasing this value makes our rate limiting more lenient,
11	// decreasing it makes us less lenient.
12	rateLimitScale = 200
13
14	// flapCountCooldownFactor is the factor by which we decrease a peer's
15	// flap count if they have not flapped for the cooldown period.
16	flapCountCooldownFactor = 0.95
17
18	// flapCountCooldownPeriod is the amount of time that we require a peer
19	// has not flapped for before we reduce their all time flap count using
20	// our cooldown factor.
21	flapCountCooldownPeriod = time.Hour * 8
22	)
23
24	// rateLimits is the set of rate limit tiers we apply to our peers based on
25	// their flap count. A peer can be placed in their tier by dividing their flap
26	// count by the rateLimitScale and returning the value at that index.
27	var rateLimits = []time.Duration{
28	time.Second,
29	time.Second * 5,
30	time.Second * 30,
31	time.Minute,
32	time.Minute * 30,
33	time.Hour,
34	}
35
36	// getRateLimit returns the value of the rate limited tier that we are on based
37	// on current flap count. If a peer's flap count exceeds the top tier, we just
38	// return our highest tier.
39	func getRateLimit(flapCount int) time.Duration {	3✔
40	// Figure out the tier we fall into based on our current flap count.	3✔
41	tier := flapCount / rateLimitScale	3✔
42		3✔
43	// If we have more events than our number of tiers, we just use the	3✔
44	// last tier	3✔
45	tierLen := len(rateLimits)	3✔
46	if tier >= tierLen {	3✔
UNCOV 47	tier = tierLen - 1	×
UNCOV 48	}	×
49
50	return rateLimits[tier]	3✔
51	}
52
53	// cooldownFlapCount takes a timestamped flap count, and returns its value
54	// scaled down by our cooldown factor if at least our cooldown period has
55	// elapsed since the peer last flapped. We do this because we store all-time
56	// flap count for peers, and want to allow downgrading of peers that have not
57	// flapped for a long time.
58	func cooldownFlapCount(now time.Time, flapCount int,
59	lastFlap time.Time) int {	3✔
60		3✔
61	// Calculate time since our last flap, and the number of times we need	3✔
62	// to apply our cooldown factor.	3✔
63	timeSinceFlap := now.Sub(lastFlap)	3✔
64		3✔
65	// If our cooldown period has not elapsed yet, we just return our flap	3✔
66	// count. We allow fractional cooldown periods once this period has	3✔
67	// elapsed, so we do not want to apply a fractional cooldown before the	3✔
68	// full cooldown period has elapsed.	3✔
69	if timeSinceFlap < flapCountCooldownPeriod {	6✔
70	return flapCount	3✔
71	}	3✔
72
73	// Get the factor by which we need to cooldown our flap count. If
74	// insufficient time has passed to cooldown our flap count. Use use a
75	// float so that we allow fractional cooldown periods.
UNCOV 76	cooldownPeriods := float64(timeSinceFlap) /	×
UNCOV 77	float64(flapCountCooldownPeriod)	×
UNCOV 78		×
UNCOV 79	effectiveFactor := math.Pow(flapCountCooldownFactor, cooldownPeriods)	×
UNCOV 80		×
UNCOV 81	return int(float64(flapCount) * effectiveFactor)	×
82	}

lightningnetwork / lnd / 13211764208

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