def __do_js(self, event): self.__vertexes.clear() self.__canvas.delete("all") self.__draw_points() if len(self.__points) < 3: return js = Jarvis(self.__points, self.__canvas.winfo_height()) self.__vertexes = js.solver() self.__draw_lines()
def __init__(self): self.arpmode = "rep" self.Jarvis = Jarvis() self.targets = None self.file = None self.interface = None self.gateway = None self.status = 0
def start_server(self): print("Starting a thread for home server!") from main import build_plugin_manager plugin_manager = build_plugin_manager() language_parser = snips.LanguageParser() jarvis_server = JarvisServer() self.io = ServerIO() self.jarvis = Jarvis(language_parser, plugin_manager, jarvis_server) self.jarvis.register_io(self.io) self.server_app.run(host=self.host_name, port=self.port, threaded=True, debug=True, use_reloader=False)
def __init__(self): super(UI, self).__init__() self.pepper = None self.stop_words = [] self.top_k = 5 # Initialize Jarvis self.jarvis = Jarvis(stop_words = self.stop_words)
def run_loop(): #function looped that recognizes speech r = sr.Recognizer() # r is the recognizer object with sr.Microphone() as source: # while there is a microphone source listen for input while True: logger.debug("Waiting for user input.") audio = r.listen(source) #gets speech and stores it in audio object logger.debug("Performing Speach to text.") try: result = r.recognize_google(audio,key=None) # speech recognition result Jarvis.handle(result) #sends result to Jarvis.py for handling except sr.UnknownValueError: # Error handling logger.debug("Could not understand audio") except sr.RequestError as e: # Error with api logger.warn("Could not fetch results from speech to text: " + str(e)) except Exception as e: # Error Handling logger.error("Error processing: " + str(e))
class Main(object): def __init__(self, gid=TEST_GROUP_ID): data = json.load(open("creds.json", 'r')) self.jarvis = Jarvis(data['id'], data['password'], gid) def get_movers(self): url = "https://apidojo-yahoo-finance-v1.p.rapidapi.com/market/v2/get-movers" resp = requests.request("GET", url, headers=HEADERS, params=QUERRY_STRING).json() gainers = resp["finance"]["result"][0]["quotes"] string = "TOP Gainers: \n" for item in gainers: string += "%s\n" % item["symbol"] losers = resp["finance"]["result"][1]["quotes"] string += "-------------------\n" string += "TOP Losers: \n" for item in losers: string += "%s\n" % item["symbol"] print("Sending notification about top movers") self.jarvis.send_message(string)
def main_cli(): from ui.cmd_interpreter import CmdInterpreter from language import snips language_parser = snips.LanguageParser() plugin_manager = build_plugin_manager() jarvis_server = server.JarvisServer() jarvis = Jarvis(language_parser, plugin_manager, jarvis_server) cmd_interpreter = CmdInterpreter(jarvis) command = " ".join(sys.argv[1:]).strip() cmd_interpreter.executor(command)
def run_transcription_loop(): # Most of this code taken from https://github.com/Uberi/speech_recognition/blob/master/examples/microphone_recognition.py. r = sr.Recognizer() with sr.Microphone() as source: while True: logger.debug("Awaiting user input.") audio = r.listen(source) logger.debug("Attempting to transcribe user input.") try: result = r.recognize_google(audio, key=GOOGLE_SPEECH_RECOGNITION_API_KEY) Jarvis.handle_action(result) except sr.UnknownValueError: logger.debug("Google Speech Recognition could not understand audio") except sr.RequestError as e: logger.warn("Could not request results from Google Speech Recognition service: %s", e) except Exception as e: logger.error("Could not process text: %s", e)
def __init__(self): #Jarvis self.Jarvis = Jarvis() #Variables self.targets = None self.file = None self.interface = None self.gateway = None self.port = 80 self.domain = None self.redirect = None self.script = None self.filter = None self.arpmode = "rep" #Status manager self.jarvis_status = 0 self.arpspoof_status = False self.inject_status = False self.dnsspoof_status = False self.mitmdrop_status = 0
def main(): """ Basic loop, listen and execute. """ bot = Jarvis() bot.say(f"Hello, {parameters.NAME}.") is_running = True while is_running: phrase = bot.listen() bot.process(phrase.lower())
def __init__(self): self.arpmode = "rep" self.Jarvis = Jarvis() self.targets = None self.file = None self.interface = None self.gateway = None self.status = 0 self.dnsstat = 0 #will need to add a set and print, utils and wiki commands reference too self.port = 80 self.domain = None self.redirect = None self.script = None
def run_transcription_loop(): # Most of this code taken from https://github.com/Uberi/speech_recognition/blob/master/examples/microphone_recognition.py. r = sr.Recognizer() with sr.Microphone() as source: while True: logger.debug("Awaiting user input.") r.adjust_for_ambient_noise(source) audio = r.listen(source) logger.debug("Attempting to transcribe user input.") try: """result = r.recognize_sphinx(audio)""" result = r.recognize_google(audio, key=GOOGLE_SPEECH_RECOGNITION_API_KEY) Jarvis.handle_action(result) except sr.UnknownValueError: logger.debug("Google Speech Recognition could not understand audio") except sr.RequestError as e: logger.warn("Could not request results from Google Speech Recognition service: %s", e) except Exception as e: logger.error("Could not process text: %s", e)
def main_gui(): from ui.gui.application import JarvisApp from kivy.utils import platform if platform == 'android': import ui.gui.android_plugins plugin_manager = ui.gui.android_plugins.build_plugin_manager() else: plugin_manager = build_plugin_manager() language_parser = default.DefaultLanguageParser() jarvis_server = server.JarvisServer() jarvis = Jarvis(language_parser, plugin_manager, jarvis_server) jarvis_gui = JarvisApp(jarvis) jarvis_gui.run()
def __init__(self): #Jarvis self.Jarvis = Jarvis() #Variables self.targets = None self.file = None self.interface = None self.gateway = None self.port = 80 self.domain = None self.redirect = None self.script = None self.arpmode = "rep" #Status manager self.jarvis_status = 0 self.arpspoof_status = False self.inject_status = False self.dnsspoof_status = False self.mitmdrop_status = 0
class Processor(object): def __init__(self): self.Jarvis = Jarvis() def start(self): try: self.Jarvis.ser.open() except Exception as e: print "[!] Arduino Leonardo not found, features that use keyboard will not work." try: self.Jarvis.Say(self.Jarvis.random('greetings')) while 1: try: self.command = self.Jarvis.Listen() self.message = self.command.split() self.input_list = [str(a) for a in self.message] if self.input_list[0] == "exit" or self.input_list[0] == "quit": self.Jarvis.Say(self.Jarvis.random('salutes')) exit() elif self.input_list[0] == "sleep" or self.input_list[0] == "stop" or self.input_list[0] == "wait": self.Jarvis.Say("Call me if you need me sir.") while 1: self.wait = self.Jarvis.Listen() if self.wait == "Jarvis": self.Jarvis.Say(self.Jarvis.random('affirmative')) break elif self.input_list[0] == "newspaper" or self.input_list[0] == "news": self.Jarvis.Say("Here are the news sir.") self.titles = self.Jarvis.GetNews() self.Jarvis.SpeakNews(self.titles) elif self.input_list[0] == "browser": try: webbrowser.open("https://www.google.com") self.Jarvis.Say(self.Jarvis.random('affirmative')) except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "terminal": try: os.system("gnome-terminal") self.Jarvis.Say(self.Jarvis.random('affirmative')) except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "search": try: search = self.input_list[1:] real = "".join(search) url = "https://www.google.com/search?q={}".format(real) webbrowser.open(url) self.Jarvis.Say(self.Jarvis.random('affirmative')) except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "say" or self.input_list[0] == "speak": self.Jarvis.Say(self.input_list[1:]) elif self.input_list[0] == "run": self.Jarvis.Say(self.Jarvis.random('affirmative')) os.system("./scripts/{}.sh".format(self.input_list[1])) elif self.input_list[0] == "input": try: self.Jarvis.SerialWrite(self.input_list[1]) self.Jarvis.Say(self.Jarvis.random('affirmative')) except: self.Jarvis.Say("Feature not working master, plug your Arduino Leonardo then restart the program.") pass elif self.input_list[0] == "editor": self.Jarvis.Say("Starting edition mode sir.") while 1: self.editmode = self.Jarvis.Listen() self.mesg = self.editmode #self.msg = "".join(self.mesg) if self.mesg is not None: try: self.Jarvis.SerialWrite(self.mesg) self.Jarvis.Say(self.Jarvis.random('affirmative')) except: self.Jarvis.Say("Feature not working, plug you Arduino Leonardo then restart the program.") break else: pass if self.editmode == "exit": self.Jarvis.Say("Stoping edition mode sir.") break else: print '[!] Input a valid option, enter "help" to see valid commands.' self.Jarvis.Say("i heard, {}".format(self.command)) self.Jarvis.Say(self.Jarvis.random('dntunderstand')) except IndexError: pass except AttributeError: pass except KeyboardInterrupt: print "\n[*] User requested shutdown" self.Jarvis.Say(self.Jarvis.random('salutes')) exit() except Exception as e: print "[!] Exception caught: {}".format(e)
def setUp(self): from jarvis import Jarvis self.he = Jarvis()
class Processor(object): def __init__(self, version): self.version = version self.arpmode = "rep" self.Jarvis = Jarvis() self.targets = None self.file = None self.interface = None self.gateway = None self.status = 0 def start(self): try: while 1: self.command = raw_input("pythem> ") self.argv = self.command.split() self.input_list = [str(a) for a in self.argv] try: if self.command == "help": print_help(self.version) elif self.command == "jarvis-help": jarvis_help(self.Jarvis.version) elif self.command == "jarvis": self.Jarvis.start('core/processor.py') self.status = 1 elif self.input_list[0] == "jarvis-log": try: jarvislog = self.input_list[1] try: os.system("tail -f log/jarvis{}.txt".format(jarvislog)) except Exception as e: print "[!] Exception caught: {}".format(e) pass except IndexError: print "[+] Jarvis log system." print "[.] Error log - type: err" print "[.] Output log - type: out" jarvislog = raw_input("[+] Select: ") try: os.system("tail -f log/jarvis{}.txt".format(jarvislog)) except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.command == "exit" or self.command == "quit": if self.status == 1: self.Jarvis.Say(self.Jarvis.random('salutes')) self.Jarvis.stop() exit() else: exit() elif self.input_list[0] == "jarvis-say": try: message = self.input_list[1] all_msg = " ".join(self.input_list[1:]) self.Jarvis.Say(all_msg) except IndexError: message = raw_input("[+] Jarvis speaker: ") self.Jarvis.Say(message) except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[0] == "jarvis-read": try: file = self.input_list[1] self.Jarvis.Read(file) except IndexError: if self.file is not None: self.Jarvis.Read(self.file) else: file = "[+] Set file path:" pass except TypeError: print "[!] You probably forgot to set a wordlist file path." pass except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[0] == "set" or self.input_list[0] == "SET": if self.input_list[1] == "interface": try: self.interface = self.input_list[2] except IndexError: try: self.interface = raw_input("[+] Enter the interface: ") except KeyboardInterrupt: pass elif self.input_list[1] == "gateway": try: self.gateway = self.input_list[2] except IndexError: try: self.gateway = raw_input("[+] Enter the gateway: ") except KeyboardInterrupt: pass elif self.input_list[1] == "target": try: self.targets = self.input_list[2] except IndexError: try: self.targets = raw_input("[+] Enter the target(s): ") except KeyboardInterrupt: pass elif self.input_list[1] == "file": try: self.file = self.input_list[2] except IndexError: try: self.file = raw_input("[+] Enter the path to the file: ") except KeyboardInterrupt: pass elif self.input_list[1] == "arpmode": try: self.arpmode = self.input_list[2] except IndexError: try: self.arpmode = raw_input("[+] Enter the arpmode:") except KeyboardInterrupt: pass elif self.input_list[0] == "print": if self.input_list[1] == "interface": print "[+] Network Interface: {}".format(self.interface) elif self.input_list[1] == "gateway": print "[+] Gateway IP Address: {}".format(self.gateway) elif self.input_list[1] == "target": print "[+] Target(s): {}".format(self.targets) elif self.input_list[1] == "file": print "[+] File path: {}".format(self.file) elif self.input_list[1] == "arpmode": print "[+] ARP spoofing mode: {}".format(self.arpmode) else: print "[-] Select a valid variable name." elif self.input_list[0] == "scan": try: mode = self.input_list[1] if self.targets is not None and self.interface is not None: from modules.scanner import Scanner self.scan = Scanner(self.targets, self.interface, mode) self.scan.start() else: print "[!] You probably forgot to set the interface or a valid IP address/range." except IndexError: print "[*] Select one scan mode, options = tcp/arp/manual" mode = raw_input("[+] Scan mode: ") if self.targets is not None and self.interface is not None: from modules.scanner import Scanner self.scan = Scanner(self.targets, self.interface, mode) self.scan.start() else: print "[!] You probably forgot to set the interface or a valid IP address/range." pass except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "arpspoof": try: myip = get_myip(self.interface) mymac = get_mymac(self.interface) from modules.arpoisoner import ARPspoof self.spoof = ARPspoof(self.gateway, self.targets, self.interface,self.arpmode ,myip, mymac) if self.input_list[1] == "start": self.spoof.start() print "[+] ARP spoofing initialized." elif self.input_list[1] == "stop": self.spoof.stop() print "[+] ARP spoofing finalized." else: print "[!] Select a valid option, call help to check syntax." except TypeError: print "[!] You probably forgot to set interface or gateway." except IndexError: print "[!] You probably forgot to type start or stop after arpspoof." except AttributeError: pass except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[0] == "dnsspoof": try: if self.input_list[1] == "start": domain = raw_input("[+] Domain to be spoofed: ") redirect = raw_input("[+] IP address to be redirected: ") from modules.dnspoisoner import DNSspoof self.dnsspoof = DNSspoof(domain, redirect) self.dnsspoof.start() print "[+] DNS spoofing initialized" elif self.input_list[1] == "stop": self.dnsspoof.stop() print "[+] DNS spoofing finalized" else: print "[!] Select a valid option, call help to check syntax." except IndexError: print "[!] You probably forgot to type start or stop after dnsspoof." except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[0] == "sniff": from modules.sniffer import Sniffer try: filter = self.input_list[1:] self.sniff = Sniffer(self.interface, filter) self.sniff.start() except IndexError: filter = raw_input("[+] Enter the filter: ") self.sniff = Sniffer(self.interface, filter) self.sniff.start() except KeyboardInterrupt: pass elif self.command == "pforensic": try: from modules.pforensic import PcapReader self.pcapread = PcapReader(self.file) self.pcapread.start() except KeyboardInterrupt: pass except TypeError: print "[!] You probably forgot to set the .pcap file" pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "fuzz": try: from modules.fuzzer import SimpleFuzz if self.targets is not None and self.file is None: self.fuzz = SimpleFuzz(self.targets,self.input_list[1]) elif self.file is not None and self.targets is None: self.fuzz = SimpleFuzz(self.file,self.input_list[1]) else: print "[!] You need to specify after fuzz with a argument:" print "[.] tcp (remember to set target) or stdin (remember to set file path with ./)" except KeyboardInterrupt: pass elif self.command == "cookiedecode": try: cookiedecode() except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "decode": try: print decode(self.input_list[1]) except KeyboardInterrupt: pass elif self.input_list[0] == "encode": try: print encode(self.input_list[1]) except KeyboardInterrupt: pass elif self.input_list[0] == "geoip": try: self.targets = self.input_list[1] from modules.geoip import Geoip path = "config/GeoLiteCity.dat" iptracker = Geoip(self.targets,path) except IndexError: if self.targets is not None: from modules.geoip import Geoip path = "config/GeoLiteCity.dat" iptracker = Geoip(self.targets,path) else: print "[!] You probably forgot to set a target" except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "brute-force": if self.input_list[1] == "ssh": try: username = raw_input("[+] Enter the username to bruteforce: ") from modules.ssh_bruter import SSHbrutus brutus = SSHbrutus(self.targets, username, self.file) brutus.start() except KeyboardInterrupt: brutus.stop() pass except TypeError: print "[!] You probably forgot to set the wordlist file path." pass elif self.input_list[1] == "url": try: url = 'url' from modules.web_bruter import WEBbrutus brutus = WEBbrutus(self.targets, self.file) brutus.start(url) except KeyboardInterrupt: brutus.stop(url) pass except TypeError: print "[!] You probably forgot to set the wordlist file path." pass elif self.input_list[1] == "webform": try: form = 'form' from modules.web_bruter import WEBbrutus brutus = WEBbrutus(self.targets, self.file) brutus.start(form) except KeyboardInterrupt: brutus.stop(form) pass except TypeError: print "[!] You probably forgot to set the wordlist file path." pass else: print "[!] Select a valid type of brute-force type help to check." else: try: os.system("{}".format(self.command)) pass except Exception as e: print "[!] Select a valid option, type help to check sintax." pass except IndexError: pass except Exception as e: print "Exception caught: {}".format(e) except KeyboardInterrupt: print "\n[*] User requested shutdown." exit()
def run(mother): category = mother.categories['Study'] all_studies = set() status = {} has_status = set() missing_status = set() missing_jarvis = set() jarvis_ids = set() for page in category: logging.debug("Checking study", page.name) all_studies.add(page.name) text = page.text() p = mwparserfromhell.parse(text) template = study_template(p) if template: if template.has("Study Status"): s = template.get("Study Status").value.strip() if s == "": continue words = re.split(r',\s*', s) for c in words: status[c] = status.get(c, set()) status[c].add(page.name) has_status.add(page.name) if not template.has("JARVIS ID") or \ template.get("JARVIS ID").value.strip() == "": missing_jarvis.add(page.name) else: jarvis_ids.add(int(template.get("JARVIS ID").value.strip())) if not page.name in has_status: missing_status.add(page.name) logging.debug("Got status: ", status) # Now statuses contains a hash of construct -> list of pages. # NOTE: This re-uses MediaWiki's category CSS classes to get three-column display. Maybe weird to do that? oldtext = category.text() cat = mwparserfromhell.parse(oldtext) sections = cat.get_sections() title = "== Sorted by Study Status ==" newtext = title + "\n\nPlease note: this section is created automatically based on the status in each study's infobox. To edit, go to the study's page and choose 'Edit with form'.\n\n" newtext += "<div class='mw-category'>" # Build up an index by status # Sort by certain rules sort_order = [ "In Development", "Piloting", "Collecting", "Data Collection Complete", "Analyzing", "Publishing", "IRB Closed" ] for k in sort_order: if not k in status: continue newtext += "<div class='mw-category-group'><h3>" + k + "</h3>\n" for study in sorted(list(status[k])): newtext += "* [[" + study + "]]\n" newtext += "</div>" # List out things that are missing statuses newtext += "<div class='mw-category-group'><h3>No statuses listed</h3>\n" for m in missing_status: newtext += "* [[" + m + "]]\n" newtext += "</div>" newtext += "</div>\n\n" # Replace the "Sorted by Study Status" section with our new text old_section = cat.get_sections(matches="Sorted by Study Status")[0] cat.replace(old_section, newtext) newpage = str(cat) if oldtext != newpage: logging.warning("Updating study category page, change detected") category.save( newpage, "Automated edit to build status categories on study library") # Now we use the statuses and dates we pulled to edit the "missing Jarvis" and "studies not edited for the longest" missing = mother.pages['Study pages missing JARVIS IDs'] oldtext = missing.text() newpage = "This page is automatically generated. See also [[JARVIS IDs missing study pages]]\n\n" newpage += "== Pages missing JARVIS IDs ==\n\n" for page in sorted(missing_jarvis): newpage += f"* [[{page}]]\n" if oldtext != newpage: logging.warning("Updating missing JARVIS IDs page, change detected") missing.save(newpage, "Automated edit") # Now we build the opposite thing missing = mother.pages['JARVIS IDs missing study pages'] oldtext = missing.text() newpage = "This page is automatically generated and only includes more recent entries in JARVIS. See also [[Study pages missing JARVIS IDs]]\n\n" newpage += "== JARVIS IDs missing study pages ==\n\n" j = Jarvis() all_studies = j.select( "SELECT id, folder, name, created_at FROM studies ORDER BY created_at DESC LIMIT 30" ) for s in all_studies: jarvis_id, folder, name, created_at = s if not jarvis_id in jarvis_ids: newpage += f"* ID {jarvis_id} in /study/{folder}: \"{name}\" (created at {created_at})\n" if oldtext != newpage: logging.warning("Updating missing study pages page, change detected") missing.save(newpage, "Automated edit")
class JarvisTest(unittest.TestCase): def setUp(self): from jarvis import Jarvis self.he = Jarvis() def _word_database_builder(self): from database import WordDataBaseBuilder db_builder = WordDataBaseBuilder() db_builder.addTxtFile("sample.txt") return db_builder def _traning_database_builder(self): from database import TrainingDataBaseBuilder builder = TrainingDataBaseBuilder() builder.addTxtFile("traning_sample.txt") return builder def _abilities_builder(self): from database import AbilitiesDataBaseBuilder return AbilitiesDataBaseBuilder() def _innervoice_builder(self): from database import InnerVoiceDataBaseBuilder return InnerVoiceDataBaseBuilder() def test_dictionary(self): self.he.createWordsDataBase(self._word_database_builder()) def test_respond_exception(self): from jarvis import JarvisException with self.assertRaises(JarvisException): self.he.respond("aaa bbb ccc") def test_respond_exception2(self): from jarvis import JarvisException self.he.createWordsDataBase(self._word_database_builder()) with self.assertRaises(JarvisException): self.he.respond("aaa bbb ccc www") def test_createAbilitiesDataBase(self): self.he.createAbilitiesDataBase(self._abilities_builder()) def test_train_exception(self): from jarvis import JarvisException with self.assertRaises(JarvisException): self.he.train() def test_train(self): self.he.createWordsDataBase(self._word_database_builder()) self.he.createTrainingDataBase(self._traning_database_builder()) self.he.train() def test_respond(self): self.he.createWordsDataBase(self._word_database_builder()) self.he.createTrainingDataBase(self._traning_database_builder()) self.he.createAbilitiesDataBase(self._abilities_builder()) self.he.train() answer = self.he.respond("aaa bbb_1 ccc") self.assertEqual(answer,"abc abc zzz") #Neural network sometimes does not answer correctly answer = self.he.respond("abc abc") self.assertEqual(answer,"abc test") def test_start_stop(self): import threading import time self.he.createInnerVoiceDatabase(self._innervoice_builder()) self.he.createWordsDataBase(self._word_database_builder()) self.he.createTrainingDataBase(self._traning_database_builder()) self.he.createAbilitiesDataBase(self._abilities_builder()) self.he.train() start_thread = threading.Thread(target=self.he.start,name=self.he.start.func_name) start_thread.start() time.sleep(0.5) self.he.stop() start_thread.join() self.assertFalse(start_thread.isAlive())
def __init__(self): # Config File os.path.abspath("config/NetGUARD.cfg") self.config = ConfigParser.ConfigParser() self.config.read("config/netguard.cfg") # Call Jarvis self.Jarvis = Jarvis() # Log file os.path.abspath("log/NetGUARD.log") # Jail self.jail = [] try: # Network Interface from config self.interface = self.configmap("NetworkSettings")['interface'] # Gateway IP address from config self.gateway_ip = self.configmap("NetworkSettings")['gateway_ip'] # Gateway MAC address from config self.gateway_mac = self.configmap("NetworkSettings")['gateway_mac'] except Exception as e: print "[-] Check your config file in NetGUARD/config/netguard.cfg" print "[!] Exception caught: ".format(e) exit(0) # My Network Interface MAC_Address self.mymac = get_mymac(self.interface) # My LAN IP Address self.myip = get_myip(self.interface) # If we are ARP spoofing status self.myspoof_status = False # If someone is ARP spoofing status self.spoof_status = False # ICMP request for this host - DDoS avoid. self.icmp_count = 0 # Network ICMP sources in 5s self.icmpsenders = {} # TCP != from gateway connections - DDoS avoid. self.tcp_count = 0 # Network UDP sources in 5s self.tcpsenders = {} # UDP != from gateway connections - DDoS avoid. self.udp_count = 0 # Network UDP sources in 5s self.udpsenders = {} # SSH client attempts and brute status self.ssh_count = 0 self.ssh_brute = False # MySQL client attempts and brute status self.sql_count = 0 self.sql_brute = False # FTP client attempts and brute status self.ftp_count = 0 self.ftp_brute = False # Time variables self.start_time = time.time() self.current_time = 0 #ICMP time auxiliary self.itt = 0 self.itt2 = 0 #TCP time auxiliary self.ttt = 0 self.ttt2 = 0 #UDP time auxiliary self.utt = 0 self.utt2 = 0 #SSH time auxiliary self.sst = 0 self.sst2 = 0 #SQL time auxiliary self.sqt = 0 self.sqt2 = 0 #FTP time auxiliary self.ftt = 0 self.ftt2 = 0
class NetGUARD(object): name = "Network Guardian" desc = "Defend host, give warnings to sysadmin and log to txt file." version = "0.9" # Initialize, create NetGUARD global variables and parse config file def __init__(self): # Config File os.path.abspath("config/NetGUARD.cfg") self.config = ConfigParser.ConfigParser() self.config.read("config/netguard.cfg") # Call Jarvis self.Jarvis = Jarvis() # Log file os.path.abspath("log/NetGUARD.log") # Jail self.jail = [] try: # Network Interface from config self.interface = self.configmap("NetworkSettings")['interface'] # Gateway IP address from config self.gateway_ip = self.configmap("NetworkSettings")['gateway_ip'] # Gateway MAC address from config self.gateway_mac = self.configmap("NetworkSettings")['gateway_mac'] except Exception as e: print "[-] Check your config file in NetGUARD/config/netguard.cfg" print "[!] Exception caught: ".format(e) exit(0) # My Network Interface MAC_Address self.mymac = get_mymac(self.interface) # My LAN IP Address self.myip = get_myip(self.interface) # If we are ARP spoofing status self.myspoof_status = False # If someone is ARP spoofing status self.spoof_status = False # ICMP request for this host - DDoS avoid. self.icmp_count = 0 # Network ICMP sources in 5s self.icmpsenders = {} # TCP != from gateway connections - DDoS avoid. self.tcp_count = 0 # Network UDP sources in 5s self.tcpsenders = {} # UDP != from gateway connections - DDoS avoid. self.udp_count = 0 # Network UDP sources in 5s self.udpsenders = {} # SSH client attempts and brute status self.ssh_count = 0 self.ssh_brute = False # MySQL client attempts and brute status self.sql_count = 0 self.sql_brute = False # FTP client attempts and brute status self.ftp_count = 0 self.ftp_brute = False # Time variables self.start_time = time.time() self.current_time = 0 #ICMP time auxiliary self.itt = 0 self.itt2 = 0 #TCP time auxiliary self.ttt = 0 self.ttt2 = 0 #UDP time auxiliary self.utt = 0 self.utt2 = 0 #SSH time auxiliary self.sst = 0 self.sst2 = 0 #SQL time auxiliary self.sqt = 0 self.sqt2 = 0 #FTP time auxiliary self.ftt = 0 self.ftt2 = 0 # Configuration file mapping def configmap(self, section): dict = {} options = self.config.options(section) for option in options: try: dict[option] = self.config.get(section, option) if dict[option] == -1: DebugPrint("[!] Skip: {}".format(option)) except: print "[!] Exception on: %s".format(s) dict[option] = None return dict # Main routine def main(self, p): # Ethernet Frame if p.haslayer(Ether): # Media Access Control destination mac_dst = str(p[Ether].dst) # Media Acess Control source mac_src = str(p[Ether].src) # ARP Layer Protection if p.haslayer(ARP): # is-at if p[ARP].op == 2: # Sender Hardware Address hardware_src = p[ARP].hwsrc # Sender Protocol Address protocol_src = p[ARP].psrc # Target Hardware Address hardware_dst = p[ARP].hwdst # Target Protocol Address protocol_dst = p[ARP].pdst # If gateway ARP is-at is normal if protocol_src == self.gateway_ip and hardware_src == self.gateway_mac: if self.spoof_status == True: self.log("Gateway returned to original mac address.") self.Jarvis.Say( "The gateway has returned to the original mac.") self.spoof_status = False if self.myspoof_status == True: self.log("This host stop to arp spoof the gateway. \n") self.Jarvis.Say( "You stopped to arp spoof the gateway sir.") self.myspoof_status = False return # If the op is: gateway is at and the hardware source diverges from original gateway MAC. if protocol_src == self.gateway_ip and hardware_src != self.gateway_mac: # If the person that are doing the ARP spoof is me." if hardware_src == self.mymac: if self.myspoof_status == False: # Log self.log( "This host start to arp spoof the gateway. \n") self.Jarvis.Say( "You are arp spoofing the gateway sir.") # Status self.myspoof_status = True else: return # If the person is not you else: if self.spoof_status == False: for i in range(0, 3): self.Jarvis.Say( "the mac {} is trying to arp spoof the network." .format(hardware_src.replace(":", " "))) #os.system("iptables -A INPUT -m mac --mac-source {} -j REJECT".format(hardware_src)) time.sleep(2) # Log self.log( "{} are trying to arp spoof the network. \n". format(hardware_src)) # Status self.spoof_status = True else: return # IP Layer Protection if p.haslayer(IP): ip_src = str(p[IP].src) ip_dst = str(p[IP].dst) ip_chk = p[IP].chksum ip_len = p[IP].len #DDoS ICMP Layer Protection if p.haslayer(ICMP): type = p[ICMP].type if ip_src != self.myip and ip_dst == self.myip and type == 8: if ip_dst not in self.icmpsenders: # Append new ICMP sender on network self.icmpsenders.update({ip_src: self.tcp_count}) self.icmp_count += 1 # First time value from 5s delay if self.icmp_count == 1: self.itt = time.time() else: self.itt2 = time.time() for ip, count in self.icmpsenders.iteritems(): if count > 500 and ip not in self.jail: self.log( "IP - {}/MAC - {} start to perform a ICMP denial of service attack against this host." .format(ip, mac_dst)) self.Jarvis.Say( "The IP address {} is performing a ICMP denial of service attack against this host." .format(ip.replace(".", " "))) os.system( "iptables -A INPUT -p icmp -s {} -j DROP".format( ip, str(dport))) self.Jarvis.Say( "Raising the packet shield for the attacker") self.jail.append(ip) interval = self.itt2 - self.itt if interval >= 5: self.icmp_count = 0 self.icmpsenders.clear() # DDoS TCP Layer Protection if p.haslayer(TCP): sport = p[TCP].sport dport = p[TCP].dport if ip_src != self.gateway_ip and ip_src != self.myip and ip_dst == self.myip: if ip_dst not in self.tcpsenders: # Append new TCP sender on network self.tcpsenders.update({ip_src: self.tcp_count}) self.tcp_count += 1 # First time value from 5s delay if self.tcp_count == 1: self.ttt = time.time() else: # Other time values from 5s delay self.ttt2 = time.time() for ip, count in self.tcpsenders.iteritems(): if count > 500 and ip not in self.jail: self.log( "IP - {}/MAC - {} start to perform a TCP denial of service attack against this host." .format(ip, mac_dst)) self.Jarvis.Say( "The IP address {} is performing a TCP denial of service attack against this host." .format(ip.replace(".", " "))) os.system( "iptables -A INPUT -p tcp -s {} -j DROP".format( ip, str(dport))) self.log("Raising the packet shield for the attacker") self.Jarvis.Say( "Raising the packet shield for the attacker") self.jail.append(ip) interval = self.ttt2 - self.ttt if interval >= 5: self.tcp_count = 0 self.tcpsenders.clear() # DDoS UDP Layer Protection if p.haslayer(UDP): sport = p[UDP].sport if ip_src != self.gateway_ip and ip_src != self.myip and ip_dst == self.myip: if ip_dst not in self.udpsenders: self.udpsenders.update({ip_src: self.udp_count}) self.udp_count += 1 if self.tcp_count == 1: self.utt = time.time() else: self.utt2 = time.time() for ip, count in self.udpsenders.iteritems(): if count > 500 and ip not in self.jail: self.log( "IP - {}/MAC - {} start to perform a UDP denial of service attack against this host." .format(ip_src, mac_dst)) self.Jarvis.Say( "The IP address {} is performing a UDP denial of service attack against this host." .format(ip_src.replace(".", " "))) os.system( "iptables -A INPUT -p udp -s {} -j DROP".format( ip_src, str(dport))) self.log("Raising the packet shield for the attacker") self.Jarvis.Say( "Raising the packet shield for the attacker") self.jail.append(ip) interval = self.utt2 - self.utt if interval >= 5: self.udp_count = 0 self.udpsenders.clear() # Brute-Force TCP Layer Protection if p.haslayer(TCP) and p.haslayer(Raw): flags = { 'F': 'FIN', 'S': 'SYN', 'R': 'RST', 'P': 'PSH', 'A': 'ACK', 'U': 'URG', 'E': 'ECE', 'C': 'CWR' } dport = p[TCP].dport sport = p[TCP].sport ack = p[TCP].ack seq = p[TCP].seq preflag = [flags[x] for x in p.sprintf('%TCP.flags%')] flag = "/".join(preflag) chksum = str(p[TCP].chksum) load = p[Raw].load # FTP Protection if sport == 21 and "530" in load and ip_src == self.myip: if self.ftp_brute == False: self.log( "IP - {}/MAC - {} tried to connect with the FTP server with a wrong password." .format(ip_dst, mac_dst)) self.Jarvis.Say( "The IP address {} tried to connect with the FTP server with a wrong password." .format(ip_dst.replace(".", " "))) self.ftp_count += 1 if self.ftp_count == 1: # Live minutes self.ftt = time.time() else: self.ftt2 = time.time() # If 4 ftp_client packets and 4º count time - 1º count time >= 1 if self.ftp_count >= 4: interval = self.ftt2 - self.ftt if interval >= 360: self.ftp_count = 0 else: self.ftp_brute = True os.system( "iptables -A INPUT -p tcp -s {} --dport {} -j REJECT" .format(ip_dst, str(sport))) # Log self.log( "! IP - {}/MAC - {} is brute forcing the FTP server." .format(ip_dst, mac_dst)) self.log( "Raising the packet shield for the attacker") self.Jarvis.Say( "The IP {} is brute forcing the FTP server.". format(ip_dst.replace(".", " "))) self.Jarvis.Say( "Raising the packet shield for the attacker") # Status self.ftp_count = 0 # MySQL Protection if sport == 3306 and "denied" in load and ip_src == self.myip: if self.sql_brute == False: self.log( "IP - {}/MAC - {} tried to connect with the SQL server with a wrong password." .format(ip_dst, mac_dst)) self.Jarvis.Say( "The IP address {} tried to connect with the SQL server with a wrong password." .format(ip_dst.replace(".", " "))) self.sql_count += 1 if self.sql_count == 1: # Live minutes self.sqt = time.time() else: self.sqt2 = time.time() # If 4 sql_client packets and 4º count time - 1º count time >= 1 if self.sql_count >= 4: interval = self.sqt2 - self.sqt if interval >= 360: self.sql_count = 0 else: self.sql_brute = True os.system( "iptables -A INPUT -p tcp -s {} --dport {} -j REJECT" .format(ip_dst, str(sport))) # Log self.log( "! IP - {}/MAC - {} is brute forcing the SQL server." .format(ip_dst, mac_dst)) self.log( "Raising the packet shield for the attacker") self.Jarvis.Say( "The IP {} is brute forcing the SQL server.". format(ip_dst.replace(".", " "))) self.Jarvis.Say( "Raising the packet shield for the attacker") # Status self.sql_count = 0 # SSH Protection if "SSH" in load and ip_src != self.myip and ip_dst == self.myip: if self.ssh_brute == False: self.log( "IP - {}/MAC - {} open a socket with the SSH server." .format(ip_src, mac_src)) self.Jarvis.Say( "The IP address {} open a socket with the SSH server." .format(ip_dst.replace(".", " "))) self.ssh_count += 1 if self.ssh_count == 1: # Live minutes self.sst = time.time() else: self.sst2 = time.time() # If 4 ssh_client packets and 4º count time - 1º count time >= 1 if self.ssh_count >= 3: interval = self.sst2 - self.sst if interval >= 360: self.ssh_count = 0 self.sst = 0 else: self.ssh_brute = True os.system( "iptables -A INPUT -p tcp -s {} --dport {} -j REJECT" .format(ip_src, str(dport))) # Log self.log( "! IP - {}/MAC - {} is brute forcing the SSH server." .format(ip_src, mac_src)) self.log( "Raising the packet shield for the attacker") self.Jarvis.Say( "The IP {} is brute forcing the SSH server.". format(ip_dst.replace(".", " "))) self.Jarvis.Say( "Raising the packet shield for the attacker") # Status self.ssh_count = 0 self.sst = 0 # Logger def log(self, message): file = open("log/NetGUARD.log", "a+") file.write("\n") time = datetime.now().strftime('%Y-%m-%d_%H:%M:%S') file.write(time + ": ") file.write(message) file.close() # Start def start(self): try: pid = os.getpid() self.log("NetGUARD started") self.Jarvis.Say( "Network guardian initialized on process {}.".format(pid)) # Set static ARP with the gateway. os.system("arp -s {} {}".format(self.gateway_ip, self.gateway_mac)) self.log("Static ARP set with gateway.") self.Jarvis.Say("Setting static arp with gateway.") self.Jarvis.Say("I will warn you if i find any threat") # Start the sniffer. p = sniff(iface=self.interface, prn=self.main) time = datetime.now().strftime('%Y-%m-%d_%H:%M:%S') wrpcap("NetGUARD_{}.pcap".format(time), p) except Exception as e: self.log("Problem starting the network monitor") self.log("Exception: {}".format(e)) self.Jarvis.Say("Problem starting the network monitor") # Start the sniffer as subprocess. def backgroundstart(self): try: with open("log/NetGUARD.log", "a+") as stdout: self.p = subprocess.Popen(["python core/NetGUARD.py"], shell=True, stdout=stdout, stderr=stdout) self.log("NetGUARD in background started.") return except Exception as e: self.log("Problem starting NetGUARD in background") self.Jarvis.Say( "Problem starting the network monitor in background")
def __init__(self): self.Jarvis = Jarvis()
from flask import Flask, request, jsonify from jarvis import Jarvis import json jarvis = Jarvis() app = Flask(__name__) # Create URL route in our application for "/" @app.route('/v1') def home(): """ This is the main page. """ return "This is a rest service for Jarvis. Jarvis is a AI text classification agent. He will try to predict the correct queue for the email you pass to it." @app.route('/v1/predict',methods = ['POST', 'GET']) def predict(): """ This fuction is to create the post and get method for prediction """ if request.method == 'POST': data = request.get_json() query = data["email"] result = jarvis.predict(query) return jsonify(result) else: query = request.args.get('email') result = jarvis.predict(query) return jsonify(result)
from database import WordDataBaseBuilder from database import TrainingDataBaseBuilder from database import AbilitiesDataBaseBuilder from database import InnerVoiceDataBaseBuilder from interfaces import Console wd_builder = WordDataBaseBuilder() wd_builder.addTxtFile("learning_material/traning.txt") td_builder = TrainingDataBaseBuilder() td_builder.addTxtFile("learning_material/traning.txt") iv_builder = InnerVoiceDataBaseBuilder() iv_builder.addTxtFile("learning_material/inner_voices.txt") ab_builder = AbilitiesDataBaseBuilder() he = Jarvis() he.createWordsDataBase(wd_builder) he.createTrainingDataBase(td_builder) he.createAbilitiesDataBase(ab_builder) he.createInnerVoiceDatabase(iv_builder) he.train() console = Console() console.jarvis(he) console.start() he.start()
class Processor(object): name = "Interface-Processor" desc = "Console to process commands" version = "0.5" def __init__(self): #Jarvis self.Jarvis = Jarvis() #Variables self.targets = None self.file = None self.interface = None self.gateway = None self.port = 80 self.domain = None self.redirect = None self.script = None self.filter = None self.arpmode = "rep" #Status manager self.jarvis_status = 0 self.arpspoof_status = False self.inject_status = False self.dnsspoof_status = False self.mitmdrop_status = 0 def start(self): try: while 1: completer = Completer("pythem") console = termcolor.colored("pythem>", "red", attrs=["bold"]) self.command = raw_input("{} ".format(console)) self.argv = self.command.split() self.input_list = [str(a) for a in self.argv] try: if self.input_list[0] == "help": print_help() elif self.command == "jarvis": self.Jarvis.start('core/processor.py') self.jarvis_status = 1 elif self.input_list[0] == "jarvis": if self.input_list[1] == "log": try: jarvislog = self.input_list[2] try: os.system( "tail -f log/jarvis{}.txt".format( jarvislog)) except Exception as e: print "[!] Exception caught: {}".format(e) pass except IndexError: print "[+] Jarvis log system." print "[.] Error log - type: err" print "[.] Output log - type: out" try: jarvislog = raw_input("[+] Select: ") os.system( "tail -f log/jarvis{}.txt".format( jarvislog)) except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[1] == "help": jarvis_help(self.Jarvis.version) elif self.input_list[1] == "say": try: message = self.input_list[2] all_msg = " ".join(self.input_list[2:]) self.Jarvis.Say(all_msg) except IndexError: try: message = raw_input("[+] Jarvis speaker: ") self.Jarvis.Say(message) except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[1] == "read": try: file = self.input_list[2] self.Jarvis.Read(file) except IndexError: if self.file is not None: self.Jarvis.Read(self.file) else: file = "[+] Set file path:" pass except TypeError: print "[!] You probably forgot to set a wordlist file path." pass except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) else: self.Jarvis.start('core/processor.py') self.jarvis_status = 1 elif self.command == "exit" or self.command == "quit": if self.jarvis_status == 1: self.Jarvis.Say(self.Jarvis.random('salutes')) self.Jarvis.stop() exit() else: exit() elif self.input_list[0] == "set" or self.input_list[ 0] == "SET": if self.input_list[1] == "interface": try: self.interface = self.input_list[2] except IndexError: try: self.interface = raw_input( "[+] Enter the interface: ") except KeyboardInterrupt: pass elif self.input_list[1] == "port": try: self.port = int(self.input_list[2]) except IndexError: try: self.port = input( "[+] Enter the default port: ") except KeyboardInterrupt: pass elif self.input_list[1] == "domain": try: self.domain = self.input_list[2] except IndexError: try: self.domain = raw_input( "[+] Domain to be spoofed: ") except KeyboardInterrupt: pass elif self.input_list[1] == "redirect": try: self.redirect = self.input_list[2] except IndexError: try: self.redirect = raw_input( "[+] IP address to redirect DNS queries: " ) except KeyboardInterrupt: pass elif self.input_list[1] == "script": try: self.script = self.input_list[2] except IndexError: try: self.script = raw_input( "[+]Script url/path: ") except KeyboardInterrupt: pass elif self.input_list[1] == "gateway": try: self.gateway = self.input_list[2] except IndexError: try: self.gateway = raw_input( "[+] Enter the gateway: ") except KeyboardInterrupt: pass elif self.input_list[1] == "target": try: self.targets = self.input_list[2] except IndexError: try: self.targets = raw_input( "[+] Enter the target(s): ") except KeyboardInterrupt: pass elif self.input_list[1] == "file": try: self.file = self.input_list[2] except IndexError: try: self.file = raw_input( "[+] Enter the path to the file: ") except KeyboardInterrupt: pass elif self.input_list[1] == "arpmode": try: self.arpmode = self.input_list[2] except IndexError: try: self.arpmode = raw_input( "[+] Enter the arpmode: ") except KeyboardInterrupt: pass elif self.input_list[1] == "filter": try: self.filter = self.input_list[2] except IndexError: try: self.filter = raw_input( "[+] Enter the sniffer filter: ") except KeyboardInterrupt: pass else: print "[!] Select a valid variable to set." elif self.input_list[0] == "print": if self.input_list[1] == "interface": print "[+] Network Interface: {}".format( self.interface) elif self.input_list[1] == "port": print "[+] Default port: {}".format(self.port) elif self.input_list[1] == "domain": print "[+] Domain: {}".format(self.domain) elif self.input_list[1] == "redirect": print "[+] Redirecting to: {}".format( self.redirect) elif self.input_list[1] == "script": print "[+] Script url/path: {}".format(self.script) elif self.input_list[1] == "gateway": print "[+] Gateway IP Address: {}".format( self.gateway) elif self.input_list[1] == "target": print "[+] Target(s): {}".format(self.targets) elif self.input_list[1] == "file": print "[+] File path: {}".format(self.file) elif self.input_list[1] == "arpmode": print "[+] ARP spoofing mode: {}".format( self.arpmode) else: print "[-] Select a valid variable name." elif self.input_list[0] == "scan": try: mode = self.input_list[1] if self.targets is not None and self.interface is not None: from modules.scanner import Scanner self.scan = Scanner(self.targets, self.interface, mode) self.scan.start() else: print "[!] You probably forgot to set the interface or a valid IP address/range." except IndexError: try: print "[*] Select one scan mode, options = tcp/arp/manual" mode = raw_input("[+] Scan mode: ") except KeyboardInterrupt: pass if self.targets is not None and self.interface is not None: from modules.scanner import Scanner self.scan = Scanner(self.targets, self.interface, mode) self.scan.start() else: print "[!] You probably forgot to set the interface or a valid IP address/range." pass except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "arpspoof": try: if self.input_list[1] == "start": from modules.arpoisoner import ARPspoof myip = get_myip(self.interface) mymac = get_mymac(self.interface) self.arpspoof_status = True self.spoof = ARPspoof(self.gateway, self.targets, self.interface, self.arpmode, myip, mymac) self.spoof.start() print "[+] ARP spoofing initialized." elif self.input_list[1] == "stop": self.spoof.stop() self.arpspoof_status = False print "[+] ARP spoofing finalized." elif self.input_list[1] == "status": if self.arpspoof_status: stat = "running" else: stat = "down" print "[*] ARP spoofing status: {}".format( stat) else: print "[!] Select a valid option, call help to check syntax." except TypeError: print "[!] You probably forgot to set interface or gateway." except IndexError: print "[!] You probably forgot to type start or stop after arpspoof." except AttributeError: pass except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[0] == "dnsspoof": try: if self.input_list[1] == "start": if not self.arpspoof_status: print "[!] You probably forgot to start an ARP spoofing." continue if self.domain != None: domain = self.domain else: try: domain = raw_input( "[!] Type all to spoof all domains\n[+] Domain to be spoofed: " ) self.domain = domain except KeyboardInterrupt: pass if self.redirect != None: redirect = self.redirect else: myip = get_myip(self.interface) opt = raw_input( "[+] Default address to redirect is:{} do you want to change?[y/n]" .format(myip)) if opt == "y" or opt == "Y" or opt == "yes" or opt == "YES": try: redirect = raw_input( "[+] IP address to be redirected: " ) except KeyboardInterrupt: pass else: redirect = myip from modules.dnspoisoner import DNSspoof self.dnsspoof = DNSspoof(redirect) self.dnsspoof.start(domain, None) print "[+] DNS spoofing initialized" self.dnsspoof_status = True elif self.input_list[1] == "stop": self.dnsspoof.stop() print "[+] DNS spoofing finalized" elif self.input_list[1] == "status": if self.dnsspoof_status: stat = "running" else: stat = "down" print "[*] DNS spoofing status: {}".format( stat) else: print "[!] Select a valid option, call help to check syntax." except IndexError: print "[!] You probably forgot to type start or stop after dnsspoof." except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[0] == "inject": try: if self.input_list[1] == "start": myip = get_myip(self.interface) try: from modules.inject import Inject self.inject = Inject( myip, self.port, self.script) self.inject_status = True self.inject.server() except AttributeError: print "\n[!] Select a valid script source path or url." except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[1] == "stop": try: self.inject.stop() self.inject_status = False except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[1] == "status": if self.inject_status: stat = "running" else: stat = "down" print "[*] Script injection status: {}".format( stat) else: print "[!] You need to specify start, stop or status after the inject module call." except IndexError: print "[!] You probably forgot to start or stop the inject module." except TypeError: print "[!] You probably forgot to start an arpspoof attack ." except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[0] == "dos": from modules.jammer import Jam self.dos = Jam() try: if self.input_list[1] == "mitmdrop": if self.arpspoof_status: try: myip = get_myip(self.interface) self.dos.mitmdropstart(myip) self.mitmdrop_status = 1 except Exception as e: print "[!] Exception caught: {}".format( e) else: print "[!] You need to start a arpspoof on a target (IP/Range) to start mitmdrop." elif self.input_list[1] == "stop": if self.mitmdrop_status == 1: self.dos.mitmdropstop() else: print "[!] You need to start a DoS attack before call stop." else: print "[!] Select a valid option, type help to check syntax." except IndexError: print "[!] You probably forgot to specify the type of DoS to use." elif self.input_list[0] == "sniff": from modules.sniffer import Sniffer try: hasfilter = self.input_list[1] self.filter = " ".join(self.input_list[1:]) if self.filter == "http": self.filter = "port 80" elif self.filter == "dns": self.filter = "port 53" self.sniff = Sniffer(self.interface, self.filter) self.sniff.start() except IndexError: try: self.filter = raw_input( "[+] Enter the filter: ") if self.filter == "http": self.filter = "port 80" elif self.filter == "dns": self.filter = "port 53" if not self.filter: self.filter = None self.sniff = Sniffer(self.interface, self.filter) self.sniff.start() except KeyboardInterrupt: pass elif self.command == "pforensic": try: completer = None completer = Completer("pforensic") from modules.pforensic import PcapReader self.pcapread = PcapReader(self.file) self.pcapread.start() except KeyboardInterrupt: pass except TypeError: print "[!] You probably forgot to set the .pcap file" pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "xploit": try: from modules.exploit import Exploit if self.targets is not None and self.input_list[ 1] == "tcp": self.xploit = Exploit(self.targets, self.input_list[1]) self.xploit.start() elif self.file is not None and self.input_list[ 1] == "stdin": self.xploit = Exploit(self.file, self.input_list[1]) self.xploit.start() else: print "[!] You need to set or stdin or tcp as argument." print "[!] You need to set or a file or a target to xploit." except IndexError: try: print "[*] Select one xploit mode, options = stdin/tcp" mode = raw_input("[+] Exploit mode: ") if mode == "stdin" or mode == "tcp": from modules.exploit import Exploit if self.targets is not None: self.xploit = Exploit( self.targets, mode) self.xploit.start() elif self.file is not None: self.xploit = Exploit(self.file, mode) self.xploit.start() else: print "[!] You need to set or a file or a target to xploit." else: print "[!] Select a valid xploit mode, stdin or tcp" except KeyboardInterrupt: pass except TypeError: print "[!] You probably forgot to set the file" pass except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.command == "cookiedecode": try: cookiedecode() except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "decode": try: print decode(self.input_list[1]) except KeyboardInterrupt: pass elif self.input_list[0] == "encode": try: print encode(self.input_list[1]) except KeyboardInterrupt: pass elif self.input_list[0] == "geoip": try: self.targets = self.input_list[1] from modules.geoip import Geoip path = "config/GeoLiteCity.dat" iptracker = Geoip(self.targets, path) except IndexError: if self.targets is not None: from modules.geoip import Geoip path = "config/GeoLiteCity.dat" iptracker = Geoip(self.targets, path) else: print "[!] You probably forgot to set a target" except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "brute": if self.input_list[1] == "ssh": try: username = raw_input( "[+] Enter the username to bruteforce: ") from modules.ssh_bruter import SSHbrutus brutus = SSHbrutus(self.targets, username, self.file) brutus.start() except KeyboardInterrupt: brutus.stop() pass except TypeError: print "[!] You probably forgot to set the wordlist file path." pass elif self.input_list[1] == "url": try: url = 'url' from modules.web_bruter import WEBbrutus brutus = WEBbrutus(self.targets, self.file) brutus.start(url) except KeyboardInterrupt: brutus.stop(url) pass except TypeError: print "[!] You probably forgot to set the wordlist file path." pass elif self.input_list[1] == "form": try: form = 'form' from modules.web_bruter import WEBbrutus brutus = WEBbrutus(self.targets, self.file) brutus.start(form) except KeyboardInterrupt: brutus.stop(form) pass except TypeError: print "[!] You probably forgot to set the wordlist file path." pass else: print "[!] Select a valid type of brute-force type help to check." else: try: os.system("{}".format(self.command)) pass except Exception as e: print "[!] Select a valid option, type help to check syntax." pass except IndexError: pass except Exception as e: print "Exception caught: {}".format(e) except KeyboardInterrupt: print "\n[*] User requested shutdown." exit()
class Processor(object): name = "Jarvis-Processor" desc = "Console to process voice commands" version = "0.2" def __init__(self): self.Jarvis = Jarvis() def start(self): try: self.Jarvis.ser.open() except Exception as e: print "[!] Arduino Leonardo not found, features that use keyboard will not work." try: self.Jarvis.Say(self.Jarvis.random('greetings')) while 1: try: self.command = self.Jarvis.Listen() self.message = self.command.split() self.input_list = [str(a) for a in self.message] if self.input_list[0] == "exit" or self.input_list[ 0] == "quit": self.Jarvis.Say(self.Jarvis.random('salutes')) exit() elif self.input_list[0] == "sleep" or self.input_list[ 0] == "stop" or self.input_list[0] == "wait": self.Jarvis.Say("Call me if you need me sir.") while 1: self.wait = self.Jarvis.Listen() if self.wait == "Jarvis": self.Jarvis.Say( self.Jarvis.random('affirmative')) break elif self.input_list[0] == "newspaper" or self.input_list[ 0] == "news": self.Jarvis.Say("Here are the news sir.") self.titles = self.Jarvis.GetNews() self.Jarvis.SpeakNews(self.titles) elif self.input_list[0] == "browser": try: webbrowser.open("https://www.google.com") self.Jarvis.Say(self.Jarvis.random('affirmative')) except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "terminal": try: os.system("gnome-terminal") self.Jarvis.Say(self.Jarvis.random('affirmative')) except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "search": try: search = self.input_list[1:] real = "".join(search) url = "https://www.google.com/search?q={}".format( real) webbrowser.open(url) self.Jarvis.Say(self.Jarvis.random('affirmative')) except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "say" or self.input_list[ 0] == "speak": self.Jarvis.Say(self.input_list[1:]) elif self.input_list[0] == "run": self.Jarvis.Say(self.Jarvis.random('affirmative')) os.system("./scripts/{}.sh".format(self.input_list[1])) elif self.input_list[0] == "input": try: self.Jarvis.SerialWrite(self.input_list[1]) self.Jarvis.Say(self.Jarvis.random('affirmative')) except: self.Jarvis.Say( "Feature not working master, plug your Arduino Leonardo then restart the program." ) pass elif self.input_list[0] == "editor": self.Jarvis.Say("Starting edition mode sir.") while 1: self.editmode = self.Jarvis.Listen() self.mesg = self.editmode #self.msg = "".join(self.mesg) if self.mesg is not None: try: self.Jarvis.SerialWrite(self.mesg) self.Jarvis.Say( self.Jarvis.random('affirmative')) except: self.Jarvis.Say( "Feature not working, plug you Arduino Leonardo then restart the program." ) break else: pass if self.editmode == "exit": self.Jarvis.Say("Stoping edition mode sir.") break else: print '[!] Input a valid option, enter "help" to see valid commands.' self.Jarvis.Say("i heard, {}".format(self.command)) self.Jarvis.Say(self.Jarvis.random('dntunderstand')) except IndexError: pass except AttributeError: pass except KeyboardInterrupt: print "\n[*] User requested shutdown" self.Jarvis.Say(self.Jarvis.random('salutes')) exit() except Exception as e: print "[!] Exception caught: {}".format(e)
import sys from colorama import Fore, Back from features.calendar_feature import Calendar from jarvis import Jarvis features = ["calendar", "weather", "wiki"] if __name__ == "__main__": j = Jarvis() while True: typed = input("What do you want to do?: ").lower() cmd = typed.split(' ')[0] if cmd.strip() == 'list': j.say("Features available:") for feature in features: j.say("\t{}".format(feature), Fore.LIGHTBLUE_EX) elif cmd.strip() == 'exit' or cmd.strip() == 'close': j.say("G O O D B Y E") exit(0) elif j.cal.valid_inputs.get(cmd, 0) > 0: action = j.cal.do_action(typed) elif j.weather.valid_inputs.get(cmd, 0) > 0: if any(typed.strip('weather ')): j.weather.get_weather(typed.replace('weather ', '')) else: j.weather.get_weather() elif j.wiki.valid_inputs.get(cmd, 0) > 0:
class JarvisServer: def __init__(self): self.server_app = Flask(__name__) self.host_name = "0.0.0.0" self.port = 8008 self.auth_string = "new String that I created just so I could access this just for myself" self.routes = [ dict(route="/health", endpoint="/health", func=self._health) ] def start_server(self): print("Starting a thread for home server!") from main import build_plugin_manager plugin_manager = build_plugin_manager() language_parser = snips.LanguageParser() jarvis_server = JarvisServer() self.io = ServerIO() self.jarvis = Jarvis(language_parser, plugin_manager, jarvis_server) self.jarvis.register_io(self.io) self.server_app.run(host=self.host_name, port=self.port, threaded=True, debug=True, use_reloader=False) def check_running(self) -> bool: pass def init_server_endpoints(self, jarvis_plugins): self._get_all_routes(jarvis_plugins) for route in self.routes: try: self.server_app.add_url_rule(route["route"], route["endpoint"], route["func"]) except Exception as e: print(e) def _wrap_plugin(self, plugin): def _run(): plugin.run(self.jarvis.jarvis_api, '') _text = self.io.fetch_recorded_texts() print(_text) return '\n'.join(_text) return _run def _get_all_routes(self, jarvis_plugins): for plugin in jarvis_plugins: route = dict() endpoint_string = "/" + '_'.join( re.findall(r"[\w']+", plugin.get_name())) if len(plugin.get_plugins().values()) != 0: self._get_all_routes(plugin.get_plugins().values()) else: route["route"] = endpoint_string route["endpoint"] = endpoint_string _plug = plugin route["func"] = self._wrap_plugin(plugin) self.routes.append(route) def _health(self): return "Healthy"
class Processor(object): name = "Interface-Processor" desc = "Console to process commands" version = "0.4" def __init__(self): #Jarvis self.Jarvis = Jarvis() #Variables self.targets = None self.file = None self.interface = None self.gateway = None self.port = 80 self.domain = None self.redirect = None self.script = None self.arpmode = "rep" #Status manager self.jarvis_status = 0 self.arpspoof_status = False self.inject_status = False self.dnsspoof_status = False self.mitmdrop_status = 0 def start(self): try: while 1: completer = Completer("pythem") console = termcolor.colored("pythem>","red", attrs=["bold"]) self.command = raw_input("{} ".format(console)) self.argv = self.command.split() self.input_list = [str(a) for a in self.argv] try: if self.input_list[0] == "help": print_help() elif self.command == "jarvis": self.Jarvis.start('core/processor.py') self.jarvis_status = 1 elif self.input_list[0] == "jarvis": if self.input_list[1] == "log": try: jarvislog = self.input_list[2] try: os.system("tail -f log/jarvis{}.txt".format(jarvislog)) except Exception as e: print "[!] Exception caught: {}".format(e) pass except IndexError: print "[+] Jarvis log system." print "[.] Error log - type: err" print "[.] Output log - type: out" try: jarvislog = raw_input("[+] Select: ") os.system("tail -f log/jarvis{}.txt".format(jarvislog)) except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[1] == "help": jarvis_help(self.Jarvis.version) elif self.input_list[1] == "say": try: message = self.input_list[2] all_msg = " ".join(self.input_list[2:]) self.Jarvis.Say(all_msg) except IndexError: try: message = raw_input("[+] Jarvis speaker: ") self.Jarvis.Say(message) except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[1] == "read": try: file = self.input_list[2] self.Jarvis.Read(file) except IndexError: if self.file is not None: self.Jarvis.Read(self.file) else: file = "[+] Set file path:" pass except TypeError: print "[!] You probably forgot to set a wordlist file path." pass except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) else: self.Jarvis.start('core/processor.py') self.jarvis_status = 1 elif self.command == "exit" or self.command == "quit": if self.jarvis_status == 1: self.Jarvis.Say(self.Jarvis.random('salutes')) self.Jarvis.stop() exit() else: exit() elif self.input_list[0] == "set" or self.input_list[0] == "SET": if self.input_list[1] == "interface": try: self.interface = self.input_list[2] except IndexError: try: self.interface = raw_input("[+] Enter the interface: ") except KeyboardInterrupt: pass elif self.input_list[1] == "port": try: self.port = int(self.input_list[2]) except IndexError: try: self.port = input("[+] Enter the default port: ") except KeyboardInterrupt: pass elif self.input_list[1] == "domain": try: self.domain = self.input_list[2] except IndexError: try: self.domain = raw_input("[+] Domain to be spoofed: ") except KeyboardInterrupt: pass elif self.input_list[1] == "redirect": try: self.redirect = self.input_list[2] except IndexError: try: self.redirect = raw_input("[+] IP address to redirect DNS queries: ") except KeyboardInterrupt: pass elif self.input_list[1] == "script": try: self.script = self.input_list[2] except IndexError: try: self.script = raw_input("[+]Script url/path: ") except KeyboardInterrupt: pass elif self.input_list[1] == "gateway": try: self.gateway = self.input_list[2] except IndexError: try: self.gateway = raw_input("[+] Enter the gateway: ") except KeyboardInterrupt: pass elif self.input_list[1] == "target": try: self.targets = self.input_list[2] except IndexError: try: self.targets = raw_input("[+] Enter the target(s): ") except KeyboardInterrupt: pass elif self.input_list[1] == "file": try: self.file = self.input_list[2] except IndexError: try: self.file = raw_input("[+] Enter the path to the file: ") except KeyboardInterrupt: pass elif self.input_list[1] == "arpmode": try: self.arpmode = self.input_list[2] except IndexError: try: self.arpmode = raw_input("[+] Enter the arpmode:") except KeyboardInterrupt: pass else: print "[!] Select a valid variable to set." elif self.input_list[0] == "print": if self.input_list[1] == "interface": print "[+] Network Interface: {}".format(self.interface) elif self.input_list[1] == "port": print "[+] Default port: {}".format(self.port) elif self.input_list[1] == "domain": print "[+] Domain: {}".format(self.domain) elif self.input_list[1] == "redirect": print "[+] Redirecting to: {}".format(self.redirect) elif self.input_list[1] == "script": print "[+] Script url/path: {}".format(self.script) elif self.input_list[1] == "gateway": print "[+] Gateway IP Address: {}".format(self.gateway) elif self.input_list[1] == "target": print "[+] Target(s): {}".format(self.targets) elif self.input_list[1] == "file": print "[+] File path: {}".format(self.file) elif self.input_list[1] == "arpmode": print "[+] ARP spoofing mode: {}".format(self.arpmode) else: print "[-] Select a valid variable name." elif self.input_list[0] == "scan": try: mode = self.input_list[1] if self.targets is not None and self.interface is not None: from modules.scanner import Scanner self.scan = Scanner(self.targets, self.interface, mode) self.scan.start() else: print "[!] You probably forgot to set the interface or a valid IP address/range." except IndexError: try: print "[*] Select one scan mode, options = tcp/arp/manual" mode = raw_input("[+] Scan mode: ") except KeyboardInterrupt: pass if self.targets is not None and self.interface is not None: from modules.scanner import Scanner self.scan = Scanner(self.targets, self.interface, mode) self.scan.start() else: print "[!] You probably forgot to set the interface or a valid IP address/range." pass except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "arpspoof": try: if self.input_list[1] == "start": from modules.arpoisoner import ARPspoof myip = get_myip(self.interface) mymac = get_mymac(self.interface) self.arpspoof_status = True self.spoof = ARPspoof(self.gateway, self.targets, self.interface,self.arpmode ,myip, mymac) self.spoof.start() print "[+] ARP spoofing initialized." elif self.input_list[1] == "stop": self.spoof.stop() self.arpspoof_status = False print "[+] ARP spoofing finalized." elif self.input_list[1] == "status": if self.arpspoof_status: stat = "running" else: stat = "down" print "[*] ARP spoofing status: {}".format(stat) else: print "[!] Select a valid option, call help to check syntax." except TypeError: print "[!] You probably forgot to set interface or gateway." except IndexError: print "[!] You probably forgot to type start or stop after arpspoof." except AttributeError: pass except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[0] == "dnsspoof": try: if self.input_list[1] == "start": if self.domain != None : domain = self.domain else: try: domain = raw_input("[+] Domain to be spoofed: ") self.domain = domain except KeyboardInterrupt: pass if self.redirect != None: redirect = self.redirect else: myip = get_myip(self.interface) opt = raw_input("[+] Default address to redirect is:{} do you want to change?[y/n]".format(myip)) if opt == "y" or opt == "Y" or opt == "yes" or opt == "YES": try:redirect = raw_input("[+] IP address to be redirected: ") except KeyboardInterrupt: pass else: redirect = myip from modules.dnspoisoner import DNSspoof self.dnsspoof = DNSspoof(redirect) self.dnsspoof.start(domain,None) print "[+] DNS spoofing initialized" self.dnsspoof_status = True elif self.input_list[1] == "stop": self.dnsspoof.stop() print "[+] DNS spoofing finalized" elif self.input_list[1] == "status": if self.dnsspoof_status: stat = "running" else: stat = "down" print "[*] DNS spoofing status: {}".format(stat) else: print "[!] Select a valid option, call help to check syntax." except IndexError: print "[!] You probably forgot to type start or stop after dnsspoof." except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[0] == "inject": try: if self.input_list[1] == "start": myip = get_myip(self.interface) try: from modules.inject import Inject self.inject = Inject(myip,self.port,self.script) self.inject_status = True self.inject.server() except AttributeError: print "\n[!] Select a valid script source path or url." except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[1] == "stop": try: self.inject.stop() self.inject_status = False except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[1] == "status": if self.inject_status: stat = "running" else: stat = "down" print "[*] Script injection status: {}".format(stat) else: print "[!] You need to specify start, stop or status after the inject module call." except IndexError: print "[!] You probably forgot to start or stop the inject module." except TypeError: print "[!] You probably forgot to start an arpspoof attack ." except Exception as e: print "[!] Exception caught: {}".format(e) elif self.input_list[0] == "dos": from modules.jammer import Jam self.dos = Jam() try: if self.input_list[1] == "mitmdrop": if self.arpspoof_status: try: myip = get_myip(self.interface) self.dos.mitmdropstart(myip) self.mitmdrop_status = 1 except Exception as e: print "[!] Exception caught: {}".format(e) else: print "[!] You need to start a arpspoof on a target (IP/Range) to start mitmdrop." elif self.input_list[1] == "stop": if self.mitmdrop_status == 1: self.dos.mitmdropstop() else: print "[!] You need to start a DoS attack before call stop." else: print "[!] Select a valid option, type help to check syntax." except IndexError: print "[!] You probably forgot to specify the type of DoS to use." elif self.input_list[0] == "sniff": from modules.sniffer import Sniffer try: filter = " ".join(self.input_list[1:]) self.sniff = Sniffer(self.interface, filter) self.sniff.start() except IndexError: filter = raw_input("[+] Enter the filter: ") self.sniff = Sniffer(self.interface, filter) self.sniff.start() except KeyboardInterrupt: pass elif self.command == "pforensic": try: completer = None completer = Completer("pforensic") from modules.pforensic import PcapReader self.pcapread = PcapReader(self.file) self.pcapread.start() except KeyboardInterrupt: pass except TypeError: print "[!] You probably forgot to set the .pcap file" pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "xploit": try: completer = None completer = Completer("xploit") from modules.exploit import Exploit if self.targets is not None and self.input_list[1] == "tcp": self.xploit = Exploit(self.targets, self.input_list[1]) self.xploit.start() elif self.file is not None and self.input_list[1] == "stdin": self.xploit = Exploit(self.file, self.input_list[1]) self.xploit.start() else: print "[!] You need to set or stdin or tcp as argument." print "[!] You need to set or a file or a target to xploit." except IndexError: try: print "[*] Select one xploit mode, options = stdin/tcp" mode = raw_input("[+] Exploit mode: ") if mode == "stdin" or mode == "tcp": from modules.exploit import Exploit if self.targets is not None: self.xploit = Exploit(self.targets, mode) self.xploit.start() elif self.file is not None: self.xploit = Exploit(self.file, mode) self.xploit.start() else: print "[!] You need to set or a file or a target to xploit." else: print "[!] Select a valid xploit mode, stdin or tcp" except KeyboardInterrupt: pass except TypeError: print "[!] You probably forgot to set the file" pass except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.command == "cookiedecode": try: cookiedecode() except KeyboardInterrupt: pass except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "decode": try: print decode(self.input_list[1]) except KeyboardInterrupt: pass elif self.input_list[0] == "encode": try: print encode(self.input_list[1]) except KeyboardInterrupt: pass elif self.input_list[0] == "geoip": try: self.targets = self.input_list[1] from modules.geoip import Geoip path = "config/GeoLiteCity.dat" iptracker = Geoip(self.targets,path) except IndexError: if self.targets is not None: from modules.geoip import Geoip path = "config/GeoLiteCity.dat" iptracker = Geoip(self.targets,path) else: print "[!] You probably forgot to set a target" except Exception as e: print "[!] Exception caught: {}".format(e) pass elif self.input_list[0] == "brute": if self.input_list[1] == "ssh": try: username = raw_input("[+] Enter the username to bruteforce: ") from modules.ssh_bruter import SSHbrutus brutus = SSHbrutus(self.targets, username, self.file) brutus.start() except KeyboardInterrupt: brutus.stop() pass except TypeError: print "[!] You probably forgot to set the wordlist file path." pass elif self.input_list[1] == "url": try: url = 'url' from modules.web_bruter import WEBbrutus brutus = WEBbrutus(self.targets, self.file) brutus.start(url) except KeyboardInterrupt: brutus.stop(url) pass except TypeError: print "[!] You probably forgot to set the wordlist file path." pass elif self.input_list[1] == "form": try: form = 'form' from modules.web_bruter import WEBbrutus brutus = WEBbrutus(self.targets, self.file) brutus.start(form) except KeyboardInterrupt: brutus.stop(form) pass except TypeError: print "[!] You probably forgot to set the wordlist file path." pass else: print "[!] Select a valid type of brute-force type help to check." else: try: os.system("{}".format(self.command)) pass except Exception as e: print "[!] Select a valid option, type help to check syntax." pass except IndexError: pass except Exception as e: print "Exception caught: {}".format(e) except KeyboardInterrupt: print "\n[*] User requested shutdown." exit()
class UI(object): def __init__(self): super(UI, self).__init__() self.pepper = None self.stop_words = [] self.top_k = 5 # Initialize Jarvis self.jarvis = Jarvis(stop_words = self.stop_words) def run(self): try: while(True): cmd = "" args = [] raw = raw_input(">") try: cmd_and_args = raw.split() if len(cmd_and_args) == 0: continue cmd, args = (cmd_and_args[0], cmd_and_args[1:]) if cmd not in self.whiteListedMethods(): print "No command %s" % cmd cmd = "help" f = operator.methodcaller(cmd, *args) except ValueError: cmd = raw if cmd not in self.whiteListedMethods(): print "No command %s" % cmd cmd = "help" f = operator.methodcaller(cmd) try: f(self) except TypeError as e: # TODO print help doc string for method in cmd. print "Wrong arguments for %s" % cmd self.help(cmd) except (UIQuitException, EOFError, KeyboardInterrupt) as e: print return def help(self, cmd=None): """Print out helpful information about available commands @usage help [command] @param command, optional, if present it will output only the help text for that command; default is to print out all commands' help text. """ if cmd and str(cmd) in self.whiteListedMethods(): print "{}:".format(cmd) doc_string = getdoc(getattr(self, cmd)) if doc_string: help_text = doc_string.split('\n') for block in help_text: print '\t{:<60}'.format(block.strip()) else: # if a command was passed if cmd: print "No command: '%s'" % cmd for method in self.whiteListedMethods(): print "{}:".format(method) doc_string = getdoc(getattr(self, method)) if doc_string: help_text = doc_string.split('\n') for block in help_text: print '\t{:<60}'.format(block.strip()) def loadStopWords(self, stop_words_file_path): """Load the specified file of stop words @usage loadStopWords stop_words_file @param stop_words_file, required, the path to a file of stop words """ try: with open(stop_words_file_path, 'r') as stop_words_file: self.stop_words = [word.strip() for word in stop_words_file.readlines()] self.jarvis.stop_words = self.stop_words except IOError: print "No file found at '%s'" % stop_words_file_path def quit(self): """Exit the interactive session""" raise UIQuitException() def buildIndex(self, target_url=None, treat_as_root=False, limit=500): """Build or add to the Index. @usage buildIndex [target_url] [treat_as_root] [limit] @param target_url, optional, a full URL (e.g. http://www.smu.edu) default is http://lyle.smu.edu/~fmoore/ @param treat_as_root, optional signifier to treat the given URL as a root URL. e.g. treat a URL like, http://lyle.smu.edu/~fmoore/, as the root instead of the server instead of http://lyle.smu.edu/ @param limit, optional limit the underlying crawler to N requests """ # Use ~fmoore as the default target URL. if target_url is None: target_url = "http://lyle.smu.edu/~fmoore/" treat_as_root = True # Guard against invalid URLs. if not urlparse(target_url).scheme: print "Invalid URL: %s" % target_url print "HINT: Did you include the scheme? (e.g. http://)" return # Ensure boolean value safely treat_as_root = str(treat_as_root).lower() in ["yes", "y", "true", "t", "1"] # Ensure and force Integer value try: limit = int(limit) except ValueError: print "Invalid integer value for limit: '%s'" % limit print "Using 500 as default" limit = 500 # Start the run self.jarvis.run(target_url, treat_as_root, limit) # After the run, grab all the necessary objects and output some basic stats fe = self.jarvis.ironman index = self.jarvis.index parser = self.jarvis.parser calculator = self.jarvis.calculator documents = self.jarvis.documents() print "\033[95mCrawl Results\033[0m" for category, results in fe.report.iteritems(): print "\033[94m\t%s:\033[0m" % category for crawl in results: print"\t%s" % str(crawl) print # Print out number of unique documents encountered print "Encountered %i unique documents" % len(documents) print "Removed %i duplicates" % parser.num_duplicates print # Initialize Pepper to handle queries self.pepper = Pepper(documents, calculator, self.stop_words) def query(self, *user_query): """Run a query against the index @usage query query_word [more_query_words...] @param query_word, a string query of 1 or more words to search within the index. @example query foo bar hello world """ if self.pepper is None: print "Index has not been built! Run `buildIndex` first." return if len(user_query) == 0: print "No query given!" return else: user_query = " ".join(user_query) index = self.jarvis.index calculator = self.jarvis.calculator print "| {0:>15} | {1:>15} | {2:>15} | {3:>14} |".format("Term", "DF", "IDF", "F") for term in self.pepper.p.stemText(user_query, self.stop_words).encode('utf_8', 'ignore').split(): if not index.word_document_frequency.has_key(term): continue if not calculator.term_idfs.has_key(term): continue if not index.word_freq.has_key(term): continue df = index.word_document_frequency[term] idf = calculator.term_idfs[term] wf = index.word_freq[term] print "| {0:>15} | {1:>15d} | {2:>15f} | {3:>14d} |".format(term, df, idf, wf) print ranked_docs = self.pepper.handleQuery(user_query) i = 1 for score, doc in ranked_docs: if score == 0: break if i == 1: print "{0:>15} | {1:>15} | {2:>15} | {3:>14}".format("Rank", "Score", "Document", "ID") print "{0:>15} | {1:15f} | {2:15s} | {3:14s}".format(i, score, doc.url, doc.id) i += 1 if i > self.top_k: break print if i == 1: print "No results found for that query :(" else: if i < self.top_k: print "NOTE: Only outputted top {:d} documents, as all other "\ "documents had zero scores".format(i-1) top_doc = ranked_docs[0][1] print "First 20 words of top ranked document: %s" % top_doc.url print "%s..." % " ".join(top_doc.full_text.split()[0:20]) def setK(self, k=5): """Set the maximum number of K results to show in a query (default is 5) @usage setK [k] @param k, optional, an integer value representing the number of results to show from queries. If left blank, it is set to 5. """ # Ensure and force Integer value try: k = int(k) self.top_k = k except ValueError: print "Invalid integer value for k: '%s'" % k def showDoc(self, docID): """Show the document with the given ID @usage showDoc bef194481a024c4cf9178e5e421529b4 @param docID, required, the hash ID of the document (partials are matched, but may return multiples if not enough of the hash is given). """ id_re = re.compile(re.escape(docID)) matches = [] for doc in self.pepper.documents: if id_re.match(doc.id): matches.append(doc) if len(matches) > 0: if len(matches) != 1: print "Warning, more than one document found matching that id." for doc in matches: print "Document ID: {}".format(doc.id) print "Document URL: {}".format(doc.url) print "Word Frequencies:" pprint(doc.word_vector) print "Normalized Document Vector:" pprint(doc.normalized_tf) print doc.full_text else: print "No document found with ID = {}".format(docID) def whiteListedMethods(self): return ["help", "setK", "buildIndex", "query", "loadStopWords", "quit", "showDoc"] def completer(self, text, state): matches = [] p = re.compile(re.escape(text)) for m in self.whiteListedMethods(): if p.match(m): matches.append(m) try: return matches[state] except IndexError: return None
def run(mother): category = mother.categories['Study'] for page in category: oldtext = page.text() p = mwparserfromhell.parse(oldtext) template = study_template(p) if template: logging.debug( "Page {} has template {} with these params: {}".format( page.name, template.name.rstrip(), template.params)) try: jarvis_id = template.get("JARVIS ID").value.rstrip() except ValueError: # Skip JARVIS integration if there's no id logging.warning("No JARVIS ID on study page %s" % page.name) pass else: try: # Pull stuff out of JARVIS and put it into the template params j = Jarvis() logging.info("JARVIS id for %s is %s" % (page.name, jarvis_id)) irb_exp = j.irb_expirations(jarvis_id) if irb_exp: template.add("JARVIS IRB Expiration", irb_exp) quota = j.total_active_quota(jarvis_id) if quota: template.add("JARVIS Study Drive Quota", quota) # Personnel is a different section of the document, so replace that personnel = j.personnel(jarvis_id) old_sections = p.get_sections(matches="JARVIS Personnel") if len(old_sections) > 0: old_personnel = old_sections[0] p.replace(old_personnel, personnel) except Exception as e: # Print the error and keep going logging.error( f"Problem fetching from JARVIS on study page {page.name}: {traceback.print_exc()}" ) pass try: nih_id = template.get("NIH RePORTER ID").value.rstrip() except ValueError: # We just skip NIH integration if there's no id or we fail in any way logging.warning("No NIH ID on study page %s" % page.name) pass else: # award date, NIH start / end dates, break out official NIH title logging.info("NIH id for %s is %s" % (page.name, nih_id)) nih_url = "https://api.federalreporter.nih.gov/v1/Projects?nihApplId=" + nih_id resp = requests.get(nih_url) if resp.status_code != 200: logging.warning("GET {} {}".format(nih_url, resp.status_code)) else: data = resp.json() template.add("NIH Title", data['title']) template.add("NIH Fiscal Year", data['fy']) template.add("NIH Budget Start Date", jsondate_to_str(data['budgetStartDate'])) template.add("NIH Budget End Date", jsondate_to_str(data['budgetEndDate'])) template.add("NIH Project Start Date", jsondate_to_str(data['projectStartDate'])) template.add("NIH Project End Date", jsondate_to_str(data['projectEndDate'])) newtext = str(p) newtext = newtext.replace( "<noinclude>NOTE: This is prefab content inserted in new study pages</noinclude>", "") if oldtext.strip() != newtext.strip(): logging.warning("Updating study page %s, change detected", page.name) page.save( newtext, "Automated edit to update study values from JARVIS and NIH") else: logging.info("Not updating study page %s, text identical", page.name)
from jarvis import Jarvis jarvis_speech_assitant = Jarvis() jarvis_speech_assitant.get_user_name() jarvis_speech_assitant.vocal_assistant()
def __init__(self, gid=TEST_GROUP_ID): data = json.load(open("creds.json", 'r')) self.jarvis = Jarvis(data['id'], data['password'], gid)