Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 1 | #!/usr/bin/env python3 |
| 2 | |
| 3 | # generate_tls13_compat_tests.py |
| 4 | # |
| 5 | # Copyright The Mbed TLS Contributors |
| 6 | # SPDX-License-Identifier: Apache-2.0 |
| 7 | # |
| 8 | # Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 9 | # not use this file except in compliance with the License. |
| 10 | # You may obtain a copy of the License at |
| 11 | # |
| 12 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 13 | # |
| 14 | # Unless required by applicable law or agreed to in writing, software |
| 15 | # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 16 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 17 | # See the License for the specific language governing permissions and |
| 18 | # limitations under the License. |
| 19 | |
| 20 | """ |
| 21 | Generate TLSv1.3 Compat test cases |
| 22 | |
| 23 | """ |
| 24 | |
| 25 | import sys |
Jerry Yu | dda036d | 2021-11-30 11:19:41 +0800 | [diff] [blame] | 26 | import os |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 27 | import argparse |
Jerry Yu | c4aa152 | 2021-11-26 11:13:58 +0800 | [diff] [blame] | 28 | import itertools |
Jerry Yu | 882c30d | 2021-12-01 10:59:59 +0800 | [diff] [blame] | 29 | from collections import namedtuple |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 30 | |
Jerry Yu | 882c30d | 2021-12-01 10:59:59 +0800 | [diff] [blame] | 31 | # define certificates configuration entry |
| 32 | Certificate = namedtuple("Certificate", ['cafile', 'certfile', 'keyfile']) |
| 33 | # define the certificate parameters for signature algorithms |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 34 | CERTIFICATES = { |
Jerry Yu | 882c30d | 2021-12-01 10:59:59 +0800 | [diff] [blame] | 35 | 'ecdsa_secp256r1_sha256': Certificate('data_files/test-ca2.crt', |
| 36 | 'data_files/ecdsa_secp256r1.crt', |
| 37 | 'data_files/ecdsa_secp256r1.key'), |
| 38 | 'ecdsa_secp384r1_sha384': Certificate('data_files/test-ca2.crt', |
| 39 | 'data_files/ecdsa_secp384r1.crt', |
| 40 | 'data_files/ecdsa_secp384r1.key'), |
| 41 | 'ecdsa_secp521r1_sha512': Certificate('data_files/test-ca2.crt', |
| 42 | 'data_files/ecdsa_secp521r1.crt', |
| 43 | 'data_files/ecdsa_secp521r1.key'), |
| 44 | 'rsa_pss_rsae_sha256': Certificate('data_files/test-ca_cat12.crt', |
| 45 | 'data_files/server2-sha256.crt', 'data_files/server2.key' |
| 46 | ) |
Jerry Yu | 29deed4 | 2021-11-25 11:09:54 +0800 | [diff] [blame] | 47 | } |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 48 | |
| 49 | CIPHER_SUITE_IANA_VALUE = { |
| 50 | "TLS_AES_128_GCM_SHA256": 0x1301, |
| 51 | "TLS_AES_256_GCM_SHA384": 0x1302, |
| 52 | "TLS_CHACHA20_POLY1305_SHA256": 0x1303, |
| 53 | "TLS_AES_128_CCM_SHA256": 0x1304, |
| 54 | "TLS_AES_128_CCM_8_SHA256": 0x1305 |
| 55 | } |
| 56 | |
| 57 | SIG_ALG_IANA_VALUE = { |
| 58 | "ecdsa_secp256r1_sha256": 0x0403, |
| 59 | "ecdsa_secp384r1_sha384": 0x0503, |
| 60 | "ecdsa_secp521r1_sha512": 0x0603, |
Jerry Yu | 29deed4 | 2021-11-25 11:09:54 +0800 | [diff] [blame] | 61 | 'rsa_pss_rsae_sha256': 0x0804, |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 62 | } |
| 63 | |
| 64 | NAMED_GROUP_IANA_VALUE = { |
| 65 | 'secp256r1': 0x17, |
| 66 | 'secp384r1': 0x18, |
| 67 | 'secp521r1': 0x19, |
| 68 | 'x25519': 0x1d, |
| 69 | 'x448': 0x1e, |
| 70 | } |
| 71 | |
XiaokangQian | 68a87e4 | 2022-03-17 06:06:07 +0000 | [diff] [blame] | 72 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 73 | class TLSProgram: |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 74 | """ |
| 75 | Base class for generate server/client command. |
| 76 | """ |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 77 | |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 78 | # pylint: disable=too-many-arguments |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 79 | def __init__(self, ciphersuite=None, signature_algorithm=None, named_group=None, |
| 80 | cert_sig_alg=None, compat_mode=True): |
Jerry Yu | 7918efe | 2021-12-01 15:29:10 +0800 | [diff] [blame] | 81 | self._ciphers = [] |
| 82 | self._sig_algs = [] |
| 83 | self._named_groups = [] |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 84 | self._cert_sig_algs = [] |
| 85 | if ciphersuite: |
| 86 | self.add_ciphersuites(ciphersuite) |
| 87 | if named_group: |
| 88 | self.add_named_groups(named_group) |
| 89 | if signature_algorithm: |
| 90 | self.add_signature_algorithms(signature_algorithm) |
| 91 | if cert_sig_alg: |
| 92 | self.add_cert_signature_algorithms(cert_sig_alg) |
Ronald Cron | ae93725 | 2021-12-10 09:55:15 +0100 | [diff] [blame] | 93 | self._compat_mode = compat_mode |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 94 | |
Jerry Yu | 7918efe | 2021-12-01 15:29:10 +0800 | [diff] [blame] | 95 | # add_ciphersuites should not override by sub class |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 96 | def add_ciphersuites(self, *ciphersuites): |
Jerry Yu | 7918efe | 2021-12-01 15:29:10 +0800 | [diff] [blame] | 97 | self._ciphers.extend( |
| 98 | [cipher for cipher in ciphersuites if cipher not in self._ciphers]) |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 99 | |
Jerry Yu | 7918efe | 2021-12-01 15:29:10 +0800 | [diff] [blame] | 100 | # add_signature_algorithms should not override by sub class |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 101 | def add_signature_algorithms(self, *signature_algorithms): |
Jerry Yu | 7918efe | 2021-12-01 15:29:10 +0800 | [diff] [blame] | 102 | self._sig_algs.extend( |
| 103 | [sig_alg for sig_alg in signature_algorithms if sig_alg not in self._sig_algs]) |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 104 | |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 105 | # add_named_groups should not override by sub class |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 106 | def add_named_groups(self, *named_groups): |
Jerry Yu | 7918efe | 2021-12-01 15:29:10 +0800 | [diff] [blame] | 107 | self._named_groups.extend( |
| 108 | [named_group for named_group in named_groups if named_group not in self._named_groups]) |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 109 | |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 110 | # add_cert_signature_algorithms should not override by sub class |
| 111 | def add_cert_signature_algorithms(self, *signature_algorithms): |
| 112 | self._cert_sig_algs.extend( |
| 113 | [sig_alg for sig_alg in signature_algorithms if sig_alg not in self._cert_sig_algs]) |
| 114 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 115 | # pylint: disable=no-self-use |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 116 | def pre_checks(self): |
| 117 | return [] |
| 118 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 119 | # pylint: disable=no-self-use |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 120 | def cmd(self): |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 121 | if not self._cert_sig_algs: |
| 122 | self._cert_sig_algs = list(CERTIFICATES.keys()) |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 123 | return self.pre_cmd() |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 124 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 125 | # pylint: disable=no-self-use |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 126 | def post_checks(self): |
| 127 | return [] |
| 128 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 129 | # pylint: disable=no-self-use |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 130 | def pre_cmd(self): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 131 | return ['false'] |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 132 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 133 | # pylint: disable=unused-argument,no-self-use |
XiaokangQian | 9b938b7 | 2022-06-10 03:10:59 +0000 | [diff] [blame] | 134 | def hrr_post_checks(self, named_group): |
| 135 | return [] |
| 136 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 137 | |
| 138 | class OpenSSLBase(TLSProgram): |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 139 | """ |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 140 | Generate base test commands for OpenSSL. |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 141 | """ |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 142 | |
| 143 | NAMED_GROUP = { |
| 144 | 'secp256r1': 'P-256', |
| 145 | 'secp384r1': 'P-384', |
| 146 | 'secp521r1': 'P-521', |
| 147 | 'x25519': 'X25519', |
| 148 | 'x448': 'X448', |
| 149 | } |
| 150 | |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 151 | def cmd(self): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 152 | ret = super().cmd() |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 153 | |
| 154 | if self._ciphers: |
| 155 | ciphersuites = ':'.join(self._ciphers) |
| 156 | ret += ["-ciphersuites {ciphersuites}".format(ciphersuites=ciphersuites)] |
| 157 | |
| 158 | if self._sig_algs: |
| 159 | signature_algorithms = set(self._sig_algs + self._cert_sig_algs) |
| 160 | signature_algorithms = ':'.join(signature_algorithms) |
| 161 | ret += ["-sigalgs {signature_algorithms}".format( |
| 162 | signature_algorithms=signature_algorithms)] |
| 163 | |
| 164 | if self._named_groups: |
| 165 | named_groups = ':'.join( |
| 166 | map(lambda named_group: self.NAMED_GROUP[named_group], self._named_groups)) |
| 167 | ret += ["-groups {named_groups}".format(named_groups=named_groups)] |
| 168 | |
| 169 | ret += ['-msg -tls1_3'] |
| 170 | if not self._compat_mode: |
| 171 | ret += ['-no_middlebox'] |
| 172 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 173 | return ret |
| 174 | |
| 175 | def pre_checks(self): |
| 176 | return ["requires_openssl_tls1_3"] |
| 177 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 178 | |
| 179 | class OpenSSLServ(OpenSSLBase): |
| 180 | """ |
| 181 | Generate test commands for OpenSSL server. |
| 182 | """ |
| 183 | |
| 184 | def cmd(self): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 185 | ret = super().cmd() |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 186 | ret += ['-num_tickets 0 -no_resume_ephemeral -no_cache'] |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 187 | return ret |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 188 | |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 189 | def post_checks(self): |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 190 | return ['-c "HTTP/1.0 200 ok"'] |
| 191 | |
| 192 | def pre_cmd(self): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 193 | ret = ['$O_NEXT_SRV_NO_CERT'] |
| 194 | for _, cert, key in map(lambda sig_alg: CERTIFICATES[sig_alg], self._cert_sig_algs): |
| 195 | ret += ['-cert {cert} -key {key}'.format(cert=cert, key=key)] |
| 196 | return ret |
| 197 | |
| 198 | |
| 199 | class OpenSSLCli(OpenSSLBase): |
| 200 | """ |
| 201 | Generate test commands for OpenSSL client. |
| 202 | """ |
| 203 | |
| 204 | def pre_cmd(self): |
| 205 | return ['$O_NEXT_CLI_NO_CERT', |
| 206 | '-CAfile {cafile}'.format(cafile=CERTIFICATES[self._cert_sig_algs[0]].cafile)] |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 207 | |
| 208 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 209 | class GnuTLSBase(TLSProgram): |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 210 | """ |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 211 | Generate base test commands for GnuTLS. |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 212 | """ |
| 213 | |
| 214 | CIPHER_SUITE = { |
| 215 | 'TLS_AES_256_GCM_SHA384': [ |
| 216 | 'AES-256-GCM', |
| 217 | 'SHA384', |
| 218 | 'AEAD'], |
| 219 | 'TLS_AES_128_GCM_SHA256': [ |
| 220 | 'AES-128-GCM', |
| 221 | 'SHA256', |
| 222 | 'AEAD'], |
| 223 | 'TLS_CHACHA20_POLY1305_SHA256': [ |
| 224 | 'CHACHA20-POLY1305', |
| 225 | 'SHA256', |
| 226 | 'AEAD'], |
| 227 | 'TLS_AES_128_CCM_SHA256': [ |
| 228 | 'AES-128-CCM', |
| 229 | 'SHA256', |
| 230 | 'AEAD'], |
| 231 | 'TLS_AES_128_CCM_8_SHA256': [ |
| 232 | 'AES-128-CCM-8', |
| 233 | 'SHA256', |
| 234 | 'AEAD']} |
| 235 | |
| 236 | SIGNATURE_ALGORITHM = { |
| 237 | 'ecdsa_secp256r1_sha256': ['SIGN-ECDSA-SECP256R1-SHA256'], |
| 238 | 'ecdsa_secp521r1_sha512': ['SIGN-ECDSA-SECP521R1-SHA512'], |
| 239 | 'ecdsa_secp384r1_sha384': ['SIGN-ECDSA-SECP384R1-SHA384'], |
| 240 | 'rsa_pss_rsae_sha256': ['SIGN-RSA-PSS-RSAE-SHA256']} |
| 241 | |
| 242 | NAMED_GROUP = { |
| 243 | 'secp256r1': ['GROUP-SECP256R1'], |
| 244 | 'secp384r1': ['GROUP-SECP384R1'], |
| 245 | 'secp521r1': ['GROUP-SECP521R1'], |
| 246 | 'x25519': ['GROUP-X25519'], |
| 247 | 'x448': ['GROUP-X448'], |
| 248 | } |
| 249 | |
| 250 | def pre_checks(self): |
| 251 | return ["requires_gnutls_tls1_3", |
| 252 | "requires_gnutls_next_no_ticket", |
| 253 | "requires_gnutls_next_disable_tls13_compat", ] |
| 254 | |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 255 | def cmd(self): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 256 | ret = super().cmd() |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 257 | |
| 258 | priority_string_list = [] |
| 259 | |
| 260 | def update_priority_string_list(items, map_table): |
| 261 | for item in items: |
| 262 | for i in map_table[item]: |
| 263 | if i not in priority_string_list: |
| 264 | yield i |
| 265 | |
| 266 | if self._ciphers: |
| 267 | priority_string_list.extend(update_priority_string_list( |
| 268 | self._ciphers, self.CIPHER_SUITE)) |
| 269 | else: |
| 270 | priority_string_list.extend(['CIPHER-ALL', 'MAC-ALL']) |
| 271 | |
| 272 | if self._sig_algs: |
| 273 | signature_algorithms = set(self._sig_algs + self._cert_sig_algs) |
| 274 | priority_string_list.extend(update_priority_string_list( |
| 275 | signature_algorithms, self.SIGNATURE_ALGORITHM)) |
| 276 | else: |
| 277 | priority_string_list.append('SIGN-ALL') |
| 278 | |
| 279 | |
| 280 | if self._named_groups: |
| 281 | priority_string_list.extend(update_priority_string_list( |
| 282 | self._named_groups, self.NAMED_GROUP)) |
| 283 | else: |
| 284 | priority_string_list.append('GROUP-ALL') |
| 285 | |
| 286 | priority_string_list = ['NONE'] + \ |
| 287 | priority_string_list + ['VERS-TLS1.3'] |
| 288 | |
| 289 | priority_string = ':+'.join(priority_string_list) |
| 290 | priority_string += ':%NO_TICKETS' |
| 291 | |
| 292 | if not self._compat_mode: |
| 293 | priority_string += [':%DISABLE_TLS13_COMPAT_MODE'] |
| 294 | |
| 295 | ret += ['--priority={priority_string}'.format( |
| 296 | priority_string=priority_string)] |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 297 | return ret |
| 298 | |
| 299 | class GnuTLSServ(GnuTLSBase): |
| 300 | """ |
| 301 | Generate test commands for GnuTLS server. |
| 302 | """ |
| 303 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 304 | def pre_cmd(self): |
| 305 | ret = ['$G_NEXT_SRV_NO_CERT', '--http', '--disable-client-cert', '--debug=4'] |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 306 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 307 | for _, cert, key in map(lambda sig_alg: CERTIFICATES[sig_alg], self._cert_sig_algs): |
| 308 | ret += ['--x509certfile {cert} --x509keyfile {key}'.format( |
| 309 | cert=cert, key=key)] |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 310 | return ret |
| 311 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 312 | def post_checks(self): |
| 313 | return ['-c "HTTP/1.0 200 OK"'] |
| 314 | |
| 315 | |
| 316 | class GnuTLSCli(GnuTLSBase): |
| 317 | """ |
| 318 | Generate test commands for GnuTLS client. |
| 319 | """ |
| 320 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 321 | def pre_cmd(self): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 322 | return ['$G_NEXT_CLI_NO_CERT', '--debug=4', '--single-key-share', |
| 323 | '--x509cafile {cafile}'.format(cafile=CERTIFICATES[self._cert_sig_algs[0]].cafile)] |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 324 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 325 | |
| 326 | class MbedTLSBase(TLSProgram): |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 327 | """ |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 328 | Generate base test commands for mbedTLS. |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 329 | """ |
Jerry Yu | 29deed4 | 2021-11-25 11:09:54 +0800 | [diff] [blame] | 330 | |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 331 | CIPHER_SUITE = { |
| 332 | 'TLS_AES_256_GCM_SHA384': 'TLS1-3-AES-256-GCM-SHA384', |
| 333 | 'TLS_AES_128_GCM_SHA256': 'TLS1-3-AES-128-GCM-SHA256', |
| 334 | 'TLS_CHACHA20_POLY1305_SHA256': 'TLS1-3-CHACHA20-POLY1305-SHA256', |
| 335 | 'TLS_AES_128_CCM_SHA256': 'TLS1-3-AES-128-CCM-SHA256', |
| 336 | 'TLS_AES_128_CCM_8_SHA256': 'TLS1-3-AES-128-CCM-8-SHA256'} |
| 337 | |
Jerry Yu | 7918efe | 2021-12-01 15:29:10 +0800 | [diff] [blame] | 338 | def cmd(self): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 339 | ret = super().cmd() |
| 340 | ret += ['debug_level=4'] |
| 341 | |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 342 | |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 343 | if self._ciphers: |
| 344 | ciphers = ','.join( |
| 345 | map(lambda cipher: self.CIPHER_SUITE[cipher], self._ciphers)) |
| 346 | ret += ["force_ciphersuite={ciphers}".format(ciphers=ciphers)] |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 347 | |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 348 | if self._sig_algs + self._cert_sig_algs: |
| 349 | ret += ['sig_algs={sig_algs}'.format( |
| 350 | sig_algs=','.join(set(self._sig_algs + self._cert_sig_algs)))] |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 351 | |
Jerry Yu | 7918efe | 2021-12-01 15:29:10 +0800 | [diff] [blame] | 352 | if self._named_groups: |
XiaokangQian | 8031ba7 | 2022-03-22 12:53:45 +0000 | [diff] [blame] | 353 | named_groups = ','.join(self._named_groups) |
Jerry Yu | 7918efe | 2021-12-01 15:29:10 +0800 | [diff] [blame] | 354 | ret += ["curves={named_groups}".format(named_groups=named_groups)] |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 355 | return ret |
| 356 | |
| 357 | def pre_checks(self): |
| 358 | ret = ['requires_config_enabled MBEDTLS_DEBUG_C', |
Ronald Cron | 928cbd3 | 2022-10-04 16:14:26 +0200 | [diff] [blame] | 359 | 'requires_config_enabled MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ENABLED'] |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 360 | |
| 361 | if self._compat_mode: |
| 362 | ret += ['requires_config_enabled MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE'] |
| 363 | |
| 364 | if 'rsa_pss_rsae_sha256' in self._sig_algs + self._cert_sig_algs: |
| 365 | ret.append( |
| 366 | 'requires_config_enabled MBEDTLS_X509_RSASSA_PSS_SUPPORT') |
| 367 | return ret |
| 368 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 369 | |
| 370 | class MbedTLSServ(MbedTLSBase): |
| 371 | """ |
| 372 | Generate test commands for mbedTLS server. |
| 373 | """ |
| 374 | |
| 375 | def cmd(self): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 376 | ret = super().cmd() |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 377 | ret += ['tls13_kex_modes=ephemeral cookies=0 tickets=0'] |
Jerry Yu | 7918efe | 2021-12-01 15:29:10 +0800 | [diff] [blame] | 378 | return ret |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 379 | |
| 380 | def pre_checks(self): |
XiaokangQian | 9b938b7 | 2022-06-10 03:10:59 +0000 | [diff] [blame] | 381 | return ['requires_config_enabled MBEDTLS_SSL_SRV_C'] + super().pre_checks() |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 382 | |
| 383 | def post_checks(self): |
Ronald Cron | a1b8f6e | 2022-03-18 14:04:12 +0100 | [diff] [blame] | 384 | check_strings = ["Protocol is TLSv1.3"] |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 385 | if self._ciphers: |
| 386 | check_strings.append( |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 387 | "server hello, chosen ciphersuite: {} ( id={:04d} )".format( |
| 388 | self.CIPHER_SUITE[self._ciphers[0]], |
| 389 | CIPHER_SUITE_IANA_VALUE[self._ciphers[0]])) |
| 390 | if self._sig_algs: |
| 391 | check_strings.append( |
| 392 | "received signature algorithm: 0x{:x}".format( |
| 393 | SIG_ALG_IANA_VALUE[self._sig_algs[0]])) |
| 394 | |
| 395 | for named_group in self._named_groups: |
| 396 | check_strings += ['got named group: {named_group}({iana_value:04x})'.format( |
| 397 | named_group=named_group, |
| 398 | iana_value=NAMED_GROUP_IANA_VALUE[named_group])] |
| 399 | |
Ronald Cron | eac00ad | 2022-09-13 10:16:31 +0200 | [diff] [blame] | 400 | check_strings.append("Certificate verification was skipped") |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 401 | return ['-s "{}"'.format(i) for i in check_strings] |
| 402 | |
| 403 | def pre_cmd(self): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 404 | ret = ['$P_SRV'] |
| 405 | for _, cert, key in map(lambda sig_alg: CERTIFICATES[sig_alg], self._cert_sig_algs): |
| 406 | ret += ['crt_file={cert} key_file={key}'.format(cert=cert, key=key)] |
| 407 | return ret |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 408 | |
XiaokangQian | 9b938b7 | 2022-06-10 03:10:59 +0000 | [diff] [blame] | 409 | def hrr_post_checks(self, named_group): |
| 410 | return ['-s "HRR selected_group: {:s}"'.format(named_group)] |
| 411 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 412 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 413 | class MbedTLSCli(MbedTLSBase): |
| 414 | """ |
| 415 | Generate test commands for mbedTLS client. |
| 416 | """ |
| 417 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 418 | def pre_cmd(self): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 419 | return ['$P_CLI', |
| 420 | 'ca_file={cafile}'.format(cafile=CERTIFICATES[self._cert_sig_algs[0]].cafile)] |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 421 | |
| 422 | def pre_checks(self): |
XiaokangQian | 9b938b7 | 2022-06-10 03:10:59 +0000 | [diff] [blame] | 423 | return ['requires_config_enabled MBEDTLS_SSL_CLI_C'] + super().pre_checks() |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 424 | |
XiaokangQian | 9b938b7 | 2022-06-10 03:10:59 +0000 | [diff] [blame] | 425 | def hrr_post_checks(self, named_group): |
| 426 | ret = ['-c "received HelloRetryRequest message"'] |
| 427 | ret += ['-c "selected_group ( {:d} )"'.format(NAMED_GROUP_IANA_VALUE[named_group])] |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 428 | return ret |
| 429 | |
| 430 | def post_checks(self): |
| 431 | check_strings = ["Protocol is TLSv1.3"] |
| 432 | if self._ciphers: |
| 433 | check_strings.append( |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 434 | "server hello, chosen ciphersuite: ( {:04x} ) - {}".format( |
| 435 | CIPHER_SUITE_IANA_VALUE[self._ciphers[0]], |
| 436 | self.CIPHER_SUITE[self._ciphers[0]])) |
| 437 | if self._sig_algs: |
| 438 | check_strings.append( |
| 439 | "Certificate Verify: Signature algorithm ( {:04x} )".format( |
| 440 | SIG_ALG_IANA_VALUE[self._sig_algs[0]])) |
| 441 | |
| 442 | for named_group in self._named_groups: |
| 443 | check_strings += ['NamedGroup: {named_group} ( {iana_value:x} )'.format( |
| 444 | named_group=named_group, |
| 445 | iana_value=NAMED_GROUP_IANA_VALUE[named_group])] |
| 446 | |
| 447 | check_strings.append("Verifying peer X.509 certificate... ok") |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 448 | return ['-c "{}"'.format(i) for i in check_strings] |
| 449 | |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 450 | |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 451 | SERVER_CLASSES = {'OpenSSL': OpenSSLServ, 'GnuTLS': GnuTLSServ, 'mbedTLS': MbedTLSServ} |
| 452 | CLIENT_CLASSES = {'OpenSSL': OpenSSLCli, 'GnuTLS': GnuTLSCli, 'mbedTLS': MbedTLSCli} |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 453 | |
| 454 | |
Ronald Cron | 9d0a3e8 | 2022-04-05 16:13:38 +0200 | [diff] [blame] | 455 | def generate_compat_test(client=None, server=None, cipher=None, named_group=None, sig_alg=None): |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 456 | """ |
| 457 | Generate test case with `ssl-opt.sh` format. |
| 458 | """ |
Jerry Yu | dda036d | 2021-11-30 11:19:41 +0800 | [diff] [blame] | 459 | name = 'TLS 1.3 {client[0]}->{server[0]}: {cipher},{named_group},{sig_alg}'.format( |
Ronald Cron | df5f868 | 2022-04-05 16:01:03 +0200 | [diff] [blame] | 460 | client=client, server=server, cipher=cipher[4:], sig_alg=sig_alg, named_group=named_group) |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 461 | |
| 462 | server_object = SERVER_CLASSES[server](ciphersuite=cipher, |
| 463 | named_group=named_group, |
| 464 | signature_algorithm=sig_alg, |
| 465 | cert_sig_alg=sig_alg) |
| 466 | client_object = CLIENT_CLASSES[client](ciphersuite=cipher, |
| 467 | named_group=named_group, |
| 468 | signature_algorithm=sig_alg, |
| 469 | cert_sig_alg=sig_alg) |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 470 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 471 | cmd = ['run_test "{}"'.format(name), |
| 472 | '"{}"'.format(' '.join(server_object.cmd())), |
| 473 | '"{}"'.format(' '.join(client_object.cmd())), |
| 474 | '0'] |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 475 | cmd += server_object.post_checks() |
| 476 | cmd += client_object.post_checks() |
| 477 | cmd += ['-C "received HelloRetryRequest message"'] |
| 478 | prefix = ' \\\n' + (' '*9) |
| 479 | cmd = prefix.join(cmd) |
| 480 | return '\n'.join(server_object.pre_checks() + client_object.pre_checks() + [cmd]) |
| 481 | |
| 482 | |
Ronald Cron | 9d0a3e8 | 2022-04-05 16:13:38 +0200 | [diff] [blame] | 483 | def generate_hrr_compat_test(client=None, server=None, |
| 484 | client_named_group=None, server_named_group=None, |
| 485 | cert_sig_alg=None): |
XiaokangQian | 7069cbc | 2022-02-24 08:30:39 +0000 | [diff] [blame] | 486 | """ |
XiaokangQian | eff93f9 | 2022-03-23 06:14:26 +0000 | [diff] [blame] | 487 | Generate Hello Retry Request test case with `ssl-opt.sh` format. |
XiaokangQian | 7069cbc | 2022-02-24 08:30:39 +0000 | [diff] [blame] | 488 | """ |
XiaokangQian | eff93f9 | 2022-03-23 06:14:26 +0000 | [diff] [blame] | 489 | name = 'TLS 1.3 {client[0]}->{server[0]}: HRR {c_named_group} -> {s_named_group}'.format( |
XiaokangQian | 2e17fb8 | 2022-03-28 03:30:05 +0000 | [diff] [blame] | 490 | client=client, server=server, c_named_group=client_named_group, |
| 491 | s_named_group=server_named_group) |
| 492 | server_object = SERVER_CLASSES[server](named_group=server_named_group, |
| 493 | cert_sig_alg=cert_sig_alg) |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 494 | |
XiaokangQian | 2e17fb8 | 2022-03-28 03:30:05 +0000 | [diff] [blame] | 495 | client_object = CLIENT_CLASSES[client](named_group=client_named_group, |
| 496 | cert_sig_alg=cert_sig_alg) |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 497 | client_object.add_named_groups(server_named_group) |
XiaokangQian | 7069cbc | 2022-02-24 08:30:39 +0000 | [diff] [blame] | 498 | |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 499 | cmd = ['run_test "{}"'.format(name), |
| 500 | '"{}"'.format(' '.join(server_object.cmd())), |
| 501 | '"{}"'.format(' '.join(client_object.cmd())), |
| 502 | '0'] |
XiaokangQian | 7069cbc | 2022-02-24 08:30:39 +0000 | [diff] [blame] | 503 | cmd += server_object.post_checks() |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 504 | cmd += client_object.post_checks() |
XiaokangQian | 9b938b7 | 2022-06-10 03:10:59 +0000 | [diff] [blame] | 505 | cmd += server_object.hrr_post_checks(server_named_group) |
| 506 | cmd += client_object.hrr_post_checks(server_named_group) |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 507 | prefix = ' \\\n' + (' '*9) |
| 508 | cmd = prefix.join(cmd) |
| 509 | return '\n'.join(server_object.pre_checks() + |
| 510 | client_object.pre_checks() + |
| 511 | [cmd]) |
Jerry Yu | 7f5e5ad | 2021-11-29 17:37:19 +0800 | [diff] [blame] | 512 | |
| 513 | SSL_OUTPUT_HEADER = '''#!/bin/sh |
Jerry Yu | cdcb683 | 2021-11-29 16:50:13 +0800 | [diff] [blame] | 514 | |
| 515 | # {filename} |
| 516 | # |
| 517 | # Copyright The Mbed TLS Contributors |
| 518 | # SPDX-License-Identifier: Apache-2.0 |
| 519 | # |
| 520 | # Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 521 | # not use this file except in compliance with the License. |
| 522 | # You may obtain a copy of the License at |
| 523 | # |
| 524 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 525 | # |
| 526 | # Unless required by applicable law or agreed to in writing, software |
| 527 | # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 528 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 529 | # See the License for the specific language governing permissions and |
| 530 | # limitations under the License. |
| 531 | # |
| 532 | # Purpose |
| 533 | # |
| 534 | # List TLS1.3 compat test cases. They are generated by |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 535 | # `{cmd}`. |
Jerry Yu | cdcb683 | 2021-11-29 16:50:13 +0800 | [diff] [blame] | 536 | # |
| 537 | # PLEASE DO NOT EDIT THIS FILE. IF NEEDED, PLEASE MODIFY `generate_tls13_compat_tests.py` |
| 538 | # AND REGENERATE THIS FILE. |
| 539 | # |
| 540 | ''' |
Jerry Yu | 29deed4 | 2021-11-25 11:09:54 +0800 | [diff] [blame] | 541 | |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 542 | def main(): |
Jerry Yu | dda036d | 2021-11-30 11:19:41 +0800 | [diff] [blame] | 543 | """ |
| 544 | Main function of this program |
| 545 | """ |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 546 | parser = argparse.ArgumentParser() |
| 547 | |
Jerry Yu | cdcb683 | 2021-11-29 16:50:13 +0800 | [diff] [blame] | 548 | parser.add_argument('-o', '--output', nargs='?', |
Jerry Yu | 7f5e5ad | 2021-11-29 17:37:19 +0800 | [diff] [blame] | 549 | default=None, help='Output file path if `-a` was set') |
Jerry Yu | cdcb683 | 2021-11-29 16:50:13 +0800 | [diff] [blame] | 550 | |
Jerry Yu | c4aa152 | 2021-11-26 11:13:58 +0800 | [diff] [blame] | 551 | parser.add_argument('-a', '--generate-all-tls13-compat-tests', action='store_true', |
| 552 | default=False, help='Generate all available tls13 compat tests') |
| 553 | |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 554 | parser.add_argument('--list-ciphers', action='store_true', |
| 555 | default=False, help='List supported ciphersuites') |
| 556 | |
| 557 | parser.add_argument('--list-sig-algs', action='store_true', |
| 558 | default=False, help='List supported signature algorithms') |
| 559 | |
| 560 | parser.add_argument('--list-named-groups', action='store_true', |
| 561 | default=False, help='List supported named groups') |
| 562 | |
| 563 | parser.add_argument('--list-servers', action='store_true', |
| 564 | default=False, help='List supported TLS servers') |
| 565 | |
| 566 | parser.add_argument('--list-clients', action='store_true', |
| 567 | default=False, help='List supported TLS Clients') |
| 568 | |
Jerry Yu | b4ac8f3 | 2021-12-01 10:41:37 +0800 | [diff] [blame] | 569 | parser.add_argument('server', choices=SERVER_CLASSES.keys(), nargs='?', |
| 570 | default=list(SERVER_CLASSES.keys())[0], |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 571 | help='Choose TLS server program for test') |
Jerry Yu | b4ac8f3 | 2021-12-01 10:41:37 +0800 | [diff] [blame] | 572 | parser.add_argument('client', choices=CLIENT_CLASSES.keys(), nargs='?', |
| 573 | default=list(CLIENT_CLASSES.keys())[0], |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 574 | help='Choose TLS client program for test') |
| 575 | parser.add_argument('cipher', choices=CIPHER_SUITE_IANA_VALUE.keys(), nargs='?', |
| 576 | default=list(CIPHER_SUITE_IANA_VALUE.keys())[0], |
| 577 | help='Choose cipher suite for test') |
| 578 | parser.add_argument('sig_alg', choices=SIG_ALG_IANA_VALUE.keys(), nargs='?', |
| 579 | default=list(SIG_ALG_IANA_VALUE.keys())[0], |
| 580 | help='Choose cipher suite for test') |
| 581 | parser.add_argument('named_group', choices=NAMED_GROUP_IANA_VALUE.keys(), nargs='?', |
| 582 | default=list(NAMED_GROUP_IANA_VALUE.keys())[0], |
| 583 | help='Choose cipher suite for test') |
| 584 | |
| 585 | args = parser.parse_args() |
Jerry Yu | cdcb683 | 2021-11-29 16:50:13 +0800 | [diff] [blame] | 586 | |
Jerry Yu | 7f5e5ad | 2021-11-29 17:37:19 +0800 | [diff] [blame] | 587 | def get_all_test_cases(): |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 588 | # Generate normal compat test cases |
Ronald Cron | 9d0a3e8 | 2022-04-05 16:13:38 +0200 | [diff] [blame] | 589 | for client, server, cipher, named_group, sig_alg in \ |
| 590 | itertools.product(CLIENT_CLASSES.keys(), |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 591 | SERVER_CLASSES.keys(), |
Ronald Cron | 9d0a3e8 | 2022-04-05 16:13:38 +0200 | [diff] [blame] | 592 | CIPHER_SUITE_IANA_VALUE.keys(), |
| 593 | NAMED_GROUP_IANA_VALUE.keys(), |
| 594 | SIG_ALG_IANA_VALUE.keys()): |
XiaokangQian | fb1a3fe | 2022-06-09 06:37:33 +0000 | [diff] [blame] | 595 | if server == 'mbedTLS' or client == 'mbedTLS': |
XiaokangQian | b1847a2 | 2022-06-08 07:49:31 +0000 | [diff] [blame] | 596 | yield generate_compat_test(client=client, server=server, |
XiaokangQian | fb1a3fe | 2022-06-09 06:37:33 +0000 | [diff] [blame] | 597 | cipher=cipher, named_group=named_group, |
| 598 | sig_alg=sig_alg) |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 599 | |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 600 | |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 601 | # Generate Hello Retry Request compat test cases |
XiaokangQian | 2e17fb8 | 2022-03-28 03:30:05 +0000 | [diff] [blame] | 602 | for client, server, client_named_group, server_named_group in \ |
| 603 | itertools.product(CLIENT_CLASSES.keys(), |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 604 | SERVER_CLASSES.keys(), |
XiaokangQian | 2e17fb8 | 2022-03-28 03:30:05 +0000 | [diff] [blame] | 605 | NAMED_GROUP_IANA_VALUE.keys(), |
| 606 | NAMED_GROUP_IANA_VALUE.keys()): |
Jerry Yu | b7c12a4 | 2022-06-12 20:53:02 +0800 | [diff] [blame] | 607 | |
XiaokangQian | 9b938b7 | 2022-06-10 03:10:59 +0000 | [diff] [blame] | 608 | if (client == 'mbedTLS' or server == 'mbedTLS') and \ |
| 609 | client_named_group != server_named_group: |
| 610 | yield generate_hrr_compat_test(client=client, server=server, |
| 611 | client_named_group=client_named_group, |
| 612 | server_named_group=server_named_group, |
| 613 | cert_sig_alg="ecdsa_secp256r1_sha256") |
XiaokangQian | d5d5b60 | 2022-05-23 09:16:20 +0000 | [diff] [blame] | 614 | |
Jerry Yu | 7f5e5ad | 2021-11-29 17:37:19 +0800 | [diff] [blame] | 615 | if args.generate_all_tls13_compat_tests: |
| 616 | if args.output: |
| 617 | with open(args.output, 'w', encoding="utf-8") as f: |
Jerry Yu | b4ac8f3 | 2021-12-01 10:41:37 +0800 | [diff] [blame] | 618 | f.write(SSL_OUTPUT_HEADER.format( |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 619 | filename=os.path.basename(args.output), cmd=' '.join(sys.argv))) |
Jerry Yu | 7f5e5ad | 2021-11-29 17:37:19 +0800 | [diff] [blame] | 620 | f.write('\n\n'.join(get_all_test_cases())) |
Jerry Yu | dda036d | 2021-11-30 11:19:41 +0800 | [diff] [blame] | 621 | f.write('\n') |
Jerry Yu | 7f5e5ad | 2021-11-29 17:37:19 +0800 | [diff] [blame] | 622 | else: |
Jerry Yu | 7de7985 | 2022-03-23 16:50:47 +0800 | [diff] [blame] | 623 | print('\n\n'.join(get_all_test_cases())) |
Jerry Yu | c4aa152 | 2021-11-26 11:13:58 +0800 | [diff] [blame] | 624 | return 0 |
| 625 | |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 626 | if args.list_ciphers or args.list_sig_algs or args.list_named_groups \ |
Jerry Yu | 29deed4 | 2021-11-25 11:09:54 +0800 | [diff] [blame] | 627 | or args.list_servers or args.list_clients: |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 628 | if args.list_ciphers: |
Jerry Yu | 7f5e5ad | 2021-11-29 17:37:19 +0800 | [diff] [blame] | 629 | print(*CIPHER_SUITE_IANA_VALUE.keys()) |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 630 | if args.list_sig_algs: |
Jerry Yu | 7f5e5ad | 2021-11-29 17:37:19 +0800 | [diff] [blame] | 631 | print(*SIG_ALG_IANA_VALUE.keys()) |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 632 | if args.list_named_groups: |
Jerry Yu | 7f5e5ad | 2021-11-29 17:37:19 +0800 | [diff] [blame] | 633 | print(*NAMED_GROUP_IANA_VALUE.keys()) |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 634 | if args.list_servers: |
Jerry Yu | b4ac8f3 | 2021-12-01 10:41:37 +0800 | [diff] [blame] | 635 | print(*SERVER_CLASSES.keys()) |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 636 | if args.list_clients: |
Jerry Yu | b4ac8f3 | 2021-12-01 10:41:37 +0800 | [diff] [blame] | 637 | print(*CLIENT_CLASSES.keys()) |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 638 | return 0 |
Jerry Yu | cdcb683 | 2021-11-29 16:50:13 +0800 | [diff] [blame] | 639 | |
XiaokangQian | a193144 | 2022-03-25 11:58:22 +0000 | [diff] [blame] | 640 | print(generate_compat_test(server=args.server, client=args.client, sig_alg=args.sig_alg, |
| 641 | cipher=args.cipher, named_group=args.named_group)) |
Jerry Yu | cdcb683 | 2021-11-29 16:50:13 +0800 | [diff] [blame] | 642 | return 0 |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 643 | |
Jerry Yu | 29deed4 | 2021-11-25 11:09:54 +0800 | [diff] [blame] | 644 | |
Jerry Yu | 305bfc3 | 2021-11-24 16:04:47 +0800 | [diff] [blame] | 645 | if __name__ == "__main__": |
| 646 | sys.exit(main()) |