util/perl/TLSProxy/ClientHello.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::ClientHello;
  11
  12 use vars '@ISA';
  13 push @ISA, 'TLSProxy::Message';
  14
  15 sub new
  16 {
  17     my $class = shift;
  18     my ($server,
  19         $data,
  20         $records,
  21         $startoffset,
  22         $message_frag_lens) = @_;
  23
  24     my $self = $class->SUPER::new(
  25         $server,
  26         1,
  27         $data,
  28         $records,
  29         $startoffset,
  30         $message_frag_lens);
  31
  32     $self->{client_version} = 0;
  33     $self->{random} = [];
  34     $self->{session_id_len} = 0;
  35     $self->{session} = "";
  36     $self->{ciphersuite_len} = 0;
  37     $self->{ciphersuites} = [];
  38     $self->{comp_meth_len} = 0;
  39     $self->{comp_meths} = [];
  40     $self->{extensions_len} = 0;
  41     $self->{extension_data} = "";
  42
  43     return $self;
  44 }
  45
  46 sub parse
  47 {
  48     my $self = shift;
  49     my $ptr = 2;
  50     my ($client_version) = unpack('n', $self->data);
  51     my $random = substr($self->data, $ptr, 32);
  52     $ptr += 32;
  53     my $session_id_len = unpack('C', substr($self->data, $ptr));
  54     $ptr++;
  55     my $session = substr($self->data, $ptr, $session_id_len);
  56     $ptr += $session_id_len;
  57     my $ciphersuite_len = unpack('n', substr($self->data, $ptr));
  58     $ptr += 2;
  59     my @ciphersuites = unpack('n*', substr($self->data, $ptr,
  60                                            $ciphersuite_len));
  61     $ptr += $ciphersuite_len;
  62     my $comp_meth_len = unpack('C', substr($self->data, $ptr));
  63     $ptr++;
  64     my @comp_meths = unpack('C*', substr($self->data, $ptr, $comp_meth_len));
  65     $ptr += $comp_meth_len;
  66     my $extensions_len = unpack('n', substr($self->data, $ptr));
  67     $ptr += 2;
  68     #For now we just deal with this as a block of data. In the future we will
  69     #want to parse this
  70     my $extension_data = substr($self->data, $ptr);
  71
  72     if (length($extension_data) != $extensions_len) {
  73         die "Invalid extension length\n";
  74     }
  75     my %extensions = ();
  76     while (length($extension_data) >= 4) {
  77         my ($type, $size) = unpack("nn", $extension_data);
  78         my $extdata = substr($extension_data, 4, $size);
  79         $extension_data = substr($extension_data, 4 + $size);
  80         $extensions{$type} = $extdata;
  81     }
  82
  83     $self->client_version($client_version);
  84     $self->random($random);
  85     $self->session_id_len($session_id_len);
  86     $self->session($session);
  87     $self->ciphersuite_len($ciphersuite_len);
  88     $self->ciphersuites(\@ciphersuites);
  89     $self->comp_meth_len($comp_meth_len);
  90     $self->comp_meths(\@comp_meths);
  91     $self->extensions_len($extensions_len);
  92     $self->extension_data(\%extensions);
  93
  94     $self->process_extensions();
  95
  96     print "    Client Version:".$client_version."\n";
  97     print "    Session ID Len:".$session_id_len."\n";
  98     print "    Ciphersuite len:".$ciphersuite_len."\n";
  99     print "    Compression Method Len:".$comp_meth_len."\n";
 100     print "    Extensions Len:".$extensions_len."\n";
 101 }
 102
 103 #Perform any actions necessary based on the extensions we've seen
 104 sub process_extensions
 105 {
 106     my $self = shift;
 107     my %extensions = %{$self->extension_data};
 108
 109     #Clear any state from a previous run
 110     TLSProxy::Record->etm(0);
 111
 112     if (exists $extensions{TLSProxy::Message::EXT_ENCRYPT_THEN_MAC}) {
 113         TLSProxy::Record->etm(1);
 114     }
 115 }
 116
 117 sub extension_contents
 118 {
 119     my $self = shift;
 120     my $key = shift;
 121     my $extension = "";
 122
 123     my $extdata = ${$self->extension_data}{$key};
 124     $extension .= pack("n", $key);
 125     $extension .= pack("n", length($extdata));
 126     $extension .= $extdata;
 127     if ($key == TLSProxy::Message::EXT_DUPLICATE_EXTENSION) {
 128         $extension .= pack("n", $key);
 129         $extension .= pack("n", length($extdata));
 130         $extension .= $extdata;
 131     }
 132     return $extension;
 133 }
 134
 135 #Reconstruct the on-the-wire message data following changes
 136 sub set_message_contents
 137 {
 138     my $self = shift;
 139     my $data;
 140     my $extensions = "";
 141
 142     $data = pack('n', $self->client_version);
 143     $data .= $self->random;
 144     $data .= pack('C', $self->session_id_len);
 145     $data .= $self->session;
 146     $data .= pack('n', $self->ciphersuite_len);
 147     $data .= pack("n*", @{$self->ciphersuites});
 148     $data .= pack('C', $self->comp_meth_len);
 149     $data .= pack("C*", @{$self->comp_meths});
 150
 151     foreach my $key (keys %{$self->extension_data}) {
 152         next if ($key == TLSProxy::Message::EXT_PSK);
 153         $extensions .= $self->extension_contents($key);
 154     }
 155     #PSK extension always goes last...
 156     if (defined ${$self->extension_data}{TLSProxy::Message::EXT_PSK}) {
 157         $extensions .= $self->extension_contents(TLSProxy::Message::EXT_PSK);
 158     }
 159     #unless we have EXT_FORCE_LAST
 160     if (defined ${$self->extension_data}{TLSProxy::Message::EXT_FORCE_LAST}) {
 161         $extensions .= $self->extension_contents(TLSProxy::Message::EXT_FORCE_LAST);
 162     }
 163
 164     $data .= pack('n', length($extensions));
 165     $data .= $extensions;
 166
 167     $self->data($data);
 168 }
 169
 170 #Read/write accessors
 171 sub client_version
 172 {
 173     my $self = shift;
 174     if (@_) {
 175       $self->{client_version} = shift;
 176     }
 177     return $self->{client_version};
 178 }
 179 sub random
 180 {
 181     my $self = shift;
 182     if (@_) {
 183       $self->{random} = shift;
 184     }
 185     return $self->{random};
 186 }
 187 sub session_id_len
 188 {
 189     my $self = shift;
 190     if (@_) {
 191       $self->{session_id_len} = shift;
 192     }
 193     return $self->{session_id_len};
 194 }
 195 sub session
 196 {
 197     my $self = shift;
 198     if (@_) {
 199       $self->{session} = shift;
 200     }
 201     return $self->{session};
 202 }
 203 sub ciphersuite_len
 204 {
 205     my $self = shift;
 206     if (@_) {
 207       $self->{ciphersuite_len} = shift;
 208     }
 209     return $self->{ciphersuite_len};
 210 }
 211 sub ciphersuites
 212 {
 213     my $self = shift;
 214     if (@_) {
 215       $self->{ciphersuites} = shift;
 216     }
 217     return $self->{ciphersuites};
 218 }
 219 sub comp_meth_len
 220 {
 221     my $self = shift;
 222     if (@_) {
 223       $self->{comp_meth_len} = shift;
 224     }
 225     return $self->{comp_meth_len};
 226 }
 227 sub comp_meths
 228 {
 229     my $self = shift;
 230     if (@_) {
 231       $self->{comp_meths} = shift;
 232     }
 233     return $self->{comp_meths};
 234 }
 235 sub extensions_len
 236 {
 237     my $self = shift;
 238     if (@_) {
 239       $self->{extensions_len} = shift;
 240     }
 241     return $self->{extensions_len};
 242 }
 243 sub extension_data
 244 {
 245     my $self = shift;
 246     if (@_) {
 247       $self->{extension_data} = shift;
 248     }
 249     return $self->{extension_data};
 250 }
 251 sub set_extension
 252 {
 253     my ($self, $ext_type, $ext_data) = @_;
 254     $self->{extension_data}{$ext_type} = $ext_data;
 255 }
 256 sub delete_extension
 257 {
 258     my ($self, $ext_type) = @_;
 259     delete $self->{extension_data}{$ext_type};
 260 }
 261 1;