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