def __init__(self, name):
"""
Setup the class with all the given arguments.
:param self: A NetworkAdapter object
:param name: Name of the interface
:type self: NetworkAdapter
:type name: str
:return: None
:rtype: None
.. note: the availability of monitor mode and AP mode is set to False
by default
"""
# Setup the fields
self._name = name
self._support_ap_mode = False
self._support_monitor_mode = False
self.being_used = False
# Set monitor and AP mode if card supports it
card = pyw.getcard(name)
modes = pyw.devmodes(card)
if "monitor" in modes:
self._support_monitor_mode = True
if "AP" in modes:
self._support_ap_mode = True
def listInterfaces(mode="managed", prefix_str="", postfix_str=""):
""" Returns the list of wireless interface.
Arguments :
mode -- list only those interfaces which have the given mode(default:manage)
prefix_str -- list only those interfaces which starts with the following prefix.
postfix_str -- list only those interfaces which ends with the following prefix.
"""
# check if its a wireless interface
wifaces = pyw.winterfaces()
# list to store the result
result = []
# iterate through all interfaces
for wi in wifaces:
# create there card object
w_card = pyw.getcard(wi)
# check modes and prefix if specifed
if (mode in pyw.devmodes(w_card)) and (w_card.dev.startswith(
prefix_str)) and w_card.dev.endswith(postfix_str):
result.append(wi)
# return a list of strings containing the names of the interfaces.
return result
def __init__(self, name):
"""
Setup the class with all the given arguments.
:param self: A NetworkAdapter object
:param name: Name of the interface
:type self: NetworkAdapter
:type name: str
:return: None
:rtype: None
.. note: the availability of monitor mode and AP mode is set to False
by default
"""
# Setup the fields
self._name = name
self._support_ap_mode = False
self._support_monitor_mode = False
self.being_used = False
# Set monitor and AP mode if card supports it
card = pyw.getcard(name)
modes = pyw.devmodes(card)
if "monitor" in modes:
self._support_monitor_mode = True
if "AP" in modes:
self._support_ap_mode = True
def __init__(self, interface):
self.interface = interface
self.card = pyw.getcard(interface)
self.modes = pyw.devmodes(self.card)
self.original_mac = pyw.macget(self.card)
# Important capabilities
self._ap_mode_support = "AP" in self.modes
self._monitor_mode_support = "monitor" in self.modes
def __init__(self, interface):
self.interface = interface
self.card = pyw.getcard(interface)
self.modes = pyw.devmodes(self.card)
self.original_mac = pyw.macget(self.card)
# Important capabilities
self._ap_mode_support = "AP" in self.modes
self._monitor_mode_support = "monitor" in self.modes
self._number_of_supported_aps = None
self._is_managed = False
def setup_ap(self):
if 'mon0' in pyw.winterfaces():
mon0 = pyw.getcard('mon0')
if pyw.modeget(mon0) == 'monitor':
try:
pyw.up(mon0)
pyw.chset(mon0, 1, None)
success = True
except Exception as e:
success = False
else:
try:
pyw.down(mon0)
pyw.modeset(mon0, 'monitor')
pyw.up(mon0)
pyw.chset(mon0, 1, None)
success = True
except Exception as e:
success = False
else:
card_name = ''
for interface in pyw.winterfaces():
if interface.startswith('wlx7'):
card_name = interface
break
c0 = pyw.getcard(card_name)
if 'monitor' in pyw.devmodes(c0):
try:
pyw.down(c0)
pyw.modeset(c0, 'monitor')
pyw.up(c0)
mon0 = pyw.devset(c0, 'mon0')
pyw.up(mon0)
pyw.chset(mon0, 1, None)
success = True
except Exception as e:
success = False
else:
success = False
if success:
print('Successfully Setup Monitoring Device')
self.request.sendall('0'.encode())
else:
print('Error Setting up Monitoring Device')
self.request.sendall('1'.encode())
def monitor_interfaces(self):
"""Get a list of interfaces that support monitor mode"""
# Get a list of all the interfaces.
ret = []
for iface in pyw.interfaces():
# Check if this card support monitor mode
try:
card = pyw.getcard(iface)
if 'monitor' in pyw.devmodes(card) and 'mon0' != card.dev:
# Add the card to the list
ret.append(iface)
except pyric.error as e:
pass
# Return the collected list
return ret
def set_scan_adapter(self, value):
""" wireless adapter being used to scan / inject """
if value:
value = value.encode('ascii')
else:
value = None
if value and pyw.isinterface(value):
card = pyw.getcard(value)
if 'monitor' not in pyw.devmodes(card):
raise Exception(
"Error, adapter: {} cannot perform monitor mode".format(
value))
elif value:
LOG.error("Invalid Card detected: {}, saving None to config")
value = None
config = cfg.get_config()
config[cfg.FIELD_ADAPTER_SCAN] = value
cfg.write_config(config)
def interface_property_detector(network_adapter):
"""
Add appropriate properties of the interface such as supported modes
and wireless type(wireless)
:param network_adapter: A NetworkAdapter object
:type interface_name: NetworkAdapter
:return: None
:rtype: None
"""
supported_modes = pyw.devmodes(network_adapter.card)
# check for monitor, AP and wireless mode support
if "monitor" in supported_modes:
network_adapter.has_monitor_mode = True
if "AP" in supported_modes:
network_adapter.has_ap_mode = True
if pyw.iswireless(network_adapter.name):
network_adapter.is_wireless = True
def interface_property_detector(network_adapter):
"""
Add appropriate properties of the interface such as supported modes
and wireless type(wireless)
:param network_adapter: A NetworkAdapter object
:type interface_name: NetworkAdapter
:return: None
:rtype: None
"""
supported_modes = pyw.devmodes(network_adapter.card)
# check for monitor, AP and wireless mode support
if "monitor" in supported_modes:
network_adapter.has_monitor_mode = True
if "AP" in supported_modes:
network_adapter.has_ap_mode = True
interface_name = network_adapter.name
network_adapter.is_managed_by_nm = is_managed_by_network_manager(interface_name)
def __init__(self, interface):
self.interface = interface
self.card = None
self.modes = None
self.original_mac = None
self._ap_mode_support = None
self._monitor_mode_support = None
try:
self.card = pyw.getcard(interface)
self.modes = pyw.devmodes(self.card)
self.original_mac = pyw.macget(self.card)
# Important capabilities
self._ap_mode_support = "AP" in self.modes
self._monitor_mode_support = "monitor" in self.modes
except: pass
self._number_of_supported_aps = None
self._is_managed = False
def createVirtualInterface(old_iface,
new_iface,
mode="monitor",
channel=1):
""" Creates a virtual interface with the specified options and returns its pywric.Card object.
(when creating new interface the old one is deleted.)
Arguments :
old_iface -- old interface name.
new_iface -- new interface name.
mode -- open the new interface in the given mode (default:monitor).
channel -- start the new interface on the given channel.
"""
# return None if invailed wireless interface
if pyw.iswireless(old_iface) == False:
return None
wi = pyw.getcard(old_iface)
# check if the specifed mode is supported by the card
if mode in pyw.devmodes(wi):
# create new interfaces with the specifed prefix-string default="mon"
viface = pyw.devadd(wi, new_iface, mode)
# delete all other interfaces with same phy id
for card, _ in pyw.ifaces(wi): # delete all interfaces
if not card.dev == viface.dev: # that are not our
pyw.devdel(card)
# set default channel
pyw.chset(viface, channel, None)
# up the vitual interface
pyw.up(viface)
# return the newly created interface as pyw.Card() onject
return viface
def show_networking():
# auto load mymons.
Global.monCtrl.autoLoadMymons()
kroute = Wired.getRoute()
wirelessInfo = []
for w in Wireless.listInterfaces():
info = Wireless.getInfo(w)
c = pyw.getcard(w)
if "monitor" in pyw.devmodes(c):
info["inUsed"] = Global.monCtrl.isMymon(c)
info["priority"] = Global.monCtrl.usedAs(c)
wirelessInfo.append(info)
wiredInfo = []
for w in Wired.listInterfaces():
wiredInfo.append(Wired.getInfo(w))
return render_template("networking.html", kroute=kroute, wiredInfo=wiredInfo, wirelessInfo=wirelessInfo)
def _check_compatibility(self, interface):
"""
Check and set the compatibility of the network adapter in regards to
monitor mode and AP mode.
:param self: A NetworkManager object
:param interface: A network adapter to be checked
:type self: NetworkManager
:type interface: NetworkAdapter
:return: None
:rtype: None
:raises IwCmdError: If an error is produced after executing iw command
.. seealso:: _iw_cmd, _word_in_sentence, NetworkAdapter
"""
# Set monitor and AP mode if card supports it
card = pyric.getcard(interface.get_name())
modes = pyric.devmodes(card)
if "monitor" in modes:
interface.set_monitor_support(True)
if "AP" in modes:
interface.set_ap_support(True)
def configure(win,conf):
"""
shows options to configure captiv8 for running
:param win: the main window
:param conf: current state of configuration dict
"""
# create our on/off for radio buttons
BON = curses.ACS_DIAMOND
BOFF = '_'
# create an inputs dict to hold the begin locations of inputs
ins = {} # input -> (start_y,start_x,endx)
# create a copy of conf to manipulate
newconf = {}
for c in conf: newconf[c] = conf[c]
# create new window (new window will cover the main window)
# get sizes for coord translation
nr,nc = win.getmaxyx() # size of the main window
ny,nx = 15,50 # size of new window
zy,zx = (nr-ny)/2,(nc-nx)/2 # 0,0 (top left corner) of new window
confwin = curses.newwin(ny,nx,zy,zx)
# draw a blue border and write title
confwin.attron(CPS[BLUE])
confwin.border(0)
confwin.attron(CPS[BLUE])
confwin.addstr(1,1,"Configure Options",CPS[BLUE])
# ssid option, add if present add a clear button to the right
confwin.addstr(2,1,"SSID: " + '_'*_SSIDLEN_,CPS[WHITE])
ins['SSID'] = (2+zy,len("SSID: ")+zx+1,len("SSID: ")+zx+_SSIDLEN_)
if newconf['SSID']:
for i,s in enumerate(newconf['SSID']):
confwin.addch(ins['SSID'][0]-zy,ins['SSID'][1]-zx+i,s,CPS[GREEN])
# allow for up to 6 devices to choose in rows of 2 x 3
confwin.addstr(3,1,"Select dev:",CPS[WHITE]) # the sub title
i = 4 # current row
j = 0 # current dev
devs = pyw.winterfaces()[:8]
if not newconf['dev'] in devs: newconf['dev'] = None
for dev in devs:
stds = ""
monitor = True
nl80211 = True
try:
card = pyw.getcard(dev)
stds = pyw.devstds(card)
monitor = 'monitor' in pyw.devmodes(card)
except pyric.error:
# assume just related to current dev
nl80211 = False
devopt = "{0}. (_) {1}".format(j+1,dev)
if stds: devopt += " IEEE 802.11{0}".format(''.join(stds))
if monitor and nl80211:
confwin.addstr(i,2,devopt,CPS[WHITE])
ins[j] = (i+zy,len("n. (")+zx+2,len("n. (")+zx+3)
if newconf['dev'] == dev:
confwin.addch(ins[j][0]-zy,ins[j][1]-zx,BON,CPS[GREEN])
else:
# make it gray
errmsg = ""
if not monitor: errmsg = "No monitor mode"
elif not nl80211: errmsg = "No nl80211"
confwin.addstr(i,2,devopt,CPS[GRAY])
confwin.addstr(i,3,'X',CPS[GRAY])
confwin.addstr(i,len(devopt)+3,errmsg,CPS[GRAY])
i += 1
j += 1
# connect option, select current if present
confwin.addstr(i,1,"Connect: (_) auto (_) manual",CPS[WHITE])
ins['auto'] = (i+zy,len("Connect: (")+zx+1,len("Connect: (")+zx+2)
ins['manual'] = (i+zy,
len("Connect: (_) auto (")+zx+1,
len("Connect: (_) auto (")+zx+2)
if newconf['connect']:
confwin.addch(ins[newconf['connect']][0]-zy,
ins[newconf['connect']][1]-zx,
BON,CPS[GREEN])
# we want two buttons Set and Cancel. Make these buttons centered. Underline
# the first character
btn1 = "Set"
btn2 = "Cancel"
btnlen = len(btn1) + len(btn2) + 1 # add a space
btncen = (nx-btnlen) / 2 # center point for both
# btn 1 -> underline first character
y,x = ny-2,btncen-(len(btn1)-1)
confwin.addstr(y,x,btn1[0],CPS[BUTTON]|curses.A_UNDERLINE)
confwin.addstr(y,x+1,btn1[1:],CPS[BUTTON])
ins['set'] = (y+zy,x+zx,x+zx+len(btn1)-1)
# btn 2 -> underline first character
y,x = ny-2,btncen+2
confwin.addstr(y,x,btn2[0],CPS[BUTTON]|curses.A_UNDERLINE)
confwin.addstr(y,x+1,btn2[1:],CPS[BUTTON])
ins['cancel'] = (y+zy,x+zx,x+zx+len(btn2)-1)
confwin.refresh()
# capture the focus and run our execution loop
confwin.keypad(1) # enable IOT read mouse events
store = False
while True:
_ev = confwin.getch()
if _ev == curses.KEY_MOUSE:
# handle mouse, determine if we should check/uncheck etc
try:
_,mx,my,_,b = curses.getmouse()
except curses.error:
continue
if b == curses.BUTTON1_CLICKED:
# determine if we're inside a option area
if my == ins['set'][0]:
if ins['set'][1] <= mx <= ins['set'][2]:
store = True
break
elif ins['cancel'][1] <= mx <= ins['cancel'][2]:
break
elif my == ins['SSID'][0]:
if ins['SSID'][1] <= mx <= ins['SSID'][2]:
# move the cursor to the first entry char & turn on
curs = ins['SSID'][0],ins['SSID'][1]
confwin.move(curs[0]-zy,curs[1]-zx)
curses.curs_set(1)
# loop until we get <ENTER>
while True:
# get the next char
_ev = confwin.getch()
if _ev == ascii.NL or _ev == curses.KEY_ENTER: break
elif _ev == ascii.BS or _ev == curses.KEY_BACKSPACE:
if curs[1] == ins['SSID'][1]: continue
# delete (write over with '-') prev char, then move back
curs = curs[0],curs[1]-1
confwin.addch(curs[0]-zy,
curs[1]-zx,
BOFF,
CPS[WHITE])
confwin.move(curs[0]-zy,curs[1]-zx)
else:
if curs[1] > ins['SSID'][2]:
curses.flash()
continue
# add the character, (cursor moves on its own)
# update our pointer for the next entry
try:
confwin.addstr(curs[0]-zy,
curs[1]-zx,
chr(_ev),
CPS[GREEN])
curs = curs[0],curs[1]+1
except ValueError:
# put this back on and see if the outer
# loop can do something with it
curses.ungetch(_ev)
break
curses.curs_set(0) # turn off the cursor
elif my == ins['auto'][0]:
if ins['auto'][1] <= mx <= ins['auto'][2]:
if newconf['connect'] == 'manual':
# turn off manual
confwin.addch(ins['manual'][0]-zy,
ins['manual'][1]-zx,
BOFF,CPS[WHITE])
newconf['connect'] = 'auto'
confwin.addch(my-zy,mx-zx,BON,CPS[GREEN])
confwin.refresh()
elif ins['manual'][1] <= mx <= ins['manual'][2]:
if newconf['connect'] == 'auto':
# turn off auto
confwin.addch(ins['auto'][0]-zy,
ins['auto'][1]-zx,
BOFF,CPS[WHITE])
newconf['connect'] = 'manual'
confwin.addch(my-zy,mx-zx,BON,CPS[GREEN])
confwin.refresh()
else:
# check for each listed device
for d in range(j):
if my == ins[d][0] and ins[d][1] <= mx <= ins[d][2]:
# check the selected dev
confwin.addch(my-zy,mx-zx,BON,CPS[GREEN])
# determine if a previously selected needs to be unchecked
if newconf['dev'] is None: pass
elif newconf['dev'] != devs[d]:
i = devs.index(newconf['dev'])
confwin.addch(ins[i][0]-zy,
ins[i][1]-zx,
BOFF,
CPS[WHITE])
newconf['dev'] = devs[d]
confwin.refresh()
break # exit the for loop
else:
try:
_ch = chr(_ev).upper()
except ValueError:
continue
if _ch == 'S':
store = True
break
elif _ch == 'C': break
elif _ch == 'L':
pass
# only 'radio buttons' are kept, check if a SSID was entered and add if so
if store:
ssid = confwin.instr(ins['SSID'][0]-zy,ins['SSID'][1]-zx,_SSIDLEN_)
ssid = ssid.strip('_').strip() # remove training lines, & spaces
if ssid: newconf['SSID'] = ssid
# delete this window and return
del confwin # remove the window
return newconf if store else None
def is_add_vif_required(args):
"""
Return the card if only that card support both monitor and ap
:param args: Arguemnt from pywifiphisher
:type args: parse.args
:return: tuple of card and is_frequency_hop_allowed
:rtype: tuple
"""
def get_perfect_card(phy_map_vifs, vif_score_tups):
"""
Get the perfect card that both supports ap and monitor when we
have only one phy interface can do that
:param phy_map_vifs: phy number maps to the virtual interfaces
:param vif_score_tups: list of tuple containing card and score
:type phy_map_vifs: dict
:type vif_score_tups: list
:return tuple of card and single_perfect_phy_case
:rtype: tuple
"""
# case 1 : one phy maps to one virtual interface
if len(phy_map_vifs) == 1 and len(phy_map_vifs.values()[0]) == 1:
# only take the first tuple
vif_score_tuple = vif_score_tups[0]
card = vif_score_tuple[0]
score = vif_score_tuple[1]
# if this card support both monitor and AP mode
if score == 2:
return card, True
# case 2 : one phy maps to multiple virtual interfaces
# we don't need to create one more virtual interface in this case
elif len(phy_map_vifs) == 1 and len(phy_map_vifs.values()[0]) > 1:
return None, True
# case 3 : we have multiple phy interfaces but only
# one card support both monitor and AP and the other
# ones just support the managed mode only
elif len(phy_map_vifs) > 1:
if vif_score_tups[0][1] == 2 and vif_score_tups[1][1] == 0:
return vif_score_tups[0][0], True
return None, False
# map the phy interface to virtual interfaces
# i.e. phy0 to wlan0
phy_to_vifs = defaultdict(list)
# store the phy number for the internet access
invalid_phy_number = list()
# record the invalid_phy_number when it is wireless card
if args.internetinterface and pyw.iswireless(args.internetinterface):
card = pyw.getcard(args.internetinterface)
invalid_phy_number.append(card.phy)
if args.wpspbc_assoc_interface:
card = pyw.getcard(args.wpspbc_assoc_interface)
invalid_phy_number.append(card.phy)
# map the phy# to the virtual interface tuples
for vif in [vif for vif in pyw.interfaces() if pyw.iswireless(vif)]:
# excluding the card that used for internet accessing
# setup basic card information
score = 0
card = pyw.getcard(vif)
phy_number = card.phy
if phy_number in invalid_phy_number:
continue
supported_modes = pyw.devmodes(card)
if "monitor" in supported_modes:
score += 1
if "AP" in supported_modes:
score += 1
phy_to_vifs[phy_number].append((card, score))
# each phy number map to a sublist containing (card, score)
vif_score_tuples = [sublist[0] for sublist in phy_to_vifs.values()]
# sort with score
vif_score_tuples = sorted(vif_score_tuples, key=lambda tup: -tup[1])
use_one_phy = False
if args.interface:
card = pyw.getcard(args.interface)
phy_number = card.phy
if phy_to_vifs[card.phy][0][1] == 2:
perfect_card = card
use_one_phy = True
else:
perfect_card, use_one_phy = get_perfect_card(
phy_to_vifs, vif_score_tuples)
return perfect_card, use_one_phy
def test_devcmds(self):
self.assertIsInstance(pyw.devmodes(self.card), list)
def test_devmodes(self):
self.assertListEqual(pri["modes"], pyw.devmodes(self.card))
def test_devmodes(self):
self.assertListEqual(pri['modes'],pyw.devmodes(self.card))
def test_devcmds(self):
self.assertIsInstance(pyw.devmodes(self.card),list)
def is_add_vif_required(args):
"""
Return the card if only that card support both monitor and ap
:param args: Arguemnt from pywifiphisher
:type args: parse.args
:return: tuple of card and is_frequency_hop_allowed
:rtype: tuple
"""
def get_perfect_card(phy_map_vifs, vif_score_tups):
"""
Get the perfect card that both supports ap and monitor when we
have only one phy interface can do that
:param phy_map_vifs: phy number maps to the virtual interfaces
:param vif_score_tups: list of tuple containing card and score
:type phy_map_vifs: dict
:type vif_score_tups: list
:return tuple of card and single_perfect_phy_case
:rtype: tuple
"""
# case 1 : one phy maps to one virtual interface
if len(phy_map_vifs) == 1 and len(phy_map_vifs.values()[0]) == 1:
# only take the first tuple
vif_score_tuple = vif_score_tups[0]
card = vif_score_tuple[0]
score = vif_score_tuple[1]
# if this card support both monitor and AP mode
if score == 2:
return card, True
# case 2 : one phy maps to multiple virtual interfaces
# we don't need to create one more virtual interface in this case
elif len(phy_map_vifs) == 1 and len(phy_map_vifs.values()[0]) > 1:
return None, True
# case 3 : we have multiple phy interfaces but only
# one card support both monitor and AP and the other
# ones just support the managed mode only
elif len(phy_map_vifs) > 1:
if vif_score_tups[0][1] == 2 and vif_score_tups[1][1] == 0:
return vif_score_tups[0][0], True
return None, False
# map the phy interface to virtual interfaces
# i.e. phy0 to wlan0
phy_to_vifs = defaultdict(list)
# store the phy number for the internet access
invalid_phy_number = None
# record the invalid_phy_number when it is wireless card
if args.internetinterface and pyw.iswireless(args.internetinterface):
card = pyw.getcard(args.internetinterface)
invalid_phy_number = card.phy
# map the phy# to the virtual interface tuples
for vif in [vif for vif in pyw.interfaces() if pyw.iswireless(vif)]:
# excluding the card that used for internet accessing
# setup basic card information
score = 0
card = pyw.getcard(vif)
phy_number = card.phy
if phy_number == invalid_phy_number:
continue
supported_modes = pyw.devmodes(card)
if "monitor" in supported_modes:
score += 1
if "AP" in supported_modes:
score += 1
phy_to_vifs[phy_number].append((card, score))
# each phy number map to a sublist containing (card, score)
vif_score_tuples = [sublist[0] for sublist in phy_to_vifs.values()]
# sort with score
vif_score_tuples = sorted(vif_score_tuples, key=lambda tup: -tup[1])
perfect_card, is_single_perfect_phy = get_perfect_card(phy_to_vifs,
vif_score_tuples)
return perfect_card, is_single_perfect_phy
def test_devmodes(self):
self.assertIn('managed',pyw.devmodes(self.card))
def configure_interface(self,
interface,
name='mon0',
channel=1,
txpower=60,
bitrate=11):
"""Configure the given card in monitor mode"""
# Determine the type of card for this interface
try:
driver = pywhw.ifcard(interface)[0]
print(driver)
if driver == 'rtl88xxau':
type = Card.rtl88xx
else:
type = Card.ath9k
except Exception as e:
print(e)
return None
# Get the card for this interface
try:
card = pyw.getcard(interface)
except pyric.error as e:
logging.error("Error connecting to the interface: " + interface)
return None
# Ensure this card supports monitor mode
if 'monitor' not in pyw.devmodes(card):
logging.error(interface + " does not support monitor mode")
return None
# Configure the bitrate for this card
# This is not supported by pyric, so we have to do it manually.
if bitrate != 0 and type == Card.ath9k:
try:
pyw.down(card)
pyw.modeset(card, 'managed')
pyw.up(card)
logging.debug("Setting the bitrate on interface " + interface +
" to " + str(bitrate))
if os.system("iw dev " + card.dev +
" set bitrates legacy-2.4 " + str(bitrate)) != 0:
#if os.system("iwconfig " + card.dev + " rate 54M fixed") != 0:
logging.error("Error setting the bitrate for: " +
interface)
return None
pyw.down(card)
except pyric.error as e:
logging.error("Error setting the bitrate for: " + interface)
logging.error(e)
return None
# Try to configure the transmit power level (some cards don't support this)
try:
pyw.txset(card, txpower, 'fixed')
except pyric.error as e:
pass
# Bring the interface up
try:
pyw.up(card)
except pyric.error as e:
logging.error("Error bringing up the interface: " + card.dev)
logging.error(e)
return False
# Configure the channel
try:
logging.debug("Changing to channel: " + str(channel))
pyw.chset(card, channel, None)
except pyric.error as e:
logging.error("Error setting the wifi channel on: " + card.dev)
logging.error(e)
return False
return card
