libgo/go/crypto/tls/tls_test.go

   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 }