Debian Codegraph @

pkg/util/x509metrics/server_cert_deprecations_test.go

raw
1 /*
2 Copyright 2020 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 x509metrics
18
19 import (
20 "crypto/tls"
21 "crypto/x509"
22 "crypto/x509/pkix"
23 "encoding/pem"
24 "fmt"
25 "net"
26 "net/http"
27 "net/http/httptest"
28 "net/url"
29 "reflect"
30 "testing"
31
32 "github.com/stretchr/testify/require"
33 auditapi "k8s.io/apiserver/pkg/apis/audit"
34 "k8s.io/apiserver/pkg/audit"
35 "k8s.io/component-base/metrics"
36 "k8s.io/component-base/metrics/testutil"
37 )
38
39 // taken from pkg/util/webhook/certs_test.go
40 var caCert = []byte(`-----BEGIN CERTIFICATE-----
41 MIIDGTCCAgGgAwIBAgIUealQGELTHLUVcpsNNwz8XexiWvswDQYJKoZIhvcNAQEL
42 BQAwGzEZMBcGA1UEAwwQd2ViaG9va190ZXN0c19jYTAgFw0yMjAzMjUxNTMzMjla
43 GA8yMjk2MDEwODE1MzMyOVowGzEZMBcGA1UEAwwQd2ViaG9va190ZXN0c19jYTCC
44 ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKeW0Jkq6ViZkyhaLCUgbqsN
45 7+6HLwfZK/ljy/KnZ7W7QlJ65Q2tkptL0fY4DPumT7JgVTGnXyTXJ35Ss5A4yhm9
46 yyMH8pNVR19udK1fU74YVmbXJkc0nP7n+AXX9lD2Yy9pDvtaq1E+erN2nR1XaCS9
47 n0ph4C/fB1Rh7mIv/u7WW7/aRz/rJjBBZIbg7hgZPwFsukEifGi0U4uitVYR6MWp
48 jHj++e1G38+4JrZR9vhBoHtBJ1DBpmjAQaAtkSZAxXJnma4awE0Bv0Q4lxkUeY+D
49 th8OxPXxgTbwTKDaguHlWLTapppygA8FnKqmcUkwHZO5OVldi/ZKOUm2YCuJlfEC
50 AwEAAaNTMFEwHQYDVR0OBBYEFJGX6zVDm0Ur4gJJR+PKlgGdwhPfMB8GA1UdIwQY
51 MBaAFJGX6zVDm0Ur4gJJR+PKlgGdwhPfMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZI
52 hvcNAQELBQADggEBAJaRryxp0iYWGfLiZ0uIdOiYRVZUtmpqUSqT9/y29ffDAnCS
53 5labJS8FjaiQdlyaH+E9gzo0+nkO9NyfemJRLTEsU4Mz9AAvxs/NuWucqiyF0Y6d
54 JSYt7+2liGK5WvJMbHfW3jloWlv3oX+qL4iGFkJN+L9G+vf0GnKZCxgNIOqM4otv
55 cviCA9ouPwnSfnCeTsBoaUJqhLMizvUx7avvUyZTuV+t9+aN/qH4V//hTBqz9CNq
56 koodzngbUuyaGFI8QISUAhU+pbt6npb69LlhJHC0icDXCc4uTsd+SDsBOorZDuUL
57 HsNKnE0CSPZ65ENVNfJjB1fVEYbbpjr8kizOCDE=
58 -----END CERTIFICATE-----`)
59
60 var caCertInter = []byte(`-----BEGIN CERTIFICATE-----
61 MIIDMzCCAhugAwIBAgIUTJoqwFusJcupNCs/u39LBFrkZEIwDQYJKoZIhvcNAQEL
62 BQAwGzEZMBcGA1UEAwwQd2ViaG9va190ZXN0c19jYTAgFw0yMjAzMjUxNTMzMjla
63 GA8yMjk2MDEwODE1MzMyOVowKDEmMCQGA1UEAwwdd2ViaG9va190ZXN0c19pbnRl
64 cm1lZGlhdGVfY2EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDT9DIt
65 uNXhesrh8XtPXK4pR7xGReEsIlgLpMYf11PtFln9eV0HXvUO2CG/YvMxwgyd6Yoq
66 EfzD4rjmXvl5bQPMygmxf5GN1PM7ef7gVYuHfDgsQ4a82u1JFhKvuOrXn3QRfRg4
67 M4uYND7J4+Bg6J8oaA0yXIiMCpBi+XwEufo0RvgxM6mT+CeJ82hmlTKVhQJZZ9ZT
68 al1C4dTR2XeH5TLiIAvm+egBmSZhtCVn14rGk/PcHOWV7hdCxaFhSm7dSC+dR4zK
69 SxNleJ4Y+tZgoMfvgP/xHZEjbBzxnxyasES/Nc4nTgylcr6aqEX/fbcF0QzHpL9Z
70 ibkt1cBExU9zHuFJAgMBAAGjYDBeMB0GA1UdDgQWBBTfgUwjHsTOey7WqL4f3oFD
71 bmY77TAfBgNVHSMEGDAWgBSRl+s1Q5tFK+ICSUfjypYBncIT3zAPBgNVHRMBAf8E
72 BTADAQH/MAsGA1UdDwQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAQEARYbIpIidgAVb
73 5ra9zd7F902+xC13/nmlrKL/dRMrRdZxk1kVVww3FbXSp7k7oHsih42KUCVDBevw
74 0ZZiolZlLneU57dEKKiTMkuPdVbNbIBPXIQpHLrXpVIR5BRRdRZ5OJZY24hYCvce
75 50XV8ITIU0R/U4sQ6NFHv8NJ5BB+2u1M3HF2LSKZFLnfP5FBcTCg84Jd6gEmTU2j
76 wZELnHy1AVdQnKMP9VrdAr9Wn6omWxAfO/PSb9YeKhGH5vtX+Bpb9bSPQIpXeBdB
77 LLCkme0M+1UsF7xua0KVi4DSuJc+RBl4aOH0ZvKmrIWzLzZhRS0vaO/fPArVCvvI
78 VrUba0E3WQ==
79 -----END CERTIFICATE-----`)
80
81 var caCertInterSHA1 = []byte(`-----BEGIN CERTIFICATE-----
82 MIIDMzCCAhugAwIBAgIUTJoqwFusJcupNCs/u39LBFrkZEMwDQYJKoZIhvcNAQEF
83 BQAwGzEZMBcGA1UEAwwQd2ViaG9va190ZXN0c19jYTAgFw0yMjAzMjUxNTMzMjla
84 GA8yMjk2MDEwODE1MzMyOVowKDEmMCQGA1UEAwwdd2ViaG9va190ZXN0c19pbnRl
85 cm1lZGlhdGVfY2EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDT9DIt
86 uNXhesrh8XtPXK4pR7xGReEsIlgLpMYf11PtFln9eV0HXvUO2CG/YvMxwgyd6Yoq
87 EfzD4rjmXvl5bQPMygmxf5GN1PM7ef7gVYuHfDgsQ4a82u1JFhKvuOrXn3QRfRg4
88 M4uYND7J4+Bg6J8oaA0yXIiMCpBi+XwEufo0RvgxM6mT+CeJ82hmlTKVhQJZZ9ZT
89 al1C4dTR2XeH5TLiIAvm+egBmSZhtCVn14rGk/PcHOWV7hdCxaFhSm7dSC+dR4zK
90 SxNleJ4Y+tZgoMfvgP/xHZEjbBzxnxyasES/Nc4nTgylcr6aqEX/fbcF0QzHpL9Z
91 ibkt1cBExU9zHuFJAgMBAAGjYDBeMB0GA1UdDgQWBBTfgUwjHsTOey7WqL4f3oFD
92 bmY77TAfBgNVHSMEGDAWgBSRl+s1Q5tFK+ICSUfjypYBncIT3zAPBgNVHRMBAf8E
93 BTADAQH/MAsGA1UdDwQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAAhMQTwrpAeIQ
94 nShHfTERiwg/tx3dL971d3pFS5wi4kEIbbYCUGpzkmK/FTw4hfUnLpwcjjAbOWkk
95 45glOmrLJXM4RvH5PQF3GZmZvxv8Dl4zuhH1QvWbJHUiC+gyrBWI0moyLSmNiutZ
96 d3TZGEehZGwivMdHHuhgiyFM4i33EQTW1vdMdOvdu8yNpAeXM2h1PcJwbEML9PO3
97 LONzVKhz/RsyEwv7PkX1gdmi6eyAE61BWJGwzxE4K0xIYmcr6iOjsJhEf/5Qc93P
98 IGSHsG/HjWwZ47gbobtv7L+8uKP/0ky+k1cE4nIB1gKYey+SYwvkQTsj24oG9xcL
99 XhgnIl+qDw==
100 -----END CERTIFICATE-----`)
101
102 var serverKey = []byte(`-----BEGIN RSA PRIVATE KEY-----
103 MIIEowIBAAKCAQEA52b4byIJpUDyTKo5FiCa5Ekiy7CCd8UoleSomQjh5zZGsIbg
104 z9RqjaTMLF0jqbzh9ix2DQSnY+w32LqPM2sOK1+/atmeCa8m5bvZrRoDxP2T3pQH
105 Tye0C9WI7jqosmMquRFakaY1ODxDRPWF9CRghFF62NcHfnztW2rMiEYtuDRkZGsp
106 JL/B5OAzEgLr4iP8TKMlqSuhaQhi52dEZo0pJ1Ie4up8xxXKeoqfO3WSVDeRpj/n
107 0tYSALhOCdGn0RMav5wfZmxdfZpKUhBrcxFfeiDB5c7xdlnziHrY5lqSQPCHxAQb
108 S1jMaV4adhxDzF56t5RU6/5eWPZ4IvlTRtYmNwIDAQABAoIBAAb0r28XxNZ011O6
109 ojCqFj3afPNGgQV8pbWrw+2luLSsiv9vbn6Q0gsj8wc6XYISrXAq8fl+NFHqndsj
110 8H4JL8nZ/PUHSZrc6vxo4ygy6f4X6UP9iyKz/NOGPbF7jeqe1H/vp5tNNbhVB2ih
111 QL+QAF653El8XTtOIgxnb3KBOYqZ6e0rWvC5XlZrfT4EGqpokW4zQ6ROQUbnWyCk
112 LC4CtQpcLLd7fdGfA2cB2xDdGJ3Er8gAnU/X+tAtcghWanoNARKGU6opyGpwhipe
113 +31CivIUhtASWdbS73ay5QaDQSlgNM1/2hk5Beal7D9bGfKtwT/VGDSpKc4EKP8j
114 ktQSE0ECgYEA/jHMLQyvJ2VuqBdMI5hbaw5jzUAQwaJof5iQNuvFrbtWDeotAf+6
115 HomwoqzZ9+juiil4PHLQJzkArHwMWXbc+3FAznN1foS+YlOmIgJrjKa+EP+sz/X2
116 GxuyH3RD9+TH4EGd4TbeDr0eZOnIbKVybj4ueE+um7jtdLzYW2Y8iCcCgYEA6Qu6
117 x5WOQaPaEOQwEP5AqVBZnZl1ogeEVanlPYl6amPFFnlc41+M61p3ebwRqikaC9Dv
118 hePiOcTTJyt4h7qzgd5rJTjy5bNYDx9F61NGagF0xJLQiMnXM/TsoFABVWetLepG
119 DTzgvCf7wmB9QTgdLct7KyG4suDBJlEAvr70q3ECgYEAxx4pC0z5U4oAMYn2aZeq
120 XOUrxpcdySC4bOMMbQkpk1rBIStEUGGK4OsIw5VVNP5xBSdQ+UESzva3EWYmoloa
121 5pgjpNUKv62qGQnfhJqStt3S2yv8qfbI7xk14a/IokHDVGbyDn5VWgRI79G1322G
122 gtcQvcvlQjSNRbm8XXRrjFcCgYA66x1Awl3h2IQUSyyfzzgX1lmhz59+5HmfksGD
123 SlOpvCmi4fILBihBhHC6VUL+C0ArhppX9mJGiq17tLDXV+t0RQA/u+MlEa+MuzJZ
124 KYee21ljLV8NhkIjP6Pnb/K2XezZs+YcCK0kxNMQtIZWS9KMtmogYHkquEn83vPa
125 Rbrj8QKBgHifm6Z9F4qTz2b2RsYPoMHOdsX0DrZ8xQOH8jioTAy/Xi2hrL5Klp7h
126 zaLifWtOdtckFxIk+6D/zLLn1icC7cc8n4TMwQ1ikY+9IPnkTXVx4b/r/NSbAVxZ
127 J821mkhGdqKJGAzk6uh/Sn4rNGubH+I1x2Xa9hWbARCLsj8tp6TX
128 -----END RSA PRIVATE KEY-----`)
129
130 var serverCert = []byte(`-----BEGIN CERTIFICATE-----
131 MIIDHzCCAgegAwIBAgIUTJoqwFusJcupNCs/u39LBFrkZEQwDQYJKoZIhvcNAQEL
132 BQAwGzEZMBcGA1UEAwwQd2ViaG9va190ZXN0c19jYTAgFw0yMjAzMjUxNTMzMjla
133 GA8yMjk2MDEwODE1MzMyOVowHzEdMBsGA1UEAwwUd2ViaG9va190ZXN0c19zZXJ2
134 ZXIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDnZvhvIgmlQPJMqjkW
135 IJrkSSLLsIJ3xSiV5KiZCOHnNkawhuDP1GqNpMwsXSOpvOH2LHYNBKdj7DfYuo8z
136 aw4rX79q2Z4Jryblu9mtGgPE/ZPelAdPJ7QL1YjuOqiyYyq5EVqRpjU4PENE9YX0
137 JGCEUXrY1wd+fO1basyIRi24NGRkaykkv8Hk4DMSAuviI/xMoyWpK6FpCGLnZ0Rm
138 jSknUh7i6nzHFcp6ip87dZJUN5GmP+fS1hIAuE4J0afRExq/nB9mbF19mkpSEGtz
139 EV96IMHlzvF2WfOIetjmWpJA8IfEBBtLWMxpXhp2HEPMXnq3lFTr/l5Y9ngi+VNG
140 1iY3AgMBAAGjVTBTMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgXgMB0GA1UdJQQWMBQG
141 CCsGAQUFBwMCBggrBgEFBQcDATAaBgNVHREEEzARhwR/AAABgglsb2NhbGhvc3Qw
142 DQYJKoZIhvcNAQELBQADggEBAAeUHlNJiGfvhi8ts96javP8tO5gPkN7uErIMpzA
143 N1rf5Kdy7/LsxM6Uvwn0ns+p1vxANAjR/c0nfu0eIO1t5fKVDD0s9+ohKA/6phrm
144 xChTyl21mDZlFKjq0sjSwzBcUHPJjzUW9+AMDvS7pOjR5h4nD21LlMIkBzinl5KT
145 uo2Pm/OZqepPdM5XH9DaW0T0tjXKvRFe4FklJSKGD7f+T1whtmyziyA84YjYVa/6
146 gF+gpIOmPruJI9UoFqEncNpLfh5vKu2Vxv+maztFRhb+9gOg+nVBq1pxmMZV0PuM
147 L+tz0avIZEO2+KhgVGF3AF8HSZQHYcaskGFSGc8FxDKcDjM=
148 -----END CERTIFICATE-----`)
149
150 var serverCertNoSAN = []byte(`-----BEGIN CERTIFICATE-----
151 MIIC+DCCAeCgAwIBAgIUTJoqwFusJcupNCs/u39LBFrkZEUwDQYJKoZIhvcNAQEL
152 BQAwGzEZMBcGA1UEAwwQd2ViaG9va190ZXN0c19jYTAgFw0yMjAzMjUxNTMzMjla
153 GA8yMjk2MDEwODE1MzMyOVowFDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkq
154 hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA52b4byIJpUDyTKo5FiCa5Ekiy7CCd8Uo
155 leSomQjh5zZGsIbgz9RqjaTMLF0jqbzh9ix2DQSnY+w32LqPM2sOK1+/atmeCa8m
156 5bvZrRoDxP2T3pQHTye0C9WI7jqosmMquRFakaY1ODxDRPWF9CRghFF62NcHfnzt
157 W2rMiEYtuDRkZGspJL/B5OAzEgLr4iP8TKMlqSuhaQhi52dEZo0pJ1Ie4up8xxXK
158 eoqfO3WSVDeRpj/n0tYSALhOCdGn0RMav5wfZmxdfZpKUhBrcxFfeiDB5c7xdlnz
159 iHrY5lqSQPCHxAQbS1jMaV4adhxDzF56t5RU6/5eWPZ4IvlTRtYmNwIDAQABozkw
160 NzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIF4DAdBgNVHSUEFjAUBggrBgEFBQcDAgYI
161 KwYBBQUHAwEwDQYJKoZIhvcNAQELBQADggEBAGfCa0eCws/7+NYLJwVsdd7C/QHT
162 qbPw6w8oGnlXELMPwC701VFOcadhhengYCY1Kwa/KVu1ucFODDgp1ncvRoMVVWvD
163 /q6V07zu+aV/aW64zU27f+TzxTVXyCgfCSFUELJYBsBFWLw0K57ZDZdN2KJD+zD5
164 BAU0ghmy1DB+WSFMTqQ2iQaNX8oZh5jTZV3JtRNncqEqqIh4Nv7YYYZ02rgE7P2o
165 btVFYLBXHW7VYqnWpWM1pBfZpfGzMpGdR+1feST/88gUZh7ze15Ib4BlyU13v+0l
166 /BjuUsSWiITKWb2fqTiAkrqVbkOrC7Orz8yvgjuih4lEinQV1+KJUtcMmng=
167 -----END CERTIFICATE-----`)
168
169 var sha1ServerCertInter = []byte(`-----BEGIN CERTIFICATE-----
170 MIIDITCCAgmgAwIBAgIUaVjtC++/JGFoZRtkpo/j5q1nQ/4wDQYJKoZIhvcNAQEF
171 BQAwKDEmMCQGA1UEAwwdd2ViaG9va190ZXN0c19pbnRlcm1lZGlhdGVfY2EwIBcN
172 MjIwMzI1MTUzMzI5WhgPMjI5NjAxMDgxNTMzMjlaMBQxEjAQBgNVBAMMCWxvY2Fs
173 aG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOdm+G8iCaVA8kyq
174 ORYgmuRJIsuwgnfFKJXkqJkI4ec2RrCG4M/Uao2kzCxdI6m84fYsdg0Ep2PsN9i6
175 jzNrDitfv2rZngmvJuW72a0aA8T9k96UB08ntAvViO46qLJjKrkRWpGmNTg8Q0T1
176 hfQkYIRRetjXB3587VtqzIhGLbg0ZGRrKSS/weTgMxIC6+Ij/EyjJakroWkIYudn
177 RGaNKSdSHuLqfMcVynqKnzt1klQ3kaY/59LWEgC4TgnRp9ETGr+cH2ZsXX2aSlIQ
178 a3MRX3ogweXO8XZZ84h62OZakkDwh8QEG0tYzGleGnYcQ8xeereUVOv+Xlj2eCL5
179 U0bWJjcCAwEAAaNVMFMwCQYDVR0TBAIwADALBgNVHQ8EBAMCBeAwHQYDVR0lBBYw
180 FAYIKwYBBQUHAwIGCCsGAQUFBwMBMBoGA1UdEQQTMBGHBH8AAAGCCWxvY2FsaG9z
181 dDANBgkqhkiG9w0BAQUFAAOCAQEATpiJFBwcRFIfZ9ffvS1WDzHqNElEnvocv/ul
182 3KVtoX4gmKRoOy344s3oJ5APPHYWUFuZVc3uofjW265r2uOW1Cb4P9yAtNc4htBS
183 +hYsdS3MQlzZCS9rItaT25R6Ieq5TbHGRCof387jzvo1NNhcAQ5akQlQKI87km77
184 VzoEBdAw68Q0ZE+X34Q9eAA44oCcLAgCpGvs6hQuUSInribSR3vtsjuaLjdJ5F1f
185 GCu2QGM4cVLaezmoa1J54ETZggT2xFw2IyWJ2g/kXFpo+HnoyaDrPthud3Pe5xEt
186 JMzX0s3jPSjfeAv34Pr37s0Or18r1bS1hrgxE0SV2vk31fsImg==
187 -----END CERTIFICATE-----`)
188
189 var serverCertInterSHA1 = []byte(`-----BEGIN CERTIFICATE-----
190 MIIDITCCAgmgAwIBAgIUfSzzygvth1xlpa9DtyGpHuY2V+swDQYJKoZIhvcNAQEL
191 BQAwKDEmMCQGA1UEAwwdd2ViaG9va190ZXN0c19pbnRlcm1lZGlhdGVfY2EwIBcN
192 MjIwMzI1MTUzMzI5WhgPMjI5NjAxMDgxNTMzMjlaMBQxEjAQBgNVBAMMCWxvY2Fs
193 aG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOdm+G8iCaVA8kyq
194 ORYgmuRJIsuwgnfFKJXkqJkI4ec2RrCG4M/Uao2kzCxdI6m84fYsdg0Ep2PsN9i6
195 jzNrDitfv2rZngmvJuW72a0aA8T9k96UB08ntAvViO46qLJjKrkRWpGmNTg8Q0T1
196 hfQkYIRRetjXB3587VtqzIhGLbg0ZGRrKSS/weTgMxIC6+Ij/EyjJakroWkIYudn
197 RGaNKSdSHuLqfMcVynqKnzt1klQ3kaY/59LWEgC4TgnRp9ETGr+cH2ZsXX2aSlIQ
198 a3MRX3ogweXO8XZZ84h62OZakkDwh8QEG0tYzGleGnYcQ8xeereUVOv+Xlj2eCL5
199 U0bWJjcCAwEAAaNVMFMwCQYDVR0TBAIwADALBgNVHQ8EBAMCBeAwHQYDVR0lBBYw
200 FAYIKwYBBQUHAwIGCCsGAQUFBwMBMBoGA1UdEQQTMBGHBH8AAAGCCWxvY2FsaG9z
201 dDANBgkqhkiG9w0BAQsFAAOCAQEAwe/JUeIiJ5ugiO4tM0ZtvgHuFC3hK+ZWndRE
202 z4JfVXTW9soxpa/cOU9QdJhZzouIu9yqZasY4zSEerC1e6grBYP95vMbN6xUAown
203 wNzrQzyJ6yP526txiIdOkKf+yVNdz0OWNHMPtwTWIr8kKGK23ABF94aUa0VlkErp
204 Qrd8NQ3guIPI+/upuxirJCFdhE+U3U0pLHpGaGvhkOytfnLYiINwR9norVCDGbQG
205 ITH0tOz8gVWWWwxa9s5CmbqTnasgUMDh1jHa5xOo+riX8H5lwQUaItKU1JM+QMIR
206 6Z+M0Isdw647A6tmX7DqNcmHlBKxPN1GDcVXalwYJUoXwTb9Hw==
207 -----END CERTIFICATE-----`)
208
209 // Test_checkForHostnameError tests that the upstream message for remote server
210 // certificate's hostname hasn't changed when no SAN extension is present and that
211 // the metrics counter increases properly when such an error is encountered
212 //
213 // Requires GODEBUG=x509ignoreCN=0 to not be set in the environment
214 func TestCheckForHostnameError(t *testing.T) {
215 tests := []struct {
216 name string
217 serverCert []byte
218 counterIncrease bool
219 }{
220 {
221 name: "no SAN",
222 serverCert: serverCertNoSAN,
223 counterIncrease: true,
224 },
225 {
226 name: "with SAN",
227 serverCert: serverCert,
228 },
229 }
230
231 // register the test metrics
232 x509MissingSANCounter := metrics.NewCounter(&metrics.CounterOpts{Name: "Test_checkForHostnameError"})
233 registry := testutil.NewFakeKubeRegistry("0.0.0")
234 registry.MustRegister(x509MissingSANCounter)
235 sanChecker := NewSANDeprecatedChecker(x509MissingSANCounter)
236
237 var lastCounterVal int
238 for _, tt := range tests {
239 t.Run(tt.name, func(t *testing.T) {
240 tlsServer, serverURL := testServer(t, tt.serverCert)
241 defer tlsServer.Close()
242
243 client := tlsServer.Client()
244 req, err := http.NewRequest(http.MethodGet, serverURL.String(), nil)
245 if err != nil {
246 t.Fatalf("failed to create an http request: %v", err)
247 }
248 req = req.WithContext(audit.WithAuditContext(req.Context()))
249 auditCtx := audit.AuditContextFrom(req.Context())
250 auditCtx.Event.Level = auditapi.LevelMetadata
251
252 _, err = client.Transport.RoundTrip(req)
253
254 if sanChecker.CheckRoundTripError(err) {
255 sanChecker.IncreaseMetricsCounter(req)
256
257 if len(auditCtx.Event.Annotations["missing-san.invalid-cert.kubernetes.io/"+req.URL.Hostname()]) == 0 {
258 t.Errorf("expected audit annotations, got %#v", auditCtx.Event.Annotations)
259 }
260 }
261
262 errorCounterVal := getSingleCounterValueFromRegistry(t, registry, "Test_checkForHostnameError")
263 if errorCounterVal == -1 {
264 t.Fatalf("failed to get the error counter from the registry")
265 }
266
267 if tt.counterIncrease && errorCounterVal != lastCounterVal+1 {
268 t.Errorf("expected the Test_checkForHostnameError metrics to increase by 1 from %d, but it is %d", lastCounterVal, errorCounterVal)
269 }
270
271 if !tt.counterIncrease && errorCounterVal != lastCounterVal {
272 t.Errorf("expected the Test_checkForHostnameError metrics to stay the same (%d), but it is %d", lastCounterVal, errorCounterVal)
273 }
274
275 lastCounterVal = errorCounterVal
276 })
277 }
278 }
279
280 func TestCheckRespForNoSAN(t *testing.T) {
281 tests := []struct {
282 name string
283 serverCert []byte
284 counterIncrease bool
285 }{
286 {
287 name: "no SAN",
288 serverCert: serverCertNoSAN,
289 counterIncrease: true,
290 },
291 {
292 name: "with SAN",
293 serverCert: serverCert,
294 },
295 }
296
297 // register the test metrics
298 x509MissingSANCounter := metrics.NewCounter(&metrics.CounterOpts{Name: "Test_checkRespForNoSAN"})
299 registry := testutil.NewFakeKubeRegistry("0.0.0")
300 registry.MustRegister(x509MissingSANCounter)
301 sanChecker := NewSANDeprecatedChecker(x509MissingSANCounter)
302
303 var lastCounterVal int
304 for _, tt := range tests {
305 t.Run(tt.name, func(t *testing.T) {
306 var tlsConnectionState *tls.ConnectionState
307 if tt.serverCert != nil {
308 block, _ := pem.Decode([]byte(tt.serverCert))
309 if block == nil {
310 t.Fatal("failed to parse certificate PEM")
311 }
312
313 serverCert, err := x509.ParseCertificate(block.Bytes)
314 if err != nil {
315 t.Fatalf("failed to parse certificate: %v", err)
316 }
317
318 tlsConnectionState = &tls.ConnectionState{
319 PeerCertificates: []*x509.Certificate{serverCert},
320 }
321 }
322
323 resp := &http.Response{
324 TLS: tlsConnectionState,
325 }
326
327 if sanChecker.CheckPeerCertificates(resp.TLS.PeerCertificates) {
328 sanChecker.IncreaseMetricsCounter(nil)
329 }
330
331 errorCounterVal := getSingleCounterValueFromRegistry(t, registry, "Test_checkRespForNoSAN")
332 if errorCounterVal == -1 {
333 t.Fatalf("failed to get the error counter from the registry")
334 }
335
336 if tt.counterIncrease && errorCounterVal != lastCounterVal+1 {
337 t.Errorf("expected the Test_checkRespForNoSAN metrics to increase by 1 from %d, but it is %d", lastCounterVal, errorCounterVal)
338 }
339
340 if !tt.counterIncrease && errorCounterVal != lastCounterVal {
341 t.Errorf("expected the Test_checkRespForNoSAN metrics to stay the same (%d), but it is %d", lastCounterVal, errorCounterVal)
342 }
343
344 lastCounterVal = errorCounterVal
345 })
346 }
347 }
348
349 func TestCheckForInsecureAlgorithmError(t *testing.T) {
350 tests := []struct {
351 name string
352 serverCert []byte
353 counterIncrease bool
354 }{
355 {
356 name: "server cert sha1-signed",
357 serverCert: append(append(sha1ServerCertInter, byte('\n')), caCertInter...),
358 counterIncrease: true,
359 },
360 {
361 name: "intermediate CA cert sha1-signed",
362 serverCert: append(append(serverCertInterSHA1, byte('\n')), caCertInterSHA1...),
363 counterIncrease: true,
364 },
365 {
366 name: "different error - cert untrusted, intermediate not in returned chain",
367 serverCert: serverCertInterSHA1,
368 },
369 {
370 name: "properly signed",
371 serverCert: serverCert,
372 },
373 }
374
375 // register the test metrics
376 x509SHA1SignatureCounter := metrics.NewCounter(&metrics.CounterOpts{Name: "Test_checkForInsecureAlgorithmError"})
377 registry := testutil.NewFakeKubeRegistry("0.0.0")
378 registry.MustRegister(x509SHA1SignatureCounter)
379 sha1checker := NewSHA1SignatureDeprecatedChecker(x509SHA1SignatureCounter)
380
381 var lastCounterVal int
382 for _, tt := range tests {
383 t.Run(tt.name, func(t *testing.T) {
384 tlsServer, serverURL := testServer(t, tt.serverCert)
385 defer tlsServer.Close()
386
387 req, err := http.NewRequest(http.MethodGet, serverURL.String(), nil)
388 if err != nil {
389 t.Fatalf("failed to create an http request: %v", err)
390 }
391 req = req.WithContext(audit.WithAuditContext(req.Context()))
392 auditCtx := audit.AuditContextFrom(req.Context())
393 auditCtx.Event.Level = auditapi.LevelMetadata
394
395 // can't use tlsServer.Client() as it contains the server certificate
396 // in tls.Config.Certificates. The signatures are, however, only checked
397 // during building a candidate verification certificate chain and
398 // if the content of tls.Config.Certificates matches the certificate
399 // returned by the server, this short-circuits and the signature verification is
400 // never performed.
401 caPool := x509.NewCertPool()
402 require.True(t, caPool.AppendCertsFromPEM(caCert))
403
404 client := &http.Client{
405 Transport: &http.Transport{
406 Proxy: http.ProxyFromEnvironment,
407 TLSClientConfig: &tls.Config{
408 RootCAs: caPool,
409 },
410 },
411 }
412
413 _, err = client.Transport.RoundTrip(req)
414
415 if sha1checker.CheckRoundTripError(err) {
416 sha1checker.IncreaseMetricsCounter(req)
417
418 if len(auditCtx.Event.Annotations["insecure-sha1.invalid-cert.kubernetes.io/"+req.URL.Hostname()]) == 0 {
419 t.Errorf("expected audit annotations, got %#v", auditCtx.Event.Annotations)
420 }
421 }
422
423 errorCounterVal := getSingleCounterValueFromRegistry(t, registry, "Test_checkForInsecureAlgorithmError")
424 if errorCounterVal == -1 {
425 t.Fatalf("failed to get the error counter from the registry")
426 }
427
428 if tt.counterIncrease && errorCounterVal != lastCounterVal+1 {
429 t.Errorf("expected the Test_checkForInsecureAlgorithmError metrics to increase by 1 from %d, but it is %d", lastCounterVal, errorCounterVal)
430 }
431
432 if !tt.counterIncrease && errorCounterVal != lastCounterVal {
433 t.Errorf("expected the Test_checkForInsecureAlgorithmError metrics to stay the same (%d), but it is %d", lastCounterVal, errorCounterVal)
434 }
435
436 lastCounterVal = errorCounterVal
437 })
438 }
439 }
440
441 func TestCheckRespSHA1SignedCert(t *testing.T) {
442 tests := []struct {
443 name string
444 serverCert []byte
445 counterIncrease bool
446 }{
447 {
448 name: "server cert sha1-signed",
449 serverCert: append(append(sha1ServerCertInter, byte('\n')), caCertInter...),
450 counterIncrease: true,
451 },
452 {
453 name: "intermediate CA cert sha1-signed",
454 serverCert: append(append(serverCertInterSHA1, byte('\n')), caCertInterSHA1...),
455 counterIncrease: true,
456 },
457 {
458 name: "properly signed",
459 serverCert: serverCert,
460 },
461 }
462
463 // register the test metrics
464 x509SHA1SignatureCounter := metrics.NewCounter(&metrics.CounterOpts{Name: "Test_checkRespSHA1SignedCert"})
465 registry := testutil.NewFakeKubeRegistry("0.0.0")
466 registry.MustRegister(x509SHA1SignatureCounter)
467 sha1checker := NewSHA1SignatureDeprecatedChecker(x509SHA1SignatureCounter)
468
469 var lastCounterVal int
470 for _, tt := range tests {
471 t.Run(tt.name, func(t *testing.T) {
472 var tlsConnectionState *tls.ConnectionState
473 if tt.serverCert != nil {
474 peerCerts := []*x509.Certificate{}
475 for block, rest := pem.Decode([]byte(tt.serverCert)); block != nil; block, rest = pem.Decode(rest) {
476 cert, err := x509.ParseCertificate(block.Bytes)
477 if err != nil {
478 t.Fatalf("failed to parse certificate: %v", err)
479 }
480
481 peerCerts = append(peerCerts, cert)
482 }
483
484 tlsConnectionState = &tls.ConnectionState{
485 PeerCertificates: peerCerts,
486 }
487 }
488
489 resp := &http.Response{
490 TLS: tlsConnectionState,
491 }
492
493 if sha1checker.CheckPeerCertificates(resp.TLS.PeerCertificates) {
494 sha1checker.IncreaseMetricsCounter(nil)
495 }
496
497 errorCounterVal := getSingleCounterValueFromRegistry(t, registry, "Test_checkRespSHA1SignedCert")
498 if errorCounterVal == -1 {
499 t.Fatalf("failed to get the error counter from the registry")
500 }
501
502 if tt.counterIncrease && errorCounterVal != lastCounterVal+1 {
503 t.Errorf("expected the Test_checkRespSHA1SignedCert metrics to increase by 1 from %d, but it is %d", lastCounterVal, errorCounterVal)
504 }
505
506 if !tt.counterIncrease && errorCounterVal != lastCounterVal {
507 t.Errorf("expected the Test_checkRespSHA1SignedCert metrics to stay the same (%d), but it is %d", lastCounterVal, errorCounterVal)
508 }
509
510 lastCounterVal = errorCounterVal
511 })
512 }
513 }
514
515 func Test_x509DeprecatedCertificateMetricsRTWrapper_RoundTrip(t *testing.T) {
516 // register the test metrics
517 testCounter := metrics.NewCounter(&metrics.CounterOpts{Name: "testCounter"})
518 registry := testutil.NewFakeKubeRegistry("0.0.0")
519 registry.MustRegister(testCounter)
520
521 tests := []struct {
522 name string
523 checkers []deprecatedCertificateAttributeChecker
524 resp *http.Response
525 err error
526 counterIncrease bool
527 }{
528 {
529 name: "no error, resp w/ cert, no counter increase",
530 checkers: []deprecatedCertificateAttributeChecker{&testNegativeChecker{counterRaiser{testCounter, "", ""}}},
531 resp: httpResponseWithCert(),
532 },
533 {
534 name: "no error, resp w/o cert, no counter increase",
535 checkers: []deprecatedCertificateAttributeChecker{&testPositiveChecker{counterRaiser{testCounter, "", ""}}},
536 resp: httpResponseNoCert(),
537 },
538 {
539 name: "no error, resp w/ cert, counter increase",
540 checkers: []deprecatedCertificateAttributeChecker{&testPositiveChecker{counterRaiser{testCounter, "", ""}}},
541 resp: httpResponseWithCert(),
542 counterIncrease: true,
543 },
544 {
545 name: "unrelated error, no resp, no counter increase",
546 checkers: []deprecatedCertificateAttributeChecker{&testNegativeChecker{counterRaiser{testCounter, "", ""}}},
547 err: fmt.Errorf("error"),
548 },
549 {
550 name: "related error, no resp, counter increase",
551 checkers: []deprecatedCertificateAttributeChecker{&testPositiveChecker{counterRaiser{testCounter, "", ""}}},
552 err: fmt.Errorf("error"),
553 counterIncrease: true,
554 },
555 }
556
557 var lastCounterVal int
558 for _, tt := range tests {
559 t.Run(tt.name, func(t *testing.T) {
560 w := &x509DeprecatedCertificateMetricsRTWrapper{
561 rt: newTestRoundTripper(tt.resp, tt.err),
562 checkers: tt.checkers,
563 }
564 got, err := w.RoundTrip(&http.Request{})
565 if err != tt.err {
566 t.Errorf("x509DeprecatedCertificateMetricsRTWrapper.RoundTrip() should not mutate the error. Got %v, want %v", err, tt.err)
567 return
568 }
569 if !reflect.DeepEqual(got, tt.resp) {
570 t.Errorf("x509DeprecatedCertificateMetricsRTWrapper.RoundTrip() = should not mutate the response. Got %v, want %v", got, tt.resp)
571 }
572
573 errorCounterVal := getSingleCounterValueFromRegistry(t, registry, "testCounter")
574 if errorCounterVal == -1 {
575 t.Fatalf("failed to get the error counter from the registry")
576 }
577
578 if tt.counterIncrease && errorCounterVal != lastCounterVal+1 {
579 t.Errorf("expected the testCounter metrics to increase by 1 from %d, but it is %d", lastCounterVal, errorCounterVal)
580 }
581
582 if !tt.counterIncrease && errorCounterVal != lastCounterVal {
583 t.Errorf("expected the testCounter metrics to stay the same (%d), but it is %d", lastCounterVal, errorCounterVal)
584 }
585
586 lastCounterVal = errorCounterVal
587 })
588 }
589 }
590
591 type testRoundTripper func(req *http.Request) (*http.Response, error)
592
593 func (rt testRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
594 return rt(req)
595 }
596
597 func newTestRoundTripper(resp *http.Response, err error) testRoundTripper {
598 return func(_ *http.Request) (*http.Response, error) {
599 return resp, err
600 }
601 }
602
603 type testPositiveChecker struct {
604 counterRaiser
605 }
606
607 func (c *testPositiveChecker) CheckRoundTripError(_ error) bool {
608 return true
609 }
610
611 func (c *testPositiveChecker) CheckPeerCertificates(_ []*x509.Certificate) bool {
612 return true
613 }
614
615 type testNegativeChecker struct {
616 counterRaiser
617 }
618
619 func (c *testNegativeChecker) CheckRoundTripError(_ error) bool {
620 return false
621 }
622
623 func (c *testNegativeChecker) CheckPeerCertificates(_ []*x509.Certificate) bool {
624 return false
625 }
626
627 func httpResponseWithCert() *http.Response {
628 return &http.Response{
629 TLS: &tls.ConnectionState{
630 PeerCertificates: []*x509.Certificate{
631 {Issuer: pkix.Name{CommonName: "a name"}},
632 },
633 },
634 }
635 }
636
637 func httpResponseNoCert() *http.Response {
638 return &http.Response{}
639 }
640
641 func testServer(t *testing.T, serverCert []byte) (*httptest.Server, *url.URL) {
642 rootCAs := x509.NewCertPool()
643 rootCAs.AppendCertsFromPEM(caCert)
644
645 cert, err := tls.X509KeyPair(serverCert, serverKey)
646 if err != nil {
647 t.Fatalf("failed to init x509 cert/key pair: %v", err)
648 }
649 tlsConfig := &tls.Config{
650 Certificates: []tls.Certificate{cert},
651 RootCAs: rootCAs,
652 }
653
654 tlsServer := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
655 w.WriteHeader(200)
656 w.Write([]byte("ok"))
657 }))
658
659 tlsServer.TLS = tlsConfig
660 tlsServer.StartTLS()
661
662 serverURL, err := url.Parse(tlsServer.URL)
663 if err != nil {
664 tlsServer.Close()
665 t.Fatalf("failed to parse the testserver URL: %v", err)
666 }
667 serverURL.Host = net.JoinHostPort("localhost", serverURL.Port())
668
669 return tlsServer, serverURL
670 }
671
672 func getSingleCounterValueFromRegistry(t *testing.T, r metrics.Gatherer, name string) int {
673 mfs, err := r.Gather()
674 if err != nil {
675 t.Logf("failed to gather local registry metrics: %v", err)
676 return -1
677 }
678
679 for _, mf := range mfs {
680 if mf.Name != nil && *mf.Name == name {
681 mfMetric := mf.GetMetric()
682 for _, m := range mfMetric {
683 if m.GetCounter() != nil {
684 return int(m.GetCounter().GetValue())
685 }
686 }
687 }
688 }
689
690 return -1
691 }