52 rs_modbus_register_parser();
77 #define MODBUS_CONFIG_DEFAULT_STREAM_DEPTH 0
80 static uint8_t invalidFunctionCode[] = {
90 static uint8_t readCoilsReq[] = { 0x00, 0x00,
98 static uint8_t readCoilsRsp[] = { 0x00, 0x00,
106 static uint8_t readCoilsErrorRsp[] = {
118 static uint8_t writeSingleRegisterReq[] = { 0x00, 0x0A,
126 static uint8_t invalidWriteSingleRegisterReq[] = { 0x00, 0x0A,
133 static uint8_t writeSingleRegisterRsp[] = { 0x00, 0x0A,
143 static uint8_t writeMultipleRegistersReq[] = { 0x00, 0x0A,
154 static uint8_t writeMultipleRegistersRsp[] = { 0x00, 0x0A,
164 static uint8_t maskWriteRegisterReq[] = { 0x00, 0x0A,
173 static uint8_t invalidMaskWriteRegisterReq[] = { 0x00, 0x0A,
181 static uint8_t maskWriteRegisterRsp[] = { 0x00, 0x0A,
193 static uint8_t readWriteMultipleRegistersReq[] = { 0x12, 0x34,
208 static uint8_t readWriteMultipleRegistersRsp[] = { 0x12, 0x34,
223 static uint8_t forceListenOnlyMode[] = { 0x0A, 0x00,
231 static uint8_t invalidProtocolIdReq[] = { 0x00, 0x00,
239 static uint8_t invalidLengthWriteMultipleRegistersReq[] = {
251 static uint8_t exceededLengthWriteMultipleRegistersReq[] = {
261 static uint8_t invalidLengthPDUWriteMultipleRegistersReq[] = {
269 static int ModbusParserTest01(
void) {
276 memset(&f, 0,
sizeof(f));
277 memset(&ssn, 0,
sizeof(ssn));
281 f.
proto = IPPROTO_TCP;
287 STREAM_TOSERVER, readCoilsReq,
288 sizeof(readCoilsReq));
291 ModbusState *modbus_state = f.
alstate;
294 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 0);
296 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 1);
297 FAIL_IF_NOT(rs_modbus_message_get_read_request_address(&request) == 0x7890);
298 FAIL_IF_NOT(rs_modbus_message_get_read_request_quantity(&request) == 19);
301 STREAM_TOCLIENT, readCoilsRsp,
302 sizeof(readCoilsRsp));
305 FAIL_IF_NOT(rs_modbus_state_get_tx_count(modbus_state) == 1);
314 static int ModbusParserTest02(
void) {
321 memset(&f, 0,
sizeof(f));
322 memset(&ssn, 0,
sizeof(ssn));
326 f.
proto = IPPROTO_TCP;
332 STREAM_TOSERVER, writeMultipleRegistersReq,
333 sizeof(writeMultipleRegistersReq));
336 ModbusState *modbus_state = f.
alstate;
339 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 0);
341 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 16);
342 FAIL_IF_NOT(rs_modbus_message_get_write_multreq_address(&request) == 0x01);
343 FAIL_IF_NOT(rs_modbus_message_get_write_multreq_quantity(&request) == 2);
346 const uint8_t *data = rs_modbus_message_get_write_multreq_data(&request, &data_len);
354 STREAM_TOCLIENT, writeMultipleRegistersRsp,
355 sizeof(writeMultipleRegistersRsp));
358 FAIL_IF_NOT(rs_modbus_state_get_tx_count(modbus_state) == 1);
367 static int ModbusParserTest03(
void) {
379 memset(&f, 0,
sizeof(
Flow));
387 f.
proto = IPPROTO_TCP;
402 "(msg:\"Modbus Data mismatch\"; "
404 "modbus.value_mismatch; "
413 readWriteMultipleRegistersReq,
414 sizeof(readWriteMultipleRegistersReq));
417 ModbusState *modbus_state = f.
alstate;
420 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 0);
423 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 23);
424 FAIL_IF_NOT(rs_modbus_message_get_rw_multreq_read_address(&request) == 0x03);
425 FAIL_IF_NOT(rs_modbus_message_get_rw_multreq_read_quantity(&request) == 6);
426 FAIL_IF_NOT(rs_modbus_message_get_rw_multreq_write_address(&request) == 0x0E);
427 FAIL_IF_NOT(rs_modbus_message_get_rw_multreq_write_quantity(&request) == 3);
430 uint8_t
const *data = rs_modbus_message_get_rw_multreq_write_data(&request, &data_len);
440 STREAM_TOCLIENT, readWriteMultipleRegistersRsp,
441 sizeof(readWriteMultipleRegistersRsp));
444 FAIL_IF_NOT(rs_modbus_state_get_tx_count(modbus_state) == 1);
465 static int ModbusParserTest04(
void) {
472 memset(&f, 0,
sizeof(f));
473 memset(&ssn, 0,
sizeof(ssn));
477 f.
proto = IPPROTO_TCP;
483 STREAM_TOSERVER, forceListenOnlyMode,
484 sizeof(forceListenOnlyMode));
487 ModbusState *modbus_state = f.
alstate;
490 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 0);
493 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 8);
494 FAIL_IF_NOT(rs_modbus_message_get_subfunction(&request) == 4);
503 static int ModbusParserTest05(
void) {
515 memset(&f, 0,
sizeof(
Flow));
523 f.
proto = IPPROTO_TCP;
538 "(msg:\"Modbus invalid Protocol version\"; "
540 "modbus.invalid_protocol_id; "
548 STREAM_TOSERVER, invalidProtocolIdReq,
549 sizeof(invalidProtocolIdReq));
552 ModbusState *modbus_state = f.
alstate;
574 static int ModbusParserTest06(
void) {
586 memset(&f, 0,
sizeof(
Flow));
594 f.
proto = IPPROTO_TCP;
609 "(msg:\"Modbus unsolicited response\"; "
611 "modbus.unsolicited_response; "
619 STREAM_TOCLIENT, readCoilsRsp,
620 sizeof(readCoilsRsp));
623 ModbusState *modbus_state = f.
alstate;
645 static int ModbusParserTest07(
void) {
657 memset(&f, 0,
sizeof(
Flow));
665 f.
proto = IPPROTO_TCP;
680 "(msg:\"Modbus invalid Length\"; "
682 "modbus.invalid_length; "
691 invalidLengthWriteMultipleRegistersReq,
692 sizeof(invalidLengthWriteMultipleRegistersReq));
695 ModbusState *modbus_state = f.
alstate;
717 static int ModbusParserTest08(
void) {
729 memset(&f, 0,
sizeof(
Flow));
737 f.
proto = IPPROTO_TCP;
752 "(msg:\"Modbus Exception code invalid\"; "
754 "modbus.invalid_exception_code; "
762 STREAM_TOSERVER, readCoilsReq,
763 sizeof(readCoilsReq));
766 ModbusState *modbus_state = f.
alstate;
769 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 0);
772 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 1);
773 FAIL_IF_NOT(rs_modbus_message_get_read_request_address(&request) == 0x7890);
774 FAIL_IF_NOT(rs_modbus_message_get_read_request_quantity(&request) == 19);
777 STREAM_TOCLIENT, readCoilsErrorRsp,
778 sizeof(readCoilsErrorRsp));
781 FAIL_IF_NOT(rs_modbus_state_get_tx_count(modbus_state) == 1);
802 static int ModbusParserTest09(
void) {
807 uint32_t input_len =
sizeof(readCoilsReq), part2_len = 3;
808 uint8_t *input = readCoilsReq;
812 memset(&f, 0,
sizeof(f));
813 memset(&ssn, 0,
sizeof(ssn));
817 f.
proto = IPPROTO_TCP;
823 STREAM_TOSERVER, input, input_len - part2_len);
827 STREAM_TOSERVER, input, input_len);
830 ModbusState *modbus_state = f.
alstate;
833 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 0);
836 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 1);
837 FAIL_IF_NOT(rs_modbus_message_get_read_request_address(&request) == 0x7890);
838 FAIL_IF_NOT(rs_modbus_message_get_read_request_quantity(&request) == 19);
840 input_len =
sizeof(readCoilsRsp);
842 input = readCoilsRsp;
845 STREAM_TOCLIENT, input, input_len - part2_len);
849 STREAM_TOCLIENT, input, input_len);
852 FAIL_IF_NOT(rs_modbus_state_get_tx_count(modbus_state) == 1);
861 static int ModbusParserTest10(
void) {
862 uint32_t input_len =
sizeof(readCoilsReq) +
sizeof(writeMultipleRegistersReq);
863 uint8_t *input, *ptr;
871 input = (uint8_t *)
SCMalloc (input_len *
sizeof(uint8_t));
874 memcpy(input, readCoilsReq,
sizeof(readCoilsReq));
875 memcpy(input +
sizeof(readCoilsReq), writeMultipleRegistersReq,
sizeof(writeMultipleRegistersReq));
877 memset(&f, 0,
sizeof(f));
878 memset(&ssn, 0,
sizeof(ssn));
882 f.
proto = IPPROTO_TCP;
888 STREAM_TOSERVER, input, input_len);
891 ModbusState *modbus_state = f.
alstate;
894 FAIL_IF_NOT(rs_modbus_state_get_tx_count(modbus_state) == 2);
896 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 1);
899 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 16);
900 FAIL_IF_NOT(rs_modbus_message_get_write_multreq_address(&request) == 0x01);
901 FAIL_IF_NOT(rs_modbus_message_get_write_multreq_quantity(&request) == 2);
904 uint8_t
const *data = rs_modbus_message_get_write_multreq_data(&request, &data_len);
911 input_len =
sizeof(readCoilsRsp) +
sizeof(writeMultipleRegistersRsp);
913 ptr = (uint8_t *)
SCRealloc (input, input_len *
sizeof(uint8_t));
917 memcpy(input, readCoilsRsp,
sizeof(readCoilsRsp));
918 memcpy(input +
sizeof(readCoilsRsp), writeMultipleRegistersRsp,
sizeof(writeMultipleRegistersRsp));
931 static int ModbusParserTest11(
void) {
940 size_t input_len = 65536;
941 uint8_t *input =
SCCalloc(1, input_len);
945 memcpy(input, exceededLengthWriteMultipleRegistersReq,
946 sizeof(exceededLengthWriteMultipleRegistersReq));
951 memset(&f, 0,
sizeof(
Flow));
959 f.
proto = IPPROTO_TCP;
974 "(msg:\"Modbus invalid Length\"; "
976 "modbus.invalid_length; "
987 ModbusState *modbus_state = f.
alstate;
1009 static int ModbusParserTest12(
void) {
1021 memset(&f, 0,
sizeof(
Flow));
1029 f.
proto = IPPROTO_TCP;
1044 "(msg:\"Modbus invalid Length\"; "
1046 "modbus.invalid_length; "
1055 invalidLengthPDUWriteMultipleRegistersReq,
1056 sizeof(invalidLengthPDUWriteMultipleRegistersReq));
1059 ModbusState *modbus_state = f.
alstate;
1081 static int ModbusParserTest13(
void) {
1088 memset(&f, 0,
sizeof(f));
1089 memset(&ssn, 0,
sizeof(ssn));
1093 f.
proto = IPPROTO_TCP;
1099 STREAM_TOSERVER, maskWriteRegisterReq,
1100 sizeof(maskWriteRegisterReq));
1103 ModbusState *modbus_state = f.
alstate;
1106 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 0);
1109 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 22);
1110 FAIL_IF_NOT(rs_modbus_message_get_and_mask(&request) == 0x00F2);
1111 FAIL_IF_NOT(rs_modbus_message_get_or_mask(&request) == 0x0025);
1114 STREAM_TOCLIENT, maskWriteRegisterRsp,
1115 sizeof(maskWriteRegisterRsp));
1118 FAIL_IF_NOT(rs_modbus_state_get_tx_count(modbus_state) == 1);
1127 static int ModbusParserTest14(
void) {
1134 memset(&f, 0,
sizeof(f));
1135 memset(&ssn, 0,
sizeof(ssn));
1139 f.
proto = IPPROTO_TCP;
1145 STREAM_TOSERVER, writeSingleRegisterReq,
1146 sizeof(writeSingleRegisterReq));
1149 ModbusState *modbus_state = f.
alstate;
1152 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 0);
1155 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 6);
1156 FAIL_IF_NOT(rs_modbus_message_get_write_address(&request) == 0x0001);
1157 FAIL_IF_NOT(rs_modbus_message_get_write_data(&request) == 0x0003);
1160 STREAM_TOCLIENT, writeSingleRegisterRsp,
1161 sizeof(writeSingleRegisterRsp));
1164 FAIL_IF_NOT(rs_modbus_state_get_tx_count(modbus_state) == 1);
1173 static int ModbusParserTest15(
void) {
1185 memset(&f, 0,
sizeof(f));
1186 memset(&ssn, 0,
sizeof(ssn));
1193 f.
proto = IPPROTO_TCP;
1208 "(msg:\"Modbus invalid Length\"; "
1210 "modbus.invalid_length; "
1218 STREAM_TOSERVER, invalidMaskWriteRegisterReq,
1219 sizeof(invalidMaskWriteRegisterReq));
1222 ModbusState *modbus_state = f.
alstate;
1225 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 0);
1228 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 22);
1236 STREAM_TOCLIENT, maskWriteRegisterRsp,
1237 sizeof(maskWriteRegisterRsp));
1240 FAIL_IF_NOT(rs_modbus_state_get_tx_count(modbus_state) == 1);
1241 ModbusMessage response = rs_modbus_state_get_tx_response(modbus_state, 0);
1244 FAIL_IF_NOT(rs_modbus_message_get_function(&response) == 22);
1260 static int ModbusParserTest16(
void) {
1272 memset(&f, 0,
sizeof(f));
1273 memset(&ssn, 0,
sizeof(ssn));
1280 f.
proto = IPPROTO_TCP;
1295 "(msg:\"Modbus invalid Length\"; "
1297 "modbus.invalid_length; "
1306 invalidWriteSingleRegisterReq,
1307 sizeof(invalidWriteSingleRegisterReq));
1310 ModbusState *modbus_state = f.
alstate;
1313 ModbusMessage request = rs_modbus_state_get_tx_request(modbus_state, 0);
1316 FAIL_IF_NOT(rs_modbus_message_get_function(&request) == 6);
1318 const uint8_t *data = rs_modbus_message_get_bytevec_data(&request, &data_len);
1329 STREAM_TOCLIENT, writeSingleRegisterRsp,
1330 sizeof(writeSingleRegisterRsp));
1333 FAIL_IF_NOT(rs_modbus_state_get_tx_count(modbus_state) == 1);
1334 ModbusMessage response = rs_modbus_state_get_tx_response(modbus_state, 0);
1337 FAIL_IF_NOT(rs_modbus_message_get_function(&response) == 6);
1338 FAIL_IF_NOT(rs_modbus_message_get_write_address(&response) == 0x0001);
1353 static int ModbusParserTest17(
void) {
1360 memset(&f, 0,
sizeof(f));
1361 memset(&ssn, 0,
sizeof(ssn));
1365 f.
proto = IPPROTO_TCP;
1371 readCoilsReq,
sizeof(readCoilsReq));
1379 readCoilsRsp,
sizeof(readCoilsRsp));
1391 static int ModbusParserTest18(
void) {
1396 uint32_t input_len =
sizeof(readCoilsReq), part2_len = 3;
1397 uint8_t *input = readCoilsReq;
1401 memset(&f, 0,
sizeof(f));
1402 memset(&ssn, 0,
sizeof(ssn));
1406 f.
proto = IPPROTO_TCP;
1412 input, input_len - part2_len);
1425 input_len =
sizeof(readCoilsRsp);
1427 input = readCoilsRsp;
1430 input, input_len - part2_len);
1448 static int ModbusParserTest19(
void) {
1460 memset(&f, 0,
sizeof(
Flow));
1468 f.
proto = IPPROTO_TCP;
1483 "(msg:\"Modbus invalid Function code\"; "
1485 "modbus.invalid_function_code; "
1494 invalidFunctionCode,
1495 sizeof(invalidFunctionCode));
1498 ModbusState *modbus_state = f.
alstate;
1523 ModbusParserTest01);
1524 UtRegisterTest(
"ModbusParserTest02 - Modbus Write Multiple registers request",
1525 ModbusParserTest02);
1526 UtRegisterTest(
"ModbusParserTest03 - Modbus Read/Write Multiple registers request",
1527 ModbusParserTest03);
1528 UtRegisterTest(
"ModbusParserTest04 - Modbus Force Listen Only Mode request",
1529 ModbusParserTest04);
1530 UtRegisterTest(
"ModbusParserTest05 - Modbus invalid Protocol version",
1531 ModbusParserTest05);
1532 UtRegisterTest(
"ModbusParserTest06 - Modbus unsolicited response",
1533 ModbusParserTest06);
1534 UtRegisterTest(
"ModbusParserTest07 - Modbus invalid Length request",
1535 ModbusParserTest07);
1536 UtRegisterTest(
"ModbusParserTest08 - Modbus Exception code invalid",
1537 ModbusParserTest08);
1538 UtRegisterTest(
"ModbusParserTest09 - Modbus fragmentation - 1 ADU in 2 TCP packets",
1539 ModbusParserTest09);
1540 UtRegisterTest(
"ModbusParserTest10 - Modbus fragmentation - 2 ADU in 1 TCP packet",
1541 ModbusParserTest10);
1542 UtRegisterTest(
"ModbusParserTest11 - Modbus exceeded Length request",
1543 ModbusParserTest11);
1545 ModbusParserTest12);
1546 UtRegisterTest(
"ModbusParserTest13 - Modbus Mask Write register request",
1547 ModbusParserTest13);
1548 UtRegisterTest(
"ModbusParserTest14 - Modbus Write single register request",
1549 ModbusParserTest14);
1550 UtRegisterTest(
"ModbusParserTest15 - Modbus invalid Mask Write register request",
1551 ModbusParserTest15);
1552 UtRegisterTest(
"ModbusParserTest16 - Modbus invalid Write single register request",
1553 ModbusParserTest16);
1555 ModbusParserTest17);
1556 UtRegisterTest(
"ModbusParserTest18 - Modbus stream depth in 2 TCP packets",
1557 ModbusParserTest18);
1558 UtRegisterTest(
"ModbusParserTest19 - Modbus invalid Function code",
1559 ModbusParserTest19);