Как обнаружить входящее рукопожатие SSL (https) (формат проводного SSL)? - PullRequest
Новая
       12

Как обнаружить входящее рукопожатие SSL (https) (формат проводного SSL)?

13 голосов
/ 10 октября 2010

Я пишу сервер, который принимает входящие TCP-соединения. Предположим, что сервер принял соединение TCP и уже получил 16 (или около того) байтов от клиента. Зная эти 16 байтов, как сервер может определить, хочет ли клиент инициировать SSL-рукопожатие?

Я провел эксперимент, который показал, что в моей системе Linux подключение к localhost (127.0.0.1 или AF_UNIX) через SSL заставляет клиента отправить следующее рукопожатие (hexdump), за которым следуют 16, казалось бы, случайных байтов: * 

8064010301004b0000001000003900003800003500001600001300000a07
00c000003300003200002f03008000000500000401008000001500001200
0009060040000014000011000008000006040080000003020080

Как сервер должен проверить эти первые несколько байтов, чтобы определить, отправляет ли клиент рукопожатие SSL? Зонд должен возвращать true для всех действительных SSL-квитирований и с высокой вероятностью должен возвращать false для сообщения, отправленного клиентом, который не является SSL-квитированием. Не разрешается использовать какие-либо библиотеки (например, OpenSSL) для исследования. Зонд должен быть простым кодом (например, несколько десятков строк в C или Python).

Ответы [ 2 ]

17 голосов
/ 27 апреля 2012

Клиент всегда сначала отправляет так называемое HelloClient сообщение. Может быть в формате SSL 2 или SSL 3.0 (тот же формат, что и в TLS 1.0, 1.1 и 1.2).

И есть также вероятность того, что клиенты SSL 3.0 / TLS 1.0 / 1.1 / 1.2 отправят HelloClient со старым форматом (SSL 2), просто с более высоким номером версии в данных. Таким образом, обнаружение SSL 2 HelloClient необходимо и для новых клиентов. (Например, реализация Java SSL делает это)

Допустим, 'b' - это ваш буфер. Я попытался наметить формат сообщения.

SSL 2 

+-----------------+------+-------
| 2 byte header   | 0x01 | etc.
+-----------------|------+-------

  • b [0] & 0x80 == 0x80 (это означает, что самый старший бит b [0] равен '1')

  • ((b [0] & 0x7f) << 8 | b [1])> 9 (Это означает, что младшие 7 битов b [0] вместе с b [1] представляют собой длину данных. Вы может иметь меньше в вашем буфере, поэтому вы не можете их проверить. Но из формата сообщения мы знаем, что есть 3 поля по 2 байта (поля длины) и, по крайней мере, один элемент в поле списка шифров (размером 3). быть не менее 9 байтов (длина данных> = 9).

  • b [2] должно быть 0x01 (тип сообщения "ClientHello")

SSL 3.0 или TLS 1.0, 1.1 и 1.2 

+-------+------------------+------------------+--------+------
| 0x16  | 2 bytes version  |  2 bytes length  |  0x01  |  etc.
+-------+------------------+------------------+--------+------

  • b [0] == 0x16 (тип сообщения "SSL handshake")

  • b [1] должно быть 0x03 (в настоящее время новейшая основная версия, но кто знает в будущем?)

  • b [5] должно быть 0x01 (сообщение протокола рукопожатия «HelloClient»)

Для справки вы можете увидеть http://www.mozilla.org/projects/security/pki/nss/ssl/draft02.html и http://tools.ietf.org/html/rfc4346

6 голосов
/ 10 октября 2010

Я мог бы понять это на основе реализации метода ClientHello.parse в http://tlslite.cvs.sourceforge.net/viewvc/tlslite/tlslite/tlslite/messages.py?view=markup

Я даю два решения здесь, в Python. IsSSlClientHandshakeSimple - это простое регулярное выражение, которое может легко дать некоторые ложные срабатывания; IsSslClientHandshake более сложный: он проверяет согласованность длин и диапазон некоторых других чисел. 

import re

def IsSslClientHandshakeSimple(buf):
  return bool(re.match(r'(?s)\A(?:\x80[\x0f-\xff]\x01[\x00-\x09][\x00-\x1f]'
                       r'[\x00-\x05].\x00.\x00.|'
                       r'\x16[\x2c-\xff]\x01\x00[\x00-\x05].'
                       r'[\x00-\x09][\x00-\x1f])', buf))

def IsSslClientHandshake(buf):
  if len(buf) < 2:  # Missing record header.
    return False
  if len(buf) < 2 + ord(buf[1]):  # Incomplete record body.
    return False
  # TODO(pts): Support two-byte lengths in buf[1].
  if ord(buf[0]) == 0x80:  # SSL v2.
    if ord(buf[1]) < 9:  # Message body too short.
      return False
    if ord(buf[2]) != 0x01:  # Not client_hello.
      return False
    if ord(buf[3]) > 9:  # Client major version too large. (Good: 0x03)
      return False
    if ord(buf[4]) > 31:  # Client minor version too large. (Good: 0x01)
      return False
    cipher_specs_size = ord(buf[5]) << 8 | ord(buf[6])
    session_id_size = ord(buf[7]) << 8 | ord(buf[8])
    random_size = ord(buf[9]) << 8 | ord(buf[10])
    if ord(buf[1]) < 9 + cipher_specs_size + session_id_size + random_size:
      return False
    if cipher_specs_size % 3 != 0:  # Cipher specs not a multiple of 3 bytes.
      return False
  elif ord(buf[0]) == 0x16:  # SSL v1.
    # TODO(pts): Test this.
    if ord(buf[1]) < 39:  # Message body too short.
      return False
    if ord(buf[2]) != 0x01:  # Not client_hello.
      return False
    head_size = ord(buf[3]) << 16 | ord(buf[4]) << 8 | ord(buf[5])
    if ord(buf[1]) < head_size + 4:  # Head doesn't fit in message body.
      return False
    if ord(buf[6]) > 9:  # Client major version too large. (Good: 0x03)
      return False
    if ord(buf[7]) > 31:  # Client minor version too large. (Good: 0x01)
      return False
    # random is at buf[8 : 40]
    session_id_size = ord(buf[40])
    i = 41 + session_id_size
    if ord(buf[1]) < i + 2:  # session_id + cipher_suites_size doesn't fit.
      return False
    cipher_specs_size = ord(buf[i]) << 8 | ord(buf[i + 1])
    if cipher_specs_size % 2 != 0:
      return False
    i += 2 + cipher_specs_size
    if ord(buf[1]) < i + 1: # cipher_specs + c..._methods_size doesn't fit.
      return False
    if ord(buf[1]) < i + 1 + ord(buf[i]): # compression_methods doesn't fit.
      return False
  else:  # Not SSL v1 or SSL v2.
    return False
return True
...