PageRenderTime 61ms CodeModel.GetById 30ms RepoModel.GetById 1ms app.codeStats 0ms

/epan/dissectors/packet-ncp-nmas.c

https://github.com/labx-technologies-llc/wireshark
C | 776 lines | 652 code | 62 blank | 62 comment | 41 complexity | f74e0c927ffb1f8153d3321b022c2ca0 MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause 
    

  1. /* packet-ncp-nmas.c
    2. 

  2.  * Routines for Novell Modular Authentication Service
    3. 

  3.  * Greg Morris <gmorris@novell.com>
    4. 

  4.  * Copyright (c) Novell, Inc. 2002-2004
    5. 

  5.  *
    6. 

  6.  * $Id$
    7. 

  7.  *
    8. 

  8.  * Wireshark - Network traffic analyzer
    9. 

  9.  * By Gerald Combs <gerald@wireshark.org>
    10. 

  10.  * Copyright 1998 Gerald Combs
    11. 

  11.  *
    12. 

  12.  * This program is free software; you can redistribute it and/or
    13. 

  13.  * modify it under the terms of the GNU General Public License
    14. 

  14.  * as published by the Free Software Foundation; either version 2
    15. 

  15.  * of the License, or (at your option) any later version.
    16. 

  16.  *
    17. 

  17.  * This program is distributed in the hope that it will be useful,
    18. 

  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    19. 

  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    20. 

  20.  * GNU General Public License for more details.
    21. 

  21.  *
    22. 

  22.  * You should have received a copy of the GNU General Public License
    23. 

  23.  * along with this program; if not, write to the Free Software
    24. 

  24.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
    25. 

  25.  */
    26. 

  26. 

  27. #include "config.h"
    28. 

  28. 

  29. #include <glib.h>
    30. 

  30. #include <epan/packet.h>
    31. 

  31. #include <epan/emem.h>
    32. 

  32. #include "packet-ncp-int.h"
    33. 

  33. #include "packet-ncp-nmas.h"
    34. 

  34. 

  35. static gint ett_nmas = -1;
    36. 

  36. 

  37. static int proto_nmas = -1;
    38. 

  38. /* static int hf_func = -1; */
    39. 

  39. /* static int hf_subfunc = -1; */
    40. 

  40. static int hf_ping_version = -1;
    41. 

  41. static int hf_ping_flags = -1;
    42. 

  42. static int hf_frag_handle = -1;
    43. 

  43. static int hf_length = -1;
    44. 

  44. static int hf_subverb = -1;
    45. 

  45. static int hf_tree = -1;
    46. 

  46. static int hf_user = -1;
    47. 

  47. static int hf_nmas_version = -1;
    48. 

  48. static int hf_msg_version = -1;
    49. 

  49. static int hf_session_ident = -1;
    50. 

  50. static int hf_msg_verb = -1;
    51. 

  51. /* static int hf_attribute = -1; */
    52. 

  52. static int hf_clearance = -1;
    53. 

  53. static int hf_login_sequence = -1;
    54. 

  54. static int hf_opaque = -1;
    55. 

  55. static int hf_data = -1;
    56. 

  56. static int hf_return_code = -1;
    57. 

  57. static int hf_lsm_verb = -1;
    58. 

  58. static int hf_squeue_bytes = -1;
    59. 

  59. static int hf_cqueue_bytes = -1;
    60. 

  60. static int hf_num_creds = -1;
    61. 

  61. static int hf_cred_type = -1;
    62. 

  62. static int hf_login_state = -1;
    63. 

  63. static int hf_enc_cred = -1;
    64. 

  64. static int hf_enc_data = -1;
    65. 

  65. static int hf_reply_buffer_size = -1;
    66. 

  66. static int hf_encrypt_error = -1;
    67. 

  67. 

  68. static expert_field ei_encrypt_error = EI_INIT;
    69. 

  69. static expert_field ei_return_error = EI_INIT;
    70. 

  70. 

  71. static const value_string nmas_func_enum[] = {
    72. 

  72.     { 0x01, "Ping" },
    73. 

  73.     { 0x02, "Fragment" },
    74. 

  74.     { 0x03, "Abort" },
    75. 

  75.     { 0,    NULL }
    76. 

  76. };
    77. 

  77. 

  78. static const value_string nmas_subverb_enum[] = {
    79. 

  79.     { 0, "Fragmented Ping" },
    80. 

  80.     { 2, "Client Put Data" },
    81. 

  81.     { 4, "Client Get Data" },
    82. 

  82.     { 6, "Client Get User NDS Credentials" },
    83. 

  83.     { 8, "Login Store Management" },
    84. 

  84.     { 10, "Writable Object Check" },
    85. 

  85.     { 1242, "Message Handler" },
    86. 

  86.     { 0,          NULL }
    87. 

  87. };
    88. 

  88. 

  89. static const value_string nmas_msgverb_enum[] = {
    90. 

  90.     { 1, "Echo Data" },
    91. 

  91.     { 3, "Start Session" },
    92. 

  92.     { 5, "Client Write Data" },
    93. 

  93.     { 7, "Client Read Data" },
    94. 

  94.     { 9, "End Session" },
    95. 

  95.     { 0,          NULL }
    96. 

  96. };
    97. 

  97. 

  98. static const value_string nmas_attribute_enum[] = {
    99. 

  99.     { 1, "User Name" },
    100. 

  100.     { 2, "Tree Name" },
    101. 

  101.     { 4, "Clearance" },
    102. 

  102.     { 11, "Login Sequence" },
    103. 

  103.     { 0,          NULL }
    104. 

  104. };
    105. 

  105. 

  106. static const value_string nmas_lsmverb_enum[] = {
    107. 

  107.     { 1, "Put Login Configuration" },
    108. 

  108.     { 2, "Get Login Configuration" },
    109. 

  109.     { 3, "Get All Configurations" },
    110. 

  110.     { 4, "Delete Login Configuration" },
    111. 

  111.     { 5, "Put Login Secret" },
    112. 

  112.     { 6, "Delete Login Secret" },
    113. 

  113.     { 7, "Set Password" },
    114. 

  114.     { 8, "Change Password" },
    115. 

  115.     { 9, "Delete Password" },
    116. 

  116.     { 10, "Get Password" },
    117. 

  117.     { 11, "Check Password Policy" },
    118. 

  118.     { 0,          NULL }
    119. 

  119. };
    120. 

  120. 

  121. static const value_string nmas_errors_enum[] = {
    122. 

  122.     { 0xFFFFF9A1, "(-1631) FRAGMENT FAILURE" },
    123. 

  123.     { 0xFFFFF9A0, "(-1632) BAD REQUEST SYNTAX" },
    124. 

  124.     { 0xFFFFF99F, "(-1633) BUFFER OVERFLOW" },
    125. 

  125.     { 0xFFFFF99E, "(-1634) SYSTEM RESOURCES" },
    126. 

  126.     { 0xFFFFF99D, "(-1635) INSUFFICIENT MEMORY" },
    127. 

  127.     { 0xFFFFF99C, "(-1636) NOT SUPPORTED" },
    128. 

  128.     { 0xFFFFF99B, "(-1637) BUFFER UNDERFLOW" },
    129. 

  129.     { 0xFFFFF99A, "(-1638) NOT FOUND" },
    130. 

  130.     { 0xFFFFF999, "(-1639) INVALID OPERATION" },
    131. 

  131.     { 0xFFFFF998, "(-1640) ASN1 DECODE" },
    132. 

  132.     { 0xFFFFF997, "(-1641) ASN1 ENCODE" },
    133. 

  133.     { 0xFFFFF996, "(-1642) LOGIN FAILED" },
    134. 

  134.     { 0xFFFFF995, "(-1643) INVALID PARAMETER" },
    135. 

  135.     { 0xFFFFF994, "(-1644) TIMED OUT RECOVERABLE" },
    136. 

  136.     { 0xFFFFF993, "(-1645) TIMED OUT NOT RECOVERABLE" },
    137. 

  137.     { 0xFFFFF992, "(-1646) TIMED OUT UNKNOWN" },
    138. 

  138.     { 0xFFFFF991, "(-1647) AUTHORIZATION FAILURE" },
    139. 

  139.     { 0xFFFFF990, "(-1648) INVALID DISTINGUISHED NAME" },
    140. 

  140.     { 0xFFFFF98F, "(-1649) CANNOT RESOLVE DISTINGUISHED NAME" },
    141. 

  141.     { 0xFFFFF98E, "(-1650) CANNOT RESOLVE CONNECTION" },
    142. 

  142.     { 0xFFFFF98D, "(-1651) NO CRYPTOGRAPHY" },
    143. 

  143.     { 0xFFFFF98C, "(-1652) INVALID VERSION" },
    144. 

  144.     { 0xFFFFF98B, "(-1653) SYNC NEEDED" },
    145. 

  145.     { 0xFFFFF98A, "(-1654) PROTOCOL STATE" },
    146. 

  146.     { 0xFFFFF989, "(-1655) INVALID HANDLE" },
    147. 

  147.     { 0xFFFFF988, "(-1656) INVALID METHOD" },
    148. 

  148.     { 0xFFFFF987, "(-1657) DEVELOPMENT VERSION" },
    149. 

  149.     { 0xFFFFF986, "(-1658) MISSING KEY" },
    150. 

  150.     { 0xFFFFF985, "(-1659) ACCESS NOT ALLOWED" },
    151. 

  151.     { 0xFFFFF984, "(-1660) SEQUENCE NOT FOUND" },
    152. 

  152.     { 0xFFFFF983, "(-1661) CLEARANCE NOT FOUND" },
    153. 

  153.     { 0xFFFFF982, "(-1662) LOGIN SERVER METHOD NOT FOUND" },
    154. 

  154.     { 0xFFFFF981, "(-1663) LOGIN CLIENT METHOD NOT FOUND" },
    155. 

  155.     { 0xFFFFF980, "(-1664) SERVER NOT FOUND" },
    156. 

  156.     { 0xFFFFF97F, "(-1665) LOGIN ATTRIBUTE NOT FOUND" },
    157. 

  157.     { 0xFFFFF97E, "(-1666) LEGACY INVALID PASSWORD" },
    158. 

  158.     { 0xFFFFF97D, "(-1667) ACCOUNT DISABLED" },
    159. 

  159.     { 0xFFFFF97C, "(-1668) ACCOUNT LOCKED" },
    160. 

  160.     { 0xFFFFF97B, "(-1669) ADDRESS RESTRICTION" },
    161. 

  161.     { 0xFFFFF97A, "(-1670) CONNECTION CLEARED" },
    162. 

  162.     { 0xFFFFF979, "(-1671) TIME RESTRICTION" },
    163. 

  163.     { 0xFFFFF978, "(-1672) SHORT TERM SECRET" },
    164. 

  164.     { 0xFFFFF977, "(-1673) NO NMAS ON TREE" },
    165. 

  165.     { 0xFFFFF976, "(-1674) NO NMAS ON SERVER" },
    166. 

  166.     { 0xFFFFF975, "(-1675) REQUEST CHALLENGED" },
    167. 

  167.     { 0xFFFFF974, "(-1676) LOGIN CANCELED" },
    168. 

  168.     { 0xFFFFF973, "(-1677) LOCAL CREDENTIAL STORE" },
    169. 

  169.     { 0xFFFFF972, "(-1678) REMOTE CREDENTIAL STORE" },
    170. 

  170.     { 0xFFFFF971, "(-1679) SMC NICM" },
    171. 

  171.     { 0xFFFFF970, "(-1680) SEQUENCE NOT AUTHORIZED" },
    172. 

  172.     { 0xFFFFF96F, "(-1681) TRANSPORT" },
    173. 

  173.     { 0xFFFFF96E, "(-1682) CRYPTO FAILED INIT" },
    174. 

  174.     { 0xFFFFF96D, "(-1683) DOUBLEBYTE FAILED INIT" },
    175. 

  175.     { 0xFFFFF96C, "(-1684) CODEPAGE FAILED INIT" },
    176. 

  176.     { 0xFFFFF96B, "(-1685) UNICODE FAILED INIT" },
    177. 

  177.     { 0xFFFFF96A, "(-1686) DLL FAILED LOADING" },
    178. 

  178.     { 0xFFFFF969, "(-1687) EVALUATION VERSION WARNING" },
    179. 

  179.     { 0xFFFFF968, "(-1688) CONCURRENT LOGIN" },
    180. 

  180.     { 0xFFFFF969, "(-1689) THREAD CREATE" },
    181. 

  181.     { 0xFFFFF96A, "(-1690) SECURE CHANNEL REQUIRED" },
    182. 

  182.     { 0xFFFFF96B, "(-1691) NO DEFAULT USER SEQUENCE" },
    183. 

  183.     { 0xFFFFF96C, "(-1692) NO TREENAME" },
    184. 

  184.     { 0xFFFFF96D, "(-1693) MECHANISM NOT FOUND" },
    185. 

  185.     { 0,          NULL }
    186. 

  186. };
    187. 

  187. 

  188. #if 0
    189. 

  189. static int
    190. 

  190. align_4(tvbuff_t *tvb, int aoffset)
    191. 

  191. {
    192. 

  192.     if (tvb_length_remaining(tvb, aoffset) > 4 ) {
    193. 

  193.         return (aoffset%4);
    194. 

  194.     }
    195. 

  195.     return 0;
    196. 

  196. }
    197. 

  197. #endif
    198. 

  198. 

  199. static int
    200. 

  200. nmas_string(tvbuff_t* tvb, int hfinfo, proto_tree *nmas_tree, int offset, gboolean little)
    201. 

  201. {
    202. 

  202.     int     foffset = offset;
    203. 

  203.     guint32 str_length;
    204. 

  204.     char    *buffer;
    205. 

  205.     guint32 i;
    206. 

  206.     guint16 c_char;
    207. 

  207.     guint32 length_remaining = 0;
    208. 

  208. 

  209.     buffer = (char *)ep_alloc(ITEM_LABEL_LENGTH+1);
    210. 

  210.     if (little) {
    211. 

  211.         str_length = tvb_get_letohl(tvb, foffset);
    212. 

  212.     } else {
    213. 

  213.         str_length = tvb_get_ntohl(tvb, foffset);
    214. 

  214.     }
    215. 

  215.     foffset += 4;
    216. 

  216.     if (str_length >= ITEM_LABEL_LENGTH) {
    217. 

  217.         proto_tree_add_string(nmas_tree, hfinfo, tvb, foffset,
    218. 

  218.             length_remaining + 4, "<String too long to process>");
    219. 

  219.         foffset += length_remaining;
    220. 

  220.         return foffset;
    221. 

  221.     }
    222. 

  222.     if (str_length == 0) {
    223. 

  223.         proto_tree_add_string(nmas_tree, hfinfo, tvb, offset, 4,
    224. 

  224.             "<Not Specified>");
    225. 

  225.         return foffset;
    226. 

  226.     }
    227. 

  227.     /*
    228. 

  228.      * XXX - other than the special-casing of null bytes,
    229. 

  229.      * we could just use "proto_tree_add_item()", as for
    230. 

  230.      * FT_STRING, FT_STRINGZ, and FT_UINT_STRING fields,
    231. 

  231.      * the display representation of an item is generated
    232. 

  232.      * using "format_text()", so it handles non-printable
    233. 

  233.      * characters.
    234. 

  234.      */
    235. 

  235.     for ( i = 0; i < str_length; i++ ) {
    236. 

  236.         c_char = tvb_get_guint8(tvb, foffset );
    237. 

  237.         if (c_char<0x20 || c_char>0x7e) {
    238. 

  238.             if (c_char != 0x00) {
    239. 

  239.                 c_char = 0x2e;
    240. 

  240.                 buffer[i] = c_char & 0xff;
    241. 

  241.             } else {
    242. 

  242.                 i--;
    243. 

  243.                 str_length--;
    244. 

  244.             }
    245. 

  245.         } else {
    246. 

  246.             buffer[i] = c_char & 0xff;
    247. 

  247.         }
    248. 

  248.         foffset++;
    249. 

  249.         length_remaining--;
    250. 

  250. 

  251.         if (length_remaining==1) {
    252. 

  252.             i++;
    253. 

  253.             break;
    254. 

  254.         }
    255. 

  255.     }
    256. 

  256.     buffer[i] = '\0';
    257. 

  257. 

  258.     if (little) {
    259. 

  259.         str_length = tvb_get_letohl(tvb, offset);
    260. 

  260.     } else {
    261. 

  261.         str_length = tvb_get_ntohl(tvb, offset);
    262. 

  262.     }
    263. 

  263.     proto_tree_add_string(nmas_tree, hfinfo, tvb, offset+4, str_length, buffer);
    264. 

  264.     return foffset;
    265. 

  265. }
    266. 

  266. 

  267. void
    268. 

  268. dissect_nmas_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *ncp_tree, ncp_req_hash_value *request_value)
    269. 

  269. {
    270. 

  270.     guint8              /*func,*/ subfunc;
    271. 

  271.     guint32             msg_length=0, cur_string_len=0;
    272. 

  272.     guint32             foffset;
    273. 

  273.     guint32             subverb=0;
    274. 

  274.     guint32             attribute=0;
    275. 

  275.     guint8              msgverb=0;
    276. 

  276.     proto_tree          *atree;
    277. 

  277.     proto_item          *aitem;
    278. 

  278. 

  279.     foffset = 6;
    280. 

  280.     /*func = tvb_get_guint8(tvb, foffset);*/
    281. 

  281.     foffset += 1;
    282. 

  282.     subfunc = tvb_get_guint8(tvb, foffset);
    283. 

  283.     foffset += 1;
    284. 

  284. 

  285.     /* Fill in the INFO column. */
    286. 

  286.     col_set_str(pinfo->cinfo, COL_PROTOCOL, "NMAS");
    287. 

  287.     col_add_fstr(pinfo->cinfo, COL_INFO, "C NMAS - %s",
    288. 

  288.         val_to_str(subfunc, nmas_func_enum, "Unknown (0x%02x)"));
    289. 

  289. 

  290.     aitem = proto_tree_add_text(ncp_tree, tvb, foffset, -1, "Packet Type: %s",
    291. 

  291.         val_to_str(subfunc, nmas_func_enum, "Unknown (0x%02x)"));
    292. 

  292.     atree = proto_item_add_subtree(aitem, ett_nmas);
    293. 

  293.     switch (subfunc) {
    294. 

  294.     case 1:
    295. 

  295.         proto_tree_add_item(atree, hf_ping_version, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    296. 

  296.         foffset += 4;
    297. 

  297.         proto_tree_add_item(atree, hf_ping_flags, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    298. 

  298.         foffset += 4;
    299. 

  299.         break;
    300. 

  300.     case 2:
    301. 

  301.         proto_tree_add_item(atree, hf_frag_handle, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    302. 

  302.         /* Check for Fragment packet */
    303. 

  303.         if (tvb_get_letohl(tvb, foffset)!=0xffffffff) {
    304. 

  304.             break;
    305. 

  305.         }
    306. 

  306.         foffset += 4;
    307. 

  307.         foffset += 4; /* Dont know what this is */
    308. 

  308.         proto_tree_add_item(atree, hf_length, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    309. 

  309.         msg_length = tvb_get_letohl(tvb, foffset);
    310. 

  310.         foffset += 4;
    311. 

  311.         foffset += 12;
    312. 

  312.         msg_length -= 16;
    313. 

  313.         proto_tree_add_item(atree, hf_subverb, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    314. 

  314.         subverb = tvb_get_letohl(tvb, foffset);
    315. 

  315.         if (request_value) {
    316. 

  316.             request_value->req_nds_flags=subverb; /* Store the NMAS fragment verb */
    317. 

  317.         }
    318. 

  318.         foffset += 4;
    319. 

  319.         msg_length -= 4;
    320. 

  320.         col_append_fstr(pinfo->cinfo, COL_INFO, ", %s",
    321. 

  321.             val_to_str(subverb, nmas_subverb_enum, "Unknown subverb (%u)"));
    322. 

  322.         switch (subverb) {
    323. 

  323.         case 0:             /* Fragmented Ping */
    324. 

  324.             proto_tree_add_item(atree, hf_ping_version, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    325. 

  325.             foffset += 4;
    326. 

  326.             proto_tree_add_item(atree, hf_ping_flags, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    327. 

  327.             foffset += 4;
    328. 

  328.             break;
    329. 

  329.         case 2:             /* Client Put Data */
    330. 

  330.             proto_tree_add_item(atree, hf_opaque, tvb, foffset, msg_length, ENC_NA);
    331. 

  331.             foffset += msg_length;
    332. 

  332.             break;
    333. 

  333.         case 4:             /* Client Get Data */
    334. 

  334.         case 6:             /* Client Get User NDS Credentials */
    335. 

  335.             /* No Op */
    336. 

  336.             break;
    337. 

  337.         case 8:             /* Login Store Management */
    338. 

  338.             proto_tree_add_item(atree, hf_reply_buffer_size, tvb, foffset, 1, ENC_LITTLE_ENDIAN);
    339. 

  339.             foffset += 4;
    340. 

  340.             msgverb = tvb_get_guint8(tvb, foffset);
    341. 

  341.             if (request_value) {
    342. 

  342.                 request_value->nds_request_verb=msgverb; /* Use nds_request_verb for passed subverb */
    343. 

  343.             }
    344. 

  344.             proto_tree_add_item(atree, hf_lsm_verb, tvb, foffset, 1, ENC_LITTLE_ENDIAN);
    345. 

  345.             foffset += 4;
    346. 

  346.             col_append_fstr(pinfo->cinfo, COL_INFO, ", %s",
    347. 

  347.                 val_to_str(msgverb, nmas_lsmverb_enum, "Unknown (%u)"));
    348. 

  348. 

  349.             switch (msgverb) {
    350. 

  350.             case 1:
    351. 

  351.                 break;
    352. 

  352.             case 2:
    353. 

  353.                 break;
    354. 

  354.             case 4:
    355. 

  355.                 break;
    356. 

  356.             case 5:
    357. 

  357.                 break;
    358. 

  358.             case 6:
    359. 

  359.                 break;
    360. 

  360.             default:
    361. 

  361.                 break;
    362. 

  362.             }
    363. 

  363.             break;
    364. 

  364.         case 10:            /* Writable Object Check */
    365. 

  365.             /* The first GUINT32 value is the len of the header? */
    366. 

  366.             foffset += 4;
    367. 

  367.             /* The next two GUINT32 values are reserved and always 0 */
    368. 

  368.             foffset += 8;
    369. 

  369.             foffset = nmas_string(tvb, hf_tree, atree, foffset, TRUE);
    370. 

  370.             foffset = nmas_string(tvb, hf_user, atree, foffset, TRUE);
    371. 

  371.             break;
    372. 

  372.         case 1242:          /* Message Handler */
    373. 

  373.             foffset += 4;
    374. 

  374.             proto_tree_add_item(atree, hf_msg_version, tvb, foffset, 4, ENC_BIG_ENDIAN);
    375. 

  375.             foffset += 4;
    376. 

  376.             proto_tree_add_item(atree, hf_session_ident, tvb, foffset, 4, ENC_BIG_ENDIAN);
    377. 

  377.             foffset += 4;
    378. 

  378.             foffset += 3;
    379. 

  379.             msgverb = tvb_get_guint8(tvb, foffset);
    380. 

  380.             if (request_value) {
    381. 

  381.                 request_value->nds_request_verb=msgverb; /* Use nds_request_verb for passed verb */
    382. 

  382.             }
    383. 

  383.             proto_tree_add_item(atree, hf_msg_verb, tvb, foffset, 1, ENC_BIG_ENDIAN);
    384. 

  384.             foffset += 1;
    385. 

  385.             msg_length -= 12;
    386. 

  386.             col_append_fstr(pinfo->cinfo, COL_INFO, ", %s",
    387. 

  387.                 val_to_str(msgverb, nmas_msgverb_enum, "Unknown (%u)"));
    388. 

  388. 

  389.             switch(msgverb) {
    390. 

  390.             case 1:
    391. 

  391.                 msg_length = tvb_get_ntohl(tvb, foffset);
    392. 

  392.                 proto_tree_add_item(atree, hf_length, tvb, foffset, 4, ENC_BIG_ENDIAN);
    393. 

  393.                 foffset += 4;
    394. 

  394.                 proto_tree_add_item(atree, hf_data, tvb, foffset, msg_length, ENC_NA);
    395. 

  395.                 foffset += msg_length;
    396. 

  396.                 break;
    397. 

  397.             case 3:
    398. 

  398.                 msg_length = tvb_get_ntohl(tvb, foffset);
    399. 

  399.                 msg_length -= 4;
    400. 

  400.                 proto_tree_add_item(atree, hf_length, tvb, foffset, 4, ENC_BIG_ENDIAN);
    401. 

  401.                 foffset += 4;
    402. 

  402.                 while (msg_length > 0) {
    403. 

  403.                     attribute = tvb_get_ntohl(tvb, foffset);
    404. 

  404.                     foffset += 4;
    405. 

  405.                     cur_string_len=tvb_get_ntohl(tvb, foffset);
    406. 

  406.                     switch (attribute) {
    407. 

  407.                     case 1:
    408. 

  408.                         foffset = nmas_string(tvb, hf_user, atree, foffset, FALSE);
    409. 

  409.                         break;
    410. 

  410.                     case 2:
    411. 

  411.                         foffset = nmas_string(tvb, hf_tree, atree, foffset, FALSE);
    412. 

  412.                         break;
    413. 

  413.                     case 4:
    414. 

  414.                         foffset = nmas_string(tvb, hf_clearance, atree, foffset, FALSE);
    415. 

  415.                         break;
    416. 

  416.                     case 11:
    417. 

  417.                         foffset = nmas_string(tvb, hf_login_sequence, atree, foffset, FALSE);
    418. 

  418.                         break;
    419. 

  419.                     default:
    420. 

  420.                         break;
    421. 

  421.                     }
    422. 

  422.                     msg_length -= cur_string_len;
    423. 

  423.                     if (tvb_reported_length_remaining(tvb, foffset)<5) {
    424. 

  424.                         break;
    425. 

  425.                     }
    426. 

  426.                 }
    427. 

  427.                 break;
    428. 

  428.             case 5:
    429. 

  429.                 proto_tree_add_item(atree, hf_opaque, tvb, foffset,
    430. 

  430.                     tvb_reported_length_remaining(tvb, foffset), ENC_NA);
    431. 

  431.                 foffset += msg_length;
    432. 

  432.                 break;
    433. 

  433.             case 7:
    434. 

  434.             case 9:
    435. 

  435.                 /* No Op */
    436. 

  436.                 break;
    437. 

  437.             default:
    438. 

  438.                 break;
    439. 

  439.             }
    440. 

  440.             break;
    441. 

  441.         default:
    442. 

  442.             break;
    443. 

  443.         }
    444. 

  444.         break;
    445. 

  445.     case 3:
    446. 

  446.         /* No Op */
    447. 

  447.         break;
    448. 

  448.     default:
    449. 

  449.         break;
    450. 

  450.     }
    451. 

  451. }
    452. 

  452. 

  453. void
    454. 

  454. dissect_nmas_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *ncp_tree, guint8 func _U_, guint8 subfunc, ncp_req_hash_value *request_value)
    455. 

  455. {
    456. 

  456.     guint32             foffset=0, roffset=0;
    457. 

  457.     guint32             subverb=0;
    458. 

  458.     guint8              msgverb=0;
    459. 

  459.     guint32             msg_length=0;
    460. 

  460.     guint32             return_code=0, encrypt_error=0;
    461. 

  461.     proto_tree          *atree;
    462. 

  462.     proto_item          *aitem;
    463. 

  463.     proto_item          *expert_item;
    464. 

  464.     const gchar         *str;
    465. 

  465. 

  466. 

  467.     foffset = 8;
    468. 

  468.     if (request_value) {
    469. 

  469.         subverb = request_value->req_nds_flags;
    470. 

  470.         msgverb = request_value->nds_request_verb;
    471. 

  471.     }
    472. 

  472.     col_set_str(pinfo->cinfo, COL_PROTOCOL, "NMAS");
    473. 

  473.     if (tvb_reported_length_remaining(tvb, foffset)<4) {
    474. 

  474.         return;
    475. 

  475.     }
    476. 

  476. 

  477.     aitem = proto_tree_add_text(ncp_tree, tvb, foffset, -1, "Packet Type: %s",
    478. 

  478.         val_to_str(subfunc, nmas_func_enum, "Unknown (0x%02x)"));
    479. 

  479.     atree = proto_item_add_subtree(aitem, ett_nmas);
    480. 

  480.     switch (subfunc) {
    481. 

  481.     case 1:
    482. 

  482.         proto_tree_add_item(atree, hf_ping_flags, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    483. 

  483.         foffset += 4;
    484. 

  484.         proto_tree_add_item(atree, hf_nmas_version, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    485. 

  485.         foffset += 4;
    486. 

  486.         break;
    487. 

  487.     case 2:
    488. 

  488.         proto_tree_add_text(atree, tvb, foffset, -1, "Verb: %s",
    489. 

  489.             val_to_str(subverb, nmas_subverb_enum, "Unknown (%u)"));
    490. 

  490.         proto_tree_add_item(atree, hf_length, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    491. 

  491.         msg_length = tvb_get_letohl(tvb, foffset);
    492. 

  492.         foffset +=4;
    493. 

  493.         proto_tree_add_item(atree, hf_frag_handle, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    494. 

  494.         /* Check for a fragment packet */
    495. 

  495.         if (tvb_get_letohl(tvb, foffset)!=0xffffffff) {
    496. 

  496.             break;
    497. 

  497.         }
    498. 

  498.         foffset += 4;
    499. 

  499.         return_code = tvb_get_letohl(tvb, foffset);
    500. 

  500.         roffset = foffset;
    501. 

  501.         foffset += 4;
    502. 

  502.         msg_length -= 8;
    503. 

  503.         if (return_code == 0 && msg_length > 0) {
    504. 

  504.             switch (subverb) {
    505. 

  505.             case 0:             /* Fragmented Ping */
    506. 

  506.                 proto_tree_add_item(atree, hf_session_ident, tvb, foffset, 4, ENC_BIG_ENDIAN);
    507. 

  507.                 foffset += 4;
    508. 

  508.                 /*proto_tree_add_item(atree, hf_nmas_version, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    509. 

  509.                 foffset += 4;*/
    510. 

  510.                 break;
    511. 

  511.             case 2:             /* Client Put Data */
    512. 

  512.                 proto_tree_add_item(atree, hf_squeue_bytes, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    513. 

  513.                 foffset += 4;
    514. 

  514.                 proto_tree_add_item(atree, hf_cqueue_bytes, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    515. 

  515.                 foffset += 4;
    516. 

  516.                 break;
    517. 

  517.             case 4:             /* Client Get Data */
    518. 

  518.                 proto_tree_add_item(atree, hf_opaque, tvb, foffset, msg_length, ENC_NA);
    519. 

  519.                 foffset += msg_length;
    520. 

  520.                 break;
    521. 

  521.             case 6:             /* Client Get User NDS Credentials */
    522. 

  522.                 proto_tree_add_item(atree, hf_num_creds, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    523. 

  523.                 foffset += 4;
    524. 

  524.                 proto_tree_add_item(atree, hf_cred_type, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    525. 

  525.                 foffset += 4;
    526. 

  526.                 proto_tree_add_item(atree, hf_login_state, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    527. 

  527.                 foffset += 4;
    528. 

  528.                 msg_length -= 12;
    529. 

  529.                 proto_tree_add_item(atree, hf_enc_cred, tvb, foffset, msg_length, ENC_NA);
    530. 

  530.                 foffset += msg_length;
    531. 

  531.                 break;
    532. 

  532.             case 8:             /* Login Store Management */
    533. 

  533.                 proto_tree_add_text(atree, tvb, foffset, -1, "Subverb: %s",
    534. 

  534.                     val_to_str(msgverb, nmas_lsmverb_enum, "Unknown (%u)"));
    535. 

  535.                 switch(msgverb) {
    536. 

  536.                     /* The data within these structures is all encrypted. */
    537. 

  537.                 case 1:
    538. 

  538.                 case 3:
    539. 

  539.                 case 5:
    540. 

  540.                 case 7:
    541. 

  541.                 case 9:
    542. 

  542.                     proto_tree_add_item(atree, hf_enc_data, tvb, foffset, msg_length, ENC_NA);
    543. 

  543.                     foffset += msg_length;
    544. 

  544.                     break;
    545. 

  545.                 default:
    546. 

  546.                     break;
    547. 

  547.                 }
    548. 

  548.                 break;
    549. 

  549.             case 10:            /* Writable Object Check */
    550. 

  550.                 proto_tree_add_item(atree, hf_nmas_version, tvb, foffset, 4, ENC_LITTLE_ENDIAN);
    551. 

  551.                 foffset += 4;
    552. 

  552.                 break;
    553. 

  553.             case 1242:          /* Message Handler */
    554. 

  554.                 proto_tree_add_text(atree, tvb, foffset, -1, "Subverb: %s",
    555. 

  555.                                     val_to_str(msgverb, nmas_msgverb_enum, "Unknown (%u)"));
    556. 

  556.                 switch(msgverb) {
    557. 

  557.                 case 1:
    558. 

  558.                     msg_length = tvb_get_ntohl(tvb, foffset);
    559. 

  559.                     proto_tree_add_item(atree, hf_length, tvb, foffset, 4, ENC_BIG_ENDIAN);
    560. 

  560.                     foffset += 4;
    561. 

  561.                     proto_tree_add_item(atree, hf_data, tvb, foffset, msg_length, ENC_NA);
    562. 

  562.                     foffset += msg_length;
    563. 

  563.                     break;
    564. 

  564.                 case 3:
    565. 

  565.                     proto_tree_add_item(atree, hf_session_ident, tvb, foffset, 4, ENC_BIG_ENDIAN);
    566. 

  566.                     foffset += 4;
    567. 

  567.                     break;
    568. 

  568.                 case 5:
    569. 

  569.                     /* No Op */
    570. 

  570.                     break;
    571. 

  571.                 case 7:
    572. 

  572.                     encrypt_error = tvb_get_ntohl(tvb, foffset);
    573. 

  573.                     str = try_val_to_str(encrypt_error, nmas_errors_enum);
    574. 

  574.                     if (str) {
    575. 

  575.                         col_add_fstr(pinfo->cinfo, COL_INFO, "R Payload Error - %s", str);
    576. 

  576.                         expert_item = proto_tree_add_item(atree, hf_encrypt_error, tvb, foffset, 4, ENC_BIG_ENDIAN);
    577. 

  577.                         expert_add_info_format_text(pinfo, expert_item, &ei_encrypt_error, "NMAS Payload Error: %s", str);
    578. 

  578.                     } else {
    579. 

  579.                         proto_tree_add_item(atree, hf_opaque, tvb, foffset, msg_length, ENC_NA);
    580. 

  580.                     }
    581. 

  581.                     foffset += msg_length;
    582. 

  582.                     break;
    583. 

  583.                 case 9:
    584. 

  584.                     /* No Op */
    585. 

  585.                     break;
    586. 

  586.                 default:
    587. 

  587.                     break;
    588. 

  588.                 }
    589. 

  589.                 break;
    590. 

  590.             default:
    591. 

  591.                 break;
    592. 

  592.             }
    593. 

  593.         }
    594. 

  594.         str = try_val_to_str(return_code, nmas_errors_enum);
    595. 

  595.         if (str) {
    596. 

  596.             expert_item = proto_tree_add_item(atree, hf_return_code, tvb, roffset, 4, ENC_LITTLE_ENDIAN);
    597. 

  597.             expert_add_info_format_text(pinfo, expert_item, &ei_return_error, "NMAS Error: 0x%08x %s", return_code, str);
    598. 

  598.             col_add_fstr(pinfo->cinfo, COL_INFO, "R Error - %s", str);
    599. 

  599.         } else {
    600. 

  600.             if (return_code!=0) {
    601. 

  601.                 expert_item = proto_tree_add_item(atree, hf_return_code, tvb, roffset, 4, ENC_LITTLE_ENDIAN);
    602. 

  602.                 expert_add_info_format_text(pinfo, expert_item, &ei_return_error, "NMAS Error: 0x%08x is unknown", return_code);
    603. 

  603.                 col_add_fstr(pinfo->cinfo, COL_INFO, "R Unknown NMAS Error - 0x%08x", return_code);
    604. 

  604.             }
    605. 

  605.         }
    606. 

  606. 

  607.         if (return_code == 0) {
    608. 

  608.             proto_tree_add_text(atree, tvb, roffset, 4, "Return Code: Success (0x00000000)");
    609. 

  609.         }
    610. 

  610.         break;
    611. 

  611.     case 3:
    612. 

  612.         break;
    613. 

  613.     default:
    614. 

  614.         break;
    615. 

  615.     }
    616. 

  616. }
    617. 

  617. 

  618. void
    619. 

  619. proto_register_nmas(void)
    620. 

  620. {
    621. 

  621.     static hf_register_info hf_nmas[] = {
    622. 

  622. #if 0
    623. 

  623.         { &hf_func,
    624. 

  624.         { "Function", "nmas.func",
    625. 

  625.             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
    626. 

  626. #endif
    627. 

  627. 

  628. #if 0
    629. 

  629.         { &hf_subfunc,
    630. 

  630.         { "Subfunction", "nmas.subfunc",
    631. 

  631.             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
    632. 

  632. #endif
    633. 

  633. 

  634.         { &hf_ping_version,
    635. 

  635.         { "Ping Version", "nmas.ping_version",
    636. 

  636.             FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }},
    637. 

  637. 

  638.         { &hf_ping_flags,
    639. 

  639.         { "Flags", "nmas.ping_flags",
    640. 

  640.             FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }},
    641. 

  641. 

  642.         { &hf_frag_handle,
    643. 

  643.         { "Fragment Handle", "nmas.frag_handle",
    644. 

  644.             FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }},
    645. 

  645. 

  646.         { &hf_length,
    647. 

  647.         { "Length", "nmas.length",
    648. 

  648.             FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
    649. 

  649. 

  650.         { &hf_subverb,
    651. 

  651.         { "Sub Verb", "nmas.subverb",
    652. 

  652.             FT_UINT32, BASE_HEX, VALS(nmas_subverb_enum), 0x0, NULL, HFILL }},
    653. 

  653. 

  654.         { &hf_tree,
    655. 

  655.         { "Tree", "nmas.tree",
    656. 

  656.             FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
    657. 

  657. 

  658.         { &hf_user,
    659. 

  659.         { "User", "nmas.user",
    660. 

  660.             FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
    661. 

  661. 

  662.         { &hf_nmas_version,
    663. 

  663.         { "NMAS Protocol Version", "nmas.version",
    664. 

  664.             FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }},
    665. 

  665. 

  666.         { &hf_msg_version,
    667. 

  667.         { "Message Version", "nmas.msg_version",
    668. 

  668.             FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }},
    669. 

  669. 

  670.         { &hf_session_ident,
    671. 

  671.         { "Session Identifier", "nmas.session_ident",
    672. 

  672.             FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }},
    673. 

  673. 

  674.         { &hf_msg_verb,
    675. 

  675.         { "Message Verb", "nmas.msg_verb",
    676. 

  676.             FT_UINT8, BASE_HEX, VALS(nmas_msgverb_enum), 0x0, NULL, HFILL }},
    677. 

  677. 

  678. #if 0
    679. 

  679.         { &hf_attribute,
    680. 

  680.         { "Attribute Type", "nmas.attribute",
    681. 

  681.             FT_UINT32, BASE_DEC, VALS(nmas_attribute_enum), 0x0, NULL, HFILL }},
    682. 

  682. #endif
    683. 

  683. 

  684.         { &hf_clearance,
    685. 

  685.         { "Requested Clearance", "nmas.clearance",
    686. 

  686.             FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
    687. 

  687. 

  688.         { &hf_login_sequence,
    689. 

  689.         { "Requested Login Sequence", "nmas.login_seq",
    690. 

  690.             FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
    691. 

  691. 

  692.         { &hf_opaque,
    693. 

  693.         { "Opaque Data", "nmas.opaque",
    694. 

  694.             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
    695. 

  695. 

  696.         { &hf_data,
    697. 

  697.         { "Data", "nmas.data",
    698. 

  698.             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
    699. 

  699. 

  700.         { &hf_return_code,
    701. 

  701.         { "Return Code", "nmas.return_code",
    702. 

  702.             FT_UINT32, BASE_HEX, VALS(nmas_errors_enum), 0x0, NULL, HFILL }},
    703. 

  703. 

  704.         { &hf_lsm_verb,
    705. 

  705.         { "Login Store Message Verb", "nmas.lsm_verb",
    706. 

  706.             FT_UINT8, BASE_HEX, VALS(nmas_lsmverb_enum), 0x0, NULL, HFILL }},
    707. 

  707. 

  708.         { &hf_squeue_bytes,
    709. 

  709.         { "Server Queue Number of Bytes", "nmas.squeue_bytes",
    710. 

  710.             FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
    711. 

  711. 

  712.         { &hf_cqueue_bytes,
    713. 

  713.         { "Client Queue Number of Bytes", "nmas.cqueue_bytes",
    714. 

  714.             FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
    715. 

  715. 

  716.         { &hf_num_creds,
    717. 

  717.         { "Number of Credentials", "nmas.num_creds",
    718. 

  718.             FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
    719. 

  719. 

  720.         { &hf_cred_type,
    721. 

  721.         { "Credential Type", "nmas.cred_type",
    722. 

  722.             FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
    723. 

  723. 

  724.         { &hf_login_state,
    725. 

  725.         { "Login State", "nmas.login_state",
    726. 

  726.             FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
    727. 

  727. 

  728.         { &hf_enc_cred,
    729. 

  729.         { "Encrypted Credential", "nmas.enc_cred",
    730. 

  730.           FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
    731. 

  731. 

  732.         { &hf_enc_data,
    733. 

  733.         { "Encrypted Data", "nmas.enc_data",
    734. 

  734.           FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
    735. 

  735. 

  736.         { &hf_reply_buffer_size,
    737. 

  737.         { "Reply Buffer Size", "nmas.buf_size",
    738. 

  738.             FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
    739. 

  739. 

  740.         { &hf_encrypt_error,
    741. 

  741.         { "Payload Error", "nmas.encrypt_error",
    742. 

  742.             FT_UINT32, BASE_HEX, VALS(nmas_errors_enum), 0x0,
    743. 

  743.             "Payload/Encryption Return Code", HFILL }}
    744. 

  744.     };
    745. 

  745. 

  746.     static gint *ett[] = {
    747. 

  747.         &ett_nmas
    748. 

  748.     };
    749. 

  749. 

  750.     static ei_register_info ei[] = {
    751. 

  751.         { &ei_encrypt_error, { "nmas.encrypt_error.expert", PI_RESPONSE_CODE, PI_NOTE, "NMAS Payload Erro", EXPFILL }},
    752. 

  752.         { &ei_return_error, { "nmas.return_code.expert", PI_RESPONSE_CODE, PI_NOTE, "NMAS Error", EXPFILL }},
    753. 

  753.     };
    754. 

  754. 

  755.     expert_module_t* expert_nmas;
    756. 

  756. 

  757.     proto_nmas = proto_register_protocol("Novell Modular Authentication Service", "NMAS", "nmas");
    758. 

  758.     proto_register_field_array(proto_nmas, hf_nmas, array_length(hf_nmas));
    759. 

  759.     proto_register_subtree_array(ett, array_length(ett));
    760. 

  760.     expert_nmas = expert_register_protocol(proto_nmas);
    761. 

  761.     expert_register_field_array(expert_nmas, ei, array_length(ei));
    762. 

  762. }
    763. 

  763. 

  764. /*
    765. 

  765.  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
    766. 

  766.  *
    767. 

  767.  * Local variables:
    768. 

  768.  * c-basic-offset: 4
    769. 

  769.  * tab-width: 4
    770. 

  770.  * indent-tabs-mode: nil
    771. 

  771.  * End:
    772. 

  772.  *
    773. 

  773.  * vi: set shiftwidth=4 tabstop=4 expandtab:
    774. 

  774.  * :indentSize=4:tabSize=4:noTabs=true:
    775. 

  775.  */
    776. 

  776. 

  777.