1 ## This file is part of Scapy 2 ## Copyright (C) 2007, 2008, 2009 Arnaud Ebalard 3 ## 2015, 2016, 2017 Maxence Tury 4 ## This program is published under a GPLv2 license 5 6 """ 7 TLS server automaton. This makes for a primitive TLS stack. 8 Obviously you need rights for network access. 9 10 We support versions SSLv2 to TLS 1.2, along with many features. 11 There is no session resumption mechanism for now. 12 13 In order to run a server listening on tcp/4433: 14 > from scapy.all import * 15 > t = TLSServerAutomaton(mycert='<cert.pem>', mykey='<key.pem>') 16 > t.run() 17 """ 18 19 from __future__ import print_function 20 import socket 21 22 from scapy.pton_ntop import inet_pton 23 from scapy.utils import randstring, repr_hex 24 from scapy.automaton import ATMT 25 from scapy.layers.tls.automaton import _TLSAutomaton 26 from scapy.layers.tls.cert import PrivKeyRSA, PrivKeyECDSA 27 from scapy.layers.tls.basefields import _tls_version 28 from scapy.layers.tls.session import tlsSession 29 from scapy.layers.tls.handshake import * 30 from scapy.layers.tls.handshake_sslv2 import * 31 from scapy.layers.tls.record import (TLS, TLSAlert, TLSChangeCipherSpec, 32 TLSApplicationData) 33 from scapy.layers.tls.crypto.suites import (_tls_cipher_suites_cls, 34 get_usable_ciphersuites) 35 36 37 class TLSServerAutomaton(_TLSAutomaton): 38 """ 39 A simple TLS test server automaton. Try to overload some states or 40 conditions and see what happens on the other side. 41 42 Because of socket and automaton limitations, for now, the best way to 43 interrupt the server is by sending him 'stop_server'. Interruptions with 44 Ctrl-Z should work, but this might leave a loose listening socket behind. 45 46 In case the server receives a TLSAlert (whatever its type), or a 'goodbye' 47 message in a SSLv2 version, he will close the client session with a 48 similar message, and start waiting for new client connections. 49 50 _'mycert' and 'mykey' may be provided as filenames. They are needed for any 51 server authenticated handshake. 52 _'preferred_ciphersuite' allows the automaton to choose a cipher suite when 53 offered in the ClientHello. If absent, another one will be chosen. 54 _'client_auth' means the client has to provide a certificate. 55 _'is_echo_server' means that everything received will be sent back. 56 _'max_client_idle_time' is the maximum silence duration from the client. 57 Once this limit has been reached, the client (if still here) is dropped, 58 and we wait for a new connection. 59 """ 60 def parse_args(self, server="127.0.0.1", sport=4433, 61 mycert=None, mykey=None, 62 preferred_ciphersuite=None, 63 client_auth=False, 64 is_echo_server=True, 65 max_client_idle_time=60, 66 **kargs): 67 68 super(TLSServerAutomaton, self).parse_args(mycert=mycert, 69 mykey=mykey, 70 **kargs) 71 try: 72 if ':' in server: 73 inet_pton(socket.AF_INET6, server) 74 else: 75 inet_pton(socket.AF_INET, server) 76 tmp = socket.getaddrinfo(server, sport) 77 except: 78 tmp = socket.getaddrinfo(socket.getfqdn(server), sport) 79 80 self.serversocket = None 81 self.ip_family = tmp[0][0] 82 self.local_ip = tmp[0][4][0] 83 self.local_port = sport 84 self.remote_ip = None 85 self.remote_port = None 86 87 self.preferred_ciphersuite = preferred_ciphersuite 88 self.client_auth = client_auth 89 self.is_echo_server = is_echo_server 90 self.max_client_idle_time = max_client_idle_time 91 92 93 def vprint_sessioninfo(self): 94 if self.verbose: 95 s = self.cur_session 96 v = _tls_version[s.tls_version] 97 self.vprint("Version : %s" % v) 98 cs = s.wcs.ciphersuite.name 99 self.vprint("Cipher suite : %s" % cs) 100 ms = s.master_secret 101 self.vprint("Master secret : %s" % repr_hex(ms)) 102 if s.client_certs: 103 self.vprint("Client certificate chain: %r" % s.client_certs) 104 self.vprint() 105 106 def http_sessioninfo(self): 107 header = "HTTP/1.1 200 OK\r\n" 108 header += "Server: Scapy TLS Extension\r\n" 109 header += "Content-type: text/html\r\n" 110 header += "Content-length: %d\r\n\r\n" 111 s = "----- Scapy TLS Server Automaton -----\n\n" 112 s += "Information on current TLS session:\n\n" 113 s += "Local end : %s:%d\n" % (self.local_ip, self.local_port) 114 s += "Remote end : %s:%d\n" % (self.remote_ip, self.remote_port) 115 v = _tls_version[self.cur_session.tls_version] 116 s += "Version : %s\n" % v 117 cs = self.cur_session.wcs.ciphersuite.name 118 s += "Cipher suite : %s\n" % cs 119 ms = self.cur_session.master_secret 120 s += "Master secret : %s\n" % repr_hex(ms) 121 body = "<html><body><pre>%s</pre></body></html>\r\n\r\n" % s 122 answer = (header+body) % len(body) 123 return answer 124 125 126 @ATMT.state(initial=True) 127 def INITIAL(self): 128 self.vprint("Starting TLS server automaton.") 129 self.vprint("Receiving 'stop_server' will cause a graceful exit.") 130 self.vprint("Interrupting with Ctrl-Z might leave a loose socket hanging.") 131 raise self.BIND() 132 133 @ATMT.state() 134 def BIND(self): 135 s = socket.socket(self.ip_family, socket.SOCK_STREAM) 136 self.serversocket = s 137 s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 138 try: 139 s.bind((self.local_ip, self.local_port)) 140 s.listen(1) 141 except: 142 m = "Unable to bind on %s:%d!" % (self.local_ip, self.local_port) 143 self.vprint() 144 self.vprint(m) 145 self.vprint("Maybe some server is already listening there?") 146 self.vprint() 147 raise self.FINAL() 148 raise self.WAITING_CLIENT() 149 150 @ATMT.state() 151 def WAITING_CLIENT(self): 152 self.vprint() 153 self.vprint("Waiting for a new client on %s:%d" % (self.local_ip, 154 self.local_port)) 155 self.socket, addr = self.serversocket.accept() 156 if not isinstance(addr, tuple): 157 addr = self.socket.getpeername() 158 if len(addr) > 2: 159 addr = (addr[0], addr[1]) 160 self.remote_ip, self.remote_port = addr 161 self.vprint("Accepted connection from %s:%d" % (self.remote_ip, 162 self.remote_port)) 163 self.vprint() 164 raise self.INIT_TLS_SESSION() 165 166 @ATMT.state() 167 def INIT_TLS_SESSION(self): 168 """ 169 XXX We should offer the right key according to the client's suites. For 170 now server_rsa_key is only used for RSAkx, but we should try to replace 171 every server_key with both server_rsa_key and server_ecdsa_key. 172 """ 173 self.cur_session = tlsSession(connection_end="server") 174 self.cur_session.server_certs = [self.mycert] 175 self.cur_session.server_key = self.mykey 176 if isinstance(self.mykey, PrivKeyRSA): 177 self.cur_session.server_rsa_key = self.mykey 178 #elif isinstance(self.mykey, PrivKeyECDSA): 179 # self.cur_session.server_ecdsa_key = self.mykey 180 raise self.WAITING_CLIENTFLIGHT1() 181 182 @ATMT.state() 183 def WAITING_CLIENTFLIGHT1(self): 184 self.get_next_msg() 185 raise self.RECEIVED_CLIENTFLIGHT1() 186 187 @ATMT.state() 188 def RECEIVED_CLIENTFLIGHT1(self): 189 pass 190 191 ########################### TLS handshake ################################# 192 193 @ATMT.condition(RECEIVED_CLIENTFLIGHT1, prio=1) 194 def should_handle_ClientHello(self): 195 self.raise_on_packet(TLSClientHello, 196 self.HANDLED_CLIENTHELLO) 197 198 @ATMT.state() 199 def HANDLED_CLIENTHELLO(self): 200 raise self.PREPARE_SERVERFLIGHT1() 201 202 @ATMT.condition(HANDLED_CLIENTHELLO) 203 def should_check_ciphersuites(self): 204 """ 205 We extract cipher suites candidates from the client's proposition. 206 """ 207 if isinstance(self.mykey, PrivKeyRSA): 208 kx = "RSA" 209 elif isinstance(self.mykey, PrivKeyECDSA): 210 kx = "ECDSA" 211 if get_usable_ciphersuites(self.cur_pkt.ciphers, kx): 212 return 213 raise self.NO_USABLE_CIPHERSUITE() 214 215 @ATMT.state() 216 def NO_USABLE_CIPHERSUITE(self): 217 self.vprint("No usable cipher suite!") 218 raise self.CLOSE_NOTIFY() 219 220 @ATMT.condition(RECEIVED_CLIENTFLIGHT1, prio=3) 221 def missing_ClientHello(self): 222 raise self.MISSING_CLIENTHELLO() 223 224 @ATMT.state(final=True) 225 def MISSING_CLIENTHELLO(self): 226 self.vprint("Missing ClientHello message!") 227 raise self.CLOSE_NOTIFY() 228 229 @ATMT.state() 230 def PREPARE_SERVERFLIGHT1(self): 231 self.add_record() 232 233 @ATMT.condition(PREPARE_SERVERFLIGHT1) 234 def should_add_ServerHello(self): 235 """ 236 Selecting a cipher suite should be no trouble as we already caught 237 the None case previously. 238 239 Also, we do not manage extensions at all. 240 """ 241 if isinstance(self.mykey, PrivKeyRSA): 242 kx = "RSA" 243 elif isinstance(self.mykey, PrivKeyECDSA): 244 kx = "ECDSA" 245 usable_suites = get_usable_ciphersuites(self.cur_pkt.ciphers, kx) 246 c = usable_suites[0] 247 if self.preferred_ciphersuite in usable_suites: 248 c = self.preferred_ciphersuite 249 self.add_msg(TLSServerHello(cipher=c)) 250 raise self.ADDED_SERVERHELLO() 251 252 @ATMT.state() 253 def ADDED_SERVERHELLO(self): 254 pass 255 256 @ATMT.condition(ADDED_SERVERHELLO) 257 def should_add_Certificate(self): 258 c = self.buffer_out[-1].msg[0].cipher 259 if not _tls_cipher_suites_cls[c].kx_alg.anonymous: 260 self.add_msg(TLSCertificate(certs=self.cur_session.server_certs)) 261 raise self.ADDED_CERTIFICATE() 262 263 @ATMT.state() 264 def ADDED_CERTIFICATE(self): 265 pass 266 267 @ATMT.condition(ADDED_CERTIFICATE) 268 def should_add_ServerKeyExchange(self): 269 c = self.buffer_out[-1].msg[0].cipher 270 if not _tls_cipher_suites_cls[c].kx_alg.no_ske: 271 self.add_msg(TLSServerKeyExchange()) 272 raise self.ADDED_SERVERKEYEXCHANGE() 273 274 @ATMT.state() 275 def ADDED_SERVERKEYEXCHANGE(self): 276 pass 277 278 @ATMT.condition(ADDED_SERVERKEYEXCHANGE) 279 def should_add_CertificateRequest(self): 280 if self.client_auth: 281 self.add_msg(TLSCertificateRequest()) 282 raise self.ADDED_CERTIFICATEREQUEST() 283 284 @ATMT.state() 285 def ADDED_CERTIFICATEREQUEST(self): 286 pass 287 288 @ATMT.condition(ADDED_CERTIFICATEREQUEST) 289 def should_add_ServerHelloDone(self): 290 self.add_msg(TLSServerHelloDone()) 291 raise self.ADDED_SERVERHELLODONE() 292 293 @ATMT.state() 294 def ADDED_SERVERHELLODONE(self): 295 pass 296 297 @ATMT.condition(ADDED_SERVERHELLODONE) 298 def should_send_ServerFlight1(self): 299 self.flush_records() 300 raise self.WAITING_CLIENTFLIGHT2() 301 302 @ATMT.state() 303 def WAITING_CLIENTFLIGHT2(self): 304 self.get_next_msg() 305 raise self.RECEIVED_CLIENTFLIGHT2() 306 307 @ATMT.state() 308 def RECEIVED_CLIENTFLIGHT2(self): 309 pass 310 311 @ATMT.condition(RECEIVED_CLIENTFLIGHT2, prio=1) 312 def should_handle_ClientCertificate(self): 313 self.raise_on_packet(TLSCertificate, 314 self.HANDLED_CLIENTCERTIFICATE) 315 316 @ATMT.condition(RECEIVED_CLIENTFLIGHT2, prio=2) 317 def no_ClientCertificate(self): 318 if self.client_auth: 319 raise self.MISSING_CLIENTCERTIFICATE() 320 raise self.HANDLED_CLIENTCERTIFICATE() 321 322 @ATMT.state() 323 def MISSING_CLIENTCERTIFICATE(self): 324 self.vprint("Missing ClientCertificate!") 325 raise self.CLOSE_NOTIFY() 326 327 @ATMT.state() 328 def HANDLED_CLIENTCERTIFICATE(self): 329 if self.client_auth: 330 self.vprint("Received client certificate chain...") 331 332 @ATMT.condition(HANDLED_CLIENTCERTIFICATE, prio=1) 333 def should_handle_ClientKeyExchange(self): 334 self.raise_on_packet(TLSClientKeyExchange, 335 self.HANDLED_CLIENTKEYEXCHANGE) 336 337 @ATMT.state() 338 def HANDLED_CLIENTKEYEXCHANGE(self): 339 pass 340 341 @ATMT.condition(HANDLED_CLIENTCERTIFICATE, prio=2) 342 def should_handle_Alert_from_ClientCertificate(self): 343 self.raise_on_packet(TLSAlert, 344 self.HANDLED_ALERT_FROM_CLIENTCERTIFICATE) 345 346 @ATMT.state() 347 def HANDLED_ALERT_FROM_CLIENTCERTIFICATE(self): 348 self.vprint("Received Alert message instead of ClientKeyExchange!") 349 raise self.CLOSE_NOTIFY() 350 351 @ATMT.condition(HANDLED_CLIENTCERTIFICATE, prio=3) 352 def missing_ClientKeyExchange(self): 353 raise self.MISSING_CLIENTKEYEXCHANGE() 354 355 @ATMT.state() 356 def MISSING_CLIENTKEYEXCHANGE(self): 357 self.vprint("Missing ClientKeyExchange!") 358 raise self.CLOSE_NOTIFY() 359 360 @ATMT.condition(HANDLED_CLIENTKEYEXCHANGE, prio=1) 361 def should_handle_CertificateVerify(self): 362 self.raise_on_packet(TLSCertificateVerify, 363 self.HANDLED_CERTIFICATEVERIFY) 364 365 @ATMT.condition(HANDLED_CLIENTKEYEXCHANGE, prio=2) 366 def no_CertificateVerify(self): 367 if self.client_auth: 368 raise self.MISSING_CERTIFICATEVERIFY() 369 raise self.HANDLED_CERTIFICATEVERIFY() 370 371 @ATMT.state() 372 def MISSING_CERTIFICATEVERIFY(self): 373 self.vprint("Missing CertificateVerify!") 374 raise self.CLOSE_NOTIFY() 375 376 @ATMT.state() 377 def HANDLED_CERTIFICATEVERIFY(self): 378 pass 379 380 @ATMT.condition(HANDLED_CERTIFICATEVERIFY, prio=1) 381 def should_handle_ChangeCipherSpec(self): 382 self.raise_on_packet(TLSChangeCipherSpec, 383 self.HANDLED_CHANGECIPHERSPEC) 384 385 @ATMT.state() 386 def HANDLED_CHANGECIPHERSPEC(self): 387 pass 388 389 @ATMT.condition(HANDLED_CERTIFICATEVERIFY, prio=2) 390 def should_handle_Alert_from_ClientKeyExchange(self): 391 self.raise_on_packet(TLSAlert, 392 self.HANDLED_ALERT_FROM_CLIENTKEYEXCHANGE) 393 394 @ATMT.state() 395 def HANDLED_ALERT_FROM_CLIENTKEYEXCHANGE(self): 396 self.vprint("Received Alert message instead of ChangeCipherSpec!") 397 raise self.CLOSE_NOTIFY() 398 399 @ATMT.condition(HANDLED_CERTIFICATEVERIFY, prio=3) 400 def missing_ChangeCipherSpec(self): 401 raise self.MISSING_CHANGECIPHERSPEC() 402 403 @ATMT.state() 404 def MISSING_CHANGECIPHERSPEC(self): 405 self.vprint("Missing ChangeCipherSpec!") 406 raise self.CLOSE_NOTIFY() 407 408 @ATMT.condition(HANDLED_CHANGECIPHERSPEC, prio=1) 409 def should_handle_ClientFinished(self): 410 self.raise_on_packet(TLSFinished, 411 self.HANDLED_CLIENTFINISHED) 412 413 @ATMT.state() 414 def HANDLED_CLIENTFINISHED(self): 415 raise self.PREPARE_SERVERFLIGHT2() 416 417 @ATMT.condition(HANDLED_CHANGECIPHERSPEC, prio=2) 418 def should_handle_Alert_from_ClientFinished(self): 419 self.raise_on_packet(TLSAlert, 420 self.HANDLED_ALERT_FROM_CHANGECIPHERSPEC) 421 422 @ATMT.state() 423 def HANDLED_ALERT_FROM_CHANGECIPHERSPEC(self): 424 self.vprint("Received Alert message instead of Finished!") 425 raise self.CLOSE_NOTIFY() 426 427 @ATMT.condition(HANDLED_CHANGECIPHERSPEC, prio=3) 428 def missing_ClientFinished(self): 429 raise self.MISSING_CLIENTFINISHED() 430 431 @ATMT.state() 432 def MISSING_CLIENTFINISHED(self): 433 self.vprint("Missing Finished!") 434 raise self.CLOSE_NOTIFY() 435 436 @ATMT.state() 437 def PREPARE_SERVERFLIGHT2(self): 438 self.add_record() 439 440 @ATMT.condition(PREPARE_SERVERFLIGHT2) 441 def should_add_ChangeCipherSpec(self): 442 self.add_msg(TLSChangeCipherSpec()) 443 raise self.ADDED_CHANGECIPHERSPEC() 444 445 @ATMT.state() 446 def ADDED_CHANGECIPHERSPEC(self): 447 pass 448 449 @ATMT.condition(ADDED_CHANGECIPHERSPEC) 450 def should_add_ServerFinished(self): 451 self.add_record() 452 self.add_msg(TLSFinished()) 453 raise self.ADDED_SERVERFINISHED() 454 455 @ATMT.state() 456 def ADDED_SERVERFINISHED(self): 457 pass 458 459 @ATMT.condition(ADDED_SERVERFINISHED) 460 def should_send_ServerFlight2(self): 461 self.flush_records() 462 raise self.SENT_SERVERFLIGHT2() 463 464 @ATMT.state() 465 def SENT_SERVERFLIGHT2(self): 466 self.vprint("TLS handshake completed!") 467 self.vprint_sessioninfo() 468 if self.is_echo_server: 469 self.vprint("Will now act as a simple echo server.") 470 raise self.WAITING_CLIENTDATA() 471 472 ####################### end of TLS handshake ############################## 473 474 @ATMT.state() 475 def WAITING_CLIENTDATA(self): 476 self.get_next_msg(self.max_client_idle_time, 1) 477 raise self.RECEIVED_CLIENTDATA() 478 479 @ATMT.state() 480 def RECEIVED_CLIENTDATA(self): 481 pass 482 483 @ATMT.condition(RECEIVED_CLIENTDATA) 484 def should_handle_ClientData(self): 485 if not self.buffer_in: 486 self.vprint("Client idle time maxed out.") 487 raise self.CLOSE_NOTIFY() 488 p = self.buffer_in[0] 489 self.buffer_in = self.buffer_in[1:] 490 491 recv_data = b"" 492 if isinstance(p, TLSApplicationData): 493 print("> Received: %r" % p.data) 494 recv_data = p.data 495 lines = recv_data.split(b"\n") 496 stop = False 497 for l in lines: 498 if l.startswith(b"stop_server"): 499 stop = True 500 break 501 if stop: 502 raise self.CLOSE_NOTIFY_FINAL() 503 elif isinstance(p, TLSAlert): 504 print("> Received: %r" % p) 505 raise self.CLOSE_NOTIFY() 506 else: 507 print("> Received: %r" % p) 508 509 if recv_data.startswith(b"GET / HTTP/1.1"): 510 p = TLSApplicationData(data=self.http_sessioninfo()) 511 512 if self.is_echo_server or recv_data.startswith(b"GET / HTTP/1.1"): 513 self.add_record() 514 self.add_msg(p) 515 raise self.ADDED_SERVERDATA() 516 517 raise self.HANDLED_CLIENTDATA() 518 519 @ATMT.state() 520 def HANDLED_CLIENTDATA(self): 521 raise self.WAITING_CLIENTDATA() 522 523 @ATMT.state() 524 def ADDED_SERVERDATA(self): 525 pass 526 527 @ATMT.condition(ADDED_SERVERDATA) 528 def should_send_ServerData(self): 529 self.flush_records() 530 raise self.SENT_SERVERDATA() 531 532 @ATMT.state() 533 def SENT_SERVERDATA(self): 534 raise self.WAITING_CLIENTDATA() 535 536 @ATMT.state() 537 def CLOSE_NOTIFY(self): 538 self.vprint() 539 self.vprint("Sending a TLSAlert to the client...") 540 541 @ATMT.condition(CLOSE_NOTIFY) 542 def close_session(self): 543 self.add_record() 544 self.add_msg(TLSAlert(level=1, descr=0)) 545 try: 546 self.flush_records() 547 except: 548 self.vprint("Could not send termination Alert, maybe the client left?") 549 self.buffer_out = [] 550 self.socket.close() 551 raise self.WAITING_CLIENT() 552 553 @ATMT.state() 554 def CLOSE_NOTIFY_FINAL(self): 555 self.vprint() 556 self.vprint("Sending a TLSAlert to the client...") 557 558 @ATMT.condition(CLOSE_NOTIFY_FINAL) 559 def close_session_final(self): 560 self.add_record() 561 self.add_msg(TLSAlert(level=1, descr=0)) 562 try: 563 self.flush_records() 564 except: 565 self.vprint("Could not send termination Alert, maybe the client left?") 566 # We might call shutdown, but unit tests with s_client fail with this. 567 #self.socket.shutdown(1) 568 self.socket.close() 569 raise self.FINAL() 570 571 ########################## SSLv2 handshake ################################ 572 573 @ATMT.condition(RECEIVED_CLIENTFLIGHT1, prio=2) 574 def sslv2_should_handle_ClientHello(self): 575 self.raise_on_packet(SSLv2ClientHello, 576 self.SSLv2_HANDLED_CLIENTHELLO) 577 578 @ATMT.state() 579 def SSLv2_HANDLED_CLIENTHELLO(self): 580 pass 581 582 @ATMT.condition(SSLv2_HANDLED_CLIENTHELLO) 583 def sslv2_should_add_ServerHello(self): 584 self.add_record(is_sslv2=True) 585 cert = self.mycert 586 ciphers = [0x010080, 0x020080, 0x030080, 0x040080, 587 0x050080, 0x060040, 0x0700C0] 588 connection_id = randstring(16) 589 p = SSLv2ServerHello(cert=cert, 590 ciphers=ciphers, 591 connection_id=connection_id) 592 self.add_msg(p) 593 raise self.SSLv2_ADDED_SERVERHELLO() 594 595 @ATMT.state() 596 def SSLv2_ADDED_SERVERHELLO(self): 597 pass 598 599 @ATMT.condition(SSLv2_ADDED_SERVERHELLO) 600 def sslv2_should_send_ServerHello(self): 601 self.flush_records() 602 raise self.SSLv2_SENT_SERVERHELLO() 603 604 @ATMT.state() 605 def SSLv2_SENT_SERVERHELLO(self): 606 raise self.SSLv2_WAITING_CLIENTMASTERKEY() 607 608 @ATMT.state() 609 def SSLv2_WAITING_CLIENTMASTERKEY(self): 610 self.get_next_msg() 611 raise self.SSLv2_RECEIVED_CLIENTMASTERKEY() 612 613 @ATMT.state() 614 def SSLv2_RECEIVED_CLIENTMASTERKEY(self): 615 pass 616 617 @ATMT.condition(SSLv2_RECEIVED_CLIENTMASTERKEY, prio=1) 618 def sslv2_should_handle_ClientMasterKey(self): 619 self.raise_on_packet(SSLv2ClientMasterKey, 620 self.SSLv2_HANDLED_CLIENTMASTERKEY) 621 622 @ATMT.condition(SSLv2_RECEIVED_CLIENTMASTERKEY, prio=2) 623 def missing_ClientMasterKey(self): 624 raise self.SSLv2_MISSING_CLIENTMASTERKEY() 625 626 @ATMT.state() 627 def SSLv2_MISSING_CLIENTMASTERKEY(self): 628 self.vprint("Missing SSLv2 ClientMasterKey!") 629 raise self.SSLv2_CLOSE_NOTIFY() 630 631 @ATMT.state() 632 def SSLv2_HANDLED_CLIENTMASTERKEY(self): 633 raise self.SSLv2_RECEIVED_CLIENTFINISHED() 634 635 @ATMT.state() 636 def SSLv2_RECEIVED_CLIENTFINISHED(self): 637 pass 638 639 @ATMT.condition(SSLv2_RECEIVED_CLIENTFINISHED, prio=1) 640 def sslv2_should_handle_ClientFinished(self): 641 self.raise_on_packet(SSLv2ClientFinished, 642 self.SSLv2_HANDLED_CLIENTFINISHED) 643 644 @ATMT.state() 645 def SSLv2_HANDLED_CLIENTFINISHED(self): 646 pass 647 648 @ATMT.condition(SSLv2_HANDLED_CLIENTFINISHED, prio=1) 649 def sslv2_should_add_ServerVerify_from_ClientFinished(self): 650 hs_msg = [type(m) for m in self.cur_session.handshake_messages_parsed] 651 if SSLv2ServerVerify in hs_msg: 652 return 653 self.add_record(is_sslv2=True) 654 p = SSLv2ServerVerify(challenge=self.cur_session.sslv2_challenge) 655 self.add_msg(p) 656 raise self.SSLv2_ADDED_SERVERVERIFY() 657 658 @ATMT.condition(SSLv2_RECEIVED_CLIENTFINISHED, prio=2) 659 def sslv2_should_add_ServerVerify_from_NoClientFinished(self): 660 hs_msg = [type(m) for m in self.cur_session.handshake_messages_parsed] 661 if SSLv2ServerVerify in hs_msg: 662 return 663 self.add_record(is_sslv2=True) 664 p = SSLv2ServerVerify(challenge=self.cur_session.sslv2_challenge) 665 self.add_msg(p) 666 raise self.SSLv2_ADDED_SERVERVERIFY() 667 668 @ATMT.condition(SSLv2_RECEIVED_CLIENTFINISHED, prio=3) 669 def sslv2_missing_ClientFinished(self): 670 raise self.SSLv2_MISSING_CLIENTFINISHED() 671 672 @ATMT.state() 673 def SSLv2_MISSING_CLIENTFINISHED(self): 674 self.vprint("Missing SSLv2 ClientFinished!") 675 raise self.SSLv2_CLOSE_NOTIFY() 676 677 @ATMT.state() 678 def SSLv2_ADDED_SERVERVERIFY(self): 679 pass 680 681 @ATMT.condition(SSLv2_ADDED_SERVERVERIFY) 682 def sslv2_should_send_ServerVerify(self): 683 self.flush_records() 684 raise self.SSLv2_SENT_SERVERVERIFY() 685 686 @ATMT.state() 687 def SSLv2_SENT_SERVERVERIFY(self): 688 hs_msg = [type(m) for m in self.cur_session.handshake_messages_parsed] 689 if SSLv2ClientFinished in hs_msg: 690 raise self.SSLv2_HANDLED_CLIENTFINISHED() 691 else: 692 raise self.SSLv2_RECEIVED_CLIENTFINISHED() 693 694 ####################### SSLv2 client authentication ####################### 695 696 @ATMT.condition(SSLv2_HANDLED_CLIENTFINISHED, prio=2) 697 def sslv2_should_add_RequestCertificate(self): 698 hs_msg = [type(m) for m in self.cur_session.handshake_messages_parsed] 699 if not self.client_auth or SSLv2RequestCertificate in hs_msg: 700 return 701 self.add_record(is_sslv2=True) 702 self.add_msg(SSLv2RequestCertificate(challenge=randstring(16))) 703 raise self.SSLv2_ADDED_REQUESTCERTIFICATE() 704 705 @ATMT.state() 706 def SSLv2_ADDED_REQUESTCERTIFICATE(self): 707 pass 708 709 @ATMT.condition(SSLv2_ADDED_REQUESTCERTIFICATE) 710 def sslv2_should_send_RequestCertificate(self): 711 self.flush_records() 712 raise self.SSLv2_SENT_REQUESTCERTIFICATE() 713 714 @ATMT.state() 715 def SSLv2_SENT_REQUESTCERTIFICATE(self): 716 raise self.SSLv2_WAITING_CLIENTCERTIFICATE() 717 718 @ATMT.state() 719 def SSLv2_WAITING_CLIENTCERTIFICATE(self): 720 self.get_next_msg() 721 raise self.SSLv2_RECEIVED_CLIENTCERTIFICATE() 722 723 @ATMT.state() 724 def SSLv2_RECEIVED_CLIENTCERTIFICATE(self): 725 pass 726 727 @ATMT.condition(SSLv2_RECEIVED_CLIENTCERTIFICATE, prio=1) 728 def sslv2_should_handle_ClientCertificate(self): 729 self.raise_on_packet(SSLv2ClientCertificate, 730 self.SSLv2_HANDLED_CLIENTCERTIFICATE) 731 732 @ATMT.condition(SSLv2_RECEIVED_CLIENTCERTIFICATE, prio=2) 733 def sslv2_missing_ClientCertificate(self): 734 raise self.SSLv2_MISSING_CLIENTCERTIFICATE() 735 736 @ATMT.state() 737 def SSLv2_MISSING_CLIENTCERTIFICATE(self): 738 self.vprint("Missing SSLv2 ClientCertificate!") 739 raise self.SSLv2_CLOSE_NOTIFY() 740 741 @ATMT.state() 742 def SSLv2_HANDLED_CLIENTCERTIFICATE(self): 743 selv.vprint("Received client certificate...") 744 # We could care about the client CA, but we don't. 745 raise self.SSLv2_HANDLED_CLIENTFINISHED() 746 747 ################### end of SSLv2 client authentication #################### 748 749 @ATMT.condition(SSLv2_HANDLED_CLIENTFINISHED, prio=3) 750 def sslv2_should_add_ServerFinished(self): 751 self.add_record(is_sslv2=True) 752 self.add_msg(SSLv2ServerFinished(sid=randstring(16))) 753 raise self.SSLv2_ADDED_SERVERFINISHED() 754 755 @ATMT.state() 756 def SSLv2_ADDED_SERVERFINISHED(self): 757 pass 758 759 @ATMT.condition(SSLv2_ADDED_SERVERFINISHED) 760 def sslv2_should_send_ServerFinished(self): 761 self.flush_records() 762 raise self.SSLv2_SENT_SERVERFINISHED() 763 764 @ATMT.state() 765 def SSLv2_SENT_SERVERFINISHED(self): 766 self.vprint("SSLv2 handshake completed!") 767 self.vprint_sessioninfo() 768 if self.is_echo_server: 769 self.vprint("Will now act as a simple echo server.") 770 raise self.SSLv2_WAITING_CLIENTDATA() 771 772 ######################## end of SSLv2 handshake ########################### 773 774 @ATMT.state() 775 def SSLv2_WAITING_CLIENTDATA(self): 776 self.get_next_msg(self.max_client_idle_time, 1) 777 raise self.SSLv2_RECEIVED_CLIENTDATA() 778 779 @ATMT.state() 780 def SSLv2_RECEIVED_CLIENTDATA(self): 781 pass 782 783 @ATMT.condition(SSLv2_RECEIVED_CLIENTDATA) 784 def sslv2_should_handle_ClientData(self): 785 if not self.buffer_in: 786 self.vprint("Client idle time maxed out.") 787 raise self.SSLv2_CLOSE_NOTIFY() 788 p = self.buffer_in[0] 789 self.buffer_in = self.buffer_in[1:] 790 if hasattr(p, "load"): 791 cli_data = p.load 792 print("> Received: %r" % cli_data) 793 if cli_data.startswith(b"goodbye"): 794 self.vprint() 795 self.vprint("Seems like the client left...") 796 raise self.WAITING_CLIENT() 797 else: 798 cli_data = str(p) 799 print("> Received: %r" % p) 800 801 lines = cli_data.split(b"\n") 802 stop = False 803 for l in lines: 804 if l.startswith(b"stop_server"): 805 stop = True 806 break 807 if stop: 808 raise self.SSLv2_CLOSE_NOTIFY_FINAL() 809 810 answer = b"" 811 if cli_data.startswith(b"GET / HTTP/1.1"): 812 p = Raw(self.http_sessioninfo()) 813 814 if self.is_echo_server or recv_data.startswith(b"GET / HTTP/1.1"): 815 self.add_record(is_sslv2=True) 816 self.add_msg(p) 817 raise self.SSLv2_ADDED_SERVERDATA() 818 819 raise self.SSLv2_HANDLED_CLIENTDATA() 820 821 @ATMT.state() 822 def SSLv2_HANDLED_CLIENTDATA(self): 823 raise self.SSLv2_WAITING_CLIENTDATA() 824 825 @ATMT.state() 826 def SSLv2_ADDED_SERVERDATA(self): 827 pass 828 829 @ATMT.condition(SSLv2_ADDED_SERVERDATA) 830 def sslv2_should_send_ServerData(self): 831 self.flush_records() 832 raise self.SSLv2_SENT_SERVERDATA() 833 834 @ATMT.state() 835 def SSLv2_SENT_SERVERDATA(self): 836 raise self.SSLv2_WAITING_CLIENTDATA() 837 838 @ATMT.state() 839 def SSLv2_CLOSE_NOTIFY(self): 840 """ 841 There is no proper way to end an SSLv2 session. 842 We try and send a 'goodbye' message as a substitute. 843 """ 844 self.vprint() 845 self.vprint("Trying to send 'goodbye' to the client...") 846 847 @ATMT.condition(SSLv2_CLOSE_NOTIFY) 848 def sslv2_close_session(self): 849 self.add_record() 850 self.add_msg(Raw('goodbye')) 851 try: 852 self.flush_records() 853 except: 854 self.vprint("Could not send our goodbye. The client probably left.") 855 self.buffer_out = [] 856 self.socket.close() 857 raise self.WAITING_CLIENT() 858 859 @ATMT.state() 860 def SSLv2_CLOSE_NOTIFY_FINAL(self): 861 """ 862 There is no proper way to end an SSLv2 session. 863 We try and send a 'goodbye' message as a substitute. 864 """ 865 self.vprint() 866 self.vprint("Trying to send 'goodbye' to the client...") 867 868 @ATMT.condition(SSLv2_CLOSE_NOTIFY_FINAL) 869 def sslv2_close_session_final(self): 870 self.add_record() 871 self.add_msg(Raw('goodbye')) 872 try: 873 self.flush_records() 874 except: 875 self.vprint("Could not send our goodbye. The client probably left.") 876 self.socket.close() 877 raise self.FINAL() 878 879 @ATMT.state(final=True) 880 def FINAL(self): 881 self.vprint("Closing server socket...") 882 self.serversocket.close() 883 self.vprint("Ending TLS server automaton.") 884 885