def scan_network(self): if self.os == "linux" or self.os == "linux2": scanner = self.linux_networks() elif self.os == "darwin": scanner = self.osx_networks() #elif os == "win32": results = [] for wifi in scanner: if self.verbosity > 1: print(wifi) # match NET's default SSID if self.regex.search(wifi[0]) is not None: print("Found WIFI!") # the password consists of CM_MAC last 4 hexas of the router, # which are the third hexa of the BSSID # plus the last 3 hexas of the SSID chunks = [ ''.join(wifi[1].upper().split(":")[2:3]), wifi[0].split("_")[1][2:] ] password = ''.join(chunks) results.append([wifi[0], password, wifi[1]]) if self.os != 'darwin': Scheme.for_cell( self.iface, wifi[1], wifi[4], password ).save() return results
def connect(self): message = None error = False cell = None if self.ssid != "": for i, v in enumerate(self.cells): if v.ssid == self.ssid: cell = self.cells[i] break if cell: scheme = None if cell.encrypted: if self.password != "": scheme = Scheme.for_cell(self.interface, "home", cell, passkey=self.password) else: scheme = Scheme.for_cell(self.interface, "home", cell) if scheme: try: scheme.delete() scheme.save() try: scheme.activate() message = "OK" error = False except Exception, e: message = e error = True except Exception, e: message = e error = True
def connect(self): message = None error = False cell = None if self.ssid != "": for i, v in enumerate(self.cells): if v.ssid == self.ssid: cell = self.cells[i] break if cell: scheme = None if cell.encrypted: if self.password != "": scheme = Scheme.for_cell(self.interface, "home", cell, passkey=self.password) else: scheme = Scheme.for_cell(self.interface, "home", cell) if scheme: try: scheme.delete() scheme.save() try: scheme.activate() message = "OK" error = False except Exception, e: message = e error = True except Exception, e: message = e error = True
def wifi_scan(): global connected reconnected = 0 while 1: print "Reconnected %d" %reconnected #Connected, check if still in range if connected != "": aps = Cell.all(interface) inrange = 0 for ap in range(0, len(aps)): if aps[ap].ssid == connected and aps[ap].signal <= -50: inrange = 1 if inrange != 1: connected = "" else: time.sleep(20) #Not connected else: aps = Cell.all(interface) for ap in range(0, len(aps)): if aps[ap].ssid in known_ssids: passwd = known_ssids_pass[known_ssids.index(aps[ap].ssid)] scheme = Scheme.for_cell(interface, "target", aps[ap], passwd) scheme.delete() scheme.save() try: scheme.activate() connected = aps[ap].ssid reconnected += 1 break except: print "Could not connect" continue #connect to the AP and stop scanning (return connected = ssid?) else: for ap in range(0, len(aps)): if aps[ap].encrypted == False and connected == "": scheme = Scheme.for_cell(interface, "target", aps[ap]) scheme.delete() scheme.save() try: scheme.activate() connected = aps[ap].ssid reconnected += 1 break except: print "could not connect" continue else: time.sleep(10)
def connecct(ssid, passkey = None): for cell in Cell.all('wlan0'): if cell.ssid == ssid: print('found {}'.format(ssid)) connect_cell = cell if (passkey == None): s = Scheme.for_cell('wlan0', 'home', connect_cell) else: s = Scheme.for_cell('wlan0', 'home', connect_cell, passkey) s.save() s.activate() s.delete() return s
def run(self): while(self.__continue): strs = serial_read_line() print (strs) if(strs == "REQ?CON"): serial_send_line("RSP?CON") print("respond") elif(strs == "GET?SSIDLIST"): ssids = get_wifi_ssid(self.__cell) serial_send_line("RSP?SSID") serial_send_line(str(len(ssids))) for ssid in ssids: serial_send_line(ssid) elif(strs == "SET?SSID"): print("SET SSID") ssid = int(serial_read_line()) pswd = serial_read_line() print(ssid, self.__cell[ssid]) scheme = Scheme.for_cell('wlan0','home',self.__cell[ssid],pswd) try: scheme.delete() except: pass try: scheme.save() except: pass try: scheme.activate() serial_send_line("RSP?COMP") except: serial_send_line("RSP?SSID")
def scanWifi(): while 1: cellName =None cellList = Cell.all('wlan0') print "Scan Around Cell" for cell in cellList: if cell.ssid == 'carcar5': cellName =cell if cellName is None: print "Can not found <carcar5> try again" time.sleep(1) continue else : temp = Scheme.find('wlan0','home') if temp is not None: temp.delete() scheme = Scheme.for_cell('wlan0', 'home',cellName, passKey) scheme.save() scheme.activate() print "Try connect to <carcar5>" myIp = commands.getoutput("hostname -I") print "Connection Success my Ip is : " + myIp return True
def run(self): while (self.__continue): strs = serial_read_line() print(strs) if (strs == "REQ?CON"): serial_send_line("RSP?CON") print("respond") elif (strs == "GET?SSIDLIST"): ssids = get_wifi_ssid(self.__cell) serial_send_line("RSP?SSID") serial_send_line(str(len(ssids))) for ssid in ssids: serial_send_line(ssid) elif (strs == "SET?SSID"): print("SET SSID") ssid = int(serial_read_line()) pswd = serial_read_line() print(ssid, self.__cell[ssid]) scheme = Scheme.for_cell('wlan0', 'home', self.__cell[ssid], pswd) try: scheme.delete() except: pass try: scheme.save() except: pass try: scheme.activate() serial_send_line("RSP?COMP") except: serial_send_line("RSP?SSID")
def run(self): #try: #print Cell.all(self.interface)[0] cell = Cell.all(self.interface)[0] scheme = Scheme.for_cell(self.interface, self.ssid, cell, self.passphrase) #scheme.save() self._return = scheme.activate()
def wifi(): error = None if request.method == 'GET': return render_template('wifi.html', error=error) if request.method == 'POST': if request.form['wifi-name'] and request.form['wifi-key']: try: cell = searchCell(request.form['wifi-name']) if cell: scheme = Scheme.for_cell(wifiInterface, request.form['wifi-name'], cell, request.form['wifi-key']) scheme.save() scheme.activate() else: error = 'Le wifi n\'a pas été trouvé veuillez en renseigner un autre' return render_template('wifi.html', error=error) except ConnectionError: error = 'Impossible de se connecter au réseau veuillez renseigner des informations valides' return render_template('wifi.html', error=error) file = open('.known_wifi', 'a') file.write(request.form['wifi-name'] + '\n') file.close() return redirect(url_for('ip')) else: error = 'Vous devez remplir les deux champs du formulaire' return render_template('wifi.html', error=error)
def save_network(self, network_ssid, password): network = self.get_network(network_ssid) saved_networks = self.get_saved_networks() saved_networks_count = len(saved_networks) new_network = Scheme.for_cell(self.interface, 'network_' + str(saved_networks_count), network, password) new_network.save()
def wifiscan(): Cell.all('wlan0') allSSID = list(Cell.all("wlan0"))[0] myssid = Scheme.for_cell('wlan0','home',allSSID,target_pwd) myssid.activate() myssid = Scheme.find('wlan0','home') myssid.activate()
def join_network(self, data): cell = [x for x in self.networks if x.ssid == data['name']][0] conn = Scheme.for_cell(self.interface, data['name'], cell, data['passkey']) self.wifiserver.svc.apmode = False while self.wifiserver.svc.ap_active: logging.debug("Waiting for AP to shut down") sleep(1) logging.debug("Activating Wireless connection") conn.activate() return {'join': 'successful'} # FIXME: return something more meaningful
def connect(interface, password, ssid): if Utils.is_saved(interface, ssid): Scheme.find(interface, ssid).activate() return True c = Utils.get_cell(ssid, interface) if c is None: return False s = Scheme.for_cell(interface, ssid, c, password) s.save() s.activate() return True
def connect_to_network(ssid, passkey=""): """ Try to connect to the given wifi network """ if ARGS.verbose >= 1: print "Connect to %s with passKey '%s'" % (ssid, passkey) try: cells = Cell.all('wlan1') except: print "Error connecting to wifi; is iwlist available on your machine?" for cell in cells: print "CHECK %s with %s" % (cell.ssid, ssid) if cell.ssid == ssid: print "Selected nework found, connecting." if passkey != "": scheme = Scheme.for_cell('wlan1', ssid, cell, passkey) else: scheme = Scheme.for_cell('wlan1', ssid, cell) scheme.save() scheme.activate() return if ARGS.verbose >= 1: print "Not able to find the selected network."
def connectToNetwork(device: Device, val, args): cell = args[0] if cell.encrypted: device.dispError(["Enter Password"]) password = device.dispKeyboard() else: password = None scheme = Scheme.for_cell("wlan0", cell.ssid, cell, password) with open("/home/pi/opc/network.pkl", "wb") as f: pickle.dump(scheme, f) p = call(["sudo", "/home/pi/opc/connectToNetwork.sh"])
def connect_wifi(self, wifi_id, passkey): print "Adding new Wifi" current_cell = self.cell[wifi_id] current_ssid = self.cell[wifi_id].ssid print "Cell info: " print current_cell scheme = Scheme.for_cell('wlan0', self.current_ssid, self.cell, passkey) scheme.save() print "Scheme info" print scheme return scheme.activate()
def put(self, name): parser = reqparse.RequestParser() parser.add_argument('action') parser.add_argument('ssid') parser.add_argument('password') args = parser.parse_args() s = [s for s in Scheme.all() if s.name == name] if len(s) == 0: return jsonify({'response': "non found"}) scheme = s[0] if args["action"] == 'connect': try: scheme.activate() except ConnectionError: return jsonify({"error": "Failed to connect to %s." % scheme.name}) return jsonify({'scheme': scheme.__dict__, "connected": True}) elif args["action"] == "configure": cells = [cell for cell in Cell.all("wlan0") if cell.ssid == args['ssid']] if len(cells) == 0: return jsonify({'error': 'wifi not found'}) sname = scheme.name scheme.delete() if cell.encrypted is True: scheme = Scheme.for_cell('wlan0', sname, cells[0], args['password']) else: scheme = Scheme.for_cell('wlan0', sname, cells[0]) scheme.save() return jsonify({'scheme': scheme.__dict__}) elif args["action"] == "clean": sname = scheme.name for s in Scheme.all(): if s.name == sname: s = Scheme('wlan0', sname) scheme.delete() s.save() else: return jsonify({'scheme': scheme.__dict__})
def connect(ssid, passkey): wifi_list = Cell.all('wlan0') wifi_to_connect = None for cell in wifi_list: if (cell.ssid == ssid): wifi_to_connect = cell if (wifi_to_connect == None): return False scheme = Scheme.for_cell('wlan', 'home', wifi_to_connect, passkey) scheme.save() scheme.activate() return True
def post(self): parser = reqparse.RequestParser() parser.add_argument('name') parser.add_argument('password') args = parser.parse_args() schemes = [s for s in Scheme.all()] cells = Cell.all('wlan0') newscheme = None for cell in cells: if cell.ssid == args['name']: if cell.encrypted is True: newscheme = Scheme.for_cell('wlan0', 'scheme-'+str(len(schemes)), cell, args['password']) else: newscheme = Scheme.for_cell('wlan0', 'scheme-'+str(len(schemes)), cell) break if newscheme is None: return jsonify({'response': "network non found"}) else: newscheme.save() newscheme.activate() return jsonify({'response': "ok"})
def connect_to_ap(log): """Function that will connect to wifi with the given parameters""" log.log("Connecting to " + WIFI_SSID + " using " + WIFI_INTERFACE) # Complicated way to account for the file not existing # Just tries to find if a scheme exists in interfaces try: scheme = Scheme.find(WIFI_INTERFACE, WIFI_PROFILE) except(IOError,err): log.log(err) log.log("WARNING: Most likely file was not found. Making one.") scheme = None if not os.path.isdir(INTERFACE_DIR): os.mkdir(INTERFACE_DIR, 0755) os.open(INTERFACE_FILE, 0644).close() elif not os.path.isfile(INTERFACE_FILE): os.open(INTERFACE_FILE, 0644).close() # If the scheme was not found or if it was found and didn't activate, # look for the ssid, save it, and connect to it. if scheme == None: cells = Cell.all(WIFI_INTERFACE) for cell in cells: if cell.ssid == WIFI_SSID: scheme = Scheme.for_cell(WIFI_INTERFACE, WIFI_PROFILE, cell, passkey=WIFI_PASS) scheme.save() break if scheme == None: log.log("ERROR: SSID " + WIFI_SSID + " was not found.") return False if scheme.activate() == False: log.log("ERROR: Could not connect to " + WIFI_SSID + ".") return False else: try: res = scheme.activate() # This can throw a lot of errors, let's just catch them all for now except: scheme.delete() #TODO delete the old scheme and add a new one. Possibly for password change log.log("ERROR: Could connect to " + WIFI_SSID) return False log.log("Successfully connected to " + WIFI_SSID + ".") return True
def connect_to_wifi(interface, name, cell, password): scheme = Scheme.for_cell(interface, name, cell, password) previous_scheme = Scheme.find(interface, name) if previous_scheme is not None: previous_scheme.delete() print scheme if scheme.find(interface, cell) is None: scheme.save() try: scheme.activate() except subprocess.CalledProcessError, e: print "Error: ", e.output return False
def scanWifi(): while 1: cellName=None #Wifi scannig use interface 'wlan0' cellList = Cell.all(iface) print "Network::scanWifi: Scan Around Cell" #find in cellList for cell in cellList: if cell.ssid == ssid: cellName =cell if cellName is None: print "Network::scanWifi: Can not found <carcar5> try again" time.sleep(1) continue # if there is 'carcar5' ap # Make connection else : temp = Scheme.find(iface,nickname) if temp is not None: temp.delete() scheme = Scheme.for_cell(iface,nickname,cellName, passKey) scheme.save() scheme.activate() print "Network::scanWifi: Try connect to <carcar5>" myIp = commands.getoutput("hostname -I") print "Network::scanWifi: Connection Success my Ip(" + myIp + ")" childPid = os.fork() #print "after os.fork() " + str(pid) #print str(os.getpid()) + "--> child Pid : " + str(childPid) # Parent process : Send Data if childPid: #print "Parent PID : " + str(os.getpid()) + " , Child PID : "+ str(childPid) sendData(childPid) # Child process : Receive Data else : #print "Child PID : " + str(os.getpid()) + " Parent PID : " + str(os.getppid()) receiveData()
def connectToWifi(ssid, passd): try: for elm in WlanCell: if elm.ssid == ssid: tmp = Scheme.find('wlan0', ssid) if tmp is not None: tmp.delete() scheme = Scheme.for_cell('wlan0', ssid, elm, passd) scheme.save() scheme.activate() print("Connected To Wifi " + ssid) return True return False except Exception: print("Error by Connecting with " + ssid) return False
def hubconnection4(request): try: curPassword = request.GET['password'] curCell = [] for cell in Cell.all('wlan1'): if cell.ssid == curSSID: curCell = cell scheme = Scheme.for_cell('wlan1', curSSID, curCell, curPassword) scheme.activate() except: curPassword = [] context = { 'curSSID' : curSSID, 'curPassword' : curPassword, } return render(request, 'she/hubconnection4.html', context)
def Setup(self, ssid, password): cell = None for i in self.endpoints: if i.ssid == ssid: cell = i break if cell is None: cell = Cell.from_string(ssid) if cell is None: #print('failure') return False scheme = Scheme.for_cell(self.interface, ssid, cell, password) scheme.save() scheme.activate() scheme.autoreconnect() #print('success') return True
def connect(interface, found_aps, selected_ap): #access_points = Cell.all(interface) found_aps = Cell.all(interface) print("In connect_linux.connect\n") #print(list(found_aps)) for ap in found_aps: print("Checking " + ap.ssid) if ap.ssid == selected_ap: print("MATCH") print("Trying to connect to " + ap.ssid) scheme = Scheme.for_cell(interface, 'net', ap) results = scheme.activate() print(results) print("Check done.\n") print("For-loop ended.\n")
def connectTo(ap, interface): try: scheme = Scheme.for_cell(interface, ap.ssid, ap) scheme.delete() #otherwise "This scheme already exists" error scheme.save() scheme.activate() #connect to the Parrot's wifi except Exception as detail: logging.error("Error while trying to connect to wifi in function connectTo - %s", detail) return False #reset global variables for sniffing global srcMAC, dstMAC, srcIP, dstIP, seqNr srcMAC = "" dstMAC = "" srcIP = "" dstIP = "" seqNr = "" return True
def wifi(display, conf): if conf.get("wifi") and not get_current_wifi(): cells = Cell.all(conf["wifi"]["interface"]) for i in cells: scheme = Scheme.find(conf["wifi"]["interface"],_name(i)) if not scheme: if i.ssid in conf["wifi"]["networks"]: display.animateRow(0,"Preparing " + i.ssid) scheme = Scheme.for_cell( conf["wifi"]["interface"], _name(i), i, conf["wifi"]["networks"][i.ssid]) scheme.save() if scheme: display.animateRow(0,"Trying " + scheme.options["wpa-ssid"]) scheme.activate() return True return False
def connect(esid, passkey=None, intf='wlan0'): cells = Cell.where(intf, lambda c: c.ssid == esid); if len(cells) == 0: raise LookupError('Network was not found'); if len(cells) > 1: raise LookupError('Sorry, network SSID is ambiguous'); scheme = Scheme.for_cell(intf, STORED_SCHEME_NAME, cells[0], passkey); old = Scheme.find(intf, STORED_SCHEME_NAME); if old is not None: old.delete(); scheme.save(); scheme.activate();
def scanAndConnectToParrot(interface, whitelist): #TODO implement whitelist, TODO change to separate scan & connect parrotNotFound = True while parrotNotFound: aps = Cell.all(interface) print aps for ap in aps: if ap.address.startswith('90:03:B7') or ap.address.startswith('58:44:98:13:80'): #if it is a parrot OR my phone (for testing) print "Parrot Wifi found" print ap parrotNotFound = False scheme = Scheme.for_cell(interface, 'abcde', ap) scheme.delete() #otherwise "This scheme already exists" error scheme.save() scheme.activate() #connect to the Parrot's wifi print "Connected to Parrot Wifi" break sleep(1)
def connect(interface, found_aps, selected_ap): #access_points = Cell.all(interface) found_aps = Cell.all(interface) print("In connect_linux.connect\n") #print(list(found_aps)) for ap in found_aps: print("Checking " + ap.ssid) if ap.ssid == selected_ap: print("MATCH") print("Trying to connect to "+ap.ssid) scheme = Scheme.for_cell(interface, 'net', ap) results = scheme.activate() print(results) print("Check done.\n") print("For-loop ended.\n")
def AttemptToConnectTo(self, targetName): targetCell = None # Find network cells in range cells = Cell.all(WIRELESS) # Find targetCell based on targetName for cell in cells: if (str(cell.ssid) == targetName): targetCell = cell # Check if cell retrieval failed if not targetCell: print("Failed to find chosen network") return False # Attempt Connection try: scheme = Scheme.for_cell(WIRELESS, targetName, targetCell) except TypeError: print("Failed to connect to scheme") return False try: scheme.save() except AssertionError: pass except IOError: print("Failed to save scheme") return False # Attempt to activate Scheme with timeout protection #signal.signal(signal.SIGALRM, TimeoutHandler) signal.alarm(CONNECTIONTIMEOUT) try: scheme.activate() except IOError: print("Activation of connection scheme timed out!") return False signal.alarm(0) # Successful connection return True
def _save_to_file(iface, ssid, cell, passkey): """ store new network scheme in /etc/network/interfaces :param iface: network interface :param ssid: network name :param cell: cell object matching the arguments :param passkey: authentication passphrase :return: """ # check if passkey is required if cell.encrypted and passkey is None: raise WifiException("ssid {}: passkey required".format(ssid), 400) scheme = Scheme.for_cell(iface, ssid, cell, passkey) scheme.save() return scheme
def connect(self, ssid, password): """The high-level method to try connect to one of available networks with using `wifi` library. Args: ssid (str): The name of the surrounding access point. password (str): The password of the surrounding access point. """ result = False for cell in self.current_cells: if cell.ssid == ssid: try: scheme = Scheme.for_cell(self.wlan, ssid, cell, password) scheme.activate() result = True except Exception as e: print(e) return result
def connectTo(ap, interface): try: scheme = Scheme.for_cell(interface, ap.ssid, ap) scheme.delete() #otherwise "This scheme already exists" error scheme.save() scheme.activate() #connect to the Parrot's wifi except Exception as detail: logging.error( "Error while trying to connect to wifi in function connectTo - %s", detail) return False #reset global variables for sniffing global srcMAC, dstMAC, srcIP, dstIP, seqNr srcMAC = "" dstMAC = "" srcIP = "" dstIP = "" seqNr = "" return True
def wifi_connect (self,eth_device, SSID, password): "This connects to a WiFi network with/without passkeys" from wifi import Cell, Scheme NotFound = True try: ap_list=Cell.all(eth_device) except: print "Conectado a la Wifi: " + SSID return while (NotFound): for item in ap_list: if(item.ssid.find(SSID) == 0): print item NotFound=False scheme.delete() scheme = Scheme.for_cell(eth_device,SSID,item,passkey=password) scheme.save() scheme.activate() return
def connect(adapter, ssid, psk=None, quiet=False): if not quiet: print "***setting up wireless adapter***" signal = [] # get a list of all the available SSIDs that match the arg ssid cells = Cell.where(adapter, lambda x: x.ssid == ssid) print cells if len(cells) == 0: if not quiet: print "Cannot find SSID:", ssid return False # find the SSID with the best signal strength and select it as the cell to connect to for c in cells: signal.append(c.signal) max_signal = max(signal) max_index = signal.index(max_signal) cell = cells[max_index] scheme = Scheme.for_cell(adapter, ssid, cell, passkey=psk) # overwrite the scheme if already in '/etc/network/interfaces' # save it to '/etc/network/interfaces' if not if Scheme.find(adapter, ssid): scheme.delete() scheme.save() else: scheme.save() # attempt to connect to ssid try: if not quiet: print 'connecting to SSID:', cell.ssid scheme.activate() if not quiet: print 'connection successful' return True except: if not quiet: print('connection failed') return False
def create_scheme(interface, ssid, passkey): # Save a couple SSID / passkey into Scheme object cell = Cell.where(interface, lambda c: c.ssid == ssid) # Get cell matching SSID if cell: # Delete previous duplicate previous = Scheme.find(interface, ssid) if previous: print "Deleting previous \"%s\" duplicate." % (ssid) previous.delete() # Instanciate Scheme for this Cell scheme = Scheme.for_cell(interface, ssid, cell[0], passkey) print "Saving WiFi scheme \"%s\"." % (ssid) try: scheme.save() return scheme except: print "Scheme could not be saved." pass return False
def wifiscan(): allSSID = Cell.all('wlan0') print allSSID myssid= 'Cell(ssid=vivekHome)' for i in range(len(allSSID )): if str(allSSID [i]) == myssid: a = i myssidA = allSSID [a] print b break else: print "getout" # Creating Scheme with my SSID. myssid= Scheme.for_cell('wlan0', 'home', myssidA, 'vivek1234') print myssid myssid.save() myssid.activate()
def start(): # download most used passwords on github.com and build a dict print("Fetch top 100K most used passwords on Github...") url = "https://raw.githubusercontent.com/danielmiessler/SecLists/master/Passwords/10_million_password_list_top_100000.txt" response = urllib2.urlopen( url ) txt = response.read() passwords = txt.splitlines() # get networks and print stats networks = Cell.all('wlan0') nb_loops = len(passwords)*len(networks) print("{} networks founded. The programs will loop {} times!!".format( len(passwords) , nb_loops )) # begin to loop nb_test = 0 for password in passwords: for cell in networks: try: scheme = Scheme.for_cell('wlan0', 'home', cell, 'test') scheme.activate() print("Connect to {} with `{}` passkey works!!".format(cell, 'test')) sys.exit(0) except exceptions.ConnectionError as e: pass finally: nb_test += 1 sys.stdout.write('\r{} / {}'.format( nb_test, nb_loops )) sys.stdout.flush() print("you are not lucky :'(")
def click(self,btn): global niggers if btn != 'Enter': if btn == 'Backspace': niggers = niggers[:-1] print btn niggers += btn try: niggers = niggers.split("Backspace")[0] except: pass self.entryVariable.set(niggers) if btn == 'Enter': # #add pw to wifi cell scheme # self.scheme = Scheme.for_cell(str(args.interface), self.value, self.selected_cell, niggers) self.scheme.save() self.scheme.activate() print "Password entered: %s" % niggers niggers = ""
def validate_pw(self, obj): self.popup.dismiss() scheme = Scheme.find(self.wifi_iface, self.ap.ssid) if scheme != None: scheme.delete() print('scheme found, deleting') scheme = Scheme.for_cell(self.wifi_iface, self.ap.ssid, self.ap, obj.text) scheme.save() progressbar = ProgressBar(max=10) progress = Popup(title='Connecting...', size_hint=(None, None), size=(400, 100), content=progressbar) progress.open() activatethread = Thread(target=self.activate_thread, args=(scheme, )) activatethread.start() print('thread started') while self.activation_status is None: time.sleep(1) progressbar.value = (progressbar.value + 1) % 10 print('tick') progress.dismiss() if self.activation_status: self.save_ap() print('activated') else: scheme.delete() self.ask_pass() print('failed, asking again') pass
import subprocess from wifi import Cell, Scheme #from collections import defaultdict cell = Cell.all('wlan0')[0] scheme = Scheme.for_cell('wlan0', 'home', cell) #scheme.save() scheme.activate() #command=['iwlist', 'wlan0', 'scan'] #output=subprocess.Popen(command, stdout=subprocess.PIPE).stdout.readlines() #data=[] #wifiFile=open("wifiReport.txt", "w+") #keys=["Quality", "Encryption", "SSID"] #networks=defaultdict(list) #networkList=[] #for item in output: # print item.strip() # wifiFile.write(item.strip()) # if item.strip().startswith('ESSID:'): # data.append('SSID: '+item.lstrip(' ESSID:"').rstrip('"\n')) # if item.strip().startswith('Quality'): # data.append('Quality: '+item.split()[0].lstrip(' Quality=').rstrip('/70 ')) # if item.strip().startswith('Encryption key:off'): # data.append('Encryption: Open') # if item.strip().startswith('Encryption key:on'): # data.append('Encryption: Encrypted') #print data #print keys #for value in data: # for key in keys: # networks[key].append(value) #networkList.append(dict(zip(keys, data)))
from wifi import Cell, Scheme cell = Cell.all('wlan0')[2] scheme = Scheme.for_cell('wlan0', 'fiBonAcci', cell, b'silentscream') scheme.activate()
def save_network(self, data): """save network to config file""" cell = [x for x in self.networks if x.ssid == data['name']][0] conn = Scheme.for_cell(self.interface, data['name'], cell, data['passkey']) conn.save() logging.info('saved network {}'.format(data['name']))
WifiName='sanjurjo' WifiPassword='******' WirelessETH='wlan0' NotFound=True from wifi import Cell, Scheme import subprocess subprocess.call('ifconfig ' + WirelessETH + ' up'], shell=True) os.system(ifconfig ) while (NotFound): ap_list=Cell.all(WirelessETH) for item in ap_list: if(item.ssid.find(WifiName) == 0): print item NotFound=False scheme.delete() scheme = Scheme.for_cell(WirelessETH,WifiName,item,passkey=WifiPassword) scheme.save() scheme.activate() #We call the Upload service subprocess.call('ifconfig ' + WirelessETH + ' down', shell=True)
scheme = None #Same as "sudo iwlist wlan0 scan" cellName = None cellList = Cell.all('wlan0') #Find cell information which ssid is 'carcar5' for cell in cellList: if cell.ssid == 'carcar5': cellName = cell #Connect to wifi scheme = Scheme.find('wlan0','home') if scheme is None: scheme = Scheme.for_cell('wlan0', 'home', cellName, passKey) scheme.save() scheme.activate() else : scheme.delete() ###################################################################### """ ###################### Monitoring Connection ###################### class MonitoringConnection(threading.Thread): def __init__(self): threading.Thread.__init__(self)
wifi = 1 wait = 0.1 estado = 2 except: log(5, "Imposible leer redes wifi error de wlan0" ) wifi = 0 conectado=0 internet=0 estado = 0 wait= 10 elif estado ==2: if (Scheme.find("wlan0", wifissid) == None ): # se guarda: try: scheme = Scheme.for_cell("wlan0",wifissid, cell[0], wificode ) scheme.save() log(0, "red -%s- guardada."%wifissid) wifi = 1 estado = 3 wait= 0.1 errores = 0 except: try: scheme.delete() except: pass log(3, "Imposible guardar la wifissid %s " %wifissid ) wifi = 0 conectado=0 internet=0
def create_scheme(self, ssid, password): cell = Cell.all(self.iface) scheme = Scheme.for_cell(self.iface, ssid, cell, password) scheme.save() scheme.activate()
# connect to network from wifi import Cell, Scheme # wifi information wifi_ssid = "labpump123" wifi_password = "******" # machine information port = Cell.all('wlan0')[0] print "Connecting..." try: scheme = Scheme.for_cell('wlan0', wifi_ssid, port, wifi_password) scheme.save() except: scheme = Scheme.find('wlan0', wifi_ssid) finally: scheme.activate(); # check internet connection from pythonwifi.iwlibs import Wireless network = Wireless('wlan0') print "Connected with "+network.getEssid()+"." print ("" if network.getMode()=="Managed" else "Not ")+"Secured Connection."