mirror of
https://github.com/refraction-networking/uquic.git
synced 2025-04-06 21:57:36 +03:00
258 lines
10 KiB
Go
258 lines
10 KiB
Go
package handshake
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/lucas-clemente/quic-go/internal/protocol"
|
|
. "github.com/onsi/ginkgo"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
var _ = Describe("Transport Parameters", func() {
|
|
Context("for gQUIC", func() {
|
|
Context("parsing", func() {
|
|
It("sets all values", func() {
|
|
values := map[Tag][]byte{
|
|
TagSFCW: {0xad, 0xfb, 0xca, 0xde},
|
|
TagCFCW: {0xef, 0xbe, 0xad, 0xde},
|
|
TagICSL: {0x0d, 0xf0, 0xad, 0xba},
|
|
TagMIDS: {0xff, 0x10, 0x00, 0xc0},
|
|
}
|
|
params, err := readHelloMap(values)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(params.StreamFlowControlWindow).To(Equal(protocol.ByteCount(0xdecafbad)))
|
|
Expect(params.ConnectionFlowControlWindow).To(Equal(protocol.ByteCount(0xdeadbeef)))
|
|
Expect(params.IdleTimeout).To(Equal(time.Duration(0xbaadf00d) * time.Second))
|
|
Expect(params.MaxStreams).To(Equal(uint32(0xc00010ff)))
|
|
Expect(params.OmitConnectionID).To(BeFalse())
|
|
})
|
|
|
|
It("reads if the connection ID should be omitted", func() {
|
|
values := map[Tag][]byte{TagTCID: {0, 0, 0, 0}}
|
|
params, err := readHelloMap(values)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(params.OmitConnectionID).To(BeTrue())
|
|
})
|
|
|
|
It("doesn't allow idle timeouts below the minimum remote idle timeout", func() {
|
|
t := 2 * time.Second
|
|
Expect(t).To(BeNumerically("<", protocol.MinRemoteIdleTimeout))
|
|
values := map[Tag][]byte{
|
|
TagICSL: {uint8(t.Seconds()), 0, 0, 0},
|
|
}
|
|
params, err := readHelloMap(values)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(params.IdleTimeout).To(Equal(protocol.MinRemoteIdleTimeout))
|
|
})
|
|
|
|
It("errors when given an invalid SFCW value", func() {
|
|
values := map[Tag][]byte{TagSFCW: {2, 0, 0}} // 1 byte too short
|
|
_, err := readHelloMap(values)
|
|
Expect(err).To(MatchError(errMalformedTag))
|
|
})
|
|
|
|
It("errors when given an invalid CFCW value", func() {
|
|
values := map[Tag][]byte{TagCFCW: {2, 0, 0}} // 1 byte too short
|
|
_, err := readHelloMap(values)
|
|
Expect(err).To(MatchError(errMalformedTag))
|
|
})
|
|
|
|
It("errors when given an invalid TCID value", func() {
|
|
values := map[Tag][]byte{TagTCID: {2, 0, 0}} // 1 byte too short
|
|
_, err := readHelloMap(values)
|
|
Expect(err).To(MatchError(errMalformedTag))
|
|
})
|
|
|
|
It("errors when given an invalid ICSL value", func() {
|
|
values := map[Tag][]byte{TagICSL: {2, 0, 0}} // 1 byte too short
|
|
_, err := readHelloMap(values)
|
|
Expect(err).To(MatchError(errMalformedTag))
|
|
})
|
|
|
|
It("errors when given an invalid MIDS value", func() {
|
|
values := map[Tag][]byte{TagMIDS: {2, 0, 0}} // 1 byte too short
|
|
_, err := readHelloMap(values)
|
|
Expect(err).To(MatchError(errMalformedTag))
|
|
})
|
|
})
|
|
|
|
Context("writing", func() {
|
|
It("returns all necessary parameters ", func() {
|
|
params := &TransportParameters{
|
|
StreamFlowControlWindow: 0xdeadbeef,
|
|
ConnectionFlowControlWindow: 0xdecafbad,
|
|
IdleTimeout: 0xbaaaaaad * time.Second,
|
|
MaxStreams: 0x1337,
|
|
}
|
|
entryMap := params.getHelloMap()
|
|
Expect(entryMap).To(HaveLen(4))
|
|
Expect(entryMap).ToNot(HaveKey(TagTCID))
|
|
Expect(entryMap).To(HaveKeyWithValue(TagSFCW, []byte{0xef, 0xbe, 0xad, 0xde}))
|
|
Expect(entryMap).To(HaveKeyWithValue(TagCFCW, []byte{0xad, 0xfb, 0xca, 0xde}))
|
|
Expect(entryMap).To(HaveKeyWithValue(TagICSL, []byte{0xad, 0xaa, 0xaa, 0xba}))
|
|
Expect(entryMap).To(HaveKeyWithValue(TagMIDS, []byte{0x37, 0x13, 0, 0}))
|
|
})
|
|
|
|
It("requests omission of the connection ID", func() {
|
|
params := &TransportParameters{OmitConnectionID: true}
|
|
entryMap := params.getHelloMap()
|
|
Expect(entryMap).To(HaveKeyWithValue(TagTCID, []byte{0, 0, 0, 0}))
|
|
})
|
|
})
|
|
})
|
|
|
|
Context("for TLS", func() {
|
|
paramsMapToList := func(p map[transportParameterID][]byte) []transportParameter {
|
|
var list []transportParameter
|
|
for id, val := range p {
|
|
list = append(list, transportParameter{id, val})
|
|
}
|
|
return list
|
|
}
|
|
|
|
It("has a string representation", func() {
|
|
p := &TransportParameters{
|
|
StreamFlowControlWindow: 0x1234,
|
|
ConnectionFlowControlWindow: 0x4321,
|
|
MaxBidiStreams: 1337,
|
|
MaxUniStreams: 7331,
|
|
IdleTimeout: 42 * time.Second,
|
|
}
|
|
Expect(p.String()).To(Equal("&handshake.TransportParameters{StreamFlowControlWindow: 0x1234, ConnectionFlowControlWindow: 0x4321, MaxBidiStreams: 1337, MaxUniStreams: 7331, IdleTimeout: 42s}"))
|
|
})
|
|
|
|
Context("parsing", func() {
|
|
var parameters map[transportParameterID][]byte
|
|
|
|
BeforeEach(func() {
|
|
parameters = map[transportParameterID][]byte{
|
|
initialMaxStreamDataParameterID: {0x11, 0x22, 0x33, 0x44},
|
|
initialMaxDataParameterID: {0x22, 0x33, 0x44, 0x55},
|
|
initialMaxStreamsBiDiParameterID: {0x33, 0x44},
|
|
initialMaxStreamsUniParameterID: {0x44, 0x55},
|
|
idleTimeoutParameterID: {0x13, 0x37},
|
|
maxPacketSizeParameterID: {0x73, 0x31},
|
|
}
|
|
})
|
|
It("reads parameters", func() {
|
|
params, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(params.StreamFlowControlWindow).To(Equal(protocol.ByteCount(0x11223344)))
|
|
Expect(params.ConnectionFlowControlWindow).To(Equal(protocol.ByteCount(0x22334455)))
|
|
Expect(params.MaxBidiStreams).To(Equal(uint16(0x3344)))
|
|
Expect(params.MaxUniStreams).To(Equal(uint16(0x4455)))
|
|
Expect(params.IdleTimeout).To(Equal(0x1337 * time.Second))
|
|
Expect(params.OmitConnectionID).To(BeFalse())
|
|
Expect(params.MaxPacketSize).To(Equal(protocol.ByteCount(0x7331)))
|
|
})
|
|
|
|
It("rejects the parameters if the initial_max_stream_data is missing", func() {
|
|
delete(parameters, initialMaxStreamDataParameterID)
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).To(MatchError("missing parameter"))
|
|
})
|
|
|
|
It("rejects the parameters if the initial_max_data is missing", func() {
|
|
delete(parameters, initialMaxDataParameterID)
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).To(MatchError("missing parameter"))
|
|
})
|
|
|
|
It("rejects the parameters if the idle_timeout is missing", func() {
|
|
delete(parameters, idleTimeoutParameterID)
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).To(MatchError("missing parameter"))
|
|
})
|
|
|
|
It("doesn't allow values below the minimum remote idle timeout", func() {
|
|
t := 2 * time.Second
|
|
Expect(t).To(BeNumerically("<", protocol.MinRemoteIdleTimeout))
|
|
parameters[idleTimeoutParameterID] = []byte{0, uint8(t.Seconds())}
|
|
params, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(params.IdleTimeout).To(Equal(protocol.MinRemoteIdleTimeout))
|
|
})
|
|
|
|
It("rejects the parameters if the initial_max_stream_data has the wrong length", func() {
|
|
parameters[initialMaxStreamDataParameterID] = []byte{0x11, 0x22, 0x33} // should be 4 bytes
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).To(MatchError("wrong length for initial_max_stream_data: 3 (expected 4)"))
|
|
})
|
|
|
|
It("rejects the parameters if the initial_max_data has the wrong length", func() {
|
|
parameters[initialMaxDataParameterID] = []byte{0x11, 0x22, 0x33} // should be 4 bytes
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).To(MatchError("wrong length for initial_max_data: 3 (expected 4)"))
|
|
})
|
|
|
|
It("rejects the parameters if the initial_max_stream_id_bidi has the wrong length", func() {
|
|
parameters[initialMaxStreamsBiDiParameterID] = []byte{0x11, 0x22, 0x33} // should be 2 bytes
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).To(MatchError("wrong length for initial_max_stream_id_bidi: 3 (expected 2)"))
|
|
})
|
|
|
|
It("rejects the parameters if the initial_max_stream_id_bidi has the wrong length", func() {
|
|
parameters[initialMaxStreamsUniParameterID] = []byte{0x11, 0x22, 0x33} // should be 2 bytes
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).To(MatchError("wrong length for initial_max_stream_id_uni: 3 (expected 2)"))
|
|
})
|
|
|
|
It("rejects the parameters if the initial_idle_timeout has the wrong length", func() {
|
|
parameters[idleTimeoutParameterID] = []byte{0x11, 0x22, 0x33} // should be 2 bytes
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).To(MatchError("wrong length for idle_timeout: 3 (expected 2)"))
|
|
})
|
|
|
|
It("rejects the parameters if max_packet_size has the wrong length", func() {
|
|
parameters[maxPacketSizeParameterID] = []byte{0x11} // should be 2 bytes
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).To(MatchError("wrong length for max_packet_size: 1 (expected 2)"))
|
|
})
|
|
|
|
It("rejects max_packet_sizes smaller than 1200 bytes", func() {
|
|
parameters[maxPacketSizeParameterID] = []byte{0x4, 0xaf} // 0x4af = 1199
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).To(MatchError("invalid value for max_packet_size: 1199 (minimum 1200)"))
|
|
})
|
|
|
|
It("ignores unknown parameters", func() {
|
|
parameters[1337] = []byte{42}
|
|
_, err := readTransportParameters(paramsMapToList(parameters))
|
|
Expect(err).ToNot(HaveOccurred())
|
|
})
|
|
})
|
|
|
|
Context("writing", func() {
|
|
var params *TransportParameters
|
|
|
|
paramsListToMap := func(l []transportParameter) map[transportParameterID][]byte {
|
|
p := make(map[transportParameterID][]byte)
|
|
for _, v := range l {
|
|
p[v.Parameter] = v.Value
|
|
}
|
|
return p
|
|
}
|
|
|
|
BeforeEach(func() {
|
|
params = &TransportParameters{
|
|
StreamFlowControlWindow: 0xdeadbeef,
|
|
ConnectionFlowControlWindow: 0xdecafbad,
|
|
IdleTimeout: 0xcafe * time.Second,
|
|
MaxBidiStreams: 0x1234,
|
|
MaxUniStreams: 0x4321,
|
|
}
|
|
})
|
|
|
|
It("creates the parameters list", func() {
|
|
values := paramsListToMap(params.getTransportParameters())
|
|
Expect(values).To(HaveLen(6))
|
|
Expect(values).To(HaveKeyWithValue(initialMaxStreamDataParameterID, []byte{0xde, 0xad, 0xbe, 0xef}))
|
|
Expect(values).To(HaveKeyWithValue(initialMaxDataParameterID, []byte{0xde, 0xca, 0xfb, 0xad}))
|
|
Expect(values).To(HaveKeyWithValue(initialMaxStreamsBiDiParameterID, []byte{0x12, 0x34}))
|
|
Expect(values).To(HaveKeyWithValue(initialMaxStreamsUniParameterID, []byte{0x43, 0x21}))
|
|
Expect(values).To(HaveKeyWithValue(idleTimeoutParameterID, []byte{0xca, 0xfe}))
|
|
Expect(values).To(HaveKeyWithValue(maxPacketSizeParameterID, []byte{0x5, 0xac})) // 1452 = 0x5ac
|
|
})
|
|
})
|
|
})
|
|
})
|