summaryrefslogtreecommitdiff
path: root/libgo/go/crypto/tls/handshake_server_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'libgo/go/crypto/tls/handshake_server_test.go')
-rw-r--r--libgo/go/crypto/tls/handshake_server_test.go183
1 files changed, 123 insertions, 60 deletions
diff --git a/libgo/go/crypto/tls/handshake_server_test.go b/libgo/go/crypto/tls/handshake_server_test.go
index a9c1c08cbc4..1e5da1e12e1 100644
--- a/libgo/go/crypto/tls/handshake_server_test.go
+++ b/libgo/go/crypto/tls/handshake_server_test.go
@@ -8,6 +8,7 @@ import (
"bytes"
"crypto"
"crypto/elliptic"
+ "crypto/x509"
"encoding/pem"
"errors"
"fmt"
@@ -61,32 +62,20 @@ func TestSimpleError(t *testing.T) {
testClientHelloFailure(t, testConfig, &serverHelloDoneMsg{}, "unexpected handshake message")
}
-var badProtocolVersions = []uint16{0x0000, 0x0005, 0x0100, 0x0105, 0x0200, 0x0205}
+var badProtocolVersions = []uint16{0x0000, 0x0005, 0x0100, 0x0105, 0x0200, 0x0205, VersionSSL30}
func TestRejectBadProtocolVersion(t *testing.T) {
+ config := testConfig.Clone()
+ config.MinVersion = VersionSSL30
for _, v := range badProtocolVersions {
- testClientHelloFailure(t, testConfig, &clientHelloMsg{
+ testClientHelloFailure(t, config, &clientHelloMsg{
vers: v,
random: make([]byte, 32),
}, "unsupported versions")
}
- testClientHelloFailure(t, testConfig, &clientHelloMsg{
- vers: VersionTLS12,
- supportedVersions: badProtocolVersions,
- random: make([]byte, 32),
- }, "unsupported versions")
-}
-
-func TestSSLv3OptIn(t *testing.T) {
- config := testConfig.Clone()
- config.MinVersion = 0
- testClientHelloFailure(t, config, &clientHelloMsg{
- vers: VersionSSL30,
- random: make([]byte, 32),
- }, "unsupported versions")
testClientHelloFailure(t, config, &clientHelloMsg{
vers: VersionTLS12,
- supportedVersions: []uint16{VersionSSL30},
+ supportedVersions: badProtocolVersions,
random: make([]byte, 32),
}, "unsupported versions")
}
@@ -284,6 +273,79 @@ func TestTLS12OnlyCipherSuites(t *testing.T) {
}
}
+func TestTLSPointFormats(t *testing.T) {
+ // Test that a Server returns the ec_point_format extension when ECC is
+ // negotiated, and not returned on RSA handshake.
+ tests := []struct {
+ name string
+ cipherSuites []uint16
+ supportedCurves []CurveID
+ supportedPoints []uint8
+ wantSupportedPoints bool
+ }{
+ {"ECC", []uint16{TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA}, []CurveID{CurveP256}, []uint8{compressionNone}, true},
+ {"RSA", []uint16{TLS_RSA_WITH_AES_256_GCM_SHA384}, nil, nil, false},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ clientHello := &clientHelloMsg{
+ vers: VersionTLS12,
+ random: make([]byte, 32),
+ cipherSuites: tt.cipherSuites,
+ compressionMethods: []uint8{compressionNone},
+ supportedCurves: tt.supportedCurves,
+ supportedPoints: tt.supportedPoints,
+ }
+
+ c, s := localPipe(t)
+ replyChan := make(chan interface{})
+ go func() {
+ cli := Client(c, testConfig)
+ cli.vers = clientHello.vers
+ cli.writeRecord(recordTypeHandshake, clientHello.marshal())
+ reply, err := cli.readHandshake()
+ c.Close()
+ if err != nil {
+ replyChan <- err
+ } else {
+ replyChan <- reply
+ }
+ }()
+ config := testConfig.Clone()
+ config.CipherSuites = clientHello.cipherSuites
+ Server(s, config).Handshake()
+ s.Close()
+ reply := <-replyChan
+ if err, ok := reply.(error); ok {
+ t.Fatal(err)
+ }
+ serverHello, ok := reply.(*serverHelloMsg)
+ if !ok {
+ t.Fatalf("didn't get ServerHello message in reply. Got %v\n", reply)
+ }
+ if tt.wantSupportedPoints {
+ if len(serverHello.supportedPoints) < 1 {
+ t.Fatal("missing ec_point_format extension from server")
+ }
+ found := false
+ for _, p := range serverHello.supportedPoints {
+ if p == pointFormatUncompressed {
+ found = true
+ break
+ }
+ }
+ if !found {
+ t.Fatal("missing uncompressed format in ec_point_format extension from server")
+ }
+ } else {
+ if len(serverHello.supportedPoints) != 0 {
+ t.Fatalf("unexcpected ec_point_format extension from server: %v", serverHello.supportedPoints)
+ }
+ }
+ })
+ }
+}
+
func TestAlertForwarding(t *testing.T) {
c, s := localPipe(t)
go func() {
@@ -668,29 +730,19 @@ func (test *serverTest) run(t *testing.T, write bool) {
}
func runServerTestForVersion(t *testing.T, template *serverTest, version, option string) {
- t.Run(version, func(t *testing.T) {
- // Make a deep copy of the template before going parallel.
- test := *template
- if template.config != nil {
- test.config = template.config.Clone()
- }
-
- if !*update && !template.wait {
- t.Parallel()
- }
-
- test.name = version + "-" + test.name
- if len(test.command) == 0 {
- test.command = defaultClientCommand
- }
- test.command = append([]string(nil), test.command...)
- test.command = append(test.command, option)
- test.run(t, *update)
- })
-}
+ // Make a deep copy of the template before going parallel.
+ test := *template
+ if template.config != nil {
+ test.config = template.config.Clone()
+ }
+ test.name = version + "-" + test.name
+ if len(test.command) == 0 {
+ test.command = defaultClientCommand
+ }
+ test.command = append([]string(nil), test.command...)
+ test.command = append(test.command, option)
-func runServerTestSSLv3(t *testing.T, template *serverTest) {
- runServerTestForVersion(t, template, "SSLv3", "-ssl3")
+ runTestAndUpdateIfNeeded(t, version, test.run, test.wait)
}
func runServerTestTLS10(t *testing.T, template *serverTest) {
@@ -714,7 +766,6 @@ func TestHandshakeServerRSARC4(t *testing.T) {
name: "RSA-RC4",
command: []string{"openssl", "s_client", "-no_ticket", "-cipher", "RC4-SHA"},
}
- runServerTestSSLv3(t, test)
runServerTestTLS10(t, test)
runServerTestTLS11(t, test)
runServerTestTLS12(t, test)
@@ -725,7 +776,6 @@ func TestHandshakeServerRSA3DES(t *testing.T) {
name: "RSA-3DES",
command: []string{"openssl", "s_client", "-no_ticket", "-cipher", "DES-CBC3-SHA"},
}
- runServerTestSSLv3(t, test)
runServerTestTLS10(t, test)
runServerTestTLS12(t, test)
}
@@ -735,7 +785,6 @@ func TestHandshakeServerRSAAES(t *testing.T) {
name: "RSA-AES",
command: []string{"openssl", "s_client", "-no_ticket", "-cipher", "AES128-SHA"},
}
- runServerTestSSLv3(t, test)
runServerTestTLS10(t, test)
runServerTestTLS12(t, test)
}
@@ -1131,16 +1180,20 @@ func TestHandshakeServerRSAPKCS1v15(t *testing.T) {
}
func TestHandshakeServerRSAPSS(t *testing.T) {
+ // We send rsa_pss_rsae_sha512 first, as the test key won't fit, and we
+ // verify the server implementation will disregard the client preference in
+ // that case. See Issue 29793.
test := &serverTest{
- name: "RSA-RSAPSS",
- command: []string{"openssl", "s_client", "-no_ticket", "-sigalgs", "rsa_pss_rsae_sha256"},
- expectHandshakeErrorIncluding: "peer doesn't support any common signature algorithms", // See Issue 32425.
+ name: "RSA-RSAPSS",
+ command: []string{"openssl", "s_client", "-no_ticket", "-sigalgs", "rsa_pss_rsae_sha512:rsa_pss_rsae_sha256"},
}
runServerTestTLS12(t, test)
+ runServerTestTLS13(t, test)
test = &serverTest{
- name: "RSA-RSAPSS",
- command: []string{"openssl", "s_client", "-no_ticket", "-sigalgs", "rsa_pss_rsae_sha256"},
+ name: "RSA-RSAPSS-TooSmall",
+ command: []string{"openssl", "s_client", "-no_ticket", "-sigalgs", "rsa_pss_rsae_sha512"},
+ expectHandshakeErrorIncluding: "peer doesn't support any of the certificate's signature algorithms",
}
runServerTestTLS13(t, test)
}
@@ -1305,16 +1358,9 @@ func TestClientAuth(t *testing.T) {
command: []string{"openssl", "s_client", "-no_ticket", "-cipher", "AES128-SHA",
"-cert", certPath, "-key", keyPath, "-client_sigalgs", "rsa_pss_rsae_sha256"},
config: config,
- expectedPeerCerts: []string{}, // See Issue 32425.
- }
- runServerTestTLS12(t, test)
- test = &serverTest{
- name: "ClientAuthRequestedAndGiven",
- command: []string{"openssl", "s_client", "-no_ticket", "-cipher", "AES128-SHA",
- "-cert", certPath, "-key", keyPath, "-client_sigalgs", "rsa_pss_rsae_sha256"},
- config: config,
expectedPeerCerts: []string{clientCertificatePEM},
}
+ runServerTestTLS12(t, test)
runServerTestTLS13(t, test)
test = &serverTest{
@@ -1601,16 +1647,33 @@ T+E0J8wlH24pgwQHzy7Ko2qLwn1b5PW8ecrlvP1g
config.MinVersion = VersionTLS13
server := Server(serverConn, config)
err := server.Handshake()
- expectError(t, err, "key size too small for PSS signature")
+ expectError(t, err, "key size too small")
close(done)
}()
err = client.Handshake()
expectError(t, err, "handshake failure")
<-done
+}
+
+func TestMultipleCertificates(t *testing.T) {
+ clientConfig := testConfig.Clone()
+ clientConfig.CipherSuites = []uint16{TLS_RSA_WITH_AES_128_GCM_SHA256}
+ clientConfig.MaxVersion = VersionTLS12
- // In TLS 1.2 RSA-PSS is not used, so this should succeed. See Issue 32425.
serverConfig := testConfig.Clone()
- serverConfig.Certificates = []Certificate{cert}
- serverConfig.MaxVersion = VersionTLS12
- testHandshake(t, testConfig, serverConfig)
+ serverConfig.Certificates = []Certificate{{
+ Certificate: [][]byte{testECDSACertificate},
+ PrivateKey: testECDSAPrivateKey,
+ }, {
+ Certificate: [][]byte{testRSACertificate},
+ PrivateKey: testRSAPrivateKey,
+ }}
+
+ _, clientState, err := testHandshake(t, clientConfig, serverConfig)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if got := clientState.PeerCertificates[0].PublicKeyAlgorithm; got != x509.RSA {
+ t.Errorf("expected RSA certificate, got %v", got)
+ }
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-07-04 12:13:53 +0000