1#!/usr/bin/env python
2# -*- coding: utf-8 -*-
3
4# ***********************IMPORTANT NMAP LICENSE TERMS************************
5# *                                                                         *
6# * The Nmap Security Scanner is (C) 1996-2020 Insecure.Com LLC ("The Nmap  *
7# * Project"). Nmap is also a registered trademark of the Nmap Project.     *
8# *                                                                         *
9# * This program is distributed under the terms of the Nmap Public Source   *
10# * License (NPSL). The exact license text applying to a particular Nmap    *
11# * release or source code control revision is contained in the LICENSE     *
12# * file distributed with that version of Nmap or source code control       *
13# * revision. More Nmap copyright/legal information is available from       *
14# * https://nmap.org/book/man-legal.html, and further information on the    *
15# * NPSL license itself can be found at https://nmap.org/npsl. This header  *
16# * summarizes some key points from the Nmap license, but is no substitute  *
17# * for the actual license text.                                            *
18# *                                                                         *
19# * Nmap is generally free for end users to download and use themselves,    *
20# * including commercial use. It is available from https://nmap.org.        *
21# *                                                                         *
22# * The Nmap license generally prohibits companies from using and           *
23# * redistributing Nmap in commercial products, but we sell a special Nmap  *
24# * OEM Edition with a more permissive license and special features for     *
25# * this purpose. See https://nmap.org/oem                                  *
26# *                                                                         *
27# * If you have received a written Nmap license agreement or contract       *
28# * stating terms other than these (such as an Nmap OEM license), you may   *
29# * choose to use and redistribute Nmap under those terms instead.          *
30# *                                                                         *
31# * The official Nmap Windows builds include the Npcap software             *
32# * (https://npcap.org) for packet capture and transmission. It is under    *
33# * separate license terms which forbid redistribution without special      *
34# * permission. So the official Nmap Windows builds may not be              *
35# * redistributed without special permission (such as an Nmap OEM           *
36# * license).                                                               *
37# *                                                                         *
38# * Source is provided to this software because we believe users have a     *
39# * right to know exactly what a program is going to do before they run it. *
40# * This also allows you to audit the software for security holes.          *
41# *                                                                         *
42# * Source code also allows you to port Nmap to new platforms, fix bugs,    *
43# * and add new features.  You are highly encouraged to submit your         *
44# * changes as a Github PR or by email to the dev@nmap.org mailing list     *
45# * for possible incorporation into the main distribution. Unless you       *
46# * specify otherwise, it is understood that you are offering us very       *
47# * broad rights to use your submissions as described in the Nmap Public    *
48# * Source License Contributor Agreement. This is important because we      *
49# * fund the project by selling licenses with various terms, and also       *
50# * because the inability to relicense code has caused devastating          *
51# * problems for other Free Software projects (such as KDE and NASM).       *
52# *                                                                         *
53# * The free version of Nmap is distributed in the hope that it will be     *
54# * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of  *
55# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Warranties,        *
56# * indemnification and commercial support are all available through the    *
57# * Npcap OEM program--see https://nmap.org/oem.                            *
58# *                                                                         *
59# ***************************************************************************/
60
61import gtk
62
63from zenmapGUI.higwidgets.higboxes import HIGVBox
64
65from zenmapCore.UmitLogging import log
66import zenmapCore.I18N  # lgtm[py/unused-import]
67
68
69def findout_service_icon(port_info):
70    if port_info["port_state"] in ["open", "open|filtered"]:
71        return gtk.STOCK_YES
72    else:
73        return gtk.STOCK_NO
74
75
76def get_version_string(d):
77    """Get a human-readable version string from the dict d. The keys used in d
78    are "service_product", "service_version", and "service_extrainfo" (all are
79    optional). This produces a string like "OpenSSH 4.3p2 Debian 9etch2
80    (protocol 2.0)"."""
81    result = []
82    if d.get("service_product"):
83        result.append(d["service_product"])
84    if d.get("service_version"):
85        result.append(d["service_version"])
86    if d.get("service_extrainfo"):
87        result.append("(" + d["service_extrainfo"] + ")")
88    return " ".join(result)
89
90
91def get_addrs(host):
92    if host is None:
93        return None
94    return host.get_addrs_for_sort()
95
96
97def cmp_addrs(host_a, host_b):
98    return cmp(get_addrs(host_a), get_addrs(host_b))
99
100
101def cmp_port_list_addr(model, iter_a, iter_b):
102    host_a = model.get_value(iter_a, 0)
103    host_b = model.get_value(iter_b, 0)
104    return cmp_addrs(host_a, host_b)
105
106
107def cmp_port_tree_addr(model, iter_a, iter_b):
108    host_a = model.get_value(iter_a, 0)
109    host_b = model.get_value(iter_b, 0)
110    return cmp_addrs(host_a, host_b)
111
112
113def cmp_host_list_addr(model, iter_a, iter_b):
114    host_a = model.get_value(iter_a, 2)
115    host_b = model.get_value(iter_b, 2)
116    return cmp_addrs(host_a, host_b)
117
118
119def cmp_host_tree_addr(model, iter_a, iter_b):
120    host_a = model.get_value(iter_a, 2)
121    host_b = model.get_value(iter_b, 2)
122    return cmp_addrs(host_a, host_b)
123
124
125class ScanOpenPortsPage(gtk.ScrolledWindow):
126    def __init__(self):
127        gtk.ScrolledWindow.__init__(self)
128        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
129
130        self.__create_widgets()
131
132        self.add_with_viewport(self.host)
133
134    def __create_widgets(self):
135        self.host = HostOpenPorts()
136
137
138class HostOpenPorts(HIGVBox):
139    def __init__(self):
140        HIGVBox.__init__(self)
141
142        self._create_widgets()
143        self._set_port_list()
144        self._set_host_list()
145        self._pack_widgets()
146
147    def _create_widgets(self):
148        # Ports view
149        self.port_columns = {}
150        # host hostname icon port protocol state service version
151        # The hostname column is shown only when more than one host is selected
152        # (hence port_tree not port_list is used).
153        self.port_list = gtk.ListStore(
154                object, str, str, int, str, str, str, str)
155        self.port_tree = gtk.TreeStore(
156                object, str, str, int, str, str, str, str)
157
158        self.port_list.set_sort_func(1000, cmp_port_list_addr)
159        self.port_list.set_sort_column_id(1000, gtk.SORT_ASCENDING)
160        self.port_tree.set_sort_func(1000, cmp_port_tree_addr)
161        self.port_tree.set_sort_column_id(1000, gtk.SORT_ASCENDING)
162
163        self.port_view = gtk.TreeView(self.port_list)
164
165        self.cell_icon = gtk.CellRendererPixbuf()
166        self.cell_port = gtk.CellRendererText()
167
168        self.port_columns['hostname'] = gtk.TreeViewColumn(_('Host'))
169        self.port_columns['icon'] = gtk.TreeViewColumn('')
170        self.port_columns['port_number'] = gtk.TreeViewColumn(_('Port'))
171        self.port_columns['protocol'] = gtk.TreeViewColumn(_('Protocol'))
172        self.port_columns['state'] = gtk.TreeViewColumn(_('State'))
173        self.port_columns['service'] = gtk.TreeViewColumn(_('Service'))
174        self.port_columns['version'] = gtk.TreeViewColumn(_('Version'))
175
176        # Host services view
177        self.host_columns = {}
178        # service icon host hostname port protocol state version
179        # service is shown only when more than one service is selected (hence
180        # host_tree not host_list is used).
181        self.host_list = gtk.ListStore(
182                str, str, object, str, int, str, str, str)
183        self.host_tree = gtk.TreeStore(
184                str, str, object, str, int, str, str, str)
185
186        self.host_list.set_sort_func(1000, cmp_host_list_addr)
187        self.host_list.set_sort_column_id(1000, gtk.SORT_ASCENDING)
188        self.host_tree.set_sort_func(1000, cmp_host_tree_addr)
189        self.host_tree.set_sort_column_id(1000, gtk.SORT_ASCENDING)
190
191        self.host_view = gtk.TreeView(self.host_list)
192
193        self.cell_host_icon = gtk.CellRendererPixbuf()
194        self.cell_host = gtk.CellRendererText()
195
196        self.host_columns['service'] = gtk.TreeViewColumn(_('Service'))
197        self.host_columns['icon'] = gtk.TreeViewColumn('')
198        self.host_columns['hostname'] = gtk.TreeViewColumn(_('Hostname'))
199        self.host_columns['protocol'] = gtk.TreeViewColumn(_('Protocol'))
200        self.host_columns['port_number'] = gtk.TreeViewColumn(_('Port'))
201        self.host_columns['state'] = gtk.TreeViewColumn(_('State'))
202        self.host_columns['version'] = gtk.TreeViewColumn(_('Version'))
203
204        self.scroll_ports_hosts = gtk.ScrolledWindow()
205
206    def _set_host_list(self):
207        self.host_view.set_enable_search(True)
208        self.host_view.set_search_column(2)
209
210        selection = self.host_view.get_selection()
211        selection.set_mode(gtk.SELECTION_MULTIPLE)
212
213        columns = ["service", "icon", "hostname", "port_number",
214                   "protocol", "state", "version"]
215
216        for c in columns:
217            self.host_view.append_column(self.host_columns[c])
218            self.host_columns[c].set_reorderable(True)
219            self.host_columns[c].set_resizable(True)
220
221        self.host_columns['service'].set_sort_column_id(0)
222        self.host_columns['icon'].set_min_width(35)
223        self.host_columns['icon'].set_sort_column_id(6)
224        self.host_columns['hostname'].set_sort_column_id(1000)
225        self.host_columns['port_number'].set_sort_column_id(4)
226        self.host_columns['protocol'].set_sort_column_id(5)
227        self.host_columns['state'].set_sort_column_id(6)
228        self.host_columns['version'].set_sort_column_id(7)
229
230        self.host_columns['service'].pack_start(self.cell_port, True)
231        self.host_columns['icon'].pack_start(self.cell_host_icon, True)
232        self.host_columns['hostname'].pack_start(self.cell_port, True)
233        self.host_columns['port_number'].pack_start(self.cell_port, True)
234        self.host_columns['protocol'].pack_start(self.cell_port, True)
235        self.host_columns['version'].pack_start(self.cell_port, True)
236        self.host_columns['state'].pack_start(self.cell_port, True)
237
238        self.host_columns['service'].set_attributes(self.cell_port, text=0)
239        self.host_columns['icon'].set_attributes(
240                self.cell_host_icon, stock_id=1)
241        self.host_columns['hostname'].set_attributes(self.cell_port, text=3)
242        self.host_columns['port_number'].set_attributes(self.cell_port, text=4)
243        self.host_columns['protocol'].set_attributes(self.cell_port, text=5)
244        self.host_columns['state'].set_attributes(self.cell_port, text=6)
245        self.host_columns['version'].set_attributes(self.cell_port, text=7)
246
247        self.host_columns['service'].set_visible(False)
248
249        self.scroll_ports_hosts.set_policy(
250                gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
251
252    def _set_port_list(self):
253        self.port_view.set_enable_search(True)
254        self.port_view.set_search_column(3)
255
256        selection = self.port_view.get_selection()
257        selection.set_mode(gtk.SELECTION_MULTIPLE)
258
259        self.port_view.append_column(self.port_columns['hostname'])
260        self.port_view.append_column(self.port_columns['icon'])
261        self.port_view.append_column(self.port_columns['port_number'])
262        self.port_view.append_column(self.port_columns['protocol'])
263        self.port_view.append_column(self.port_columns['state'])
264        self.port_view.append_column(self.port_columns['service'])
265        self.port_view.append_column(self.port_columns['version'])
266
267        for k in self.port_columns:
268            self.port_columns[k].set_reorderable(True)
269            self.port_columns[k].set_resizable(True)
270
271        self.port_columns['icon'].set_min_width(35)
272
273        self.port_columns['hostname'].set_sort_column_id(1000)
274        self.port_columns['icon'].set_sort_column_id(5)
275        self.port_columns['port_number'].set_sort_column_id(3)
276        self.port_columns['protocol'].set_sort_column_id(4)
277        self.port_columns['state'].set_sort_column_id(5)
278        self.port_columns['service'].set_sort_column_id(6)
279        self.port_columns['version'].set_sort_column_id(7)
280
281        self.port_columns['hostname'].pack_start(self.cell_port, True)
282        self.port_columns['icon'].pack_start(self.cell_icon, True)
283        self.port_columns['port_number'].pack_start(self.cell_port, True)
284        self.port_columns['protocol'].pack_start(self.cell_port, True)
285        self.port_columns['service'].pack_start(self.cell_port, True)
286        self.port_columns['version'].pack_start(self.cell_port, True)
287        self.port_columns['state'].pack_start(self.cell_port, True)
288
289        self.port_columns['hostname'].set_attributes(self.cell_port, text=1)
290        self.port_columns['icon'].set_attributes(self.cell_icon, stock_id=2)
291        self.port_columns['port_number'].set_attributes(self.cell_port, text=3)
292        self.port_columns['protocol'].set_attributes(self.cell_port, text=4)
293        self.port_columns['state'].set_attributes(self.cell_port, text=5)
294        self.port_columns['service'].set_attributes(self.cell_port, text=6)
295        self.port_columns['version'].set_attributes(self.cell_port, text=7)
296
297        self.port_columns['hostname'].set_visible(False)
298
299        self.scroll_ports_hosts.set_policy(
300                gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
301
302    def port_mode(self):
303        child = self.scroll_ports_hosts.get_child()
304        if id(child) != id(self.port_view):
305            if child is not None:
306                self.scroll_ports_hosts.remove(child)
307            self.scroll_ports_hosts.add(self.port_view)
308            self.port_view.show_all()
309            self.host_view.hide()
310
311    def host_mode(self):
312        child = self.scroll_ports_hosts.get_child()
313        if id(child) != id(self.host_view):
314            if child is not None:
315                self.scroll_ports_hosts.remove(child)
316            self.scroll_ports_hosts.add(self.host_view)
317            self.host_view.show_all()
318            self.port_view.hide()
319
320    def freeze(self):
321        """Freeze notifications and sorting to make adding lots of elements to
322        the model faster."""
323        self.frozen_host_list_sort_column_id = \
324                self.host_list.get_sort_column_id()
325        self.frozen_host_tree_sort_column_id = \
326                self.host_tree.get_sort_column_id()
327        self.frozen_port_list_sort_column_id = \
328                self.port_list.get_sort_column_id()
329        self.frozen_port_tree_sort_column_id = \
330                self.port_tree.get_sort_column_id()
331        self.host_list.set_default_sort_func(lambda *args: -1)
332        self.host_tree.set_default_sort_func(lambda *args: -1)
333        self.port_list.set_default_sort_func(lambda *args: -1)
334        self.port_tree.set_default_sort_func(lambda *args: -1)
335        self.frozen_host_view_model = self.host_view.get_model()
336        self.frozen_port_view_model = self.port_view.get_model()
337        self.host_view.freeze_child_notify()
338        self.port_view.freeze_child_notify()
339        self.host_view.set_model(None)
340        self.port_view.set_model(None)
341
342    def thaw(self):
343        """Restore notifications and sorting (after making changes to the
344        model)."""
345        if self.frozen_host_list_sort_column_id != (None, None):
346            self.host_list.set_sort_column_id(
347                    *self.frozen_host_list_sort_column_id)
348        if self.frozen_host_tree_sort_column_id != (None, None):
349            self.host_tree.set_sort_column_id(
350                    *self.frozen_host_tree_sort_column_id)
351        if self.frozen_port_list_sort_column_id != (None, None):
352            self.port_list.set_sort_column_id(
353                    *self.frozen_port_list_sort_column_id)
354        if self.frozen_port_tree_sort_column_id != (None, None):
355            self.port_tree.set_sort_column_id(
356                    *self.frozen_port_tree_sort_column_id)
357        self.host_view.set_model(self.frozen_host_view_model)
358        self.port_view.set_model(self.frozen_port_view_model)
359        self.host_view.thaw_child_notify()
360        self.port_view.thaw_child_notify()
361
362    def add_to_port_list(self, p):
363        entry = [None, "", findout_service_icon(p), int(p.get('portid', '0')),
364            p.get('protocol', ''), p.get('port_state', ''),
365            p.get('service_name', ''), get_version_string(p)]
366        log.debug(">>> Add Port: %s" % entry)
367        self.port_list.append(entry)
368
369    def add_to_host_list(self, host, p):
370        entry = ["", findout_service_icon(p), host, host.get_hostname(),
371            int(p.get('portid', '0')), p.get('protocol', ''),
372            p.get('port_state', ''), get_version_string(p)]
373        log.debug(">>> Add Host: %s" % entry)
374        self.host_list.append(entry)
375
376    def add_to_port_tree(self, host):
377        parent = self.port_tree.append(
378                None, [host, host.get_hostname(), None, 0, '', '', '', ''])
379        for p in host.get_ports():
380            self.port_tree.append(parent,
381                [None, '', findout_service_icon(p), int(p.get('portid', "0")),
382                p.get('protocol', ''), p.get('port_state', ""),
383                p.get('service_name', _("Unknown")), get_version_string(p)])
384
385    def add_to_host_tree(self, service_name, ports):
386        parent = self.host_tree.append(
387                None, [service_name, '', None, '', 0, '', '', ''])
388        for p in ports:
389            self.host_tree.append(parent,
390                    [
391                        '',
392                        findout_service_icon(p),
393                        p["host"],
394                        p["host"].get_hostname(),
395                        int(p.get('portid', "0")),
396                        p.get('protocol', ""),
397                        p.get('port_state', _("Unknown")),
398                        get_version_string(p)
399                    ]
400                )
401
402    def switch_port_to_list_store(self):
403        if self.port_view.get_model() != self.port_list:
404            self.port_view.set_model(self.port_list)
405            self.port_columns['hostname'].set_visible(False)
406
407    def switch_port_to_tree_store(self):
408        if self.port_view.get_model() != self.port_tree:
409            self.port_view.set_model(self.port_tree)
410            self.port_columns['hostname'].set_visible(True)
411
412    def switch_host_to_list_store(self):
413        if self.host_view.get_model() != self.host_list:
414            self.host_view.set_model(self.host_list)
415            self.host_columns['service'].set_visible(False)
416
417    def switch_host_to_tree_store(self):
418        if self.host_view.get_model() != self.host_tree:
419            self.host_view.set_model(self.host_tree)
420            self.host_columns['service'].set_visible(True)
421
422    def _pack_widgets(self):
423        self.scroll_ports_hosts.add(self.port_view)
424        self._pack_expand_fill(self.scroll_ports_hosts)
425
426    def clear_port_list(self):
427        for i in range(len(self.port_list)):
428            iter = self.port_list.get_iter_root()
429            del(self.port_list[iter])
430
431    def clear_host_list(self):
432        for i in range(len(self.host_list)):
433            iter = self.host_list.get_iter_root()
434            del(self.host_list[iter])
435
436    def clear_port_tree(self):
437        for i in range(len(self.port_tree)):
438            iter = self.port_tree.get_iter_root()
439            del(self.port_tree[iter])
440
441    def clear_host_tree(self):
442        for i in range(len(self.host_tree)):
443            iter = self.host_tree.get_iter_root()
444            del(self.host_tree[iter])
445
446if __name__ == "__main__":
447    w = gtk.Window()
448    h = HostOpenPorts()
449    w.add(h)
450    w.show_all()
451
452    gtk.main()
453