github.com/zmap/zcrypto@v0.0.0-20240512203510-0fef58d9a9db/tls/tls_test.go (about)

     1  // Copyright 2012 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package tls
     6  
     7  import (
     8  	"fmt"
     9  	"io"
    10  	"net"
    11  	"strings"
    12  	"testing"
    13  	"time"
    14  )
    15  
    16  var rsaCertPEM = `-----BEGIN CERTIFICATE-----
    17  MIIB0zCCAX2gAwIBAgIJAI/M7BYjwB+uMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV
    18  BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX
    19  aWRnaXRzIFB0eSBMdGQwHhcNMTIwOTEyMjE1MjAyWhcNMTUwOTEyMjE1MjAyWjBF
    20  MQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50
    21  ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBANLJ
    22  hPHhITqQbPklG3ibCVxwGMRfp/v4XqhfdQHdcVfHap6NQ5Wok/4xIA+ui35/MmNa
    23  rtNuC+BdZ1tMuVCPFZcCAwEAAaNQME4wHQYDVR0OBBYEFJvKs8RfJaXTH08W+SGv
    24  zQyKn0H8MB8GA1UdIwQYMBaAFJvKs8RfJaXTH08W+SGvzQyKn0H8MAwGA1UdEwQF
    25  MAMBAf8wDQYJKoZIhvcNAQEFBQADQQBJlffJHybjDGxRMqaRmDhX0+6v02TUKZsW
    26  r5QuVbpQhH6u+0UgcW0jp9QwpxoPTLTWGXEWBBBurxFwiCBhkQ+V
    27  -----END CERTIFICATE-----
    28  `
    29  
    30  var rsaKeyPEM = `-----BEGIN RSA PRIVATE KEY-----
    31  MIIBOwIBAAJBANLJhPHhITqQbPklG3ibCVxwGMRfp/v4XqhfdQHdcVfHap6NQ5Wo
    32  k/4xIA+ui35/MmNartNuC+BdZ1tMuVCPFZcCAwEAAQJAEJ2N+zsR0Xn8/Q6twa4G
    33  6OB1M1WO+k+ztnX/1SvNeWu8D6GImtupLTYgjZcHufykj09jiHmjHx8u8ZZB/o1N
    34  MQIhAPW+eyZo7ay3lMz1V01WVjNKK9QSn1MJlb06h/LuYv9FAiEA25WPedKgVyCW
    35  SmUwbPw8fnTcpqDWE3yTO3vKcebqMSsCIBF3UmVue8YU3jybC3NxuXq3wNm34R8T
    36  xVLHwDXh/6NJAiEAl2oHGGLz64BuAfjKrqwz7qMYr9HCLIe/YsoWq/olzScCIQDi
    37  D2lWusoe2/nEqfDVVWGWlyJ7yOmqaVm/iNUN9B2N2g==
    38  -----END RSA PRIVATE KEY-----
    39  `
    40  
    41  // keyPEM is the same as rsaKeyPEM, but declares itself as just
    42  // "PRIVATE KEY", not "RSA PRIVATE KEY".  http://golang.org/issue/4477
    43  var keyPEM = `-----BEGIN PRIVATE KEY-----
    44  MIIBOwIBAAJBANLJhPHhITqQbPklG3ibCVxwGMRfp/v4XqhfdQHdcVfHap6NQ5Wo
    45  k/4xIA+ui35/MmNartNuC+BdZ1tMuVCPFZcCAwEAAQJAEJ2N+zsR0Xn8/Q6twa4G
    46  6OB1M1WO+k+ztnX/1SvNeWu8D6GImtupLTYgjZcHufykj09jiHmjHx8u8ZZB/o1N
    47  MQIhAPW+eyZo7ay3lMz1V01WVjNKK9QSn1MJlb06h/LuYv9FAiEA25WPedKgVyCW
    48  SmUwbPw8fnTcpqDWE3yTO3vKcebqMSsCIBF3UmVue8YU3jybC3NxuXq3wNm34R8T
    49  xVLHwDXh/6NJAiEAl2oHGGLz64BuAfjKrqwz7qMYr9HCLIe/YsoWq/olzScCIQDi
    50  D2lWusoe2/nEqfDVVWGWlyJ7yOmqaVm/iNUN9B2N2g==
    51  -----END PRIVATE KEY-----
    52  `
    53  
    54  var ecdsaCertPEM = `-----BEGIN CERTIFICATE-----
    55  MIIB/jCCAWICCQDscdUxw16XFDAJBgcqhkjOPQQBMEUxCzAJBgNVBAYTAkFVMRMw
    56  EQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0
    57  eSBMdGQwHhcNMTIxMTE0MTI0MDQ4WhcNMTUxMTE0MTI0MDQ4WjBFMQswCQYDVQQG
    58  EwJBVTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lk
    59  Z2l0cyBQdHkgTHRkMIGbMBAGByqGSM49AgEGBSuBBAAjA4GGAAQBY9+my9OoeSUR
    60  lDQdV/x8LsOuLilthhiS1Tz4aGDHIPwC1mlvnf7fg5lecYpMCrLLhauAc1UJXcgl
    61  01xoLuzgtAEAgv2P/jgytzRSpUYvgLBt1UA0leLYBy6mQQbrNEuqT3INapKIcUv8
    62  XxYP0xMEUksLPq6Ca+CRSqTtrd/23uTnapkwCQYHKoZIzj0EAQOBigAwgYYCQXJo
    63  A7Sl2nLVf+4Iu/tAX/IF4MavARKC4PPHK3zfuGfPR3oCCcsAoz3kAzOeijvd0iXb
    64  H5jBImIxPL4WxQNiBTexAkF8D1EtpYuWdlVQ80/h/f4pBcGiXPqX5h2PQSQY7hP1
    65  +jwM1FGS4fREIOvlBYr/SzzQRtwrvrzGYxDEDbsC0ZGRnA==
    66  -----END CERTIFICATE-----
    67  `
    68  
    69  var ecdsaKeyPEM = `-----BEGIN EC PARAMETERS-----
    70  BgUrgQQAIw==
    71  -----END EC PARAMETERS-----
    72  -----BEGIN EC PRIVATE KEY-----
    73  MIHcAgEBBEIBrsoKp0oqcv6/JovJJDoDVSGWdirrkgCWxrprGlzB9o0X8fV675X0
    74  NwuBenXFfeZvVcwluO7/Q9wkYoPd/t3jGImgBwYFK4EEACOhgYkDgYYABAFj36bL
    75  06h5JRGUNB1X/Hwuw64uKW2GGJLVPPhoYMcg/ALWaW+d/t+DmV5xikwKssuFq4Bz
    76  VQldyCXTXGgu7OC0AQCC/Y/+ODK3NFKlRi+AsG3VQDSV4tgHLqZBBus0S6pPcg1q
    77  kohxS/xfFg/TEwRSSws+roJr4JFKpO2t3/be5OdqmQ==
    78  -----END EC PRIVATE KEY-----
    79  `
    80  
    81  var keyPairTests = []struct {
    82  	algo string
    83  	cert string
    84  	key  string
    85  }{
    86  	{"ECDSA", ecdsaCertPEM, ecdsaKeyPEM},
    87  	{"RSA", rsaCertPEM, rsaKeyPEM},
    88  	{"RSA-untyped", rsaCertPEM, keyPEM}, // golang.org/issue/4477
    89  }
    90  
    91  func TestX509KeyPair(t *testing.T) {
    92  	var pem []byte
    93  	for _, test := range keyPairTests {
    94  		pem = []byte(test.cert + test.key)
    95  		if _, err := X509KeyPair(pem, pem); err != nil {
    96  			t.Errorf("Failed to load %s cert followed by %s key: %s", test.algo, test.algo, err)
    97  		}
    98  		pem = []byte(test.key + test.cert)
    99  		if _, err := X509KeyPair(pem, pem); err != nil {
   100  			t.Errorf("Failed to load %s key followed by %s cert: %s", test.algo, test.algo, err)
   101  		}
   102  	}
   103  }
   104  
   105  func TestX509MixedKeyPair(t *testing.T) {
   106  	if _, err := X509KeyPair([]byte(rsaCertPEM), []byte(ecdsaKeyPEM)); err == nil {
   107  		t.Error("Load of RSA certificate succeeded with ECDSA private key")
   108  	}
   109  	if _, err := X509KeyPair([]byte(ecdsaCertPEM), []byte(rsaKeyPEM)); err == nil {
   110  		t.Error("Load of ECDSA certificate succeeded with RSA private key")
   111  	}
   112  }
   113  
   114  func newLocalListener(t *testing.T) net.Listener {
   115  	ln, err := net.Listen("tcp", "127.0.0.1:0")
   116  	if err != nil {
   117  		ln, err = net.Listen("tcp6", "[::1]:0")
   118  	}
   119  	if err != nil {
   120  		t.Fatal(err)
   121  	}
   122  	return ln
   123  }
   124  
   125  func TestDialTimeout(t *testing.T) {
   126  	if testing.Short() {
   127  		t.Skip("skipping in short mode")
   128  	}
   129  	listener := newLocalListener(t)
   130  
   131  	addr := listener.Addr().String()
   132  	defer listener.Close()
   133  
   134  	complete := make(chan bool)
   135  	defer close(complete)
   136  
   137  	go func() {
   138  		conn, err := listener.Accept()
   139  		if err != nil {
   140  			t.Error(err)
   141  			return
   142  		}
   143  		<-complete
   144  		conn.Close()
   145  	}()
   146  
   147  	dialer := &net.Dialer{
   148  		Timeout: 10 * time.Millisecond,
   149  	}
   150  
   151  	var err error
   152  	if _, err = DialWithDialer(dialer, "tcp", addr, nil); err == nil {
   153  		t.Fatal("DialWithTimeout completed successfully")
   154  	}
   155  
   156  	if !strings.Contains(err.Error(), "timed out") {
   157  		t.Errorf("resulting error not a timeout: %s", err)
   158  	}
   159  }
   160  
   161  // tests that Conn.Read returns (non-zero, io.EOF) instead of
   162  // (non-zero, nil) when a Close (alertCloseNotify) is sitting right
   163  // behind the application data in the buffer.
   164  func TestConnReadNonzeroAndEOF(t *testing.T) {
   165  	// This test is racy: it assumes that after a write to a
   166  	// localhost TCP connection, the peer TCP connection can
   167  	// immediately read it.  Because it's racy, we skip this test
   168  	// in short mode, and then retry it several times with an
   169  	// increasing sleep in between our final write (via srv.Close
   170  	// below) and the following read.
   171  	if testing.Short() {
   172  		t.Skip("skipping in short mode")
   173  	}
   174  	var err error
   175  	for delay := time.Millisecond; delay <= 64*time.Millisecond; delay *= 2 {
   176  		if err = testConnReadNonzeroAndEOF(t, delay); err == nil {
   177  			return
   178  		}
   179  	}
   180  	t.Error(err)
   181  }
   182  
   183  func testConnReadNonzeroAndEOF(t *testing.T, delay time.Duration) error {
   184  	ln := newLocalListener(t)
   185  	defer ln.Close()
   186  
   187  	srvCh := make(chan *Conn, 1)
   188  	var serr error
   189  	go func() {
   190  		sconn, err := ln.Accept()
   191  		if err != nil {
   192  			serr = err
   193  			srvCh <- nil
   194  			return
   195  		}
   196  		serverConfig := *testConfig
   197  		srv := Server(sconn, &serverConfig)
   198  		if err := srv.Handshake(); err != nil {
   199  			serr = fmt.Errorf("handshake: %v", err)
   200  			srvCh <- nil
   201  			return
   202  		}
   203  		srvCh <- srv
   204  	}()
   205  
   206  	clientConfig := *testConfig
   207  	conn, err := Dial("tcp", ln.Addr().String(), &clientConfig)
   208  	if err != nil {
   209  		t.Fatal(err)
   210  	}
   211  	defer conn.Close()
   212  
   213  	srv := <-srvCh
   214  	if srv == nil {
   215  		return serr
   216  	}
   217  
   218  	buf := make([]byte, 6)
   219  
   220  	srv.Write([]byte("foobar"))
   221  	n, err := conn.Read(buf)
   222  	if n != 6 || err != nil || string(buf) != "foobar" {
   223  		return fmt.Errorf("Read = %d, %v, data %q; want 6, nil, foobar", n, err, buf)
   224  	}
   225  
   226  	srv.Write([]byte("abcdef"))
   227  	srv.Close()
   228  	time.Sleep(delay)
   229  	n, err = conn.Read(buf)
   230  	if n != 6 || string(buf) != "abcdef" {
   231  		return fmt.Errorf("Read = %d, buf= %q; want 6, abcdef", n, buf)
   232  	}
   233  	if err != io.EOF {
   234  		return fmt.Errorf("Second Read error = %v; want io.EOF", err)
   235  	}
   236  	return nil
   237  }