Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-13 12:08:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Refactored the SSH analyzer. Added supported for algorithm detection and more key exchange message types.

Browse source
This commit is contained in:
Vlad Grigorescu 2015-01-13 12:02:31 -05:00
parent 245bd07af7
commit 05ecac2497
11 changed files with 745 additions and 328 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/analyzer/protocol/ssh/CMakeLists.txt
View file

@ -6,6 +6,7 @@ include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DI
bro_plugin_begin(Bro SSH)
bro_plugin_cc(SSH.cc Plugin.cc)
bro_plugin_bif(types.bif)
bro_plugin_bif(events.bif)
bro_plugin_pac(ssh.pac ssh-analyzer.pac ssh-protocol.pac)
bro_plugin_end()

147
src/analyzer/protocol/ssh/SSH.cc
View file

@ -6,6 +6,7 @@
#include "Reporter.h"
#include "types.bif.h"
#include "events.bif.h"
using namespace analyzer::SSH;
@ -18,10 +19,10 @@ SSH_Analyzer::SSH_Analyzer(Connection* c)
interp = new binpac::SSH::SSH_Conn(this);
had_gap = false;
auth_decision_made = false;
num_encrypted_packets_seen = 0;
initial_client_packet_size = 0;
initial_server_packet_size = 0;
}
skipped_banner = false;
service_accept_size = 0;
userauth_failure_size = 0;
}
SSH_Analyzer::~SSH_Analyzer()
{
@ -59,7 +60,13 @@ void SSH_Analyzer::DeliverStream(int len, const u_char* data, bool orig)
if ( interp->get_state(orig) == binpac::SSH::ENCRYPTED )
{
ProcessEncrypted(len, orig);
if ( ssh_encrypted_packet )
BifEvent::generate_ssh_encrypted_packet(interp->bro_analyzer(), interp->bro_analyzer()->Conn(),
orig, len);
if ( !auth_decision_made )
ProcessEncrypted(len, orig);
return;
}
@ -69,7 +76,6 @@ void SSH_Analyzer::DeliverStream(int len, const u_char* data, bool orig)
}
catch ( const binpac::Exception& e )
{
printf("Binpac exception: %s\n", e.c_msg());
ProtocolViolation(fmt("Binpac exception: %s", e.c_msg()));
}
}
@ -83,84 +89,65 @@ void SSH_Analyzer::Undelivered(uint64 seq, int len, bool orig)
void SSH_Analyzer::ProcessEncrypted(int len, bool orig)
{
if (orig && !initial_client_packet_size)
initial_client_packet_size = len;
if (!orig && !initial_server_packet_size)
initial_server_packet_size = len;
int relative_len;
if (orig)
relative_len = len - initial_client_packet_size;
else
relative_len = len - initial_server_packet_size;
if ( !auth_decision_made && ( num_encrypted_packets_seen > 3 ) )
// We're interested in messages from the server for SSH2
if (!orig && (interp->get_version() == binpac::SSH::SSH2))
{
int auth_result = AuthResult(relative_len, orig, interp->get_version());
if ( auth_result > 0 )
// The first thing we see and want to know is the length of
// SSH_MSG_SERVICE_REQUEST, which has a fixed (decrypted) size
// of 24 bytes (17 for content pad-aligned to 8-byte
// boundaries)
if (!service_accept_size)
{
service_accept_size = len;
return;
}
// If our user can authenticate via the "none" method, this
// packet will be a SSH_MSG_USERAUTH_SUCCESS, which has a
// fixed (decrypted) size of 8 bytes (1 for content
// pad-aligned to 8-byte boundaries). relative_len would be
// -16.
if (!userauth_failure_size && (len + 16 == service_accept_size))
{
auth_decision_made = true;
if ( auth_result == 1 )
BifEvent::generate_ssh_auth_successful(interp->bro_analyzer(),
interp->bro_analyzer()->Conn(),
len,
packet_n_1_size,
packet_n_2_size);
if ( auth_result == 2 )
BifEvent::generate_ssh_auth_failed(interp->bro_analyzer(),
interp->bro_analyzer()->Conn(),
len,
packet_n_1_size,
packet_n_2_size);
if ( ssh_auth_successful )
BifEvent::generate_ssh_auth_successful(interp->bro_analyzer(), interp->bro_analyzer()->Conn(), true);
return;
}
// Normally, this packet would be a SSH_MSG_USERAUTH_FAILURE
// message, with a variable length, depending on the
// authentication methods the server supports. If it's too
// big, it might contain a pre-auth MOTD/banner, so we'll just
// skip it.
if (!userauth_failure_size)
{
if ( !skipped_banner && (len - service_accept_size) > 256 )
{
skipped_banner = true;
return;
}
userauth_failure_size = len;
return;
}
// If we've already seen a failure, let's see if this is
// another packet of the same size.
if (len == userauth_failure_size)
{
if ( ssh_auth_failed )
BifEvent::generate_ssh_auth_failed(interp->bro_analyzer(), interp->bro_analyzer()->Conn());
return;
}
// ...or a success packet.
if (len - service_accept_size == -16)
{
auth_decision_made = true;
if ( ssh_auth_successful )
BifEvent::generate_ssh_auth_successful(interp->bro_analyzer(), interp->bro_analyzer()->Conn(), false);
return;
}
}
if ( ( num_encrypted_packets_seen >= 2 ) &&
( orig != packet_n_1_is_orig ) )
{
packet_n_2_is_orig = packet_n_1_is_orig;
packet_n_2_size = packet_n_1_size;
}
if ( num_encrypted_packets_seen == 0 )
num_encrypted_packets_seen = 1;
else if ( orig == packet_n_1_is_orig )
packet_n_1_size += len;
else
{
packet_n_1_is_orig = orig;
packet_n_1_size = relative_len;
if ( ! ( ( interp->get_version() == binpac::SSH::SSH1 ) && len > 90 ) )
num_encrypted_packets_seen++;
}
}
int SSH_Analyzer::AuthResult(int len, bool orig, int version)
{
if ( version == binpac::SSH::SSH2 )
{
if ( !orig && packet_n_1_is_orig && !packet_n_2_is_orig )
{
if ( len == -16 )
return 1;
else if ( len >= 16 && len <= 32 )
return 2;
return 0;
}
}
else if ( version == binpac::SSH::SSH1 )
{
// On a successful login, the server sends a longer message
if ( !orig && len > 0 )
{
// To verify a public key, the server sends back a message of the same size
// as the previous one. Ignore that occurrence here.
if ( ! ( packet_n_1_is_orig && ( len == packet_n_1_size ) ) )
return 1;
}
// If we've seen too many messages without a longer message, treat it as a failure
if ( num_encrypted_packets_seen > 7 )
return 2;
}
return -1;
}

12
src/analyzer/protocol/ssh/SSH.h
View file

@ -31,22 +31,16 @@ protected:
binpac::SSH::SSH_Conn* interp;
void ProcessEncrypted(int len, bool orig);
int AuthResult(int len, bool orig, int version);
bool had_gap;
// Packet analysis stuff
bool auth_decision_made;
bool skipped_banner;
int initial_client_packet_size;
int initial_server_packet_size;
int num_encrypted_packets_seen;
int service_accept_size;
int userauth_failure_size;
bool packet_n_1_is_orig;
int packet_n_1_size;
bool packet_n_2_is_orig;
int packet_n_2_size;
};
} } // namespace analyzer::*

8
src/analyzer/protocol/ssh/events.bif
View file

@ -2,11 +2,13 @@ event ssh_server_version%(c: connection, version: string%);
event ssh_client_version%(c: connection, version: string%);
event ssh_auth_successful%(c: connection, last_packet_len: int, middle_packet_len: int, first_packet_len: int%);
event ssh_auth_successful%(c: connection, auth_method_none: bool%);
event ssh_auth_failed%(c: connection, last_packet_len: int, middle_packet_len: int, first_packet_len: int%);
event ssh_auth_failed%(c: connection%);
event ssh_server_capabilities%(c: connection, kex_algorithms: string, server_host_key_algorithms: string, encryption_algorithms_client_to_server: string, encryption_algorithms_server_to_client: string, mac_algorithms_client_to_server: string, mac_algorithms_server_to_client: string, compression_algorithms_client_to_server: string, compression_algorithms_server_to_client: string, languages_client_to_server: string, languages_server_to_client: string%);
event ssh_encrypted_packet%(c: connection, orig: bool, len: count%);
event ssh_capabilities%(c: connection, cookie: string, capabilities: SSH::Capabilities%);
event ssh_server_host_key%(c: connection, key: string%);

98
src/analyzer/protocol/ssh/ssh-analyzer.pac
View file

@ -1,3 +1,53 @@
%extern{
#include <cstdlib>
#include <vector>
#include <string>
%}
%header{
VectorVal* name_list_to_vector(const bytestring nl);
%}
%code{
// Copied from IRC_Analyzer::SplitWords
VectorVal* name_list_to_vector(const bytestring nl)
{
VectorVal* vv = new VectorVal(internal_type("string_vec")->AsVectorType());
string name_list = std_str(nl);
if ( name_list.size() < 1 )
return vv;
unsigned int start = 0;
unsigned int split_pos = 0;
while ( name_list[start] == ',' )
{
++start;
++split_pos;
}
string word;
while ( (split_pos = name_list.find(',', start)) < name_list.size() )
{
word = name_list.substr(start, split_pos - start);
if ( word.size() > 0 && word[0] != ',' )
vv->Assign(vv->Size(), new StringVal(word));
start = split_pos + 1;
}
// Add line end if needed.
if ( start < name_list.size() )
{
word = name_list.substr(start, name_list.size() - start);
vv->Assign(vv->Size(), new StringVal(word));
}
return vv;
}
%}
refine flow SSH_Flow += {
function proc_ssh_version(msg: SSH_Version): bool
%{
@ -18,20 +68,26 @@ refine flow SSH_Flow += {
function proc_ssh_kexinit(msg: SSH_KEXINIT): bool
%{
if ( ssh_server_capabilities )
if ( ssh_capabilities )
{
BifEvent::generate_ssh_server_capabilities(connection()->bro_analyzer(),
connection()->bro_analyzer()->Conn(),
bytestring_to_val(${msg.kex_algorithms.val}),
bytestring_to_val(${msg.server_host_key_algorithms.val}),
bytestring_to_val(${msg.encryption_algorithms_client_to_server.val}),
bytestring_to_val(${msg.encryption_algorithms_server_to_client.val}),
bytestring_to_val(${msg.mac_algorithms_client_to_server.val}),
bytestring_to_val(${msg.mac_algorithms_server_to_client.val}),
bytestring_to_val(${msg.compression_algorithms_client_to_server.val}),
bytestring_to_val(${msg.compression_algorithms_server_to_client.val}),
bytestring_to_val(${msg.languages_client_to_server.val}),
bytestring_to_val(${msg.languages_server_to_client.val}));
RecordVal* result = new RecordVal(BifType::Record::SSH::Capabilities);
result->Assign(0, name_list_to_vector(${msg.kex_algorithms.val}));
result->Assign(1, name_list_to_vector(${msg.server_host_key_algorithms.val}));
result->Assign(2, name_list_to_vector(${msg.encryption_algorithms_client_to_server.val}));
result->Assign(3, name_list_to_vector(${msg.encryption_algorithms_server_to_client.val}));
result->Assign(4, name_list_to_vector(${msg.mac_algorithms_client_to_server.val}));
result->Assign(5, name_list_to_vector(${msg.mac_algorithms_server_to_client.val}));
result->Assign(6, name_list_to_vector(${msg.compression_algorithms_client_to_server.val}));
result->Assign(7, name_list_to_vector(${msg.compression_algorithms_server_to_client.val}));
if ( ${msg.languages_client_to_server.len} )
result->Assign(8, name_list_to_vector(${msg.languages_client_to_server.val}));
if ( ${msg.languages_server_to_client.len} )
result->Assign(9, name_list_to_vector(${msg.languages_server_to_client.val}));
result->Assign(10, new Val(${msg.is_orig}, TYPE_BOOL));
BifEvent::generate_ssh_capabilities(connection()->bro_analyzer(),
connection()->bro_analyzer()->Conn(), bytestring_to_val(${msg.cookie}),
result);
}
return true;
%}
@ -49,7 +105,7 @@ refine flow SSH_Flow += {
function proc_ssh1_server_host_key(p: bytestring, e: bytestring): bool
%{
if ( ssh_server_host_key )
if ( ssh1_server_host_key )
{
BifEvent::generate_ssh1_server_host_key(connection()->bro_analyzer(),
connection()->bro_analyzer()->Conn(),
@ -75,10 +131,6 @@ refine typeattr SSH_KEXINIT += &let {
proc: bool = $context.flow.proc_ssh_kexinit(this);
};
refine typeattr SSH_DH_GEX_REPLY += &let {
proc: bool = $context.flow.proc_ssh_server_host_key(k_s.val);
};
refine typeattr SSH1_Message += &let {
proc_newkeys: bool = $context.flow.proc_newkeys() &if(msg_type == SSH_CMSG_SESSION_KEY);
};
@ -87,6 +139,14 @@ refine typeattr SSH2_Message += &let {
proc_newkeys: bool = $context.flow.proc_newkeys() &if(msg_type == MSG_NEWKEYS);
};
refine typeattr SSH_DH_GEX_REPLY += &let {
proc: bool = $context.flow.proc_ssh_server_host_key(k_s.val);
};
refine typeattr SSH_ECC_REPLY += &let {
proc: bool = $context.flow.proc_ssh_server_host_key(k_s.val);
};
refine typeattr SSH1_PUBLIC_KEY += &let {
proc: bool = $context.flow.proc_ssh1_server_host_key(host_key_p.val, host_key_e.val);
proc: bool = $context.flow.proc_ssh1_server_host_key(host_key_p.val, host_key_e.val);
};

502
src/analyzer/protocol/ssh/ssh-protocol.pac
View file

@ -5,104 +5,143 @@ enum version {
};
enum state {
VERSION_EXCHANGE = 0,
KEY_EXCHANGE_CLEARTEXT = 1,
ENCRYPTED = 2,
VERSION_EXCHANGE = 0,
KEX_INIT = 1,
KEX_DH_GEX = 2,
KEX_DH = 3,
KEX_ECC = 4,
KEX_GSS = 5,
KEX_RSA = 6,
ENCRYPTED = 7,
};
# diffie-hellman-group1-sha1 [RFC4253] Section 8.1
# diffie-hellman-group14-sha1 [RFC4253] Section 8.2
enum KEX_DH_message_id {
SSH_MSG_KEXDH_INIT = 30,
SSH_MSG_KEXDH_REPLY = 31,
};
# diffie-hellman-group-exchange-sha1 [RFC4419] Section 4.1
# diffie-hellman-group-exchange-sha256 [RFC4419] Section 4.2
enum KEX_DH_GEX_message_id {
SSH_MSG_KEX_DH_GEX_REQUEST_OLD = 30,
SSH_MSG_KEX_DH_GEX_GROUP = 31,
SSH_MSG_KEX_DH_GEX_INIT = 32,
SSH_MSG_KEX_DH_GEX_REPLY = 33,
SSH_MSG_KEX_DH_GEX_REQUEST = 34,
};
# rsa1024-sha1 [RFC4432]
# rsa2048-sha256 [RFC4432]
enum KEX_RSA_message_id {
SSH_MSG_KEXRSA_PUBKEY = 30,
SSH_MSG_KEXRSA_SECRET = 31,
SSH_MSG_KEXRSA_DONE = 32,
};
# gss-group1-sha1-* [RFC4462] Section 2.3
# gss-group14-sha1-* [RFC4462] Section 2.4
# gss-gex-sha1-* [RFC4462] Section 2.5
# gss-* [RFC4462] Section 2.6
enum KEX_GSS_message_id {
SSH_MSG_KEXGSS_INIT = 30,
SSH_MSG_KEXGSS_CONTINUE = 31,
SSH_MSG_KEXGSS_COMPLETE = 32,
SSH_MSG_KEXGSS_HOSTKEY = 33,
SSH_MSG_KEXGSS_ERROR = 34,
SSH_MSG_KEXGSS_GROUPREQ = 40,
SSH_MSG_KEXGSS_GROUP = 41,
};
# ecdh-sha2-* [RFC5656]
enum KEX_ECDH_message_id {
SSH_MSG_KEX_ECDH_INIT = 30,
SSH_MSG_KEX_ECDH_REPLY = 31,
};
# ecmqv-sha2 [RFC5656]
enum KEX_ECMQV_message_id {
SSH_MSG_ECMQV_INIT = 30,
SSH_MSG_ECMQV_REPLY = 31,
};
enum ssh1_message_id {
SSH_MSG_NONE = 0,
SSH_MSG_DISCONNECT = 1,
SSH_SMSG_PUBLIC_KEY = 2,
SSH_CMSG_SESSION_KEY = 3,
SSH_CMSG_USER = 4,
SSH_CMSG_AUTH_RHOSTS = 5,
SSH_CMSG_AUTH_RSA = 6,
SSH_SMSG_AUTH_RSA_CHALLENGE = 7,
SSH_CMSG_AUTH_RSA_RESPONSE = 8,
SSH_CMSG_AUTH_PASSWORD = 9,
SSH_CMSG_REQUEST_PTY = 10,
SSH_CMSG_WINDOW_SIZE = 11,
SSH_CMSG_EXEC_SHELL = 12,
SSH_CMSG_EXEC_CMD = 13,
SSH_SMSG_SUCCESS = 14,
SSH_SMSG_FAILURE = 15,
SSH_CMSG_STDIN_DATA = 16,
SSH_SMSG_STDOUT_DATA = 17,
SSH_SMSG_STDERR_DATA = 18,
SSH_CMSG_EOF = 19,
SSH_SMSG_EXITSTATUS = 20,
SSH_MSG_NONE = 0,
SSH_MSG_DISCONNECT = 1,
SSH_SMSG_PUBLIC_KEY = 2,
SSH_CMSG_SESSION_KEY = 3,
SSH_CMSG_USER = 4,
SSH_CMSG_AUTH_RHOSTS = 5,
SSH_CMSG_AUTH_RSA = 6,
SSH_SMSG_AUTH_RSA_CHALLENGE = 7,
SSH_CMSG_AUTH_RSA_RESPONSE = 8,
SSH_CMSG_AUTH_PASSWORD = 9,
SSH_CMSG_REQUEST_PTY = 10,
SSH_CMSG_WINDOW_SIZE = 11,
SSH_CMSG_EXEC_SHELL = 12,
SSH_CMSG_EXEC_CMD = 13,
SSH_SMSG_SUCCESS = 14,
SSH_SMSG_FAILURE = 15,
SSH_CMSG_STDIN_DATA = 16,
SSH_SMSG_STDOUT_DATA = 17,
SSH_SMSG_STDERR_DATA = 18,
SSH_CMSG_EOF = 19,
SSH_SMSG_EXITSTATUS = 20,
SSH_MSG_CHANNEL_OPEN_CONFIRMATION = 21,
SSH_MSG_CHANNEL_OPEN_FAILURE = 22,
SSH_MSG_CHANNEL_DATA = 23,
SSH_MSG_CHANNEL_CLOSE = 24,
SSH_MSG_CHANNEL_DATA = 23,
SSH_MSG_CHANNEL_CLOSE = 24,
SSH_MSG_CHANNEL_CLOSE_CONFIRMATION = 25,
SSH_CMSG_X11_REQUEST_FORWARDING_OLD = 26,
SSH_SMSG_X11_OPEN = 27,
SSH_SMSG_X11_OPEN = 27,
SSH_CMSG_PORT_FORWARD_REQUEST = 28,
SSH_MSG_PORT_OPEN = 29,
SSH_MSG_PORT_OPEN = 29,
SSH_CMSG_AGENT_REQUEST_FORWARDING = 30,
SSH_SMSG_AGENT_OPEN = 31,
SSH_MSG_IGNORE = 32,
SSH_CMSG_EXIT_CONFIRMATION = 33,
SSH_SMSG_AGENT_OPEN = 31,
SSH_MSG_IGNORE = 32,
SSH_CMSG_EXIT_CONFIRMATION = 33,
SSH_CMSG_X11_REQUEST_FORWARDING = 34,
SSH_CMSG_AUTH_RHOSTS_RSA = 35,
SSH_MSG_DEBUG = 36,
SSH_CMSG_AUTH_RHOSTS_RSA = 35,
SSH_MSG_DEBUG = 36,
SSH_CMSG_REQUEST_COMPRESSION = 37,
SSH_CMSG_MAX_PACKET_SIZE = 38,
SSH_CMSG_AUTH_TIS = 39,
SSH_SMSG_AUTH_TIS_CHALLENGE = 40,
SSH_CMSG_AUTH_TIS_RESPONSE = 41,
SSH_CMSG_AUTH_KERBEROS = 42,
SSH_CMSG_MAX_PACKET_SIZE = 38,
SSH_CMSG_AUTH_TIS = 39,
SSH_SMSG_AUTH_TIS_CHALLENGE = 40,
SSH_CMSG_AUTH_TIS_RESPONSE = 41,
SSH_CMSG_AUTH_KERBEROS = 42,
SSH_SMSG_AUTH_KERBEROS_RESPONSE = 43,
SSH_CMSG_HAVE_KERBEROS_TGT = 44,
SSH_CMSG_HAVE_KERBEROS_TGT = 44,
};
enum ssh2_message_id {
MSG_DISCONNECT = 1,
MSG_IGNORE = 2,
MSG_UNIMPLEMENTED = 3,
MSG_DEBUG = 4,
MSG_SERVICE_REQUEST = 5,
MSG_SERVICE_ACCEPT = 6,
MSG_KEXINIT = 20,
MSG_NEWKEYS = 21,
MSG_KEX_DH_GEX_REQUEST_OLD = 30,
MSG_KEX_DH_GEX_GROUP = 31,
MSG_KEX_DH_GEX_INIT = 32,
MSG_KEX_DH_GEX_REPLY = 33,
MSG_KEX_DH_GEX_REQUEST = 34,
MSG_USERAUTH_REQUEST = 50,
MSG_USERAUTH_FAILURE = 51,
MSG_USERAUTH_SUCCESS = 52,
MSG_USERAUTH_BANNER = 53,
MSG_GLOBAL_REQUEST = 80,
MSG_REQUEST_SUCCESS = 81,
MSG_REQUEST_FAILURE = 82,
MSG_CHANNEL_OPEN = 90,
MSG_CHANNEL_OPEN_CONFIRMATION = 91,
MSG_CHANNEL_OPEN_FAILURE = 92,
MSG_CHANNEL_WINDOW_ADJUST = 93,
MSG_CHANNEL_DATA = 94,
MSG_CHANNEL_EXTENDED_DATA = 95,
MSG_CHANNEL_EOF = 96,
MSG_CHANNEL_CLOSE = 97,
MSG_CHANNEL_REQUEST = 98,
MSG_CHANNEL_SUCCESS = 99,
MSG_CHANNEL_FAILURE = 100,
MSG_DISCONNECT = 1,
MSG_IGNORE = 2,
MSG_UNIMPLEMENTED = 3,
MSG_DEBUG = 4,
MSG_SERVICE_REQUEST = 5,
MSG_SERVICE_ACCEPT = 6,
MSG_KEXINIT = 20,
MSG_NEWKEYS = 21,
};
## SSH Generic
type SSH_PDU(is_orig: bool) = case $context.connection.get_state(is_orig) of {
VERSION_EXCHANGE -> version: SSH_Version(is_orig);
KEY_EXCHANGE_CLEARTEXT -> kex: SSH_Key_Exchange(is_orig);
ENCRYPTED -> ciphertext: bytestring &length=1 &transient;
VERSION_EXCHANGE -> version: SSH_Version(is_orig);
KEX_INIT -> kex: SSH_Key_Exchange(is_orig);
KEX_DH_GEX -> kex_dh_gex: SSH_Key_Exchange_DH_GEX(is_orig);
KEX_DH -> kex_dh: SSH_Key_Exchange_DH(is_orig);
KEX_ECC -> kex_ecc: SSH_Key_Exchange_ECC(is_orig);
KEX_GSS -> kex_gss: SSH_Key_Exchange_GSS(is_orig);
KEX_RSA -> kex_rsa: SSH_Key_Exchange_RSA(is_orig);
} &byteorder=bigendian;
type SSH_Version(is_orig: bool) = record {
version: bytestring &oneline;
pad: bytestring &length=0 &transient;
} &let {
update_state : bool = $context.connection.update_state(KEY_EXCHANGE_CLEARTEXT, is_orig);
update_state : bool = $context.connection.update_state(KEX_INIT, is_orig);
update_version: bool = $context.connection.update_version(version, is_orig);
};
@ -111,6 +150,8 @@ type SSH_Key_Exchange(is_orig: bool) = case $context.connection.get_version() of
SSH2 -> ssh2_msg: SSH2_Key_Exchange(is_orig);
};
## SSH1
type SSH1_Key_Exchange(is_orig: bool) = record {
packet_length: uint32;
pad_fill : bytestring &length = 8 - (packet_length % 8);
@ -119,20 +160,6 @@ type SSH1_Key_Exchange(is_orig: bool) = record {
crc : uint32;
} &length = packet_length + 4 + 8 - (packet_length % 8);
type SSH2_Key_Exchange_Header = record {
packet_length : uint32;
padding_length: uint8;
msg_type : uint8;
} &let {
payload_length: uint32 = packet_length - padding_length - 2;
} &length=6;
type SSH2_Key_Exchange(is_orig: bool) = record {
header : SSH2_Key_Exchange_Header;
payload : SSH2_Message(is_orig, header.msg_type, header.payload_length);
pad : bytestring &length=header.padding_length;
} &length=header.packet_length + 4;
type SSH1_Message(is_orig: bool, msg_type: uint8, length: uint32) = case msg_type of {
SSH_SMSG_PUBLIC_KEY -> public_key: SSH1_PUBLIC_KEY(length);
SSH_CMSG_SESSION_KEY -> session_key: SSH1_SESSION_KEY(length);
@ -160,19 +187,35 @@ type SSH1_SESSION_KEY(length: uint32) = record {
flags : uint32;
} &length=length;
type ssh1_mp_int = record {
len: uint16;
val: bytestring &length=(len+7)/8;
};
## SSH2
type SSH2_Key_Exchange_Header = record {
packet_length : uint32;
padding_length: uint8;
msg_type : uint8;
} &let {
payload_length: uint32 = packet_length - padding_length - 2;
} &length=6;
type SSH2_Key_Exchange(is_orig: bool) = record {
header : SSH2_Key_Exchange_Header;
payload : SSH2_Message(is_orig, header.msg_type, header.payload_length);
pad : bytestring &length=header.padding_length;
} &length=header.packet_length + 4;
type SSH2_Message(is_orig: bool, msg_type: uint8, length: uint32) = case msg_type of {
MSG_KEXINIT -> kexinit: SSH_KEXINIT(length);
MSG_KEX_DH_GEX_REQUEST -> dh_gex_request: SSH_DH_GEX_REQUEST(length);
MSG_KEX_DH_GEX_REQUEST_OLD -> dh_gex_request_old: SSH_DH_GEX_REQUEST_OLD(length);
MSG_KEX_DH_GEX_GROUP -> dh_gex_group: SSH_DH_GEX_GROUP(length);
MSG_KEX_DH_GEX_INIT -> dh_gex_init: SSH_DH_GEX_INIT(length);
MSG_KEX_DH_GEX_REPLY -> dh_gex_reply: SSH_DH_GEX_REPLY(length);
MSG_NEWKEYS -> new_keys: bytestring &length=length;
MSG_KEXINIT -> kexinit: SSH_KEXINIT(length, is_orig);
default -> unknown: bytestring &length=length;
} &let {
detach: bool = $context.connection.update_state(ENCRYPTED, is_orig) &if(msg_type == MSG_NEWKEYS);
};
type SSH_KEXINIT(length: uint32) = record {
type SSH_KEXINIT(length: uint32, is_orig: bool) = record {
cookie : bytestring &length=16;
kex_algorithms : ssh_string;
server_host_key_algorithms : ssh_string;
@ -182,21 +225,52 @@ type SSH_KEXINIT(length: uint32) = record {
mac_algorithms_server_to_client : ssh_string;
compression_algorithms_client_to_server : ssh_string;
compression_algorithms_server_to_client : ssh_string;
languages_client_to_server : ssh_string;
languages_server_to_client : ssh_string;
first_kex_packet_follows : uint8;
reserved : uint32;
languages_client_to_server : ssh_string;
languages_server_to_client : ssh_string;
first_kex_packet_follows : uint8;
reserved : uint32;
} &let {
proc_kex : bool = $context.connection.update_kex(kex_algorithms.val, is_orig);
} &length=length;
type SSH_DH_GEX_REQUEST(length: uint32) = record {
# KEX_DH exchanges
type SSH_Key_Exchange_DH(is_orig: bool) = record {
header : SSH2_Key_Exchange_Header;
payload : SSH_Key_Exchange_DH_Message(is_orig, header.msg_type, header.payload_length);
pad : bytestring &length=header.padding_length;
} &length=header.packet_length + 4;
type SSH_Key_Exchange_DH_Message(is_orig: bool, msg_type: uint8, length: uint32) = case msg_type of {
SSH_MSG_KEXDH_INIT -> init : SSH_DH_GEX_INIT(length);
SSH_MSG_KEXDH_REPLY -> reply : SSH_DH_GEX_REPLY(length);
};
# KEX_DH_GEX exchanges
type SSH_Key_Exchange_DH_GEX(is_orig: bool) = record {
header : SSH2_Key_Exchange_Header;
payload : SSH_Key_Exchange_DH_GEX_Message(is_orig, header.msg_type, header.payload_length);
pad : bytestring &length=header.padding_length;
} &length=header.packet_length + 4;
type SSH_Key_Exchange_DH_GEX_Message(is_orig: bool, msg_type: uint8, length: uint32) = case msg_type of {
SSH_MSG_KEX_DH_GEX_REQUEST_OLD -> request_old : SSH_DH_GEX_REQUEST_OLD;
SSH_MSG_KEX_DH_GEX_REQUEST -> request : SSH_DH_GEX_REQUEST;
SSH_MSG_KEX_DH_GEX_GROUP -> group : SSH_DH_GEX_GROUP(length);
SSH_MSG_KEX_DH_GEX_INIT -> init : SSH_DH_GEX_INIT(length);
SSH_MSG_KEX_DH_GEX_REPLY -> reply : SSH_DH_GEX_REPLY(length);
};
type SSH_DH_GEX_REQUEST = record {
min: uint32;
n : uint32;
max: uint32;
} &length=12;
type SSH_DH_GEX_REQUEST_OLD(length: uint32) = record {
payload: bytestring &length=length;
} &length=length;
type SSH_DH_GEX_REQUEST_OLD = record {
n: uint32;
} &length=4;
type SSH_DH_GEX_GROUP(length: uint32) = record {
p: ssh_string;
@ -213,9 +287,106 @@ type SSH_DH_GEX_REPLY(length: uint32) = record {
signature: ssh_string;
} &length=length;
type ssh1_mp_int = record {
len: uint16;
val: bytestring &length=(len+7)/8;
# KEX_RSA exchanges
type SSH_Key_Exchange_RSA(is_orig: bool) = record {
header : SSH2_Key_Exchange_Header;
payload : SSH_Key_Exchange_RSA_Message(is_orig, header.msg_type, header.payload_length);
pad : bytestring &length=header.padding_length;
} &length=header.packet_length + 4;
type SSH_Key_Exchange_RSA_Message(is_orig: bool, msg_type: uint8, length: uint32) = case msg_type of {
SSH_MSG_KEXRSA_PUBKEY -> pubkey : SSH_RSA_PUBKEY(length);
SSH_MSG_KEXRSA_SECRET -> secret : SSH_RSA_SECRET(length);
SSH_MSG_KEXRSA_DONE -> done : SSH_RSA_DONE(length);
};
type SSH_RSA_PUBKEY(length: uint32) = record {
k_s: ssh_string;
k_t: ssh_string;
} &length=length;
type SSH_RSA_SECRET(length: uint32) = record {
encrypted_payload: ssh_string;
} &length=length;
type SSH_RSA_DONE(length: uint32) = record {
signature: ssh_string;
} &length=length;
# KEX_GSS exchanges
type SSH_Key_Exchange_GSS(is_orig: bool) = record {
header : SSH2_Key_Exchange_Header;
payload : SSH_Key_Exchange_GSS_Message(is_orig, header.msg_type, header.payload_length);
pad : bytestring &length=header.padding_length;
} &length=header.packet_length + 4;
type SSH_Key_Exchange_GSS_Message(is_orig: bool, msg_type: uint8, length: uint32) = case msg_type of {
SSH_MSG_KEXGSS_INIT -> init : SSH_GSS_INIT(length);
SSH_MSG_KEXGSS_CONTINUE -> cont : SSH_GSS_CONTINUE(length);
SSH_MSG_KEXGSS_COMPLETE -> complete : SSH_GSS_COMPLETE(length);
SSH_MSG_KEXGSS_HOSTKEY -> hostkey : SSH_GSS_HOSTKEY(length);
SSH_MSG_KEXGSS_ERROR -> error : SSH_GSS_ERROR(length);
SSH_MSG_KEXGSS_GROUPREQ -> groupreq : SSH_DH_GEX_REQUEST;
SSH_MSG_KEXGSS_GROUP -> group : SSH_DH_GEX_GROUP(length);
};
type SSH_GSS_INIT(length: uint32) = record {
output_token: ssh_string;
e : ssh_string;
} &length=length;
type SSH_GSS_CONTINUE(length: uint32) = record {
output_token: ssh_string;
} &length=length;
type SSH_GSS_COMPLETE(length: uint32) = record {
f : ssh_string;
per_msg_token : ssh_string;
have_token : uint8;
parse_token : case have_token of {
0 -> no_token: empty;
default -> token: ssh_string;
};
} &length=length;
type SSH_GSS_HOSTKEY(length: uint32) = record {
k_s: ssh_string;
} &length=length;
type SSH_GSS_ERROR(length: uint32) = record {
major_status: uint32;
minor_status: uint32;
message : ssh_string;
language : ssh_string;
} &length=length;
# KEX_ECDH and KEX_ECMQV exchanges
type SSH_Key_Exchange_ECC(is_orig: bool) = record {
header : SSH2_Key_Exchange_Header;
payload : SSH_Key_Exchange_ECC_Message(is_orig, header.msg_type, header.payload_length);
pad : bytestring &length=header.padding_length;
} &length=header.packet_length + 4;
type SSH_Key_Exchange_ECC_Message(is_orig: bool, msg_type: uint8, length: uint32) = case msg_type of {
SSH_MSG_KEX_ECDH_INIT -> init : SSH_ECC_INIT(length);
SSH_MSG_KEX_ECDH_REPLY -> reply : SSH_ECC_REPLY(length);
};
# This deviates from the RFC. SSH_MSG_KEX_ECDH_INIT and
# SSH_MSG_KEX_ECMQV_INIT can be parsed the same way.
type SSH_ECC_INIT(length: uint32) = record {
q_c: ssh_string;
};
# This deviates from the RFC. SSH_MSG_KEX_ECDH_REPLY and
# SSH_MSG_KEX_ECMQV_REPLY can be parsed the same way.
type SSH_ECC_REPLY(length: uint32) = record {
k_s : ssh_string;
q_s : ssh_string;
signature : ssh_string;
};
type ssh_string = record {
@ -223,17 +394,35 @@ type ssh_string = record {
val: bytestring &length=len;
};
type ssh_host_key = record {
len: uint32;
key_type: ssh_string;
key: ssh_string;
} &length=(len + 4);
## Done with types
refine connection SSH_Conn += {
%member{
int state_up_;
int state_down_;
int version_;
bool kex_orig_;
bool kex_seen_;
bytestring kex_algs_cache_;
bytestring kex_algorithm_;
%}
%init{
state_up_ = VERSION_EXCHANGE;
state_down_ = VERSION_EXCHANGE;
version_ = UNK;
kex_seen_ = false;
kex_orig_ = false;
kex_algs_cache_ = bytestring();
kex_algorithm_ = bytestring();
%}
function get_state(is_orig: bool): int
@ -274,4 +463,103 @@ refine connection SSH_Conn += {
return true;
%}
function update_kex_state_if_equal(s: string, to_state: state): bool
%{
if ( strcmp(c_str(kex_algorithm_), s.c_str()) == 0 )
{
update_state(to_state, true);
update_state(to_state, false);
return true;
}
return false;
%}
function update_kex_state_if_startswith(s: string, to_state: state): bool
%{
if ( (uint) kex_algorithm_.length() < s.length() )
return false;
if ( strcmp(std_str(kex_algorithm_).substr(0, s.length()).c_str(), s.c_str()) == 0 )
{
update_state(to_state, true);
update_state(to_state, false);
return true;
}
return false;
%}
function update_kex(algs: bytestring, orig: bool): bool
%{
if ( !kex_seen_ )
{
kex_seen_ = true;
kex_orig_ = orig;
kex_algs_cache_.init(${algs}.data(), ${algs}.length());
return false;
}
else if ( kex_orig_ == orig )
return false;
VectorVal* client_list = name_list_to_vector(orig ? algs : kex_algs_cache_);
VectorVal* server_list = name_list_to_vector(orig ? kex_algs_cache_ : algs);
for ( unsigned int i = 0; i < client_list->Size(); ++i)
{
for ( unsigned int j = 0; j < server_list->Size(); ++j)
{
if ( strcmp((const char *) client_list->Lookup(i)->AsStringVal()->Bytes(),
(const char *) server_list->Lookup(j)->AsStringVal()->Bytes()) == 0 )
{
kex_algorithm_.init((const uint8 *) client_list->Lookup(i)->AsStringVal()->Bytes(),
client_list->Lookup(i)->AsStringVal()->Len());
// UNTESTED
if ( update_kex_state_if_equal("rsa1024-sha1", KEX_RSA) )
return true;
// UNTESTED
if ( update_kex_state_if_equal("rsa2048-sha256", KEX_RSA) )
return true;
// UNTESTED
if ( update_kex_state_if_equal("diffie-hellman-group1-sha1", KEX_DH) )
return true;
// UNTESTED
if ( update_kex_state_if_equal("diffie-hellman-group14-sha1", KEX_DH) )
return true;
if ( update_kex_state_if_equal("diffie-hellman-group-exchange-sha1", KEX_DH_GEX) )
return true;
if ( update_kex_state_if_equal("diffie-hellman-group-exchange-sha256", KEX_DH_GEX) )
return true;
if ( update_kex_state_if_startswith("gss-group1-sha1-", KEX_GSS) )
return true;
if ( update_kex_state_if_startswith("gss-group14-sha1-", KEX_GSS) )
return true;
if ( update_kex_state_if_startswith("gss-gex-sha1-", KEX_GSS) )
return true;
if ( update_kex_state_if_startswith("gss-", KEX_GSS) )
return true;
if ( update_kex_state_if_startswith("ecdh-sha2-", KEX_ECC) )
return true;
if ( update_kex_state_if_equal("ecmqv-sha2", KEX_ECC) )
return true;
if ( update_kex_state_if_equal("curve25519-sha256@libssh.org", KEX_ECC) )
return true;
bro_analyzer()->Weird(fmt("ssh_unknown_kex_algorithm=%s", c_str(kex_algorithm_)));
return true;
}
}
}
return true;
%}
};

1
src/analyzer/protocol/ssh/ssh.pac
View file

@ -8,6 +8,7 @@
%include bro.pac
%extern{
#include "types.bif.h"
#include "events.bif.h"
%}

5
src/analyzer/protocol/ssh/types.bif Normal file
View file

@ -0,0 +1,5 @@
module SSH;
type Capabilities: record;
module GLOBAL;