3
0

Generator.py 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398
  1. from scapy.packet import Raw
  2. import numpy.random as random2
  3. import random
  4. import string
  5. from numpy.random import bytes
  6. from random import getrandbits
  7. from scapy.layers.inet import IP, Ether, UDP, TCP
  8. from scapy.packet import Raw
  9. from Attack.MembersMgmtCommAttack import MessageType
  10. from . import IPv4 as ip
  11. '''PaddingGenerator
  12. '''
  13. def add_padding(packet, bytes_padding:int = 0, user_padding:bool=True, rnd:bool = False):
  14. '''
  15. Adds padding to a packet with the given amount of bytes, but a maximum of 100 bytes, if called by the user.
  16. :param packet: the packet that will be extended with the additional payload
  17. :param bytes_padding: the amount of bytes that will be appended to the packet. Capped to 100,
  18. if called by the user.
  19. :param user_padding: true, if the function add_padding by the user and not within the code
  20. :param rnd: adds a random padding between 0 and bytes_padding, if true
  21. :return: the initial packet, extended with the wanted amount of bytes of padding
  22. '''
  23. if(user_padding == True and bytes_padding > 100):
  24. bytes_padding = 100
  25. if (rnd is True):
  26. r = int(round(bytes_padding / 4)) #sets bytes_padding to any number between 0 and bytes_padding
  27. bytes_padding = random2.random_integers(0, r) * 4 #, that's dividable by 4
  28. payload = generate_payload(bytes_padding)
  29. packet[Raw].load += Raw(load=payload).load
  30. return packet
  31. def equal_length(list_of_packets:list, length:int = 0, padding:int = 0, force_len:bool = False):
  32. '''
  33. Equals the length of all packets of a given list of packets to the given length. If the given length is smaller than the largest
  34. packet, all the other packets are extended to the largest packet's length. Add additional padding
  35. afterwards to create realism.
  36. :param list_of_packets: The given set of packet.
  37. :param length: The length each packet should have. Can be redundant, if the largest packet has more bytes
  38. :param force_len: if true, all packets are forced to take on the length of param length
  39. than length.
  40. :return: The list of extended packets.
  41. '''
  42. if not force_len:
  43. largest_packet = length
  44. for packet in list_of_packets:
  45. packet_length = len(packet)
  46. if(packet_length > largest_packet):
  47. largest_packet = packet_length
  48. else:
  49. largest_packet = length
  50. for packet in list_of_packets:
  51. bytes_padding = largest_packet - len(packet)
  52. if(bytes_padding > 0):
  53. add_padding(packet, bytes_padding, False, False) #Add padding to extend to param:length
  54. add_padding(packet, padding, False, True) #Add random additional padding to create realism
  55. return list_of_packets
  56. '''PayloadGenerator
  57. '''
  58. def generate_payload(size:int=0):
  59. """
  60. Generates a payload of random bytes of the given amount
  61. :param size: number of generated bytes
  62. :return: the generated payload
  63. """
  64. payload = bytes(size)
  65. return payload
  66. '''PortGenerator
  67. '''
  68. def gen_random_server_port(offset: int=2199):
  69. """
  70. Generates a valid random first and last character for a bots hostname
  71. and computes a port from these two characters.
  72. The default offset is chosen from a Sality implementation in 2011
  73. """
  74. firstLetter = random.choice(string.ascii_letters);
  75. lastLetter = random.choice(string.ascii_letters + string.digits);
  76. return (offset + ord(firstLetter) * ord(lastLetter));
  77. '''MacAddressGenerator
  78. '''
  79. class MacAddressGenerator:
  80. def __init__(self, include_broadcast_macs=False, include_virtual_macs=False):
  81. self.broadcast = include_broadcast_macs
  82. self.virtual = include_virtual_macs
  83. self.generated = set()
  84. def random_mac(self) -> str:
  85. while True:
  86. mac = self._random_mac()
  87. if mac not in self.generated:
  88. self.generated.add(mac)
  89. return mac
  90. def clear(self):
  91. self.generated.clear()
  92. def generates_broadcast_macs(self) -> bool:
  93. return self.broadcast
  94. def generates_virtual_macs(self) -> bool:
  95. return self.virtual
  96. def set_broadcast_generation(self, broadcast: bool):
  97. self.broadcast = broadcast
  98. def set_virtual_generation(self, virtual: bool):
  99. self.virtual = virtual
  100. def _random_mac(self) -> str:
  101. mac_bytes = bytearray(getrandbits(8) for i in range(6))
  102. if not self.broadcast:
  103. mac_bytes[0] &= ~1 # clear the first bytes' first bit
  104. if not self.virtual:
  105. mac_bytes[0] &= ~2 # clear the first bytes' second bit
  106. return ":".join("%02X" % b for b in mac_bytes)
  107. '''PacketGenerator
  108. '''
  109. class PacketGenerator():
  110. """
  111. Creates packets, based on the set protocol
  112. """
  113. def __init__(self, protocol="udp"):
  114. """
  115. Creates a new Packet_Generator Object
  116. :param protocol: the protocol of the packets to be created, udp or tcp
  117. """
  118. super(PacketGenerator, self).__init__()
  119. self.protocol = protocol
  120. def generate_packet(self, ip_src: str = "192.168.64.32", ip_dst: str = "192.168.64.48",
  121. mac_src: str = "56:6D:D9:BC:70:1C",
  122. mac_dst: str = "F4:2B:95:B3:0E:1A", port_src: int = 1337, port_dst: int = 6442, ttl: int = 64,
  123. tcpflags: str = "S", payload: str = ""):
  124. """
  125. Creates a Packet with the specified Values for the current protocol
  126. :param ip_src: the source IP address of the IP header
  127. :param ip_dst the destination IP address of the IP header
  128. :param mac_src: the source MAC address of the MAC header
  129. :param mac_dst: the destination MAC address of the MAC header
  130. :param port_src: the source port of the header
  131. :param port_dst: the destination port of the header
  132. :param ttl: the ttl Value of the packet
  133. :param tcpflags: the TCP flags of the TCP header
  134. :param payload: the payload of the packet
  135. :return: the corresponding packet
  136. """
  137. if (self.protocol == "udp"):
  138. packet = generate_udp_packet(ip_src=ip_src, ip_dst=ip_dst, mac_src=mac_src, mac_dst=mac_dst, ttl=ttl,
  139. port_src=port_src, port_dst=port_dst, payload=payload)
  140. elif (self.protocol == "tcp"):
  141. packet = generate_tcp_packet(ip_src=ip_src, ip_dst=ip_dst, mac_src=mac_src, mac_dst=mac_dst, ttl=ttl,
  142. port_src=port_src, port_dst=port_dst, tcpflags=tcpflags, payload=payload)
  143. return packet
  144. def generate_mmcom_packet(self, ip_src: str = "192.168.64.32", ip_dst: str = "192.168.64.48",
  145. mac_src: str = "56:6D:D9:BC:70:1C",
  146. mac_dst: str = "F4:2B:95:B3:0E:1A", port_src: int = 1337, port_dst: int = 6442,
  147. tcpflags: str = "S", ttl: int = 64,
  148. message_type: MessageType = MessageType.SALITY_HELLO, neighborlist_entries: int = 1):
  149. """
  150. Creates a Packet for Members-Management-Communication with the specified Values and the current protocol
  151. :param ip_src: the source IP address of the IP header
  152. :param ip_dst the destination IP address of the IP header
  153. :param mac_src: the source MAC address of the MAC header
  154. :param mac_dst: the destination MAC address of the MAC header
  155. :param port_src: the source port of the header
  156. :param port_dst: the destination port of the header
  157. :param tcpflags: the TCP flags of the TCP header, if tcp is selected as protocol
  158. :param ttl: the ttl Value of the packet
  159. :param message_type: affects the size of the payload
  160. :param neighborlist_entries: number of entries of a Neighbourlist-reply, affects the size of the payload
  161. :return: the corresponding packet
  162. """
  163. # Determine length of the payload that has to be generated
  164. if (message_type == MessageType.SALITY_HELLO):
  165. payload_len = 0
  166. elif (message_type == MessageType.SALITY_HELLO_REPLY):
  167. payload_len = 22
  168. elif (message_type == MessageType.SALITY_NL_REQUEST):
  169. payload_len = 28
  170. elif (message_type == MessageType.SALITY_NL_REPLY):
  171. payload_len = 24 + 6 * neighborlist_entries
  172. else:
  173. payload_len = 0
  174. payload = generate_payload(payload_len)
  175. if (self.protocol == "udp"):
  176. packet = generate_udp_packet(ip_src=ip_src, ip_dst=ip_dst, mac_src=mac_src, mac_dst=mac_dst, ttl=ttl,
  177. port_src=port_src, port_dst=port_dst, payload=payload)
  178. elif (self.protocol == "tcp"):
  179. packet = generate_tcp_packet(ip_src=ip_src, ip_dst=ip_dst, mac_src=mac_src, mac_dst=mac_dst, ttl=ttl,
  180. port_src=port_src, port_dst=port_dst, tcpflags=tcpflags, payload=payload)
  181. else:
  182. print("Error: unsupported protocol for generating Packets")
  183. return packet
  184. def generate_tcp_packet(ip_src: str = "192.168.64.32", ip_dst: str = "192.168.64.48",
  185. mac_src: str = "56:6D:D9:BC:70:1C", ttl: int = 64,
  186. mac_dst: str = "F4:2B:95:B3:0E:1A", port_src: int = 1337, port_dst: int = 6442,
  187. tcpflags: str = "S", payload: str = ""):
  188. """
  189. Builds a TCP packet with the values specified by the caller.
  190. :param ip_src: the source IP address of the IP header
  191. :param ip_dst the destination IP address of the IP header
  192. :param mac_src: the source MAC address of the MAC header
  193. :param ttl: the ttl value of the packet
  194. :param mac_dst: the destination MAC address of the MAC header
  195. :param port_src: the source port of the TCP header
  196. :param port_dst: the destination port of the TCP header
  197. :param tcpflags: the TCP flags of the TCP header
  198. :param payload: the payload of the packet
  199. :return: the corresponding TCP packet
  200. """
  201. ether = Ether(src=mac_src, dst=mac_dst)
  202. ip = IP(src=ip_src, dst=ip_dst, ttl=ttl)
  203. tcp = TCP(sport=port_src, dport=port_dst, flags=tcpflags)
  204. packet = ether / ip / tcp / Raw(load=payload)
  205. return packet
  206. def generate_udp_packet(ip_src: str = "192.168.64.32", ip_dst: str = "192.168.64.48",
  207. mac_src: str = "56:6D:D9:BC:70:1C", ttl: int = 64,
  208. mac_dst: str = "F4:2B:95:B3:0E:1A", port_src: int = 1337, port_dst: int = 6442,
  209. payload: str = ""):
  210. """
  211. Builds an UDP packet with the values specified by the caller.
  212. :param ip_src: the source IP address of the IP header
  213. :param ip_dst the destination IP address of the IP header
  214. :param mac_src: the source MAC address of the MAC header
  215. :param ttl: the ttl value of the packet
  216. :param mac_dst: the destination MAC address of the MAC header
  217. :param port_src: the source port of the UDP header
  218. :param port_dst: the destination port of the UDP header
  219. :param payload: the payload of the packet
  220. :return: the corresponding UDP packet
  221. """
  222. ether = Ether(src=mac_src, dst=mac_dst)
  223. ip = IP(src=ip_src, dst=ip_dst, ttl=ttl)
  224. udp = UDP(sport=port_src, dport=port_dst)
  225. packet = ether / ip / udp / Raw(load=payload)
  226. return packet
  227. '''IPGenerator
  228. '''
  229. class IPChooser:
  230. def random_ip(self):
  231. return ip.IPAddress.from_int(random.randrange(0, 1 << 32))
  232. def size(self):
  233. return 1 << 32
  234. def __len__(self):
  235. return self.size()
  236. class IPChooserByRange(IPChooser):
  237. def __init__(self, ip_range):
  238. self.range = ip_range
  239. def random_ip(self):
  240. start = int(self.range.first_address())
  241. end = start + self.range.block_size()
  242. return ip.IPAddress.from_int(random.randrange(start, end))
  243. def size(self):
  244. return self.range.block_size()
  245. class IPChooserByList(IPChooser):
  246. def __init__(self, ips):
  247. self.ips = list(ips)
  248. if not self.ips:
  249. raise ValueError("list of ips must not be empty")
  250. def random_ip(self):
  251. return random.choice(self.ips)
  252. def size(self):
  253. return len(self.ips)
  254. class IPGenerator:
  255. def __init__(self, ip_chooser=IPChooser(), # include all ip-addresses by default (before the blacklist)
  256. include_private_ips=False, include_localhost=False,
  257. include_multicast=False, include_reserved=False,
  258. include_link_local=False, blacklist=None):
  259. self.blacklist = []
  260. self.generated_ips = set()
  261. if not include_private_ips:
  262. for segment in ip.ReservedIPBlocks.PRIVATE_IP_SEGMENTS:
  263. self.add_to_blacklist(segment)
  264. if not include_localhost:
  265. self.add_to_blacklist(ip.ReservedIPBlocks.LOCALHOST_SEGMENT)
  266. if not include_multicast:
  267. self.add_to_blacklist(ip.ReservedIPBlocks.MULTICAST_SEGMENT)
  268. if not include_reserved:
  269. self.add_to_blacklist(ip.ReservedIPBlocks.RESERVED_SEGMENT)
  270. if not include_link_local:
  271. self.add_to_blacklist(ip.ReservedIPBlocks.ZERO_CONF_SEGMENT)
  272. if blacklist:
  273. for segment in blacklist:
  274. self.add_to_blacklist(segment)
  275. self.chooser = ip_chooser
  276. @staticmethod
  277. def from_range(range, *args, **kwargs):
  278. return IPGenerator(IPChooserByRange(range), *args, **kwargs)
  279. def add_to_blacklist(self, ip_segment):
  280. if isinstance(ip_segment, ip.IPAddressBlock):
  281. self.blacklist.append(ip_segment)
  282. else:
  283. self.blacklist.append(ip.IPAddressBlock.parse(ip_segment))
  284. def random_ip(self):
  285. if len(self.generated_ips) == self.chooser.size():
  286. raise ValueError("Exhausted the space of possible ip-addresses, no new unique ip-address can be generated")
  287. while True:
  288. random_ip = self.chooser.random_ip()
  289. if not self._is_in_blacklist(random_ip) and random_ip not in self.generated_ips:
  290. self.generated_ips.add(random_ip)
  291. return str(random_ip)
  292. def clear(self, clear_blacklist=True, clear_generated_ips=True):
  293. if clear_blacklist: self.blacklist.clear()
  294. if clear_generated_ips: self.generated_ips.clear()
  295. def _is_in_blacklist(self, ip: ip.IPAddress):
  296. return any(ip in block for block in self.blacklist)
  297. class MappingIPGenerator(IPGenerator):
  298. def __init__(self, *args, **kwargs):
  299. super().__init__(self, *args, **kwargs)
  300. self.mapping = {}
  301. def clear(self, clear_generated_ips=True, *args, **kwargs):
  302. super().clear(self, clear_generated_ips=clear_generated_ips, *args, **kwargs)
  303. if clear_generated_ips:
  304. self.mapping = {}
  305. def get_mapped_ip(self, key):
  306. if key not in self.mapping:
  307. self.mapping[key] = self.random_ip()
  308. return self.mapping[key]
  309. def __getitem__(self, item):
  310. return self.get_mapped_ip(item)