| blob | be57ae1ca7b8e2207e360b297f2212a978283846 |
1 /* packet-knxip.c
2 * Routines for KNXnet/IP dissection
3 * By Jan Kessler <kessler@ise.de>
4 * Copyright 2004, Jan Kessler <kessler@ise.de>
5 *
6 * Wireshark - Network traffic analyzer
7 * By Gerald Combs <gerald@wireshark.org>
8 * Copyright 1998 Gerald Combs
9 *
10 * SPDX-License-Identifier: GPL-2.0-or-later
11 */
13 /*
14 * See
15 *
16 * https://my.knx.org/en/shop/knx-specifications
17 *
18 * for the specifications.
19 */
23 #include <stdlib.h>
24 #include <string.h>
26 #include <epan/packet.h>
27 #include <epan/expert.h>
28 #include <epan/proto.h>
29 #include <epan/ipproto.h>
30 #include <epan/prefs.h>
31 #include <epan/proto_data.h>
32 #include <epan/tvbuff.h>
33 #include <epan/strutil.h>
41 /* Other ports are commonly used, especially 3672 by KNX IP Gateways, but
42 * not registered.
43 */
45 #define ECDH_PUBLIC_VALUE_SIZE 32
47 #define KIP_HDR_LEN 6
49 /* The following service families are defined for the
50 version 1.0 KNXnet/IP implementation of the eFCP protocol
51 */
52 #define KIP_SERVICE_CORE 0x02
53 #define KIP_SERVICE_MANAGEMENT 0x03
54 #define KIP_SERVICE_TUNNELING 0x04
55 #define KIP_SERVICE_ROUTING 0x05
56 #define KIP_SERVICE_REMOTE_LOGGING 0x06
57 #define KIP_SERVICE_REMOTE_DIAG_AND_CONFIG 0x07
58 #define KIP_SERVICE_OBJECT_SERVER 0x08
59 #define KIP_SERVICE_SECURITY 0x09
61 /* The service codes for the core services (device discovery,
62 self description and connection management) as defined in
63 chapter 2 of the KNXnet/IP system specification
64 */
65 #define KIP_SEARCH_REQUEST 0x0201
66 #define KIP_SEARCH_RESPONSE 0x0202
67 #define KIP_DESCRIPTION_REQUEST 0x0203
68 #define KIP_DESCRIPTION_RESPONSE 0x0204
69 #define KIP_CONNECT_REQUEST 0x0205
70 #define KIP_CONNECT_RESPONSE 0x0206
71 #define KIP_CONNECTIONSTATE_REQUEST 0x0207
72 #define KIP_CONNECTIONSTATE_RESPONSE 0x0208
73 #define KIP_DISCONNECT_REQUEST 0x0209
74 #define KIP_DISCONNECT_RESPONSE 0x020A
75 #define KIP_SEARCH_REQUEST_EXT 0x020B
76 #define KIP_SEARCH_RESPONSE_EXT 0x020C
78 /* The service codes for the device management services
79 (tunneling of cEMI local management procedures) as
80 defined in chapter 3 of the KNXnet/IP system specification
81 */
82 #define KIP_CONFIGURATION_REQUEST 0x0310
83 #define KIP_CONFIGURATION_ACK 0x0311
85 /* The service codes for the tunneling services
86 (transport of cEMI frames from service interface) as
87 defined in chapter 4 of the KNXnet/IP system specification
88 */
89 #define KIP_TUNNELING_REQUEST 0x0420
90 #define KIP_TUNNELING_ACK 0x0421
91 #define KIP_TUNNELING_FEATURE_GET 0x0422
92 #define KIP_TUNNELING_FEATURE_RESPONSE 0x0423
93 #define KIP_TUNNELING_FEATURE_SET 0x0424
94 #define KIP_TUNNELING_FEATURE_INFO 0x0425
96 /* The service codes for the routing services
97 (transport of cEMI frames between EIB couplers) as
98 defined in chapter 5 of the KNXnet/IP system specification
99 */
100 #define KIP_ROUTING_INDICATION 0x0530
101 #define KIP_ROUTING_LOST_MESSAGE 0x0531
102 #define KIP_ROUTING_BUSY 0x0532
103 #define KIP_ROUTING_SYSTEM_BROADCAST 0x0533
105 /* The service codes for RemoteDiagAndConfig
106 */
107 #define KIP_REMOTE_DIAG_REQUEST 0x0740
108 #define KIP_REMOTE_DIAG_RESPONSE 0x0741
109 #define KIP_REMOTE_CONFIG_REQUEST 0x0742
110 #define KIP_REMOTE_RESET_REQUEST 0x0743
112 /* The service codes for KNX-IP Secure
113 */
114 #define KIP_SECURE_WRAPPER 0x0950
115 #define KIP_SESSION_REQUEST 0x0951
116 #define KIP_SESSION_RESPONSE 0x0952
117 #define KIP_SESSION_AUTHENTICATE 0x0953
118 #define KIP_SESSION_STATUS 0x0954
119 #define KIP_TIMER_NOTIFY 0x0955
121 /* KNXnet/IP host protocols */
122 #define KIP_IPV4_UDP 0x01
123 #define KIP_IPV4_TCP 0x02
125 /* The different types of DIBs (Description Information Blocks)
126 for the KNXnet/IP Core Discovery and Description services
127 as defined in chapter 1 of the KNXnet/IP system specification
128 */
129 #define KIP_DIB_DEVICE_INFO 0x01
130 #define KIP_DIB_SUPP_SVC_FAMILIES 0x02
131 #define KIP_DIB_IP_CONFIG 0x03
132 #define KIP_DIB_CUR_CONFIG 0x04
133 #define KIP_DIB_KNX_ADDRESSES 0x05
134 #define KIP_DIB_SECURED_SERVICE_FAMILIES 0x06
135 #define KIP_DIB_TUNNELING_INFO 0x07
136 #define KIP_DIB_EXTENDED_DEVICE_INFO 0x08
137 #define KIP_DIB_MFR_DATA 0xFE
139 /* The different types of SRPs (Search Request Parameter Blocks)
140 for the KNXnet/IP Core Discovery and Description services
141 */
142 #define KIP_SRP_BY_PROGMODE 0x01
143 #define KIP_SRP_BY_MACADDR 0x02
144 #define KIP_SRP_BY_SERVICE 0x03
145 #define KIP_SRP_REQUEST_DIBS 0x04
147 /* The different KNX medium types for the hardware (device info)
148 DIB as defined in AN033 Common EMI Specification
149 */
150 #define KIP_KNXTYPE_TP0 0x01
151 #define KIP_KNXTYPE_TP1 0x02
152 #define KIP_KNXTYPE_PL110 0x04
153 #define KIP_KNXTYPE_PL132 0x08
154 #define KIP_KNXTYPE_RF 0x10
155 #define KIP_KNXTYPE_IP 0x20
157 /* KNXnet/IP connection types */
158 #define KIP_DEVICE_MGMT_CONNECTION 0x03
159 #define KIP_TUNNEL_CONNECTION 0x04
160 #define KIP_REMLOG_CONNECTION 0x06
161 #define KIP_REMCONF_CONNECTION 0x07
162 #define KIP_OBJSVR_CONNECTION 0x08
164 /* Tunneling v2 feature ids */
165 #define KIP_TUNNELING_FEATURE_ID_SUPPORTED_EMI_TYPE 0x01
166 #define KIP_TUNNELING_FEATURE_ID_HOST_DEVICE_DEVICE_DESCRIPTOR_TYPE_0 0x02
167 #define KIP_TUNNELING_FEATURE_ID_BUS_CONNECTION_STATUS 0x03
168 #define KIP_TUNNELING_FEATURE_ID_KNX_MANUFACTURER_CODE 0x04
169 #define KIP_TUNNELING_FEATURE_ID_ACTIVE_EMI_TYPE 0x05
170 #define KIP_TUNNELING_FEATURE_ID_INDIVIDUAL_ADDRESS 0x06
171 #define KIP_TUNNELING_FEATURE_ID_MAX_APDU_LENGTH 0x07
172 #define KIP_TUNNELING_FEATURE_ID_INFO_SERVICE_ENABLE 0x08
174 /* KNXnet/IP tunnel types */
175 #define TUNNEL_LINKLAYER 0x02
176 #define TUNNEL_RAW 0x04
177 #define TUNNEL_BUSMONITOR 0x80
179 /* KNXnet/IP error codes */
180 #define KIP_E_NO_ERROR 0x00
181 #define KIP_E_CONNECTION_ID 0x21
182 #define KIP_E_CONNECTION_TYPE 0x22
183 #define KIP_E_CONNECTION_OPTION 0x23
184 #define KIP_E_NO_MORE_CONNECTIONS 0x24
185 #define KIP_E_NO_MORE_UNIQUE_CONNECTIONS 0x25
186 #define KIP_E_DATA_CONNECTION 0x26
187 #define KIP_E_KNX_CONNECTION 0x27
188 #define KIP_E_TUNNELING_LAYER 0x29
190 /* KNXnet/IP remote selection types */
191 #define SELECT_PROGMODE 0x01
192 #define SELECT_MACADDRESS 0x02
194 /* SESSION_STATUS codes */
195 #define SESSION_STATUS_AUTHENTICATION_SUCCESS 0x00
196 #define SESSION_STATUS_AUTHENTICATION_FAILED 0x01
197 #define SESSION_STATUS_UNAUTHENTICATED 0x02
198 #define SESSION_STATUS_TIMEOUT 0x03
199 #define SESSION_STATUS_KEEPALIVE 0x04
200 #define SESSION_STATUS_CLOSE 0x05
202 /* Initialize the protocol identifier that is needed for the
203 protocol hook and to register the fields in the protocol tree
204 */
207 /* Initialize the registered fields identifiers. These fields
208 will be registered with the protocol during initialization.
209 Protocol fields are like type definitions. The protocol dissector
210 later on adds items of these types to the protocol tree.
211 */
266 /* Initialize the subtree pointers. These pointers are needed to
267 display the protocol in a structured tree. Subtrees hook on
268 already defined fields or (the topmost) on the protocol itself
269 */
289 /* Set up the value_string tables for the service families
290 and the service types (note that the service types in KNXnet/IP
291 version 1.0 are unique even across service families...)
292 */
303 };
340 };
377 };
382 };
394 };
406 };
407 #if 0
414 };
415 #endif
422 };
431 };
439 };
447 };
458 };
464 };
476 };
485 };
490 expert_field ei_knxip_error;
491 expert_field ei_knxip_warning;
495 //static const char* authentication_code_text;
496 //static const char* password_hash_text;
501 /* KNX decryption keys
502 */
506 /* Forward declarations
507 */
508 static int dissect_knxip( tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, void* data _U_ );
512 /* Add raw data to list view, tree view, and parent folder
513 */
514 static proto_item* knxip_tree_add_data( proto_tree* tree, tvbuff_t* tvb, int offset, int length, column_info* cinfo, proto_item* item,
516 {
517 proto_item* new_item = proto_tree_add_bytes_format( tree, hf_bytes, tvb, offset, length, NULL, "%s: $", name );
522 {
527 offset++;
528 length--;
529 }
532 }
534 /* Show unknown or unexpected data
535 */
536 static proto_item* knxip_tree_add_unknown_data( proto_tree* tree, tvbuff_t* tvb, int offset, int length )
537 {
538 return proto_tree_add_bytes_format( tree, hf_bytes, tvb, offset, length, NULL, "? Unknown data (%d bytes)", length );
539 }
542 {
546 {
548 }
549 else
550 {
552 {
556 }
558 }
560 }
563 {
565 }
567 static proto_item* knxip_tree_add_reserved( proto_tree* tree, tvbuff_t* tvb, int offset, packet_info* pinfo, uint8_t* p_ok )
568 {
569 proto_item* new_item = proto_tree_add_item( tree, hf_knxip_reserved, tvb, offset, 1, ENC_BIG_ENDIAN );
571 {
575 }
577 }
579 static proto_item* knxip_tree_add_missing_reserved( proto_tree* tree, tvbuff_t* tvb, int offset, packet_info* pinfo )
580 {
581 proto_item* new_item = proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? Reserved: expected 1 byte" );
583 }
585 static proto_item* knxip_tree_add_length( proto_tree* tree, tvbuff_t* tvb, int offset, int value )
586 {
587 return proto_tree_add_uint_format_value( tree, hf_knxip_structure_length, tvb, offset, 1, value, "%u bytes", value );
588 }
590 static void knxip_item_illegal_length( proto_item* length_item, packet_info* pinfo, const char* info )
591 {
594 }
596 static proto_item* knxip_tree_add_ip_address( proto_tree* tree, tvbuff_t* tvb, int offset, char* output, int output_max )
597 {
599 {
602 }
604 }
606 static proto_item* knxip_tree_add_knx_address( proto_tree* tree, int hfindex, tvbuff_t* tvb, int offset, char* output, int output_max )
607 {
610 snprintf( text, sizeof text, "%u.%u.%u", (value >> 12) & 0xF, (value >> 8) & 0xF, value & 0xFF );
615 }
617 static proto_item* knxip_tree_add_bit( proto_tree* tree, tvbuff_t* tvb, int offset, int bitpos, const char* name, char* output, int output_max )
618 {
624 {
626 {
630 }
633 }
635 return proto_tree_add_bytes_format( tree, hf_bytes, tvb, offset, 1, NULL, format, name, value );
636 }
638 static proto_item* knxip_tree_add_ip_assignment( proto_tree* tree, int hfindex, tvbuff_t* tvb, int offset, uint8_t manual )
639 {
650 }
652 /* Dissect HPAI field
653 */
654 static uint8_t dissect_hpai( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset, uint8_t* p_ok, char* name, uint8_t check_protocol )
655 {
662 proto_item* hpai_item = proto_tree_add_none_format( tree, hf_folder, tvb, offset, eff_struct_len, "HPAI %s Endpoint", name );
670 {
674 }
675 else
676 {
677 /* 1 byte Structure Length */
683 offset++;
686 {
689 }
692 {
697 {
700 }
701 }
703 {
706 }
707 else
708 {
709 /* 1 byte Host Protocol */
714 node = proto_tree_add_item( hpai_tree, hf_knxip_host_protocol, tvb, offset, 1, ENC_BIG_ENDIAN );
717 {
720 {
722 {
724 }
725 }
726 }
728 {
731 {
733 {
735 }
736 }
737 }
738 else
739 {
741 }
744 {
746 expert_add_info_format( pinfo, node, KIP_ERROR, (protocol_error == 1) ? "Wrong Host Protocol" : "Expected: 0x01 or 0x02" );
748 }
750 offset++;
753 {
756 }
757 else
758 {
759 /* 4 bytes IP Address */
763 {
767 }
776 {
779 }
780 else
781 {
782 /* 2 bytes Port Number */
791 {
795 }
798 }
799 }
802 {
805 }
808 }
809 }
815 {
818 }
822 }
824 /* Dissect CRI (= Connection Request Information)
825 */
826 static uint8_t dissect_cri( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset, uint8_t* p_ok )
827 {
833 proto_item* cri_item = proto_tree_add_none_format( tree, hf_folder, tvb, offset, eff_struct_len, "CRI" );
842 {
845 //ok = 0;
846 }
847 else
848 {
855 {
858 //ok = 0;
860 }
863 {
865 //ok = 0;
866 }
867 else
868 {
870 type_item = proto_tree_add_item( cri_tree, hf_knxip_connection_type, tvb, offset + 1, 1, ENC_BIG_ENDIAN );
873 {
876 //ok = 0;
879 {
881 }
882 }
883 else
884 {
889 {
895 {
901 }
906 {
910 }
912 {
915 proto_item* layer_item = proto_tree_add_item( cri_tree, hf_knxip_knx_layer, tvb, offset + 2, 1, ENC_BIG_ENDIAN );
918 {
922 }
925 {
928 }
929 else
930 {
932 }
934 {
935 knxip_tree_add_knx_address( cri_tree, hf_knxip_knx_address, tvb, offset + 4, extra_text, sizeof extra_text );
936 }
938 {
941 }
942 }
944 }
945 }
946 }
949 {
951 }
952 }
956 {
958 }
959 else
960 {
962 {
966 {
968 }
969 }
973 {
975 }
976 }
979 {
982 }
986 }
988 /* Dissect CRD (= Connection Response Data)
989 */
990 static uint8_t dissect_crd( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset, uint8_t* p_ok )
991 {
997 proto_item* crd_item = proto_tree_add_none_format( tree, hf_folder, tvb, offset, eff_struct_len, "CRD" );
1004 {
1007 //ok = 0;
1008 }
1009 else
1010 {
1017 {
1020 //ok = 0;
1022 }
1025 {
1027 //ok = 0;
1028 }
1029 else
1030 {
1032 type_item = proto_tree_add_item( crd_tree, hf_knxip_connection_type, tvb, offset + 1, 1, ENC_BIG_ENDIAN );
1035 {
1038 //ok = 0;
1041 {
1043 }
1044 }
1045 else
1046 {
1051 {
1057 {
1062 }
1067 {
1071 }
1074 {
1076 //ok = 0;
1078 {
1080 }
1081 }
1082 else
1083 {
1085 knxip_tree_add_knx_address( crd_tree, hf_knxip_knx_address, tvb, offset + 2, output, sizeof output );
1088 {
1090 }
1092 {
1094 }
1096 {
1098 //ok = 0;
1099 }
1100 }
1102 }
1103 }
1104 }
1107 {
1109 }
1110 }
1113 if( pinfo && conn_type_name ) col_prepend_fstr( pinfo->cinfo, COL_INFO, "%s ", conn_type_name );
1117 {
1120 }
1124 }
1126 /* Dissect Connection Header
1127 */
1128 static uint8_t dissect_cnhdr( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset, uint8_t* p_ok, uint8_t response )
1129 {
1135 proto_item* cnhdr_item = proto_tree_add_none_format( tree, hf_folder, tvb, offset, eff_struct_len, "Connection Header" );
1143 output_max--;
1147 {
1150 }
1151 else
1152 {
1157 offset++;
1160 {
1162 }
1163 else
1164 {
1166 }
1169 {
1174 {
1177 }
1178 }
1181 {
1183 //ok = 0;
1184 }
1185 else
1186 {
1192 offset++;
1195 {
1197 //ok = 0;
1198 }
1199 else
1200 {
1205 offset++;
1208 {
1210 {
1212 output_max--;
1214 }
1215 }
1218 {
1219 expert_add_info_format( pinfo, cnhdr_item, KIP_ERROR, "Missing 1 byte %s", response ? "Status" : "Reserved" );
1220 //ok = 0;
1221 }
1222 else
1223 {
1225 {
1226 snprintf( output, output_max, "%s", val_to_str( tvb_get_uint8( tvb, offset ), error_vals, "Error 0x%02x" ) );
1228 }
1229 else
1230 {
1232 }
1234 offset++;
1235 }
1236 }
1239 {
1241 //ok = 0;
1242 }
1245 }
1246 }
1252 {
1255 }
1259 }
1261 /* Dissect tunneling feature frames.
1262 */
1263 static void dissect_tunneling_feature( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset, uint8_t* p_ok, uint16_t service )
1264 {
1275 /* Connection Header */
1280 /* 1 byte Feature Identifier */
1282 {
1283 proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? Feature Identifier: expected 1 byte" );
1285 }
1286 else
1287 {
1298 }
1300 /* 1 byte Return Code / Reserved */
1303 {
1304 proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? %s: expected 1 byte", name );
1306 }
1307 else
1308 {
1310 proto_tree_add_item( tree, isResponse ? hf_knxip_status : hf_knxip_reserved, tvb, offset, 1, ENC_BIG_ENDIAN );
1313 {
1316 }
1320 }
1322 /* Feature Value */
1324 {
1326 {
1327 proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? Feature Value: missing" );
1329 }
1330 }
1331 else
1332 {
1333 node = knxip_tree_add_data( tree, tvb, offset, remaining_len, cinfo, item, "Feature Value", " $", " $" );
1335 {
1338 }
1340 }
1345 }
1347 /* Dissect cEMI
1348 */
1350 {
1354 /* Call the cEMI data dissector for the remaining bytes
1355 */
1360 {
1362 }
1366 }
1368 /* Dissect ROUTING_LOSS
1369 */
1370 static uint8_t dissect_routing_loss( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset )
1371 {
1378 proto_item* info_item = proto_tree_add_none_format( tree, hf_folder, tvb, offset, struct_len, "Loss Info" );
1384 {
1387 }
1388 else
1389 {
1394 offset++;
1397 {
1399 }
1400 else
1401 {
1403 }
1406 {
1410 }
1413 {
1415 }
1418 {
1420 offset++;
1422 /* 2 bytes Lost Messages */
1424 {
1429 }
1432 {
1434 }
1437 }
1438 }
1444 {
1446 }
1450 }
1452 /* Dissect ROUTING_BUSY
1453 */
1454 static uint8_t dissect_routing_busy( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset )
1455 {
1462 proto_item* info_item = proto_tree_add_none_format( tree, hf_folder, tvb, offset, eff_struct_len, "Busy Info" );
1468 {
1471 }
1472 else
1473 {
1478 offset++;
1481 {
1483 }
1484 else
1485 {
1487 }
1490 {
1494 }
1497 {
1499 }
1502 {
1504 offset++;
1507 {
1508 /* 2 bytes Wait Time (ms) */
1509 proto_item* new_item = proto_tree_add_item( info_tree, hf_knxip_busy_time, tvb, offset, 2, ENC_BIG_ENDIAN );
1515 {
1516 /* 2 bytes Control */
1519 }
1520 }
1523 {
1525 }
1528 }
1529 }
1535 {
1537 }
1541 }
1543 /* Dissect SELECTOR field
1544 */
1545 static uint8_t dissect_selector( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset, uint8_t* p_ok )
1546 {
1553 proto_item* info_item = proto_tree_add_none_format( tree, hf_folder, tvb, offset, eff_struct_len, "Selector" );
1559 {
1562 //ok = 0;
1563 }
1564 else
1565 {
1571 offset++;
1574 {
1576 //ok = 0;
1579 }
1582 {
1584 //ok = 0;
1586 }
1587 else
1588 {
1589 /* 1 byte Selection Type */
1591 proto_item* type_item = proto_tree_add_item( info_tree, hf_knxip_selector, tvb, offset, 1, ENC_BIG_ENDIAN );
1592 proto_item_append_text( type_item, " = %s", (sel == SELECT_PROGMODE) ? "ProgMode" : (sel == SELECT_MACADDRESS) ? "MAC" : "Unknown" );
1593 offset++;
1597 {
1601 {
1605 }
1606 }
1608 {
1616 {
1620 }
1623 {
1624 /* 6 bytes MAC Address */
1627 snprintf( output, output_max, "%02x:%02x:%02x:%02x:%02x:%02x", mac[ 0 ], mac[ 1 ], mac[ 2 ], mac[ 3 ], mac[ 4 ], mac[ 5 ] );
1630 }
1631 }
1632 else
1633 {
1637 }
1640 {
1643 }
1646 }
1649 {
1651 }
1652 }
1658 {
1661 }
1666 }
1668 /* Dissect DevInfo DIB
1669 */
1673 {
1680 {
1683 }
1686 {
1687 /* 1 byte KNX Medium */
1689 proto_item* item = proto_tree_add_item( dib_tree, hf_knxip_knx_medium, tvb, offset, 1, ENC_BIG_ENDIAN );
1698 /* Check for missing or multiple medium */
1699 {
1703 {
1705 {
1706 media++;
1707 }
1709 }
1712 {
1714 }
1715 }
1717 offset++;
1720 {
1721 /* 1 byte Device Status */
1723 item = proto_tree_add_item( dib_tree, hf_knxip_device_status, tvb, offset, 1, ENC_BIG_ENDIAN );
1728 {
1731 }
1733 offset++;
1736 {
1737 /* 2 bytes KNX Address */
1745 {
1746 /* 2 bytes Project Installation Identifier */
1757 {
1758 /* 6 bytes KNX Serial Number */
1761 }
1764 {
1765 /* 4 bytes Routing Multicast Address */
1770 {
1771 /* 6 bytes MAC Address */
1776 {
1777 /* 30 bytes Friendly Name - ISO 8859-1 */
1780 proto_tree_add_item_ret_display_string( dib_tree, hf_knxip_friendly_name, tvb, offset, 30, ENC_ISO_8859_1 | ENC_NA, pinfo->pool, &friendly_name );
1785 }
1786 }
1787 }
1788 }
1789 }
1790 }
1791 }
1794 {
1796 }
1798 {
1800 }
1802 {
1804 }
1809 }
1811 /* Dissect SuppSvc DIB
1812 */
1816 {
1824 {
1827 }
1830 {
1834 proto_item* item = proto_tree_add_none_format( dib_tree, hf_folder, tvb, offset, 2, "KNXnet/IP %s v%u",
1838 /* 1 byte Service Family ID */
1841 /* 1 byte Service Family Version */
1845 {
1848 }
1851 {
1853 }
1856 }
1859 {
1861 }
1863 {
1865 }
1869 }
1871 /* Dissect IpConfig DIB
1872 */
1876 {
1882 {
1885 }
1888 {
1890 }
1891 else
1892 {
1893 /* 4 bytes IP Address */
1898 {
1899 /* 4 bytes Subnet Mask */
1904 {
1905 /* 4 bytes Default Gateway */
1910 {
1911 /* 1 byte IP Capabilities */
1913 offset++;
1916 {
1917 /* 1 byte IP Assignment Method */
1919 offset++;
1920 }
1921 }
1922 }
1923 }
1924 }
1930 }
1932 /* Dissect CurConfig DIB
1933 */
1937 {
1943 {
1946 }
1949 {
1951 }
1952 else
1953 {
1954 /* 4 bytes IP Address */
1959 {
1960 /* 4 bytes Subnet Mask */
1965 {
1966 /* 4 bytes Default Gateway */
1971 {
1972 /* 4 bytes DHCP Server */
1977 {
1978 /* IP Assignment Method */
1980 offset++;
1983 {
1984 /* Reserved Byte */
1986 offset++;
1987 }
1988 }
1989 }
1990 }
1991 }
1992 }
1998 }
2000 /* Dissect KnxAddr DIB
2001 */
2005 {
2012 {
2016 }
2017 else
2018 {
2022 {
2025 }
2027 /* 2 bytes KNX Address */
2028 knxip_tree_add_knx_address( dib_tree, hf_knxip_knx_address, tvb, offset, text1, sizeof text1 );
2033 {
2034 /* 2 bytes Additional KNX Address */
2035 knxip_tree_add_knx_address( dib_tree, hf_knxip_knx_address, tvb, offset, text2, sizeof text2 );
2038 }
2039 }
2043 }
2045 /* Dissect SecuredServices DIB
2046 */
2050 {
2057 {
2060 }
2063 {
2067 proto_item* item = proto_tree_add_none_format( dib_tree, hf_folder, tvb, offset, 2, "KNXnet/IP %s v%u",
2071 /* 1 byte Service Family ID */
2074 /* 1 byte Security Version */
2078 {
2081 }
2084 }
2088 }
2090 /* Dissect TunnelingInfo DIB
2091 */
2095 {
2100 {
2102 {
2105 }
2106 }
2107 else
2108 {
2112 /* 2 bytes Max APDU Length */
2117 {
2119 {
2122 }
2123 }
2126 {
2136 /* 2 bytes KNX Address, 1 byte reserved */
2141 /* 1 byte flags */
2145 offset++;
2148 {
2151 }
2152 }
2153 }
2157 }
2159 /* Dissect ExtDevInfo DIB
2160 */
2164 {
2170 {
2173 }
2176 {
2177 /* 1 byte Medium Status */
2181 {
2183 }
2185 offset++;
2188 {
2189 /* 1 byte reserved */
2191 offset++;
2194 {
2195 /* 2 bytes Max APDU Length */
2200 {
2201 /* 2 bytes Mask Version */
2204 }
2205 }
2206 }
2207 }
2211 }
2213 /* Dissect MfrData DIB
2214 */
2218 {
2224 {
2228 }
2229 else
2230 {
2234 }
2240 }
2242 /* Dissect DIB
2243 */
2244 static uint8_t dissect_dib( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree,
2246 {
2251 {
2259 proto_item* dib_item = proto_tree_add_none_format( tree, hf_folder, tvb, offset, eff_struct_len, "DIB" );
2263 offset++;
2266 {
2272 }
2275 {
2278 }
2279 else
2280 {
2281 proto_item* type_item = proto_tree_add_item( dib_tree, hf_knxip_description_type, tvb, offset, 1, ENC_BIG_ENDIAN );
2285 offset++;
2288 {
2291 }
2292 else
2293 {
2295 }
2298 {
2300 }
2303 {
2305 ok &= dissect_dib_devinfo( tvb, pinfo, dib_item, dib_tree, length_item, length_ok, &offset, struct_len, output );
2309 ok &= dissect_dib_suppsvc( tvb, pinfo, dib_item, dib_tree, length_item, length_ok, &offset, struct_len );
2313 ok &= dissect_dib_ipconfig( tvb, pinfo, dib_item, dib_tree, length_item, length_ok, &offset, struct_len );
2317 ok &= dissect_dib_curconfig( tvb, pinfo, dib_item, dib_tree, length_item, length_ok, &offset, struct_len );
2321 ok &= dissect_dib_knxaddr( tvb, pinfo, dib_item, dib_tree, length_item, length_ok, &offset, struct_len );
2325 ok &= dissect_dib_secured_service_families( tvb, pinfo, dib_item, dib_tree, length_item, length_ok, &offset, struct_len );
2329 ok &= dissect_dib_tunneling_info( tvb, pinfo, dib_item, dib_tree, length_item, length_ok, &offset, struct_len );
2333 ok &= dissect_dib_extdevinfo( tvb, pinfo, dib_item, dib_tree, length_item, length_ok, &offset, struct_len );
2337 ok &= dissect_dib_mfrdata( tvb, pinfo, dib_item, dib_tree, length_item, length_ok, &offset, struct_len );
2343 }
2346 {
2349 }
2350 }
2353 {
2355 {
2360 {
2362 }
2363 else
2364 {
2367 }
2368 }
2371 {
2375 {
2377 }
2378 else
2379 {
2382 }
2383 }
2384 }
2387 {
2390 }
2393 }
2396 }
2398 /* Dissect sequence of DIBs
2399 */
2400 static char dissect_dibs( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset, wmem_strbuf_t* output, char separator, uint8_t* p_count, uint8_t* p_ok )
2401 {
2403 {
2405 }
2408 }
2410 /* Dissect SRP
2411 */
2412 static uint8_t dissect_srp( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset, uint8_t* p_ok )
2413 {
2418 {
2422 proto_item* srp_item = proto_tree_add_none_format( tree, hf_folder, tvb, offset, eff_struct_len, "SRP" );
2428 offset++;
2431 {
2435 }
2438 {
2441 }
2442 else
2443 {
2444 /* 1 bit Mandatory */
2447 /* 7 bits SRP Type */
2450 proto_item* type_item = proto_tree_add_item( srp_tree, hf_knxip_srp_type, tvb, offset, 1, ENC_BIG_ENDIAN );
2454 {
2457 }
2463 {
2466 }
2469 {
2479 }
2482 {
2484 {
2488 }
2489 }
2490 offset++;
2493 {
2494 knxip_tree_add_data( srp_tree, tvb, offset, end_pos - offset, srp_name ? cinfo : NULL, item, "Data", "=$", " = $" );
2498 {
2501 }
2503 //offset = end_pos;
2504 }
2505 }
2508 {
2511 }
2514 {
2516 }
2519 }
2522 }
2524 /* Dissect sequence of SRPs
2525 */
2526 static void dissect_srps( tvbuff_t *tvb, packet_info *pinfo, proto_item *item, proto_tree *tree, int *p_offset, uint8_t* p_ok )
2527 {
2529 }
2531 /* Dissect RESET command
2532 */
2533 static uint8_t dissect_resetter( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset )
2534 {
2545 {
2546 proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? Command, Reserved: expected 2 bytes" );
2547 }
2548 else
2549 {
2550 /* 1 byte Reset Command */
2555 {
2557 }
2558 else
2559 {
2561 }
2564 {
2565 proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? Reserved: expected 1 byte" );
2567 }
2568 else
2569 {
2570 /* 1 byte Reserved */
2572 }
2573 }
2580 }
2582 /* Decrypt SECURE_WRAPPER. Returns decrypted part if MAC matches
2583 */
2584 static uint8_t* decrypt_secure_wrapper( const uint8_t* key, const uint8_t* data, int h_length, int p_length )
2585 {
2589 {
2591 }
2594 {
2599 {
2600 /* Calculate MAC */
2606 /* Check MAC */
2608 {
2611 }
2612 }
2615 }
2618 }
2621 {
2625 {
2627 }
2628 else
2629 {
2631 {
2633 }
2634 else
2635 {
2637 }
2640 {
2643 }
2644 }
2645 }
2647 /* Dissect SECURE_WRAPPER
2648 */
2649 // NOLINTNEXTLINE(misc-no-recursion)
2650 static uint8_t dissect_secure_wrapper( uint8_t header_length, tvbuff_t* tvb, packet_info* pinfo, proto_tree* root, proto_item* item, proto_tree* tree, int* p_offset )
2651 {
2656 const uint8_t* dest_addr = (pinfo->dst.type == AT_IPv4) ? (const uint8_t*) pinfo->dst.data : NULL;
2659 /* 2 bytes Session ID */
2661 {
2665 }
2666 else
2667 {
2672 {
2675 }
2680 /* 6 bytes Sequence Nr */
2682 {
2683 node = proto_tree_add_bytes_format( tree, hf_bytes, tvb, offset, size, NULL, "? Sequence Number" );
2686 }
2687 else
2688 {
2689 knxip_tree_add_data( tree, tvb, offset, 6, cinfo, item, "Sequence Number", " $", ", Seq Nr: $" );
2693 /* 6 bytes Serial Nr */
2695 {
2696 node = proto_tree_add_bytes_format( tree, hf_bytes, tvb, offset, size, NULL, "? Serial Number" );
2699 }
2700 else
2701 {
2706 /* 2 bytes Tag */
2708 {
2712 }
2713 else
2714 {
2722 /* Encrypted part */
2724 {
2728 }
2729 else
2730 {
2740 node = proto_tree_add_bytes_format( tree, hf_bytes, tvb, offset, size, encrypted, "Encrypted (%d bytes)", size );
2745 {
2746 // Try keys associateD with IP MCA in keyring.XML
2748 {
2750 {
2754 {
2757 }
2758 }
2759 }
2760 }
2763 {
2764 // Try explicitly specified keys
2766 {
2770 {
2773 }
2774 }
2775 }
2778 {
2779 const char* text = knx_decryption_key_count ? " (decryption failed)" : knx_keyring_mca_keys ? " (no key found)" : " (no key available)";
2781 }
2782 else
2783 {
2787 //tvb_set_free_cb( tvb2, wmem_free );
2794 {
2796 }
2798 /* Embedded KIP packet */
2799 knxip_tree_add_data( tree, tvb2, 0, size2, NULL, NULL, "Embedded KNXnet/IP packet", NULL, NULL );
2801 /* MAC */
2802 knxip_tree_add_data( tree, tvb2, size2, 16, NULL, NULL, "Message Authentication Code", NULL, NULL );
2804 /* Dissect embedded KIP packet */
2805 {
2810 }
2811 }
2812 }
2813 }
2814 }
2815 }
2816 }
2820 }
2822 /* Check encrypted MAC in TIMER_NOTIFY
2823 */
2824 static uint8_t check_timer_sync_mac( const uint8_t* key, const uint8_t* data, int header_length )
2825 {
2826 // Calculate and encrypt MAC
2832 // Check MAC
2834 }
2836 /* Dissect TIMER_NOTIFY
2837 */
2838 static uint8_t dissect_timer_notify( uint8_t header_length, tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset )
2839 {
2844 const uint8_t* dest_addr = (pinfo->dst.type == AT_IPv4) ? (const uint8_t*) pinfo->dst.data : NULL;
2847 /* 6 bytes Timestamp */
2849 {
2853 }
2854 else
2855 {
2860 /* 6 bytes Serial Nr */
2862 {
2863 node = proto_tree_add_bytes_format( tree, hf_bytes, tvb, offset, size, NULL, "? Serial Number" );
2866 }
2867 else
2868 {
2873 /* 2 bytes Tag */
2875 {
2879 }
2880 else
2881 {
2889 /* 16 bytes MAC */
2891 {
2892 node = proto_tree_add_bytes_format( tree, hf_bytes, tvb, offset, size, NULL, "? Message Authentication Code" );
2895 }
2896 else
2897 {
2907 knxip_tree_add_data( tree, tvb, offset, 16, NULL, NULL, "Message Authentication Code", NULL, NULL );
2912 {
2913 // Try keys associated with IP MCA in keyring.XML
2915 {
2917 {
2920 {
2924 }
2925 }
2926 }
2927 }
2930 {
2931 // Try explicitly specified keys
2933 {
2936 {
2940 }
2941 }
2942 }
2945 {
2951 {
2953 }
2955 /* TODO: mac_error is never being set... */
2957 {
2961 }
2962 }
2966 }
2967 }
2968 }
2969 }
2973 }
2975 /* Dissect SESSION_REQUEST
2976 */
2977 static uint8_t dissect_session_request( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset )
2978 {
2982 /* Control Endpoint HPAI */
2984 {
2988 /* DH Client Public Value */
2990 {
2991 proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? DH Client Public Value: missing" );
2993 }
2994 else
2995 {
2996 node = knxip_tree_add_data( tree, tvb, offset, size, NULL, NULL, "DH Client Public Value", NULL, NULL );
2998 #if ECDH_PUBLIC_VALUE_SIZE > 0
3000 {
3002 expert_add_info_format( pinfo, node, KIP_ERROR, "Expected: %u bytes", ECDH_PUBLIC_VALUE_SIZE );
3004 }
3005 #endif
3008 }
3009 }
3013 }
3015 /* Dissect SESSION_RESPONSE
3016 */
3017 static uint8_t dissect_session_response( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset )
3018 {
3025 /* 2 bytes Session ID */
3027 {
3032 }
3033 else
3034 {
3042 /* DH Server Public Value */
3043 {
3046 {
3048 }
3050 node = knxip_tree_add_data( tree, tvb, offset, size2, NULL, NULL, "DH Server Public Value", NULL, NULL );
3053 {
3055 expert_add_info_format( pinfo, node, KIP_ERROR, "Expected: %u bytes", ECDH_PUBLIC_VALUE_SIZE );
3057 }
3061 }
3063 /* 16 bytes MAC */
3065 {
3066 node = proto_tree_add_bytes_format( tree, hf_bytes, tvb, offset, size, NULL, "? Message Authentication Code" );
3070 }
3071 else
3072 {
3073 knxip_tree_add_data( tree, tvb, offset, 16, NULL, NULL, "Message Authentication Code", NULL, NULL );
3075 }
3076 }
3080 }
3082 /* Dissect SESSION_AUTHENTICATE
3083 */
3084 static uint8_t dissect_session_auth( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset )
3085 {
3092 /* 1 byte Reserved */
3094 {
3095 proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? Reserved: expected 1 byte" );
3097 }
3098 else
3099 {
3104 /* 1 byte User ID */
3106 {
3107 proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? User: expected 1 byte" );
3109 }
3110 else
3111 {
3119 /* 16 bytes MAC */
3121 {
3122 node = proto_tree_add_bytes_format( tree, hf_bytes, tvb, offset, size, NULL, "? Message Authentication Code" );
3126 }
3127 else
3128 {
3129 knxip_tree_add_data( tree, tvb, offset, 16, NULL, NULL, "Message Authentication Code", NULL, NULL );
3131 }
3132 }
3133 }
3137 }
3139 /* Dissect SESSION_STATUS
3140 */
3141 static uint8_t dissect_session_status( tvbuff_t* tvb, packet_info* pinfo, proto_item* item, proto_tree* tree, int* p_offset )
3142 {
3148 /* 1 byte Status */
3150 {
3151 proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? Status: expected 1 byte" );
3153 }
3154 else
3155 {
3163 /* 1 byte Reserved */
3165 {
3166 proto_tree_add_expert_format( tree, pinfo, KIP_ERROR, tvb, offset, 0, "? Reserved: expected 1 byte" );
3168 }
3169 else
3170 {
3174 }
3175 }
3179 }
3181 /* Dissect KNX-IP data after KNX-IP header
3182 */
3183 // NOLINTNEXTLINE(misc-no-recursion)
3184 static void dissect_knxip_data( uint8_t header_length, uint8_t protocol_version _U_, uint16_t service, tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, proto_item* kip_item, proto_tree* kip_tree )
3185 {
3195 /* Make sure that we cope with a well known service family
3196 */
3198 {
3202 }
3203 else
3204 {
3205 /* Make sure that we cope with a well known service type
3206 */
3208 {
3212 }
3213 else
3214 {
3218 /* Dissect according to Service Type
3219 */
3221 {
3223 /* CORE */
3226 {
3227 /* Discovery Endpoint HPAI */
3229 }
3233 {
3234 /* Discovery Endpoint HPAI */
3236 {
3237 /* Search Request Parameters */
3239 }
3240 }
3245 {
3246 /* Control Endpoint HPAI */
3248 {
3249 /* DIBs */
3258 {
3261 }
3264 {
3266 {
3269 }
3271 {
3274 }
3275 }
3276 }
3277 }
3281 {
3282 /* Control Endpoint HPAI */
3284 }
3288 {
3289 /* DIBs */
3293 {
3296 }
3298 {
3301 }
3302 }
3306 {
3307 /* Control Endpoint HPAI */
3309 {
3310 /* Data Endpoint HPAI */
3312 {
3313 /* CRI */
3315 }
3316 }
3317 }
3321 {
3322 /* 1 byte Channel ID */
3324 {
3329 }
3330 else
3331 {
3334 offset++;
3336 /* 1 byte Status */
3338 {
3343 }
3344 else
3345 {
3348 offset++;
3351 {
3355 /* Data Endpoint HPAI */
3357 {
3358 /* CRD */
3360 }
3361 }
3362 else
3363 {
3367 }
3368 }
3369 }
3370 }
3374 {
3375 /* 1 byte Channel ID */
3380 {
3385 }
3386 else
3387 {
3392 offset++;
3394 /* Reserved Byte */
3396 {
3399 }
3400 else
3401 {
3403 offset++;
3405 /* Control Endpoint HPAI */
3407 }
3408 }
3409 }
3413 {
3414 /* 1 byte Channel ID */
3419 {
3424 }
3425 else
3426 {
3431 offset++;
3433 /* 1 byte Status */
3435 {
3440 }
3441 else
3442 {
3448 offset++;
3449 }
3450 }
3451 }
3455 {
3456 /* 1 byte Channel ID */
3461 {
3466 }
3467 else
3468 {
3473 offset++;
3475 /* Reserved Byte */
3477 {
3480 }
3481 else
3482 {
3484 offset++;
3486 /* Control Endpoint HPAI */
3488 }
3489 }
3490 }
3494 {
3495 /* 1 byte Channel ID */
3500 {
3505 }
3506 else
3507 {
3512 offset++;
3514 /* 1 byte Status */
3516 {
3521 }
3522 else
3523 {
3529 offset++;
3530 }
3531 }
3532 }
3535 /* MANAGEMENT */
3538 {
3539 /* Connection Header */
3541 {
3542 /* cEMI */
3544 }
3545 }
3549 {
3550 /* Connection Header */
3552 }
3555 /* TUNNELING */
3558 {
3559 /* Connection Header */
3561 {
3562 /* cEMI */
3564 }
3565 }
3569 {
3570 /* Connection Header */
3572 }
3579 {
3580 /* Connection Header, 1 byte Feature ID, 1 byte Return Code, Feature Value */
3582 }
3585 /* ROUTING */
3588 {
3589 /* cEMI */
3591 }
3595 {
3596 /* Routing Loss */
3598 }
3602 {
3603 /* Routing Busy */
3605 }
3609 {
3610 /* cEMI */
3612 }
3615 /* REMOTE_DIAG_AND_CONFIG */
3618 {
3619 /* Discovery Endpoint HPAI */
3621 {
3622 /* Selector */
3624 }
3625 }
3629 {
3630 /* Selector */
3632 {
3633 /* DIBs */
3637 {
3640 }
3642 {
3645 }
3647 {
3650 }
3651 }
3652 }
3656 {
3657 /* Discovery Endpoint HPAI */
3659 {
3660 /* Selector */
3662 {
3663 /* DIBs */
3667 {
3669 }
3670 }
3671 }
3672 }
3676 {
3677 /* Selector */
3679 {
3680 /* Reset Mode */
3682 }
3683 }
3709 }
3710 }
3711 }
3714 {
3717 {
3719 {
3720 proto_item* unknown_item = knxip_tree_add_unknown_data( kip_tree, tvb, offset, remaining_len );
3722 }
3725 }
3726 }
3729 {
3730 /* If not already done */
3732 {
3735 }
3738 }
3739 }
3741 static unsigned
3743 {
3745 }
3747 // NOLINTNEXTLINE(misc-no-recursion)
3748 static int dissect_knxip( tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, void* data _U_ )
3749 {
3774 {
3778 }
3779 else
3780 {
3782 }
3785 kip_item = proto_tree_add_item( tree, proto_knxip, tvb, offset, (remaining_len <= 0) ? 0 : -1, ENC_BIG_ENDIAN );
3789 {
3790 /* This may happen if we are embedded in another KNXnet/IP frame (level != 0)
3791 */
3796 /* If not already done */
3798 {
3801 }
3802 }
3803 else
3804 {
3805 /* 1 byte Header Length */
3809 {
3815 }
3818 {
3820 expert_add_info_format( pinfo, header_len_item, KIP_ERROR, "Available: %u bytes", remaining_len );
3823 }
3825 {
3829 }
3831 offset++;
3834 {
3835 /* 1 byte Protocol Version */
3837 snprintf( version_info, sizeof version_info, "%u.%u", hi_nibble( protocol_version ), lo_nibble( protocol_version ) );
3840 {
3843 }
3846 {
3850 }
3852 offset++;
3855 {
3856 /* 2 bytes Service ID */
3860 {
3865 else
3867 service_item = proto_tree_add_item( header_tree, hf_knxip_service_id, tvb, 2, 2, ENC_BIG_ENDIAN );
3871 }
3876 {
3877 /* 2 bytes Total Length */
3881 {
3884 }
3887 {
3891 }
3893 {
3895 expert_add_info_format( pinfo, total_length_item, KIP_ERROR, "Available: %u bytes", remaining_len );
3897 }
3899 {
3901 expert_add_info_format( pinfo, total_length_item, KIP_ERROR, "Available: %u bytes", remaining_len );
3903 }
3906 }
3907 }
3908 }
3911 {
3913 }
3916 {
3920 {
3922 }
3923 else
3924 {
3925 /* If not already done */
3927 {
3930 }
3931 }
3932 }
3934 dissect_knxip_data( header_len, protocol_version, service_id, tvb, pinfo, tree, kip_item, kip_tree );
3935 }
3937 }
3939 static int dissect_tcp_knxip( tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, void* udata )
3940 {
3942 tcp_dissect_pdus(tvb, pinfo, tree, pref_desegment, KIP_HDR_LEN, get_knxip_pdu_len, dissect_knxip, udata);
3945 }
3947 static int dissect_udp_knxip( tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, void* udata )
3948 {
3950 udp_dissect_pdus( tvb, pinfo, tree, KIP_HDR_LEN, NULL, get_knxip_pdu_len, dissect_knxip, udata );
3952 }
3955 {
3956 /* Header fields */
3958 {
3961 { &hf_knxip_header_length, { "Header Length", "knxip.headerlength", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
3962 { &hf_knxip_protocol_version, { "Protocol Version", "knxip.version", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
3963 { &hf_knxip_service_id, { "Service Identifier", "knxip.service", FT_UINT16, BASE_HEX, VALS( knxip_service_type_vals ), 0, NULL, HFILL } },
3964 { &hf_knxip_service_family, { "Service Family", "knxip.service.family", FT_UINT8, BASE_HEX, VALS( knxip_service_family_vals ), 0, NULL, HFILL } },
3965 { &hf_knxip_service_type, { "Service Type", "knxip.service.type", FT_UINT16, BASE_HEX, VALS( knxip_service_type_vals ), 0, NULL, HFILL } },
3966 { &hf_knxip_total_length, { "Total Length", "knxip.totallength", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } },
3967 { &hf_knxip_structure_length, { "Structure Length", "knxip.struct.length", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
3968 { &hf_knxip_host_protocol, { "Host Protocol", "knxip.hostprotocol", FT_UINT8, BASE_HEX, VALS( host_protocol_vals ), 0, NULL, HFILL } },
3969 { &hf_knxip_ip_address, { "IP Address", "knxip.ipaddr", FT_IPv4, BASE_NONE, NULL, 0, NULL, HFILL } },
3970 { &hf_knxip_port, { "Port Number", "knxip.port", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } },
3971 { &hf_knxip_description_type, { "Description Type", "knxip.dibtype", FT_UINT8, BASE_HEX, VALS( description_type_vals ), 0, NULL, HFILL } },
3972 { &hf_knxip_knx_medium, { "KNX Medium", "knxip.medium", FT_UINT8, BASE_HEX, VALS( medium_type_vals ), 0, NULL, HFILL } },
3973 { &hf_knxip_device_status, { "Device Status", "knxip.device.status", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
3974 { &hf_knxip_program_mode, { "Programming Mode", "knxip.progmode", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
3975 { &hf_knxip_knx_address, { "KNX Individual Address", "knxip.knxaddr", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } },
3976 { &hf_knxip_project_id, { "Project Installation Identifier", "knxip.project", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } },
3977 { &hf_knxip_project_number, { "Project Number", "knxip.project.nr", FT_UINT16, BASE_DEC, NULL, 0xFFF0, NULL, HFILL } },
3978 { &hf_knxip_installation_number, { "Installation Number", "knxip.project.installation", FT_UINT16, BASE_DEC, NULL, 0x000F, NULL, HFILL } },
3979 { &hf_knxip_serial_number, { "KNX Serial Number", "knxip.sernr", FT_UINT48, BASE_HEX, NULL, 0, NULL, HFILL } },
3980 { &hf_knxip_multicast_address, { "Multicast Address", "knxip.mcaddr", FT_IPv4, BASE_NONE, NULL, 0, NULL, HFILL } },
3981 { &hf_knxip_mac_address, { "MAC Address", "knxip.macaddr", FT_ETHER, BASE_NONE, NULL, 0, NULL, HFILL } },
3982 { &hf_knxip_friendly_name, { "Friendly Name", "knxip.device.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL } },
3983 { &hf_knxip_service_version, { "Service Version", "knxip.service.version", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
3984 { &hf_knxip_security_version, { "Security Version", "knxip.security.version", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
3985 { &hf_knxip_manufacturer_code, { "KNX Manufacturer Code", "knxip.manufacturer", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } },
3986 { &hf_knxip_connection_type, { "Connection Type", "knxip.conn.type", FT_UINT8, BASE_HEX, VALS( connection_type_vals ), 0, NULL, HFILL } },
3987 { &hf_knxip_knx_layer, { "KNX Layer", "knxip.tunnel.layer", FT_UINT8, BASE_HEX, VALS( knx_layer_vals ), 0, NULL, HFILL } },
3988 { &hf_knxip_channel, { "Channel", "knxip.channel", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
3989 { &hf_knxip_status, { "Status", "knxip.status", FT_UINT8, BASE_HEX, VALS( error_vals ), 0, NULL, HFILL } },
3990 { &hf_knxip_reserved, { "Reserved", "knxip.reserved", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
3991 { &hf_knxip_seq_counter, { "Sequence Counter", "knxip.seqctr", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
3992 { &hf_knxip_ip_subnet, { "Subnet Mask", "knxip.subnet", FT_IPv4, BASE_NONE, NULL, 0, NULL, HFILL } },
3993 { &hf_knxip_ip_gateway, { "Default Gateway", "knxip.gateway", FT_IPv4, BASE_NONE, NULL, 0, NULL, HFILL } },
3994 { &hf_knxip_ip_assign, { "IP Assignment", "knxip.ipassign", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
3995 { &hf_knxip_ip_caps, { "IP Capabilities", "knxip.ipcaps", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
3996 { &hf_knxip_ip_dhcp, { "DHCP Server", "knxip.dhcp", FT_IPv4, BASE_NONE, NULL, 0, NULL, HFILL } },
3997 { &hf_knxip_tunnel_feature, { "Tunneling Feature Identifier", "knxip.tunnel.feature", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
3998 { &hf_knxip_routing_loss, { "Lost Messages", "knxip.loss", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } },
3999 { &hf_knxip_busy_time, { "Wait Time", "knxip.busy.time", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } },
4000 { &hf_knxip_busy_control, { "Control", "knxip.busy.control", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } },
4001 { &hf_knxip_selector, { "Selector", "knxip.selector", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
4002 { &hf_knxip_max_apdu_length, { "Max APDU Length", "knxip.maxapdulength", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } },
4003 { &hf_knxip_medium_status, { "Medium Status", "knxip.medium.status", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
4004 { &hf_knxip_mask_version, { "Mask Version", "knxip.mask.version", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } },
4005 { &hf_knxip_srp_mandatory, { "Mandatory", "knxip.srp.mandatory", FT_UINT8, BASE_DEC, NULL, 0x80, NULL, HFILL } },
4006 { &hf_knxip_srp_type, { "SRP Type", "knxip.srp.type", FT_UINT8, BASE_HEX, NULL, 0x7F, NULL, HFILL } },
4007 { &hf_knxip_reset_command, { "Command", "knxip.reset.command", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
4008 { &hf_knxip_session, { "Session", "knxip.session", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } },
4011 { &hf_knxip_session_status, { "Status", "knxip.session.status", FT_UINT8, BASE_HEX, VALS( session_status_vals ), 0, NULL, HFILL } },
4012 };
4014 /* Subtrees */
4016 {
4035 };
4038 {
4041 };
4055 //register_dissector_table( "knxip.version", "KNXnet/IP Protocol Version", proto_knxip, FT_UINT8, BASE_HEX );
4062 prefs_register_filename_preference( knxip_module, "key_file", "Key file", "Keyring.XML file (exported from ETS)",
4064 prefs_register_string_preference( knxip_module, "key_file_pwd", "Key file password", "Keyring password",
4066 prefs_register_filename_preference( knxip_module, "key_info_file", "Key info output file", "Output file (- for stdout) for keys extracted from key file",
4073 NULL );
4075 "(KNX/IP multicast/group keys, KNX/IP unicast session keys, KNX data-security tool keys and link-table keys)",
4076 NULL );
4079 NULL );
4082 {
4086 "KNX decryption key (format: 16 bytes as hex; example: A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF)",
4088 }
4090 prefs_register_bool_preference(knxip_module, "desegment", "Reassemble KNX/IP messages spanning multiple TCP segments.", "Whether the KNX/IP dissector should reassemble messages spanning multiple TCP segments. To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.", &pref_desegment);
4091 }
4094 {
4095 dissector_handle_t knxip_handle;
4105 /* Evaluate preferences
4106 */
4108 {
4109 /* Read Keyring.XML file (containing decryption keys, exported from ETS) */
4111 }
4114 for( x = 0; x < MAX_KNX_DECRYPTION_KEYS && knx_decryption_key_count < MAX_KNX_DECRYPTION_KEYS; ++x )
4115 {
4118 {
4120 {
4122 }
4123 }
4124 }
4125 }
4127 /*
4128 * Editor modelines - https://www.wireshark.org/tools/modelines.html
4129 *
4130 * Local variables:
4131 * c-basic-offset: 2
4132 * tab-width: 8
4133 * indent-tabs-mode: nil
4134 * End:
4135 *
4136 * vi: set shiftwidth=2 tabstop=8 expandtab:
4137 * :indentSize=2:tabSize=8:noTabs=true:
4138 */