Debian Codegraph @

pkg/server/dynamiccertificates/server_test.go

raw
1 /*
2 Copyright 2019 The Kubernetes Authors.
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 package dynamiccertificates
18
19 import (
20 "bytes"
21 "crypto/tls"
22 "crypto/x509"
23 "fmt"
24 "net"
25 "net/http"
26 "strings"
27 "testing"
28 "time"
29
30 "k8s.io/client-go/util/cert"
31 )
32
33 func TestServingCert(t *testing.T) {
34 tlsConfig := &tls.Config{
35 // Can't use SSLv3 because of POODLE and BEAST
36 // Can't use TLSv1.0 because of POODLE and BEAST using CBC cipher
37 // Can't use TLSv1.1 because of RC4 cipher usage
38 MinVersion: tls.VersionTLS12,
39 // enable HTTP2 for go's 1.7 HTTP Server
40 NextProtos: []string{"h2", "http/1.1"},
41 }
42
43 defaultCertProvider, err := createTestTLSCerts(testCertSpec{
44 host: "172.30.0.1",
45 ips: []string{"172.30.0.1"},
46 names: []string{"kubernetes", "kubernetes.default.svc.cluster.local"},
47 }, nil)
48 if err != nil {
49 t.Fatal(err)
50 }
51
52 var sniCerts []SNICertKeyContentProvider
53 certSpecs := []testCertSpec{
54 {
55 host: "172.30.0.1",
56 ips: []string{"172.30.0.1"},
57 names: []string{"openshift", "openshift.default.svc.cluster.local"},
58 },
59 {
60 host: "127.0.0.1",
61 ips: []string{"127.0.0.1"},
62 names: []string{"localhost"},
63 },
64 {
65 host: "2001:abcd:bcda::1",
66 ips: []string{"2001:abcd:bcda::1"},
67 names: []string{"openshiftv6", "openshiftv6.default.svc.cluster.local"},
68 },
69 }
70
71 for _, certSpec := range certSpecs {
72 names := append([]string{}, certSpec.ips...)
73 names = append(names, certSpec.names...)
74 certProvider, err := createTestTLSCerts(certSpec, names)
75 if err != nil {
76 t.Fatal(err)
77 }
78 sniCerts = append(sniCerts, certProvider)
79 }
80
81 dynamicCertificateController := NewDynamicServingCertificateController(
82 tlsConfig,
83 &nullCAContent{name: "client-ca"},
84 defaultCertProvider,
85 sniCerts,
86 nil, // TODO see how to plumb an event recorder down in here. For now this results in simply klog messages.
87 )
88 if err := dynamicCertificateController.RunOnce(); err != nil {
89 t.Fatal(err)
90 }
91 tlsConfig.GetConfigForClient = dynamicCertificateController.GetConfigForClient
92 tlsConfig.GetCertificate = func(*tls.ClientHelloInfo) (*tls.Certificate, error) { return nil, fmt.Errorf("positive failure") }
93
94 stopCh := make(chan struct{})
95 defer close(stopCh)
96 server := &http.Server{
97 Handler: http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
98 w.WriteHeader(http.StatusOK)
99 }),
100 MaxHeaderBytes: 1 << 20,
101 TLSConfig: tlsConfig,
102 }
103 listener, _, err := createListener("tcp", "127.0.0.1:0")
104 if err != nil {
105 t.Fatal(err)
106 }
107 apiPort := listener.Addr().String()
108 go func() {
109 t.Logf("listening on %s", listener.Addr().String())
110 listener = tls.NewListener(listener, server.TLSConfig)
111 if err := server.ServeTLS(listener, "", ""); err != nil {
112 t.Error(err)
113 panic(err)
114 }
115
116 <-stopCh
117 server.Close()
118 t.Logf("stopped listening on %s", listener.Addr().String())
119 }()
120
121 time.Sleep(1 * time.Second)
122
123 expectedDefaultCertBytes, _ := defaultCertProvider.CurrentCertKeyContent()
124 expectedServiceCertBytes, _ := sniCerts[0].CurrentCertKeyContent()
125 expectedLocalhostCertBytes, _ := sniCerts[1].CurrentCertKeyContent()
126 expectedServiceV6CertBytes, _ := sniCerts[2].CurrentCertKeyContent()
127
128 tests := []struct {
129 name string
130 serverName string
131 expected []byte
132 }{
133 {
134 name: "default", // the no server name hits 127.0.0.1, which we hope matches by IP
135 serverName: "",
136 expected: []byte(strings.TrimSpace(string(expectedLocalhostCertBytes))),
137 },
138 {
139 name: "invalid",
140 serverName: "not-marked",
141 expected: []byte(strings.TrimSpace(string(expectedDefaultCertBytes))),
142 },
143 {
144 name: "service by dns",
145 serverName: "openshift",
146 expected: []byte(strings.TrimSpace(string(expectedServiceCertBytes))),
147 },
148 {
149 name: "service v6 by dns",
150 serverName: "openshiftv6",
151 expected: []byte(strings.TrimSpace(string(expectedServiceV6CertBytes))),
152 },
153 {
154 name: "localhost by dns",
155 serverName: "localhost",
156 expected: []byte(strings.TrimSpace(string(expectedLocalhostCertBytes))),
157 },
158 {
159 name: "localhost by IP",
160 serverName: "127.0.0.1", // this can never actually happen, but let's see
161 expected: []byte(strings.TrimSpace(string(expectedLocalhostCertBytes))),
162 },
163 }
164
165 for _, test := range tests {
166 t.Run(test.name, func(t *testing.T) {
167 _, actualDefaultCertBytes, err := cert.GetServingCertificates(apiPort, test.serverName)
168 if err != nil {
169 t.Fatal(err)
170 }
171 if e, a := test.expected, actualDefaultCertBytes[0]; !bytes.Equal(e, a) {
172 eCert, _ := cert.ParseCertsPEM(e)
173 aCert, _ := cert.ParseCertsPEM(a)
174 t.Fatalf("expected %v\n, got %v", GetHumanCertDetail(eCert[0]), GetHumanCertDetail(aCert[0]))
175 }
176 })
177 }
178
179 }
180
181 func createListener(network, addr string) (net.Listener, int, error) {
182 if len(network) == 0 {
183 network = "tcp"
184 }
185 ln, err := net.Listen(network, addr)
186 if err != nil {
187 return nil, 0, fmt.Errorf("failed to listen on %v: %v", addr, err)
188 }
189
190 // get port
191 tcpAddr, ok := ln.Addr().(*net.TCPAddr)
192 if !ok {
193 ln.Close()
194 return nil, 0, fmt.Errorf("invalid listen address: %q", ln.Addr().String())
195 }
196
197 return ln, tcpAddr.Port, nil
198 }
199
200 type nullCAContent struct {
201 name string
202 }
203
204 var _ CAContentProvider = &nullCAContent{}
205
206 // Name is just an identifier
207 func (c *nullCAContent) Name() string {
208 return c.name
209 }
210
211 func (c *nullCAContent) AddListener(Listener) {}
212
213 // CurrentCABundleContent provides ca bundle byte content
214 func (c *nullCAContent) CurrentCABundleContent() (cabundle []byte) {
215 return nil
216 }
217
218 func (c *nullCAContent) VerifyOptions() (x509.VerifyOptions, bool) {
219 return x509.VerifyOptions{}, false
220 }