Merge branch 'master' into feat/websocket-reuseport

.github/workflows/link-check.yml

@@ -0,0 +1,17 @@
+name: Markdown Link Checking
+on:
+  pull_request:
+  push:
+    branches:
+      - "master"
+
+jobs:
+  check-links:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: gaurav-nelson/github-action-markdown-link-check@v1
+        with:
+          use-quiet-mode: 'yes'   # show only broken links
+          use-verbose-mode: 'yes'
+          config-file: .github/workflows/markdown-links-config.json # for removing any false positives

.github/workflows/markdown-links-config.json

@@ -0,0 +1,22 @@
+{
+  "ignorePatterns": [
+    {
+        "pattern": "^http://localhost"
+    },
+    {
+        "pattern": "^https://twitter.com/"
+    },
+    {
+        "pattern": "^https://opensource.org/"
+    }
+  ],
+  "aliveStatusCodes": [200],
+  "httpHeaders": [
+    {
+      "urls": ["https://docs.github.com/"],
+      "headers": {
+        "Accept-Encoding": "*"
+      }
+    }
+  ]
+}

.github/workflows/stale.yml

@@ -2,25 +2,12 @@ name: Close and mark stale issue
 
 on:
   schedule:
-  - cron: '0 0 * * *'
+    - cron: '0 0 * * *'
+
+permissions:
+  issues: write
+  pull-requests: write
 
 jobs:
   stale:
-
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-
-    steps:
-    - uses: actions/stale@v3
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        stale-issue-message: 'Oops, seems like we needed more information for this issue, please comment with more details or this issue will be closed in 7 days.'
-        close-issue-message: 'This issue was closed because it is missing author input.'
-        stale-issue-label: 'kind/stale'
-        any-of-labels: 'need/author-input'
-        exempt-issue-labels: 'need/triage,need/community-input,need/maintainer-input,need/maintainers-input,need/analysis,status/blocked,status/in-progress,status/ready,status/deferred,status/inactive'
-        days-before-issue-stale: 6
-        days-before-issue-close: 7
-        enable-statistics: true
+    uses: pl-strflt/.github/.github/workflows/[email protected]

CHANGELOG.md

@@ -1,4 +1,5 @@
 # Table Of Contents <!-- omit in toc -->
+- [v0.28.0](#v0280)
 - [v0.27.0](#v0270)
 - [v0.26.4](#v0264)
 - [v0.26.3](#v0263)
@@ -8,6 +9,73 @@
 - [v0.25.1](#v0251)
 - [v0.25.0](#v0250)
 
+# [v0.28.0](https://github.com/libp2p/go-libp2p/releases/tag/v0.28.0)
+
+## 🔦 Highlights <!-- omit in toc -->
+
+### Smart Dialing <!-- omit in toc -->
+
+This release introduces smart dialing logic. Currently, libp2p dials all addresses of a remote peer in parallel, and
+aborts all outstanding dials as soon as the first one succeeds.
+Dialing many addresses in parallel creates a lot of churn on the client side, and unnecessary load on the network and
+on the server side, and is heavily discouraged by the networking community (see [RFC 8305](https://www.rfc-editor.org/rfc/rfc8305) for example).
+
+When connecting to a peer we first determine the order to dial its addresses. This ranking logic considers a number of corner cases
+described in detail in the documentation of the swarm package (`swarm.DefaultDialRanker`).
+At a high level, this is what happens:
+* If a peer offers a WebTransport and a QUIC address (on the same IP:port), the QUIC address is preferred.
+* If a peer has a QUIC and a TCP address, the QUIC address is dialed first. Only if the connection attempt doesn't succeed within 250ms, a TCP connection is started.
+
+Our measurements on the IPFS network show that for >90% of established libp2p connections, the first connection attempt succeeds,
+leading a dramatic decrease in the number of aborted connection attempts.
+
+We also added new metrics to the swarm Grafana dashboard, showing:
+* The number of connection attempts it took to establish a connection
+* The delay introduced by the ranking logic
+
+This feature should be safe to enable for nodes running in data centers and for most nodes in home networks.
+However, there are some (mostly home and corporate networks) that block all UDP traffic. If enabled, the current implementation
+of the smart dialing logic will lead to a regression, since it preferes QUIC addresses over TCP addresses. Nodes would still be
+able to connect, but connection establishment of the TCP connection would be delayed by 250ms.
+
+In a future release (see #1605 for details), we will introduce a feature called blackhole detection. By observing the outcome of
+QUIC connection attempts, we can determine if UDP traffic is blocked (namely, if all QUIC connection attempts fail), and stop
+dialing QUIC in this case altogether. Once this detection logic is in place, smart dialing will be enabled by default.
+
+### More Metrics! <!-- omit in toc -->
+Since the last release, we've added metrics for:
+* [Holepunching](https://github.com/libp2p/go-libp2p/pull/2246)
+* Smart Dialing (see above)
+
+### WebTransport <!-- omit in toc -->
+* [#2251](https://github.com/libp2p/go-libp2p/pull/2251): Infer public WebTransport address from `quic-v1` addresses if both transports are using the same port for both quic-v1 and WebTransport addresses.
+* [#2271](https://github.com/libp2p/go-libp2p/pull/2271): Only add certificate hashes to WebTransport mulitaddress if listening on WebTransport
+
+## Housekeeping updates <!-- omit in toc -->
+* Identify
+  * [#2303](https://github.com/libp2p/go-libp2p/pull/2303): Don't send default protocol version
+  * Prevent polluting PeerStore with local addrs
+    * [#2325](https://github.com/libp2p/go-libp2p/pull/2325): Don't save signed peer records
+    * [#2300](https://github.com/libp2p/go-libp2p/pull/2300): Filter received addresses based on the node's remote address
+* WebSocket
+  * [#2280](https://github.com/libp2p/go-libp2p/pull/2280): Reverted back to the Gorilla library for WebSocket
+* NAT
+  * [#2248](https://github.com/libp2p/go-libp2p/pull/2248): Move NAT mapping logic out of the host
+
+## 🐞 Bugfixes <!-- omit in toc -->
+* Identify
+  * [Reject signed peer records on peer ID mismatch](https://github.com/libp2p/go-libp2p/commit/8d771355b41297623e05b04a865d029a2522a074)
+  * [#2299](https://github.com/libp2p/go-libp2p/pull/2299): Avoid spuriously pushing updates
+* Swarm
+  * [#2322](https://github.com/libp2p/go-libp2p/pull/2322): Dedup addresses to dial
+  * [#2284](https://github.com/libp2p/go-libp2p/pull/2284): Change maps with multiaddress keys to use strings
+* QUIC
+  * [#2262](https://github.com/libp2p/go-libp2p/pull/2262): Prioritize listen connections for reuse
+  * [#2276](https://github.com/libp2p/go-libp2p/pull/2276): Don't panic when quic-go's accept call errors
+  * [#2263](https://github.com/libp2p/go-libp2p/pull/2263): Fix race condition when generating random holepunch packet
+
+**Full Changelog**: https://github.com/libp2p/go-libp2p/compare/v0.27.0...v0.28.0
+
 # [v0.27.0](https://github.com/libp2p/go-libp2p/releases/tag/v0.27.0)
 
 ### Breaking Changes <!-- omit in toc -->
@@ -82,7 +150,7 @@ Since the last release, we've added additional metrics to different components.
 Metrics were added to:
 * [AutoNat](https://github.com/libp2p/go-libp2p/pull/2086): Current Reachability Status and Confidence, Client and Server DialResponses, Server DialRejections. The dashboard is [available here](https://github.com/libp2p/go-libp2p/blob/master/dashboards/autonat/autonat.json).
 * Swarm:
-  - [Early Muxer Selection](https://github.com/libp2p/go-libp2p/pull/2119): Added early_muxer label indicating whether a connection was established using early muxer selection. 
+  - [Early Muxer Selection](https://github.com/libp2p/go-libp2p/pull/2119): Added early_muxer label indicating whether a connection was established using early muxer selection.
   - [IP Version](https://github.com/libp2p/go-libp2p/pull/2114): Added ip_version label to connection metrics
 * Identify:
   - Metrics for Identify, IdentifyPush, PushesTriggered (https://github.com/libp2p/go-libp2p/pull/2069)
@@ -127,8 +195,8 @@ Fix some test-utils used by https://github.com/libp2p/go-libp2p-kad-dht
 ### Metrics <!-- omit in toc -->
 
 We've started instrumenting the entire stack. In this release, we're adding metrics for:
-* the swarm: tracking incoming and outgoing connections, transports, security protocols and stream multiplexers in use: (https://github.com/libp2p/go-libp2p/blob/master/p2p/net/swarm/grafana-dashboards/swarm.json)
-* the event bus: tracking how different events are propagated through the stack and to external consumers (https://github.com/libp2p/go-libp2p/blob/master/p2p/host/eventbus/grafana-dashboards/eventbus.json)
+* the swarm: tracking incoming and outgoing connections, transports, security protocols and stream multiplexers in use: (https://github.com/libp2p/go-libp2p/blob/master/dashboards/swarm/swarm.json)
+* the event bus: tracking how different events are propagated through the stack and to external consumers (https://github.com/libp2p/go-libp2p/blob/master/dashboards/eventbus/eventbus.json)
 
 Our metrics effort is still ongoing, see https://github.com/libp2p/go-libp2p/issues/1356 for progress. We'll add metrics and dashboards for more libp2p components in a future release.
 
@@ -155,7 +223,7 @@ We therefore concluded that it's safe to drop this code path altogether, and the
 * Introduces a new `ResourceLimits` type which uses `LimitVal` instead of ints so it can encode the above for the resources.
 * Changes `LimitConfig` to `PartialLimitConfig` and uses `ResourceLimits`. This along with the marshalling changes means you can now marshal the fact that some resource limit is set to block all.
   * Because the default is to use the defaults, this avoids the footgun of initializing the resource manager with 0 limits (that would block everything).
-  
+
 In general, you can go from a resource config with defaults to a concrete one with `.Build()`. e.g. `ResourceLimits.Build() => BaseLimit`, `PartialLimitConfig.Build() => ConcreteLimitConfig`, `LimitVal.Build() => int`. See PR #2000 for more details.
 
 If you're using the defaults for the resource manager, there should be no changes needed.

README.md

@@ -13,18 +13,16 @@
   <a href="https://marcopolo.github.io/FlakyTests/"><img src="https://marcopolo.github.io/FlakyTests/current-score.svg"/></a>
 </p>
 
-# Table of Contents
-
+# Table of Contents <!-- omit in toc -->
 - [Background](#background)
 - [Roadmap](#roadmap)
 - [Usage](#usage)
   - [Examples](#examples)
-- [Development](#development)
-  - [Tests](#tests)
 - [Contribute](#contribute)
-- [Supported Go Versions](#supported-go-versions)
+  - [Supported Go Versions](#supported-go-versions)
+- [Notable Users](#notable-users)
 
-## Background
+# Background
 
 [libp2p](https://github.com/libp2p/specs) is a networking stack and library modularized out of [The IPFS Project](https://github.com/ipfs/ipfs), and bundled separately for other tools to use.
 >
@@ -37,12 +35,12 @@ To learn more, check out the following resources:
 - [**js-libp2p implementation**](https://github.com/libp2p/js-libp2p)
 - [**rust-libp2p implementation**](https://github.com/libp2p/rust-libp2p)
 
-## Roadmap
+# Roadmap
 
 Our roadmap for go-libp2p can be found here: https://github.com/libp2p/go-libp2p/blob/master/ROADMAP.md
-This document represents current projects the go-libp2p team is focused on and provides an estimation of completion targets. It is a completementary roadmap to the overarching libp2p project roadmap: https://github.com/libp2p/specs/blob/master/ROADMAP.md
+This document represents current projects the go-libp2p team is focused on and provides an estimation of completion targets. It is a complementary roadmap to the overarching libp2p project roadmap: https://github.com/libp2p/specs/blob/master/ROADMAP.md
 
-## Usage
+# Usage
 
 This repository (`go-libp2p`) serves as the entrypoint to the universe of packages that compose the Go implementation of the libp2p stack.
 
@@ -52,25 +50,25 @@ You can start using go-libp2p in your Go application simply by adding imports fr
 import "github.com/libp2p/go-libp2p"
 ```
 
-### Examples
+## Examples
 
 Examples can be found in the [examples folder](examples).
 
 
 # Contribute
 
-go-libp2p is part of [The IPFS Project](https://github.com/ipfs/ipfs), and is MIT-licensed open source software. We welcome contributions big and small! Take a look at the [community contributing notes](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md). Please make sure to check the [issues](https://github.com/ipfs/go-libp2p/issues). Search the closed ones before reporting things, and help us with the open ones.
+go-libp2p is MIT-licensed open source software. We welcome contributions big and small! Take a look at the [community contributing notes](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md). Please make sure to check the [issues](https://github.com/libp2p/go-libp2p/issues). Search the closed ones before reporting things, and help us with the open ones.
 
 Guidelines:
 
 - read the [libp2p spec](https://github.com/libp2p/specs)
-- ask questions or talk about things in  our [discussion forums](https://discuss.libp2p.io), or open an [issue](https://github.com/libp2p/go-libp2p/issues) for bug reports, or #libp2p on freenode.
+- ask questions or talk about things in our [discussion forums](https://discuss.libp2p.io), or open an [issue](https://github.com/libp2p/go-libp2p/issues) for bug reports, or #libp2p-implementers on [Filecoin slack](https://filecoin.io/slack).
 - ensure you are able to contribute (no legal issues please -- we use the DCO)
-- get in touch with @marten-seemann about how best to contribute
+- get in touch with @libp2p/go-libp2p-maintainers about how best to contribute
 - have fun!
 
 There's a few things you can do right now to help out:
- - Go through the modules below and **check out existing issues**. This would be especially useful for modules in active development. Some knowledge of IPFS/libp2p may be required, as well as the infrasture behind it - for instance, you may need to read up on p2p and more complex operations like muxing to be able to help technically.
+ - Go through the modules below and **check out existing issues**. This would be especially useful for modules in active development. Some knowledge of IPFS/libp2p may be required, as well as the infrastructure behind it - for instance, you may need to read up on p2p and more complex operations like muxing to be able to help technically.
  - **Perform code reviews**.
  - **Add tests**. There can never be enough tests.
 
@@ -99,4 +97,4 @@ Some notable users of go-libp2p are:
 - [Kairos](https://github.com/kairos-io/kairos) - A Kubernetes-focused, Cloud Native Linux meta-distribution.
 - [Oasis Core](https://github.com/oasisprotocol/oasis-core) - The consensus and runtime layers of the [Oasis protocol](https://oasisprotocol.org/).
 
-Please open a pull request if you want your project to be added here.
+Please open a pull request if you want your project (min. 250 GitHub stars) to be added here.

config/config.go

@@ -26,6 +26,7 @@ import (
 	blankhost "github.com/libp2p/go-libp2p/p2p/host/blank"
 	"github.com/libp2p/go-libp2p/p2p/host/eventbus"
 	"github.com/libp2p/go-libp2p/p2p/host/peerstore/pstoremem"
+	rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager"
 	routed "github.com/libp2p/go-libp2p/p2p/host/routed"
 	"github.com/libp2p/go-libp2p/p2p/net/swarm"
 	tptu "github.com/libp2p/go-libp2p/p2p/net/upgrader"
@@ -123,6 +124,10 @@ type Config struct {
 
 	DisableMetrics       bool
 	PrometheusRegisterer prometheus.Registerer
+
+	DialRanker network.DialRanker
+
+	SwarmOpts []swarm.Option
 }
 
 func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swarm, error) {
@@ -134,8 +139,8 @@ func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swa
 	if pnet.ForcePrivateNetwork && len(cfg.PSK) == 0 {
 		log.Error("tried to create a libp2p node with no Private" +
 			" Network Protector but usage of Private Networks" +
-			" is forced by the enviroment")
-		// Note: This is *also* checked the upgrader itself so it'll be
+			" is forced by the environment")
+		// Note: This is *also* checked the upgrader itself, so it'll be
 		// enforced even *if* you don't use the libp2p constructor.
 		return nil, pnet.ErrNotInPrivateNetwork
 	}
@@ -157,7 +162,7 @@ func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swa
 		return nil, err
 	}
 
-	opts := make([]swarm.Option, 0, 6)
+	opts := cfg.SwarmOpts
 	if cfg.Reporter != nil {
 		opts = append(opts, swarm.WithMetrics(cfg.Reporter))
 	}
@@ -173,6 +178,10 @@ func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swa
 	if cfg.MultiaddrResolver != nil {
 		opts = append(opts, swarm.WithMultiaddrResolver(cfg.MultiaddrResolver))
 	}
+	if cfg.DialRanker != nil {
+		opts = append(opts, swarm.WithDialRanker(cfg.DialRanker))
+	}
+
 	if enableMetrics {
 		opts = append(opts,
 			swarm.WithMetricsTracer(swarm.NewMetricsTracer(swarm.WithRegisterer(cfg.PrometheusRegisterer))))
@@ -292,6 +301,10 @@ func (cfg *Config) NewNode() (host.Host, error) {
 		return nil, err
 	}
 
+	if !cfg.DisableMetrics {
+		rcmgr.MustRegisterWith(cfg.PrometheusRegisterer)
+	}
+
 	h, err := bhost.NewHost(swrm, &bhost.HostOpts{
 		EventBus:             eventBus,
 		ConnManager:          cfg.ConnManager,
@@ -393,7 +406,7 @@ func (cfg *Config) NewNode() (host.Host, error) {
 		}
 
 		// Pull out the pieces of the config that we _actually_ care about.
-		// Specifically, don't setup things like autorelay, listeners,
+		// Specifically, don't set up things like autorelay, listeners,
 		// identify, etc.
 		autoNatCfg := Config{
 			Transports:         cfg.Transports,
@@ -405,6 +418,7 @@ func (cfg *Config) NewNode() (host.Host, error) {
 			Reporter:           cfg.Reporter,
 			PeerKey:            autonatPrivKey,
 			Peerstore:          ps,
+			DialRanker:         swarm.NoDelayDialRanker,
 		}
 
 		dialer, err := autoNatCfg.makeSwarm(eventbus.NewBus(), false)

core/crypto/ecdsa.go

@@ -49,7 +49,7 @@ func GenerateECDSAKeyPair(src io.Reader) (PrivKey, PubKey, error) {
 	return GenerateECDSAKeyPairWithCurve(ECDSACurve, src)
 }
 
-// GenerateECDSAKeyPairWithCurve generates a new ecdsa private and public key with a speicified curve
+// GenerateECDSAKeyPairWithCurve generates a new ecdsa private and public key with a specified curve
 func GenerateECDSAKeyPairWithCurve(curve elliptic.Curve, src io.Reader) (PrivKey, PubKey, error) {
 	priv, err := ecdsa.GenerateKey(curve, src)
 	if err != nil {

core/crypto/ed25519.go

@@ -101,7 +101,7 @@ func (k *Ed25519PublicKey) Equals(o Key) bool {
 	return bytes.Equal(k.k, edk.k)
 }
 
-// Verify checks a signature agains the input data.
+// Verify checks a signature against the input data.
 func (k *Ed25519PublicKey) Verify(data []byte, sig []byte) (success bool, err error) {
 	defer func() {
 		catch.HandlePanic(recover(), &err, "ed15519 signature verification")

core/crypto/key.go

@@ -90,7 +90,7 @@ type PrivKey interface {
 	GetPublic() PubKey
 }
 
-// PubKey is a public key that can be used to verifiy data signed with the corresponding private key
+// PubKey is a public key that can be used to verify data signed with the corresponding private key
 type PubKey interface {
 	Key
 
@@ -106,7 +106,7 @@ func GenerateKeyPair(typ, bits int) (PrivKey, PubKey, error) {
 	return GenerateKeyPairWithReader(typ, bits, rand.Reader)
 }
 
-// GenerateKeyPairWithReader returns a keypair of the given type and bitsize
+// GenerateKeyPairWithReader returns a keypair of the given type and bit-size
 func GenerateKeyPairWithReader(typ, bits int, src io.Reader) (PrivKey, PubKey, error) {
 	switch typ {
 	case RSA:

core/crypto/rsa_common.go

@@ -12,9 +12,12 @@ const WeakRsaKeyEnv = "LIBP2P_ALLOW_WEAK_RSA_KEYS"
 
 var MinRsaKeyBits = 2048
 
+var maxRsaKeyBits = 8192
+
 // ErrRsaKeyTooSmall is returned when trying to generate or parse an RSA key
 // that's smaller than MinRsaKeyBits bits. In test
 var ErrRsaKeyTooSmall error
+var ErrRsaKeyTooBig error = fmt.Errorf("rsa keys must be <= %d bits", maxRsaKeyBits)
 
 func init() {
 	if _, ok := os.LookupEnv(WeakRsaKeyEnv); ok {