util/TLSProxy/Message.pm

   1 # Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   2 #
   3 # Licensed under the OpenSSL license (the "License").  You may not use
   4 # this file except in compliance with the License.  You can obtain a copy
   5 # in the file LICENSE in the source distribution or at
   6 # https://www.openssl.org/source/license.html
   7
   8 use strict;
   9
  10 package TLSProxy::Message;
  11
  12 use constant TLS_MESSAGE_HEADER_LENGTH => 4;
  13
  14 #Message types
  15 use constant {
  16     MT_HELLO_REQUEST => 0,
  17     MT_CLIENT_HELLO => 1,
  18     MT_SERVER_HELLO => 2,
  19     MT_NEW_SESSION_TICKET => 4,
  20     MT_HELLO_RETRY_REQUEST => 6,
  21     MT_ENCRYPTED_EXTENSIONS => 8,
  22     MT_CERTIFICATE => 11,
  23     MT_SERVER_KEY_EXCHANGE => 12,
  24     MT_CERTIFICATE_REQUEST => 13,
  25     MT_SERVER_HELLO_DONE => 14,
  26     MT_CERTIFICATE_VERIFY => 15,
  27     MT_CLIENT_KEY_EXCHANGE => 16,
  28     MT_FINISHED => 20,
  29     MT_CERTIFICATE_STATUS => 22,
  30     MT_NEXT_PROTO => 67
  31 };
  32
  33 #Alert levels
  34 use constant {
  35     AL_LEVEL_WARN => 1,
  36     AL_LEVEL_FATAL => 2
  37 };
  38
  39 #Alert descriptions
  40 use constant {
  41     AL_DESC_CLOSE_NOTIFY => 0,
  42     AL_DESC_UNEXPECTED_MESSAGE => 10,
  43     AL_DESC_NO_RENEGOTIATION => 100
  44 };
  45
  46 my %message_type = (
  47     MT_HELLO_REQUEST, "HelloRequest",
  48     MT_CLIENT_HELLO, "ClientHello",
  49     MT_SERVER_HELLO, "ServerHello",
  50     MT_NEW_SESSION_TICKET, "NewSessionTicket",
  51     MT_HELLO_RETRY_REQUEST, "HelloRetryRequest",
  52     MT_ENCRYPTED_EXTENSIONS, "EncryptedExtensions",
  53     MT_CERTIFICATE, "Certificate",
  54     MT_SERVER_KEY_EXCHANGE, "ServerKeyExchange",
  55     MT_CERTIFICATE_REQUEST, "CertificateRequest",
  56     MT_SERVER_HELLO_DONE, "ServerHelloDone",
  57     MT_CERTIFICATE_VERIFY, "CertificateVerify",
  58     MT_CLIENT_KEY_EXCHANGE, "ClientKeyExchange",
  59     MT_FINISHED, "Finished",
  60     MT_CERTIFICATE_STATUS, "CertificateStatus",
  61     MT_NEXT_PROTO, "NextProto"
  62 );
  63
  64 use constant {
  65     EXT_SERVER_NAME => 0,
  66     EXT_STATUS_REQUEST => 5,
  67     EXT_SUPPORTED_GROUPS => 10,
  68     EXT_EC_POINT_FORMATS => 11,
  69     EXT_SRP => 12,
  70     EXT_SIG_ALGS => 13,
  71     EXT_USE_SRTP => 14,
  72     EXT_ALPN => 16,
  73     EXT_SCT => 18,
  74     EXT_PADDING => 21,
  75     EXT_ENCRYPT_THEN_MAC => 22,
  76     EXT_EXTENDED_MASTER_SECRET => 23,
  77     EXT_SESSION_TICKET => 35,
  78     EXT_KEY_SHARE => 40,
  79     EXT_PSK => 41,
  80     EXT_SUPPORTED_VERSIONS => 43,
  81     EXT_COOKIE => 44,
  82     EXT_PSK_KEX_MODES => 45,
  83     EXT_RENEGOTIATE => 65281,
  84     EXT_NPN => 13172,
  85     # This extension is an unofficial extension only ever written by OpenSSL
  86     # (i.e. not read), and even then only when enabled. We use it to test
  87     # handling of duplicate extensions.
  88     EXT_DUPLICATE_EXTENSION => 0xfde8,
  89     #Unknown extension that should appear last
  90     EXT_FORCE_LAST => 0xffff
  91 };
  92
  93 use constant {
  94     CIPHER_DHE_RSA_AES_128_SHA => 0x0033,
  95     CIPHER_ADH_AES_128_SHA => 0x0034
  96 };
  97
  98 my $payload = "";
  99 my $messlen = -1;
 100 my $mt;
 101 my $startoffset = -1;
 102 my $server = 0;
 103 my $success = 0;
 104 my $end = 0;
 105 my @message_rec_list = ();
 106 my @message_frag_lens = ();
 107 my $ciphersuite = 0;
 108 my $successondata = 0;
 109
 110 sub clear
 111 {
 112     $payload = "";
 113     $messlen = -1;
 114     $startoffset = -1;
 115     $server = 0;
 116     $success = 0;
 117     $end = 0;
 118     $successondata = 0;
 119     @message_rec_list = ();
 120     @message_frag_lens = ();
 121 }
 122
 123 #Class method to extract messages from a record
 124 sub get_messages
 125 {
 126     my $class = shift;
 127     my $serverin = shift;
 128     my $record = shift;
 129     my @messages = ();
 130     my $message;
 131
 132     @message_frag_lens = ();
 133
 134     if ($serverin != $server && length($payload) != 0) {
 135         die "Changed peer, but we still have fragment data\n";
 136     }
 137     $server = $serverin;
 138
 139     if ($record->content_type == TLSProxy::Record::RT_CCS) {
 140         if ($payload ne "") {
 141             #We can't handle this yet
 142             die "CCS received before message data complete\n";
 143         }
 144         if ($server) {
 145             TLSProxy::Record->server_encrypting(1);
 146         } else {
 147             TLSProxy::Record->client_encrypting(1);
 148         }
 149     } elsif ($record->content_type == TLSProxy::Record::RT_HANDSHAKE) {
 150         if ($record->len == 0 || $record->len_real == 0) {
 151             print "  Message truncated\n";
 152         } else {
 153             my $recoffset = 0;
 154
 155             if (length $payload > 0) {
 156                 #We are continuing processing a message started in a previous
 157                 #record. Add this record to the list associated with this
 158                 #message
 159                 push @message_rec_list, $record;
 160
 161                 if ($messlen <= length($payload)) {
 162                     #Shouldn't happen
 163                     die "Internal error: invalid messlen: ".$messlen
 164                         ." payload length:".length($payload)."\n";
 165                 }
 166                 if (length($payload) + $record->decrypt_len >= $messlen) {
 167                     #We can complete the message with this record
 168                     $recoffset = $messlen - length($payload);
 169                     $payload .= substr($record->decrypt_data, 0, $recoffset);
 170                     push @message_frag_lens, $recoffset;
 171                     $message = create_message($server, $mt, $payload,
 172                                               $startoffset);
 173                     push @messages, $message;
 174
 175                     $payload = "";
 176                 } else {
 177                     #This is just part of the total message
 178                     $payload .= $record->decrypt_data;
 179                     $recoffset = $record->decrypt_len;
 180                     push @message_frag_lens, $record->decrypt_len;
 181                 }
 182                 print "  Partial message data read: ".$recoffset." bytes\n";
 183             }
 184
 185             while ($record->decrypt_len > $recoffset) {
 186                 #We are at the start of a new message
 187                 if ($record->decrypt_len - $recoffset < 4) {
 188                     #Whilst technically probably valid we can't cope with this
 189                     die "End of record in the middle of a message header\n";
 190                 }
 191                 @message_rec_list = ($record);
 192                 my $lenhi;
 193                 my $lenlo;
 194                 ($mt, $lenhi, $lenlo) = unpack('CnC',
 195                                                substr($record->decrypt_data,
 196                                                       $recoffset));
 197                 $messlen = ($lenhi << 8) | $lenlo;
 198                 print "  Message type: $message_type{$mt}\n";
 199                 print "  Message Length: $messlen\n";
 200                 $startoffset = $recoffset;
 201                 $recoffset += 4;
 202                 $payload = "";
 203
 204                 if ($recoffset <= $record->decrypt_len) {
 205                     #Some payload data is present in this record
 206                     if ($record->decrypt_len - $recoffset >= $messlen) {
 207                         #We can complete the message with this record
 208                         $payload .= substr($record->decrypt_data, $recoffset,
 209                                            $messlen);
 210                         $recoffset += $messlen;
 211                         push @message_frag_lens, $messlen;
 212                         $message = create_message($server, $mt, $payload,
 213                                                   $startoffset);
 214                         push @messages, $message;
 215
 216                         $payload = "";
 217                     } else {
 218                         #This is just part of the total message
 219                         $payload .= substr($record->decrypt_data, $recoffset,
 220                                            $record->decrypt_len - $recoffset);
 221                         $recoffset = $record->decrypt_len;
 222                         push @message_frag_lens, $recoffset;
 223                     }
 224                 }
 225             }
 226         }
 227     } elsif ($record->content_type == TLSProxy::Record::RT_APPLICATION_DATA) {
 228         print "  [ENCRYPTED APPLICATION DATA]\n";
 229         print "  [".$record->decrypt_data."]\n";
 230
 231         if ($successondata) {
 232             $success = 1;
 233             $end = 1;
 234         }
 235     } elsif ($record->content_type == TLSProxy::Record::RT_ALERT) {
 236         my ($alertlev, $alertdesc) = unpack('CC', $record->decrypt_data);
 237         #A CloseNotify from the client indicates we have finished successfully
 238         #(we assume)
 239         if (!$end && !$server && $alertlev == AL_LEVEL_WARN
 240             && $alertdesc == AL_DESC_CLOSE_NOTIFY) {
 241             $success = 1;
 242         }
 243         #All alerts end the test
 244         $end = 1;
 245     }
 246
 247     return @messages;
 248 }
 249
 250 #Function to work out which sub-class we need to create and then
 251 #construct it
 252 sub create_message
 253 {
 254     my ($server, $mt, $data, $startoffset) = @_;
 255     my $message;
 256
 257     #We only support ClientHello in this version...needs to be extended for
 258     #others
 259     if ($mt == MT_CLIENT_HELLO) {
 260         $message = TLSProxy::ClientHello->new(
 261             $server,
 262             $data,
 263             [@message_rec_list],
 264             $startoffset,
 265             [@message_frag_lens]
 266         );
 267         $message->parse();
 268     } elsif ($mt == MT_HELLO_RETRY_REQUEST) {
 269         $message = TLSProxy::HelloRetryRequest->new(
 270             $server,
 271             $data,
 272             [@message_rec_list],
 273             $startoffset,
 274             [@message_frag_lens]
 275         );
 276         $message->parse();
 277     } elsif ($mt == MT_SERVER_HELLO) {
 278         $message = TLSProxy::ServerHello->new(
 279             $server,
 280             $data,
 281             [@message_rec_list],
 282             $startoffset,
 283             [@message_frag_lens]
 284         );
 285         $message->parse();
 286     } elsif ($mt == MT_ENCRYPTED_EXTENSIONS) {
 287         $message = TLSProxy::EncryptedExtensions->new(
 288             $server,
 289             $data,
 290             [@message_rec_list],
 291             $startoffset,
 292             [@message_frag_lens]
 293         );
 294         $message->parse();
 295     } elsif ($mt == MT_CERTIFICATE) {
 296         $message = TLSProxy::Certificate->new(
 297             $server,
 298             $data,
 299             [@message_rec_list],
 300             $startoffset,
 301             [@message_frag_lens]
 302         );
 303         $message->parse();
 304     } elsif ($mt == MT_CERTIFICATE_VERIFY) {
 305         $message = TLSProxy::CertificateVerify->new(
 306             $server,
 307             $data,
 308             [@message_rec_list],
 309             $startoffset,
 310             [@message_frag_lens]
 311         );
 312         $message->parse();
 313     } elsif ($mt == MT_SERVER_KEY_EXCHANGE) {
 314         $message = TLSProxy::ServerKeyExchange->new(
 315             $server,
 316             $data,
 317             [@message_rec_list],
 318             $startoffset,
 319             [@message_frag_lens]
 320         );
 321         $message->parse();
 322     } elsif ($mt == MT_NEW_SESSION_TICKET) {
 323         $message = TLSProxy::NewSessionTicket->new(
 324             $server,
 325             $data,
 326             [@message_rec_list],
 327             $startoffset,
 328             [@message_frag_lens]
 329         );
 330         $message->parse();
 331     } else {
 332         #Unknown message type
 333         $message = TLSProxy::Message->new(
 334             $server,
 335             $mt,
 336             $data,
 337             [@message_rec_list],
 338             $startoffset,
 339             [@message_frag_lens]
 340         );
 341     }
 342
 343     return $message;
 344 }
 345
 346 sub end
 347 {
 348     my $class = shift;
 349     return $end;
 350 }
 351 sub success
 352 {
 353     my $class = shift;
 354     return $success;
 355 }
 356 sub fail
 357 {
 358     my $class = shift;
 359     return !$success && $end;
 360 }
 361 sub new
 362 {
 363     my $class = shift;
 364     my ($server,
 365         $mt,
 366         $data,
 367         $records,
 368         $startoffset,
 369         $message_frag_lens) = @_;
 370
 371     my $self = {
 372         server => $server,
 373         data => $data,
 374         records => $records,
 375         mt => $mt,
 376         startoffset => $startoffset,
 377         message_frag_lens => $message_frag_lens
 378     };
 379
 380     return bless $self, $class;
 381 }
 382
 383 sub ciphersuite
 384 {
 385     my $class = shift;
 386     if (@_) {
 387       $ciphersuite = shift;
 388     }
 389     return $ciphersuite;
 390 }
 391
 392 #Update all the underlying records with the modified data from this message
 393 #Note: Only supports re-encrypting for TLSv1.3
 394 sub repack
 395 {
 396     my $self = shift;
 397     my $msgdata;
 398
 399     my $numrecs = $#{$self->records};
 400
 401     $self->set_message_contents();
 402
 403     my $lenhi;
 404     my $lenlo;
 405
 406     $lenlo = length($self->data) & 0xff;
 407     $lenhi = length($self->data) >> 8;
 408     $msgdata = pack('CnC', $self->mt, $lenhi, $lenlo).$self->data;
 409
 410     if ($numrecs == 0) {
 411         #The message is fully contained within one record
 412         my ($rec) = @{$self->records};
 413         my $recdata = $rec->decrypt_data;
 414
 415         my $old_length;
 416
 417         # We use empty message_frag_lens to indicates that pre-repacking,
 418         # the message wasn't present. The first fragment length doesn't include
 419         # the TLS header, so we need to check and compute the right length.
 420         if (@{$self->message_frag_lens}) {
 421             $old_length = ${$self->message_frag_lens}[0] +
 422               TLS_MESSAGE_HEADER_LENGTH;
 423         } else {
 424             $old_length = 0;
 425         }
 426
 427         my $prefix = substr($recdata, 0, $self->startoffset);
 428         my $suffix = substr($recdata, $self->startoffset + $old_length);
 429
 430         $rec->decrypt_data($prefix.($msgdata).($suffix));
 431         # TODO(openssl-team): don't keep explicit lengths.
 432         # (If a length override is ever needed to construct invalid packets,
 433         #  use an explicit override field instead.)
 434         $rec->decrypt_len(length($rec->decrypt_data));
 435         $rec->len($rec->len + length($msgdata) - $old_length);
 436         # Only support re-encryption for TLSv1.3.
 437         if (TLSProxy::Proxy->is_tls13() && $rec->encrypted()) {
 438             #Add content type (1 byte) and 16 tag bytes
 439             $rec->data($rec->decrypt_data
 440                 .pack("C", TLSProxy::Record::RT_HANDSHAKE).("\0"x16));
 441         } else {
 442             $rec->data($rec->decrypt_data);
 443         }
 444
 445         #Update the fragment len in case we changed it above
 446         ${$self->message_frag_lens}[0] = length($msgdata)
 447                                          - TLS_MESSAGE_HEADER_LENGTH;
 448         return;
 449     }
 450
 451     #Note we don't currently support changing a fragmented message length
 452     my $recctr = 0;
 453     my $datadone = 0;
 454     foreach my $rec (@{$self->records}) {
 455         my $recdata = $rec->decrypt_data;
 456         if ($recctr == 0) {
 457             #This is the first record
 458             my $remainlen = length($recdata) - $self->startoffset;
 459             $rec->data(substr($recdata, 0, $self->startoffset)
 460                        .substr(($msgdata), 0, $remainlen));
 461             $datadone += $remainlen;
 462         } elsif ($recctr + 1 == $numrecs) {
 463             #This is the last record
 464             $rec->data(substr($msgdata, $datadone));
 465         } else {
 466             #This is a middle record
 467             $rec->data(substr($msgdata, $datadone, length($rec->data)));
 468             $datadone += length($rec->data);
 469         }
 470         $recctr++;
 471     }
 472 }
 473
 474 #To be overridden by sub-classes
 475 sub set_message_contents
 476 {
 477 }
 478
 479 #Read only accessors
 480 sub server
 481 {
 482     my $self = shift;
 483     return $self->{server};
 484 }
 485
 486 #Read/write accessors
 487 sub mt
 488 {
 489     my $self = shift;
 490     if (@_) {
 491       $self->{mt} = shift;
 492     }
 493     return $self->{mt};
 494 }
 495 sub data
 496 {
 497     my $self = shift;
 498     if (@_) {
 499       $self->{data} = shift;
 500     }
 501     return $self->{data};
 502 }
 503 sub records
 504 {
 505     my $self = shift;
 506     if (@_) {
 507       $self->{records} = shift;
 508     }
 509     return $self->{records};
 510 }
 511 sub startoffset
 512 {
 513     my $self = shift;
 514     if (@_) {
 515       $self->{startoffset} = shift;
 516     }
 517     return $self->{startoffset};
 518 }
 519 sub message_frag_lens
 520 {
 521     my $self = shift;
 522     if (@_) {
 523       $self->{message_frag_lens} = shift;
 524     }
 525     return $self->{message_frag_lens};
 526 }
 527 sub encoded_length
 528 {
 529     my $self = shift;
 530     return TLS_MESSAGE_HEADER_LENGTH + length($self->data);
 531 }
 532 sub successondata
 533 {
 534     my $class = shift;
 535     if (@_) {
 536         $successondata = shift;
 537     }
 538     return $successondata;
 539 }
 540 1;