Utility.py 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373
  1. import calendar as cal
  2. import datetime as dt
  3. import ipaddress
  4. import os
  5. import random as rnd
  6. import matplotlib
  7. import scipy.stats as stats
  8. matplotlib.use('Agg', force=True)
  9. import lea
  10. import xdg.BaseDirectory as BaseDir
  11. import scapy.layers.inet as inet
  12. CACHE_DIR = os.path.join(BaseDir.xdg_cache_home, 'id2t')
  13. CODE_DIR = os.path.dirname(os.path.abspath(__file__)) + "/../"
  14. ROOT_DIR = CODE_DIR + "../"
  15. RESOURCE_DIR = ROOT_DIR + "resources/"
  16. TEST_DIR = RESOURCE_DIR + "test/"
  17. OUT_DIR = None
  18. MISC_OUT_FILES = {}
  19. platforms = {"win7", "win10", "winxp", "win8.1", "macos", "linux", "win8", "winvista", "winnt", "win2000"}
  20. platform_probability = {"win7": 48.43, "win10": 27.99, "winxp": 6.07, "win8.1": 6.07, "macos": 5.94, "linux": 3.38,
  21. "win8": 1.35, "winvista": 0.46, "winnt": 0.31}
  22. x86_nops = {b'\x90', b'\xfc', b'\xfd', b'\xf8', b'\xf9', b'\xf5', b'\x9b'}
  23. x86_pseudo_nops = {b'\x97', b'\x96', b'\x95', b'\x93', b'\x92', b'\x91', b'\x99', b'\x4d', b'\x48', b'\x47', b'\x4f',
  24. b'\x40', b'\x41', b'\x37', b'\x3f', b'\x27', b'\x2f', b'\x46', b'\x4e', b'\x98', b'\x9f', b'\x4a',
  25. b'\x44', b'\x42', b'\x43', b'\x49', b'\x4b', b'\x45', b'\x4c', b'\x60', b'\x0e', b'\x1e', b'\x50',
  26. b'\x55', b'\x53', b'\x51', b'\x57', b'\x52', b'\x06', b'\x56', b'\x54', b'\x16', b'\x58', b'\x5d',
  27. b'\x5b', b'\x59', b'\x5f', b'\x5a', b'\x5e', b'\xd6'}
  28. forbidden_chars = [b'\x00', b'\x0a', b'\x0d']
  29. attacker_port_mapping = {}
  30. attacker_ttl_mapping = {}
  31. generic_attack_names = {"attack", "exploit"}
  32. def update_timestamp(timestamp, pps, delay=0):
  33. """
  34. Calculates the next timestamp to be used based on the packet per second rate (pps) and the maximum delay.
  35. :return: Timestamp to be used for the next packet.
  36. """
  37. if delay == 0:
  38. # Calculate request timestamp
  39. # To imitate the bursty behavior of traffic
  40. randomdelay = lea.Lea.fromValFreqsDict({1 / pps: 70, 2 / pps: 20, 5 / pps: 7, 10 / pps: 3})
  41. return timestamp + rnd.uniform(1 / pps, randomdelay.random())
  42. else:
  43. # Calculate reply timestamp
  44. randomdelay = lea.Lea.fromValFreqsDict({2 * delay: 70, 3 * delay: 20, 5 * delay: 7, 10 * delay: 3})
  45. return timestamp + rnd.uniform(1 / pps + delay, 1 / pps + randomdelay.random())
  46. def get_interval_pps(complement_interval_pps, timestamp):
  47. """
  48. Gets the packet rate (pps) for a specific time interval.
  49. :param complement_interval_pps: an array of tuples (the last timestamp in the interval, the packet rate in the
  50. corresponding interval).
  51. :param timestamp: the timestamp at which the packet rate is required.
  52. :return: the corresponding packet rate (pps) .
  53. """
  54. for row in complement_interval_pps:
  55. if timestamp <= row[0]:
  56. return row[1]
  57. return complement_interval_pps[-1][1] # in case the timstamp > capture max timestamp
  58. def get_nth_random_element(*element_list):
  59. """
  60. Returns the n-th element of every list from an arbitrary number of given lists.
  61. For example, list1 contains IP addresses, list 2 contains MAC addresses. Use of this function ensures that
  62. the n-th IP address uses always the n-th MAC address.
  63. :param element_list: An arbitrary number of lists.
  64. :return: A tuple of the n-th element of every list.
  65. """
  66. if len(element_list) <= 0:
  67. return None
  68. elif len(element_list) == 1 and len(element_list[0]) > 0:
  69. return rnd.choice(element_list[0])
  70. else:
  71. range_max = min([len(x) for x in element_list])
  72. if range_max > 0:
  73. range_max -= 1
  74. n = rnd.randint(0, range_max)
  75. return tuple(x[n] for x in element_list)
  76. else:
  77. return None
  78. def get_rnd_os():
  79. """
  80. Chooses random platform over an operating system probability distribution
  81. :return: random platform as string
  82. """
  83. os_dist = lea.Lea.fromValFreqsDict(platform_probability)
  84. return os_dist.random()
  85. def check_platform(platform: str):
  86. """
  87. Checks if the given platform is currently supported
  88. if not exits with error
  89. :param platform: the platform, which should be validated
  90. """
  91. if platform not in platforms:
  92. print("\nERROR: Invalid platform: " + platform + "." +
  93. "\n Please select one of the following platforms: ", platforms)
  94. exit(1)
  95. def get_ip_range(start_ip: str, end_ip: str):
  96. """
  97. Generates a list of IPs of a given range. If the start_ip is greater than the end_ip, the reverse range is generated
  98. :param start_ip: the start_ip of the desired IP-range
  99. :param end_ip: the end_ip of the desired IP-range
  100. :return: a list of all IPs in the desired IP-range, including start-/end_ip
  101. """
  102. start = ipaddress.ip_address(start_ip)
  103. end = ipaddress.ip_address(end_ip)
  104. ips = []
  105. if start < end:
  106. while start <= end:
  107. ips.append(start.exploded)
  108. start = start + 1
  109. elif start > end:
  110. while start >= end:
  111. ips.append(start.exploded)
  112. start = start - 1
  113. else:
  114. ips.append(start_ip)
  115. return ips
  116. def generate_source_port_from_platform(platform: str, previous_port=0):
  117. """
  118. Generates the next source port according to the TCP-port-selection strategy of the given platform
  119. :param platform: the platform for which to generate source ports
  120. :param previous_port: the previously used/generated source port. Must be 0 if no port was generated before
  121. :return: the next source port for the given platform
  122. """
  123. check_platform(platform)
  124. if platform in {"winnt", "winxp", "win2000"}:
  125. if (previous_port == 0) or (previous_port + 1 > 5000):
  126. return rnd.randint(1024, 5000)
  127. else:
  128. return previous_port + 1
  129. elif platform == "linux":
  130. return rnd.randint(32768, 61000)
  131. else:
  132. if (previous_port == 0) or (previous_port + 1 > 65535):
  133. return rnd.randint(49152, 65535)
  134. else:
  135. return previous_port + 1
  136. def get_filetime_format(timestamp):
  137. """
  138. Converts a timestamp into MS FILETIME format
  139. :param timestamp: a timestamp in seconds
  140. :return: MS FILETIME timestamp
  141. """
  142. boot_datetime = dt.datetime.fromtimestamp(timestamp)
  143. if boot_datetime.tzinfo is None or boot_datetime.tzinfo.utcoffset(boot_datetime) is None:
  144. boot_datetime = boot_datetime.replace(tzinfo=boot_datetime.tzname())
  145. boot_filetime = 116444736000000000 + (cal.timegm(boot_datetime.timetuple()) * 10000000)
  146. return boot_filetime + (boot_datetime.microsecond * 10)
  147. def get_rnd_boot_time(timestamp, platform="winxp"):
  148. """
  149. Generates a random boot time based on a given timestamp and operating system
  150. :param timestamp: a timestamp in seconds
  151. :param platform: a platform as string as specified in check_platform above. default is winxp. this param is optional
  152. :return: timestamp of random boot time in seconds since EPOCH
  153. """
  154. check_platform(platform)
  155. if platform is "linux":
  156. uptime_in_days = lea.Lea.fromValFreqsDict({3: 50, 7: 25, 14: 12.5, 31: 6.25, 92: 3.125, 183: 1.5625,
  157. 365: 0.78125, 1461: 0.390625, 2922: 0.390625})
  158. elif platform is "macos":
  159. uptime_in_days = lea.Lea.fromValFreqsDict({7: 50, 14: 25, 31: 12.5, 92: 6.25, 183: 3.125, 365: 3.076171875,
  160. 1461: 0.048828125})
  161. else:
  162. uptime_in_days = lea.Lea.fromValFreqsDict({3: 50, 7: 25, 14: 12.5, 31: 6.25, 92: 3.125, 183: 1.5625,
  163. 365: 0.78125, 1461: 0.78125})
  164. timestamp -= rnd.randint(0, uptime_in_days.random() * 86400)
  165. return timestamp
  166. def get_rnd_x86_nop(count=1, side_effect_free=False, char_filter=set()):
  167. """
  168. Generates a specified number of x86 single-byte (pseudo-)NOPs
  169. :param count: The number of bytes to generate
  170. :param side_effect_free: Determines whether NOPs with side-effects (to registers or the stack) are allowed
  171. :param char_filter: A set of bytes which are forbidden to generate
  172. :return: Random x86 NOP bytestring
  173. """
  174. result = b''
  175. nops = x86_nops.copy()
  176. if not side_effect_free:
  177. nops |= x86_pseudo_nops.copy()
  178. if not isinstance(char_filter, set):
  179. char_filter = set(char_filter)
  180. nops = list(nops - char_filter)
  181. for i in range(0, count):
  182. result += nops[rnd.randint(0, len(nops) - 1)]
  183. return result
  184. def get_rnd_bytes(count=1, ignore=None):
  185. """
  186. Generates a specified number of random bytes while excluding unwanted bytes
  187. :param count: Number of wanted bytes
  188. :param ignore: The bytes, which should be ignored, as an array
  189. :return: Random bytestring
  190. """
  191. if ignore is None:
  192. ignore = []
  193. result = b''
  194. for i in range(0, count):
  195. char = os.urandom(1)
  196. while char in ignore:
  197. char = os.urandom(1)
  198. result += char
  199. return result
  200. def check_payload_len(payload_len: int, limit: int):
  201. """
  202. Checks if the len of the payload exceeds a given limit
  203. :param payload_len: The length of the payload
  204. :param limit: The limit of the length of the payload which is allowed
  205. """
  206. if payload_len > limit:
  207. print("\nCustom payload too long: ", payload_len, " bytes. Should be a maximum of ", limit, " bytes.")
  208. exit(1)
  209. def get_bytes_from_file(filepath):
  210. """
  211. Converts the content of a file into its byte representation
  212. The content of the file can either be a string or hexadecimal numbers/bytes (e.g. shellcode)
  213. The file must have the keyword "str" or "hex" in its first line to specify the rest of the content
  214. If the content is hex, whitespaces, backslashes, "x", quotation marks and "+" are removed
  215. Example for a hexadecimal input file:
  216. hex
  217. "abcd ef \xff10\ff 'xaa' x \ ab"
  218. Output: b'\xab\xcd\xef\xff\x10\xff\xaa\xab'
  219. :param filepath: The path of the file from which to get the bytes
  220. :return: The bytes of the file (either a byte representation of a string or the bytes contained in the file)
  221. """
  222. try:
  223. file = open(filepath)
  224. result_bytes = b''
  225. header = file.readline().strip()
  226. content = file.read()
  227. if header == "hex":
  228. content = content.replace(" ", "").replace("\n", "").replace("\\", "").replace("x", "").replace("\"", "") \
  229. .replace("'", "").replace("+", "").replace("\r", "")
  230. try:
  231. result_bytes = bytes.fromhex(content)
  232. except ValueError:
  233. print("\nERROR: Content of file is not all hexadecimal.")
  234. file.close()
  235. exit(1)
  236. elif header == "str":
  237. result_bytes = content.strip().encode()
  238. else:
  239. print("\nERROR: Invalid header found: " + header + ". Try 'hex' or 'str' followed by endline instead.")
  240. file.close()
  241. exit(1)
  242. for forbidden_char in forbidden_chars:
  243. if forbidden_char in result_bytes:
  244. print("\nERROR: Forbidden character found in payload: ", forbidden_char)
  245. file.close()
  246. exit(1)
  247. file.close()
  248. return result_bytes
  249. except FileNotFoundError:
  250. print("\nERROR: File not found: ", filepath)
  251. exit(1)
  252. def handle_most_used_outputs(most_used_x):
  253. """
  254. :param most_used_x: Element or list (e.g. from SQL-query output) which should only be one element
  255. :return: most_used_x if it's not a list. The first element of most_used_x after being sorted if it's a list.
  256. None if that list is empty.
  257. """
  258. if isinstance(most_used_x, list):
  259. if len(most_used_x) == 0:
  260. return None
  261. most_used_x.sort()
  262. return most_used_x[0]
  263. else:
  264. return most_used_x
  265. def get_attacker_config(ip_source_list, ip_address: str):
  266. """
  267. Returns the attacker configuration depending on the IP address, this includes the port for the next
  268. attacking packet and the previously used (fixed) TTL value.
  269. :param ip_source_list: List of source IPs
  270. :param ip_address: The IP address of the attacker
  271. :return: A tuple consisting of (port, ttlValue)
  272. """
  273. # Gamma distribution parameters derived from MAWI 13.8G dataset
  274. alpha, loc, beta = (2.3261710235, -0.188306914406, 44.4853123884)
  275. gd = stats.gamma.rvs(alpha, loc=loc, scale=beta, size=len(ip_source_list))
  276. # Determine port
  277. port = attacker_port_mapping.get(ip_address)
  278. if port is not None: # use next port
  279. next_port = attacker_port_mapping.get(ip_address) + 1
  280. if next_port > (2 ** 16 - 1):
  281. next_port = 1
  282. else: # generate starting port
  283. next_port = inet.RandShort()
  284. attacker_port_mapping[ip_address] = next_port
  285. # Determine TTL value
  286. ttl = attacker_ttl_mapping.get(ip_address)
  287. if ttl is None: # determine TTL value
  288. is_invalid = True
  289. pos = ip_source_list.index(ip_address)
  290. pos_max = len(gd)
  291. while is_invalid:
  292. ttl = int(round(gd[pos]))
  293. if 0 < ttl < 256: # validity check
  294. is_invalid = False
  295. else:
  296. pos = (pos + 1) % pos_max
  297. attacker_ttl_mapping[ip_address] = ttl
  298. # return port and TTL
  299. return next_port, ttl
  300. def remove_generic_ending(string):
  301. """"
  302. Returns the input string with it's ending cut off, in case it was a generic one
  303. :param string: Input string
  304. :return: Input string with ending cut off
  305. """
  306. for end in generic_attack_names:
  307. if string.endswith(end):
  308. return string[:-len(end)]
  309. return string