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 ssi... | 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_addre... |
'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._cre... |
'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_... |
'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... |
'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._obser... |
'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.tar... |
'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
:t... | @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_pac... |
'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 = Destinatio... | 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):
... |
'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 inde... | 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]
... |
'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 == a... |
'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 se... | 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 sel... |
'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 Captur... |
'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:
(b... |
'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_m... |
'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
e... |
'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.devi... |
'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
... |
'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 ... |
'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.I... |
'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)... |
'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(interfac... |
'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(int... |
'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.InvalidInterfaceE... |
'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.InterfaceManagedByNetworkMana... |
'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_nam... |
'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, ... |
'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, 'A... |
'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_v... |
'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)
p... |
'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.I... |
'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.assertRai... |
'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._... |
'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._... |
'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_... |
'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]... |
'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._... |
'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._... |
'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_... |
'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 ... |
'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_... |
'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 ... |
'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_... |
'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... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.