├── README.md
├── bin
    └── Panorama.exe
└── src
    ├── Panorama.py
    ├── actions
        ├── Files.py
        ├── Report.py
        └── __init__.py
    ├── common
        ├── __init__.py
        ├── encodedFiles.py
        └── paths.py
    ├── gui
        ├── MainWindow.py
        ├── __init__.py
        └── logView.py
    ├── lib
        ├── Registry.py
        └── __init__.py
    ├── panorama.ico
    └── utils
        ├── HTML.py
        ├── TXT.py
        ├── __init__.py
        ├── forensic.py
        ├── getters.py
        └── parsers.py


/README.md:
--------------------------------------------------------------------------------
 1 | [<img src="https://cloud.githubusercontent.com/assets/15038417/18474722/2f78cc4e-79cc-11e6-801e-b8efd70ba471.png" width="380" />](https://cloud.githubusercontent.com/assets/15038417/18474722/2f78cc4e-79cc-11e6-801e-b8efd70ba471.png)
 2 | 
 3 | ### What is PANORAMA?
 4 | Panorama was made to generate a wide report about Windows systems, support and tested on Windows XP SP2 and up.
 5 | 
 6 | Provide a fast solution as giving an initial overview to the incident, Currently performing quite basic report.
 7 | 
 8 | The tool doesn't require admin permissions and yet can provide you a professional report on any Windows computer locally or throughout the network (Using without GUI).
 9 | 
10 | New - 'Files Finder' - Map all media files, Currenlty available from GUI only. (doc, docx, ppt, pptx, PDF, gif, png, jpg, jped, wmv, mp4, avi)
11 | 
12 | Report structure
13 | ---------
14 | #### System:
15 |   1. Users - Password, Admin, Last logon, Last password update
16 |   2. Startup commands - Command, Active
17 |   3. Task scheduler - Name, Next run, Status
18 |   4. Installed Softwares - List
19 |   5. Recently used files - List
20 |   4. Active processes - Name, ID, Communication
21 | 
22 | 
23 | #### Security:
24 |   1. McAfee - Version, Dat Date, Quarantine, Exclusions, Logs
25 |   2. Firewall - Status, Allowed applications
26 |   3. Microsoft hotfixes - Date, List of packages
27 | 
28 | 
29 | #### Networking:
30 |   1. Network cards - List
31 |   2. IP Address - IP, Gateway, DHCP, Date, IPv6
32 |   3. MAC Address - List
33 |   4. Net view - List
34 |   5. Netstat - Local, Target, ID, Process, Status
35 |   6. ARP Table - IP, MAC, Type
36 |   7. Hosts file - Domain, Target IP
37 |   
38 | 
39 | #### USB:
40 |   1. USB - Name, Type, Serial number, Date
41 |   2. USB Deview - Link
42 |   
43 | 
44 | Report output options:
45 | ---------
46 |   1. HTML - Web page
47 |   2. Text file
48 |  
49 | Quick USER guide:
50 | ---------
51 |   1. Run 'Panorama.exe' from bin folder:
52 |   
53 |     2.1 Double-click OR from CMD without arguments - Opens the GUI
54 |     
55 |     2.2 Run from CMD - with argument '-c' - writes the results to TXT file (%temp%/panorama):
56 |     
57 |     ```Panorama.exe -c```
58 |   
59 |   3. Can run from CMD with argument '-h' to see the tiny help screen.
60 |     
61 |   4. NO admin permissions is required :)
62 | 
63 | Compile:
64 | ---------
65 | The original Panorama file compiled by:
66 | 
67 | ```c:\Python27\Scripts\pyinstaller.exe --onefile --window --icon=panorama.ico Panorama.py```
68 | 
69 | Screenshots:
70 | ---------
71 | [<img src="https://cloud.githubusercontent.com/assets/15038417/21966272/4b64c304-db79-11e6-98e8-1f9504fcc5bc.png" width="200" height="200" />](https://cloud.githubusercontent.com/assets/15038417/21966272/4b64c304-db79-11e6-98e8-1f9504fcc5bc.png)
72 | 
73 | Web report view:
74 | 
75 | [<img src="https://cloud.githubusercontent.com/assets/15038417/21966282/669acc54-db79-11e6-9acb-afd86140327a.png" width="200" height="110" />](https://cloud.githubusercontent.com/assets/15038417/21966282/669acc54-db79-11e6-9acb-afd86140327a.png)
76 | 
77 | Text report view:
78 | 
79 | [<img src="https://cloud.githubusercontent.com/assets/15038417/21966287/6ba000ca-db79-11e6-87bb-a6ca17a639f0.png" width="200" height="110" />](https://cloud.githubusercontent.com/assets/15038417/21966287/6ba000ca-db79-11e6-87bb-a6ca17a639f0.png)
80 | 


--------------------------------------------------------------------------------
/bin/Panorama.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlmCo/Panorama/0e78524ab694d595a42cf9e200f22881a2e7cd58/bin/Panorama.exe


--------------------------------------------------------------------------------
/src/Panorama.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | # Panorama
 4 | # https://github.com/AlmCo/Panorama
 5 | # copyright: Almog Cohen <almogcn@gmail.com>
 6 | 
 7 | from sys import argv, exit
 8 | from PyQt4.QtGui import QApplication
 9 | 
10 | from gui.MainWindow import Ui_Panorama
11 | from actions.Report import TxtReportBuilding
12 | 
13 | helpScreen = """
14 |  Panorama - Fast incident overview
15 |  ----
16 | 	Double click or no more arguments to run with GUI
17 | 	Run with argument '-c' to run without GUI, TXT file is default output.
18 | 
19 | 	http://github.com/AlmCo/Panorama
20 | 	"""
21 | 
22 | if __name__ == "__main__":
23 | 
24 | 	if len(argv) > 1:
25 | 		if argv[1] == "-c":
26 | 			TxtReportBuilding()
27 | 		elif argv[1] == "-h":
28 | 			print helpScreen
29 | 		else:
30 | 			print "Try -h"
31 | 
32 | 	else: # GUI:
33 | 		app = QApplication(argv)
34 | 
35 | 		Panorama = Ui_Panorama()
36 | 		Panorama.show()
37 | 
38 | 		exit(app.exec_())


--------------------------------------------------------------------------------
/src/actions/Files.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from os import walk
 4 | 
 5 | from utils.HTML import *
 6 | 
 7 | wantedFiles = {"ppt":"content",
 8 | 				"pptx":"content", 
 9 | 				"doc":"content",
10 | 				"docx":"content", 
11 | 				"pdf":"content", 
12 | 				"xslx":"content", 
13 | 				"avi":"video", 
14 | 				"wmv":"video", 
15 | 				"mp4":"video", 
16 | 				"jpg":"photo",
17 | 				"jpeg":"photo",
18 | 				"gif":"photo",
19 | 				"png":"photo"}
20 | 
21 | class FilesFinder():
22 | 	def __init__(self, Ui_Panorama):
23 | 		self.contentFiles = []
24 | 		self.videoFiles = []
25 | 		self.photoFiles = []
26 | 		Ui_Panorama.logView.write("Start scanning")
27 | 		Ui_Panorama.logView.writeColor("Scanning...", "grey")
28 | 		Ui_Panorama.logView.write("<b>May take few minutes</b>")
29 | 
30 | 		Ui_Panorama.logView.write("Scan USERS folder..")
31 | 
32 | 		self.scan("c:\users")
33 | 		self.scan("c:\documents and settings")
34 | 
35 | 		Ui_Panorama.logView.write("Writing resules...")
36 | 		fileslist = FilesList(self.contentFiles, self.photoFiles, self.videoFiles)
37 | 		Ui_Panorama.logView.writeColor("Finished, Opens the report", "green")
38 | 		fileslist.openReport()
39 | 		Ui_Panorama.logView.write("")
40 | 
41 | 
42 | 
43 | 	def scan(self, scanPath):
44 | 		for root, dirs, files in walk(scanPath):
45 | 			for filename in files:
46 | 				try:
47 | 					if "." in filename and "appdata" not in root.lower():
48 | 						name = root+"\\"+filename
49 | 						# print name
50 | 						extension = name.rsplit(".",1)[1]
51 | 						if extension in wantedFiles:
52 | 							self.addPath(extension, name)
53 | 				except:
54 | 					pass
55 | 
56 | 	def addPath(self, ext, path):
57 | 		if wantedFiles[ext] == "content":
58 | 			self.contentFiles.append(path.decode('iso8859_8'))
59 | 
60 | 		elif wantedFiles[ext] == "video":
61 | 			self.videoFiles.append(path.decode('iso8859_8'))
62 | 
63 | 		elif wantedFiles[ext] == "photo":
64 | 			self.photoFiles.append(path.decode('iso8859_8'))


--------------------------------------------------------------------------------
/src/actions/Report.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | from utils.forensic import forensic
  4 | from utils.HTML import *
  5 | from utils.TXT import *
  6 | 
  7 | class TxtReportBuilding():
  8 | 	def __init__(self):
  9 | 		print "Start generate report"
 10 | 		
 11 | 		print "OS..."
 12 | 		forensic.fOS()
 13 | 		forensic.fSerialNumber()
 14 | 
 15 | 		print "Firewall..."
 16 | 		forensic.fFirewall()
 17 | 
 18 | 		print "Hotfixes..."
 19 | 		forensic.fHotfixs()
 20 | 
 21 | 		print "McAfee..."
 22 | 		forensic.fMcAfee()
 23 | 
 24 | 		print "USB..."
 25 | 		forensic.fUSB()
 26 | 
 27 | 		print "Network cards..."
 28 | 		forensic.fNetworkCards()
 29 | 
 30 | 		print "Users..."
 31 | 		forensic.fUsers()
 32 | 
 33 | 		print "Installed softwares..."
 34 | 		forensic.fSoftwareList()
 35 | 
 36 | 		print "IPs and MACs..."
 37 | 		forensic.fIPs()
 38 | 		forensic.fMACs()
 39 | 
 40 | 		print "Processes..."
 41 | 		forensic.fProcesses()
 42 | 
 43 | 		print "Commands on startup..."
 44 | 		forensic.fCommandsOnStartup()
 45 | 
 46 | 		print "Netstat..."
 47 | 		forensic.fNetStat()
 48 | 
 49 | 		print "Tasks..."
 50 | 		forensic.fTasks()
 51 | 
 52 | 		print "Hosts file..."
 53 | 		forensic.fHosts()
 54 | 
 55 | 		print "Recent used files..."
 56 | 		forensic.fRecent()
 57 | 
 58 | 		if len(forensic.IPs) != 0:
 59 | 			# If never was connected to network, it's westing time:
 60 | 			print "ARP Table..."
 61 | 			forensic.fArpTable()
 62 | 
 63 | 			print "Net view..."
 64 | 			forensic.fLocalNetworkMachines()
 65 | 		else:
 66 | 			pass
 67 | 
 68 | 		print "Writing results..."
 69 | 		report = TextReport(forensic)
 70 | 
 71 | 		print "\n\nFinished. Output:"
 72 | 		print txtPanoramaReportPage
 73 | 
 74 | 
 75 | class GuiReportBuilding():
 76 | 	def __init__(self, Ui_Panorama):
 77 | 		Ui_Panorama.logView.write("Generate report")
 78 | 		Ui_Panorama.logView.writeColor("Exporting data...", "grey")
 79 | 
 80 | 		Ui_Panorama.logView.write("Basic OS details..")
 81 | 		forensic.fOS() # This function fills up the OS dict
 82 | 		Ui_Panorama.logView.write("<b>Hostname:</b> "+forensic.hostname+"<br>"
 83 | 								 "<b>OS:</b> "+forensic.OS["ProductName"]+" "+forensic.OS["SP"])
 84 | 		
 85 | 		forensic.fSerialNumber() # This function fills up the Serial number variable
 86 | 		if forensic.serialnumber == "000000":
 87 | 			Ui_Panorama.logView.writeColor("Can't export serial number","red")
 88 | 
 89 | 		Ui_Panorama.logView.write("Firewall..")
 90 | 		forensic.fFirewall()
 91 | 
 92 | 		Ui_Panorama.logView.write("Hotfixes..")
 93 | 		forensic.fHotfixs() # This function fills up the installedHotfixes dict
 94 | 		if forensic.installedHotfixes["Sum"] == -1:
 95 | 			Ui_Panorama.logView.writeColor("Can't read hotfixes","red")
 96 | 		
 97 | 		Ui_Panorama.logView.write("McAfee..")
 98 | 		forensic.fMcAfee()
 99 | 
100 | 		Ui_Panorama.logView.write("USB...")
101 | 		forensic.fUSB()
102 | 
103 | 		Ui_Panorama.logView.write("Network cards...")
104 | 		forensic.fNetworkCards()
105 | 
106 | 		Ui_Panorama.logView.write("Users...")
107 | 		forensic.fUsers()
108 | 
109 | 		Ui_Panorama.logView.write("Softwares...")
110 | 		forensic.fSoftwareList()
111 | 		
112 | 		Ui_Panorama.logView.write("IP Address...")
113 | 		forensic.fIPs()
114 | 
115 | 		Ui_Panorama.logView.write("MAC Address...")
116 | 		forensic.fMACs()
117 | 
118 | 		Ui_Panorama.logView.write("Processes list...")
119 | 		forensic.fProcesses()
120 | 
121 | 		Ui_Panorama.logView.write("Startup commands...")
122 | 		forensic.fCommandsOnStartup()
123 | 
124 | 		Ui_Panorama.logView.write("Netstat...")
125 | 		forensic.fNetStat()
126 | 
127 | 		Ui_Panorama.logView.write("Task scheduler...")
128 | 		forensic.fTasks()
129 | 
130 | 		Ui_Panorama.logView.write("Hosts file...")
131 | 		forensic.fHosts()
132 | 
133 | 		Ui_Panorama.logView.write("Recent files...")
134 | 		forensic.fRecent()
135 | 
136 | 		if len(forensic.IPs) != 0:
137 | 			# If never was connected to network, it's westing time:
138 | 			Ui_Panorama.logView.write("ARP Table...")
139 | 			forensic.fArpTable()
140 | 
141 | 			Ui_Panorama.logView.write("Net View...")
142 | 			forensic.fLocalNetworkMachines()
143 | 		else:
144 | 			Ui_Panorama.logView.writeColor("Skipped ARP Table and 'Net View'","grey")
145 | 
146 | 
147 | 		Ui_Panorama.logView.writeColor("Writing results...","grey")
148 | 
149 | 		report = HTMLReport(forensic)
150 | 		
151 | 		Ui_Panorama.logView.writeColor("Finished, Opens the report", "green")
152 | 		
153 | 		Ui_Panorama.logView.write("")
154 | 
155 | 		report.openReport()
156 | 


--------------------------------------------------------------------------------
/src/actions/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlmCo/Panorama/0e78524ab694d595a42cf9e200f22881a2e7cd58/src/actions/__init__.py


--------------------------------------------------------------------------------
/src/common/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlmCo/Panorama/0e78524ab694d595a42cf9e200f22881a2e7cd58/src/common/__init__.py


--------------------------------------------------------------------------------
/src/common/encodedFiles.py:
--------------------------------------------------------------------------------
 1 | from base64 import b64decode
 2 | 
 3 | from paths import *
 4 | 
 5 | # Encoded logo for the GUI
 6 | guiLogo = b64decode("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")
 7 | 
 8 | # Icon:
 9 | iconIco = b64decode("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")
10 | 
11 | # Web page logo:
12 | webLogo = b64decode("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")
13 | 
14 | # USBDeview
15 | USBDeview = b64decode("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")
16 | 
17 | # List of the files|names that need to be dropped:
18 | droppedFiles = {webLogo:"logo.png", USBDeview:"USBDeview.exe"}
19 | 
20 | for fileContent,name in droppedFiles.iteritems():
21 | 	outputFile = open(PanoramaDir+"\\"+name,'wb')
22 | 	outputFile.write(fileContent)
23 | 	outputFile.close()


--------------------------------------------------------------------------------
/src/common/paths.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from os import popen, listdir
 4 | from os.path import isdir, isfile
 5 | from lib.Registry import *
 6 | 
 7 | SystemRoot = str(readName(r"SOFTWARE\Microsoft\Windows NT\CurrentVersion",'SystemRoot'))
 8 | TEMP = str(readName(r"SYSTEM\CurrentControlSet\Control\Session Manager\Environment",'TEMP'))
 9 | 
10 | appdata = popen("echo %appdata%").read().split("\n")[0]
11 | 
12 | sysTempFolder = TEMP.replace("%SystemRoot%",SystemRoot)
13 | PanoramaDir = sysTempFolder+"\Panorama"
14 | 
15 | # WEB:
16 | PanoramaReportPage = PanoramaDir+"\Panorama.html"
17 | PanoramaFilesPage = PanoramaDir+"\FilesPanorama.html"
18 | WebLogo = PanoramaDir+"\logo.png"
19 | 
20 | #TXT:
21 | txtPanoramaReportPage = PanoramaDir+"\Panorama.txt"
22 | txtPanoramaFilesPage = PanoramaDir+"\FilesPanorama.txt"
23 | 
24 | if not isdir(PanoramaDir):
25 | 	# if Panorama dir not exist - create the dir
26 | 	popen("mkdir "+PanoramaDir)
27 | 
28 | 
29 | 
30 | def rmPanoramaDir():
31 | 	popen("rmdir /s /q "+PanoramaDir)


--------------------------------------------------------------------------------
/src/gui/MainWindow.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | from PyQt4 import QtCore, QtGui
  4 | 
  5 | from actions.Report import GuiReportBuilding
  6 | from actions.Files import FilesFinder
  7 | from common.encodedFiles import *
  8 | import logView
  9 | 
 10 | 
 11 | try:
 12 | 	_fromUtf8 = QtCore.QString.fromUtf8
 13 | except AttributeError:
 14 | 	def _fromUtf8(s):
 15 | 		return s
 16 | 
 17 | try:
 18 | 	_encoding = QtGui.QApplication.UnicodeUTF8
 19 | 	def _translate(context, text, disambig):
 20 | 		return QtGui.QApplication.translate(context, text, disambig, _encoding)
 21 | except AttributeError:
 22 | 	def _translate(context, text, disambig):
 23 | 		return QtGui.QApplication.translate(context, text, disambig)
 24 | 
 25 | class Ui_Panorama(QtGui.QMainWindow):
 26 | 	def __init__(self):
 27 | 		self.logView = logView.logView(self)
 28 | 		QtGui.QMainWindow.__init__(self)
 29 | 		self.setupUi(self)
 30 | 	
 31 | 	def setupUi(self, Panorama):
 32 | 		# GUI settings:
 33 | 		Panorama.setObjectName(_fromUtf8("Panorama"))
 34 | 		Panorama.resize(445, 440)
 35 | 		Panorama.setAnimated(False)
 36 | 		Panorama.setDocumentMode(False)
 37 | 
 38 | 		# Setting the centralwidget:
 39 | 		self.centralwidget = QtGui.QWidget(Panorama)
 40 | 		self.centralwidget.setStyleSheet(_fromUtf8("background-color: rgb(7, 33, 68);"))
 41 | 		self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
 42 | 		
 43 | 		# Set icon
 44 | 		icon = QtGui.QPixmap()
 45 | 		icon.loadFromData(iconIco)
 46 | 		Panorama.setWindowIcon(QtGui.QIcon(icon))
 47 | 		
 48 | 		# Logo is decoded from base64:
 49 | 		logo = QtGui.QPixmap()
 50 | 		logo.loadFromData(guiLogo)
 51 | 		self.LogoView = QtGui.QLabel(self.centralwidget)
 52 | 		self.LogoView.setGeometry(QtCore.QRect(15, 10, 560, 101))
 53 | 		self.LogoView.setPixmap(logo)
 54 | 
 55 | 		# Report Button:
 56 | 		self.ReportGen = QtGui.QPushButton(self.centralwidget)
 57 | 				#								X 	  Y    W    H
 58 | 		self.ReportGen.setGeometry(QtCore.QRect(290, 123, 145, 51))
 59 | 		self.ReportGen.setStyleSheet(_fromUtf8("font: 95 17pt \"Arial\";\n"
 60 | 												"color: rgb(9, 38, 49);\n"
 61 | 												"background-color: qlineargradient(spread:pad, x1:0.387, y1:0.926, x2:0.93733, y2:0.119, stop:0 rgba(184, 184, 184, 255), stop:1 rgba(255, 255, 255, 255));\n"
 62 | 												"border-radius: 15px;\n"
 63 | 												"border:2px solid rgb(190, 190, 190); "))
 64 | 		self.ReportGen.setObjectName(_fromUtf8("ReportGen"))
 65 | 		self.ReportGen.clicked.connect(self.startReport)
 66 | 
 67 | 
 68 | 		# Media file scanning button:
 69 | 		self.FindFiles = QtGui.QPushButton(self.centralwidget)
 70 | 		self.FindFiles.setGeometry(QtCore.QRect(290, 190, 145, 51))		
 71 | 		self.FindFiles.setStyleSheet(_fromUtf8("font: 95 17pt \"Arial\";\n"
 72 | 													"color: rgb(9, 38, 49);\n"
 73 | 													"background-color: qlineargradient(spread:pad, x1:0.387, y1:0.926, x2:0.93733, y2:0.119, stop:0 rgba(184, 184, 184, 255), stop:1 rgba(255, 255, 255, 255));\n"
 74 | 													"border-radius: 15px;\n"
 75 | 													"border:2px solid rgb(190, 190, 190); "))
 76 | 		self.FindFiles.setObjectName(_fromUtf8("FindFiles"))
 77 | 		self.FindFiles.clicked.connect(self.startFindFiles)
 78 | 
 79 | 
 80 | 		# Hibernate button:
 81 | 		self.Hibernate = QtGui.QPushButton(self.centralwidget)
 82 | 		self.Hibernate.setGeometry(QtCore.QRect(290, 260, 145, 51))		
 83 | 		self.Hibernate.setStyleSheet(_fromUtf8("font: 75 13.5pt \"Arial\";\n"
 84 | 													"color: rgb(9, 38, 49);\n"
 85 | 													"background-color: qlineargradient(spread:pad, x1:0.387, y1:0.926, x2:0.93733, y2:0.119, stop:0 rgba(184, 184, 184, 255), stop:1 rgba(255, 255, 255, 255));\n"
 86 | 													"border-radius: 15px;\n"
 87 | 													"border:2px solid rgb(190, 190, 190); "))
 88 | 		self.Hibernate.setObjectName(_fromUtf8("Hibernate"))
 89 | 		self.Hibernate.clicked.connect(self.startHibernate)
 90 | 
 91 | 
 92 | 		# Close and Delete button:
 93 | 		self.CloseAndDelete = QtGui.QPushButton(self.centralwidget)
 94 | 		self.CloseAndDelete.setGeometry(QtCore.QRect(290, 330, 145, 51))
 95 | 		self.CloseAndDelete.setStyleSheet(_fromUtf8("font: 75 13.5pt \"Arial\";\n"
 96 | 													"color: rgb(9, 38, 49);\n"
 97 | 													"background-color: qlineargradient(spread:pad, x1:0.387, y1:0.926, x2:0.93733, y2:0.119, stop:0 rgba(184, 184, 184, 255), stop:1 rgba(255, 255, 255, 255));\n"
 98 | 													"border-radius: 15px;\n"
 99 | 													"border:2px solid rgb(190, 190, 190); "))
100 | 		self.CloseAndDelete.setObjectName(_fromUtf8("CloseAndDelete"))
101 | 		self.CloseAndDelete.clicked.connect(self.closeAndDelete)
102 | 
103 | 
104 | 		# About button:
105 | 		self.AboutButton = QtGui.QPushButton(self.centralwidget)
106 | 		self.AboutButton.setGeometry(QtCore.QRect(365, 400, 70, 30))
107 | 		self.AboutButton.setStyleSheet(_fromUtf8("font: 75 14pt \"Arial\";\n"
108 | 													"color: rgb(9, 38, 49);\n"
109 | 													"background-color: qlineargradient(spread:pad, x1:0.387, y1:0.926, x2:0.93733, y2:0.119, stop:0 rgba(184, 184, 184, 255), stop:1 rgba(255, 255, 255, 255));\n"
110 | 													"border-radius: 15px;\n"
111 | 													"border:2px solid rgb(190, 190, 190); "))
112 | 		self.AboutButton.setObjectName(_fromUtf8("AboutButton"))
113 | 		self.AboutButton.clicked.connect(lambda: self.showMessageBox("About","Panorama\n\nSupports Windows XP SP2 and up.\n\nwww.github.com/AlmCo/Panorama\nalmogcn@gmail.com"))
114 | 
115 | 
116 | 		# Just close button:
117 | 		self.CloseButton = QtGui.QPushButton(self.centralwidget)
118 | 		self.CloseButton.setGeometry(QtCore.QRect(290, 400, 70, 30))
119 | 		self.CloseButton.setStyleSheet(_fromUtf8("font: 75 14pt \"Arial\";\n"
120 | 													"color: rgb(9, 38, 49);\n"
121 | 													"background-color: qlineargradient(spread:pad, x1:0.387, y1:0.926, x2:0.93733, y2:0.119, stop:0 rgba(184, 184, 184, 255), stop:1 rgba(255, 255, 255, 255));\n"
122 | 													"border-radius: 15px;\n"
123 | 													"border:2px solid rgb(190, 190, 190); "))
124 | 		self.CloseButton.setObjectName(_fromUtf8("CloseButton"))
125 | 		self.CloseButton.clicked.connect(self.closeGui)
126 | 
127 | 
128 | 		# Log View box:
129 | 		self.logBox = QtGui.QTextBrowser(self.centralwidget)
130 | 		self.logBox.setGeometry(QtCore.QRect(10, 120, 270, 310))
131 | 		self.logBox.setStyleSheet(_fromUtf8("padding-left: 5px;\n"
132 | 											"padding-right: 5px;\n"
133 | 											"font: 75 12pt \"Arial\";\n"
134 | 											"color: rgb(9, 38, 49);\n"
135 | 											"border-radius: 5px;\n"
136 | 											"border:2px solid rgb(190, 190, 190);\n"
137 | 											"background-color: rgb(230, 230, 230);\n"))
138 | 		self.logBox.verticalScrollBar().setStyleSheet(_fromUtf8("color: rgb(230, 230, 230);\nheight: 0px;"))
139 | 		self.logBox.verticalScrollBar().setHidden(1)
140 | 
141 | 
142 | 		Panorama.setCentralWidget(self.centralwidget) # Setting the main widget
143 | 		self.retranslateUi(Panorama) # Getting names for the buttons
144 | 		QtCore.QMetaObject.connectSlotsByName(Panorama)
145 | 
146 | 
147 | 	def update(self):
148 | 		# Using from another files to update the logView
149 | 		self.retranslateUi(self)
150 | 		self.logBox.verticalScrollBar().setValue(self.logBox.verticalScrollBar().maximum())
151 | 		QtCore.QCoreApplication.processEvents()
152 | 
153 | 	def retranslateUi(self, Panorama):
154 | 		# Translate the name for each attribute:
155 | 		Panorama.setWindowTitle(_translate("Panorama", "Panorama", None))
156 | 		self.ReportGen.setText(_translate("Panorama", "Report", None))
157 | 		self.FindFiles.setText(_translate("Panorama", "Files Finder", None))
158 | 		self.Hibernate.setText(_translate("Panorama", "Hibernate", None))
159 | 		self.CloseAndDelete.setText(_translate("Panorama", "Close and Delete", None))
160 | 		self.AboutButton.setText(_translate("Panorama", "About", None))
161 | 		self.CloseButton.setText(_translate("Panorama", "Close", None))
162 | 		self.logBox.setHtml(_translate("Panorama", self.logView.log, None)) # self.logView.log is the variable that holds the HTML	
163 | 
164 | 	def showMessageBox(self, title, message):
165 | 		# Creating popup message
166 | 		msg = QtGui.QMessageBox()
167 | 		msg.setIcon(QtGui.QMessageBox.Information)
168 | 		# Set icon
169 | 		icon = QtGui.QPixmap()
170 | 		icon.loadFromData(iconIco)
171 | 		msg.setWindowIcon(QtGui.QIcon(icon))
172 | 		# Creating the popup
173 | 		msg.setText(message.decode('utf-8'))
174 | 		msg.setWindowTitle(title.decode('utf-8'))
175 | 		msg.setStandardButtons(QtGui.QMessageBox.Ok)
176 | 		retval = msg.exec_()
177 | 
178 | 
179 | 	def startReport(self):
180 | 		# Calling to ReportBuilding to generate the report and open the webpage
181 | 		GuiReportBuilding(self)
182 | 
183 | 
184 | 	def startFindFiles(self):
185 | 		# No time to explain:
186 | 		FilesFinder(self)
187 | 
188 | 	def startHibernate(self):
189 | 		popen("%windir%\\system32\\powercfg.exe /h on")
190 | 		popen("%windir%\\system32\\shutdown.exe /h")
191 | 		popen("%windir%\\system32\\rundll32.exe powrprof.dll,SetSuspendState")
192 | 
193 | 	def closeGui(self):
194 | 		# Closing the app
195 | 		QtCore.QCoreApplication.instance().quit()
196 | 
197 | 	def closeAndDelete(self):
198 | 		# Close the app, Eject the cd-rom and delete the dir from Temp folder
199 | 		rmPanoramaDir()
200 | 		self.closeGui()
201 | 


--------------------------------------------------------------------------------
/src/gui/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlmCo/Panorama/0e78524ab694d595a42cf9e200f22881a2e7cd58/src/gui/__init__.py


--------------------------------------------------------------------------------
/src/gui/logView.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | class logView():
 4 |     def __init__(self, Ui_Panorama):
 5 |         self.log = '<html xmlns="http://www.w3.org/1999/xhtml"><center><b>Panorama</b><br>Fast incident overview'
 6 |         self.Ui_Panorama = Ui_Panorama
 7 | 
 8 |     def read(self):
 9 |         return self.log
10 | 
11 |     def write(self, string):
12 |     	self.log += "<br>"+string
13 |     	self.Ui_Panorama.update()
14 | 
15 |     def writeColor(self, string, color):
16 |     	self.log += "<br><font color="+color+">"+string+"</font>"
17 |     	self.Ui_Panorama.update()
18 |     
19 |     def addTextToLogView(self,AddThis): 
20 |     	print self.log


--------------------------------------------------------------------------------
/src/lib/Registry.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from datetime import datetime
 4 | from _winreg import OpenKey, QueryInfoKey, QueryValueEx, EnumKey, EnumValue, HKEY_LOCAL_MACHINE, KEY_READ, KEY_WOW64_64KEY
 5 | 
 6 | def readName(keyPath, name):
 7 | 	# return the value of single path and name
 8 | 	explorer = OpenKey(HKEY_LOCAL_MACHINE,keyPath, 0, KEY_READ | KEY_WOW64_64KEY)
 9 | 	return str(QueryValueEx(explorer, name)[0])
10 | 
11 | def readValues(keyPath):
12 | 	# return Dict of name:value from key
13 | 	explorer = OpenKey(HKEY_LOCAL_MACHINE, keyPath, 0, KEY_READ | KEY_WOW64_64KEY)
14 | 	valuesDict = {}
15 | 	for i in range(QueryInfoKey(explorer)[1]):
16 | 		name, value, type = EnumValue(explorer, i)
17 | 		valuesDict[name] = value
18 | 	return valuesDict
19 | 
20 | def readKeys(keyPath):
21 | 	# return list of Keys
22 | 	explorer = OpenKey(HKEY_LOCAL_MACHINE, keyPath, 0, KEY_READ | KEY_WOW64_64KEY)
23 | 	KeysList = []
24 | 	for i in xrange(QueryInfoKey(explorer)[0]):
25 | 		name = EnumKey(explorer, i)
26 | 		KeysList.append(name)
27 | 	return KeysList
28 | 


--------------------------------------------------------------------------------
/src/lib/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlmCo/Panorama/0e78524ab694d595a42cf9e200f22881a2e7cd58/src/lib/__init__.py


--------------------------------------------------------------------------------
/src/panorama.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlmCo/Panorama/0e78524ab694d595a42cf9e200f22881a2e7cd58/src/panorama.ico


--------------------------------------------------------------------------------
/src/utils/HTML.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | import sys
  3 | from os import startfile
  4 | from os.path import getctime
  5 | from datetime import datetime
  6 | 
  7 | from common.paths import *
  8 | 
  9 | reload(sys)
 10 | sys.setdefaultencoding("utf-8")
 11 | 
 12 | def timestamp2date(timestamp, hour):
 13 | 	mydate = datetime.fromtimestamp(int(timestamp))
 14 | 	if hour == 1:
 15 | 		return mydate.strftime("%H:%M %d-%m-%Y")
 16 | 	else:
 17 | 		return mydate.strftime("%d-%m-%Y")
 18 | 
 19 | closeContent = '</div>' # for the BOX div
 20 | closeTitle = '</div>' # for the ID div
 21 | 
 22 | 
 23 | class FilesList:
 24 | 	def __init__(self, contentList, PhotoList, VideoList):
 25 | 		self.FilesContent = '<div id="Content" style="display:none;">'
 26 | 		self.FilesPhoto = '<div id="Photo" style="display: none;">'
 27 | 		self.FilesVideo = '<div id="Video" style="display: ;">'
 28 | 		self.Files = open(PanoramaFilesPage, 'w')
 29 | 		self.write(header)
 30 | 		self.writeContent(topLogo)
 31 | 		self.write("</div></div>") # Close the top
 32 | 		self.write(FilesMenu)
 33 | 		self.writeContentList(contentList)
 34 | 		self.writePhotoList(PhotoList)
 35 | 		self.writeVideoList(VideoList)
 36 | 		self.closeReportFile()
 37 | 
 38 | 	def writeContentList(self, contentList):
 39 | 		self.writeContent(self.FilesContent)
 40 | 		self.writeTitle("Content files")
 41 | 
 42 | 		if len(contentList) != 0:
 43 | 			self.write("<table style='word-break:break-all;'><tr><th width='75%'>File name</th><th>Created date</th></tr>")
 44 | 			for cfile in contentList:
 45 | 				self.writeFile(cfile)
 46 | 			self.write("</table>")
 47 | 		else:
 48 | 			self.write("No content files")
 49 | 		self.write(closeTitle)
 50 | 		self.writeContent(closeContent)
 51 | 
 52 | 	def writePhotoList(self, PhotoList):
 53 | 		self.writeContent(self.FilesPhoto)
 54 | 		self.writeTitle("Images")
 55 | 
 56 | 		if len(PhotoList) != 0:
 57 | 			self.write("<table style='word-break:break-all;'><tr><th width='8%'>Thumb</th><th width='70%'>Files name</th><th>Created date</th></tr>")
 58 | 			for cfile in PhotoList:
 59 | 				self.writeIMG(cfile)
 60 | 			self.write("</table>")
 61 | 		else:
 62 | 			self.write("No images")
 63 | 
 64 | 		self.write(closeTitle)
 65 | 		self.writeContent(closeContent)
 66 | 
 67 | 	def writeVideoList(self, VideoList):
 68 | 		self.writeContent(self.FilesVideo)
 69 | 		self.writeTitle("Video files")
 70 | 
 71 | 		if len(VideoList) != 0:
 72 | 			self.write("<table style='word-break:break-all;'><tr><th width='75%'>File name</th><th>Created date</th></tr>")
 73 | 			for cfile in VideoList:
 74 | 				self.writeFile(cfile)
 75 | 			self.write("</table>")
 76 | 		else:
 77 | 			self.write("No video files")
 78 | 
 79 | 		self.write(closeTitle)
 80 | 		self.writeContent(closeContent)
 81 | 
 82 | 	def write(self, string):
 83 | 		self.Files.write(string+"<br>\n")
 84 | 
 85 | 	def writeFile(self, string):
 86 | 		name = '<font color="silver" size="3">'+string.rsplit("\\",1)[0]+'</font> '+string.rsplit("\\",1)[1]
 87 | 		link = string.replace("\\","\\\\").replace("%20"," ")
 88 | 		self.Files.write('<tr><td><a href="javascript:openURL(\'{}\')">\
 89 | 			{}</a></td><td>{}</td></tr>\n'.format(link, name, timestamp2date(getctime(string),1)))
 90 | 
 91 | 	def writeIMG(self, string):
 92 | 		name = string.rsplit("\\",1)[1]
 93 | 		link = string.replace("\\","\\\\").replace("%20"," ")
 94 | 		self.Files.write('<tr><td><img src="{}" width="40" height="25"></td><td><a href="javascript:openURL(\'{}\')">\
 95 | 			{}</a></td><td>{}</td></tr>\n'.format(link, link, name, timestamp2date(getctime(string),1)))
 96 | 
 97 | 	def writeContent(self, string):
 98 | 		self.Files.write(string+"\n")
 99 | 
100 | 	def writeTitle(self, title):
101 | 		self.Files.write('<div class="box">\
102 | 			<div class="title">'+title+'</div><hr>')
103 | 
104 | 	def closeReportFile(self):
105 | 		self.Files.close()
106 | 
107 | 	def openReport(self):
108 | 		startfile(PanoramaFilesPage)
109 | 
110 | 
111 | class HTMLReport:
112 | 	def __init__(self, forensics):
113 | 		self.OSContent = '<div id="OS" style="display: ;">'
114 | 		self.NetworkContent = '<div id="Network" style="display: none;">'
115 | 		self.SecurityContent = '<div id="Security" style="display: none;">'
116 | 		self.USBContent = '<div id="USB" style="display: none;">'
117 | 		self.forensics = forensics
118 | 		self.Panorama = open(PanoramaReportPage, 'w')
119 | 		self.write(header)
120 | 		self.writeContent(topLogo)
121 | 		self.writeOSDetails()
122 | 		self.write(ReportMenu)
123 | 		self.writeOS()
124 | 		self.writeNetwork()
125 | 		self.writeSecurity()
126 | 		self.writeUSB()
127 | 		self.closeReportFile()
128 | 
129 | 	def write(self, string, line=1):
130 | 		self.Panorama.write(string+"<br>\n")
131 | 
132 | 	def writeContent(self, string):
133 | 		self.Panorama.write(string+"\n")
134 | 
135 | 	def writeTitle(self, title):
136 | 		self.Panorama.write('<div class="box">\
137 | 			<div class="title">'+title+'</div><hr>')
138 | 	
139 | 	def writeOSDetails(self):
140 | 		self.write("Hostname: "+self.forensics.hostname)
141 | 		self.write("Serial number: "+self.forensics.serialnumber)
142 | 		self.write("OS: "+self.forensics.OS["ProductName"]+" "+self.forensics.OS["SP"]+" "+self.forensics.OS["Bit"])
143 | 		self.write("OS Install date: "+self.forensics.OS["InstallDate"])
144 | 		self.write("Num of hotfixes: "+str(self.forensics.installedHotfixes["Sum"]))
145 | 		self.write("Firewall status: "+(self.forensics.Firewall["Status"]))
146 | 		self.write('</div><div style="clear: both;"></div></div>') # this is close the top
147 | 	
148 | 	def writeOS(self):
149 | 		self.writeContent(self.OSContent)
150 | 		self.writeTitle("Users")
151 | 		for user in self.forensics.Users:
152 | 			if user not in ["Guest", "DefaultAccount"]:
153 | 				self.write("<b>"+user+"</b>")
154 | 				for value in self.forensics.Users[user]:
155 | 					self.write((value)+": "+(str(self.forensics.Users[user][value])))
156 | 				self.write(" ")
157 | 		self.write(closeTitle)
158 | 
159 | 
160 | 		self.writeTitle("Commands on startup")
161 | 		if len(self.forensics.CommandsOnStartup) != 0:
162 | 			table = ("<table><tr><th width='90%'>Command</th><th>Process active now</th></tr>")
163 | 			for command,active in self.forensics.CommandsOnStartup.iteritems():
164 | 				try:
165 | 					table += ("<tr><td>%s</td><td>%s</td></tr>\n" % (command,(str(active))))
166 | 				except:
167 | 					print "ERROR: 6349"
168 | 					print command
169 | 			self.write(table+"</table>")
170 | 		else:
171 | 			self.write("Empty")
172 | 		self.write(closeTitle)
173 | 
174 | 
175 | 		self.writeTitle("Task scheduler")
176 | 		if len(self.forensics.Tasks) != 0:
177 | 			table = ("<table><tr><th>Name</th><th>Execute date</th><th>Status</th></tr>")
178 | 			for task in self.forensics.Tasks:
179 | 				table+= "<tr><td>"+task["TaskName"]+"</td><td>"+task["Next Run Time"]+"</td><td>"+task["Status"]+"</td></tr>"
180 | 			self.write(table+"</table>")
181 | 		else:
182 | 			self.write("Empty")
183 | 		self.write(closeTitle)
184 | 
185 | 
186 | 		self.writeTitle("Installed softwares")
187 | 		rowCount = 0
188 | 		if len(self.forensics.SoftwareList) != 0:
189 | 			blacklist = ['utorrent', 'teraterm', 'logmein', 'flashfxp', 'bittorrent', 'bitorrent', 'tor','teamviewer','skype','icq','emule','kazaa','dropbox','apple','itunes','wireless','havij','popcorn', 'torbrowser', 'logmett', 'join.me', 'popcorn time']
190 | 			table = "<table>"
191 | 			for software in self.forensics.SoftwareList:
192 | 				if rowCount == 3:
193 | 					table += ("</tr>\n<tr>")
194 | 					rowCount = 0
195 | 				try:
196 | 					if software.lower() in blacklist:
197 | 						table += ('<td style="word-break:break-all; width: 25%; background: #ff5050;">{}</td>\n'.format(software.encode('utf-8')))
198 | 					else:
199 | 						table += ('<td style="word-break:break-all; width: 25%;">{}</td>\n'.format(software.encode('utf-8')))
200 | 					rowCount += 1
201 | 				except:
202 | 					pass
203 | 			self.write(table+"</table>")
204 | 		else:
205 | 			self.write('Empty')
206 | 		self.write(closeTitle)
207 | 
208 | 
209 | 		self.writeTitle("Recently used files")
210 | 		rowCount = 0
211 | 		if len(self.forensics.Recent) != 0:
212 | 			table = "<table>"
213 | 			for each in self.forensics.Recent:
214 | 				if rowCount == 3:
215 | 					table += ("</tr>\n<tr>")
216 | 					rowCount = 0
217 | 				table += ('<td style="word-break:break-all; width: 25%;"><a href="javascript:openURL(\'{}\')">{}</a></td>\n'.format(each.replace("\\","\\\\"), each.rsplit("\\",1)[1].replace(".lnk","")))
218 | 				rowCount += 1
219 | 
220 | 			self.write(table+"</table>")
221 | 		else:
222 | 			self.write('0 Recent files')
223 | 		self.write(closeTitle)
224 | 
225 | 
226 | 		self.writeTitle("Active processes")
227 | 		if len(self.forensics.Processes) != 0:
228 | 			table = ("<table><tr><th>Name</th><th>ID</th><th>Communicating</th></tr>")
229 | 			for pid,name in self.forensics.Processes.iteritems():
230 | 				if name.strip() not in ["System", "System Idle Process"]:
231 | 					if str(self.forensics.Netstat).find(str(name+"', 'PID': '"+str(pid))) == -1:
232 | 						table += ("<tr><td>"+name+"</td><td>"+str(pid)+"</td><td>No</td></tr>\n")
233 | 					else:
234 | 						table += ("<tr><td>"+name+"</td><td>"+str(pid)+"</td><td><b>Yes</b></td></tr>\n")
235 | 			self.write(table+"</table>")
236 | 		else:
237 | 			self.write("ERR")
238 | 		self.write(closeTitle)
239 | 
240 | 		self.writeContent(closeContent)
241 | 
242 | 	def writeNetwork(self):
243 | 		self.writeContent(self.NetworkContent)
244 | 
245 | 		self.writeTitle("Network cards")
246 | 		if len(self.forensics.NetworkCards) != 0:
247 | 			wirelessWords = ["wireless", "802"]
248 | 			for card in self.forensics.NetworkCards:
249 | 				writed = 0
250 | 				for word in wirelessWords:
251 | 					if card.lower().find(word) != -1 and writed == 0:
252 | 						self.write('<font color="red">'+card+"</font>")
253 | 						writed = 1
254 | 				if writed == 0:
255 | 					self.write(card)
256 | 		else:
257 | 			self.write("Empty")
258 | 		self.write(closeTitle)
259 | 
260 | 
261 | 		self.writeTitle("IP Address")
262 | 		if len(self.forensics.IPs) != 0:
263 | 			for ip,Dict in self.forensics.IPs.iteritems():
264 | 				if ip == "Current":
265 | 					ips = ""
266 | 					for addr in Dict:
267 | 						if len(addr) < 16:
268 | 							ips += "IPv4 - "+addr+"<br>"
269 | 						else:
270 | 							ips += "IPv6 - "+addr+"<br>"
271 | 					self.write("<b>Currently IPs:</b><br>"+ips)
272 | 				else:
273 | 					singleIP = "<br><b>"+ip+"</b>"
274 | 					for key, value in Dict.iteritems():
275 | 						singleIP += "<br><b>"+(key) + ":</b> " + value
276 | 					self.write(singleIP)
277 | 		else:
278 | 			self.write("Empty")
279 | 		self.write(closeTitle)
280 | 
281 | 
282 | 		self.writeTitle("MAC Address")
283 | 		if len(self.forensics.MACs) != 0:
284 | 			for mac in self.forensics.MACs:
285 | 				self.write(mac)
286 | 		else:
287 | 			self.write("Empty")
288 | 		self.write(closeTitle)
289 | 
290 | 
291 | 		if len(self.forensics.LocalNetworkMachines) != 0:
292 | 			self.writeTitle("Net view")
293 | 			for host in self.forensics.LocalNetworkMachines:
294 | 				self.write(host)
295 | 			self.write(closeTitle)
296 | 
297 | 
298 | 		self.writeTitle("Netstat")
299 | 		if len(self.forensics.Netstat) != 0:
300 | 			table = "<table><tr><th>Local</th><th>Target</th><th>ID</th><th>Process</th><th>Status</th></tr>\n"
301 | 			for connection in self.forensics.Netstat:
302 | 				table += '<tr><td style="word-break:break-all;">'+connection["Local"]+'</td><td style="word-break:break-all;">'+connection["Remote"]+'</td><td>'+connection["PID"]+'</td><td style="word-break:break-all;">'+connection["appName"]+'</td><td>'+(connection["Status"])+'</td></tr>\n'
303 | 			self.write(table+"</table>")
304 | 		else:
305 | 			self.write("Empty")
306 | 		self.write(closeTitle)
307 | 
308 | 
309 | 		self.writeTitle("ARP Table")
310 | 		if len(self.forensics.ArpTable) != 0:
311 | 			for interface, Dict in self.forensics.ArpTable.iteritems():
312 | 				table = "<table><tr><th>"+interface+"</th></tr><tr><th>IP</th><th>MAC</th><th>Type</th></tr>\n"
313 | 				for known in Dict:
314 | 					table += "<tr><td>"+known["IP"] + "</td><td>" + known["MAC"] + "</td><td>" + known["Type"] + "</td></tr>\n"
315 | 				self.write(table+"</table>")
316 | 		else:
317 | 			self.write("Empty")
318 | 		self.write(closeTitle)
319 | 
320 | 
321 | 		self.writeTitle("Hosts file")
322 | 		if len(self.forensics.HostsFile) != 0:
323 | 			table = "<table><tr><th>Domain</th><th>Target IP</th></tr>"
324 | 			for counter, entry in self.forensics.HostsFile.iteritems():
325 | 				if entry["TargetIP"] not in ["0.0.0.0", "127.0.0.1"]:
326 | 					table += "<tr><td>"+entry["RequestedDomain"]+"</td><td>"+entry["TargetIP"]+"</td></tr>"
327 | 			self.write(table+"</table>")
328 | 		else:
329 | 			self.write("Empty")
330 | 		self.write(closeTitle)
331 | 
332 | 
333 | 		self.writeContent(closeContent)
334 | 
335 | 	def writeSecurity(self):
336 | 		self.writeContent(self.SecurityContent)
337 | 
338 | 		self.writeTitle("McAfee")
339 | 		if self.forensics.McAfee["Installed"] == 0:
340 | 			self.write("McAfee not installed")
341 | 		else:
342 | 			self.write("Version: McAfee "+self.forensics.McAfee["Version"])
343 | 			self.write("DAT date: "+self.forensics.McAfee["DatDate"])
344 | 			self.write("Weekly sched: "+(str(self.forensics.McAfee["WeeklySched"])))
345 | 			self.write("Action: "+(self.forensics.McAfee["Action"]))
346 | 			self.write("Last scan: "+self.forensics.McAfee["lastScan"])
347 | 			self.write("Num quarantine files: "+str(len(self.forensics.McAfee["quarantine"])))
348 | 
349 | 			if len(self.forensics.McAfee["quarantine"]) != 0:
350 | 				self.write("<br><b>Quarantine files:</b>")
351 | 				for File in self.forensics.McAfee["quarantine"]:
352 | 					self.write(File)
353 | 
354 | 			if len(self.forensics.McAfee["Exclusions"]) != 0:
355 | 				self.write("<br><b>Exclusions:</b>")
356 | 				for role in self.forensics.McAfee["Exclusions"]:
357 | 					if role[0] == "3":
358 | 						self.write("Skip file: "+role.rsplit("|",1)[1])
359 | 					elif role[0] == "4":
360 | 						self.write("Skip format: "+role.rsplit("|",1)[1])
361 | 					elif role[0] in ["0","1","2"]:
362 | 						self.write("Skip files older than "+role.rsplit("|",1)[1]+' days')
363 | 					else:
364 | 						self.write(role)
365 | 
366 | 			self.write("<br><b>Logs:</b>")
367 | 			if len(self.forensics.McAfee["Logs"]) != 0:
368 | 				for log in self.forensics.McAfee["Logs"]:
369 | 					self.write("<b>Path: </b>"+log["Path"])
370 | 					self.write("<b>Time: </b>"+log["Date"])
371 | 					self.write("<b>Description: </b>"+log["Description"])
372 | 					self.write("<b>Action taken: </b>"+(log["Action"].strip()))
373 | 					self.write("<b>Process: </b>"+log["Process"])
374 | 					self.write("<b>MD5: </b>"+log["Hash"].strip("(MD5)"))
375 | 					self.write("")
376 | 			else:
377 | 				self.write("No interesting logs")
378 | 		self.write(closeTitle)
379 | 
380 | 
381 | 		self.writeTitle("Firewall")
382 | 		self.write("<b>Status: </b>"+self.forensics.Firewall["Status"]+"<br>")
383 | 		self.write("<b>Allowed applications:</b>")
384 | 		if len(self.forensics.Firewall["Rules"]) != 0:
385 | 			table = "<table><tr><th>Name</th><th>Active</th><th>Action</th></tr>"
386 | 			for rule in self.forensics.Firewall["Rules"]:
387 | 				table += "<tr><td>"+rule["Name"]+"</td><td>"+rule["Active"]+"</td><td>"+rule["Action"]+"</td></tr>"
388 | 			self.write(table+"</table>")
389 | 		else:
390 | 			self.write("Empty")
391 | 		self.write(closeTitle)
392 | 
393 | 
394 | 		self.writeTitle("Hotfixes")
395 | 		if len(self.forensics.installedHotfixes) != 0:
396 | 			for date,hotfixList in self.forensics.installedHotfixes["Dict"].iteritems(): # the first one is the sum number
397 | 				self.write("<br><b>Date: </b>"+date)
398 | 				self.write("<b>Packages installed: </b>"+", ".join(hotfixList))
399 | 		else:
400 | 			self.write("Empty")
401 | 		self.write(closeTitle)
402 | 
403 | 
404 | 		self.writeContent(closeContent)
405 | 
406 | 	def writeUSB(self):
407 | 		self.writeContent(self.USBContent)
408 | 
409 | 		self.writeTitle("USB list")
410 | 		knownDict = {'belkin': 'smart', 'meizu': 'smart', 'galaxy': 'smart', 'lg': 'smart', 'tablet': 'smart', 'flash': 'storage', 'black': 'smart', 'dlink': 'network', 'smart': 'smart', 'sm-g920': 'smart', 'g4': 'smart', 'g3': 'smart', 'gadget': 'smart', 'nokia': 'smart', 'watch': 'smart', 'dell': 'smart', 'toshiba': 'storage', 'band': 'network', 'sony': 'smart', 'lumia': 'smart', 'motorola': 'smart', 'xbox': 'smart', 'blackberry': 'smart', 'google': 'smart', 'htc': 'smart', 'portable': 'storage', '256gb': 'storage', 'bluetooth': 'network', 'hitachi': 'storage', 'gt-i9300': 'smart', 'huawei': 'smart', 'cdram': 'disk', 'net': 'network', 'wd': 'storage', '128gb': 'storage', 'dualband': 'network', 'ipod': 'smart', '4gb': 'storage', 'web': 'smart', 'sandisk': 'storage', 'tplink': 'network', '8gb': 'storage', 'apple': 'smart', 'corsair': 'storage', 'linux': 'smart', 'gt-i9200': 'smart', 'jetflash': 'storage', '802.11': 'network', 'camera': 'camera', 'iphone': 'smart', 'safenet': 'license', 'gt-i9100t': 'smart', 'webcam': 'camera', 'floppy': 'storage', '64gb': 'storage', 'wireless': 'network', 'phone': 'smart', '32gb': 'storage', 'datatravel': 'storage', 'ipad': 'smart', 'patriot': 'storage', 'sm-g900i': 'smart', 'sm-g900f': 'smart', 'budget': 'smart', 'windows': 'smart', '802.11ac': 'network', 'cam': 'camera', '16gb': 'storage', '802.11a': 'network', 'transcend': 'storage', 'ac': 'network', '802.11b': 'network', '802.11g': 'network', 'nexus': 'smart', 'kingston': 'storage', 'canon': 'camera', '802.11n': 'network', 'sm-g920i': 'smart', 'tab': 'smart', 'acer': 'smart', 'sm-g920f': 'smart', 'cddvd': 'disk', 'gt-i9100': 'smart', 'dvdram': 'disk', 'generic': 'storage', 'storage': 'storage', 'note': 'smart', 'android': 'smart', 'lan': 'network', 'nic': 'network', 'powershot': 'camera', 'tp-link': 'network', 'ethernet': 'network', 'nikon': 'camera', 'linksys': 'network', 'samsung': 'smart', 'mobile': 'smart', 'sm-g900': 'smart', 'd-link': 'network', 'link': 'network', 'oneplus': 'smart'}
411 | 		for x,usb in self.forensics.USB.iteritems():
412 | 			if "HID" not in usb['name'] and "Composite" not in usb['name'] and "HID" not in usb['type']:
413 | 				writeUSB = "<br><b>"+usb['name']+"</b>"
414 | 				for word in usb['name'].split():
415 | 					# Try to say what is the USB
416 | 					if word.lower() in knownDict:
417 | 						writeUSB += "<br><b>Description: </b>"+knownDict[word.lower()]+" device"
418 | 						break
419 | 
420 | 				# Type of the USB:
421 | 				writeUSB += "<br><b>Type: </b>"+usb['type']
422 | 				writeUSB += "<br><b>Serial number: </b>"+usb['serial']
423 | 				writeUSB += "<br><b>Date: </b>"+usb['ldate']
424 | 
425 | 				self.write(writeUSB)
426 | 		self.write(closeTitle)
427 | 
428 | 
429 | 		self.writeTitle("USBDeview")
430 | 		self.write('<a href="'+PanoramaDir+'\usbdeview.html" target="_blank"><b>> Open the original table <</b></a>')
431 | 		self.write(closeTitle)
432 | 
433 | 		self.writeContent(closeContent)
434 | 
435 | 	def closeReportFile(self):
436 | 		self.Panorama.close()
437 | 
438 | 	def openReport(self):
439 | 		startfile(PanoramaReportPage)
440 | 
441 | 
442 | 
443 | topLogo = '<div style="width: 80%; font-size: 20px; color: #fff; margin-right: auto; margin-left: auto;">\
444 | 			<div style="float: left;"><img src="'+WebLogo.strip(" ")+'" width="350px"></div>\
445 | 			<div style="float: right;">'
446 | 
447 | ReportMenu = """
448 | 		<div class="menu">
449 | 		<a href="javascript:show(\'OS\')"><div class="menuButton">System</div></a>
450 | 		<a href="javascript:show(\'Network\')"><div class="menuButton">Network</div></a>
451 | 		<a href="javascript:show(\'USB\')"><div class="menuButton">USB</div></a>
452 | 		<a href="javascript:show(\'Security\')"><div class="menuButton">Security</div></a>
453 | 		</div>"""
454 | 
455 | FilesMenu = """
456 | 		<div class="menu">
457 | 		<a href="javascript:show(\'Video\')"><div class="menuButton">Video</div></a>
458 | 		<a href="javascript:show(\'Photo\')"><div class="menuButton">Images</div></a>
459 | 		<a href="javascript:show(\'Content\')"><div class="menuButton">Content</div></a>
460 | 		</div>"""
461 | 
462 | header = """<html>
463 | 			<!-- Writed by Almog Cohen - almogcn@gmail.com -->
464 | 			<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
465 | 			<html><head>
466 | 			  <title>Panorama - Fast incident overview</title>
467 | 			<style>
468 | 			body {
469 | 				background-color: #072144;
470 | 				margin-left: auto;
471 | 				margin-right: auto;
472 | 				font-family: Arial, 'Helvetica Neue', Helvetica, sans-serif;m,
473 | 			}
474 | 
475 | 			.menu {
476 | 				width: 100%;
477 | 				font-size: 36px;
478 | 				background-color: #d6d3d6;
479 | 				text-align: center;
480 | 				padding-top: 5px;
481 | 				padding-bottom: 7px;
482 | 			}
483 | 
484 | 			.menuButton{
485 | 				display: inline-block;
486 | 				*display:inline;
487 | 				zoom:1;
488 | 				text-align: center;
489 | 				margin-left: 27px;
490 | 				margin-right: 27px;
491 | 			}
492 | 
493 | 			.title {
494 | 				font-size: 27px;
495 | 				text-align: left;
496 | 				padding-left: 12px;
497 | 				padding-top: 5px;
498 | 				font-weight: bold;
499 | 			}
500 | 
501 | 			hr {
502 | 				max-width: 98%;
503 | 				border: 0;
504 | 				height: 1px;
505 | 				background-color: #092730;
506 | 			}
507 | 
508 | 			.box {
509 | 				font-size: 19px;
510 | 				background-color: #efefef;
511 | 				width: 85%;
512 | 				margin-top: 10px;
513 | 				margin-bottom: 15px;
514 | 				margin-right: auto;
515 | 				margin-left: auto;
516 | 				padding: 12px;
517 | 				line-height: 1.3;
518 | 			}
519 | 
520 | 			table{
521 | 				border-collapse: collapse;
522 | 				border-spacing: 0;
523 | 				font-size: 18px;
524 | 				width: 98%;
525 | 			}
526 | 
527 | 			tr:nth-child(even){background: #f2f2f2;}
528 | 
529 | 			tr:hover {
530 | 				background: #DADADA;
531 | 				color: #000;
532 | 			}
533 | 
534 | 			td:hover {
535 | 				background: #cfcfcf;
536 | 			}
537 | 
538 | 			td {
539 | 				padding: 4px;
540 | 				border: 1px solid #dedede;
541 | 			}
542 | 
543 | 			th{background-color: #e6e6e6;}
544 | 
545 | 
546 | 			a {text-decoration: none; color: #00317B;}
547 | 			a:hover{text-decoration: underline; color:#8b8b8b;}
548 | 			.menu a{color:#8b8b8b;}
549 | 			.menu a:hover{color:#071e29;}
550 | 			.menu a:active{color:#071e29;}
551 | 			</style></head>
552 | 			<body>
553 | 			<script type="text/javascript">
554 | 				var all = ["OS", "Video", "Network", "USB", "Photo", "Security", "Content"]
555 | 				function show(element){
556 | 					document.getElementById(element).style.display = "";
557 | 					for (var i = 0; i < all.length; i++){
558 | 						if (all[i] != element){
559 | 							try{
560 | 								hideThis(all[i]);
561 | 							}
562 | 							catch(err){}
563 | 						}
564 | 					};
565 | 				}
566 | 
567 | 				function hideThis(element){
568 | 					document.getElementById(element).style.display = "none";
569 | 				}
570 | 
571 | 				function openURL(url) {
572 | 					var myWindow = window.open(url, "", "width=500,height=500");
573 | 				}
574 | 			</script>
575 | 			"""
576 | 


--------------------------------------------------------------------------------
/src/utils/TXT.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | import sys
  3 | from os import startfile
  4 | from os.path import getctime
  5 | from datetime import datetime
  6 | 
  7 | from common.paths import *
  8 | 
  9 | reload(sys)
 10 | sys.setdefaultencoding("utf-8")
 11 | 
 12 | def timestamp2date(timestamp, hour):
 13 | 	mydate = datetime.fromtimestamp(int(timestamp))
 14 | 	if hour == 1:
 15 | 		return mydate.strftime("%H:%M %d-%m-%Y")
 16 | 	else:
 17 | 		return mydate.strftime("%d-%m-%Y")
 18 | 
 19 | 
 20 | class TextReport:
 21 | 	def __init__(self, forensics):
 22 | 		self.forensics = forensics
 23 | 		self.Panorama = open(txtPanoramaReportPage, 'w')
 24 | 		self.writeHeader()
 25 | 		self.write("Report created: "+str(datetime.now())+"\n")
 26 | 		self.writeOSDetails()
 27 | 		self.writeOS()
 28 | 		self.writeNetwork()
 29 | 		self.writeSecurity()
 30 | 		self.writeUSB()
 31 | 		self.closeReportFile()
 32 | 
 33 | 	def write(self, string, line=1):
 34 | 		self.Panorama.write("\t"+string+"\n")
 35 | 
 36 | 	def writeContent(self, string):
 37 | 		self.Panorama.write(string+"\n")
 38 | 
 39 | 	def writeTitle(self, title):
 40 | 		self.Panorama.write("\n\n"+title+':\n')
 41 | 	
 42 | 	def writeHeader(self):
 43 | 		header = """--Panorama--\nFast incident overview\n\n
 44 | Contact: almogcn@gmail.com
 45 | Offical page: https://github.com/AlmCo/Panorama\n\n
 46 | ===================================================\n\n"""
 47 | 		self.writeContent(header)
 48 | 
 49 | 	def writeOSDetails(self):
 50 | 		self.write("Hostname: "+self.forensics.hostname)
 51 | 		self.write("Serial number: "+self.forensics.serialnumber)
 52 | 		self.write("OS: "+self.forensics.OS["ProductName"]+" "+self.forensics.OS["SP"]+" "+self.forensics.OS["Bit"])
 53 | 		self.write("OS Install date: "+self.forensics.OS["InstallDate"])
 54 | 		self.write("Num of hotfixes: "+str(self.forensics.installedHotfixes["Sum"]))
 55 | 		self.write("Firewall status: "+(self.forensics.Firewall["Status"]))
 56 | 	
 57 | 	def writeOS(self):
 58 | 		self.writeTitle("Users")
 59 | 		for user in self.forensics.Users:
 60 | 			if user not in ["Guest", "DefaultAccount"]:
 61 | 				self.write(user)
 62 | 				for value in self.forensics.Users[user]:
 63 | 					self.write("\t"+(value)+": "+(str(self.forensics.Users[user][value])))
 64 | 				self.write(" ")
 65 | 
 66 | 
 67 | 		self.writeTitle("Commands on startup")
 68 | 		if len(self.forensics.CommandsOnStartup) != 0:
 69 | 			for command,active in self.forensics.CommandsOnStartup.iteritems():
 70 | 				try:
 71 | 					self.write(command+" | active: "+str(active))
 72 | 				except:
 73 | 					print "ERROR: 6349"
 74 | 					print command
 75 | 		else:
 76 | 			self.write("Empty")
 77 | 
 78 | 
 79 | 		self.writeTitle("Task scheduler")
 80 | 		if len(self.forensics.Tasks) != 0:
 81 | 			for task in self.forensics.Tasks:
 82 | 				self.write(task["TaskName"]+" | NextRun: "+task["Next Run Time"]+" | Status: "+task["Status"])
 83 | 		else:
 84 | 			self.write("Empty")
 85 | 
 86 | 
 87 | 		self.writeTitle("Installed softwares")
 88 | 		if len(self.forensics.SoftwareList) != 0:
 89 | 			for software in self.forensics.SoftwareList:
 90 | 				self.write(software)
 91 | 		else:
 92 | 			self.write('Empty')
 93 | 
 94 | 
 95 | 		self.writeTitle("Recently used files")
 96 | 		if len(self.forensics.Recent) != 0:
 97 | 			for each in self.forensics.Recent:
 98 | 				self.write(each)
 99 | 		else:
100 | 			self.write('Empty')
101 | 
102 | 
103 | 		self.writeTitle("Active processes")
104 | 		if len(self.forensics.Processes) != 0:
105 | 			for pid,name in self.forensics.Processes.iteritems():
106 | 				if name.strip() not in ["System", "System Idle Process"]:
107 | 					if str(self.forensics.Netstat).find(str(name+"', 'PID': '"+str(pid))) == -1:
108 | 						self.write(name+" | PID: "+str(pid)+" | Communicating: No")
109 | 					else:
110 | 						self.write(name+" | PID: "+str(pid)+" | Communicating: Yes")
111 | 		else:
112 | 			self.write("ERR")
113 | 
114 | 
115 | 	def writeNetwork(self):
116 | 
117 | 		self.writeTitle("Network cards")
118 | 		if len(self.forensics.NetworkCards) != 0:
119 | 			for card in self.forensics.NetworkCards:
120 | 				self.write(card)
121 | 		else:
122 | 			self.write("Empty")
123 | 
124 | 
125 | 		self.writeTitle("IP Address")
126 | 		if len(self.forensics.IPs) != 0:
127 | 			for ip,Dict in self.forensics.IPs.iteritems():
128 | 				if ip == "Current":
129 | 					for addr in Dict:
130 | 						if len(addr) < 16:
131 | 							self.write("Currently IPv4: "+addr)
132 | 						else:
133 | 							self.write("Currently IPv6: "+addr)
134 | 				else:
135 | 					self.write("\n\t"+ip)
136 | 					for key, value in Dict.iteritems():
137 | 						self.write("\t"+(key) + ": " + value)
138 | 		else:
139 | 			self.write("Empty")
140 | 
141 | 
142 | 		self.writeTitle("MAC Address")
143 | 		if len(self.forensics.MACs) != 0:
144 | 			for mac in self.forensics.MACs:
145 | 				self.write(mac)
146 | 		else:
147 | 			self.write("Empty")
148 | 
149 | 
150 | 		if len(self.forensics.LocalNetworkMachines) != 0:
151 | 			self.writeTitle("Net view")
152 | 			for host in self.forensics.LocalNetworkMachines:
153 | 				self.write(host)
154 | 
155 | 
156 | 		self.writeTitle("Netstat")
157 | 		if len(self.forensics.Netstat) != 0:
158 | 			for connection in self.forensics.Netstat:
159 | 				self.write('Local: '+connection["Local"]+' | Target: '+connection["Remote"]+' | PID: '+connection["PID"]+' | App: '+connection["appName"]+' | Status: '+(connection["Status"]))
160 | 		else:
161 | 			self.write("Empty")
162 | 
163 | 
164 | 		self.writeTitle("ARP Table")
165 | 		if len(self.forensics.ArpTable) != 0:
166 | 			for interface, Dict in self.forensics.ArpTable.iteritems():
167 | 				self.write("\n\tInterface: "+interface)
168 | 				for known in Dict:
169 | 					self.write("IP: "+known["IP"] + " | MAC: " + known["MAC"] + " | Type: " + known["Type"])
170 | 		else:
171 | 			self.write("Empty")
172 | 
173 | 
174 | 		self.writeTitle("Hosts file")
175 | 		if len(self.forensics.HostsFile) != 0:
176 | 			for counter, entry in self.forensics.HostsFile.iteritems():
177 | 				if entry["TargetIP"] not in ["0.0.0.0", "127.0.0.1"]:
178 | 					self.write("Domain: "+entry["RequestedDomain"]+" | Target IP: "+entry["TargetIP"])
179 | 		else:
180 | 			self.write("Empty")
181 | 
182 | 
183 | 
184 | 	def writeSecurity(self):
185 | 
186 | 		self.writeTitle("McAfee")
187 | 		if self.forensics.McAfee["Installed"] == 0:
188 | 			self.write("McAfee not installed")
189 | 		else:
190 | 			self.write("Version: McAfee "+self.forensics.McAfee["Version"])
191 | 			self.write("DAT date: "+self.forensics.McAfee["DatDate"])
192 | 			self.write("Weekly sched: "+(str(self.forensics.McAfee["WeeklySched"])))
193 | 			self.write("Action: "+(self.forensics.McAfee["Action"]))
194 | 			self.write("Last scan: "+self.forensics.McAfee["lastScan"])
195 | 			self.write("Num quarantine files: "+str(len(self.forensics.McAfee["quarantine"])))
196 | 
197 | 			if len(self.forensics.McAfee["quarantine"]) != 0:
198 | 				self.write("\n\tQuarantine files:")
199 | 				for File in self.forensics.McAfee["quarantine"]:
200 | 					self.write("\t"+File)
201 | 
202 | 			if len(self.forensics.McAfee["Exclusions"]) != 0:
203 | 				self.write("\n\tExclusions:")
204 | 				for role in self.forensics.McAfee["Exclusions"]:
205 | 					if role[0] == "3":
206 | 						self.write("\tSkip file: "+role.rsplit("|",1)[1])
207 | 					elif role[0] == "4":
208 | 						self.write("\tSkip format: "+role.rsplit("|",1)[1])
209 | 					elif role[0] in ["0","1","2"]:
210 | 						self.write("\tSkip files older than "+role.rsplit("|",1)[1]+' days')
211 | 					else:
212 | 						self.write("\t"+role)
213 | 
214 | 			self.write("\n\tLogs:")
215 | 			if len(self.forensics.McAfee["Logs"]) != 0:
216 | 				for log in self.forensics.McAfee["Logs"]:
217 | 					self.write("\tPath: "+log["Path"])
218 | 					self.write("\tTime: "+log["Date"])
219 | 					self.write("\tDescription: "+log["Description"])
220 | 					self.write("\tAction taken: "+(log["Action"].strip()))
221 | 					self.write("\tProcess: "+log["Process"])
222 | 					self.write("\tMD5: "+log["Hash"].strip("(MD5)"))
223 | 					self.write("")
224 | 			else:
225 | 				self.write("No interesting logs")
226 | 
227 | 
228 | 		self.writeTitle("Firewall")
229 | 		self.write("Status: "+self.forensics.Firewall["Status"])
230 | 		self.write("Allowed applications:")
231 | 		if len(self.forensics.Firewall["Rules"]) != 0:
232 | 			for rule in self.forensics.Firewall["Rules"]:
233 | 				self.write("\t"+rule["Name"]+" | Status: "+rule["Active"]+" | Action: "+rule["Action"])
234 | 		else:
235 | 			self.write("Empty")
236 | 
237 | 
238 | 		self.writeTitle("Hotfixes")
239 | 		if len(self.forensics.installedHotfixes) != 0:
240 | 			for date,hotfixList in self.forensics.installedHotfixes["Dict"].iteritems(): # the first one is the sum number
241 | 				self.write("\n\tDate: "+date)
242 | 				self.write("Packages installed: "+", ".join(hotfixList))
243 | 		else:
244 | 			self.write("Empty")
245 | 
246 | 
247 | 
248 | 	def writeUSB(self):
249 | 
250 | 		self.writeTitle("USB list")
251 | 		for x,usb in self.forensics.USB.iteritems():
252 | 			if "HID" not in usb['name'] and "Composite" not in usb['name'] and "HID" not in usb['type']:
253 | 				# Type of the USB:
254 | 				self.write(usb['name'] + " | Type: "+usb['type'] + " | Serial number: " + usb['serial'] + " | Date: " + usb['ldate'])
255 | 
256 | 
257 | 
258 | 	def closeReportFile(self):
259 | 		self.Panorama.close()
260 | 
261 | 	def openReport(self):
262 | 		startfile(PanoramaReportPage)
263 | 


--------------------------------------------------------------------------------
/src/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlmCo/Panorama/0e78524ab694d595a42cf9e200f22881a2e7cd58/src/utils/__init__.py


--------------------------------------------------------------------------------
/src/utils/forensic.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | import sys
  4 | 
  5 | from utils.HTML import timestamp2date
  6 | from lib.Registry import *
  7 | from common.paths import *
  8 | from utils.parsers import *
  9 | from utils.getters import *
 10 | 
 11 | # To do:
 12 | # Networks the computer was joined
 13 | # Mapped shares
 14 | 
 15 | reload(sys)
 16 | sys.setdefaultencoding("utf-8")
 17 | 
 18 | class Forensic:
 19 | 	def __init__(self):
 20 | 		self.hostname = readName(r"SYSTEM\CurrentControlSet\Control\ComputerName\ComputerName",'ComputerName')
 21 | 		self.OS = {}
 22 | 		self.serialnumber = ""
 23 | 		self.Firewall = {}
 24 | 		self.installedHotfixes = {} # Install date : [KBs]
 25 | 		self.McAfee = {}
 26 | 		self.USB = {}
 27 | 		self.NetworkCards = {} # Card name : Type
 28 | 		self.Users = {} # Dict of Dicts = Username {Admin, Password last set, Last logon, Password required, Account active, Password expires}
 29 | 		self.SoftwareList = set() # Uniqe list of Installed softwares
 30 | 		self.IPs = {} # Dict of IP : Date, DHCPServer
 31 | 		self.MACs = set() # Uniqe list of MAC address
 32 | 		self.Processes = {} # Dict of PID : Name
 33 | 		self.CommandsOnStartup = {} # Dict of name of the command : if its currently running
 34 | 		self.Netstat = [] # List of Dict's of all connections - Dict includes: ip addresses, protocol, app name, pid and status
 35 | 		self.Tasks = [] # List of Dict's of all tasks - Dict includes: name, next run date and status
 36 | 		self.HostsFile = {} # Dict's of all entries - Dict includes: counted number, requested domain and target ip
 37 | 		self.LocalNetworkMachines = [] # List of hostnames on the network
 38 | 		self.ArpTable = {} # Dict of ARP table by interface, every interface have his own arp table
 39 | 		self.Recent = [] # List of recent files
 40 | 
 41 | 	def fOS(self):
 42 | 		# Fills the OS dict by the description
 43 | 		try:
 44 | 			self.OS["ProductName"] = readName(r"SOFTWARE\Microsoft\Windows NT\CurrentVersion",'ProductName')
 45 | 		except:
 46 | 			self.OS["ProductName"] = "0"
 47 | 
 48 | 		try:
 49 | 			self.OS["SP"] = getServicePack()
 50 | 		except:
 51 | 			self.OS["ProductName"] = "0"
 52 | 
 53 | 		try:
 54 | 			self.OS["Bit"] = getOSArch()
 55 | 		except:
 56 | 			self.OS["Bit"] = "0"
 57 | 
 58 | 		try:
 59 | 			self.OS["InstallDate"] = timestamp2date(readName(r"SOFTWARE\Microsoft\Windows NT\CurrentVersion",'InstallDate'), 1)
 60 | 		except:
 61 | 			self.OS["InstallDate"] = "0"
 62 | 
 63 | 	def fSerialNumber(self):
 64 | 		# Extract the embeded serial number by WMIC
 65 | 		try:
 66 | 			wmicSerial = cmd("wmic bios get serialnumber")[1]
 67 | 			if wmicSerial not in ["To be filled by O.E.M.", "Default string"]:
 68 | 				self.serialnumber = wmicSerial
 69 | 			else:
 70 | 				self.serialnumber = "000000"
 71 | 		except:
 72 | 			self.serialnumber = "000000"
 73 | 
 74 | 	def fHotfixs(self):
 75 | 		# Parse all of the installed hotfixes into a dict:
 76 | 		# TO DO: Parse it out from the registry to avoid the CMD command.
 77 | 		# Example of return: {'Sum': 4, 'Dict': {'1/14/2016': ['KB2425227', 'KB2533552', 'KB2534366', 'KB971412']}}
 78 | 		self.installedHotfixes = {"Sum":0, "Dict":{}} 
 79 | 		try:
 80 | 			kblist = cmd("wmic qfe get hotfixid,installedon")
 81 | 			for i in kblist:
 82 | 				try:
 83 | 					if i[:2] == "KB":
 84 | 						self.installedHotfixes["Sum"] += 1
 85 | 						kbNum,installDate = i.split()
 86 | 						if installDate in self.installedHotfixes["Dict"]:
 87 | 							self.installedHotfixes["Dict"][installDate].append(kbNum)
 88 | 						else:
 89 | 							self.installedHotfixes["Dict"][installDate] = []
 90 | 							self.installedHotfixes["Dict"][installDate].append(kbNum)
 91 | 				except:
 92 | 					pass
 93 | 		except Exception as e:
 94 | 			print e
 95 | 			self.installedHotfixes["Sum"] = -1 # Return -1 to report the error
 96 | 
 97 | 	def fFirewall(self):
 98 | 		# Checks firewall status
 99 | 		try:
100 | 			StandardProfile = readName(r"SYSTEM\CurrentControlSet\Services\SharedAccess\Parameters\FirewallPolicy\StandardProfile",'EnableFirewall')
101 | 		except:
102 | 			StandardProfile = "0" # Never was enabled so the reg key wasnt created
103 | 		
104 | 		if StandardProfile.find("1") != -1:
105 | 			self.Firewall["Status"] = "ON"
106 | 		else:
107 | 			self.Firewall["Status"] = "OFF"
108 | 
109 | 		# Load the firewall rules:
110 | 		self.Firewall["Rules"] = []
111 | 		try:
112 | 			rulesDict = readValues(r"SYSTEM\CurrentControlSet\services\SharedAccess\Parameters\FirewallPolicy\FirewallRules")
113 | 			for name, value in rulesDict.iteritems():
114 | 				try:
115 | 					rule = parseFirewallRule(value)
116 | 					if rule["Active"] == "TRUE" and rule["Action"] == "Allow" and "FirewallAPI.dll" not in rule["Name"]:
117 | 						self.Firewall["Rules"].append(rule)
118 | 				except:
119 | 					pass
120 | 		except:
121 | 			pass # No rules
122 | 
123 | 	def fMcAfee(self):
124 | 		try:
125 | 			self.McAfee["Installed"] = 1
126 | 			if "64" in self.OS["Bit"]:
127 | 				self.McAfee["Version"] = readName(r"Software\Wow6432Node\McAfee\DesktopProtection",'szProductVer')
128 | 				self.McAfee["DatDate"] = parseMcAfeeDatDate(readName(r"Software\Wow6432Node\McAfee\AVEngine",'AVDatDate'))
129 | 			else:
130 | 				self.McAfee["Version"] = readName(r"Software\McAfee\DesktopProtection",'szProductVer')
131 | 				self.McAfee["DatDate"] = parseMcAfeeDatDate(readName(r"Software\McAfee\AVEngine",'AVDatDate'))
132 | 
133 | 			self.McAfee["LogDir"] = readName(r"SYSTEM\CurrentControlSet\Control\Session Manager\Environment",'DEFLOGDIR')
134 | 			self.McAfee["WeeklySched"] = getMcAfeeSchedStatus(self.OS["Bit"]) # Registry path is diffrent from 64Bit to 32Bit
135 | 			self.McAfee["Action"] = getMcAfeeAction(self.OS["Bit"]) # Registry path is diffrent from 64Bit to 32Bit
136 | 			self.McAfee["Exclusions"] = getMcAfeeExclusions(self.OS["Bit"]) # Registry path is diffrent from 64Bit to 32Bit
137 | 			self.McAfee["lastScan"] = parseMcAfeeLastScanDate(self.McAfee["LogDir"])
138 | 			self.McAfee["Logs"] = parseMcAfeeLogs(self.McAfee["LogDir"])
139 | 			self.McAfee["quarantine"] = listdir("C:\quarantine")
140 | 		except:
141 | 			self.McAfee["Installed"] = 0
142 | 
143 | 
144 | 	def fUSB(self):
145 | 		cmd(PanoramaDir+"\USBDeview.exe /shtml "+PanoramaDir+"\usbdeview.html")
146 | 		try:
147 | 			self.USB = parseUSB(PanoramaDir+"\usbdeview.html")
148 | 		except:
149 | 			pass
150 | 
151 | 	def fNetworkCards(self):
152 | 		# Check on USB plugs:
153 | 		networds = ['wireless','lan','bluetooth','ethernet','802.11','nic','802.11n','802.11a','802.11ac','802.11g','802.11b','net','tplink','tp-link','linksys','dlink','d-link','link','band','dualband','dsl','netstick']
154 | 		for uid,usb in self.USB.iteritems():
155 | 			try:
156 | 				usbname = usb["name"]+" - "+usb["type"]
157 | 				if any(word in usbname.lower() for word in networds):
158 | 					self.NetworkCards[usbname] = "Wireless"
159 | 			except:
160 | 				pass
161 | 
162 | 		# Check on registry
163 | 		try:
164 | 			networkCards = readKeys(r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkCards")
165 | 			for card in networkCards:
166 | 				try:
167 | 					cardName = readName(r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkCards\%s" % card, "Description")
168 | 					self.NetworkCards[cardName] = "Network"
169 | 				except:
170 | 					pass
171 | 		except:
172 | 			pass
173 | 
174 | 	def fUsers(self):
175 | 		wantedDetails = ["Password last set", "Last logon", "Password required", "Account active", "Password expires"]
176 | 		try:
177 | 			usersList = parseUsers(cmd("net user"))
178 | 			for user in usersList:
179 | 				self.Users[user] = {}
180 | 				userDetails = cmd("net user "+user)
181 | 
182 | 				# Check if this user in administrators group
183 | 				if str(userDetails).find("Administrators") != -1:
184 | 					self.Users[user]["admin"] = "Yes"
185 | 				else:
186 | 					self.Users[user]["admin"] = "No"
187 | 
188 | 				for line in userDetails:
189 | 					for lineInfo in line.split("\t"):
190 | 						try:
191 | 							valueName = lineInfo.split("  ")[0]
192 | 							if valueName in wantedDetails:
193 | 								self.Users[user][valueName] = lineInfo.rsplit("  ",1)[1]
194 | 						except:
195 | 							pass
196 | 		except:
197 | 			pass
198 | 
199 | 	def fSoftwareList(self):
200 | 		try:
201 | 			# Registry Uninstall path:		
202 | 			for software in readKeys(r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"):
203 | 				if "{" != software[0]:
204 | 					try:
205 | 						software = readName(r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall",'DisplayName')
206 | 					except:
207 | 						pass # No display name - take the key name
208 | 					self.SoftwareList.add(software)
209 | 		except:
210 | 			pass
211 | 
212 | 		# Installed DIRs and merage the set lists:
213 | 		try:
214 | 			self.SoftwareList |= set(listdir("C:\Program Files"))
215 | 		except:
216 | 			pass
217 | 
218 | 
219 | 		if "64" in self.OS["Bit"]:
220 | 			try:
221 | 				self.SoftwareList |= set(listdir("C:\Program Files (x86)"))
222 | 			except:
223 | 				pass
224 | 
225 | 		try:
226 | 			self.SoftwareList |= set(listdir(appdata))
227 | 		except:
228 | 			pass
229 | 
230 | 		try:
231 | 			self.SoftwareList |= set(listdir(appdata.replace("Roaming","Local")))
232 | 		except:
233 | 			pass
234 | 
235 | 		try:
236 | 			self.SoftwareList |= set(listdir(appdata.replace("Roaming","LocalLow")))
237 | 		except:
238 | 			pass
239 | 
240 | 	def fIPs(self):
241 | 		try:
242 | 			for ip in readKeys(r"SYSTEM\CurrentControlSet\services\Tcpip\Parameters\Interfaces"):
243 | 				try:
244 | 					try:
245 | 						ipAddress = readName(r"SYSTEM\CurrentControlSet\services\Tcpip\Parameters\Interfaces\%s" % ip, 'DhcpIPAddress')
246 | 					except:
247 | 						ipAddress = readName(r"SYSTEM\CurrentControlSet\services\Tcpip\Parameters\Interfaces\%s" % ip, 'IPAddress')
248 | 
249 | 					ipAddress = ipAddress.strip(" []'u")
250 | 					if ipAddress != "0.0.0.0":
251 | 						self.IPs[ipAddress] = {}
252 | 						self.IPs[ipAddress]["Time"] = timestamp2date(readName(r"SYSTEM\CurrentControlSet\services\Tcpip\Parameters\Interfaces\%s" % ip, 'LeaseObtainedTime'), 1)
253 | 						self.IPs[ipAddress]["DhcpServer"] = readName(r"SYSTEM\CurrentControlSet\services\Tcpip\Parameters\Interfaces\%s" % ip, 'DhcpServer')
254 | 
255 | 				except:
256 | 					pass # Not really used IP address
257 | 		except:
258 | 			pass
259 | 
260 | 		try:
261 | 			self.IPs["Current"] = getCurrentIPs()
262 | 		except:
263 | 			pass
264 | 
265 | 	def fMACs(self):
266 | 		try:
267 | 			for MAC in cmd('ipconfig /all | find "Physical Address"'):
268 | 				try:
269 | 					self.MACs.add(MAC.split(":",1)[1])
270 | 				except:
271 | 					pass
272 | 		except:
273 | 			pass
274 | 
275 | 	def fProcesses(self):
276 | 		whitelist = ["audiodg.exe","conhost.exe","csrss.exe","lsass.exe","lsm.exe","MSCamS64.exe","McTray.exe","alg.exe","naPrdMgr.exe","OSPPSVC.EXE","PresentationFontCache.exe","SearchIndexer.exe","services.exe","smss.exe","spoolsv.exe","svchost.exe","System","SystemIdleProcess","UNS.exe","wininit.exe","WmiApSrv.exe","WmiPrvSE.exe","wmpnetwk.exe","WUDFHost.exe","chrome.exe","atiesrxx.exe","stacsv64.exe","tasklist.exe","conhost.exe","SmartMenu.exe","explorer.exe","explore.exe","taskhost.exe","cmd.exe","LogonUI.exe","jusched.exe","dllhost.exe","taskeng.exe","TrustedInstaller.exe","shstat.exe","winlogon.exe","ctfmon.exe","mcshield.exe","WLIDSVC.EXE","notepad.exe","VsTskMgr.exe","mfeann.exe","RtkNGUI64.exe","mfevtps.exe"]
277 | 		try:
278 | 			for proc in getActiveProcesses():
279 | 				try:
280 | 					pid, pname = parseProc(proc)
281 | 					self.Processes[pid] = pname
282 | 				except:
283 | 					pass
284 | 		except:
285 | 			pass
286 | 
287 | 	def fCommandsOnStartup(self):
288 | 		# Registry of x86 Bit:
289 | 		try:
290 | 			run = readValues(r"SOFTWARE\Microsoft\Windows\CurrentVersion\Run")
291 | 			for name,command in run.iteritems():
292 | 				self.CommandsOnStartup[command] = 0
293 | 		except:
294 | 			pass
295 | 
296 | 		try:
297 | 			runonce = readValues(r"SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce")
298 | 			for name,command in runonce.iteritems():
299 | 				self.CommandsOnStartup[command] = 0
300 | 		except:
301 | 			pass
302 | 
303 | 		# Registry of x64 Bit:
304 | 		if "64" in self.OS["Bit"]:
305 | 			try:
306 | 				run = readValues(r"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Run")
307 | 				for name,command in run.iteritems():
308 | 					self.CommandsOnStartup[command] = 0
309 | 			except:
310 | 				pass
311 | 
312 | 			try:
313 | 				runonce = readValues(r"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\RunOnce")
314 | 				for name,command in runonce.iteritems():
315 | 					self.CommandsOnStartup[command] = 0
316 | 			except:
317 | 				pass
318 | 		
319 | 		try:
320 | 			# Startup folder of user AppData:
321 | 			startupDirPath = appdata+"\Microsoft\Windows\Start Menu\Programs\Startup"
322 | 			if isdir(startupDirPath):
323 | 				startupDir = listdir(startupDirPath)
324 | 				for sFile in startupDir:
325 | 					try:
326 | 						if sFile != "desktop.ini":
327 | 							self.CommandsOnStartup[sFile] = 0
328 | 					except:
329 | 						pass
330 | 		except:
331 | 			pass
332 | 
333 | 		try:
334 | 			# Check which of the startup commands are running right now:
335 | 			for command in self.CommandsOnStartup:
336 | 				try:
337 | 					if (str(self.Processes).lower()).find(command.rsplit(".",-1)[0].rsplit("\\",1)[1].lower()) != -1:
338 | 						self.CommandsOnStartup[command] = 1
339 | 				except Exception as e:
340 | 					print e
341 | 		except:
342 | 			pass
343 | 
344 | 	def fNetStat(self):
345 | 		try:
346 | 			netstatTable = cmd("netstat -no")[3:]
347 | 			for line in netstatTable:
348 | 				try:
349 | 					connection = filter(None,line.split("  "))
350 | 					self.Netstat.append(parseConnection(connection, self.Processes))
351 | 				except:
352 | 					pass
353 | 		except:
354 | 			pass
355 | 
356 | 	def fTasks(self):
357 | 		try:
358 | 			for task in getTaskschList():
359 | 				try:
360 | 					if "\Microsoft\Windows" not in task: # Hide all defaults
361 | 						parsedTask = parseTask(task)
362 | 						if parsedTask and parsedTask not in self.Tasks:
363 | 							self.Tasks.append(parsedTask)
364 | 				except:
365 | 					pass
366 | 		except:
367 | 			pass
368 | 
369 | 	def fHosts(self):
370 | 		try:
371 | 			HostsFileContent = getHostsFileContent()
372 | 			count = 0
373 | 			for line in HostsFileContent:
374 | 				try:
375 | 					if line[0] != "#":
376 | 						try:
377 | 							ip, domain = parseHosts(line)
378 | 							self.HostsFile[count] = {}
379 | 							self.HostsFile[count]["TargetIP"] = ip
380 | 							self.HostsFile[count]["RequestedDomain"] = domain
381 | 							count += 1
382 | 						except:
383 | 							pass
384 | 				except:
385 | 					pass
386 | 		except:
387 | 			pass
388 | 
389 | 	def fLocalNetworkMachines(self):
390 | 		try:
391 | 			for hostname in cmd("net view")[3:-1]:
392 | 				try:
393 | 					self.LocalNetworkMachines.append(hostname.strip().replace("\\\\",""))
394 | 				except:
395 | 					pass
396 | 		except:
397 | 			pass
398 | 
399 | 	def fArpTable(self):
400 | 		try:
401 | 			arptable = getArpTable()
402 | 			for interface in arptable:
403 | 				try:
404 | 					localIP = interface.split("Interface:")[1].split("--")[0].strip()
405 | 					self.ArpTable[localIP] = []
406 | 					for line in interface.split("Type")[1].split("\n"):
407 | 						if len(line) > 1: self.ArpTable[localIP].append(parseArpTableLine(line))
408 | 				except:
409 | 					pass
410 | 		except:
411 | 			pass
412 | 
413 | 	def fRecent(self):
414 | 		try:
415 | 			RecentDirPath = appdata+"\Microsoft\Windows\Recent"
416 | 			if isdir(RecentDirPath):
417 | 				listRecentDirPath = listdir(RecentDirPath)
418 | 				for rfile in listRecentDirPath:
419 | 					try:
420 | 						self.Recent.append(appdata+"\Microsoft\Windows\Recent\%s" % rfile.decode('iso8859_8').replace("?","\\"))
421 | 					except:
422 | 						pass
423 | 		except:
424 | 			pass
425 | 
426 | 
427 | 
428 | forensic = Forensic()


--------------------------------------------------------------------------------
/src/utils/getters.py:
--------------------------------------------------------------------------------
 1 | from os import popen
 2 | 
 3 | from lib.Registry import *
 4 | 
 5 | def cmd(command):
 6 | 	# Using for single command from cmd
 7 | 	return popen(command).read().strip().split("\n")
 8 | 
 9 | def getServicePack():
10 | 	# Parse the service pack of the system
11 | 	spDict = {"0":"SP0", "256":"SP1", "512":"SP2", "768":"SP3", "1024":"SP4"}
12 | 	try:
13 | 		sp = readName(r"SYSTEM\CurrentControlSet\Control\Windows",'CSDVersion')
14 | 		return spDict[str(sp)]
15 | 	except:
16 | 		return "SP0"
17 | 
18 | def getOSArch():
19 | 	# Parse how many Bit this processor
20 | 	if "86" in readName(r"SYSTEM\CurrentControlSet\Control\Session Manager\Environment",'PROCESSOR_ARCHITECTURE'):
21 | 		return "32Bit"
22 | 	else:
23 | 		return "64Bit"
24 | 
25 | def getMcAfeeSchedStatus(Bit):
26 | 	# Checks if full scan schedule is set at least for every 7 days
27 | 	if "64" in Bit: # 64Bit host
28 | 		if int(readName(r"Software\Wow6432Node\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'bSchedEnabled')) == 1:
29 | 			if int(readName(r"Software\Wow6432Node\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'Weekly_maskDaysOfWeek')) != 0 and int(readName(r"Software\Wow6432Node\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'Weekly_nRepeatWeeks')) == 1: return 1
30 | 			if int(readName(r"Software\Wow6432Node\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'Daily_nRepeatDays')) < 8: return 1
31 | 		return 0
32 | 	else: # x32Bit host
33 | 		if int(readName(r"Software\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'bSchedEnabled')) == 1:
34 | 			if int(readName(r"Software\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'Weekly_maskDaysOfWeek')) != 0 and int(readName(r"Software\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'Weekly_nRepeatWeeks')) == 1: return 1
35 | 			if int(readName(r"Software\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'Daily_nRepeatDays')) < 8: return 1
36 | 		return 0
37 | 
38 | def getMcAfeeAction(Bit):
39 | 	if "64" in Bit: # 64Bit host
40 | 		if readName(r"SOFTWARE\Wow6432Node\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'uAction_Program') in ["4","5"]: return "Delete"
41 | 		if readName(r"SOFTWARE\Wow6432Node\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'uAction') in ["4","5"]: return "Delete"
42 | 		return "Scan"
43 | 	else: # x32Bit host
44 | 		if readName(r"SOFTWARE\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'uAction_Program') in ["4","5"]: return "Delete"
45 | 		if readName(r"SOFTWARE\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}",'uAction') in ["4","5"]: return "Delete"
46 | 		return "Scan"
47 | 
48 | def getMcAfeeExclusions(Bit):
49 | 	if "64" in Bit: # 64Bit host
50 | 		query = readValues(r"SOFTWARE\Wow6432Node\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}")
51 | 	else: # x32Bit host
52 | 		query = readValues(r"SOFTWARE\McAfee\DesktopProtection\Tasks\{21221C11-A06D-4558-B833-98E8C7F6C4D2}")
53 | 
54 | 	Exclusions = []
55 | 	for name, value in query.iteritems():
56 | 		if name.lower()[:13] == "excludeditem_":
57 | 			Exclusions.append(value)
58 | 	return Exclusions
59 | 
60 | def getCurrentIPs():
61 | 	LiveIPs = []
62 | 	current = cmd('ipconfig | find "IP"')[1:] # the 1: is to avoid the first printed junk line
63 | 	for ip in current:
64 | 		try:
65 | 			LiveIPs.append(ip.split(":",1)[1].strip())
66 | 		except Exception as e:
67 | 			print e
68 | 	return LiveIPs
69 | 
70 | def getActiveProcesses():
71 | 	return popen("tasklist /FO LIST").read().strip().split("\n\n")
72 | 
73 | def getTaskschList():
74 | 	return popen("schtasks /Query /FO LIST").read().strip().split("\n\n")
75 | 
76 | def getHostsFileContent():
77 | 	return open("c:\windows\system32\drivers\etc\hosts",'r').readlines()
78 | 
79 | def getArpTable():
80 | 	return popen("arp -a").read().strip().split("\n\n")


--------------------------------------------------------------------------------
/src/utils/parsers.py:
--------------------------------------------------------------------------------
  1 | import re
  2 | 
  3 | def parseFirewallRule(line):
  4 | 	# Recive the value from the registry and return parsed dict of the rule
  5 | 	rule = {}
  6 | 	rule["Active"] = line.split("Active=")[1].split("|")[0]
  7 | 	rule["App"] = line.split("App=")[1].split("|")[0]
  8 | 	rule["Name"] = line.split("Name=")[1].split("|")[0]
  9 | 	rule["Action"] = line.split("Action=")[1].split("|")[0]
 10 | 	return rule
 11 | 
 12 | def parseMcAfeeDatDate(date):
 13 | 	# Convert the date 2016/12/31 into 31/12/2016
 14 | 	date = date.split("/")
 15 | 	return date[2]+"/"+date[1]+"/"+date[0]
 16 | 
 17 | def parseMcAfeeLastScanDate(path):
 18 | 	# Reads the end of the file OnDemandScanLog from DEFLOGDIR and parse the last date
 19 | 	offset = 0
 20 | 	line = ''
 21 | 	with open(path+"\\"+"OnDemandScanLog.txt") as f: 
 22 | 		while True: 
 23 | 			offset -= 1
 24 | 			f.seek(offset, 2) 
 25 | 			nextline = f.next() 
 26 | 			if nextline == '\n' and line.strip(): 
 27 | 				return line.split("\t")[1].rsplit(":",1)[0] + " " + line.split("\t")[0]
 28 | 				break
 29 | 			else:
 30 | 				line = nextline
 31 | 
 32 | def parseMcAfeeLogs(path):
 33 | 	# Extract the suspicios logs
 34 | 	KnownLogfilesNames = ['AccessProtectionLog.txt','OnAccessScanLog.txt','OnDemandScanLog.txt']
 35 | 	Logs = []
 36 | 	for logfile in KnownLogfilesNames:
 37 | 		try:
 38 | 			logfile = open(path+"\\"+logfile,'r').read()
 39 | 			for line in logfile.split("\n"):
 40 | 				parsedLine = {}
 41 | 				if "trojan" in line.lower() or "deleted)" in line.lower() or "no action taken" in line.lower() or "unwanted program" in line.lower():
 42 | 					if "scan timed out" not in line.lower():
 43 | 						line = line.split("\t")
 44 | 						parsedLine["Date"] = line[0]
 45 | 						parsedLine["Time"] = line[1]
 46 | 						parsedLine["Action"] = line[2]
 47 | 						parsedLine["Process"] = line[4]
 48 | 						parsedLine["Path"] = line[5]
 49 | 						parsedLine["Description"] = line[6]
 50 | 						parsedLine["Hash"] = line[7]
 51 | 						Logs.append(parsedLine)
 52 | 		except:
 53 | 			pass
 54 | 	return Logs
 55 | 
 56 | def parseUSB(path):
 57 | 	# Build a dict of all USBs connections
 58 | 	uid = 0
 59 | 	USB = {}
 60 | 	USBfile = open(path, 'r').read().split("<tr>")
 61 | 	for usb in USBfile:
 62 | 		try:
 63 | 			if "<td" == usb[:3]:
 64 | 				uid = uid + 1
 65 | 				USB[uid]={}
 66 | 				#get all values from table:
 67 | 				usbparse = re.findall(r"([^>]*)[$<]", usb)
 68 | 				#get the usb title:
 69 | 				if "0000" in usbparse[1]:
 70 | 					usbname = usbparse[2]
 71 | 				else:
 72 | 					usbname=usbparse[1]+" - "+usbparse[2]
 73 | 				#set the usb name:
 74 | 				USB[uid]['name']=usbname
 75 | 				#get the usb type:
 76 | 				usbtype = usbparse[3]
 77 | 				USB[uid]['type']=usbtype
 78 | 				#get the usb serial:
 79 | 				usbserial = usbparse[9]
 80 | 				USB[uid]['serial']=usbserial
 81 | 				#get the first date:
 82 | 				usbfdate = usbparse[10]
 83 | 				USB[uid]['fdate']=usbfdate.replace(" ","|")
 84 | 				#get the last date:
 85 | 				usbldate = usbparse[11]
 86 | 				USB[uid]['ldate']=usbldate.replace(" ","|")
 87 | 		except:
 88 | 			pass
 89 | 	return USB
 90 | 
 91 | def parseUsers(output):
 92 | 	return output[3:][:-1][0].split() # Remove 2 first line and 1 last line
 93 | 
 94 | def parseProc(proc):
 95 | 	PID = ""
 96 | 	Name = ""
 97 | 	for line in proc.split("\n"):
 98 | 		lineName = line.split(":",1)[0]
 99 | 		if lineName == "PID":
100 | 			PID = line.split(":",1)[1].strip()
101 | 		if lineName == "Image Name":
102 | 			Name = line.split(":",1)[1].strip()
103 | 	
104 | 	return PID, Name
105 | 
106 | def parseConnection(line, Processes):
107 | 	connection = {}
108 | 	# Index: 0=Protocol, 1=Local, 2=Remote, 3=Status, 4=PID
109 | 	connection["Local"] = line[1].strip()
110 | 	connection["Remote"] = line[2].strip()
111 | 	connection["Status"] = line[3].strip()
112 | 	connection["Protocol"] = line[0].strip()
113 | 	connection["PID"] = line[4].strip()
114 | 	connection["appName"] = Processes[line[4].strip()]
115 | 	return connection
116 | 
117 | def parseTask(Task):
118 | 	wantedDetails = ["TaskName", "Next Run Time", "Status"]
119 | 	parsedTask = {}
120 | 	for line in Task.split("\n"):
121 | 		if line.split(":")[0] in wantedDetails:
122 | 			parsedTask[line.split(":")[0]] = line.split(":")[1].strip()
123 | 
124 | 	return parsedTask
125 | 
126 | def parseHosts(hostLine):
127 | 	return hostLine.split(" ")[0], hostLine.rsplit(" ",1)[1].strip()
128 | 
129 | def parseArpTableLine(line):
130 | 	parsedLine = {}
131 | 	for value in line.split():
132 | 		if "." in value:
133 | 			parsedLine["IP"] = value
134 | 		elif "-" in value:
135 | 			parsedLine["MAC"] = value
136 | 		else:
137 | 			parsedLine["Type"] = value
138 | 	return parsedLine


--------------------------------------------------------------------------------