aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rust/dhcp: rustfmt

Browse Source
pull/12445/head
Jason Ish 10 months ago committed by Victor Julien
parent c5089ac5f4
commit a7f7dc5296
3 changed files with 125 additions and 141 deletions
Show Stats Download Patch File Download Diff File

92
rust/src/dhcp/dhcp.rs
Unescape Escape View File

@ -16,7 +16,7 @@
*/ */
use crate::applayer::{self, *}; use crate::applayer::{self, *};
use crate::core::{ALPROTO_UNKNOWN, AppProto, IPPROTO_UDP}; use crate::core::{AppProto, ALPROTO_UNKNOWN, IPPROTO_UDP};
use crate::dhcp::parser::*; use crate::dhcp::parser::*;
use crate::flow::Flow; use crate::flow::Flow;
use std; use std;
@ -177,12 +177,9 @@ impl DHCPState {
} }
} }
unsafe extern "C" fn dhcp_probing_parser(_flow: *const Flow, unsafe extern "C" fn dhcp_probing_parser(
_direction: u8, _flow: *const Flow, _direction: u8, input: *const u8, input_len: u32, _rdir: *mut u8,
input: *const u8, ) -> AppProto {
input_len: u32,
_rdir: *mut u8) -> AppProto
{
if input_len < DHCP_MIN_FRAME_LEN || input.is_null() { if input_len < DHCP_MIN_FRAME_LEN || input.is_null() {
return ALPROTO_UNKNOWN; return ALPROTO_UNKNOWN;
} }
@ -198,14 +195,16 @@ unsafe extern "C" fn dhcp_probing_parser(_flow: *const Flow,
} }
} }
extern "C" fn dhcp_tx_get_alstate_progress(_tx: *mut std::os::raw::c_void, extern "C" fn dhcp_tx_get_alstate_progress(
_direction: u8) -> std::os::raw::c_int { _tx: *mut std::os::raw::c_void, _direction: u8,
) -> std::os::raw::c_int {
// As this is a stateless parser, simply use 1. // As this is a stateless parser, simply use 1.
return 1; return 1;
} }
unsafe extern "C" fn dhcp_state_get_tx(state: *mut std::os::raw::c_void, unsafe extern "C" fn dhcp_state_get_tx(
tx_id: u64) -> *mut std::os::raw::c_void { state: *mut std::os::raw::c_void, tx_id: u64,
) -> *mut std::os::raw::c_void {
let state = cast_pointer!(state, DHCPState); let state = cast_pointer!(state, DHCPState);
match state.get_tx(tx_id) { match state.get_tx(tx_id) {
Some(tx) => { Some(tx) => {
@ -222,12 +221,10 @@ unsafe extern "C" fn dhcp_state_get_tx_count(state: *mut std::os::raw::c_void) -
return state.tx_id; return state.tx_id;
} }
unsafe extern "C" fn dhcp_parse(_flow: *const Flow, unsafe extern "C" fn dhcp_parse(
state: *mut std::os::raw::c_void, _flow: *const Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
_pstate: *mut std::os::raw::c_void, stream_slice: StreamSlice, _data: *const std::os::raw::c_void,
stream_slice: StreamSlice, ) -> AppLayerResult {
_data: *const std::os::raw::c_void,
) -> AppLayerResult {
let state = cast_pointer!(state, DHCPState); let state = cast_pointer!(state, DHCPState);
if state.parse(stream_slice.as_slice()) { if state.parse(stream_slice.as_slice()) {
return AppLayerResult::ok(); return AppLayerResult::ok();
@ -235,15 +232,14 @@ unsafe extern "C" fn dhcp_parse(_flow: *const Flow,
return AppLayerResult::err(); return AppLayerResult::err();
} }
pub unsafe extern "C" fn dhcp_state_tx_free( pub unsafe extern "C" fn dhcp_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
state: *mut std::os::raw::c_void,
tx_id: u64)
{
let state = cast_pointer!(state, DHCPState); let state = cast_pointer!(state, DHCPState);
state.free_tx(tx_id); state.free_tx(tx_id);
} }
extern "C" fn dhcp_state_new(_orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto) -> *mut std::os::raw::c_void { extern "C" fn dhcp_state_new(
_orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto,
) -> *mut std::os::raw::c_void {
let state = DHCPState::new(); let state = DHCPState::new();
let boxed = Box::new(state); let boxed = Box::new(state);
return Box::into_raw(boxed) as *mut _; return Box::into_raw(boxed) as *mut _;
@ -264,32 +260,32 @@ pub unsafe extern "C" fn SCRegisterDhcpParser() {
let ports = CString::new("[67,68]").unwrap(); let ports = CString::new("[67,68]").unwrap();
let parser = RustParser { let parser = RustParser {
name: PARSER_NAME.as_ptr() as *const std::os::raw::c_char, name: PARSER_NAME.as_ptr() as *const std::os::raw::c_char,
default_port : ports.as_ptr(), default_port: ports.as_ptr(),
ipproto : IPPROTO_UDP, ipproto: IPPROTO_UDP,
probe_ts : Some(dhcp_probing_parser), probe_ts: Some(dhcp_probing_parser),
probe_tc : Some(dhcp_probing_parser), probe_tc: Some(dhcp_probing_parser),
min_depth : 0, min_depth: 0,
max_depth : 16, max_depth: 16,
state_new : dhcp_state_new, state_new: dhcp_state_new,
state_free : dhcp_state_free, state_free: dhcp_state_free,
tx_free : dhcp_state_tx_free, tx_free: dhcp_state_tx_free,
parse_ts : dhcp_parse, parse_ts: dhcp_parse,
parse_tc : dhcp_parse, parse_tc: dhcp_parse,
get_tx_count : dhcp_state_get_tx_count, get_tx_count: dhcp_state_get_tx_count,
get_tx : dhcp_state_get_tx, get_tx: dhcp_state_get_tx,
tx_comp_st_ts : 1, tx_comp_st_ts: 1,
tx_comp_st_tc : 1, tx_comp_st_tc: 1,
tx_get_progress : dhcp_tx_get_alstate_progress, tx_get_progress: dhcp_tx_get_alstate_progress,
get_eventinfo : Some(DHCPEvent::get_event_info), get_eventinfo: Some(DHCPEvent::get_event_info),
get_eventinfo_byid : Some(DHCPEvent::get_event_info_by_id), get_eventinfo_byid: Some(DHCPEvent::get_event_info_by_id),
localstorage_new : None, localstorage_new: None,
localstorage_free : None, localstorage_free: None,
get_tx_files : None, get_tx_files: None,
get_tx_iterator : Some(applayer::state_get_tx_iterator::<DHCPState, DHCPTransaction>), get_tx_iterator: Some(applayer::state_get_tx_iterator::<DHCPState, DHCPTransaction>),
get_tx_data : dhcp_get_tx_data, get_tx_data: dhcp_get_tx_data,
get_state_data : dhcp_get_state_data, get_state_data: dhcp_get_state_data,
apply_tx_config : None, apply_tx_config: None,
flags : 0, flags: 0,
get_frame_id_by_name: None, get_frame_id_by_name: None,
get_frame_name_by_id: None, get_frame_name_by_id: None,
}; };

170
rust/src/dhcp/logger.rs
Unescape Escape View File

@ -18,10 +18,10 @@
use std; use std;
use std::os::raw::c_void; use std::os::raw::c_void;
use crate::conf::ConfNode;
use crate::dhcp::dhcp::*; use crate::dhcp::dhcp::*;
use crate::dhcp::parser::{DHCPOptionWrapper,DHCPOptGeneric}; use crate::dhcp::parser::{DHCPOptGeneric, DHCPOptionWrapper};
use crate::dns::log::dns_print_addr; use crate::dns::log::dns_print_addr;
use crate::conf::ConfNode;
use crate::jsonbuilder::{JsonBuilder, JsonError}; use crate::jsonbuilder::{JsonBuilder, JsonError};
pub struct DHCPLogger { pub struct DHCPLogger {
@ -29,11 +29,10 @@ pub struct DHCPLogger {
} }
impl DHCPLogger { impl DHCPLogger {
pub fn new(conf: ConfNode) -> Self { pub fn new(conf: ConfNode) -> Self {
return Self { return Self {
extended: conf.get_child_bool("extended"), extended: conf.get_child_bool("extended"),
} };
} }
fn get_type(&self, tx: &DHCPTransaction) -> Option<u8> { fn get_type(&self, tx: &DHCPTransaction) -> Option<u8> {
@ -42,7 +41,8 @@ impl DHCPLogger {
let code = option.code; let code = option.code;
#[allow(clippy::single_match)] #[allow(clippy::single_match)]
match &option.option { match &option.option {
DHCPOptionWrapper::Generic(option) => { DHCPOptionWrapper::Generic(option) =>
{
#[allow(clippy::single_match)] #[allow(clippy::single_match)]
match code { match code {
DHCP_OPT_TYPE => { DHCP_OPT_TYPE => {
@ -61,7 +61,7 @@ impl DHCPLogger {
pub fn do_log(&self, tx: &DHCPTransaction) -> bool { pub fn do_log(&self, tx: &DHCPTransaction) -> bool {
if !self.extended { if !self.extended {
if let Some(DHCP_TYPE_ACK) = self.get_type(tx){ if let Some(DHCP_TYPE_ACK) = self.get_type(tx) {
return true; return true;
} }
return false; return false;
@ -86,101 +86,86 @@ impl DHCPLogger {
js.set_string("type", "<unknown>")?; js.set_string("type", "<unknown>")?;
} }
} }
js.set_uint("id", header.txid as u64)?; js.set_uint("id", header.txid as u64)?;
js.set_string("client_mac", js.set_string("client_mac", &format_addr_hex(&header.clienthw))?;
&format_addr_hex(&header.clienthw))?;
js.set_string("assigned_ip", &dns_print_addr(&header.yourip))?; js.set_string("assigned_ip", &dns_print_addr(&header.yourip))?;
if self.extended { if self.extended {
js.set_string("client_ip", &dns_print_addr(&header.clientip))?; js.set_string("client_ip", &dns_print_addr(&header.clientip))?;
if header.opcode == BOOTP_REPLY { if header.opcode == BOOTP_REPLY {
js.set_string("relay_ip", js.set_string("relay_ip", &dns_print_addr(&header.giaddr))?;
&dns_print_addr(&header.giaddr))?; js.set_string("next_server_ip", &dns_print_addr(&header.serverip))?;
js.set_string("next_server_ip",
&dns_print_addr(&header.serverip))?;
} }
} }
for option in options { for option in options {
let code = option.code; let code = option.code;
match option.option { match option.option {
DHCPOptionWrapper::ClientId(ref clientid) => { DHCPOptionWrapper::ClientId(ref clientid) => {
js.set_string("client_id", js.set_string("client_id", &format_addr_hex(&clientid.data))?;
&format_addr_hex(&clientid.data))?;
} }
DHCPOptionWrapper::TimeValue(ref time_value) => { DHCPOptionWrapper::TimeValue(ref time_value) => match code {
match code { DHCP_OPT_ADDRESS_TIME => {
DHCP_OPT_ADDRESS_TIME => { if self.extended {
if self.extended { js.set_uint("lease_time", time_value.seconds as u64)?;
js.set_uint("lease_time",
time_value.seconds as u64)?;
}
}
DHCP_OPT_REBINDING_TIME => {
if self.extended {
js.set_uint("rebinding_time",
time_value.seconds as u64)?;
}
}
DHCP_OPT_RENEWAL_TIME => {
js.set_uint("renewal_time",
time_value.seconds as u64)?;
} }
_ => {}
} }
} DHCP_OPT_REBINDING_TIME => {
DHCPOptionWrapper::Generic(ref option) => { if self.extended {
match code { js.set_uint("rebinding_time", time_value.seconds as u64)?;
DHCP_OPT_SUBNET_MASK => {
if self.extended {
js.set_string("subnet_mask",
&dns_print_addr(&option.data))?;
}
} }
DHCP_OPT_HOSTNAME => { }
if !option.data.is_empty() { DHCP_OPT_RENEWAL_TIME => {
js.set_string_from_bytes("hostname", js.set_uint("renewal_time", time_value.seconds as u64)?;
&option.data)?; }
} _ => {}
},
DHCPOptionWrapper::Generic(ref option) => match code {
DHCP_OPT_SUBNET_MASK => {
if self.extended {
js.set_string("subnet_mask", &dns_print_addr(&option.data))?;
} }
DHCP_OPT_TYPE => { }
self.log_opt_type(js, option)?; DHCP_OPT_HOSTNAME => {
if !option.data.is_empty() {
js.set_string_from_bytes("hostname", &option.data)?;
} }
DHCP_OPT_REQUESTED_IP => { }
if self.extended { DHCP_OPT_TYPE => {
js.set_string("requested_ip", self.log_opt_type(js, option)?;
&dns_print_addr(&option.data))?; }
} DHCP_OPT_REQUESTED_IP => {
if self.extended {
js.set_string("requested_ip", &dns_print_addr(&option.data))?;
} }
DHCP_OPT_PARAMETER_LIST => { }
if self.extended { DHCP_OPT_PARAMETER_LIST => {
self.log_opt_parameters(js, option)?; if self.extended {
} self.log_opt_parameters(js, option)?;
} }
DHCP_OPT_DNS_SERVER => { }
if self.extended { DHCP_OPT_DNS_SERVER => {
self.log_opt_dns_server(js, option)?; if self.extended {
} self.log_opt_dns_server(js, option)?;
} }
DHCP_OPT_ROUTERS => { }
if self.extended { DHCP_OPT_ROUTERS => {
self.log_opt_routers(js, option)?; if self.extended {
} self.log_opt_routers(js, option)?;
} }
DHCP_OPT_VENDOR_CLASS_ID => { }
if self.extended && !option.data.is_empty(){ DHCP_OPT_VENDOR_CLASS_ID => {
js.set_string_from_bytes("vendor_class_identifier", if self.extended && !option.data.is_empty() {
&option.data)?; js.set_string_from_bytes("vendor_class_identifier", &option.data)?;
}
} }
_ => {}
} }
} _ => {}
},
_ => {} _ => {}
} }
} }
js.close()?; js.close()?;
return Ok(()); return Ok(());
@ -197,14 +182,16 @@ impl DHCPLogger {
DHCP_TYPE_NAK => "nak", DHCP_TYPE_NAK => "nak",
DHCP_TYPE_RELEASE => "release", DHCP_TYPE_RELEASE => "release",
DHCP_TYPE_INFORM => "inform", DHCP_TYPE_INFORM => "inform",
_ => "unknown" _ => "unknown",
}; };
js.set_string("dhcp_type", dhcp_type)?; js.set_string("dhcp_type", dhcp_type)?;
} }
Ok(()) Ok(())
} }
fn log_opt_parameters(&self, js: &mut JsonBuilder, option: &DHCPOptGeneric) -> Result<(), JsonError> { fn log_opt_parameters(
&self, js: &mut JsonBuilder, option: &DHCPOptGeneric,
) -> Result<(), JsonError> {
js.open_array("params")?; js.open_array("params")?;
for i in &option.data { for i in &option.data {
let param = match *i { let param = match *i {
@ -216,7 +203,7 @@ impl DHCPLogger {
DHCP_PARAM_NTP_SERVER => "ntp_server", DHCP_PARAM_NTP_SERVER => "ntp_server",
DHCP_PARAM_TFTP_SERVER_NAME => "tftp_server_name", DHCP_PARAM_TFTP_SERVER_NAME => "tftp_server_name",
DHCP_PARAM_TFTP_SERVER_IP => "tftp_server_ip", DHCP_PARAM_TFTP_SERVER_IP => "tftp_server_ip",
_ => "" _ => "",
}; };
if !param.is_empty() { if !param.is_empty() {
js.append_string(param)?; js.append_string(param)?;
@ -225,8 +212,10 @@ impl DHCPLogger {
js.close()?; js.close()?;
Ok(()) Ok(())
} }
fn log_opt_dns_server(&self, js: &mut JsonBuilder, option: &DHCPOptGeneric) -> Result<(), JsonError> { fn log_opt_dns_server(
&self, js: &mut JsonBuilder, option: &DHCPOptGeneric,
) -> Result<(), JsonError> {
js.open_array("dns_servers")?; js.open_array("dns_servers")?;
for i in 0..(option.data.len() / 4) { for i in 0..(option.data.len() / 4) {
let val = dns_print_addr(&option.data[(i * 4)..(i * 4) + 4]); let val = dns_print_addr(&option.data[(i * 4)..(i * 4) + 4]);
@ -235,8 +224,10 @@ impl DHCPLogger {
js.close()?; js.close()?;
Ok(()) Ok(())
} }
fn log_opt_routers(&self, js: &mut JsonBuilder, option: &DHCPOptGeneric) -> Result<(), JsonError> { fn log_opt_routers(
&self, js: &mut JsonBuilder, option: &DHCPOptGeneric,
) -> Result<(), JsonError> {
js.open_array("routers")?; js.open_array("routers")?;
for i in 0..(option.data.len() / 4) { for i in 0..(option.data.len() / 4) {
let val = dns_print_addr(&option.data[(i * 4)..(i * 4) + 4]); let val = dns_print_addr(&option.data[(i * 4)..(i * 4) + 4]);
@ -245,13 +236,10 @@ impl DHCPLogger {
js.close()?; js.close()?;
Ok(()) Ok(())
} }
} }
fn format_addr_hex(input: &[u8]) -> String { fn format_addr_hex(input: &[u8]) -> String {
let parts: Vec<String> = input.iter() let parts: Vec<String> = input.iter().map(|b| format!("{:02x}", b)).collect();
.map(|b| format!("{:02x}", b))
.collect();
return parts.join(":"); return parts.join(":");
} }
@ -268,18 +256,18 @@ pub unsafe extern "C" fn SCDhcpLoggerFree(logger: *mut std::os::raw::c_void) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn SCDhcpLoggerLog(logger: *mut std::os::raw::c_void, pub unsafe extern "C" fn SCDhcpLoggerLog(
tx: *mut std::os::raw::c_void, logger: *mut std::os::raw::c_void, tx: *mut std::os::raw::c_void, js: &mut JsonBuilder,
js: &mut JsonBuilder) -> bool { ) -> bool {
let logger = cast_pointer!(logger, DHCPLogger); let logger = cast_pointer!(logger, DHCPLogger);
let tx = cast_pointer!(tx, DHCPTransaction); let tx = cast_pointer!(tx, DHCPTransaction);
logger.log(tx, js).is_ok() logger.log(tx, js).is_ok()
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn SCDhcpLoggerDoLog(logger: *mut std::os::raw::c_void, pub unsafe extern "C" fn SCDhcpLoggerDoLog(
tx: *mut std::os::raw::c_void) logger: *mut std::os::raw::c_void, tx: *mut std::os::raw::c_void,
-> bool { ) -> bool {
let logger = cast_pointer!(logger, DHCPLogger); let logger = cast_pointer!(logger, DHCPLogger);
let tx = cast_pointer!(tx, DHCPTransaction); let tx = cast_pointer!(tx, DHCPTransaction);
logger.do_log(tx) logger.do_log(tx)

4
rust/src/dhcp/mod.rs
Unescape Escape View File

@ -17,7 +17,7 @@
//! DHCP parser, detection and logger module. //! DHCP parser, detection and logger module.
pub mod detect;
pub mod dhcp; pub mod dhcp;
pub mod parser;
pub mod logger; pub mod logger;
pub mod detect; pub mod parser;

Write Preview
Loading…
Cancel
Save