Skip to content

Commit cefbf97

Browse files
marten-seemannmarten-seemann
authored
webtransport: add PSK to constructor, and fail if it is used (#1929)
That way, it won't be possible to construct a host with a PSK when WebTransport is enabled. This is desireable since WebTransport doesn't support private network (same as QUIC).
1 parent 2cc4de5 commit cefbf97

File tree

3 files changed

+39
-34
lines changed

3 files changed

+39
-34
lines changed

‎p2p/net/swarm/swarm_addr_test.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -86,7 +86,7 @@ func TestDialAddressSelection(t *testing.T) {
8686
quicTr, err := quic.NewTransport(priv, reuse, nil, nil, nil)
8787
require.NoError(t, err)
8888
require.NoError(t, s.AddTransport(quicTr))
89-
webtransportTr, err := webtransport.New(priv, reuse, nil, nil)
89+
webtransportTr, err := webtransport.New(priv, nil, reuse, nil, nil)
9090
require.NoError(t, err)
9191
require.NoError(t, s.AddTransport(webtransportTr))
9292
h := sha256.Sum256([]byte("foo"))

‎p2p/transport/webtransport/transport.go‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@ import (
1515
ic "github.com/libp2p/go-libp2p/core/crypto"
1616
"github.com/libp2p/go-libp2p/core/network"
1717
"github.com/libp2p/go-libp2p/core/peer"
18+
"github.com/libp2p/go-libp2p/core/pnet"
1819
tpt "github.com/libp2p/go-libp2p/core/transport"
1920
"github.com/libp2p/go-libp2p/p2p/security/noise"
2021
"github.com/libp2p/go-libp2p/p2p/security/noise/pb"
@@ -93,7 +94,11 @@ var _ tpt.Transport = &transport{}
9394
var _ tpt.Resolver = &transport{}
9495
var _ io.Closer = &transport{}
9596

96-
func New(key ic.PrivKey, connManager *quicreuse.ConnManager, gater connmgr.ConnectionGater, rcmgr network.ResourceManager, opts ...Option) (tpt.Transport, error) {
97+
func New(key ic.PrivKey, psk pnet.PSK, connManager *quicreuse.ConnManager, gater connmgr.ConnectionGater, rcmgr network.ResourceManager, opts ...Option) (tpt.Transport, error) {
98+
if len(psk) > 0 {
99+
log.Error("WebTransport doesn't support private networks yet.")
100+
return nil, errors.New("WebTransport doesn't support private networks yet")
101+
}
97102
id, err := peer.IDFromPrivateKey(key)
98103
if err != nil {
99104
return nil, err

‎p2p/transport/webtransport/transport_test.go‎

Lines changed: 32 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -112,7 +112,7 @@ func newConnManager(t *testing.T, opts ...quicreuse.Option) *quicreuse.ConnManag
112112

113113
func TestTransport(t *testing.T) {
114114
serverID, serverKey := newIdentity(t)
115-
tr, err := libp2pwebtransport.New(serverKey, newConnManager(t), nil, &network.NullResourceManager{})
115+
tr, err := libp2pwebtransport.New(serverKey, nil, newConnManager(t), nil, &network.NullResourceManager{})
116116
require.NoError(t, err)
117117
defer tr.(io.Closer).Close()
118118
ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
@@ -122,7 +122,7 @@ func TestTransport(t *testing.T) {
122122
addrChan := make(chan ma.Multiaddr)
123123
go func() {
124124
_, clientKey := newIdentity(t)
125-
tr2, err := libp2pwebtransport.New(clientKey, newConnManager(t), nil, &network.NullResourceManager{})
125+
tr2, err := libp2pwebtransport.New(clientKey, nil, newConnManager(t), nil, &network.NullResourceManager{})
126126
require.NoError(t, err)
127127
defer tr2.(io.Closer).Close()
128128

@@ -158,7 +158,7 @@ func TestTransport(t *testing.T) {
158158

159159
func TestHashVerification(t *testing.T) {
160160
serverID, serverKey := newIdentity(t)
161-
tr, err := libp2pwebtransport.New(serverKey, newConnManager(t), nil, &network.NullResourceManager{})
161+
tr, err := libp2pwebtransport.New(serverKey, nil, newConnManager(t), nil, &network.NullResourceManager{})
162162
require.NoError(t, err)
163163
defer tr.(io.Closer).Close()
164164
ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
@@ -171,7 +171,7 @@ func TestHashVerification(t *testing.T) {
171171
}()
172172

173173
_, clientKey := newIdentity(t)
174-
tr2, err := libp2pwebtransport.New(clientKey, newConnManager(t), nil, &network.NullResourceManager{})
174+
tr2, err := libp2pwebtransport.New(clientKey, nil, newConnManager(t), nil, &network.NullResourceManager{})
175175
require.NoError(t, err)
176176
defer tr2.(io.Closer).Close()
177177

@@ -209,7 +209,7 @@ func TestCanDial(t *testing.T) {
209209
}
210210

211211
_, key := newIdentity(t)
212-
tr, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{})
212+
tr, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{})
213213
require.NoError(t, err)
214214
defer tr.(io.Closer).Close()
215215

@@ -235,7 +235,7 @@ func TestListenAddrValidity(t *testing.T) {
235235
}
236236

237237
_, key := newIdentity(t)
238-
tr, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{})
238+
tr, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{})
239239
require.NoError(t, err)
240240
defer tr.(io.Closer).Close()
241241

@@ -252,7 +252,7 @@ func TestListenAddrValidity(t *testing.T) {
252252

253253
func TestListenerAddrs(t *testing.T) {
254254
_, key := newIdentity(t)
255-
tr, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{})
255+
tr, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{})
256256
require.NoError(t, err)
257257
defer tr.(io.Closer).Close()
258258

@@ -275,7 +275,7 @@ func TestResourceManagerDialing(t *testing.T) {
275275
p := peer.ID("foobar")
276276

277277
_, key := newIdentity(t)
278-
tr, err := libp2pwebtransport.New(key, newConnManager(t), nil, rcmgr)
278+
tr, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, rcmgr)
279279
require.NoError(t, err)
280280
defer tr.(io.Closer).Close()
281281

@@ -290,7 +290,7 @@ func TestResourceManagerDialing(t *testing.T) {
290290

291291
func TestResourceManagerListening(t *testing.T) {
292292
clientID, key := newIdentity(t)
293-
cl, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{})
293+
cl, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{})
294294
require.NoError(t, err)
295295
defer cl.(io.Closer).Close()
296296

@@ -299,7 +299,7 @@ func TestResourceManagerListening(t *testing.T) {
299299
ctrl := gomock.NewController(t)
300300
defer ctrl.Finish()
301301
rcmgr := mocknetwork.NewMockResourceManager(ctrl)
302-
tr, err := libp2pwebtransport.New(key, newConnManager(t), nil, rcmgr)
302+
tr, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, rcmgr)
303303
require.NoError(t, err)
304304
ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
305305
require.NoError(t, err)
@@ -325,7 +325,7 @@ func TestResourceManagerListening(t *testing.T) {
325325
ctrl := gomock.NewController(t)
326326
defer ctrl.Finish()
327327
rcmgr := mocknetwork.NewMockResourceManager(ctrl)
328-
tr, err := libp2pwebtransport.New(key, newConnManager(t), nil, rcmgr)
328+
tr, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, rcmgr)
329329
require.NoError(t, err)
330330
ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
331331
require.NoError(t, err)
@@ -369,7 +369,7 @@ func TestConnectionGaterDialing(t *testing.T) {
369369
connGater := NewMockConnectionGater(ctrl)
370370

371371
serverID, serverKey := newIdentity(t)
372-
tr, err := libp2pwebtransport.New(serverKey, newConnManager(t), nil, &network.NullResourceManager{})
372+
tr, err := libp2pwebtransport.New(serverKey, nil, newConnManager(t), nil, &network.NullResourceManager{})
373373
require.NoError(t, err)
374374
defer tr.(io.Closer).Close()
375375
ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
@@ -380,7 +380,7 @@ func TestConnectionGaterDialing(t *testing.T) {
380380
require.Equal(t, stripCertHashes(ln.Multiaddr()), addrs.RemoteMultiaddr())
381381
})
382382
_, key := newIdentity(t)
383-
cl, err := libp2pwebtransport.New(key, newConnManager(t), connGater, &network.NullResourceManager{})
383+
cl, err := libp2pwebtransport.New(key, nil, newConnManager(t), connGater, &network.NullResourceManager{})
384384
require.NoError(t, err)
385385
defer cl.(io.Closer).Close()
386386
_, err = cl.Dial(context.Background(), ln.Multiaddr(), serverID)
@@ -393,7 +393,7 @@ func TestConnectionGaterInterceptAccept(t *testing.T) {
393393
connGater := NewMockConnectionGater(ctrl)
394394

395395
serverID, serverKey := newIdentity(t)
396-
tr, err := libp2pwebtransport.New(serverKey, newConnManager(t), connGater, &network.NullResourceManager{})
396+
tr, err := libp2pwebtransport.New(serverKey, nil, newConnManager(t), connGater, &network.NullResourceManager{})
397397
require.NoError(t, err)
398398
defer tr.(io.Closer).Close()
399399
ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
@@ -406,7 +406,7 @@ func TestConnectionGaterInterceptAccept(t *testing.T) {
406406
})
407407

408408
_, key := newIdentity(t)
409-
cl, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{})
409+
cl, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{})
410410
require.NoError(t, err)
411411
defer cl.(io.Closer).Close()
412412
_, err = cl.Dial(context.Background(), ln.Multiaddr(), serverID)
@@ -419,15 +419,15 @@ func TestConnectionGaterInterceptSecured(t *testing.T) {
419419
connGater := NewMockConnectionGater(ctrl)
420420

421421
serverID, serverKey := newIdentity(t)
422-
tr, err := libp2pwebtransport.New(serverKey, newConnManager(t), connGater, &network.NullResourceManager{})
422+
tr, err := libp2pwebtransport.New(serverKey, nil, newConnManager(t), connGater, &network.NullResourceManager{})
423423
require.NoError(t, err)
424424
defer tr.(io.Closer).Close()
425425
ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
426426
require.NoError(t, err)
427427
defer ln.Close()
428428

429429
clientID, key := newIdentity(t)
430-
cl, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{})
430+
cl, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{})
431431
require.NoError(t, err)
432432
defer cl.(io.Closer).Close()
433433

@@ -485,7 +485,7 @@ func TestStaticTLSConf(t *testing.T) {
485485
tlsConf := getTLSConf(t, net.ParseIP("127.0.0.1"), time.Now(), time.Now().Add(365*24*time.Hour))
486486

487487
serverID, serverKey := newIdentity(t)
488-
tr, err := libp2pwebtransport.New(serverKey, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithTLSConfig(tlsConf))
488+
tr, err := libp2pwebtransport.New(serverKey, nil, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithTLSConfig(tlsConf))
489489
require.NoError(t, err)
490490
defer tr.(io.Closer).Close()
491491
ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
@@ -495,7 +495,7 @@ func TestStaticTLSConf(t *testing.T) {
495495

496496
t.Run("fails when the certificate is invalid", func(t *testing.T) {
497497
_, key := newIdentity(t)
498-
cl, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{})
498+
cl, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{})
499499
require.NoError(t, err)
500500
defer cl.(io.Closer).Close()
501501

@@ -509,7 +509,7 @@ func TestStaticTLSConf(t *testing.T) {
509509

510510
t.Run("fails when dialing with a wrong certhash", func(t *testing.T) {
511511
_, key := newIdentity(t)
512-
cl, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{})
512+
cl, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{})
513513
require.NoError(t, err)
514514
defer cl.(io.Closer).Close()
515515

@@ -524,7 +524,7 @@ func TestStaticTLSConf(t *testing.T) {
524524
store := x509.NewCertPool()
525525
store.AddCert(tlsConf.Certificates[0].Leaf)
526526
tlsConf := &tls.Config{RootCAs: store}
527-
cl, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithTLSClientConfig(tlsConf))
527+
cl, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithTLSClientConfig(tlsConf))
528528
require.NoError(t, err)
529529
defer cl.(io.Closer).Close()
530530

@@ -537,7 +537,7 @@ func TestStaticTLSConf(t *testing.T) {
537537

538538
func TestAcceptQueueFilledUp(t *testing.T) {
539539
serverID, serverKey := newIdentity(t)
540-
tr, err := libp2pwebtransport.New(serverKey, newConnManager(t), nil, &network.NullResourceManager{})
540+
tr, err := libp2pwebtransport.New(serverKey, nil, newConnManager(t), nil, &network.NullResourceManager{})
541541
require.NoError(t, err)
542542
defer tr.(io.Closer).Close()
543543
ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
@@ -547,7 +547,7 @@ func TestAcceptQueueFilledUp(t *testing.T) {
547547
newConn := func() (tpt.CapableConn, error) {
548548
t.Helper()
549549
_, key := newIdentity(t)
550-
cl, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{})
550+
cl, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{})
551551
require.NoError(t, err)
552552
defer cl.(io.Closer).Close()
553553
return cl.Dial(context.Background(), ln.Multiaddr(), serverID)
@@ -577,15 +577,15 @@ func TestSNIIsSent(t *testing.T) {
577577
return tlsConf, nil
578578
},
579579
}
580-
tr, err := libp2pwebtransport.New(key, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithTLSConfig(tlsConf))
580+
tr, err := libp2pwebtransport.New(key, nil, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithTLSConfig(tlsConf))
581581
require.NoError(t, err)
582582
defer tr.(io.Closer).Close()
583583

584584
ln1, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
585585
require.NoError(t, err)
586586

587587
_, key2 := newIdentity(t)
588-
clientTr, err := libp2pwebtransport.New(key2, newConnManager(t), nil, &network.NullResourceManager{})
588+
clientTr, err := libp2pwebtransport.New(key2, nil, newConnManager(t), nil, &network.NullResourceManager{})
589589
require.NoError(t, err)
590590
defer tr.(io.Closer).Close()
591591

@@ -643,7 +643,7 @@ func TestFlowControlWindowIncrease(t *testing.T) {
643643
serverID, serverKey := newIdentity(t)
644644
serverWindowIncreases := make(chan int, 100)
645645
serverRcmgr := &reportingRcmgr{report: serverWindowIncreases}
646-
tr, err := libp2pwebtransport.New(serverKey, newConnManager(t), nil, serverRcmgr)
646+
tr, err := libp2pwebtransport.New(serverKey, nil, newConnManager(t), nil, serverRcmgr)
647647
require.NoError(t, err)
648648
defer tr.(io.Closer).Close()
649649
ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
@@ -670,7 +670,7 @@ func TestFlowControlWindowIncrease(t *testing.T) {
670670
_, clientKey := newIdentity(t)
671671
clientWindowIncreases := make(chan int, 100)
672672
clientRcmgr := &reportingRcmgr{report: clientWindowIncreases}
673-
tr2, err := libp2pwebtransport.New(clientKey, newConnManager(t), nil, clientRcmgr)
673+
tr2, err := libp2pwebtransport.New(clientKey, nil, newConnManager(t), nil, clientRcmgr)
674674
require.NoError(t, err)
675675
defer tr2.(io.Closer).Close()
676676

@@ -754,7 +754,7 @@ func serverSendsBackValidCert(t *testing.T, timeSinceUnixEpoch time.Duration, ke
754754

755755
priv, _, err := test.SeededTestKeyPair(ic.Ed25519, 256, keySeed)
756756
require.NoError(t, err)
757-
tr, err := libp2pwebtransport.New(priv, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithClock(cl))
757+
tr, err := libp2pwebtransport.New(priv, nil, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithClock(cl))
758758
require.NoError(t, err)
759759
l, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
760760
require.NoError(t, err)
@@ -833,7 +833,7 @@ func TestServerRotatesCertCorrectly(t *testing.T) {
833833
if err != nil {
834834
return false
835835
}
836-
tr, err := libp2pwebtransport.New(priv, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithClock(cl))
836+
tr, err := libp2pwebtransport.New(priv, nil, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithClock(cl))
837837
if err != nil {
838838
return false
839839
}
@@ -847,7 +847,7 @@ func TestServerRotatesCertCorrectly(t *testing.T) {
847847

848848
// These two certificates together are valid for at most certValidity - (4*clockSkewAllowance)
849849
cl.Add(certValidity - (4 * clockSkewAllowance) - time.Second)
850-
tr, err = libp2pwebtransport.New(priv, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithClock(cl))
850+
tr, err = libp2pwebtransport.New(priv, nil, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithClock(cl))
851851
if err != nil {
852852
return false
853853
}
@@ -883,7 +883,7 @@ func TestServerRotatesCertCorrectlyAfterSteps(t *testing.T) {
883883

884884
priv, _, err := test.RandTestKeyPair(ic.Ed25519, 256)
885885
require.NoError(t, err)
886-
tr, err := libp2pwebtransport.New(priv, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithClock(cl))
886+
tr, err := libp2pwebtransport.New(priv, nil, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithClock(cl))
887887
require.NoError(t, err)
888888

889889
l, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
@@ -896,7 +896,7 @@ func TestServerRotatesCertCorrectlyAfterSteps(t *testing.T) {
896896
// e.g. certhash/A/certhash/B ... -> ... certhash/B/certhash/C ... -> ... certhash/C/certhash/D
897897
for i := 0; i < 200; i++ {
898898
cl.Add(24 * time.Hour)
899-
tr, err := libp2pwebtransport.New(priv, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithClock(cl))
899+
tr, err := libp2pwebtransport.New(priv, nil, newConnManager(t), nil, &network.NullResourceManager{}, libp2pwebtransport.WithClock(cl))
900900
require.NoError(t, err)
901901
l, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
902902
require.NoError(t, err)

0 commit comments

Comments
 (0)