/* packet-vnc.c * Routines for VNC dissection (Virtual Network Computing) * Copyright 2005, Ulf Lamping * Copyright 2006-2007, Stephen Fisher (see AUTHORS file) * * Wireshark - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs * * SPDX-License-Identifier: GPL-2.0-or-later */ /* Dissection of the VNC (Virtual Network Computing) network traffic. * * All versions of RealVNC and TightVNC are supported. * Note: The addition of TightVNC support is not yet complete. * * Several VNC implementations available, see: * http://www.realvnc.com/ * http://www.tightvnc.com/ * http://ultravnc.sourceforge.net/ * [Fedora TigerVNC] * ... * * The protocol itself is known as RFB - Remote Frame Buffer Protocol. * * This code is based on the protocol specification published in RFC 6143 * and the RealVNC free edition & TightVNC source code * Note: rfbproto.rst [ https://github.com/svn2github/tigervnc/blob/master/rfbproto/rfbproto.rst ] * seems to have additional information over rfbproto.pdf. */ /* XXX: * This dissector adds items to the protocol tree before completing re-assembly * of a VNC PDU which extends over more than one TCP segment. * This is not correct. As noted in Bug #5366 (and elsewhere), the correct method * is that: * "one must walk over all the message first, to determine its exact length * (one of the characteristics of the protocol, hard to determine prior to * going over the message what its final size would be)". * * The original method of reassembly: * When more data is needed to continue dissecting a PDU, repeatedly request * a few additional bytes (for one or a few more fields of the PDU). * This resulted in 'one-pass' tshark dissection redissecting * the PDU repeatedly many, many times with each time dissecting * the PDU with one or a few more additional fields. * This generated *lots* of (repeated) output since a reassembled * VNC PDU can contain many fields (each of short length). * It also resulted in the fragment table containing many, many small fragments * for VNC PDUS containing many small fields. * * The current reassembly method: * Use DESEGMENT_ONE_MORE_SEGMENT when requesting additional data for a PDU. * This significantly reduces the amount of repeated data in a dissection, * but will still result in "partial" repeated dissection output in some cases. */ /* (Somewhat random notes while reviewing the code): Check types, etc against IANA list Optimize: Do col_set(..., COL_INFO) once (after fetching message type & before dispatching ?) Dispatch via a message table (instead of using a switch(...) Msg type 150: client-server: enable/disable (1+9 bytes); server-client: endofContinousUpdates(1+0 bytes) ? */ #include "config.h" #include #include #include #include #include #include "packet-x11.h" /* This contains the extern for the X11 value_string_ext * "x11_keysym_vals_source_ext" that VNC uses. */ void proto_register_vnc(void); typedef enum { VNC_SECURITY_TYPE_INVALID = 0, VNC_SECURITY_TYPE_NONE = 1, VNC_SECURITY_TYPE_VNC = 2, VNC_SECURITY_TYPE_RA2 = 5, VNC_SECURITY_TYPE_RA2ne = 6, VNC_SECURITY_TYPE_TIGHT = 16, VNC_SECURITY_TYPE_ULTRA = 17, VNC_SECURITY_TYPE_TLS = 18, VNC_SECURITY_TYPE_VENCRYPT = 19, VNC_SECURITY_TYPE_GTK_VNC_SASL = 20, VNC_SECURITY_TYPE_MD5_HASH_AUTH = 21, VNC_SECURITY_TYPE_XVP = 22, VNC_SECURITY_TYPE_ARD = 30, VNC_TIGHT_AUTH_TGHT_ULGNAUTH = 119, VNC_TIGHT_AUTH_TGHT_XTRNAUTH = 130, VNC_VENCRYPT_AUTH_PLAIN = 256, VNC_VENCRYPT_AUTH_TLSNONE = 257, VNC_VENCRYPT_AUTH_TLSVNC = 258, VNC_VENCRYPT_AUTH_TLSPLAIN = 259, VNC_VENCRYPT_AUTH_X509_NONE = 260, VNC_VENCRYPT_AUTH_X509_VNC = 261, VNC_VENCRYPT_AUTH_X509_PLAIN = 262, VNC_VENCRYPT_AUTH_TLSSASL = 263, VNC_VENCRYPT_AUTH_X509_SASL = 264 } vnc_security_types_e; static const value_string vnc_security_types_vs[] = { { VNC_SECURITY_TYPE_INVALID, "Invalid" }, { VNC_SECURITY_TYPE_NONE, "None" }, { VNC_SECURITY_TYPE_VNC, "VNC" }, { VNC_SECURITY_TYPE_RA2, "RA2" }, { VNC_SECURITY_TYPE_RA2ne, "RA2ne" }, { VNC_SECURITY_TYPE_TIGHT, "Tight" }, { VNC_SECURITY_TYPE_ULTRA, "Ultra" }, { VNC_SECURITY_TYPE_TLS, "TLS" }, { VNC_SECURITY_TYPE_VENCRYPT, "VeNCrypt" }, { VNC_SECURITY_TYPE_GTK_VNC_SASL, "GTK-VNC SASL" }, { VNC_SECURITY_TYPE_ARD, "Apple Remote Desktop" }, { 0, NULL } }; static const value_string vnc_vencrypt_auth_types_vs[] = { { VNC_SECURITY_TYPE_NONE, "None" }, { VNC_SECURITY_TYPE_VNC, "VNC" }, { VNC_VENCRYPT_AUTH_PLAIN, "Plain" }, { VNC_VENCRYPT_AUTH_TLSNONE, "TLS None" }, { VNC_VENCRYPT_AUTH_TLSVNC, "TLS VNC" }, { VNC_VENCRYPT_AUTH_TLSPLAIN, "TLS Plain" }, { VNC_VENCRYPT_AUTH_X509_NONE, "X.509 None" }, { VNC_VENCRYPT_AUTH_X509_VNC, "X.509 VNC" }, { VNC_VENCRYPT_AUTH_X509_PLAIN, "X.509 Plain" }, { VNC_VENCRYPT_AUTH_TLSSASL, "TLS SASL" }, { VNC_VENCRYPT_AUTH_X509_SASL, "X.509 SASL" }, { 0, NULL } }; static const true_false_string auth_result_tfs = { "Failed", "OK" }; typedef enum { /* Required */ VNC_CLIENT_MESSAGE_TYPE_SET_PIXEL_FORMAT = 0, VNC_CLIENT_MESSAGE_TYPE_SET_ENCODINGS = 2, VNC_CLIENT_MESSAGE_TYPE_FRAMEBUF_UPDATE_REQ = 3, VNC_CLIENT_MESSAGE_TYPE_KEY_EVENT = 4, VNC_CLIENT_MESSAGE_TYPE_POINTER_EVENT = 5, VNC_CLIENT_MESSAGE_TYPE_CLIENT_CUT_TEXT = 6, /* Optional */ VNC_CLIENT_MESSAGE_TYPE_MIRRORLINK = 128, VNC_CLIENT_MESSAGE_TYPE_ENABLE_CONTINUOUS_UPDATES = 150, /* TightVNC */ VNC_CLIENT_MESSAGE_TYPE_FENCE = 248, /* TigerVNC */ VNC_CLIENT_MESSAGE_TYPE_XVP = 250, VNC_CLIENT_MESSAGE_TYPE_SETR_DESKTOP_SIZE = 251, VNC_CLIENT_MESSAGE_TYPE_TIGHT = 252, VNC_CLIENT_MESSAGE_TYPE_GII = 253, VNC_CLIENT_MESSAGE_TYPE_QEMU = 255 } vnc_client_message_types_e; static const value_string vnc_client_message_types_vs[] = { /* Required */ { VNC_CLIENT_MESSAGE_TYPE_SET_PIXEL_FORMAT, "Set Pixel Format" }, { VNC_CLIENT_MESSAGE_TYPE_SET_ENCODINGS, "Set Encodings" }, { VNC_CLIENT_MESSAGE_TYPE_FRAMEBUF_UPDATE_REQ, "Framebuffer Update Request" }, { VNC_CLIENT_MESSAGE_TYPE_KEY_EVENT, "Key Event" }, { VNC_CLIENT_MESSAGE_TYPE_POINTER_EVENT, "Pointer Event" }, { VNC_CLIENT_MESSAGE_TYPE_CLIENT_CUT_TEXT, "Cut Text" }, /* Optional */ { VNC_CLIENT_MESSAGE_TYPE_MIRRORLINK, "MirrorLink" }, { VNC_CLIENT_MESSAGE_TYPE_ENABLE_CONTINUOUS_UPDATES, "Enable Continuous Updates" }, { VNC_CLIENT_MESSAGE_TYPE_FENCE, "Fence" }, { VNC_CLIENT_MESSAGE_TYPE_XVP, "Xvp" }, { VNC_CLIENT_MESSAGE_TYPE_SETR_DESKTOP_SIZE, "Setr Desktop Size" }, { VNC_CLIENT_MESSAGE_TYPE_TIGHT, "Tight" }, { VNC_CLIENT_MESSAGE_TYPE_GII, "Gii" }, { VNC_CLIENT_MESSAGE_TYPE_QEMU, "Qemu" }, { 0, NULL } }; typedef enum { VNC_SERVER_MESSAGE_TYPE_FRAMEBUFFER_UPDATE = 0, VNC_SERVER_MESSAGE_TYPE_SET_COLORMAP_ENTRIES = 1, VNC_SERVER_MESSAGE_TYPE_RING_BELL = 2, VNC_SERVER_MESSAGE_TYPE_CUT_TEXT = 3, VNC_SERVER_MESSAGE_TYPE_MIRRORLINK = 128, VNC_SERVER_MESSAGE_TYPE_END_CONTINUOUS_UPDATES = 150, /* TightVNC */ VNC_SERVER_MESSAGE_TYPE_FENCE = 248, /* TigerVNC */ VNC_SERVER_MESSAGE_TYPE_XVP = 250, VNC_SERVER_MESSAGE_TYPE_TIGHT = 252, VNC_SERVER_MESSAGE_TYPE_GII = 253, VNC_SERVER_MESSAGE_TYPE_QEMU = 255 } vnc_server_message_types_e; static const value_string vnc_server_message_types_vs[] = { { VNC_SERVER_MESSAGE_TYPE_FRAMEBUFFER_UPDATE, "Framebuffer Update" }, { VNC_SERVER_MESSAGE_TYPE_SET_COLORMAP_ENTRIES, "Set Colormap Entries" }, { VNC_SERVER_MESSAGE_TYPE_RING_BELL, "Ring Bell" }, { VNC_SERVER_MESSAGE_TYPE_CUT_TEXT, "Cut Text" }, { VNC_SERVER_MESSAGE_TYPE_MIRRORLINK, "MirrorLink" }, { VNC_SERVER_MESSAGE_TYPE_END_CONTINUOUS_UPDATES, "End Continuous Updates" }, { VNC_SERVER_MESSAGE_TYPE_FENCE, "Fence" }, { VNC_SERVER_MESSAGE_TYPE_XVP, "Xvp" }, { VNC_SERVER_MESSAGE_TYPE_TIGHT, "Tight" }, { VNC_SERVER_MESSAGE_TYPE_GII, "Gii" }, { VNC_SERVER_MESSAGE_TYPE_QEMU, "Qemu" }, { 0, NULL } }; #define VNC_ENCODING_TYPE_DESKTOP_SIZE 0xFFFFFF21 #define VNC_ENCODING_TYPE_LAST_RECT 0xFFFFFF20 #define VNC_ENCODING_TYPE_POINTER_POS 0xFFFFFF18 #define VNC_ENCODING_TYPE_RICH_CURSOR 0xFFFFFF11 #define VNC_ENCODING_TYPE_X_CURSOR 0xFFFFFF10 #define VNC_ENCODING_TYPE_RAW 0 #define VNC_ENCODING_TYPE_COPY_RECT 1 #define VNC_ENCODING_TYPE_RRE 2 #define VNC_ENCODING_TYPE_CORRE 4 #define VNC_ENCODING_TYPE_HEXTILE 5 #define VNC_ENCODING_TYPE_ZLIB 6 #define VNC_ENCODING_TYPE_TIGHT 7 #define VNC_ENCODING_TYPE_ZLIBHEX 8 #define VNC_ENCODING_TYPE_ULTRA 9 #define VNC_ENCODING_TYPE_TRLE 15 #define VNC_ENCODING_TYPE_RLE 16 #define VNC_ENCODING_TYPE_HITACHI_ZYWRLE 17 #define VNC_ENCODING_TYPE_JPEG_0 -32 #define VNC_ENCODING_TYPE_JPEG_1 -31 #define VNC_ENCODING_TYPE_JPEG_2 -30 #define VNC_ENCODING_TYPE_JPEG_3 -29 #define VNC_ENCODING_TYPE_JPEG_4 -28 #define VNC_ENCODING_TYPE_JPEG_5 -27 #define VNC_ENCODING_TYPE_JPEG_6 -26 #define VNC_ENCODING_TYPE_JPEG_7 -25 #define VNC_ENCODING_TYPE_JPEG_8 -24 #define VNC_ENCODING_TYPE_JPEG_9 -23 #define VNC_ENCODING_TYPE_COMPRESSION_0 0xFFFFFF00 #define VNC_ENCODING_TYPE_COMPRESSION_1 0xFFFFFF01 #define VNC_ENCODING_TYPE_COMPRESSION_2 0xFFFFFF02 #define VNC_ENCODING_TYPE_COMPRESSION_3 0xFFFFFF03 #define VNC_ENCODING_TYPE_COMPRESSION_4 0xFFFFFF04 #define VNC_ENCODING_TYPE_COMPRESSION_5 0xFFFFFF05 #define VNC_ENCODING_TYPE_COMPRESSION_6 0xFFFFFF06 #define VNC_ENCODING_TYPE_COMPRESSION_7 0xFFFFFF07 #define VNC_ENCODING_TYPE_COMPRESSION_8 0xFFFFFF08 #define VNC_ENCODING_TYPE_COMPRESSION_9 0xFFFFFF09 #define VNC_ENCODING_TYPE_WMVi 0x574D5669 #define VNC_ENCODING_TYPE_CACHE 0xFFFF0000 #define VNC_ENCODING_TYPE_CACHE_ENABLE 0xFFFF0001 #define VNC_ENCODING_TYPE_XOR_ZLIB 0xFFFF0002 #define VNC_ENCODING_TYPE_XOR_MONO_ZLIB 0xFFFF0003 #define VNC_ENCODING_TYPE_XOR_MULTI_ZLIB 0xFFFF0004 #define VNC_ENCODING_TYPE_SOLID_COLOR 0xFFFF0005 #define VNC_ENCODING_TYPE_XOR_ENABLE 0xFFFF0006 #define VNC_ENCODING_TYPE_CACHE_ZIP 0xFFFF0007 #define VNC_ENCODING_TYPE_SOL_MONO_ZIP 0xFFFF0008 #define VNC_ENCODING_TYPE_ULTRA_ZIP 0xFFFF0009 #define VNC_ENCODING_TYPE_SERVER_STATE 0xFFFF8000 #define VNC_ENCODING_TYPE_ENABLE_KEEP_ALIVE 0xFFFF8001 #define VNC_ENCODING_TYPE_FTP_PROTO_VER 0xFFFF8002 #define VNC_ENCODING_TYPE_POINTER_CHANGE -257 #define VNC_ENCODING_TYPE_EXT_KEY_EVENT -258 #define VNC_ENCODING_TYPE_AUDIO 259 #define VNC_ENCODING_TYPE_DESKTOP_NAME -307 #define VNC_ENCODING_TYPE_EXTENDED_DESK_SIZE -308 #define VNC_ENCODING_TYPE_KEYBOARD_LED_STATE 0XFFFE0000 #define VNC_ENCODING_TYPE_SUPPORTED_MESSAGES 0XFFFE0001 #define VNC_ENCODING_TYPE_SUPPORTED_ENCODINGS 0XFFFE0002 #define VNC_ENCODING_TYPE_SERVER_IDENTITY 0XFFFE0003 #define VNC_ENCODING_TYPE_MIRRORLINK 0xFFFFFDF5 #define VNC_ENCODING_TYPE_CONTEXT_INFORMATION 0xFFFFFDF4 #define VNC_ENCODING_TYPE_SLRLE 0xFFFFFDF3 #define VNC_ENCODING_TYPE_TRANSFORM 0xFFFFFDF2 #define VNC_ENCODING_TYPE_HSML 0xFFFFFDF1 #define VNC_ENCODING_TYPE_H264 0X48323634 static const value_string encoding_types_vs[] = { { VNC_ENCODING_TYPE_DESKTOP_SIZE, "DesktopSize (pseudo)" }, { VNC_ENCODING_TYPE_LAST_RECT, "LastRect (pseudo)" }, { VNC_ENCODING_TYPE_POINTER_POS, "Pointer pos (pseudo)" }, { VNC_ENCODING_TYPE_RICH_CURSOR, "Rich Cursor (pseudo)" }, { VNC_ENCODING_TYPE_X_CURSOR, "X Cursor (pseudo)" }, { VNC_ENCODING_TYPE_RAW, "Raw" }, { VNC_ENCODING_TYPE_COPY_RECT, "CopyRect" }, { VNC_ENCODING_TYPE_RRE, "RRE" }, { VNC_ENCODING_TYPE_CORRE, "CoRRE" }, { VNC_ENCODING_TYPE_HEXTILE, "Hextile" }, { VNC_ENCODING_TYPE_ZLIB, "Zlib" }, { VNC_ENCODING_TYPE_TIGHT, "Tight" }, { VNC_ENCODING_TYPE_ZLIBHEX, "ZlibHex" }, { VNC_ENCODING_TYPE_ULTRA, "Ultra" }, { VNC_ENCODING_TYPE_RLE, "ZRLE" }, { VNC_ENCODING_TYPE_HITACHI_ZYWRLE, "Hitachi ZYWRLE" }, { VNC_ENCODING_TYPE_JPEG_0, "JPEG quality level 0" }, { VNC_ENCODING_TYPE_JPEG_1, "JPEG quality level 1" }, { VNC_ENCODING_TYPE_JPEG_2, "JPEG quality level 2" }, { VNC_ENCODING_TYPE_JPEG_3, "JPEG quality level 3" }, { VNC_ENCODING_TYPE_JPEG_4, "JPEG quality level 4" }, { VNC_ENCODING_TYPE_JPEG_5, "JPEG quality level 5" }, { VNC_ENCODING_TYPE_JPEG_6, "JPEG quality level 6" }, { VNC_ENCODING_TYPE_JPEG_7, "JPEG quality level 7" }, { VNC_ENCODING_TYPE_JPEG_8, "JPEG quality level 8" }, { VNC_ENCODING_TYPE_JPEG_9, "JPEG quality level 9" }, { VNC_ENCODING_TYPE_COMPRESSION_0, "Compression level 0" }, { VNC_ENCODING_TYPE_COMPRESSION_1, "Compression level 1" }, { VNC_ENCODING_TYPE_COMPRESSION_2, "Compression level 2" }, { VNC_ENCODING_TYPE_COMPRESSION_3, "Compression level 3" }, { VNC_ENCODING_TYPE_COMPRESSION_4, "Compression level 4" }, { VNC_ENCODING_TYPE_COMPRESSION_5, "Compression level 5" }, { VNC_ENCODING_TYPE_COMPRESSION_6, "Compression level 6" }, { VNC_ENCODING_TYPE_COMPRESSION_7, "Compression level 7" }, { VNC_ENCODING_TYPE_COMPRESSION_8, "Compression level 8" }, { VNC_ENCODING_TYPE_COMPRESSION_9, "Compression level 9" }, /* FIXME understand for real what the below mean. Taken from Ultra VNC source code */ /* { VNC_ENCODING_TYPE_CACHE, */ { VNC_ENCODING_TYPE_CACHE_ENABLE, "Enable Caching"}, /* { VNC_ENCODING_TYPE_XOR_ZLIB, { VNC_ENCODING_TYPE_XOR_MONO_ZLIB, { VNC_ENCODING_TYPE_XOR_MULTI_ZLIB, { VNC_ENCODING_TYPE_SOLID_COLOR, { VNC_ENCODING_TYPE_XOR_ENABLE, { VNC_ENCODING_TYPE_CACHE_ZIP, { VNC_ENCODING_TYPE_SOL_MONO_ZIP, { VNC_ENCODING_TYPE_ULTRA_ZIP, */ { VNC_ENCODING_TYPE_SERVER_STATE, "Server State" }, { VNC_ENCODING_TYPE_ENABLE_KEEP_ALIVE, "Enable Keep Alive" }, { VNC_ENCODING_TYPE_FTP_PROTO_VER, "FTP protocol version" }, { VNC_ENCODING_TYPE_EXTENDED_DESK_SIZE, "Extended Desktop Size"}, { VNC_ENCODING_TYPE_DESKTOP_NAME, "Desktop Name" }, { VNC_ENCODING_TYPE_KEYBOARD_LED_STATE, "Keyboard LED State" }, { VNC_ENCODING_TYPE_SUPPORTED_MESSAGES, "Supported Messages" }, { VNC_ENCODING_TYPE_SUPPORTED_ENCODINGS, "Supported Encodings" }, { VNC_ENCODING_TYPE_SERVER_IDENTITY, "Server Identity" }, { VNC_ENCODING_TYPE_MIRRORLINK, "MirrorLink" }, { VNC_ENCODING_TYPE_CONTEXT_INFORMATION, "Context Information" }, { VNC_ENCODING_TYPE_SLRLE, "SLRLE" }, { VNC_ENCODING_TYPE_TRANSFORM, "Transform" }, { VNC_ENCODING_TYPE_HSML, "HSML" }, { VNC_ENCODING_TYPE_H264, "H264" }, { 0, NULL } }; /* Rectangle types for Tight encoding. These come in the "control byte" at the * start of a rectangle's payload. Note that these are with respect to the most * significant bits 4-7 of the control byte, so you must shift it to the right 4 * bits before comparing against these values. */ #define TIGHT_RECT_FILL 0x08 #define TIGHT_RECT_JPEG 0x09 #define TIGHT_RECT_MAX_VALUE 0x09 #define TIGHT_RECT_EXPLICIT_FILTER_FLAG 0x04 /* Filter types for Basic encoding of Tight rectangles */ #define TIGHT_RECT_FILTER_COPY 0x00 #define TIGHT_RECT_FILTER_PALETTE 0x01 #define TIGHT_RECT_FILTER_GRADIENT 0x02 /* Minimum number of bytes to compress for Tight encoding */ #define TIGHT_MIN_BYTES_TO_COMPRESS 12 static const value_string tight_filter_ids_vs[] = { { TIGHT_RECT_FILTER_COPY, "Copy" }, { TIGHT_RECT_FILTER_PALETTE, "Palette" }, { TIGHT_RECT_FILTER_GRADIENT, "Gradient" }, { 0, NULL } }; /* MirrorLink messages */ typedef enum { VNC_ML_EXT_BYE_BYE = 0, VNC_ML_EXT_SERVER_DISPLAY_CONFIGURATION = 1, VNC_ML_EXT_CLIENT_DISPLAY_CONFIGURATION = 2, VNC_ML_EXT_SERVER_EVENT_CONFIGURATION = 3, VNC_ML_EXT_CLIENT_EVENT_CONFIGURATION = 4, VNC_ML_EXT_EVENT_MAPPING = 5, VNC_ML_EXT_EVENT_MAPPING_REQUEST = 6, VNC_ML_EXT_KEY_EVENT_LISTING = 7, VNC_ML_EXT_KEY_EVENT_LISTING_REQUEST = 8, VNC_ML_EXT_VIRTUAL_KEYBOARD = 9, VNC_ML_EXT_VIRTUAL_KEYBOARD_REQUEST = 10, VNC_ML_EXT_DEVICE_STATUS = 11, VNC_ML_EXT_DEVICE_STATUS_REQUEST = 12, VNC_ML_EXT_CONTENT_ATTESTATION = 13, VNC_ML_EXT_CONTENT_ATTESTATION_REQUEST = 14, VNC_ML_EXT_FB_BLOCKING_NOTIFICATION = 16, VNC_ML_EXT_AUDIO_BLOCKING_NOTIFICATION = 18, VNC_ML_EXT_TOUCH_EVENT = 20, VNC_ML_EXT_FB_ALTERNATIVE_TEXT = 21, VNC_ML_EXT_FB_ALTERNATIVE_TEXT_REQUEST = 22 } vnc_mirrorlink_ext_types_e; static const value_string vnc_mirrorlink_types_vs[] = { { VNC_ML_EXT_BYE_BYE, "ByeBye" }, { VNC_ML_EXT_SERVER_DISPLAY_CONFIGURATION, "Server Display Configuration" }, { VNC_ML_EXT_CLIENT_DISPLAY_CONFIGURATION, "Client Display Configuration" }, { VNC_ML_EXT_SERVER_EVENT_CONFIGURATION, "Server Event Configuration" }, { VNC_ML_EXT_CLIENT_EVENT_CONFIGURATION, "Client Event Configuration" }, { VNC_ML_EXT_EVENT_MAPPING, "Event Mapping" }, { VNC_ML_EXT_EVENT_MAPPING_REQUEST, "Event Mapping Request" }, { VNC_ML_EXT_KEY_EVENT_LISTING, "Key Event Listing" }, { VNC_ML_EXT_KEY_EVENT_LISTING_REQUEST, "Key Event Listing Request" }, { VNC_ML_EXT_VIRTUAL_KEYBOARD, "Virtual Keyboard Trigger" }, { VNC_ML_EXT_VIRTUAL_KEYBOARD_REQUEST, "Virtual Keyboard Trigger Request" }, { VNC_ML_EXT_DEVICE_STATUS, "Device Status" }, { VNC_ML_EXT_DEVICE_STATUS_REQUEST, "Device Status Request" }, { VNC_ML_EXT_CONTENT_ATTESTATION, "Content Attestation" }, { VNC_ML_EXT_CONTENT_ATTESTATION_REQUEST, "Content Attestation Request" }, { VNC_ML_EXT_FB_BLOCKING_NOTIFICATION, "Framebuffer Blocking Notification" }, { VNC_ML_EXT_AUDIO_BLOCKING_NOTIFICATION, "Audio Blocking Notification" }, { VNC_ML_EXT_TOUCH_EVENT, "Touch Event" }, { VNC_ML_EXT_FB_ALTERNATIVE_TEXT, "Framebuffer Alternative Text" }, { VNC_ML_EXT_FB_ALTERNATIVE_TEXT_REQUEST, "Framebuffer Alternative Text Request" }, { 0, NULL } }; /* Slice types for H.264 encoding */ typedef enum { VNC_H264_SLICE_TYPE_P = 0, VNC_H264_SLICE_TYPE_B = 1, VNC_H264_SLICE_TYPE_I = 2 } vnc_h264_slice_types_e; static const value_string vnc_h264_slice_types_vs[] = { { VNC_H264_SLICE_TYPE_P, "Predicted" }, { VNC_H264_SLICE_TYPE_B, "Bi-predicted" }, { VNC_H264_SLICE_TYPE_I, "Intra coded" }, { 0, NULL } }; typedef enum { VNC_SESSION_STATE_SERVER_VERSION, VNC_SESSION_STATE_CLIENT_VERSION, VNC_SESSION_STATE_SECURITY, VNC_SESSION_STATE_SECURITY_TYPES, VNC_SESSION_STATE_TIGHT_TUNNELING_CAPABILITIES, VNC_SESSION_STATE_TIGHT_TUNNEL_TYPE_REPLY, VNC_SESSION_STATE_TIGHT_AUTH_CAPABILITIES, VNC_SESSION_STATE_TIGHT_AUTH_TYPE_REPLY, VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3, VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE, VNC_SESSION_STATE_VNC_AUTHENTICATION_RESPONSE, VNC_SESSION_STATE_ARD_AUTHENTICATION_CHALLENGE, VNC_SESSION_STATE_ARD_AUTHENTICATION_RESPONSE, VNC_SESSION_STATE_SECURITY_RESULT, VNC_SESSION_STATE_VENCRYPT_SERVER_VERSION, VNC_SESSION_STATE_VENCRYPT_CLIENT_VERSION, VNC_SESSION_STATE_VENCRYPT_AUTH_CAPABILITIES, VNC_SESSION_STATE_VENCRYPT_AUTH_TYPE_REPLY, VNC_SESSION_STATE_VENCRYPT_AUTH_ACK, VNC_SESSION_STATE_CLIENT_INIT, VNC_SESSION_STATE_SERVER_INIT, VNC_SESSION_STATE_TIGHT_INTERACTION_CAPS, VNC_SESSION_STATE_NORMAL_TRAFFIC } vnc_session_state_e; #define VNC_FENCE_BLOCK_BEFORE 0x00000001 #define VNC_FENCE_BLOCK_AFTER 0x00000002 #define VNC_FENCE_SYNC_NEXT 0x00000004 #define VNC_FENCE_REQUEST 0x80000000 /* This structure will be tied to each conversation. */ typedef struct { double server_proto_ver, client_proto_ver; uint32_t server_port; /* These are specific to TightVNC */ int num_server_message_types; int num_client_message_types; int num_encoding_types; uint8_t security_type_selected; bool tight_enabled; /* This is specific to Apple Remote Desktop */ uint16_t ard_key_length; /* State information valid on first sequential pass; * stored in per-packet info for subsequent passes. */ uint8_t bytes_per_pixel; uint8_t depth; vnc_session_state_e vnc_next_state; int preferred_encoding; } vnc_conversation_t; /* This structure will be tied to each packet */ typedef struct { vnc_session_state_e state; //int preferred_encoding; XXX: Not actually used? uint8_t bytes_per_pixel; uint8_t depth; } vnc_packet_t; void proto_reg_handoff_vnc(void); static bool vnc_startup_messages(tvbuff_t *tvb, packet_info *pinfo, int offset, proto_tree *tree, vnc_conversation_t *per_conversation_info); static void vnc_client_to_server(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, vnc_conversation_t *per_conversation_info); static void vnc_server_to_client(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static void vnc_client_set_pixel_format(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, vnc_conversation_t *per_conversation_info); static void vnc_client_set_encodings(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, vnc_conversation_t *per_conversation_info); static void vnc_client_framebuffer_update_request(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static void vnc_client_key_event(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static void vnc_client_pointer_event(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static void vnc_client_cut_text(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static unsigned vnc_server_framebuffer_update(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static unsigned vnc_raw_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height); static unsigned vnc_copyrect_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height); static unsigned vnc_rre_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height); static unsigned vnc_hextile_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height); static unsigned vnc_zrle_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height); static unsigned vnc_tight_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height); static unsigned vnc_rich_cursor_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height); static unsigned vnc_x_cursor_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height); static unsigned vnc_server_set_colormap_entries(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static void vnc_server_ring_bell(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static unsigned vnc_server_cut_text(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static void vnc_set_bytes_per_pixel(packet_info *pinfo, vnc_conversation_t *per_conversation_info, const uint8_t bytes_per_pixel); static void vnc_set_depth(packet_info *pinfo, vnc_conversation_t *per_conversation_info, const uint8_t depth); static uint8_t vnc_get_bytes_per_pixel(packet_info *pinfo); static uint8_t vnc_get_depth(packet_info *pinfo); static uint32_t vnc_extended_desktop_size(tvbuff_t *tvb, int *offset, proto_tree *tree); static unsigned vnc_supported_messages(tvbuff_t *tvb, int *offset, proto_tree *tree, const uint16_t width); static unsigned vnc_supported_encodings(tvbuff_t *tvb, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height); static unsigned vnc_server_identity(tvbuff_t *tvb, int *offset, proto_tree *tree, const uint16_t width); static unsigned vnc_fence(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static unsigned vnc_mirrorlink(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree); static unsigned vnc_context_information(tvbuff_t *tvb, int *offset, proto_tree *tree); static unsigned vnc_slrle_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t height); static unsigned vnc_h264_encoding(tvbuff_t *tvb, int *offset, proto_tree *tree); #define VNC_BYTES_NEEDED(a) \ if((a) > (unsigned)tvb_reported_length_remaining(tvb, *offset)) \ return (a); /* Initialize the protocol and registered fields */ static int proto_vnc; /* Protocol subtree */ static int hf_vnc_padding; static int hf_vnc_server_proto_ver; static int hf_vnc_client_proto_ver; static int hf_vnc_num_security_types; static int hf_vnc_security_type; static int hf_vnc_server_security_type; static int hf_vnc_client_security_type; static int hf_vnc_auth_challenge; static int hf_vnc_auth_response; static int hf_vnc_auth_result; static int hf_vnc_auth_error; static int hf_vnc_auth_error_length; static int hf_vnc_ard_auth_generator; static int hf_vnc_ard_auth_key_len; static int hf_vnc_ard_auth_modulus; static int hf_vnc_ard_auth_server_key; static int hf_vnc_ard_auth_credentials; static int hf_vnc_ard_auth_client_key; static int hf_vnc_share_desktop_flag; static int hf_vnc_width; static int hf_vnc_height; static int hf_vnc_server_bits_per_pixel; static int hf_vnc_server_depth; static int hf_vnc_server_big_endian_flag; static int hf_vnc_server_true_color_flag; static int hf_vnc_server_red_max; static int hf_vnc_server_green_max; static int hf_vnc_server_blue_max; static int hf_vnc_server_red_shift; static int hf_vnc_server_green_shift; static int hf_vnc_server_blue_shift; static int hf_vnc_desktop_name; static int hf_vnc_desktop_name_len; static int hf_vnc_desktop_screen_num; static int hf_vnc_desktop_screen_id; static int hf_vnc_desktop_screen_x; static int hf_vnc_desktop_screen_y; static int hf_vnc_desktop_screen_width; static int hf_vnc_desktop_screen_height; static int hf_vnc_desktop_screen_flags; static int hf_vnc_num_server_message_types; static int hf_vnc_num_client_message_types; static int hf_vnc_num_encoding_types; /********** Client Message Types **********/ static int hf_vnc_client_message_type; /* A subtree under VNC */ static int hf_vnc_client_bits_per_pixel; static int hf_vnc_client_depth; static int hf_vnc_client_big_endian_flag; static int hf_vnc_client_true_color_flag; static int hf_vnc_client_red_max; static int hf_vnc_client_green_max; static int hf_vnc_client_blue_max; static int hf_vnc_client_red_shift; static int hf_vnc_client_green_shift; static int hf_vnc_client_blue_shift; /* Client Key Event */ static int hf_vnc_key_down; static int hf_vnc_key; /* Client Pointer Event */ static int hf_vnc_button_1_pos; static int hf_vnc_button_2_pos; static int hf_vnc_button_3_pos; static int hf_vnc_button_4_pos; static int hf_vnc_button_5_pos; static int hf_vnc_button_6_pos; static int hf_vnc_button_7_pos; static int hf_vnc_button_8_pos; static int hf_vnc_pointer_x_pos; static int hf_vnc_pointer_y_pos; /* Client Framebuffer Update Request */ static int hf_vnc_update_req_incremental; static int hf_vnc_update_req_x_pos; static int hf_vnc_update_req_y_pos; static int hf_vnc_update_req_width; static int hf_vnc_update_req_height; /* Client Set Encodings */ static int hf_vnc_encoding_num; static int hf_vnc_client_set_encodings_encoding_type; /* Client Cut Text */ static int hf_vnc_client_cut_text_len; static int hf_vnc_client_cut_text; /********** Server Message Types **********/ static int hf_vnc_server_message_type; /* Subtree */ /* Tunneling capabilities (TightVNC extension) */ static int hf_vnc_tight_num_tunnel_types; static int hf_vnc_tight_tunnel_type_code; static int hf_vnc_tight_tunnel_type_vendor; static int hf_vnc_tight_tunnel_type_signature; /* Authentication capabilities (TightVNC extension) */ static int hf_vnc_tight_num_auth_types; static int hf_vnc_tight_auth_code; /* TightVNC capabilities */ static int hf_vnc_tight_server_message_type; static int hf_vnc_tight_server_vendor; static int hf_vnc_tight_signature; static int hf_vnc_tight_server_name; static int hf_vnc_tight_client_message_type; static int hf_vnc_tight_client_vendor; static int hf_vnc_tight_client_name; static int hf_vnc_tight_encoding_type; static int hf_vnc_tight_encoding_vendor; static int hf_vnc_tight_encoding_name; /* VeNCrypt capabilities */ static int hf_vnc_vencrypt_server_major_ver; static int hf_vnc_vencrypt_server_minor_ver; static int hf_vnc_vencrypt_client_major_ver; static int hf_vnc_vencrypt_client_minor_ver; static int hf_vnc_vencrypt_version_ack; static int hf_vnc_vencrypt_num_auth_types; static int hf_vnc_vencrypt_auth_type; static int hf_vnc_vencrypt_auth_type_ack; /* Tight compression parameters */ static int hf_vnc_tight_reset_stream0; static int hf_vnc_tight_reset_stream1; static int hf_vnc_tight_reset_stream2; static int hf_vnc_tight_reset_stream3; static int hf_vnc_tight_rect_type; static int hf_vnc_tight_image_len; static int hf_vnc_tight_image_data; static int hf_vnc_tight_fill_color; static int hf_vnc_tight_filter_flag; static int hf_vnc_tight_filter_id; static int hf_vnc_tight_palette_num_colors; static int hf_vnc_tight_palette_data; /* Server Framebuffer Update */ static int hf_vnc_rectangle_num; static int hf_vnc_fb_update_x_pos; static int hf_vnc_fb_update_y_pos; static int hf_vnc_fb_update_width; static int hf_vnc_fb_update_height; static int hf_vnc_fb_update_encoding_type; /* Raw Encoding */ static int hf_vnc_raw_pixel_data; /* CopyRect Encoding */ static int hf_vnc_copyrect_src_x_pos; static int hf_vnc_copyrect_src_y_pos; /* RRE Encoding */ static int hf_vnc_rre_num_subrects; static int hf_vnc_rre_bg_pixel; static int hf_vnc_rre_subrect_pixel; static int hf_vnc_rre_subrect_x_pos; static int hf_vnc_rre_subrect_y_pos; static int hf_vnc_rre_subrect_width; static int hf_vnc_rre_subrect_height; /* Hextile Encoding */ static int hf_vnc_hextile_subencoding_mask; static int hf_vnc_hextile_raw; static int hf_vnc_hextile_raw_value; static int hf_vnc_hextile_bg; static int hf_vnc_hextile_bg_value; static int hf_vnc_hextile_fg; static int hf_vnc_hextile_fg_value; static int hf_vnc_hextile_anysubrects; static int hf_vnc_hextile_num_subrects; static int hf_vnc_hextile_subrectscolored; static int hf_vnc_hextile_subrect_pixel_value; static int hf_vnc_hextile_subrect_x_pos; static int hf_vnc_hextile_subrect_y_pos; static int hf_vnc_hextile_subrect_width; static int hf_vnc_hextile_subrect_height; /* ZRLE Encoding */ static int hf_vnc_zrle_len; static int hf_vnc_zrle_subencoding; static int hf_vnc_zrle_rle; static int hf_vnc_zrle_palette_size; static int hf_vnc_zrle_data; static int hf_vnc_zrle_raw; static int hf_vnc_zrle_palette; /* Cursor Encoding */ static int hf_vnc_cursor_x_fore_back; static int hf_vnc_cursor_encoding_pixels; static int hf_vnc_cursor_encoding_bitmask; /* Server Set Colormap Entries */ static int hf_vnc_color_groups; static int hf_vnc_colormap_first_color; static int hf_vnc_colormap_num_colors; static int hf_vnc_colormap_red; static int hf_vnc_colormap_green; static int hf_vnc_colormap_blue; /* Server Cut Text */ static int hf_vnc_server_cut_text_len; static int hf_vnc_server_cut_text; /* LibVNCServer additions */ static int hf_vnc_supported_messages_client2server; static int hf_vnc_supported_messages_server2client; static int hf_vnc_num_supported_encodings; static int hf_vnc_supported_encodings; static int hf_vnc_server_identity; /* MirrorLink */ static int hf_vnc_mirrorlink_type; static int hf_vnc_mirrorlink_length; static int hf_vnc_mirrorlink_version_major; static int hf_vnc_mirrorlink_version_minor; static int hf_vnc_mirrorlink_framebuffer_configuration; static int hf_vnc_mirrorlink_pixel_width; static int hf_vnc_mirrorlink_pixel_height; static int hf_vnc_mirrorlink_pixel_format; static int hf_vnc_mirrorlink_display_width; static int hf_vnc_mirrorlink_display_height; static int hf_vnc_mirrorlink_display_distance; static int hf_vnc_mirrorlink_keyboard_language; static int hf_vnc_mirrorlink_keyboard_country; static int hf_vnc_mirrorlink_ui_language; static int hf_vnc_mirrorlink_ui_country; static int hf_vnc_mirrorlink_knob_keys; static int hf_vnc_mirrorlink_device_keys; static int hf_vnc_mirrorlink_multimedia_keys; static int hf_vnc_mirrorlink_key_related; static int hf_vnc_mirrorlink_pointer_related; static int hf_vnc_mirrorlink_key_symbol_value_client; static int hf_vnc_mirrorlink_key_symbol_value_server; static int hf_vnc_mirrorlink_key_configuration; static int hf_vnc_mirrorlink_key_num_events; static int hf_vnc_mirrorlink_key_event_counter; static int hf_vnc_mirrorlink_key_symbol_value; static int hf_vnc_mirrorlink_key_request_configuration; static int hf_vnc_mirrorlink_keyboard_configuration; static int hf_vnc_mirrorlink_cursor_x; static int hf_vnc_mirrorlink_cursor_y; static int hf_vnc_mirrorlink_text_x; static int hf_vnc_mirrorlink_text_y; static int hf_vnc_mirrorlink_text_width; static int hf_vnc_mirrorlink_text_height; static int hf_vnc_mirrorlink_keyboard_request_configuration; static int hf_vnc_mirrorlink_device_status; static int hf_vnc_mirrorlink_app_id; static int hf_vnc_mirrorlink_fb_block_x; static int hf_vnc_mirrorlink_fb_block_y; static int hf_vnc_mirrorlink_fb_block_width; static int hf_vnc_mirrorlink_fb_block_height; static int hf_vnc_mirrorlink_fb_block_reason; static int hf_vnc_mirrorlink_audio_block_reason; static int hf_vnc_mirrorlink_touch_num_events; static int hf_vnc_mirrorlink_touch_x; static int hf_vnc_mirrorlink_touch_y; static int hf_vnc_mirrorlink_touch_id; static int hf_vnc_mirrorlink_touch_pressure; static int hf_vnc_mirrorlink_text; static int hf_vnc_mirrorlink_text_length; static int hf_vnc_mirrorlink_text_max_length; static int hf_vnc_mirrorlink_unknown; /* Fence */ static int hf_vnc_fence_flags; static int hf_vnc_fence_request; static int hf_vnc_fence_sync_next; static int hf_vnc_fence_block_after; static int hf_vnc_fence_block_before; static int hf_vnc_fence_payload_length; static int hf_vnc_fence_payload; static int * const vnc_fence_flags[] = { &hf_vnc_fence_request, &hf_vnc_fence_sync_next, &hf_vnc_fence_block_after, &hf_vnc_fence_block_before, NULL }; /* Context Information */ static int hf_vnc_context_information_app_id; static int hf_vnc_context_information_app_category; static int hf_vnc_context_information_app_trust_level; static int hf_vnc_context_information_content_category; static int hf_vnc_context_information_content_rules; static int hf_vnc_context_information_content_trust_level; /* Scan Line based Run-Length Encoding */ static int hf_vnc_slrle_run_num; static int hf_vnc_slrle_run_data; /* H.264 Encoding */ static int hf_vnc_h264_slice_type; static int hf_vnc_h264_nbytes; static int hf_vnc_h264_width; static int hf_vnc_h264_height; static int hf_vnc_h264_data; /********** End of Server Message Types **********/ static bool vnc_preference_desegment = true; /* Initialize the subtree pointers */ static int ett_vnc; static int ett_vnc_client_message_type; static int ett_vnc_server_message_type; static int ett_vnc_rect; static int ett_vnc_encoding_type; static int ett_vnc_rre_subrect; static int ett_vnc_hextile_subencoding_mask; static int ett_vnc_hextile_num_subrects; static int ett_vnc_hextile_subrect; static int ett_vnc_hextile_tile; static int ett_vnc_zrle_subencoding; static int ett_vnc_colormap_num_groups; static int ett_vnc_colormap_color_group; static int ett_vnc_desktop_screen; static int ett_vnc_key_events; static int ett_vnc_touch_events; static int ett_vnc_slrle_subline; static int ett_vnc_fence_flags; static expert_field ei_vnc_possible_gtk_vnc_bug; static expert_field ei_vnc_auth_code_mismatch; static expert_field ei_vnc_unknown_tight_vnc_auth; static expert_field ei_vnc_too_many_rectangles; static expert_field ei_vnc_too_many_sub_rectangles; static expert_field ei_vnc_invalid_encoding; static expert_field ei_vnc_too_many_colors; static expert_field ei_vnc_too_many_cut_text; static expert_field ei_vnc_zrle_failed; static expert_field ei_vnc_unknown_tight; static expert_field ei_vnc_reassemble; #define VNC_PORT_RANGE "5500-5501,5900-5901" /* Port 5900 is IANA registered (under the service name "Remote Framebuffer"), * the others are customary but not registered as mentioned in RFC 6143. * (5900+N is commonly used in the case of multiple servers, analogous to * X11.) */ static range_t *vnc_tcp_range; static dissector_handle_t vnc_handle; static dissector_handle_t tls_handle; /* Code to dissect the packets */ static int dissect_vnc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { bool ret; int offset = 0; /* Set up structures needed to add the protocol subtree and manage it */ proto_item *ti; proto_tree *vnc_tree; conversation_t *conversation; vnc_conversation_t *per_conversation_info; conversation = find_or_create_conversation(pinfo); /* Retrieve information from conversation, or add it if it isn't * there yet */ per_conversation_info = (vnc_conversation_t *)conversation_get_proto_data(conversation, proto_vnc); if(!per_conversation_info) { per_conversation_info = wmem_new(wmem_file_scope(), vnc_conversation_t); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SERVER_VERSION; per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_INVALID; per_conversation_info->tight_enabled = false; per_conversation_info->preferred_encoding = VNC_ENCODING_TYPE_RAW; /* Initial values for depth and bytes_per_pixel are set in * in the mandatory VNC_SESSION_STATE_SERVER_INIT startup * message. "This pixel format will be used unless the * client requests a different format using the SetPixelFormat * message" (RFC 6143 7.3.2 ServerInit) */ conversation_add_proto_data(conversation, proto_vnc, per_conversation_info); } /* Make entries in Protocol column and Info column on summary display */ col_set_str(pinfo->cinfo, COL_PROTOCOL, "VNC"); /* First, clear the info column */ col_clear(pinfo->cinfo, COL_INFO); /* create display subtree for the protocol */ ti = proto_tree_add_item(tree, proto_vnc, tvb, 0, -1, ENC_NA); vnc_tree = proto_item_add_subtree(ti, ett_vnc); /* Dissect any remaining session startup messages */ ret = vnc_startup_messages(tvb, pinfo, offset, vnc_tree, per_conversation_info); if (ret) { return tvb_captured_length(tvb); /* We're in a "startup" state; Cannot yet do "normal" processing */ } if (per_conversation_info->security_type_selected == VNC_SECURITY_TYPE_VENCRYPT) { call_dissector_with_data(tls_handle, tvb, pinfo, vnc_tree, GUINT_TO_POINTER(offset)); return tvb_captured_length(tvb); } if(value_is_in_range(vnc_tcp_range, pinfo->destport) || per_conversation_info->server_port == pinfo->destport) { vnc_client_to_server(tvb, pinfo, &offset, vnc_tree, per_conversation_info); } else { vnc_server_to_client(tvb, pinfo, &offset, vnc_tree); } return tvb_captured_length(tvb); } /* Returns the new offset after processing the 4-byte vendor string */ static int process_vendor(proto_tree *tree, int hfindex, tvbuff_t *tvb, int offset) { const uint8_t *vendor; proto_item *ti; if (tree) { ti = proto_tree_add_item_ret_string(tree, hfindex, tvb, offset, 4, ENC_ASCII|ENC_NA, wmem_packet_scope(), &vendor); if(g_ascii_strcasecmp(vendor, "STDV") == 0) proto_item_append_text(ti, " (Standard VNC vendor)"); else if(g_ascii_strcasecmp(vendor, "TRDV") == 0) proto_item_append_text(ti, " (Tridia VNC vendor)"); else if(g_ascii_strcasecmp(vendor, "TGHT") == 0) proto_item_append_text(ti, " (Tight VNC vendor)"); } offset += 4; return offset; } /* Returns the new offset after processing the specified number of capabilities */ static int process_tight_capabilities(proto_tree *tree, int type_index, int vendor_index, int name_index, tvbuff_t *tvb, int offset, const int num_capabilities) { int i; /* See vnc_unixsrc/include/rfbproto.h:rfbCapabilityInfo */ for (i = 0; i < num_capabilities; i++) { proto_tree_add_item(tree, type_index, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; offset = process_vendor(tree, vendor_index, tvb, offset); proto_tree_add_item(tree, name_index, tvb, offset, 8, ENC_ASCII|ENC_NA); offset += 8; } return offset; } /* Returns true if this looks like a client or server version packet: 12 bytes, in the format "RFB xxx.yyy\n" . * Will check for the 12 bytes exact length, the 'RFB ' string and that it ends with a '\n'. * The exact 'xxx.yyy' is checked later, by trying to convert it to a double using g_ascii_strtod. * pinfo and tree are NULL when using this function to check the heuristics for dissection. If we're * checking the heuristics, we don't need to add expert_info, we just reject that packet as not * being a VNC packet. */ static bool vnc_is_client_or_server_version_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { if(tvb_captured_length(tvb) != 12) { return false; } if(tvb_strncaseeql(tvb, 0, "RFB ", 4) != 0) { return false; } /* 0x2e = '.' 0xa = '\n' */ if (tvb_get_uint8(tvb, 7) != 0x2e) { return false; } if (tvb_get_uint8(tvb,11) != 0xa) { if (tvb_get_uint8(tvb,11) == 0) { /* Per bug 5469, It appears that any VNC clients using gtk-vnc before [1] was * fixed will exhibit the described protocol violation that prevents wireshark * from dissecting the session. * * [1] http://git.gnome.org/browse/gtk-vnc/commit/?id=bc9e2b19167686dd381a0508af1a5113675d08a2 */ if ((pinfo != NULL) && (tree != NULL)) { proto_tree_add_expert(tree, pinfo, &ei_vnc_possible_gtk_vnc_bug, tvb, -1, 0); } return true; } return false; } return true; } static bool test_vnc_protocol(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) { conversation_t *conversation; if (vnc_is_client_or_server_version_message(tvb, NULL, NULL)) { conversation = conversation_new(pinfo->num, &pinfo->src, &pinfo->dst, conversation_pt_to_conversation_type(pinfo->ptype), pinfo->srcport, pinfo->destport, 0); conversation_set_dissector(conversation, vnc_handle); dissect_vnc(tvb, pinfo, tree, data); return true; } return false; } /* Returns true if additional session startup messages follow */ static bool vnc_startup_messages(tvbuff_t *tvb, packet_info *pinfo, int offset, proto_tree *tree, vnc_conversation_t *per_conversation_info) { uint8_t num_security_types; uint32_t desktop_name_len, auth_result, text_len, auth_code; vnc_packet_t *per_packet_info; int num_tunnel_types; int num_auth_types; proto_item* auth_item; int bytes_available; int bytes_needed = 0; per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); if(!per_packet_info) { per_packet_info = wmem_new(wmem_file_scope(), vnc_packet_t); per_packet_info->state = per_conversation_info->vnc_next_state; per_packet_info->bytes_per_pixel = per_conversation_info->bytes_per_pixel; per_packet_info->depth = per_conversation_info->depth; p_add_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0, per_packet_info); } bytes_available = tvb_reported_length_remaining(tvb, offset); /* Packet dissection follows */ switch(per_packet_info->state) { case VNC_SESSION_STATE_SERVER_VERSION : if (!vnc_is_client_or_server_version_message(tvb, pinfo, tree)) return true; /* we still hope to get a SERVER_VERSION message some day. Do not proceed yet */ proto_tree_add_item(tree, hf_vnc_server_proto_ver, tvb, 4, 7, ENC_ASCII); per_conversation_info->server_proto_ver = g_ascii_strtod((char *)tvb_get_string_enc(wmem_packet_scope(), tvb, 4, 7, ENC_ASCII), NULL); per_conversation_info->server_port = pinfo->srcport; col_add_fstr(pinfo->cinfo, COL_INFO, "Server protocol version: %s", tvb_format_text(pinfo->pool, tvb, 4, 7)); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_VERSION; break; case VNC_SESSION_STATE_CLIENT_VERSION : if (!vnc_is_client_or_server_version_message(tvb, pinfo, tree)) return true; /* we still hope to get a CLIENT_VERSION message some day. Do not proceed yet */ proto_tree_add_item(tree, hf_vnc_client_proto_ver, tvb, 4, 7, ENC_ASCII); per_conversation_info->client_proto_ver = g_ascii_strtod((char *)tvb_get_string_enc(wmem_packet_scope(), tvb, 4, 7, ENC_ASCII), NULL); col_add_fstr(pinfo->cinfo, COL_INFO, "Client protocol version: %s", tvb_format_text(pinfo->pool, tvb, 4, 7)); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY; break; case VNC_SESSION_STATE_SECURITY : col_set_str(pinfo->cinfo, COL_INFO, "Security types supported"); /* We're checking against the client protocol version because * the client is the final decider on which version to use * after the server offers the highest version it supports. */ if(per_conversation_info->client_proto_ver >= 3.007) { num_security_types = tvb_get_uint8(tvb, offset); bytes_needed = 1 + num_security_types; if (bytes_available < bytes_needed && vnc_preference_desegment && pinfo->can_desegment) { pinfo->desegment_offset = offset; pinfo->desegment_len = bytes_needed - bytes_available; break; } if (tree) { proto_tree_add_item(tree, hf_vnc_num_security_types, tvb, offset, 1, ENC_BIG_ENDIAN); for(offset = 1; offset <= num_security_types; offset++){ proto_tree_add_item(tree, hf_vnc_security_type, tvb, offset, 1, ENC_BIG_ENDIAN); } } per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY_TYPES; } else { /* Version < 3.007: The server decides the * authentication type for us to use */ proto_tree_add_item(tree, hf_vnc_server_security_type, tvb, offset, 4, ENC_BIG_ENDIAN); /* The cast below is possible since in older versions of the protocol the only possible values are 0,1,2 */ per_conversation_info->security_type_selected = (uint8_t)tvb_get_ntohl(tvb, offset); switch(per_conversation_info->security_type_selected) { case VNC_SECURITY_TYPE_INVALID: /* TODO: In this case (INVALID) the connection has failed */ /* and there should be an error string describing the error */ per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY_TYPES; break; case VNC_SECURITY_TYPE_NONE: per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; break; case VNC_SECURITY_TYPE_VNC: per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE; break; case VNC_SECURITY_TYPE_ARD: per_conversation_info->vnc_next_state = VNC_SESSION_STATE_ARD_AUTHENTICATION_CHALLENGE; break; default: /* Security type not supported by this dissector */ break; } } break; case VNC_SESSION_STATE_SECURITY_TYPES : proto_tree_add_item(tree, hf_vnc_client_security_type, tvb, offset, 1, ENC_BIG_ENDIAN); per_conversation_info->security_type_selected = tvb_get_uint8(tvb, offset); col_add_fstr(pinfo->cinfo, COL_INFO, "Security type %s (%d) selected by client", val_to_str_const(per_conversation_info->security_type_selected, vnc_security_types_vs, "Unknown"), per_conversation_info->security_type_selected); switch(per_conversation_info->security_type_selected) { case VNC_SECURITY_TYPE_NONE : if(per_conversation_info->client_proto_ver >= 3.008) per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY_RESULT; else per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; break; case VNC_SECURITY_TYPE_VNC : per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE; break; case VNC_SECURITY_TYPE_TIGHT : per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_TUNNELING_CAPABILITIES; per_conversation_info->tight_enabled = true; break; case VNC_SECURITY_TYPE_ARD: per_conversation_info->vnc_next_state = VNC_SESSION_STATE_ARD_AUTHENTICATION_CHALLENGE; break; case VNC_SECURITY_TYPE_VENCRYPT: per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VENCRYPT_SERVER_VERSION; break; default : /* Security type not supported by this dissector */ break; } break; case VNC_SESSION_STATE_TIGHT_TUNNELING_CAPABILITIES : { int i; col_set_str(pinfo->cinfo, COL_INFO, "TightVNC tunneling capabilities supported"); proto_tree_add_item(tree, hf_vnc_tight_num_tunnel_types, tvb, offset, 4, ENC_BIG_ENDIAN); num_tunnel_types = tvb_get_ntohl(tvb, offset); offset += 4; for(i = 0; i < num_tunnel_types; i++) { /* TightVNC and Xvnc don't support any tunnel capabilities yet, but each capability * is 16 bytes, so skip them. */ proto_tree_add_item(tree, hf_vnc_tight_tunnel_type_code, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_vnc_tight_tunnel_type_vendor, tvb, offset + 4, 4, ENC_ASCII); proto_tree_add_item(tree, hf_vnc_tight_tunnel_type_signature, tvb, offset + 8, 8, ENC_ASCII); offset += 16; } if (num_tunnel_types == 0) per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_AUTH_CAPABILITIES; else per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_TUNNEL_TYPE_REPLY; break; } case VNC_SESSION_STATE_TIGHT_TUNNEL_TYPE_REPLY: /* Neither TightVNC nor Xvnc implement this; they just have a placeholder that emits an error * message and closes the connection (xserver/hw/vnc/auth.c:rfbProcessClientTunnelingType). * We should actually never get here... */ break; case VNC_SESSION_STATE_TIGHT_AUTH_CAPABILITIES: { const uint8_t *vendor, *signature; col_set_str(pinfo->cinfo, COL_INFO, "TightVNC authentication capabilities supported"); proto_tree_add_item(tree, hf_vnc_tight_num_auth_types, tvb, offset, 4, ENC_BIG_ENDIAN); num_auth_types = tvb_get_ntohl(tvb, offset); offset += 4; auth_code = tvb_get_ntohl(tvb, offset); auth_item = proto_tree_add_item(tree, hf_vnc_tight_auth_code, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; vendor = tvb_get_string_enc(wmem_packet_scope(), tvb, offset, 4, ENC_ASCII); process_vendor(tree, hf_vnc_tight_server_vendor, tvb, offset); offset += 4; proto_tree_add_item_ret_string(tree, hf_vnc_tight_signature, tvb, offset, 8, ENC_ASCII|ENC_NA, wmem_packet_scope(), &signature); switch(auth_code) { case VNC_SECURITY_TYPE_NONE: if ((g_ascii_strcasecmp(vendor, "STDV") != 0) || (g_ascii_strcasecmp(signature, "NOAUTH__") != 0)) { expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); } break; case VNC_SECURITY_TYPE_VNC: if ((g_ascii_strcasecmp(vendor, "STDV") != 0) || (g_ascii_strcasecmp(signature, "VNCAUTH_") != 0)) { expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); } break; case VNC_SECURITY_TYPE_VENCRYPT: if ((g_ascii_strcasecmp(vendor, "VENC") != 0) || (g_ascii_strcasecmp(signature, "VENCRYPT") != 0)) { expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); } break; case VNC_SECURITY_TYPE_GTK_VNC_SASL: if ((g_ascii_strcasecmp(vendor, "GTKV") != 0) || (g_ascii_strcasecmp(signature, "SASL____") != 0)) { expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); } break; case VNC_TIGHT_AUTH_TGHT_ULGNAUTH: if ((g_ascii_strcasecmp(vendor, "TGHT") != 0) || (g_ascii_strcasecmp(signature, "ULGNAUTH") != 0)) { expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); } break; case VNC_TIGHT_AUTH_TGHT_XTRNAUTH: if ((g_ascii_strcasecmp(vendor, "TGHT") != 0) || (g_ascii_strcasecmp(signature, "XTRNAUTH") != 0)) { expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); } break; default: expert_add_info(pinfo, auth_item, &ei_vnc_unknown_tight_vnc_auth); break; } if (num_auth_types == 0) per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; else per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_AUTH_TYPE_REPLY; break; } case VNC_SESSION_STATE_TIGHT_AUTH_TYPE_REPLY: col_set_str(pinfo->cinfo, COL_INFO, "TightVNC authentication type selected by client"); auth_code = tvb_get_ntohl(tvb, offset); auth_item = proto_tree_add_item(tree, hf_vnc_tight_auth_code, tvb, offset, 4, ENC_BIG_ENDIAN); switch(auth_code) { case VNC_SECURITY_TYPE_NONE: per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_NONE; per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; break; case VNC_SECURITY_TYPE_VNC: per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_VNC; per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE; break; case VNC_SECURITY_TYPE_GTK_VNC_SASL: per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_GTK_VNC_SASL; /* TODO: dissection not implemented yet */ per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3; break; case VNC_TIGHT_AUTH_TGHT_ULGNAUTH: per_conversation_info->security_type_selected = VNC_TIGHT_AUTH_TGHT_ULGNAUTH; /* TODO: dissection not implemented yet */ per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3; break; case VNC_TIGHT_AUTH_TGHT_XTRNAUTH: per_conversation_info->security_type_selected = VNC_TIGHT_AUTH_TGHT_XTRNAUTH; /* TODO: dissection not implemented yet */ per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3; break; default: expert_add_info(pinfo, auth_item, &ei_vnc_unknown_tight_vnc_auth); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3; break; } break; case VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3 : col_set_str(pinfo->cinfo, COL_INFO, "Unknown packet (TightVNC)"); proto_tree_add_expert(tree, pinfo, &ei_vnc_unknown_tight, tvb, offset, -1); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE; break; case VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE : col_set_str(pinfo->cinfo, COL_INFO, "Authentication challenge from server"); proto_tree_add_item(tree, hf_vnc_auth_challenge, tvb, offset, 16, ENC_NA); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VNC_AUTHENTICATION_RESPONSE; break; case VNC_SESSION_STATE_VNC_AUTHENTICATION_RESPONSE : col_set_str(pinfo->cinfo, COL_INFO, "Authentication response from client"); proto_tree_add_item(tree, hf_vnc_auth_response, tvb, offset, 16, ENC_NA); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY_RESULT; break; case VNC_SESSION_STATE_ARD_AUTHENTICATION_CHALLENGE : { int key_len; col_set_str(pinfo->cinfo, COL_INFO, "ARD authentication challenge"); proto_tree_add_item(tree, hf_vnc_ard_auth_generator, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_vnc_ard_auth_key_len, tvb, offset + 2, 2, ENC_BIG_ENDIAN); key_len = tvb_get_ntohs(tvb, offset + 2); offset += 4; proto_tree_add_item(tree, hf_vnc_ard_auth_modulus, tvb, offset, key_len, ENC_NA); proto_tree_add_item(tree, hf_vnc_ard_auth_server_key, tvb, offset + key_len, key_len, ENC_NA); per_conversation_info->ard_key_length = key_len; per_conversation_info->vnc_next_state = VNC_SESSION_STATE_ARD_AUTHENTICATION_RESPONSE; } break; case VNC_SESSION_STATE_ARD_AUTHENTICATION_RESPONSE : col_set_str(pinfo->cinfo, COL_INFO, "ARD authentication response"); proto_tree_add_item(tree, hf_vnc_ard_auth_credentials, tvb, offset, 128, ENC_NA); proto_tree_add_item(tree, hf_vnc_ard_auth_client_key, tvb, offset + 128, per_conversation_info->ard_key_length, ENC_NA); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY_RESULT; break; case VNC_SESSION_STATE_SECURITY_RESULT : col_set_str(pinfo->cinfo, COL_INFO, "Authentication result"); proto_tree_add_item(tree, hf_vnc_auth_result, tvb, offset, 4, ENC_BIG_ENDIAN); auth_result = tvb_get_ntohl(tvb, offset); offset += 4; switch(auth_result) { case 0 : /* OK */ per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; break; case 1 : /* Failed */ if(per_conversation_info->client_proto_ver >= 3.008) { text_len = tvb_get_ntohl(tvb, offset); proto_tree_add_item(tree, hf_vnc_auth_error_length, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(tree, hf_vnc_auth_error, tvb, offset, text_len, ENC_ASCII); } return true; /* All versions: Do not continue processing VNC packets as connection will be closed after this packet. */ break; } break; case VNC_SESSION_STATE_VENCRYPT_SERVER_VERSION: { bytes_needed = 2; if (bytes_available < bytes_needed && vnc_preference_desegment && pinfo->can_desegment) { pinfo->desegment_offset = offset; pinfo->desegment_len = bytes_needed - bytes_available; break; } proto_tree_add_item(tree, hf_vnc_vencrypt_server_major_ver, tvb, offset, 1, ENC_BIG_ENDIAN); int major = tvb_get_uint8(tvb, offset++); proto_tree_add_item(tree, hf_vnc_vencrypt_server_minor_ver, tvb, offset, 1, ENC_BIG_ENDIAN); int minor = tvb_get_uint8(tvb, offset++); col_add_fstr(pinfo->cinfo, COL_INFO, "VeNCrypt server version %d.%d", major, minor); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VENCRYPT_CLIENT_VERSION; break; } case VNC_SESSION_STATE_VENCRYPT_CLIENT_VERSION: { bytes_needed = 2; if (bytes_available < bytes_needed && vnc_preference_desegment && pinfo->can_desegment) { pinfo->desegment_offset = offset; pinfo->desegment_len = bytes_needed - bytes_available; break; } proto_tree_add_item(tree, hf_vnc_vencrypt_client_major_ver, tvb, offset, 1, ENC_BIG_ENDIAN); int major = tvb_get_uint8(tvb, offset++); proto_tree_add_item(tree, hf_vnc_vencrypt_client_minor_ver, tvb, offset, 1, ENC_BIG_ENDIAN); int minor = tvb_get_uint8(tvb, offset++); col_add_fstr(pinfo->cinfo, COL_INFO, "VeNCrypt client version %d.%d", major, minor); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VENCRYPT_AUTH_CAPABILITIES; break; } case VNC_SESSION_STATE_VENCRYPT_AUTH_CAPABILITIES: { int i; bytes_needed = 2; if (bytes_available < bytes_needed && vnc_preference_desegment && pinfo->can_desegment) { pinfo->desegment_offset = offset; pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT; break; } num_auth_types = tvb_get_uint8(tvb, offset + 1); bytes_needed = 2 + 4 * num_auth_types; if (bytes_available < bytes_needed && vnc_preference_desegment && pinfo->can_desegment) { pinfo->desegment_offset = offset; pinfo->desegment_len = bytes_needed - bytes_available; break; } col_set_str(pinfo->cinfo, COL_INFO, "VeNCrypt authentication types supported"); proto_tree_add_item(tree, hf_vnc_vencrypt_version_ack, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(tree, hf_vnc_vencrypt_num_auth_types, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; for(i = 0; i < num_auth_types; i++) { proto_tree_add_item(tree, hf_vnc_vencrypt_auth_type, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; } per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VENCRYPT_AUTH_TYPE_REPLY; break; } case VNC_SESSION_STATE_VENCRYPT_AUTH_TYPE_REPLY: { bytes_needed = 4; if (bytes_available < bytes_needed && vnc_preference_desegment && pinfo->can_desegment) { pinfo->desegment_offset = offset; pinfo->desegment_len = bytes_needed - bytes_available; break; } uint32_t authtype = tvb_get_ntohl(tvb, offset); col_add_fstr(pinfo->cinfo, COL_INFO, "VeNCrypt authentication type %s (%d) selected by client", val_to_str_const(authtype, vnc_vencrypt_auth_types_vs, "Unknown"), authtype); proto_tree_add_item(tree, hf_vnc_vencrypt_auth_type, tvb, offset, 4, ENC_BIG_ENDIAN); /* offset+=4; */ if (authtype == VNC_SECURITY_TYPE_NONE) { per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_NONE; } else if (authtype == VNC_SECURITY_TYPE_VNC) { per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE; per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_VNC; } else { per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VENCRYPT_AUTH_ACK; } break; } case VNC_SESSION_STATE_VENCRYPT_AUTH_ACK: col_set_str(pinfo->cinfo, COL_INFO, "VeNCrypt server ack"); proto_tree_add_item(tree, hf_vnc_vencrypt_auth_type_ack, tvb, offset, 1, ENC_BIG_ENDIAN); tls_handle = find_dissector("tls"); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_NORMAL_TRAFFIC; break; case VNC_SESSION_STATE_CLIENT_INIT : col_set_str(pinfo->cinfo, COL_INFO, "Share desktop flag"); proto_tree_add_item(tree, hf_vnc_share_desktop_flag, tvb, offset, 1, ENC_BIG_ENDIAN); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SERVER_INIT; break; case VNC_SESSION_STATE_SERVER_INIT : col_set_str(pinfo->cinfo, COL_INFO, "Server framebuffer parameters"); proto_tree_add_item(tree, hf_vnc_width, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; proto_tree_add_item(tree, hf_vnc_height, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; proto_tree_add_item(tree, hf_vnc_server_bits_per_pixel, tvb, offset, 1, ENC_BIG_ENDIAN); vnc_set_bytes_per_pixel(pinfo, per_conversation_info, tvb_get_uint8(tvb, offset) / 8); offset += 1; proto_tree_add_item(tree, hf_vnc_server_depth, tvb, offset, 1, ENC_BIG_ENDIAN); vnc_set_depth(pinfo, per_conversation_info, tvb_get_uint8(tvb, offset)); offset += 1; proto_tree_add_item(tree, hf_vnc_server_big_endian_flag, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(tree, hf_vnc_server_true_color_flag, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(tree, hf_vnc_server_red_max, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; proto_tree_add_item(tree, hf_vnc_server_green_max, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; proto_tree_add_item(tree, hf_vnc_server_blue_max, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; proto_tree_add_item(tree, hf_vnc_server_red_shift, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(tree, hf_vnc_server_green_shift, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(tree, hf_vnc_server_blue_shift, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(tree, hf_vnc_padding, tvb, offset, 3, ENC_NA); offset += 3; /* Skip over 3 bytes of padding */ if(tvb_reported_length_remaining(tvb, offset) > 4) { /* Sometimes the desktop name & length is skipped */ proto_tree_add_item(tree, hf_vnc_desktop_name_len, tvb, offset, 4, ENC_BIG_ENDIAN); desktop_name_len = tvb_get_ntohl(tvb, offset); offset += 4; proto_tree_add_item(tree, hf_vnc_desktop_name, tvb, offset, desktop_name_len, ENC_ASCII); } if(per_conversation_info->tight_enabled == true) per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_INTERACTION_CAPS; else per_conversation_info->vnc_next_state = VNC_SESSION_STATE_NORMAL_TRAFFIC; break; case VNC_SESSION_STATE_TIGHT_INTERACTION_CAPS : col_set_str(pinfo->cinfo, COL_INFO, "TightVNC Interaction Capabilities"); proto_tree_add_item(tree, hf_vnc_num_server_message_types, tvb, offset, 2, ENC_BIG_ENDIAN); per_conversation_info->num_server_message_types = tvb_get_ntohs(tvb, offset); offset += 2; proto_tree_add_item(tree, hf_vnc_num_client_message_types, tvb, offset, 2, ENC_BIG_ENDIAN); per_conversation_info->num_client_message_types = tvb_get_ntohs(tvb, offset); offset += 2; proto_tree_add_item(tree, hf_vnc_num_encoding_types, tvb, offset, 2, ENC_BIG_ENDIAN); per_conversation_info->num_encoding_types = tvb_get_ntohs(tvb, offset); offset += 2; proto_tree_add_item(tree, hf_vnc_padding, tvb, offset, 2, ENC_NA); offset += 2; offset = process_tight_capabilities(tree, hf_vnc_tight_server_message_type, hf_vnc_tight_server_vendor, hf_vnc_tight_server_name, tvb, offset, per_conversation_info->num_server_message_types); offset = process_tight_capabilities(tree, hf_vnc_tight_client_message_type, hf_vnc_tight_client_vendor, hf_vnc_tight_client_name, tvb, offset, per_conversation_info->num_client_message_types); process_tight_capabilities(tree, hf_vnc_tight_encoding_type, hf_vnc_tight_encoding_vendor, hf_vnc_tight_encoding_name, tvb, offset, per_conversation_info->num_encoding_types); per_conversation_info->vnc_next_state = VNC_SESSION_STATE_NORMAL_TRAFFIC; break; case VNC_SESSION_STATE_NORMAL_TRAFFIC : return false; } return true; } static void vnc_client_to_server(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, vnc_conversation_t *per_conversation_info) { uint8_t message_type; proto_item *ti; proto_tree *vnc_client_message_type_tree; message_type = tvb_get_uint8(tvb, *offset); ti = proto_tree_add_item(tree, hf_vnc_client_message_type, tvb, *offset, 1, ENC_BIG_ENDIAN); vnc_client_message_type_tree = proto_item_add_subtree(ti, ett_vnc_client_message_type); *offset += 1; switch(message_type) { case VNC_CLIENT_MESSAGE_TYPE_SET_PIXEL_FORMAT : vnc_client_set_pixel_format(tvb, pinfo, offset, vnc_client_message_type_tree, per_conversation_info); break; case VNC_CLIENT_MESSAGE_TYPE_SET_ENCODINGS : vnc_client_set_encodings(tvb, pinfo, offset, vnc_client_message_type_tree, per_conversation_info); break; case VNC_CLIENT_MESSAGE_TYPE_FRAMEBUF_UPDATE_REQ : vnc_client_framebuffer_update_request(tvb, pinfo, offset, vnc_client_message_type_tree); break; case VNC_CLIENT_MESSAGE_TYPE_KEY_EVENT : vnc_client_key_event(tvb, pinfo, offset, vnc_client_message_type_tree); break; case VNC_CLIENT_MESSAGE_TYPE_POINTER_EVENT: vnc_client_pointer_event(tvb, pinfo, offset, vnc_client_message_type_tree); break; case VNC_CLIENT_MESSAGE_TYPE_CLIENT_CUT_TEXT : vnc_client_cut_text(tvb, pinfo, offset, vnc_client_message_type_tree); break; case VNC_CLIENT_MESSAGE_TYPE_MIRRORLINK : vnc_mirrorlink(tvb, pinfo, offset, vnc_client_message_type_tree); break; case VNC_CLIENT_MESSAGE_TYPE_ENABLE_CONTINUOUS_UPDATES : col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Client Enable Continuous Updates"); *offset += 9; break; case VNC_CLIENT_MESSAGE_TYPE_FENCE : vnc_fence(tvb, pinfo, offset, vnc_client_message_type_tree); break; default : col_append_sep_fstr(pinfo->cinfo, COL_INFO, "; ", "Unknown client message type (%u)", message_type); break; } } static void vnc_server_to_client(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree) { int start_offset; uint8_t message_type; int bytes_needed = 0; proto_item *ti; proto_tree *vnc_server_message_type_tree; again: start_offset = *offset; message_type = tvb_get_uint8(tvb, *offset); ti = proto_tree_add_item(tree, hf_vnc_server_message_type, tvb, *offset, 1, ENC_BIG_ENDIAN); vnc_server_message_type_tree = proto_item_add_subtree(ti, ett_vnc_server_message_type); *offset += 1; switch(message_type) { case VNC_SERVER_MESSAGE_TYPE_FRAMEBUFFER_UPDATE : bytes_needed = vnc_server_framebuffer_update(tvb, pinfo, offset, vnc_server_message_type_tree); break; case VNC_SERVER_MESSAGE_TYPE_SET_COLORMAP_ENTRIES : bytes_needed = vnc_server_set_colormap_entries(tvb, pinfo, offset, vnc_server_message_type_tree); break; case VNC_SERVER_MESSAGE_TYPE_RING_BELL : vnc_server_ring_bell(tvb, pinfo, offset, vnc_server_message_type_tree); break; case VNC_SERVER_MESSAGE_TYPE_CUT_TEXT : bytes_needed = vnc_server_cut_text(tvb, pinfo, offset, vnc_server_message_type_tree); break; case VNC_SERVER_MESSAGE_TYPE_MIRRORLINK : bytes_needed = vnc_mirrorlink(tvb, pinfo, offset, vnc_server_message_type_tree); break; case VNC_SERVER_MESSAGE_TYPE_END_CONTINUOUS_UPDATES : col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Server End Continuous Updates"); *offset += 1; break; case VNC_SERVER_MESSAGE_TYPE_FENCE : bytes_needed = vnc_fence(tvb, pinfo, offset, vnc_server_message_type_tree); break; default : col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Unknown server message type"); *offset = tvb_reported_length(tvb); /* Swallow the rest of the segment */ break; } if(bytes_needed > 0 && vnc_preference_desegment && pinfo->can_desegment) { proto_tree_add_expert(vnc_server_message_type_tree, pinfo, &ei_vnc_reassemble, tvb, start_offset, -1); pinfo->desegment_offset = start_offset; pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT; return; } if ((unsigned)*offset < tvb_reported_length(tvb)) { goto again; } } static void vnc_client_set_pixel_format(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, vnc_conversation_t *per_conversation_info) { col_set_str(pinfo->cinfo, COL_INFO, "Client set pixel format"); proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 3, ENC_NA); *offset += 3; /* Skip over 3 bytes of padding */ proto_tree_add_item(tree, hf_vnc_client_bits_per_pixel, tvb, *offset, 1, ENC_BIG_ENDIAN); vnc_set_bytes_per_pixel(pinfo, per_conversation_info, tvb_get_uint8(tvb, *offset) / 8); *offset += 1; proto_tree_add_item(tree, hf_vnc_client_depth, tvb, *offset, 1, ENC_BIG_ENDIAN); vnc_set_depth(pinfo, per_conversation_info, tvb_get_uint8(tvb, *offset)); *offset += 1; proto_tree_add_item(tree, hf_vnc_client_big_endian_flag, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_client_true_color_flag, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_client_red_max, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_client_green_max, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_client_blue_max, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_client_red_shift, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_client_green_shift, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_client_blue_shift, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 3, ENC_NA); *offset += 3; /* Skip over 3 bytes of padding */ } static void vnc_client_set_encodings(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, vnc_conversation_t *per_conversation_info) { uint16_t number_of_encodings; unsigned counter; col_set_str(pinfo->cinfo, COL_INFO, "Client set encodings"); proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 1, ENC_NA); *offset += 1; /* Skip over 1 byte of padding */ number_of_encodings = tvb_get_ntohs(tvb, *offset); proto_tree_add_item(tree, hf_vnc_encoding_num, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; per_conversation_info->preferred_encoding = -1; for(counter = 0; counter < number_of_encodings; counter++) { proto_tree_add_item(tree, hf_vnc_client_set_encodings_encoding_type, tvb, *offset, 4, ENC_BIG_ENDIAN); /* Remember the first real encoding as the preferred encoding, * per xserver/hw/vnc/rfbserver.c:rfbProcessClientNormalMessage(). * Otherwise, use RAW as the preferred encoding. */ if (per_conversation_info->preferred_encoding == -1) { int encoding; encoding = tvb_get_ntohl(tvb, *offset); switch(encoding) { case VNC_ENCODING_TYPE_RAW: case VNC_ENCODING_TYPE_RRE: case VNC_ENCODING_TYPE_CORRE: case VNC_ENCODING_TYPE_HEXTILE: case VNC_ENCODING_TYPE_ZLIB: case VNC_ENCODING_TYPE_TIGHT: per_conversation_info->preferred_encoding = encoding; break; } } *offset += 4; } if (per_conversation_info->preferred_encoding == -1) per_conversation_info->preferred_encoding = VNC_ENCODING_TYPE_RAW; } static void vnc_client_framebuffer_update_request(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree) { col_set_str(pinfo->cinfo, COL_INFO, "Client framebuffer update request"); proto_tree_add_item(tree, hf_vnc_update_req_incremental, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_update_req_x_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_update_req_y_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_update_req_width, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_update_req_height, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; } static void vnc_client_key_event(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree) { col_set_str(pinfo->cinfo, COL_INFO, "Client key event"); proto_tree_add_item(tree, hf_vnc_key_down, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 2, ENC_NA); *offset += 2; /* Skip over 2 bytes of padding */ proto_tree_add_item(tree, hf_vnc_key, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; } static void vnc_client_pointer_event(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree) { col_set_str(pinfo->cinfo, COL_INFO, "Client pointer event"); proto_tree_add_item(tree, hf_vnc_button_1_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_vnc_button_2_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_vnc_button_3_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_vnc_button_4_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_vnc_button_5_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_vnc_button_6_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_vnc_button_7_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_vnc_button_8_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_pointer_x_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_pointer_y_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; } static void vnc_client_cut_text(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree) { uint32_t text_len; col_set_str(pinfo->cinfo, COL_INFO, "Client cut text"); proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 3, ENC_NA); *offset += 3; /* Skip over 3 bytes of padding */ text_len = tvb_get_ntohl(tvb, *offset); proto_tree_add_item(tree, hf_vnc_client_cut_text_len, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_client_cut_text, tvb, *offset, text_len, ENC_ASCII); *offset += text_len; } static unsigned vnc_server_framebuffer_update(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree) { unsigned ii; unsigned num_rects; uint16_t width, height; unsigned bytes_needed = 0; uint32_t encoding_type; proto_item *ti, *ti_x, *ti_y, *ti_width, *ti_height; proto_tree *vnc_rect_tree, *vnc_encoding_type_tree; col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Server framebuffer update"); proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 1, ENC_NA); *offset += 1; num_rects = tvb_get_ntohs(tvb, *offset); ti = proto_tree_add_item(tree, hf_vnc_rectangle_num, tvb, *offset, 2, ENC_BIG_ENDIAN); /* In some cases, TIGHT encoding ignores the "number of rectangles" field; */ /* VNC_ENCODING_TYPE_LAST_RECT is used to indicate the end of the rectangle list. */ /* (It appears that TIGHT encoding uses 0xFFFF for the num_rects field when the */ /* field is not being used). For now: we'll assume that a value 0f 0xFFFF means */ /* that the field is not being used. */ if (num_rects == 0xFFFF) { proto_item_append_text(ti, " [TIGHT encoding assumed (field is not used)]"); } if ((num_rects != 0xFFFF) && (num_rects > 5000)) { expert_add_info_format(pinfo, ti, &ei_vnc_too_many_rectangles, "Too many rectangles (%d), aborting dissection", num_rects); return 0; } *offset += 2; for(ii = 0; ii < num_rects; ii++) { if (ii > 5000) { expert_add_info_format(pinfo, ti, &ei_vnc_too_many_rectangles, "Too many rectangles (%d), aborting dissection", ii); return 0; } VNC_BYTES_NEEDED(12); vnc_rect_tree = proto_tree_add_subtree_format(tree, tvb, *offset, 12, ett_vnc_rect, NULL, "Rectangle #%d", ii+1); ti_x = proto_tree_add_item(vnc_rect_tree, hf_vnc_fb_update_x_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; ti_y = proto_tree_add_item(vnc_rect_tree, hf_vnc_fb_update_y_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; ti_width = proto_tree_add_item(vnc_rect_tree, hf_vnc_fb_update_width, tvb, *offset, 2, ENC_BIG_ENDIAN); width = tvb_get_ntohs(tvb, *offset); *offset += 2; ti_height = proto_tree_add_item(vnc_rect_tree, hf_vnc_fb_update_height, tvb, *offset, 2, ENC_BIG_ENDIAN); height = tvb_get_ntohs(tvb, *offset); *offset += 2; ti = proto_tree_add_item(vnc_rect_tree, hf_vnc_fb_update_encoding_type, tvb, *offset, 4, ENC_BIG_ENDIAN); encoding_type = tvb_get_ntohl(tvb, *offset); *offset += 4; if (encoding_type == VNC_ENCODING_TYPE_LAST_RECT) break; /* exit the loop */ vnc_encoding_type_tree = proto_item_add_subtree(ti, ett_vnc_encoding_type); switch(encoding_type) { case VNC_ENCODING_TYPE_RAW: bytes_needed = vnc_raw_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, width, height); break; case VNC_ENCODING_TYPE_COPY_RECT: bytes_needed = vnc_copyrect_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, width, height); break; case VNC_ENCODING_TYPE_RRE: bytes_needed = vnc_rre_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, width, height); break; case VNC_ENCODING_TYPE_HEXTILE: bytes_needed = vnc_hextile_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, width, height); break; case VNC_ENCODING_TYPE_RLE: bytes_needed = vnc_zrle_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, width, height); break; case VNC_ENCODING_TYPE_TIGHT: bytes_needed = vnc_tight_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, width, height); break; case VNC_ENCODING_TYPE_RICH_CURSOR: case VNC_ENCODING_TYPE_X_CURSOR: proto_item_append_text (ti_x, " (hotspot X)"); proto_item_append_text (ti_y, " (hotspot Y)"); proto_item_append_text (ti_width, " (cursor width)"); proto_item_append_text (ti_height, " (cursor height)"); if (encoding_type == VNC_ENCODING_TYPE_RICH_CURSOR) bytes_needed = vnc_rich_cursor_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, width, height); else bytes_needed = vnc_x_cursor_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, width, height); break; case VNC_ENCODING_TYPE_POINTER_POS: proto_item_append_text (ti_x, " (pointer X)"); proto_item_append_text (ti_y, " (pointer Y)"); proto_item_append_text (ti_width, " (unused)"); proto_item_append_text (ti_height, " (unused)"); bytes_needed = 0; break; case VNC_ENCODING_TYPE_DESKTOP_SIZE: /* There is no payload for this message type */ bytes_needed = 0; break; case VNC_ENCODING_TYPE_EXTENDED_DESK_SIZE : bytes_needed = vnc_extended_desktop_size(tvb, offset, vnc_encoding_type_tree); break; case VNC_ENCODING_TYPE_KEYBOARD_LED_STATE : /* There is no payload for this message type */ bytes_needed = 0; break; case VNC_ENCODING_TYPE_SUPPORTED_MESSAGES : bytes_needed = vnc_supported_messages(tvb, offset, vnc_encoding_type_tree, width); break; case VNC_ENCODING_TYPE_SUPPORTED_ENCODINGS : bytes_needed = vnc_supported_encodings(tvb, offset, vnc_encoding_type_tree, width, height); break; case VNC_ENCODING_TYPE_SERVER_IDENTITY : bytes_needed = vnc_server_identity(tvb, offset, vnc_encoding_type_tree, width); break; case VNC_ENCODING_TYPE_CONTEXT_INFORMATION : bytes_needed = vnc_context_information(tvb, offset, vnc_encoding_type_tree); break; case VNC_ENCODING_TYPE_SLRLE : bytes_needed = vnc_slrle_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, height); break; case VNC_ENCODING_TYPE_H264 : bytes_needed = vnc_h264_encoding(tvb, offset, vnc_encoding_type_tree); break; } /* Check if the routines above requested more bytes to * be desegmented. */ if(bytes_needed > 0) return bytes_needed; } return 0; } static uint32_t vnc_extended_desktop_size(tvbuff_t *tvb, int *offset, proto_tree *tree) { uint8_t i, num_of_screens; proto_tree *screen_tree; num_of_screens = tvb_get_uint8(tvb, *offset); proto_tree_add_item(tree, hf_vnc_desktop_screen_num, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 3, ENC_NA); VNC_BYTES_NEEDED((uint32_t)(3 + (num_of_screens * 16))); *offset += 3; for(i = 0; i < num_of_screens; i++) { screen_tree = proto_tree_add_subtree_format(tree, tvb, *offset, 16, ett_vnc_desktop_screen, NULL, "Screen #%u", i+1); proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_id, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_x, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_y, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_width, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_height, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_flags, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; } return 0; } static unsigned vnc_raw_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height) { uint8_t bytes_per_pixel = vnc_get_bytes_per_pixel(pinfo); unsigned length; length = width * height * bytes_per_pixel; VNC_BYTES_NEEDED(length); proto_tree_add_item(tree, hf_vnc_raw_pixel_data, tvb, *offset, length, ENC_NA); *offset += length; return 0; /* bytes_needed */ } static unsigned vnc_copyrect_encoding(tvbuff_t *tvb, packet_info *pinfo _U_, int *offset, proto_tree *tree, const uint16_t width _U_, const uint16_t height _U_) { proto_tree_add_item(tree, hf_vnc_copyrect_src_x_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_copyrect_src_y_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; return 0; /* bytes_needed */ } static unsigned vnc_rre_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width _U_, const uint16_t height _U_) { uint8_t bytes_per_pixel = vnc_get_bytes_per_pixel(pinfo); uint32_t num_subrects, i; unsigned bytes_needed; proto_item *ti; proto_tree *subrect_tree; VNC_BYTES_NEEDED(4); ti = proto_tree_add_item(tree, hf_vnc_rre_num_subrects, tvb, *offset, 4, ENC_BIG_ENDIAN); num_subrects = tvb_get_ntohl(tvb, *offset); *offset += 4; if (num_subrects > 10000) { expert_add_info_format(pinfo, ti, &ei_vnc_too_many_sub_rectangles, "Too many sub-rectangles (%d), aborting dissection", num_subrects); return 0; } VNC_BYTES_NEEDED(bytes_per_pixel); proto_tree_add_item(tree, hf_vnc_rre_bg_pixel, tvb, *offset, bytes_per_pixel, ENC_NA); *offset += bytes_per_pixel; /* We know we need (at least) all these bytes, so ask for them now * (instead of a few at a time...). */ bytes_needed = bytes_per_pixel + 8; VNC_BYTES_NEEDED(bytes_needed * num_subrects); for(i = 0; i < num_subrects; i++) { subrect_tree = proto_tree_add_subtree_format(tree, tvb, *offset, bytes_per_pixel + 8, ett_vnc_rre_subrect, NULL, "Subrectangle #%d", i+1); proto_tree_add_item(subrect_tree, hf_vnc_rre_subrect_pixel, tvb, *offset, bytes_per_pixel, ENC_NA); *offset += bytes_per_pixel; proto_tree_add_item(subrect_tree, hf_vnc_rre_subrect_x_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(subrect_tree, hf_vnc_rre_subrect_y_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(subrect_tree, hf_vnc_rre_subrect_width, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(subrect_tree, hf_vnc_rre_subrect_height, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; } return 0; /* bytes_needed */ } static unsigned vnc_hextile_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height) { uint8_t bytes_per_pixel = vnc_get_bytes_per_pixel(pinfo); uint8_t i, subencoding_mask, num_subrects, subrect_len, tile_height, tile_width; uint32_t raw_length; proto_tree *tile_tree, *subencoding_mask_tree, *subrect_tree, *num_subrects_tree; proto_item *ti; uint16_t current_height = 0, current_width; while(current_height != height) { if (current_height + 16 > height) tile_height = height - current_height; else tile_height = 16; current_height += tile_height; current_width = 0; while(current_width != width) { if (current_width + 16 > width) tile_width = width - current_width; else tile_width = 16; current_width += tile_width; VNC_BYTES_NEEDED(1); subencoding_mask = tvb_get_uint8(tvb, *offset); tile_tree = proto_tree_add_subtree_format(tree, tvb, *offset, 1, ett_vnc_hextile_tile, NULL, "Tile {%d:%d}, sub encoding mask %u", current_width, current_height, subencoding_mask); ti = proto_tree_add_item(tile_tree, hf_vnc_hextile_subencoding_mask, tvb, *offset, 1, ENC_BIG_ENDIAN); subencoding_mask_tree = proto_item_add_subtree(ti, ett_vnc_hextile_subencoding_mask); proto_tree_add_item(subencoding_mask_tree, hf_vnc_hextile_raw, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(subencoding_mask_tree, hf_vnc_hextile_bg, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(subencoding_mask_tree, hf_vnc_hextile_fg, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(subencoding_mask_tree, hf_vnc_hextile_anysubrects, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(subencoding_mask_tree, hf_vnc_hextile_subrectscolored, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; if(subencoding_mask & 0x1) { /* Raw */ raw_length = tile_width * tile_height * bytes_per_pixel; VNC_BYTES_NEEDED(raw_length); proto_tree_add_item(tile_tree, hf_vnc_hextile_raw_value, tvb, *offset, raw_length, ENC_NA); *offset += raw_length; } else { if(subencoding_mask & 0x2) { /* Background Specified */ VNC_BYTES_NEEDED(bytes_per_pixel); proto_tree_add_item(tile_tree, hf_vnc_hextile_bg_value, tvb, *offset, bytes_per_pixel, ENC_NA); *offset += bytes_per_pixel; } if(subencoding_mask & 0x4) { /* Foreground Specified */ VNC_BYTES_NEEDED(bytes_per_pixel); proto_tree_add_item(tile_tree, hf_vnc_hextile_fg_value, tvb, *offset, bytes_per_pixel, ENC_NA); *offset += bytes_per_pixel; } if(subencoding_mask & 0x8) { /* Any Subrects */ VNC_BYTES_NEEDED(3); /* 1 byte for number of subrects field, +2 at least for 1 subrect */ ti = proto_tree_add_item(tile_tree, hf_vnc_hextile_num_subrects, tvb, *offset, 1, ENC_BIG_ENDIAN); num_subrects = tvb_get_uint8(tvb, *offset); *offset += 1; if(subencoding_mask & 0x10) subrect_len = bytes_per_pixel + 2; else subrect_len = 2; VNC_BYTES_NEEDED((unsigned)(subrect_len * num_subrects)); num_subrects_tree = proto_item_add_subtree(ti, ett_vnc_hextile_num_subrects); for(i = 0; i < num_subrects; i++) { subrect_tree = proto_tree_add_subtree_format(num_subrects_tree, tvb, *offset, subrect_len, ett_vnc_hextile_subrect, NULL, "Subrectangle #%d", i+1); if(subencoding_mask & 0x10) { /* Subrects Colored */ proto_tree_add_item(subrect_tree, hf_vnc_hextile_subrect_pixel_value, tvb, *offset, bytes_per_pixel, ENC_NA); *offset += bytes_per_pixel; } proto_tree_add_item(subrect_tree, hf_vnc_hextile_subrect_x_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(subrect_tree, hf_vnc_hextile_subrect_y_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(subrect_tree, hf_vnc_hextile_subrect_width, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(subrect_tree, hf_vnc_hextile_subrect_height, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; } } } } } return 0; /* bytes_needed */ } static unsigned vnc_supported_messages(tvbuff_t *tvb, int *offset, proto_tree *tree, const uint16_t width) { VNC_BYTES_NEEDED(width); if (width >= 64) { proto_tree_add_item(tree, hf_vnc_supported_messages_client2server, tvb, *offset, 32, ENC_NA); *offset += 32; proto_tree_add_item(tree, hf_vnc_supported_messages_server2client, tvb, *offset, 32, ENC_NA); *offset += 32; *offset += width - 64; } else { *offset += width; } return 0; /* bytes_needed */ } static unsigned vnc_supported_encodings(tvbuff_t *tvb, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height) { uint16_t i = width; proto_tree_add_uint(tree, hf_vnc_num_supported_encodings, tvb, *offset, 0, height); VNC_BYTES_NEEDED(width); for (; i >= 4; i -= 4) { proto_tree_add_item(tree, hf_vnc_supported_encodings, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; } *offset += i; return 0; /* bytes_needed */ } static unsigned vnc_server_identity(tvbuff_t *tvb, int *offset, proto_tree *tree, const uint16_t width) { VNC_BYTES_NEEDED(width); proto_tree_add_item(tree, hf_vnc_server_identity, tvb, *offset, width, ENC_ASCII); *offset += width; return 0; /* bytes_needed */ } static unsigned vnc_mirrorlink(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree) { uint8_t type; uint16_t length; uint16_t num, i; int end; proto_tree *sub_tree; /* Header */ VNC_BYTES_NEEDED(3); type = tvb_get_uint8(tvb, *offset); proto_tree_add_item(tree, hf_vnc_mirrorlink_type, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; length = tvb_get_ntohs(tvb, *offset); proto_tree_add_item(tree, hf_vnc_mirrorlink_length, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; col_add_fstr(pinfo->cinfo, COL_INFO, "MirrorLink (%s)", val_to_str_const(type, vnc_mirrorlink_types_vs, "Unknown")); /* Payload */ end = *offset + length; switch(type) { case VNC_ML_EXT_BYE_BYE : break; case VNC_ML_EXT_SERVER_DISPLAY_CONFIGURATION : VNC_BYTES_NEEDED(12); proto_tree_add_item(tree, hf_vnc_mirrorlink_version_major, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_mirrorlink_version_minor, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_mirrorlink_framebuffer_configuration, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_pixel_width, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_pixel_height, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_pixel_format, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case VNC_ML_EXT_CLIENT_DISPLAY_CONFIGURATION : VNC_BYTES_NEEDED(14); proto_tree_add_item(tree, hf_vnc_mirrorlink_version_major, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_mirrorlink_version_minor, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_mirrorlink_framebuffer_configuration, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_pixel_width, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_pixel_height, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_display_width, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_display_height, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_display_distance, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; break; case VNC_ML_EXT_SERVER_EVENT_CONFIGURATION : case VNC_ML_EXT_CLIENT_EVENT_CONFIGURATION : VNC_BYTES_NEEDED(28); proto_tree_add_item(tree, hf_vnc_mirrorlink_keyboard_language, tvb, *offset, 2, ENC_ASCII); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_keyboard_country, tvb, *offset, 2, ENC_ASCII); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_ui_language, tvb, *offset, 2, ENC_ASCII); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_ui_country, tvb, *offset, 2, ENC_ASCII); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_knob_keys, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_mirrorlink_device_keys, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_mirrorlink_multimedia_keys, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_mirrorlink_key_related, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_mirrorlink_pointer_related, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case VNC_ML_EXT_EVENT_MAPPING : case VNC_ML_EXT_EVENT_MAPPING_REQUEST : VNC_BYTES_NEEDED(8); proto_tree_add_item(tree, hf_vnc_mirrorlink_key_symbol_value_client, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_mirrorlink_key_symbol_value_server, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case VNC_ML_EXT_KEY_EVENT_LISTING : VNC_BYTES_NEEDED(4); proto_tree_add_item(tree, hf_vnc_mirrorlink_key_configuration, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; num = tvb_get_uint8(tvb, *offset); proto_tree_add_item(tree, hf_vnc_mirrorlink_key_num_events, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(tree, hf_vnc_mirrorlink_key_event_counter, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; VNC_BYTES_NEEDED((unsigned)(4 * num)); sub_tree = proto_tree_add_subtree(tree, tvb, *offset, 4 * num, ett_vnc_key_events, NULL, "Key Event List"); for (; num > 0; num--) { proto_tree_add_item(sub_tree, hf_vnc_mirrorlink_key_symbol_value, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4 ; } break; case VNC_ML_EXT_KEY_EVENT_LISTING_REQUEST : VNC_BYTES_NEEDED(4); proto_tree_add_item(tree, hf_vnc_mirrorlink_key_request_configuration, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case VNC_ML_EXT_VIRTUAL_KEYBOARD : VNC_BYTES_NEEDED(16); proto_tree_add_item(tree, hf_vnc_mirrorlink_keyboard_configuration, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_mirrorlink_cursor_x, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_cursor_y, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_text_x, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_text_y, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_text_width, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_text_height, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; break; case VNC_ML_EXT_VIRTUAL_KEYBOARD_REQUEST : VNC_BYTES_NEEDED(4); proto_tree_add_item(tree, hf_vnc_mirrorlink_keyboard_request_configuration, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case VNC_ML_EXT_DEVICE_STATUS : case VNC_ML_EXT_DEVICE_STATUS_REQUEST : VNC_BYTES_NEEDED(4); proto_tree_add_item(tree, hf_vnc_mirrorlink_device_status, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; /* case VNC_ML_EXT_CONTENT_ATTESTATION : break; case VNC_ML_EXT_CONTENT_ATTESTATION_REQUEST : break; */ case VNC_ML_EXT_FB_BLOCKING_NOTIFICATION : VNC_BYTES_NEEDED(14); proto_tree_add_item(tree, hf_vnc_mirrorlink_fb_block_x, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_fb_block_y, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_fb_block_width, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_fb_block_height, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_mirrorlink_app_id, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_mirrorlink_fb_block_reason, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; break; case VNC_ML_EXT_AUDIO_BLOCKING_NOTIFICATION : VNC_BYTES_NEEDED(6); proto_tree_add_item(tree, hf_vnc_mirrorlink_app_id, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_mirrorlink_audio_block_reason, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; break; case VNC_ML_EXT_TOUCH_EVENT : VNC_BYTES_NEEDED(1); num = tvb_get_uint8(tvb, *offset); proto_tree_add_item(tree, hf_vnc_mirrorlink_touch_num_events, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; VNC_BYTES_NEEDED((unsigned)(6 * num)); /*sub_tree = proto_item_add_subtree(tree, ett_vnc_touch_events);*/ for (i = 0; i < num; i++) { sub_tree = proto_tree_add_subtree_format(tree, tvb, *offset, 6, ett_vnc_touch_events, NULL, "Touch Event #%d", i + 1); proto_tree_add_item(sub_tree, hf_vnc_mirrorlink_touch_x, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(sub_tree, hf_vnc_mirrorlink_touch_y, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(sub_tree, hf_vnc_mirrorlink_touch_id, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; proto_tree_add_item(sub_tree, hf_vnc_mirrorlink_touch_pressure, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; } break; case VNC_ML_EXT_FB_ALTERNATIVE_TEXT : VNC_BYTES_NEEDED(6); proto_tree_add_item(tree, hf_vnc_mirrorlink_app_id, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; num = tvb_get_ntohs(tvb, *offset); proto_tree_add_item(tree, hf_vnc_mirrorlink_text_length, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; VNC_BYTES_NEEDED(num); proto_tree_add_item(tree, hf_vnc_mirrorlink_text, tvb, *offset, num, ENC_ASCII); *offset += num; break; case VNC_ML_EXT_FB_ALTERNATIVE_TEXT_REQUEST : VNC_BYTES_NEEDED(2); proto_tree_add_item(tree, hf_vnc_mirrorlink_text_max_length, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; break; } if (end > *offset) { length = end - *offset; VNC_BYTES_NEEDED(length); proto_tree_add_item(tree, hf_vnc_mirrorlink_unknown, tvb, *offset, length, ENC_NA); *offset = end; } return 0; /* bytes_needed */ } static unsigned vnc_fence(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree) { unsigned payload_length; VNC_BYTES_NEEDED(8); payload_length = tvb_get_uint8(tvb, *offset+7); VNC_BYTES_NEEDED((8+payload_length)); col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Fence"); proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 3, ENC_NA); *offset += 3; /* skip padding */ proto_tree_add_bitmask(tree, tvb, *offset, hf_vnc_fence_flags, ett_vnc_fence_flags, vnc_fence_flags, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_fence_payload_length, tvb, *offset, 1, ENC_BIG_ENDIAN); *offset += 1; if (payload_length > 0) { proto_tree_add_item(tree, hf_vnc_fence_payload, tvb, *offset, payload_length, ENC_NA); *offset += payload_length; } return 0; } static unsigned vnc_context_information(tvbuff_t *tvb, int *offset, proto_tree *tree) { VNC_BYTES_NEEDED(20); proto_tree_add_item(tree, hf_vnc_context_information_app_id, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_context_information_app_trust_level, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_context_information_content_trust_level, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_vnc_context_information_app_category, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_context_information_content_category, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_context_information_content_rules, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; return 0; /* bytes_needed */ } static unsigned vnc_slrle_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t height) { uint8_t depth = vnc_get_depth(pinfo); uint8_t depth_mod = depth % 8; uint8_t bytes_per_run; uint16_t num_runs, i; unsigned length; proto_tree *sub_tree; if (depth_mod <= 4) bytes_per_run = ( 8 - depth_mod + depth) / 8; else bytes_per_run = (16 - depth_mod + depth) / 8; for (i = 0; i < height; i++) { VNC_BYTES_NEEDED(2); num_runs = tvb_get_ntohs(tvb, *offset); length = num_runs * bytes_per_run; sub_tree = proto_tree_add_subtree_format(tree, tvb, *offset, 2 + length, ett_vnc_slrle_subline, NULL, "Scanline #%d", i+1); proto_tree_add_item(sub_tree, hf_vnc_slrle_run_num, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; VNC_BYTES_NEEDED(length); proto_tree_add_item(sub_tree, hf_vnc_slrle_run_data, tvb, *offset, length, ENC_NA); *offset += length; } return 0; /* bytes_needed */ } static unsigned vnc_h264_encoding(tvbuff_t *tvb, int *offset, proto_tree *tree) { uint32_t nbytes; VNC_BYTES_NEEDED(16); nbytes = tvb_get_ntohl(tvb, *offset); proto_tree_add_item(tree, hf_vnc_h264_nbytes, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; /*0 == P-Frame; 1 == B-Frame; 2 == I-Frame*/ proto_tree_add_item(tree, hf_vnc_h264_slice_type, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_h264_width, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_vnc_h264_height, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; VNC_BYTES_NEEDED(nbytes); proto_tree_add_item(tree, hf_vnc_h264_data, tvb, *offset, nbytes, ENC_NA); *offset += nbytes; return 0; /* bytes_needed */ } #if defined(HAVE_ZLIB) || defined(HAVE_ZLIBNG) static unsigned vnc_zrle_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height) #else static unsigned vnc_zrle_encoding(tvbuff_t *tvb, packet_info *pinfo _U_, int *offset, proto_tree *tree, const uint16_t width _U_, const uint16_t height _U_) #endif { uint32_t data_len; #if defined (HAVE_ZLIB) || defined (HAVE_ZLIBNG) uint8_t palette_size; uint8_t bytes_per_cpixel = vnc_get_bytes_per_pixel(pinfo); int uncomp_offset = 0; unsigned length; int subencoding_type; tvbuff_t *uncomp_tvb; proto_tree *zrle_subencoding_tree; proto_item *ti; #endif VNC_BYTES_NEEDED(4); proto_tree_add_item(tree, hf_vnc_zrle_len, tvb, *offset, 4, ENC_BIG_ENDIAN); data_len = tvb_get_ntohl(tvb, *offset); *offset += 4; VNC_BYTES_NEEDED(data_len); proto_tree_add_item(tree, hf_vnc_zrle_data, tvb, *offset, data_len, ENC_NA); #if defined (HAVE_ZLIB) || defined (HAVE_ZLIBNG) uncomp_tvb = tvb_child_uncompress_zlib(tvb, tvb, *offset, data_len); if(uncomp_tvb != NULL) { add_new_data_source(pinfo, uncomp_tvb, "Uncompressed ZRLE data"); ti = proto_tree_add_item(tree, hf_vnc_zrle_subencoding, uncomp_tvb, uncomp_offset, 1, ENC_BIG_ENDIAN); zrle_subencoding_tree = proto_item_add_subtree(ti, ett_vnc_zrle_subencoding); proto_tree_add_item(zrle_subencoding_tree, hf_vnc_zrle_rle, uncomp_tvb, uncomp_offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(zrle_subencoding_tree, hf_vnc_zrle_palette_size, uncomp_tvb, uncomp_offset, 1, ENC_BIG_ENDIAN); subencoding_type = tvb_get_uint8(uncomp_tvb, uncomp_offset); palette_size = subencoding_type & 0x7F; uncomp_offset += 1; if(subencoding_type == 0) { /* Raw */ length = width * height * bytes_per_cpixel; VNC_BYTES_NEEDED(length); /* XXX - not working yet! */ proto_tree_add_item(zrle_subencoding_tree, hf_vnc_zrle_raw, uncomp_tvb, uncomp_offset, length, ENC_NA); } else if(subencoding_type >= 130 && subencoding_type <= 255) { length = palette_size * bytes_per_cpixel; VNC_BYTES_NEEDED(length); proto_tree_add_item(zrle_subencoding_tree, hf_vnc_zrle_palette, uncomp_tvb, uncomp_offset, length, ENC_NA); /* XXX - Not complete! */ } } else { proto_tree_add_expert(tree, pinfo, &ei_vnc_zrle_failed, tvb, *offset, data_len); } #endif /* HAVE_ZLIB */ *offset += data_len; return 0; /* bytes_needed */ } static unsigned read_compact_len(tvbuff_t *tvb, int *offset, int *length, int *value_length) { int b; VNC_BYTES_NEEDED(1); *value_length = 0; b = tvb_get_uint8(tvb, *offset); *offset += 1; *value_length += 1; *length = b & 0x7f; if ((b & 0x80) != 0) { VNC_BYTES_NEEDED(1); b = tvb_get_uint8(tvb, *offset); *offset += 1; *value_length += 1; *length |= (b & 0x7f) << 7; if ((b & 0x80) != 0) { VNC_BYTES_NEEDED (1); b = tvb_get_uint8(tvb, *offset); *offset += 1; *value_length += 1; *length |= (b & 0xff) << 14; } } return 0; } static unsigned process_compact_length_and_image_data(tvbuff_t *tvb, int *offset, proto_tree *tree) { unsigned bytes_needed; unsigned length, value_length; bytes_needed = read_compact_len (tvb, offset, &length, &value_length); if (bytes_needed != 0) return bytes_needed; proto_tree_add_uint(tree, hf_vnc_tight_image_len, tvb, *offset - value_length, value_length, length); VNC_BYTES_NEEDED(length); proto_tree_add_item(tree, hf_vnc_tight_image_data, tvb, *offset, length, ENC_NA); *offset += length; return 0; /* bytes_needed */ } static unsigned process_tight_rect_filter_palette(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, int *bits_per_pixel) { vnc_packet_t *per_packet_info; int num_colors; unsigned palette_bytes; /* See TightVNC's vnc_unixsrc/vncviewer/tight.c:InitFilterPaletteBPP() */ per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); /* Our calling function should have set the packet's proto data already */ DISSECTOR_ASSERT(per_packet_info != NULL); VNC_BYTES_NEEDED(1); proto_tree_add_item(tree, hf_vnc_tight_palette_num_colors, tvb, *offset, 1, ENC_BIG_ENDIAN); num_colors = tvb_get_uint8(tvb, *offset); *offset += 1; num_colors++; if (num_colors < 2) return 0; if (per_packet_info->depth == 24) palette_bytes = num_colors * 3; else palette_bytes = num_colors * per_packet_info->depth / 8; VNC_BYTES_NEEDED(palette_bytes); proto_tree_add_item(tree, hf_vnc_tight_palette_data, tvb, *offset, palette_bytes, ENC_NA); *offset += palette_bytes; /* This is the number of bits per pixel *in the image data*, not the actual client depth */ if (num_colors == 2) *bits_per_pixel = 1; else *bits_per_pixel = 8; return 0; } static unsigned vnc_tight_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width _U_, const uint16_t height _U_) { vnc_packet_t *per_packet_info; uint8_t comp_ctl; proto_item *compression_type_ti; int bit_offset; int bytes_needed = -1; per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); /* Our calling function should have set the packet's proto data already */ DISSECTOR_ASSERT(per_packet_info != NULL); /* See xserver/hw/vnc/rfbproto.h and grep for "Tight Encoding." for the following layout */ VNC_BYTES_NEEDED(1); /* least significant bits 0-3 are "reset compression stream N" */ bit_offset = *offset * 8; proto_tree_add_bits_item(tree, hf_vnc_tight_reset_stream0, tvb, bit_offset + 7, 1, ENC_BIG_ENDIAN); proto_tree_add_bits_item(tree, hf_vnc_tight_reset_stream1, tvb, bit_offset + 6, 1, ENC_BIG_ENDIAN); proto_tree_add_bits_item(tree, hf_vnc_tight_reset_stream2, tvb, bit_offset + 5, 1, ENC_BIG_ENDIAN); proto_tree_add_bits_item(tree, hf_vnc_tight_reset_stream3, tvb, bit_offset + 4, 1, ENC_BIG_ENDIAN); /* most significant bits 4-7 are "compression type" */ compression_type_ti = proto_tree_add_bits_item(tree, hf_vnc_tight_rect_type, tvb, bit_offset + 0, 4, ENC_BIG_ENDIAN); comp_ctl = tvb_get_uint8(tvb, *offset); *offset += 1; comp_ctl >>= 4; /* skip over the "reset compression" bits from above */ /* compression format */ if (comp_ctl == TIGHT_RECT_FILL) { /* "fill" encoding (solid rectangle) */ proto_item_append_text(compression_type_ti, " (fill encoding - solid rectangle)"); if (per_packet_info->depth == 24) { VNC_BYTES_NEEDED(3); proto_tree_add_item(tree, hf_vnc_tight_fill_color, tvb, *offset, 3, ENC_NA); *offset += 3; } else { VNC_BYTES_NEEDED(per_packet_info->bytes_per_pixel); proto_tree_add_item(tree, hf_vnc_tight_fill_color, tvb, *offset, per_packet_info->bytes_per_pixel, ENC_NA); *offset += per_packet_info->bytes_per_pixel; } bytes_needed = 0; } else if (comp_ctl == TIGHT_RECT_JPEG) { /* jpeg encoding */ proto_item_append_text(compression_type_ti, " (JPEG encoding)"); bytes_needed = process_compact_length_and_image_data(tvb, offset, tree); if (bytes_needed != 0) return bytes_needed; } else if (comp_ctl > TIGHT_RECT_MAX_VALUE) { /* invalid encoding */ expert_add_info(pinfo, compression_type_ti, &ei_vnc_invalid_encoding); } else { unsigned row_size; int bits_per_pixel; /* basic encoding */ proto_item_append_text(compression_type_ti, " (basic encoding)"); proto_tree_add_bits_item(tree, hf_vnc_tight_filter_flag, tvb, bit_offset + 1, 1, ENC_BIG_ENDIAN); bits_per_pixel = per_packet_info->depth; if ((comp_ctl & TIGHT_RECT_EXPLICIT_FILTER_FLAG) != 0) { uint8_t filter_id; /* explicit filter */ VNC_BYTES_NEEDED(1); proto_tree_add_item(tree, hf_vnc_tight_filter_id, tvb, *offset, 1, ENC_BIG_ENDIAN); filter_id = tvb_get_uint8(tvb, *offset); *offset += 1; switch (filter_id) { case TIGHT_RECT_FILTER_COPY: /* nothing to do */ break; case TIGHT_RECT_FILTER_PALETTE: bytes_needed = process_tight_rect_filter_palette(tvb, pinfo, offset, tree, &bits_per_pixel); if (bytes_needed != 0) return bytes_needed; break; case TIGHT_RECT_FILTER_GRADIENT: /* nothing to do */ break; } } else { /* this is the same case as TIGHT_RECT_FILTER_COPY, so there's nothing special to do */ } row_size = ((unsigned) width * bits_per_pixel + 7) / 8; if (row_size * height < TIGHT_MIN_BYTES_TO_COMPRESS) { unsigned num_bytes; /* The data is not compressed; just skip over it */ num_bytes = row_size * height; VNC_BYTES_NEEDED(num_bytes); proto_tree_add_item(tree, hf_vnc_tight_image_data, tvb, *offset, num_bytes, ENC_NA); *offset += num_bytes; bytes_needed = 0; } else { /* The data is compressed; read its length and data */ bytes_needed = process_compact_length_and_image_data(tvb, offset, tree); if (bytes_needed != 0) return bytes_needed; } } DISSECTOR_ASSERT(bytes_needed != -1); return bytes_needed; } static unsigned decode_cursor(tvbuff_t *tvb, int *offset, proto_tree *tree, unsigned pixels_bytes, unsigned mask_bytes) { unsigned total_bytes; total_bytes = pixels_bytes + mask_bytes; VNC_BYTES_NEEDED (total_bytes); proto_tree_add_item(tree, hf_vnc_cursor_encoding_pixels, tvb, *offset, pixels_bytes, ENC_NA); *offset += pixels_bytes; proto_tree_add_item(tree, hf_vnc_cursor_encoding_bitmask, tvb, *offset, mask_bytes, ENC_NA); *offset += mask_bytes; return 0; /* bytes_needed */ } static unsigned vnc_rich_cursor_encoding(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height) { uint8_t bytes_per_pixel = vnc_get_bytes_per_pixel(pinfo); unsigned pixels_bytes, mask_bytes; pixels_bytes = width * height * bytes_per_pixel; mask_bytes = ((width + 7) / 8) * height; return decode_cursor(tvb, offset, tree, pixels_bytes, mask_bytes); } static unsigned vnc_x_cursor_encoding(tvbuff_t *tvb, packet_info *pinfo _U_, int *offset, proto_tree *tree, const uint16_t width, const uint16_t height) { int bitmap_row_bytes = (width + 7) / 8; int mask_bytes = bitmap_row_bytes * height; VNC_BYTES_NEEDED (6); proto_tree_add_item(tree, hf_vnc_cursor_x_fore_back, tvb, *offset, 6, ENC_NA); *offset += 6; /* The length of the pixel data is the same as the length of the mask data (X cursors are strictly black/white) */ return decode_cursor(tvb, offset, tree, mask_bytes, mask_bytes); } static unsigned vnc_server_set_colormap_entries(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree) { uint16_t number_of_colors; unsigned counter, bytes_needed; proto_item *ti; proto_tree *vnc_colormap_num_groups, *vnc_colormap_color_group; col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Server set colormap entries"); number_of_colors = tvb_get_ntohs(tvb, 4); VNC_BYTES_NEEDED(3); proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 1, ENC_NA); *offset += 1; /* Skip over 1 byte of padding */ proto_tree_add_item(tree, hf_vnc_colormap_first_color, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; /* XXX - this is 3 bytes into the tvb, but number_of_colors is set off * of 4 bytes in... Bug??? */ ti = proto_tree_add_item(tree, hf_vnc_colormap_num_colors, tvb, *offset, 2, ENC_BIG_ENDIAN); if (number_of_colors > 10000) { expert_add_info_format(pinfo, ti, &ei_vnc_too_many_colors,"Too many colors (%d), aborting dissection", number_of_colors); return 0; } bytes_needed = (number_of_colors * 6) + 5; VNC_BYTES_NEEDED(bytes_needed); *offset += 2; ti = proto_tree_add_item(tree, hf_vnc_color_groups, tvb, *offset, number_of_colors * 6, ENC_NA); vnc_colormap_num_groups = proto_item_add_subtree(ti, ett_vnc_colormap_num_groups); for(counter = 0; counter < number_of_colors; counter++) { vnc_colormap_color_group = proto_tree_add_subtree_format(vnc_colormap_num_groups, tvb, *offset, 6, ett_vnc_colormap_color_group, NULL, "Color group #%d", counter+1); proto_tree_add_item(vnc_colormap_color_group, hf_vnc_colormap_red, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(vnc_colormap_color_group, hf_vnc_colormap_green, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(vnc_colormap_color_group, hf_vnc_colormap_blue, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; } return 0; } static void vnc_server_ring_bell(tvbuff_t *tvb _U_, packet_info *pinfo, int *offset _U_, proto_tree *tree _U_) { col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Server ring bell on client"); /* This message type has no payload... */ } static unsigned vnc_server_cut_text(tvbuff_t *tvb, packet_info *pinfo, int *offset, proto_tree *tree) { uint32_t text_len; proto_item *pi; col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Server cut text"); text_len = tvb_get_ntohl(tvb, *offset); pi = proto_tree_add_item(tree, hf_vnc_server_cut_text_len, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; if (text_len > 100000) { expert_add_info_format(pinfo, pi, &ei_vnc_too_many_cut_text, "Too much cut text (%d), aborting dissection", text_len); return 0; } VNC_BYTES_NEEDED(text_len); proto_tree_add_item(tree, hf_vnc_server_cut_text, tvb, *offset, text_len, ENC_ASCII); *offset += text_len; return *offset; } static void vnc_set_bytes_per_pixel(packet_info *pinfo, vnc_conversation_t *per_conversation_info, const uint8_t bytes_per_pixel) { if (PINFO_FD_VISITED(pinfo)) { return; } vnc_packet_t *per_packet_info; per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); /* Our calling function should have set the packet's proto data already */ DISSECTOR_ASSERT(per_packet_info != NULL); per_packet_info->bytes_per_pixel = per_conversation_info->bytes_per_pixel = bytes_per_pixel; } static void vnc_set_depth(packet_info *pinfo, vnc_conversation_t *per_conversation_info, const uint8_t depth) { if (PINFO_FD_VISITED(pinfo)) { return; } vnc_packet_t *per_packet_info; per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); /* Our calling function should have set the packet's proto data already */ DISSECTOR_ASSERT(per_packet_info != NULL); per_packet_info->depth = per_conversation_info->depth = depth; } static uint8_t vnc_get_bytes_per_pixel(packet_info *pinfo) { vnc_packet_t *per_packet_info; per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); /* Our calling function should have set the packet's proto data already */ DISSECTOR_ASSERT(per_packet_info != NULL); return per_packet_info->bytes_per_pixel; } static uint8_t vnc_get_depth(packet_info *pinfo) { vnc_packet_t *per_packet_info; per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); /* Our calling function should have set the packet's proto data already */ DISSECTOR_ASSERT(per_packet_info != NULL); return per_packet_info->depth; } /* Preference callbacks */ static void apply_vnc_prefs(void) { vnc_tcp_range = prefs_get_range_value("vnc", "tcp.port"); } /* Register the protocol with Wireshark */ void proto_register_vnc(void) { module_t *vnc_module; /* To handle our preferences */ expert_module_t* expert_vnc; /* Setup list of header fields */ static hf_register_info hf[] = { { &hf_vnc_padding, { "Padding", "vnc.padding", FT_NONE, BASE_NONE, NULL, 0x0, "Unused space", HFILL } }, { &hf_vnc_server_proto_ver, { "Server protocol version", "vnc.server_proto_ver", FT_STRING, BASE_NONE, NULL, 0x0, "VNC protocol version on server", HFILL } }, { &hf_vnc_client_proto_ver, { "Client protocol version", "vnc.client_proto_ver", FT_STRING, BASE_NONE, NULL, 0x0, "VNC protocol version on client", HFILL } }, { &hf_vnc_num_security_types, { "Number of security types", "vnc.num_security_types", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of security (authentication) types supported by the server", HFILL } }, { &hf_vnc_security_type, { "Security type", "vnc.security_type", FT_UINT8, BASE_DEC, VALS(vnc_security_types_vs), 0x0, "Security types offered by the server (VNC versions => 3.007)", HFILL } }, { &hf_vnc_server_security_type, { "Security type", "vnc.server_security_type", FT_UINT32, BASE_DEC, VALS(vnc_security_types_vs), 0x0, "Security type mandated by the server", HFILL } }, { &hf_vnc_client_security_type, { "Security type selected", "vnc.client_security_type", FT_UINT8, BASE_DEC, VALS(vnc_security_types_vs), 0x0, "Security type selected by the client", HFILL } }, { &hf_vnc_tight_num_tunnel_types, { "Number of supported tunnel types", "vnc.num_tunnel_types", FT_UINT32, BASE_DEC, NULL, 0x0, "Number of tunnel types for TightVNC", HFILL } }, { &hf_vnc_tight_tunnel_type_code, { "Tunnel type code", "vnc.tunnel_type_code", FT_UINT32, BASE_DEC, NULL, 0x0, "Tunnel type code specific to TightVNC", HFILL } }, { &hf_vnc_tight_tunnel_type_vendor, { "Tunnel type vendor", "vnc.tunnel_type_vendor", FT_STRING, BASE_NONE, NULL, 0x0, "Tunnel type vendor specific to TightVNC", HFILL } }, { &hf_vnc_tight_tunnel_type_signature, { "Tunnel type signature", "vnc.tunnel_type_signature", FT_STRING, BASE_NONE, NULL, 0x0, "Tunnel type signature specific to TightVNC", HFILL } }, { &hf_vnc_tight_num_auth_types, { "Number of supported authentication types", "vnc.num_auth_types", FT_UINT32, BASE_DEC, NULL, 0x0, "Authentication types specific to TightVNC", HFILL } }, { &hf_vnc_tight_auth_code, { "Authentication code", "vnc.tight_auth_code", FT_UINT32, BASE_DEC, VALS(vnc_security_types_vs), 0x0, "Authentication code specific to TightVNC", HFILL } }, { &hf_vnc_tight_server_message_type, { "Server message type (TightVNC)", "vnc.tight_server_message_type", FT_INT32, BASE_DEC, NULL, 0x0, "Server message type specific to TightVNC", HFILL } }, { &hf_vnc_tight_server_vendor, { "Server vendor code", "vnc.server_vendor", FT_STRING, BASE_NONE, NULL, 0x0, "Server vendor code specific to TightVNC", HFILL } }, { &hf_vnc_tight_signature, { "Signature", "vnc.signature", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_tight_server_name, { "Server name", "vnc.server_name", FT_STRING, BASE_NONE, NULL, 0x0, "Server name specific to TightVNC", HFILL } }, { &hf_vnc_tight_client_message_type, { "Client message type (TightVNC)", "vnc.tight_client_message_type", FT_INT32, BASE_DEC, NULL, 0x0, "Client message type specific to TightVNC", HFILL } }, { &hf_vnc_tight_client_vendor, { "Client vendor code", "vnc.client_vendor", FT_STRING, BASE_NONE, NULL, 0x0, "Client vendor code specific to TightVNC", HFILL } }, { &hf_vnc_tight_client_name, { "Client name", "vnc.client_name", FT_STRING, BASE_NONE, NULL, 0x0, "Client name specific to TightVNC", HFILL } }, { &hf_vnc_tight_encoding_type, { "Encoding type", "vnc.encoding_type", FT_INT32, BASE_DEC, VALS(encoding_types_vs), 0x0, "Encoding type specific to TightVNC", HFILL } }, { &hf_vnc_tight_encoding_vendor, { "Encoding vendor code", "vnc.encoding_vendor", FT_STRING, BASE_NONE, NULL, 0x0, "Encoding vendor code specific to TightVNC", HFILL } }, { &hf_vnc_tight_encoding_name, { "Encoding name", "vnc.encoding_name", FT_STRING, BASE_NONE, NULL, 0x0, "Encoding name specific to TightVNC", HFILL } }, { &hf_vnc_tight_reset_stream0, { "Reset compression stream 0", "vnc.tight_reset_stream0", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Tight compression, reset compression stream 0", HFILL } }, { &hf_vnc_tight_reset_stream1, { "Reset compression stream 1", "vnc.tight_reset_stream1", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Tight compression, reset compression stream 1", HFILL } }, { &hf_vnc_tight_reset_stream2, { "Reset compression stream 2", "vnc.tight_reset_stream2", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Tight compression, reset compression stream 2", HFILL } }, { &hf_vnc_tight_reset_stream3, { "Reset compression stream 3", "vnc.tight_reset_stream3", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Tight compression, reset compression stream 3", HFILL } }, { &hf_vnc_tight_rect_type, { "Rectangle type", "vnc.tight_rect_type", FT_UINT8, BASE_HEX, NULL, 0x0, "Tight compression, rectangle type", HFILL } }, { &hf_vnc_tight_image_len, { "Image data length", "vnc.tight_image_len", FT_UINT32, BASE_DEC, NULL, 0x0, "Tight compression, length of image data", HFILL } }, { &hf_vnc_tight_image_data, { "Image data", "vnc.tight_image_data", FT_BYTES, BASE_NONE, NULL, 0x0, "Tight compression, image data", HFILL } }, { &hf_vnc_tight_fill_color, { "Fill color (RGB)", "vnc.tight_fill_color", FT_BYTES, BASE_NONE, NULL, 0x0, "Tight compression, fill color for solid rectangle", HFILL } }, { &hf_vnc_tight_filter_flag, { "Explicit filter flag", "vnc.tight_filter_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Tight compression, explicit filter flag", HFILL } }, { &hf_vnc_tight_filter_id, { "Filter ID", "vnc.tight_filter_id", FT_UINT8, BASE_DEC, VALS(tight_filter_ids_vs), 0x0, "Tight compression, filter ID", HFILL } }, { &hf_vnc_tight_palette_num_colors, { "Number of colors in palette", "vnc.tight_palette_num_colors", FT_UINT8, BASE_DEC, NULL, 0x0, "Tight compression, number of colors in rectangle's palette", HFILL } }, { &hf_vnc_tight_palette_data, { "Palette data", "vnc.tight_palette_data", FT_BYTES, BASE_NONE, NULL, 0x0, "Tight compression, palette data for a rectangle", HFILL } }, { &hf_vnc_auth_challenge, { "Authentication challenge", "vnc.auth_challenge", FT_BYTES, BASE_NONE, NULL, 0x0, "Random authentication challenge from server to client", HFILL } }, { &hf_vnc_auth_response, { "Authentication response", "vnc.auth_response", FT_BYTES, BASE_NONE, NULL, 0x0, "Client's encrypted response to the server's authentication challenge", HFILL } }, { &hf_vnc_auth_result, { "Authentication result", "vnc.auth_result", FT_BOOLEAN, 32, TFS(&auth_result_tfs), 0x1, NULL, HFILL } }, { &hf_vnc_auth_error_length, { "Length of authentication error", "vnc.auth_error_len", FT_UINT32, BASE_DEC, NULL, 0x0, "Authentication error length (present only if the authentication result is fail)", HFILL } }, { &hf_vnc_auth_error, { "Authentication error", "vnc.auth_error", FT_STRING, BASE_NONE, NULL, 0x0, "Authentication error (present only if the authentication result is fail)", HFILL } }, { &hf_vnc_ard_auth_generator, { "Generator", "vnc.ard_auth_generator", FT_UINT16, BASE_DEC, NULL, 0x0, "Generator for Diffie-Hellman key exchange", HFILL } }, { &hf_vnc_ard_auth_key_len, { "Key length", "vnc.ard_auth_key_len", FT_UINT16, BASE_DEC, NULL, 0x0, "Diffie-Hellman key length", HFILL } }, { &hf_vnc_ard_auth_modulus, { "Prime modulus", "vnc.ard_auth_modulus", FT_BYTES, BASE_NONE, NULL, 0x0, "Prime modulus for Diffie-Hellman key exchange", HFILL } }, { &hf_vnc_ard_auth_server_key, { "Server public key", "vnc.ard_auth_server_key", FT_BYTES, BASE_NONE, NULL, 0x0, "Server's public Diffie-Hellman key", HFILL } }, { &hf_vnc_ard_auth_credentials, { "Encrypted credentials", "vnc.ard_auth_credentials", FT_BYTES, BASE_NONE, NULL, 0x0, "Encrypted client username and password", HFILL } }, { &hf_vnc_ard_auth_client_key, { "Client public key", "vnc.ard_auth_client_key", FT_BYTES, BASE_NONE, NULL, 0x0, "Client's public Diffie-Hellman key", HFILL } }, { &hf_vnc_vencrypt_server_major_ver, { "VeNCrypt server major version", "vnc.vencrypt_server_major_ver", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_vencrypt_server_minor_ver, { "VeNCrypt server minor version", "vnc.vencrypt_server_minor_ver", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_vencrypt_client_major_ver, { "VeNCrypt client major version", "vnc.vencrypt_client_major_ver", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_vencrypt_client_minor_ver, { "VeNCrypt client minor version", "vnc.vencrypt_client_minor_ver", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_vencrypt_version_ack, { "VeNCrypt version ack", "vnc.vencrypt_version_ack", FT_BOOLEAN, 8, TFS(&tfs_error_ok), 0xFF, NULL, HFILL } }, { &hf_vnc_vencrypt_auth_type, { "VeNCrypt authentication type", "vnc.vencrypt_auth_type", FT_UINT32, BASE_DEC, VALS(vnc_vencrypt_auth_types_vs), 0x0, "Authentication type specific to VeNCrypt", HFILL } }, { &hf_vnc_vencrypt_num_auth_types, { "VeNCrypt Number of supported authentication types", "vnc.vencrypt_num_auth_types", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_vencrypt_auth_type_ack, { "VeNCrypt Authorization type ack", "vnc.vencrypt_auth_type_ack", FT_BOOLEAN, 8, TFS(&tfs_ok_error), 0xFF, NULL, HFILL } }, { &hf_vnc_share_desktop_flag, { "Share desktop flag", "vnc.share_desktop_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Client's desire to share the server's desktop with other clients", HFILL } }, { &hf_vnc_width, { "Framebuffer width", "vnc.width", FT_UINT16, BASE_DEC, NULL, 0x0, "Width of the framebuffer (screen) in pixels", HFILL } }, { &hf_vnc_height, { "Framebuffer height", "vnc.height", FT_UINT16, BASE_DEC, NULL, 0x0, "Height of the framebuffer (screen) in pixels", HFILL } }, { &hf_vnc_server_bits_per_pixel, { "Bits per pixel", "vnc.server_bits_per_pixel", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of bits used by server for each pixel value on the wire from the server", HFILL } }, { &hf_vnc_server_depth, { "Depth", "vnc.server_depth", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of useful bits in the pixel value on server", HFILL } }, { &hf_vnc_server_big_endian_flag, { "Big endian flag", "vnc.server_big_endian_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "True if multi-byte pixels are interpreted as big endian by server", HFILL } }, { &hf_vnc_server_true_color_flag, { "True color flag", "vnc.server_true_color_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "If true, then the next six items specify how to extract the red, green and blue intensities from the pixel value on the server.", HFILL } }, { &hf_vnc_server_red_max, { "Red maximum", "vnc.server_red_max", FT_UINT16, BASE_DEC, NULL, 0x0, "Maximum red value on server as n: 2^n - 1", HFILL } }, { &hf_vnc_server_green_max, { "Green maximum", "vnc.server_green_max", FT_UINT16, BASE_DEC, NULL, 0x0, "Maximum green value on server as n: 2^n - 1", HFILL } }, { &hf_vnc_server_blue_max, { "Blue maximum", "vnc.server_blue_max", FT_UINT16, BASE_DEC, NULL, 0x0, "Maximum blue value on server as n: 2^n - 1", HFILL } }, { &hf_vnc_server_red_shift, { "Red shift", "vnc.server_red_shift", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of shifts needed to get the red value in a pixel to the least significant bit on the server", HFILL } }, { &hf_vnc_server_green_shift, { "Green shift", "vnc.server_green_shift", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of shifts needed to get the green value in a pixel to the least significant bit on the server", HFILL } }, { &hf_vnc_server_blue_shift, { "Blue shift", "vnc.server_blue_shift", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of shifts needed to get the blue value in a pixel to the least significant bit on the server", HFILL } }, { &hf_vnc_desktop_name_len, { "Desktop name length", "vnc.desktop_name_len", FT_UINT32, BASE_DEC, NULL, 0x0, "Length of desktop name in bytes", HFILL } }, { &hf_vnc_desktop_screen_num, { "Number of screens", "vnc.screen_num", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_desktop_screen_id, { "Screen ID", "vnc.screen_id", FT_UINT32, BASE_DEC, NULL, 0x0, "ID of screen", HFILL } }, { &hf_vnc_desktop_screen_x, { "Screen X position", "vnc.screen_x", FT_UINT16, BASE_DEC, NULL, 0x0, "X coordinate of screen", HFILL } }, { &hf_vnc_desktop_screen_y, { "Screen Y position", "vnc.screen_y", FT_UINT16, BASE_DEC, NULL, 0x0, "Y coordinate of screen", HFILL } }, { &hf_vnc_desktop_screen_width, { "Screen width", "vnc.screen_width", FT_UINT16, BASE_DEC, NULL, 0x0, "Width of screen", HFILL } }, { &hf_vnc_desktop_screen_height, { "Screen height", "vnc.screen_height", FT_UINT16, BASE_DEC, NULL, 0x0, "Height of screen", HFILL } }, { &hf_vnc_desktop_screen_flags, { "Screen flags", "vnc.screen_flags", FT_UINT32, BASE_DEC, NULL, 0x0, "Flags of screen", HFILL } }, { &hf_vnc_desktop_name, { "Desktop name", "vnc.desktop_name", FT_STRING, BASE_NONE, NULL, 0x0, "Name of the VNC desktop on the server", HFILL } }, { &hf_vnc_num_server_message_types, { "Server message types", "vnc.num_server_message_types", FT_UINT16, BASE_DEC, NULL, 0x0, "Unknown", HFILL } /* XXX - Needs description */ }, { &hf_vnc_num_client_message_types, { "Client message types", "vnc.num_client_message_types", FT_UINT16, BASE_DEC, NULL, 0x0, "Unknown", HFILL } /* XXX - Needs description */ }, { &hf_vnc_num_encoding_types, { "Encoding types", "vnc.num_encoding_types", FT_UINT16, BASE_DEC, NULL, 0x0, "Unknown", HFILL } /* XXX - Needs description */ }, { &hf_vnc_client_message_type, { "Client Message Type", "vnc.client_message_type", FT_UINT8, BASE_DEC, VALS(vnc_client_message_types_vs), 0x0, "Message type from client", HFILL } }, { &hf_vnc_client_bits_per_pixel, { "Bits per pixel", "vnc.client_bits_per_pixel", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of bits used by server for each pixel value on the wire from the client", HFILL } }, { &hf_vnc_client_depth, { "Depth", "vnc.client_depth", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of useful bits in the pixel value on client", HFILL } }, { &hf_vnc_client_big_endian_flag, { "Big endian flag", "vnc.client_big_endian_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "True if multi-byte pixels are interpreted as big endian by client", HFILL } }, { &hf_vnc_client_true_color_flag, { "True color flag", "vnc.client_true_color_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "If true, then the next six items specify how to extract the red, green and blue intensities from the pixel value on the client.", HFILL } }, { &hf_vnc_client_red_max, { "Red maximum", "vnc.client_red_max", FT_UINT16, BASE_DEC, NULL, 0x0, "Maximum red value on client as n: 2^n - 1", HFILL } }, { &hf_vnc_client_green_max, { "Green maximum", "vnc.client_green_max", FT_UINT16, BASE_DEC, NULL, 0x0, "Maximum green value on client as n: 2^n - 1", HFILL } }, { &hf_vnc_client_blue_max, { "Blue maximum", "vnc.client_blue_max", FT_UINT16, BASE_DEC, NULL, 0x0, "Maximum blue value on client as n: 2^n - 1", HFILL } }, { &hf_vnc_client_red_shift, { "Red shift", "vnc.client_red_shift", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of shifts needed to get the red value in a pixel to the least significant bit on the client", HFILL } }, { &hf_vnc_client_green_shift, { "Green shift", "vnc.client_green_shift", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of shifts needed to get the green value in a pixel to the least significant bit on the client", HFILL } }, { &hf_vnc_client_blue_shift, { "Blue shift", "vnc.client_blue_shift", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of shifts needed to get the blue value in a pixel to the least significant bit on the client", HFILL } }, /* Client Key Event */ { &hf_vnc_key_down, { "Key down", "vnc.key_down", FT_BOOLEAN, BASE_NONE, TFS(&tfs_yes_no), 0x0, "Specifies whether the key is being pressed or not", HFILL } }, { &hf_vnc_key, { "Key", "vnc.key", FT_UINT32, BASE_HEX | BASE_EXT_STRING, &x11_keysym_vals_source_ext, 0x0, /* keysym_vals_source_exr is from packet-x11.c */ "Key being pressed/depressed", HFILL } }, /* Client Pointer Event */ { &hf_vnc_button_1_pos, { "Mouse button #1 position", "vnc.button_1_pos", FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x1, "Whether mouse button #1 is being pressed or not", HFILL } }, { &hf_vnc_button_2_pos, { "Mouse button #2 position", "vnc.button_2_pos", FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x2, "Whether mouse button #2 is being pressed or not", HFILL } }, { &hf_vnc_button_3_pos, { "Mouse button #3 position", "vnc.button_3_pos", FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x4, "Whether mouse button #3 is being pressed or not", HFILL } }, { &hf_vnc_button_4_pos, { "Mouse button #4 position", "vnc.button_4_pos", FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x8, "Whether mouse button #4 is being pressed or not", HFILL } }, { &hf_vnc_button_5_pos, { "Mouse button #5 position", "vnc.button_5_pos", FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x10, "Whether mouse button #5 is being pressed or not", HFILL } }, { &hf_vnc_button_6_pos, { "Mouse button #6 position", "vnc.button_6_pos", FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x20, "Whether mouse button #6 is being pressed or not", HFILL } }, { &hf_vnc_button_7_pos, { "Mouse button #7 position", "vnc.button_7_pos", FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x40, "Whether mouse button #7 is being pressed or not", HFILL } }, { &hf_vnc_button_8_pos, { "Mouse button #8 position", "vnc.button_8_pos", FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x80, "Whether mouse button #8 is being pressed or not", HFILL } }, { &hf_vnc_pointer_x_pos, { "X position", "vnc.pointer_x_pos", FT_UINT16, BASE_DEC, NULL, 0x0, "Position of mouse cursor on the x-axis", HFILL } }, { &hf_vnc_pointer_y_pos, { "Y position", "vnc.pointer_y_pos", FT_UINT16, BASE_DEC, NULL, 0x0, "Position of mouse cursor on the y-axis", HFILL } }, { &hf_vnc_encoding_num, { "Number of encodings", "vnc.client_set_encodings_num", FT_UINT16, BASE_DEC, NULL, 0x0, "Number of encodings used to send pixel data from server to client", HFILL } }, { &hf_vnc_client_set_encodings_encoding_type, { "Encoding type", "vnc.client_set_encodings_encoding_type", FT_INT32, BASE_DEC, VALS(encoding_types_vs), 0x0, "Type of encoding used to send pixel data from server to client", HFILL } }, /* Client Framebuffer Update Request */ { &hf_vnc_update_req_incremental, { "Incremental update", "vnc.update_req_incremental", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Specifies if the client wants an incremental update instead of a full one", HFILL } }, { &hf_vnc_update_req_x_pos, { "X position", "vnc.update_req_x_pos", FT_UINT16, BASE_DEC, NULL, 0x0, "X position of framebuffer (screen) update requested", HFILL } }, { &hf_vnc_update_req_y_pos, { "Y position", "vnc.update_req_y_pos", FT_UINT16, BASE_DEC, NULL, 0x0, "Y position of framebuffer (screen) update request", HFILL } }, { &hf_vnc_update_req_width, { "Width", "vnc.update_req_width", FT_UINT16, BASE_DEC, NULL, 0x0, "Width of framebuffer (screen) update request", HFILL } }, { &hf_vnc_update_req_height, { "Height", "vnc.update_req_height", FT_UINT16, BASE_DEC, NULL, 0x0, "Height of framebuffer (screen) update request", HFILL } }, { &hf_vnc_client_cut_text_len, { "Length", "vnc.client_cut_text_len", FT_UINT32, BASE_DEC, NULL, 0x0, "Length of client's copy/cut text (clipboard) string in bytes", HFILL } }, { &hf_vnc_client_cut_text, { "Text", "vnc.client_cut_text", FT_STRING, BASE_NONE, NULL, 0x0, "Text string in the client's copy/cut text (clipboard)", HFILL } }, /********** Server Message Types **********/ { &hf_vnc_server_message_type, { "Server Message Type", "vnc.server_message_type", FT_UINT8, BASE_DEC, VALS(vnc_server_message_types_vs), 0x0, "Message type from server", HFILL } }, { &hf_vnc_rectangle_num, { "Number of rectangles", "vnc.fb_update_num_rects", FT_UINT16, BASE_DEC, NULL, 0x0, "Number of rectangles of this server framebuffer update", HFILL } }, { &hf_vnc_fb_update_x_pos, { "X position", "vnc.fb_update_x_pos", FT_UINT16, BASE_DEC, NULL, 0x0, "X position of this server framebuffer update", HFILL } }, { &hf_vnc_fb_update_y_pos, { "Y position", "vnc.fb_update_y_pos", FT_UINT16, BASE_DEC, NULL, 0x0, "Y position of this server framebuffer update", HFILL } }, { &hf_vnc_fb_update_width, { "Width", "vnc.fb_update_width", FT_UINT16, BASE_DEC, NULL, 0x0, "Width of this server framebuffer update", HFILL } }, { &hf_vnc_fb_update_height, { "Height", "vnc.fb_update_height", FT_UINT16, BASE_DEC, NULL, 0x0, "Height of this server framebuffer update", HFILL } }, { &hf_vnc_fb_update_encoding_type, { "Encoding type", "vnc.fb_update_encoding_type", FT_INT32, BASE_DEC, VALS(encoding_types_vs), 0x0, "Encoding type of this server framebuffer update", HFILL } }, /* Cursor encoding */ { &hf_vnc_cursor_x_fore_back, { "X Cursor foreground RGB / background RGB", "vnc.cursor_x_fore_back", FT_BYTES, BASE_NONE, NULL, 0x0, "RGB values for the X cursor's foreground and background", HFILL } }, { &hf_vnc_cursor_encoding_pixels, { "Cursor encoding pixels", "vnc.cursor_encoding_pixels", FT_BYTES, BASE_NONE, NULL, 0x0, "Cursor encoding pixel data", HFILL } }, { &hf_vnc_cursor_encoding_bitmask, { "Cursor encoding bitmask", "vnc.cursor_encoding_bitmask", FT_BYTES, BASE_NONE, NULL, 0x0, "Cursor encoding pixel bitmask", HFILL } }, /* Raw Encoding */ { &hf_vnc_raw_pixel_data, { "Pixel data", "vnc.raw_pixel_data", FT_BYTES, BASE_NONE, NULL, 0x0, "Raw pixel data.", HFILL } }, /* CopyRect Encoding*/ { &hf_vnc_copyrect_src_x_pos, { "Source x position", "vnc.copyrect_src_x_pos", FT_UINT16, BASE_DEC, NULL, 0x0, "X position of the rectangle to copy from", HFILL } }, { &hf_vnc_copyrect_src_y_pos, { "Source y position", "vnc.copyrect_src_y_pos", FT_UINT16, BASE_DEC, NULL, 0x0, "Y position of the rectangle to copy from", HFILL } }, /* RRE Encoding */ { &hf_vnc_rre_num_subrects, { "Number of subrectangles", "vnc.rre_num_subrects", FT_UINT32, BASE_DEC, NULL, 0x0, "Number of subrectangles contained in this encoding type", HFILL } }, { &hf_vnc_rre_bg_pixel, { "Background pixel value", "vnc.rre_bg_pixel", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_rre_subrect_pixel, { "Pixel value", "vnc.rre_subrect_pixel", FT_BYTES, BASE_NONE, NULL, 0x0, "Subrectangle pixel value", HFILL } }, { &hf_vnc_rre_subrect_x_pos, { "X position", "vnc.rre_subrect_x_pos", FT_UINT16, BASE_DEC, NULL, 0x0, "Position of this subrectangle on the x axis", HFILL } }, { &hf_vnc_rre_subrect_y_pos, { "Y position", "vnc.rre_subrect_y_pos", FT_UINT16, BASE_DEC, NULL, 0x0, "Position of this subrectangle on the y axis", HFILL } }, { &hf_vnc_rre_subrect_width, { "Width", "vnc.rre_subrect_width", FT_UINT16, BASE_DEC, NULL, 0x0, "Width of this subrectangle", HFILL } }, { &hf_vnc_rre_subrect_height, { "Height", "vnc.rre_subrect_height", FT_UINT16, BASE_DEC, NULL, 0x0, "Height of this subrectangle", HFILL } }, /* Hextile Encoding */ { &hf_vnc_hextile_subencoding_mask, { "Subencoding type", "vnc.hextile_subencoding", FT_UINT8, BASE_DEC, NULL, 0x0, "Hextile subencoding type.", HFILL } }, { &hf_vnc_hextile_raw, { "Raw", "vnc.hextile_raw", FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x1, "Raw subencoding is used in this tile", HFILL } }, { &hf_vnc_hextile_raw_value, { "Raw pixel values", "vnc.hextile_raw_value", FT_BYTES, BASE_NONE, NULL, 0x0, "Raw subencoding pixel values", HFILL } }, { &hf_vnc_hextile_bg, { "Background Specified", "vnc.hextile_bg", FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x2, "Background Specified subencoding is used in this tile", HFILL } }, { &hf_vnc_hextile_bg_value, { "Background pixel value", "vnc.hextile_bg_value", FT_BYTES, BASE_NONE, NULL, 0x0, "Background color for this tile", HFILL } }, { &hf_vnc_hextile_fg, { "Foreground Specified", "vnc.hextile_fg", FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x4, "Foreground Specified subencoding is used in this tile", HFILL } }, { &hf_vnc_hextile_fg_value, { "Foreground pixel value", "vnc.hextile_fg_value", FT_BYTES, BASE_NONE, NULL, 0x0, "Foreground color for this tile", HFILL } }, { &hf_vnc_hextile_anysubrects, { "Any Subrects", "vnc.hextile_anysubrects", FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x8, "Any subrects subencoding is used in this tile", HFILL } }, { &hf_vnc_hextile_num_subrects, { "Number of subrectangles", "vnc.hextile_num_subrects", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of subrectangles that follow", HFILL } }, { &hf_vnc_hextile_subrectscolored, { "Subrects Colored", "vnc.hextile_subrectscolored", FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x10, "Subrects colored subencoding is used in this tile", HFILL } }, { &hf_vnc_hextile_subrect_pixel_value, { "Pixel value", "vnc.hextile_subrect_pixel_value", FT_BYTES, BASE_NONE, NULL, 0x0, "Pixel value of this subrectangle", HFILL } }, { &hf_vnc_hextile_subrect_x_pos, { "X position", "vnc.hextile_subrect_x_pos", FT_UINT8, BASE_DEC, NULL, 0xF0, /* Top 4 bits */ "X position of this subrectangle", HFILL } }, { &hf_vnc_hextile_subrect_y_pos, { "Y position", "vnc.hextile_subrect_y_pos", FT_UINT8, BASE_DEC, NULL, 0xF, /* Bottom 4 bits */ "Y position of this subrectangle", HFILL } }, { &hf_vnc_hextile_subrect_width, { "Width", "vnc.hextile_subrect_width", FT_UINT8, BASE_DEC, NULL, 0xF0, /* Top 4 bits */ "Subrectangle width minus one", HFILL } }, { &hf_vnc_hextile_subrect_height, { "Height", "vnc.hextile_subrect_height", FT_UINT8, BASE_DEC, NULL, 0xF, /* Bottom 4 bits */ "Subrectangle height minus one", HFILL } }, /* ZRLE Encoding */ { &hf_vnc_zrle_len, { "ZRLE compressed length", "vnc.zrle_len", FT_UINT32, BASE_DEC, NULL, 0x0, "Length of compressed ZRLE data that follows", HFILL } }, { &hf_vnc_zrle_subencoding, { "Subencoding type", "vnc.zrle_subencoding", FT_UINT8, BASE_DEC, NULL, 0x0, "Subencoding type byte", HFILL } }, { &hf_vnc_zrle_rle, { "RLE", "vnc.zrle_rle", FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x80, /* Upper bit */ "Specifies that data is run-length encoded", HFILL } }, { &hf_vnc_zrle_palette_size, { "Palette size", "vnc.zrle_palette_size", FT_UINT8, BASE_DEC, NULL, 0x7F, /* Lower 7 bits */ NULL, HFILL } }, { &hf_vnc_zrle_data, { "ZRLE compressed data", "vnc.zrle_data", FT_BYTES, BASE_NONE, NULL, 0x0, "Compressed ZRLE data. Compiling with zlib support will uncompress and dissect this data", HFILL } }, { &hf_vnc_zrle_raw, { "Pixel values", "vnc.zrle_raw", FT_BYTES, BASE_NONE, NULL, 0x0, "Raw pixel values for this tile", HFILL } }, { &hf_vnc_zrle_palette, { "Palette", "vnc.zrle_palette", FT_BYTES, BASE_NONE, NULL, 0x0, "Palette pixel values", HFILL } }, /* Server Set Colormap Entries */ { &hf_vnc_colormap_first_color, { "First color", "vnc.colormap_first_color", FT_UINT16, BASE_DEC, NULL, 0x0, "First color that should be mapped to given RGB intensities", HFILL } }, { &hf_vnc_color_groups, { "Color groups", "vnc.color_groups", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_colormap_num_colors, { "Number of color groups", "vnc.colormap_groups", FT_UINT16, BASE_DEC, NULL, 0x0, "Number of red/green/blue color groups", HFILL } }, { &hf_vnc_colormap_red, { "Red", "vnc.colormap_red", FT_UINT16, BASE_DEC, NULL, 0x0, "Red intensity", HFILL } }, { &hf_vnc_colormap_green, { "Green", "vnc.colormap_green", FT_UINT16, BASE_DEC, NULL, 0x0, "Green intensity", HFILL } }, { &hf_vnc_colormap_blue, { "Blue", "vnc.colormap_blue", FT_UINT16, BASE_DEC, NULL, 0x0, "Blue intensity", HFILL } }, /* Server Cut Text */ { &hf_vnc_server_cut_text_len, { "Length", "vnc.server_cut_text_len", FT_UINT32, BASE_DEC, NULL, 0x0, "Length of server's copy/cut text (clipboard) string in bytes", HFILL } }, { &hf_vnc_server_cut_text, { "Text", "vnc.server_cut_text", FT_STRING, BASE_NONE, NULL, 0x0, "Text string in the server's copy/cut text (clipboard)", HFILL } }, /* LibVNCServer additions */ { &hf_vnc_supported_messages_client2server, { "Client2server", "vnc.supported_messages_client2server", FT_BYTES, BASE_NONE, NULL, 0x0, "Supported client to server messages (bit flags)", HFILL } }, { &hf_vnc_supported_messages_server2client, { "Server2client", "vnc.supported_messages_server2client", FT_BYTES, BASE_NONE, NULL, 0x0, "Supported server to client messages (bit flags)", HFILL } }, { &hf_vnc_num_supported_encodings, { "Number of supported encodings", "vnc.num_supported_encodings", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_supported_encodings, { "Encoding", "vnc.supported_encodings", FT_UINT32, BASE_HEX, NULL, 0x0, "Supported encoding", HFILL } }, { &hf_vnc_server_identity, { "Server Identity", "vnc.server_identity", FT_STRING, BASE_NONE, NULL, 0x0, "Server identity string", HFILL } }, /* MirrorLink */ { &hf_vnc_mirrorlink_type, { "Type", "vnc.mirrorlink_type", FT_UINT8, BASE_DEC, VALS(vnc_mirrorlink_types_vs), 0x0, "MirrorLink extension message type", HFILL } }, { &hf_vnc_mirrorlink_length, { "Length", "vnc.mirrorlink_length", FT_UINT16, BASE_DEC, NULL, 0x0, "Payload length", HFILL } }, { &hf_vnc_mirrorlink_version_major, { "Major Version", "vnc.mirrorlink_version_major", FT_UINT8, BASE_DEC, NULL, 0x0, "MirrorLink major version", HFILL } }, { &hf_vnc_mirrorlink_version_minor, { "Minor Version", "vnc.mirrorlink_version_minor", FT_UINT8, BASE_DEC, NULL, 0x0, "MirrorLink minor version", HFILL } }, { &hf_vnc_mirrorlink_framebuffer_configuration, { "Configuration", "vnc.mirrorlink_framebuffer_configuration", FT_UINT16, BASE_HEX, NULL, 0x0, "Framebuffer configuration", HFILL } }, { &hf_vnc_mirrorlink_pixel_width, { "Pixel Width", "vnc.mirrorlink_pixel_width", FT_UINT16, BASE_DEC, NULL, 0x0, "Display width [pixel]", HFILL } }, { &hf_vnc_mirrorlink_pixel_height, { "Pixel Height", "vnc.mirrorlink_pixel_height", FT_UINT16, BASE_DEC, NULL, 0x0, "Display height [pixel]", HFILL } }, { &hf_vnc_mirrorlink_pixel_format, { "Pixel Format", "vnc.mirrorlink_pixel_format", FT_UINT32, BASE_HEX, NULL, 0x0, "Pixel format support", HFILL } }, { &hf_vnc_mirrorlink_display_width, { "Display Width", "vnc.mirrorlink_display_width", FT_UINT16, BASE_DEC, NULL, 0x0, "Display width [mm]", HFILL } }, { &hf_vnc_mirrorlink_display_height, { "Display Height", "vnc.mirrorlink_display_height", FT_UINT16, BASE_DEC, NULL, 0x0, "Display height [mm]", HFILL } }, { &hf_vnc_mirrorlink_display_distance, { "Display Distance", "vnc.mirrorlink_display_distance", FT_UINT16, BASE_DEC, NULL, 0x0, "Display distance [mm]", HFILL } }, { &hf_vnc_mirrorlink_keyboard_language, { "Keyboard Language", "vnc.mirrorlink_keyboard_language", FT_STRING, BASE_NONE, NULL, 0x0, "Keyboard layout - Language code (according ISO 639-1)", HFILL } }, { &hf_vnc_mirrorlink_keyboard_country, { "Keyboard Country", "vnc.mirrorlink_keyboard_country", FT_STRING, BASE_NONE, NULL, 0x0, "Keyboard layout - Country code (according ISO 3166-1 alpha-2)", HFILL } }, { &hf_vnc_mirrorlink_ui_language, { "UI Language", "vnc.mirrorlink_ui_language", FT_STRING, BASE_NONE, NULL, 0x0, "UI language - Language code (according ISO 639-1)", HFILL } }, { &hf_vnc_mirrorlink_ui_country, { "UI Country", "vnc.mirrorlink_ui_country", FT_STRING, BASE_NONE, NULL, 0x0, "UI language - Country code (according ISO 3166-1 alpha 2)", HFILL } }, { &hf_vnc_mirrorlink_knob_keys, { "Knob Keys", "vnc.mirrorlink_knob_keys", FT_UINT32, BASE_HEX, NULL, 0x0, "Supported knob keys", HFILL } }, { &hf_vnc_mirrorlink_device_keys, { "Device Keys", "vnc.mirrorlink_device_keys", FT_UINT32, BASE_HEX, NULL, 0x0, "Supported device keys", HFILL } }, { &hf_vnc_mirrorlink_multimedia_keys, { "Multimedia Keys", "vnc.mirrorlink_multimedia_keys", FT_UINT32, BASE_HEX, NULL, 0x0, "Supported multimedia keys", HFILL } }, { &hf_vnc_mirrorlink_key_related, { "Keyboard", "vnc.mirrorlink_key_related", FT_UINT32, BASE_HEX, NULL, 0x0, "Keyboard related", HFILL } }, { &hf_vnc_mirrorlink_pointer_related, { "Pointer", "vnc.mirrorlink_pointer_related", FT_UINT32, BASE_HEX, NULL, 0x0, "Pointer related", HFILL } }, { &hf_vnc_mirrorlink_key_symbol_value_client, { "Client KeySymValue", "vnc.mirrorlink_key_symbol_value_client", FT_UINT32, BASE_HEX, NULL, 0x0, "Client key symbol value", HFILL } }, { &hf_vnc_mirrorlink_key_symbol_value_server, { "Server KeySymValue", "vnc.mirrorlink_key_symbol_value_server", FT_UINT32, BASE_HEX, NULL, 0x0, "Server key symbol value", HFILL } }, { &hf_vnc_mirrorlink_key_configuration, { "Configuration", "vnc.mirrorlink_key_configuration", FT_UINT8, BASE_HEX, NULL, 0x0, "Key event listing configuration", HFILL } }, { &hf_vnc_mirrorlink_key_num_events, { "Number of Key Events", "vnc.mirrorlink_key_num_events", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of key events in list", HFILL } }, { &hf_vnc_mirrorlink_key_event_counter, { "Key Event Counter", "vnc.mirrorlink_key_event_counter", FT_UINT16, BASE_DEC, NULL, 0x0, "Key event listing counter", HFILL } }, { &hf_vnc_mirrorlink_key_symbol_value, { "KeySymValue", "vnc.mirrorlink_key_symbol_value", FT_UINT32, BASE_HEX, NULL, 0x0, "Key symbol value", HFILL } }, { &hf_vnc_mirrorlink_key_request_configuration, { "Configuration", "vnc.mirrorlink_key_request_configuration", FT_UINT32, BASE_HEX, NULL, 0x0, "Key event listing request configuration", HFILL } }, { &hf_vnc_mirrorlink_keyboard_configuration, { "Configuration", "vnc.mirrorlink_keyboard_configuration", FT_UINT32, BASE_HEX, NULL, 0x0, "Virtual keyboard configuration", HFILL } }, { &hf_vnc_mirrorlink_cursor_x, { "Cursor X", "vnc.mirrorlink_cursor_x", FT_UINT16, BASE_DEC, NULL, 0x0, "Cursor - X position", HFILL } }, { &hf_vnc_mirrorlink_cursor_y, { "Cursor Y", "vnc.mirrorlink_cursor_y", FT_UINT16, BASE_DEC, NULL, 0x0, "Cursor - Y position", HFILL } }, { &hf_vnc_mirrorlink_text_x, { "Text X", "vnc.mirrorlink_text_x", FT_UINT16, BASE_DEC, NULL, 0x0, "Text input area - X position", HFILL } }, { &hf_vnc_mirrorlink_text_y, { "Text Y", "vnc.mirrorlink_text_y", FT_UINT16, BASE_DEC, NULL, 0x0, "Text input area - Y position", HFILL } }, { &hf_vnc_mirrorlink_text_width, { "Text Width", "vnc.mirrorlink_text_width", FT_UINT16, BASE_DEC, NULL, 0x0, "Text input area - Width", HFILL } }, { &hf_vnc_mirrorlink_text_height, { "Text Height", "vnc.mirrorlink_text_height", FT_UINT16, BASE_DEC, NULL, 0x0, "Text input area - Height", HFILL } }, { &hf_vnc_mirrorlink_keyboard_request_configuration, { "Configuration", "vnc.mirrorlink_keyboard_request_configuration", FT_UINT32, BASE_HEX, NULL, 0x0, "Virtual keyboard request configuration", HFILL } }, { &hf_vnc_mirrorlink_device_status, { "Device Status", "vnc.mirrorlink_device_status", FT_UINT32, BASE_HEX, NULL, 0x0, "Status of Device Features", HFILL } }, { &hf_vnc_mirrorlink_app_id, { "App Id", "vnc.mirrorlink_app_id", FT_UINT32, BASE_HEX, NULL, 0x0, "Unique application id", HFILL } }, { &hf_vnc_mirrorlink_fb_block_x, { "Framebuffer X", "vnc.mirrorlink_fb_block_x", FT_UINT16, BASE_DEC, NULL, 0x0, "Framebuffer blocking - X position", HFILL } }, { &hf_vnc_mirrorlink_fb_block_y, { "Framebuffer Y", "vnc.mirrorlink_fb_block_y", FT_UINT16, BASE_DEC, NULL, 0x0, "Framdbuffer blocking - Y position", HFILL } }, { &hf_vnc_mirrorlink_fb_block_width, { "Framebuffer Width", "vnc.mirrorlink_fb_block_width", FT_UINT16, BASE_DEC, NULL, 0x0, "Framebuffer blocking - Width", HFILL } }, { &hf_vnc_mirrorlink_fb_block_height, { "Framebuffer Height", "vnc.mirrorlink_fb_block_height", FT_UINT16, BASE_DEC, NULL, 0x0, "Framebuffer blocking - Height", HFILL } }, { &hf_vnc_mirrorlink_fb_block_reason, { "Reason", "vnc.mirrorlink_fb_block_reason", FT_UINT16, BASE_HEX, NULL, 0x0, "Reason for blocking", HFILL } }, { &hf_vnc_mirrorlink_audio_block_reason, { "Reason", "vnc.mirrorlink_audio_block_reason", FT_UINT16, BASE_HEX, NULL, 0x0, "Reason for blocking", HFILL } }, { &hf_vnc_mirrorlink_touch_num_events, { "Number of Touch Events", "vnc.mirrorlink_touch_num_events", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of touch events in list", HFILL } }, { &hf_vnc_mirrorlink_touch_x, { "Touch X", "vnc.mirrorlink_touch_x", FT_UINT16, BASE_DEC, NULL, 0x0, "Touch event - X position", HFILL } }, { &hf_vnc_mirrorlink_touch_y, { "Touch Y", "vnc.mirrorlink_touch_y", FT_UINT16, BASE_DEC, NULL, 0x0, "Touch event - Y position", HFILL } }, { &hf_vnc_mirrorlink_touch_id, { "Touch Id", "vnc.mirrorlink_touch_id", FT_UINT8, BASE_DEC, NULL, 0x0, "Touch event - identifier", HFILL } }, { &hf_vnc_mirrorlink_touch_pressure, { "Touch Pressure", "vnc.mirrorlink_touch_pressure", FT_UINT8, BASE_DEC, NULL, 0x0, "Touch event - pressure value", HFILL } }, { &hf_vnc_mirrorlink_text, { "Text", "vnc.mirrorlink_text", FT_STRING, BASE_NONE, NULL, 0x0, "Textual information", HFILL } }, { &hf_vnc_mirrorlink_text_length, { "Length", "vnc.mirrorlink_text_length", FT_UINT16, BASE_DEC, NULL, 0x0, "Length of textual information", HFILL } }, { &hf_vnc_mirrorlink_text_max_length, { "Max Length", "vnc.mirrorlink_text_max_length", FT_UINT16, BASE_DEC, NULL, 0x0, "Maximum length of textual information", HFILL } }, { &hf_vnc_mirrorlink_unknown, { "Unknown", "vnc.mirrorlink_unknown", FT_BYTES, BASE_NONE, NULL, 0x0, "Unknown data", HFILL } }, /* Fence */ { &hf_vnc_fence_flags, {"Fence flags", "vnc.fence_flags", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_vnc_fence_request, { "Fence_request", "vnc.fence_request", FT_BOOLEAN, 32, NULL, VNC_FENCE_REQUEST, NULL, HFILL } }, { &hf_vnc_fence_sync_next, { "Fence_sync_next", "vnc.fence_sync_next", FT_BOOLEAN, 32, NULL, VNC_FENCE_SYNC_NEXT, NULL, HFILL } }, { &hf_vnc_fence_block_after, { "Fence_block_after", "vnc.fence_block_after", FT_BOOLEAN, 32, NULL, VNC_FENCE_BLOCK_AFTER, NULL, HFILL } }, { &hf_vnc_fence_block_before, { "Fence block_before", "vnc.fence_block_before", FT_BOOLEAN, 32, NULL, VNC_FENCE_BLOCK_BEFORE, NULL, HFILL } }, { &hf_vnc_fence_payload_length, { "Fence payload length", "vnc.fence_payload_length", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_vnc_fence_payload, { "Fence payload", "vnc.fence_payload", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, /* Context Information */ { &hf_vnc_context_information_app_id, { "App Id", "vnc.context_information_app_id", FT_UINT32, BASE_HEX, NULL, 0x0, "Unique application id", HFILL } }, { &hf_vnc_context_information_app_trust_level, { "App Trust Level", "vnc.context_information_app_trust_level", FT_UINT16, BASE_HEX, NULL, 0x0, "Trust Level for Application Category", HFILL } }, { &hf_vnc_context_information_content_trust_level, { "Content Trust Level", "vnc.context_information_content_trust_level", FT_UINT16, BASE_HEX, NULL, 0x0, "Trust Level for Content Category", HFILL } }, { &hf_vnc_context_information_app_category, { "App Category", "vnc.context_information_app_category", FT_UINT32, BASE_HEX, NULL, 0x0, "Application Category", HFILL } }, { &hf_vnc_context_information_content_category, { "Content Category", "vnc.context_information_content_category", FT_UINT32, BASE_HEX, NULL, 0x0, "Visual content category", HFILL } }, { &hf_vnc_context_information_content_rules, { "Content Rules", "vnc.context_information_content_rules", FT_UINT32, BASE_HEX, NULL, 0x0, "Visual content rules", HFILL } }, /* Scan Line based Run-Length Encoding */ { &hf_vnc_slrle_run_num, { "Number of Runs", "vnc.slrle_run_num", FT_UINT16, BASE_DEC, NULL, 0x0, "Number of Runs within Line", HFILL } }, { &hf_vnc_slrle_run_data, { "Raw RLE data", "vnc.slrle_run_data", FT_BYTES, BASE_NONE, NULL, 0x0, "Raw Run-Length encoded data within Line", HFILL } }, /* H.264 Encoding */ { &hf_vnc_h264_slice_type, { "Slice Type", "vnc.h264_slice_type", FT_UINT32, BASE_DEC, VALS(vnc_h264_slice_types_vs), 0x0, "Frame slice type", HFILL } }, { &hf_vnc_h264_nbytes, { "Number of Bytes", "vnc.h264_nbytes", FT_UINT32, BASE_DEC, NULL, 0x0, "Number of bytes within frame", HFILL } }, { &hf_vnc_h264_width, { "Width", "vnc.h264_width", FT_UINT32, BASE_DEC, NULL, 0x0, "Frame Width", HFILL } }, { &hf_vnc_h264_height, { "Height", "vnc.h264_height", FT_UINT32, BASE_DEC, NULL, 0x0, "Frame Height", HFILL } }, { &hf_vnc_h264_data, { "Data", "vnc.h264_data", FT_BYTES, BASE_NONE, NULL, 0x0, "Frame H.264 data", HFILL } }, }; /* Setup protocol subtree arrays */ static int *ett[] = { &ett_vnc, &ett_vnc_client_message_type, &ett_vnc_server_message_type, &ett_vnc_rect, &ett_vnc_encoding_type, &ett_vnc_rre_subrect, &ett_vnc_hextile_subencoding_mask, &ett_vnc_hextile_num_subrects, &ett_vnc_hextile_subrect, &ett_vnc_hextile_tile, &ett_vnc_zrle_subencoding, &ett_vnc_colormap_num_groups, &ett_vnc_desktop_screen, &ett_vnc_colormap_color_group, &ett_vnc_key_events, &ett_vnc_touch_events, &ett_vnc_slrle_subline, &ett_vnc_fence_flags }; static ei_register_info ei[] = { { &ei_vnc_possible_gtk_vnc_bug, { "vnc.possible_gtk_vnc_bug", PI_MALFORMED, PI_ERROR, "NULL found in greeting. client -> server greeting must be 12 bytes (possible gtk-vnc bug)", EXPFILL }}, { &ei_vnc_auth_code_mismatch, { "vnc.auth_code_mismatch", PI_PROTOCOL, PI_WARN, "Authentication code does not match vendor or signature", EXPFILL }}, { &ei_vnc_unknown_tight_vnc_auth, { "vnc.unknown_tight_vnc_auth", PI_PROTOCOL, PI_ERROR, "Unknown TIGHT VNC authentication", EXPFILL }}, { &ei_vnc_too_many_rectangles, { "vnc.too_many_rectangles", PI_MALFORMED, PI_ERROR, "Too many rectangles, aborting dissection", EXPFILL }}, { &ei_vnc_too_many_sub_rectangles, { "vnc.too_many_sub_rectangles", PI_MALFORMED, PI_ERROR, "Too many sub-rectangles, aborting dissection", EXPFILL }}, { &ei_vnc_invalid_encoding, { "vnc.invalid_encoding", PI_MALFORMED, PI_ERROR, "Invalid encoding", EXPFILL }}, { &ei_vnc_too_many_colors, { "vnc.too_many_colors", PI_MALFORMED, PI_ERROR, "Too many colors, aborting dissection", EXPFILL }}, { &ei_vnc_too_many_cut_text, { "vnc.too_many_cut_text", PI_MALFORMED, PI_ERROR, "Too much cut text, aborting dissection", EXPFILL }}, { &ei_vnc_zrle_failed, { "vnc.zrle_failed", PI_UNDECODED, PI_ERROR, "Decompression of ZRLE data failed", EXPFILL }}, { &ei_vnc_unknown_tight, { "vnc.unknown_tight_packet", PI_UNDECODED, PI_WARN, "Unknown packet (TightVNC)", EXPFILL }}, { &ei_vnc_reassemble, { "vnc.reassemble", PI_REASSEMBLE, PI_CHAT, "See further on for dissection of the complete (reassembled) PDU", EXPFILL }}, }; /* Register the protocol name and description */ proto_vnc = proto_register_protocol("Virtual Network Computing", "VNC", "vnc"); vnc_handle = register_dissector("vnc", dissect_vnc, proto_vnc); /* Required function calls to register the header fields and subtrees */ proto_register_field_array(proto_vnc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_vnc = expert_register_protocol(proto_vnc); expert_register_field_array(expert_vnc, ei, array_length(ei)); /* Register our preferences module */ vnc_module = prefs_register_protocol(proto_vnc, apply_vnc_prefs); prefs_register_bool_preference(vnc_module, "desegment", "Reassemble VNC messages spanning multiple TCP segments.", "Whether the VNC 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.", &vnc_preference_desegment); } void proto_reg_handoff_vnc(void) { dissector_add_uint_range_with_preference("tcp.port", VNC_PORT_RANGE, vnc_handle); heur_dissector_add("tcp", test_vnc_protocol, "VNC over TCP", "vnc_tcp", proto_vnc, HEURISTIC_ENABLE); /* We don't register a port for the VNC HTTP server because * that simply provides a java program for download via the * HTTP protocol. The java program then connects to a standard * VNC port. */ } /* * Editor modelines - https://www.wireshark.org/tools/modelines.html * * Local variables: * c-basic-offset: 8 * tab-width: 8 * indent-tabs-mode: t * End: * * vi: set shiftwidth=8 tabstop=8 noexpandtab: * :indentSize=8:tabSize=8:noTabs=false: */