def get_device(client: AdbClient):
"""
Gets the Android Device section from the user
:param client: adb client
:return: adb device object
"""
devices = client.devices()
done = False
device = None
# get device selection from the user
while not done:
if len(devices) == 0:
print("No Android Devices Found!")
exit(1)
print("Select a device:")
print("Choice\tSerial #")
ndx = 0
for device in devices:
print("%d\t\t%s" % (ndx, get_serial_number(device)))
choice = input("\nEnter Choice: ")
try:
device = devices[int(choice)]
done = True
except Exception as e:
print(e)
print("Invalid choice, please try again")
return device
def main():
try:
from adb.client import Client as AdbClient
import sys
if len(sys.argv) < 3:
print(
"Error: Syntax: Python logger.py filename [cache clear (Y/N)]")
apps = [
"com.android.chrome", "com.yandex.browser", "com.microsoft.emmx",
"org.mozilla.firefox"
]
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
isCacheClear = sys.argv[2]
for device in devices:
if isCacheClear == 'Y':
for app in apps:
clearAppFromCache(app, device)
clearLog(device)
saving_log = save_log(sys.argv[1])
time = 30
for i in apps:
open_app(i, time)
saving_log.wait()
except Exception as e:
print("Error in main!")
def __init__(self):
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
if len(devices) <= 0:
raise ValueError("No device connected")
self.device = client.device(str(devices[0].get_serial_no()))
self.settings = Settings("config.cfg")
self.adbscreen = ADBScreen(self.device)
def adb_connect(self):
try:
client = AdbClient(host="127.0.0.1", port=5037)
self.adb_device = client.devices()[0]
except Exception as e:
self.adb_device = ""
self.err = str(e)
return self.adb_device
def list_devices(host="127.0.0.1", port=5037):
client = AdbClient(host=host, port=port)
try:
client.version()
except RuntimeError:
# Can't connect to the adb server, try to start the adb server by command line.
Adb._start_adb_server()
return client.devices()
def get_devices():
adb = subprocess.Popen(
['adb', '-P', str(config['adb_port']), 'start-server'],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
client = AdbClient(host="127.0.0.1", port=config['adb_port'])
print(client)
devs = []
for d in client.devices():
devs.append(AndroidDevice(d))
return devs
def __init__(self):
print("program was starting")
# Default is "127.0.0.1" and 5037
try:
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
devices_packages = devices[0].shell("pm list packages")
get_all_files_from_device(devices[0], devices_packages)
except Exception as e:
print(e)
class getInstalledApps:
def __init__(self):
self.client = AdbClient(host="127.0.0.1", port=5037)
self.adb_device = self.client.devices()[0]
self.applist = []
self.apppath = []
self.asset = Assets()
def get_Applist(self):
self.ltemp = self.adb_device.shell("pm list packages ")
# if search_keword is none, print all lists out.
temp = self.ltemp.split("\n")
del temp[len(temp)-1]
self.applist = [x.split(":")[1] for x in temp]
#print (self.applist)
return self.applist
def get_Path(self, pkgid):
path_temp = self.adb_device.shell("pm path " + pkgid)
path = path_temp.split(":")[1].strip()
return path
def get_app(self, pkgid):
path = self.get_Path(pkgid)
tmp_path = os.path.join("./tmp/") + pkgid + '.apk'
data = self.adb_device.pull(path, tmp_path)
if self.asset.exist(pkgid) == False:
self.asset.add(pkgid, "", 0, "")
def get_SDKApps(self, pkgid):
apkpath = str(self.get_Path(pkgid))
apkfinal_path = str("tmp/" + pkgid + ".apk")
self.adb_device.pull(apkpath.strip("\n"), apkfinal_path)
cprint('[+] Checking AWS_SDK', 'blue')
s = os.popen('/usr/bin/grep -i "aws-android-sdk" {0}'.format(apkfinal_path)).read()
if 'matches' in s:
cprint ("[!] This Application use AWS_SDK", 'blue')
pass
else:
cprint ("[!] NO AWS_SDK FOUND", 'blue')
os.remove(apkfinal_path)
def is_AWSSDK(self, pkgid):
apkfinal_path = os.path.join("./tmp/") + pkgid + '.apk'
if re.search(b'(?i)aws-android-sdk', open(apkfinal_path,"rb").read()):
self.asset.exist_sdk(pkgid, True)
return True
else:
self.asset.exist_sdk(pkgid, False)
return False
def __init__(self, init=False):
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
if len(devices) <= 0:
raise ValueError("No device connected")
self.device = client.device(str(devices[0].get_serial_no()))
self.settings = Settings("config.cfg", init=init)
self.adbscreen = ADBScreen(self.device)
self.ENDC = '\033[0m'
self.WARNING = '\033[93m'
self.BLUE = '\033[94m'
self.RED = '\033[91m'
pytesseract.pytesseract.tesseract_cmd = self.settings.tesseract_dir
class PurpleScouter(object):
"""
Handles the main user loop.
"""
def __init__(self, adb_ip, adb_port, config):
"""
Starts the connection with the adb server.
"""
try:
self.__adb = AdbClient(host=adb_ip, port=adb_port)
self.__adb.devices()
except Exception:
with colored(colors.RED):
print "adb server isn't running, opening."
subprocess.Popen([config.get("adb", "adb_location"), "start-server"])
self.__config = config
def start(self):
"""
Starts the infinite loop.
"""
print "Welcome to:"
with colored(colors.PURPLE):
print "Purple Scouter!"
time.sleep(1)
while True:
devices = self.__adb.devices()
if devices:
with colored(colors.BLUE):
print "\nFound {len} connected devices!".format(len=len(devices))
for device in devices:
FilePuller(device, self.__config).move_all_scouting_files_from_phone()
animate_loading()
class AdbUtils:
def __init__(self, ip="127.0.0.1", port=5037):
subprocess.run(["adb", "devices"])
self.client = AdbClient(host=ip, port=port)
self.devices = []
def get_client_version(self):
return self.client.version()
def list_all_devices(self):
for device in self.client.devices():
self.devices.append(device.serial)
return self.devices
# Exemple "example.package"
def is_installed_apk(self, device, apk_package):
return device.is_installed(apk_package)
def install_apk(self, device, apk_path):
device.install(apk_path)
# Exemple "example.package"
def uninstall_apk(self, device, apk_package):
device.install(apk_package)
return self.is_installed_apk(device, apk_package)
def get_device_name(self, device):
model = device.shell("getprop ro.product.model")
manufacturer = device.shell("getprop ro.product.manufacturer")
full_name = manufacturer + " " + model
return full_name.replace("\n", "").replace("\r", "")
def _dump_logcat(connection):
while True:
data = connection.read(1024)
if not data:
break
print(data.decode('utf-8'))
connection.close()
def get_device_logcat(self, device):
return device.shell("logcat", handler=self._dump_logcat)
def get_screen_shot(self, device):
result = device.screencap()
with open(
datetime.datetime.now().replace(" ", "").replace(
"-", "").replace(":", "").replace(".", "") + ".png",
"wb") as fp:
fp.write(result)
def __init__(self, ini_name,init = False):
#Loading config.cfg
cparser = configparser.ConfigParser()
dirname = os.path.dirname(__file__)
ini_file = Path(os.path.join(dirname, "..\conf\\"+ini_name))
if ini_file.is_file():
cparser.read(ini_file)
else:
raise ValueError("Config file name not valid")
self.language = "DE"
#loads the config information
try:
self.language = cparser.get("custom", "language")
self.speed_multi = cparser.getfloat("custom", "speed_multi")
self.selected_raid = cparser.get("custom", "selected_raid")
self.round_robin_raids = eval(cparser.get("custom", "round_robin_raids"), {}, {})
self.round_robin = cparser.getboolean("custom", "round_robin")
self.tesseract_dir = cparser.get("custom", "tesseract_directory")
self.rounds = cparser.getint("custom", "rounds")
self.rounds_per_raid = cparser.getint("custom", "rounds_per_raid")
self.debug = cparser.getboolean("custom", "debug")
self.autodetect_buttons = cparser.get("screen", "autodeteckt_buttons")
self.taps_resultscreen = cparser.getint("custom", "taps_resultscreen")
self.auto_remove_pkmn = cparser.getboolean("custom", "auto_remove_pkmn")
except Exception as e:
raise ValueError("Couldn´t read config file")
try:
with open(os.path.join(dirname, '../conf/languages.json')) as json_file:
data = json.load(json_file)
self.language_pack = data[self.language]
except Exception:
raise ValueError("Language not found. Check your config file and update the languages.json")
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
if len(devices) <= 0:
raise ValueError("No device connected")
adbscreen = ADBScreen(client.device(str(devices[0].get_serial_no())))
if not init:
try:
with open(os.path.join(dirname, '../conf/screens/'+str(adbscreen.get_model_name()+".json"))) as json_file:
data = json.load(json_file)
self.screen = data
except Exception:
raise ValueError("Screenconfig not found. Start the python script with the --init argument to create a config.")
self.check_screen_values()
def get_devices():
for attempt in range(2):
try:
client = AdbClient(host="127.0.0.1", port=5037)
client.version() # a random call to check if adb server is up
except Exception as err:
print(str(err))
print("⚡ Starting ADB server...")
subprocess.run(["adb", "start-server"])
devices = client.devices()
if len(devices) == 0:
print("⚠️ no devices connected!")
return devices
class Clicking(PyKeyboardEvent):
def __init__(self, interval=0):
super(Clicking, self).__init__()
self.interval = interval
self.client = AdbClient(host="127.0.0.1", port=5037)
self.device = self.client.devices()[0]
self.x, self.y = None, None
def get_position(self):
def dump(connection):
while self.x is None or self.y is None:
data = connection.read(1024)
if not data:
break
for line in data.decode('utf-8').strip().split('\n'):
try:
line = line.split(' ')
if line[0] == '/dev/input/event1:':
if line[2] == '0035':
self.x = int(line[3], 16)
elif line[2] == '0036':
self.y = int(line[3], 16)
except Exception:
pass
connection.close()
print('Please tap your phone screen.')
self.device.shell('getevent', handler=dump)
print(self.x, self.y)
def click(self):
while CLICK_FLAG:
self.device.shell('input tap {} {}'.format(self.x, self.y))
sleep(self.interval)
def tap(self, keycode, character, press):
global CLICK_FLAG
if keycode == 74:
if press:
print('Start clicking!')
CLICK_FLAG = True
Thread(target=self.click).start()
elif keycode == 75:
if press:
print('Stop clicking!')
CLICK_FLAG = False
def get(self):
from adb.client import Client as AdbClient
client = AdbClient()
devices = client.devices()
ret = {"success": True, "devices": []}
if not devices:
self.write({"success": False})
return
for device in devices:
data = {}
data["serial"] = device.serial
data["status"] = device.get_state()
if device.shell("getprop ro.arch").strip() == "x86":
data["emulator"] = True
else:
data["emulator"] = False
ret["devices"].append(data)
self.write(ret)
def get(self):
from uiautomator2.__main__ import _init_with_serial
from uiautomator2.version import __apk_version__, __atx_agent_version__
print("start...")
from adb.client import Client as AdbClient
client = AdbClient()
devices = client.devices()
for d in devices:
print(d.serial)
if not devices:
self.write({
"success": False,
"serial": "",
"deviceId": "",
})
return
for d in devices:
serial = d.get_serial_no()
if d.get_state() != 'device':
print("Skip invalid device: %s %s", serial, d.get_state())
continue
print("Init device %s", serial)
# todo:初始化代码优化
try:
device = _AndroidDevice(serial)
except BaseException:
_init_with_serial(serial=serial,
apk_version=__apk_version__,
agent_version=__atx_agent_version__,
server=None,
reinstall=False)
device = _AndroidDevice(serial)
# serial = device._d.wlan_ip + ":7912"
id = str(uuid.uuid4())
cached_devices[id] = device
socket_url = device._d._host + ":" + str(device._d._port)
self.write({
"success": True,
"serial": serial,
"deviceId": id,
"socket_url": socket_url
})
return
from adb.client import Client as AdbClient # Adb client that allows adb in python
import sys # Allows access to system.
import os # Operating system access
import datetime # Gets the date and the time
import time # Imports the system time
import csv
os.system(
'adb start-server'
) # Automatically starts the adb server if it is not already running.
client = AdbClient(
host="127.0.0.1",
port=5037) # Opens the adb gateway. Default is "127.0.0.1" and 5037
devices = client.devices(
) # This calls adb devices to see all the devices connected
watch_count = 2 # Number of watch given to each individual
origin = None # Initializes the origin variable
destination = None # Initializes the destination variable
downloadtime = None # Initializes the download time variable
previousrun = None # Initializes the previous run variable
patient_1_time = "Never" # Initializes the patient-1 variable
patient_2_time = "Never" # Initializes the patient-2 variable
caregiver_1_time = "Never" # Initializes the caregiver-1 variable
caregiver_2_time = "Never" # Initializes the caregiver-2 variable
# ----------------------------------------------------------------------SET-UP----------------------------------------------------------------------- #
Deployment_Identification = "P2D3" # Name of the deployment
Watch_Main_Directory = "BESI-C" # Name of the folder directory where all the data is stored on the watch
class Adb(object):
def __init__(self, serial=None, host="127.0.0.1", port=5037):
self._serial = serial
self._client = AdbClient(host=host, port=port)
try:
self._client.version()
except RuntimeError:
# Can't connect to the adb server, try to start the adb server by command line.
self._start_adb_server()
if self._serial:
self._device = self._client.device(serial)
else:
# The serial can be None only when there is only one device/emulator.
devices = self._client.devices()
if len(devices) == 0:
raise RuntimeError("Can't find any android device/emulator")
elif len(devices) > 1:
raise RuntimeError(
"more than one device/emulator, please specify the serial number"
)
else:
device = devices[0]
self._serial = device.get_serial_no()
self._device = device
@staticmethod
def list_devices(host="127.0.0.1", port=5037):
client = AdbClient(host=host, port=port)
try:
client.version()
except RuntimeError:
# Can't connect to the adb server, try to start the adb server by command line.
Adb._start_adb_server()
return client.devices()
@staticmethod
def _start_adb_server():
adb_path = whichcraft.which("adb")
if adb_path is None:
raise EnvironmentError(
"Can't find the adb, please install adb on your PC")
cmd = [adb_path, "start-server"]
cmdline = subprocess.list2cmdline(cmd)
try:
return subprocess.check_output(cmdline,
stderr=subprocess.STDOUT,
shell=True).decode('utf-8')
except subprocess.CalledProcessError as e:
raise EnvironmentError("subprocess", cmdline,
e.output.decode('utf-8', errors='ignore'))
def devices(self, states=['device', 'offline']):
"""
Returns:
[($serial1, "device"), ($serial2, "offline")]
"""
# TODO: not really checking anything
return [(d, "device") for d in self.list_devices()]
output = subprocess.check_output([self.adb_path(), 'devices'])
pattern = re.compile(r'(?P<serial>[^\s]+)\t(?P<status>device|offline)')
matches = pattern.findall(output.decode())
return [(m[0], m[1]) for m in matches]
@property
def serial(self):
return self._serial
def forward(self, local, remote, rebind=True):
if isinstance(local, int):
local = 'tcp:%d' % local
if isinstance(remote, int):
remote = 'tcp:%d' % remote
return self._device.forward(local, remote, norebind=not rebind)
def forward_list(self):
"""
Only return tcp:<int> format forwards
Returns:
{
"{RemotePort}": "{LocalPort}"
}
"""
forward_list = self._device.list_forward()
ret = {}
for local, remote in forward_list.items():
ltype, lport = local.split(":")
rtype, rport = remote.split(":")
if ltype == "tcp" and rtype == "tcp":
ret[int(rport)] = int(lport)
return ret
def forward_port(self, remote_port):
forwards = self.forward_list()
lport = forwards.get(remote_port)
if lport:
return lport
free_port = find_free_port()
self.forward(free_port, remote_port)
return free_port
def shell(self, *args, **kwargs):
return self._device.shell(" ".join(args))
def getprop(self, prop):
return self.shell('getprop', prop).strip()
def push(self, src, dst, mode=0o644):
self._device.push(src, dst, mode=mode)
def install(self, apk_path):
sdk = self.getprop('ro.build.version.sdk')
if int(sdk) <= 23:
self._device.install(apk_path, reinstall=True, downgrade=True)
return
try:
# some device is missing -g
self._device.install(apk_path,
reinstall=True,
downgrade=True,
grand_all_permissions=True)
except InstallError:
self._device.install(apk_path, reinstall=True, downgrade=True)
def uninstall(self, pkg_name):
return self._device.uninstall(pkg_name)
def package_info(self, pkg_name):
output = self.shell('dumpsys', 'package', pkg_name)
m = re.compile(r'versionName=(?P<name>[\d.]+)').search(output)
version_name = m.group('name') if m else None
m = re.search(r'PackageSignatures\{(.*?)\}', output)
signature = m.group(1) if m else None
if version_name is None and signature is None:
return None
return dict(version_name=version_name, signature=signature)
import io
import time
from PIL import Image
from screenshot.screencapture import screenshot_window
from adb.client import Client as AdbClient
file = '/tmp/player_shoot.png'
# not so good
def screenshoot():
screenshot_window("player", filename='/tmp/player_shoot.png')
player = Image.open('/tmp/player_shoot.png')
player = player.crop((84, 112, 1044, 1713))
player.thumbnail((480,800), Image.ANTIALIAS)
return player
def screencap(device):
return Image.open(io.BytesIO(device.screencap()))
if __name__ == '__main__':
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
print(devices)
device = devices[0]
while True:
s = time.time()
screencap(device)
print(time.time() - s)
def devices():
client = AdbClient(host='127.0.0.1',
port=5037) # TODO(ssx): should get HOST from env
return client.devices()
def main():
phone = None
source_device = None
sdk = AndroidSDK()
parser = argparse.ArgumentParser(prog="WhatsDump")
parser.add_argument(
"--install-sdk",
action="store_true",
help="Download & extract latest Android SDK emulator packages")
parser.add_argument("--msgstore",
help="Location of msgstore database to decrypt")
parser.add_argument(
"--wa-phone",
help=
"WhatsApp phone number associated with msgstore database from which "
"you will receive verification SMS (with prefix, ex. +393387182291)")
parser.add_argument("--wa-verify",
choices=["sms", "call"],
help="Phone verification method to use")
parser.add_argument("--verbose",
action="store_true",
help="Show verbose (debug) output")
parser.add_argument("--show-emulator",
action="store_true",
help="Show emulator screen (by default headless)")
parser.add_argument(
"--no-accel",
action="store_true",
help="Disable hardware acceleration (very slow emulator!)")
args = parser.parse_args()
print("""
_ _ _ _ ______
| | | | | | | | _ \
| | | | |__ __ _| |_ ___| | | |_ _ _ __ ___ _ __
| |/\| | '_ \ / _` | __/ __| | | | | | | '_ ` _ \| '_ \
\ /\ / | | | (_| | |_\__ \ |/ /| |_| | | | | | | |_) |
\/ \/|_| |_|\__,_|\__|___/___/ \__,_|_| |_| |_| .__/
| |
|_|
v0.2 beta
""")
# Setup logging
logging.basicConfig(
format=
"%(asctime)s - %(levelname)s - %(name)s - [%(funcName)s]: %(message)s",
datefmt="%d/%m/%Y %H:%M:%S",
stream=sys.stdout)
logger.setLevel(logging.DEBUG if args.verbose else logging.INFO)
# TODO: CHECK IF JAVA IS INSTALLED
# SDK Checks
is_avd_installed = sdk.is_avd_installed()
if args.install_sdk:
if is_avd_installed:
logger.error(
"WhatsDump AVD already installed! Remove android-sdk/ directory to reinstall Android SDK"
)
sys.exit(1)
# download&install
if not sdk.install():
logger.error("Failed to install Android SDK")
sys.exit(1)
logger.info("\nAndroid AVD successfully installed")
sys.exit(0)
else:
if not is_avd_installed:
logger.error(
"Cannot find WhatsDump AVD; install Android SDK and emulator packages with --install-sdk"
)
sys.exit(1)
# Connect / Start ADB server
adb_client = AdbClient()
try:
logger.info("Connected to ADB (version %d) @ 127.0.0.1:5037" %
adb_client.version())
except:
logger.info("Attempting to start ADB server...")
if sdk.start_adb():
logger.info("ADB server started successfully")
adb_client = AdbClient()
logger.info("Connected to ADB (version %d) @ 127.0.0.1:5037" %
adb_client.version())
else:
logger.error("Could not connect/start ADB server")
sys.exit(1)
# Require msgstore or connected device
if args.msgstore:
# Check if file exists
if not os.path.isfile(args.msgstore):
logger.error(
"Msgstore location is not valid (file does not exist)")
sys.exit(1)
else:
logger.info(
"Msgstore location not provided, attempting to find connected devices with ADB...\n"
)
devices = adb_client.devices()
i = 0
# If no devices and no msgstore, quit
if len(devices) == 0:
logger.error("Cannot find any connected devices")
sys.exit(1)
# Show all devices
for device in devices:
print("\t[%d] %s (%s)" %
(i, device.serial,
device.shell("getprop ro.product.name").rstrip()))
i += 1
print("\n")
while source_device is None:
dev_index = int(
input(
"\n>> Which device number you want to extract msgstore from?: "
))
if dev_index < 0 or dev_index + 1 > len(devices):
continue
source_device = devices[dev_index]
print("\n")
# Validate required phone
if not args.wa_phone:
logger.error(
"Please provide the phone number associated with msgstore")
sys.exit(1)
else:
# Add "+" if not given
if args.wa_phone[0] != "+":
args.wa_phone = "+" + args.wa_phone
try:
phone = phonenumbers.parse(args.wa_phone)
except NumberParseException:
pass
if not phone:
logger.error("Provided phone number is NOT valid")
sys.exit(1)
if not args.wa_verify:
logger.error("Please provide a WhatsApp verification method")
sys.exit(1)
# recap
if source_device:
logger.info("Extract WhatsApp database from device >> %s",
source_device.serial)
else:
logger.info("Using msgstore database from path: %s", args.msgstore)
logger.info("Using WhatsApp phone number: +%d %d", phone.country_code,
phone.national_number)
logger.info("Using WhatsApp verification method: %s",
args.wa_verify.upper())
# yn = input("\n>> Continue? (y/n): ")
# if yn != 'y':
# sys.exit(0)
# create phone directory tree where to store results
dst_path = os.path.join(os.path.abspath("output"),
str(phone.national_number))
if not os.path.exists(dst_path):
try:
os.makedirs(dst_path)
except OSError:
logging.error("Cannot create output directory tree")
sys.exit(1)
log_formatter = logging.Formatter(
"%(asctime)s - %(levelname)s - %(name)s - [%(funcName)s]: %(message)s",
datefmt="%d/%m/%Y %H:%M:%S")
file_handler = logging.FileHandler(os.path.join(dst_path, "log.txt"))
file_handler.setFormatter(log_formatter)
logger.addHandler(file_handler)
# Extract msgstore.db from source device, if any
msgstore_path = args.msgstore
if msgstore_path:
logger.info("Provided msgstore.db SHA-256 hash: %s",
sha256(args.msgstore))
if source_device:
logger.info(
"Extracting msgstore.db.crypt from phone to output/%ld/ ..." %
phone.national_number)
wa = WhatsApp(source_device)
msgstore_path = wa.extract_msgstore(dst_path)
if not msgstore_path:
logger.error(
"Could not find/extract msgstore database from device (is WhatsApp installed?)"
)
sys.exit(1)
logger.info("Extracted msgstore.db SHA-256 hash: %s",
sha256(msgstore_path))
# Start emulator and connect to it
logger.info("Starting emulator...")
if args.no_accel:
logger.warn(
"Hardware acceleration disabled! Device might be very slow")
emulator_device = sdk.start_emulator(adb_client, args.show_emulator,
args.no_accel)
if not emulator_device:
logger.error("Could not start emulator!")
sys.exit(1)
if args.show_emulator:
logger.info("Do not interact with the emulator!")
logger.info(
"Trying to register phone on emulator... (may take few minutes)")
# Attempt to register phone using provided msgstore
wa_emu = WhatsApp(emulator_device)
sdk.adb_root() # Allowing adb as root
time.sleep(10)
try:
wa_emu.register_phone(msgstore_path, phone.country_code,
phone.national_number)
# Verify by call or SMS
if args.wa_verify == "sms":
logger.info("You should receive a SMS by WhatsApp soon")
wa_emu._verify_by_sms(wa_code_callback)
else:
logger.info("You should receive a call by WhatsApp soon")
wa_emu._verify_by_call(wa_code_callback)
wa_emu.complete_registration(phone.country_code, phone.national_number)
except WaException as e:
logger.info("Exception in verification: %s", e.reason)
code.interact(local=locals())
sys.exit(1)
logger.info("Phone registered successfully!")
logger.info("Extracting key...")
# Extract private key
if not wa_emu.extract_priv_key(dst_path):
logger.error("Could not extract private key!")
sys.exit(1)
logger.info("Private key extracted in %s", os.path.join(dst_path, "key"))
class ADBConnect(object):
def __init__(self, args):
self._args = args
self._useadb = args.use_adb
self._client = None
if self._useadb:
try:
from adb.client import Client as AdbClient
except ImportError:
pass
self.check_adblib = 'adb.client' in sys.modules
if not self.check_adblib:
logger.warning(
"Could not find pure-python-adb library - no support for ADB."
"If you have no idea what ADB is or not planning to use it - IGNORE :)"
)
self._useadb = False
else:
self._client = AdbClient(
host=self._args.adb_server_ip, port=self._args.adb_server_port)
def check_adb_status(self, adb):
if not self._useadb:
return None
try:
if self._client.device(adb) is not None:
self._client.device(adb).shell('echo checkadb')
return True
except RuntimeError as e:
logger.exception(
'MADmin: Exception occurred while checking adb status ({}).', str(adb))
return None
def return_adb_devices(self):
if not self._useadb:
return []
try:
return self._client.devices()
except Exception as e:
logger.exception(
'MADmin: Exception occurred while getting adb clients: {}.', e)
return []
def send_shell_command(self, adb, origin, command):
try:
device = self._client.device(adb)
if device is not None:
logger.info(
'MADmin: Using ADB shell command ({})', str(origin))
device.shell(command)
return True
except Exception as e:
logger.exception(
'MADmin: Exception occurred while sending shell command ({}): {}.', str(origin), e)
return False
def make_screenshot(self, adb, origin, extenstion):
try:
device = self._client.device(adb)
if device is not None:
logger.info('MADmin: Using ADB ({})', str(origin))
result = device.screencap()
# TODO: adjust with devicesettings
with open(os.path.join(self._args.temp_path, 'screenshot_%s.png' % str(origin)), "wb") as fp:
fp.write(result)
if extenstion == "jpg":
pngtojpg(os.path.join(self._args.temp_path, 'screenshot_%s.png' % str(origin)))
return True
except Exception as e:
logger.exception(
'MADmin: Exception occurred while making screenshot ({}): {}.', str(origin), e)
return False
def make_screenclick(self, adb, origin, x, y):
try:
device = self._client.device(adb)
if device is not None:
device.shell("input tap " + str(x) + " " + str(y))
logger.info('MADMin ADB Click x:{} y:{} ({})',
str(x), str(y), str(origin))
time.sleep(1)
return True
except Exception as e:
logger.exception(
'MADmin: Exception occurred while making screenclick ({}): {}.', str(origin), e)
return False
def make_screenswipe(self, adb, origin, x, y, xe, ye):
try:
device = self._client.device(adb)
if device is not None:
device.shell("input swipe " + str(x) + " " +
str(y) + " " + str(xe) + " " + str(ye) + " 100")
logger.info('MADMin ADB Swipe x:{} y:{} xe:{} ye:{}({})', str(
x), str(y), str(xe), str(ye), str(origin))
time.sleep(1)
return True
except Exception as e:
logger.exception(
'MADmin: Exception occurred while making screenswipe ({}): {}.', str(origin), e)
return False
def connectAndGetDevices():
# Connect to devices Default is "127.0.0.1" and 5037
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
return devices
def __init__(self):
c = Client()
self.device = c.devices()[0]
self.pkgs = []
def main():
phone = None
source_device = None
sdk = AndroidSDK()
parser = argparse.ArgumentParser(prog='WhatsDump')
parser.add_argument(
'--install-sdk',
action='store_true',
help='Download & extract latest Android SDK emulator packages')
parser.add_argument('--msgstore',
help='Location of msgstore database to decrypt')
parser.add_argument(
'--wa-phone',
help=
'WhatsApp phone number associated with msgstore database from which '
'you will receive verification SMS (with prefix, ex. +393387182291)')
parser.add_argument('--wa-verify',
choices=['sms', 'call'],
help='Phone verification method to use')
parser.add_argument('--verbose',
action='store_true',
help='Show verbose (debug) output')
parser.add_argument('--show-emulator',
action='store_true',
help='Show emulator screen (by default headless)')
parser.add_argument(
'--no-accel',
action='store_true',
help='Disable hardware acceleration (very slow emulator!)')
args = parser.parse_args()
print('''
_ _ _ _ ______
| | | | | | | | _ \
| | | | |__ __ _| |_ ___| | | |_ _ _ __ ___ _ __
| |/\| | '_ \ / _` | __/ __| | | | | | | '_ ` _ \| '_ \
\ /\ / | | | (_| | |_\__ \ |/ /| |_| | | | | | | |_) |
\/ \/|_| |_|\__,_|\__|___/___/ \__,_|_| |_| |_| .__/
| |
|_|
v0.1 beta
''')
# Setup logging
logging.basicConfig(format='[%(levelname)s] %(message)s',
stream=sys.stdout)
logger.setLevel(logging.DEBUG if args.verbose else logging.INFO)
# TODO: CHECK IF JAVA IS INSTALLED
# SDK Checks
is_avd_installed = sdk.is_avd_installed()
if args.install_sdk:
if is_avd_installed:
logger.error(
"WhatsDump AVD already installed! Remove android-sdk/ directory to reinstall Android SDK"
)
exit(1)
# download&install
if not sdk.install():
logger.error('Failed to install Android SDK')
exit(1)
logger.info('\nAndroid AVD successfully installed')
exit(0)
else:
if not is_avd_installed:
logger.error(
"Cannot find WhatsDump AVD; install Android SDK and emulator packages with --install-sdk"
)
exit(1)
# Connect / Start ADB server
adb_client = AdbClient()
try:
logger.info("Connected to ADB (version %d) @ 127.0.0.1:5037" %
adb_client.version())
except:
logger.info("Attempting to start ADB server...")
if sdk.start_adb():
logger.info("ADB server started successfully")
adb_client = AdbClient()
logger.info("Connected to ADB (version %d) @ 127.0.0.1:5037" %
adb_client.version())
else:
logger.error('Could not connect/start ADB server')
exit(1)
# Require msgstore or connected device
if args.msgstore:
# Check if file exists
if not os.path.isfile(args.msgstore):
logger.error(
"Msgstore location is not valid (file does not exist)")
exit(1)
else:
logger.info(
"Msgstore location not provided, attempting to find connected devices with ADB...\n"
)
devices = adb_client.devices()
i = 0
# If no devices and no msgstore, quit
if len(devices) == 0:
logger.error("Cannot find any connected devices")
exit(1)
# Show all devices
for device in devices:
print("\t[%d] %s (%s)" %
(i, device.serial,
device.shell('getprop ro.product.name').rstrip()))
i += 1
print('\n')
while source_device is None:
dev_index = int(
raw_input(
"\n>> Which device number you want to extract msgstore from?: "
))
if dev_index < 0 or dev_index + 1 > len(devices):
continue
source_device = devices[dev_index]
print('\n')
# Validate required phone
if not args.wa_phone:
logger.error(
"Please provide the phone number associated with msgstore")
exit(1)
else:
# Add "+" if not given
if args.wa_phone[0] != '+':
args.wa_phone = '+' + args.wa_phone
try:
phone = phonenumbers.parse(args.wa_phone)
except NumberParseException:
pass
if not phone:
logger.error("Provided phone number is NOT valid")
exit(1)
if not args.wa_verify:
logger.error("Please provide a WhatsApp verification method")
exit(1)
# recap
if source_device:
logger.info('Extract WhatsApp database from device >> %s',
source_device.serial)
else:
logger.info('Using msgstore database from path: %s', args.msgstore)
logger.info('Using WhatsApp phone number: +%d %d', phone.country_code,
phone.national_number)
logger.info('Using WhatsApp verification method: %s',
args.wa_verify.upper())
yn = raw_input("\n>> Continue? (y/n): ")
if yn != 'y':
exit(0)
# create phone directory tree where to store results
dst_path = os.path.join(os.path.abspath('output'),
str(phone.national_number))
if not os.path.exists(dst_path):
try:
os.makedirs(dst_path)
except OSError:
logging.error('Cannot create output directory tree')
exit(1)
log_formatter = logging.Formatter(
"%(asctime)s - [%(levelname)s]: %(message)s")
file_handler = logging.FileHandler(os.path.join(dst_path, 'log.txt'))
file_handler.setFormatter(log_formatter)
logger.addHandler(file_handler)
# Extract msgstore.db from source device, if any
msgstore_path = args.msgstore
if msgstore_path:
logger.info('Provided msgstore.db SHA-256 hash: %s',
sha256(args.msgstore))
if source_device:
logger.info(
'Extracting msgstore.db.crypt from phone to output/%ld/ ...' %
phone.national_number)
wa = WhatsApp(source_device)
msgstore_path = wa.extract_msgstore(dst_path)
if not msgstore_path:
logger.error(
'Could not find/extract msgstore database from device (is WhatsApp installed?)'
)
exit(1)
logger.info('Extracted msgstore.db SHA-256 hash: %s',
sha256(msgstore_path))
# Start emulator and connect to it
logger.info('Starting emulator...')
if args.no_accel:
logger.warn(
'Hardware acceleration disabled! Device might be very slow')
emulator_device = sdk.start_emulator(adb_client, args.show_emulator,
args.no_accel)
if not emulator_device:
logger.error('Could not start emulator!')
exit(1)
if args.show_emulator:
logger.info('Do not interact with the emulator!')
logger.info(
'Trying to register phone on emulator... (may take few minutes)')
# Attempt to register phone using provided msgstore
wa_emu = WhatsApp(emulator_device)
try:
wa_emu.register_phone(msgstore_path, phone.country_code,
phone.national_number, args.wa_verify,
wa_code_callback)
except WaException, e:
logger.error('Exception in verification: %s', e.reason)
exit(1)
import logging
import os
import time
from io import BytesIO
import numpy as np
from PIL import Image
from adb.client import Client as AdbClient
client = AdbClient(host="127.0.0.1", port=5037)
device = client.devices()[0]
baseline = {}
SCREEN_PATH = 'screen.png'
hero_anchor = (10, 134, 5)
MODE = "COIN"
tap_cords = {
'restart': (1000, 635, 1170, 690),
'continue': (560, 630, 720, 657),
'start': (880, 555, 1035, 611),
'skip0': (1190, 12, 1260, 45),
'skip1': (1190, 12, 1260, 45),
'exit': (
1153,
43,
1264,
class Executer:
def __init__(self):
self.client = AdbClient(host="127.0.0.1", port=5037)
def load_devices(self, only_number=False):
try:
adb_devices = self.client.devices()
# details not needed, we only need the number of connecting devices
if only_number:
return [device.get_serial_no() for device in adb_devices]
devices = []
for dev in adb_devices:
# adb shell getprop ro.boot.serialno
# adb shell getprop ro.build.version.release
# adb shell getprop ro.build.version.sdk
# adb shell getprop ro.build.version.security_patch
# adb shell getprop ro.debuggable
# adb shell getprop ro.product.cpu.abi
# adb shell getprop ro.product.model
# adb shell getprop ro.secure
# pure-python-adb supplies device.get_properties()
# props_str = str(dev.shell("getprop"))
# trantab = props_str.maketrans('', '', '[] \r')
# props_list = props_str.translate(trantab).split('\n')
# props_list = [props for props in props_list if props != '']
# keys = [props.split(':')[0] for props in props_list]
# values = [props.split(':')[1] for props in props_list]
# props = dict(zip(keys, values))
props = dev.get_properties()
# adb shell cat /proc/version
proc_version = str(dev.shell("cat /proc/version")).strip()
name = dev.get_serial_no()
# adb shell getenforce
enforce = str(dev.shell("getenforce")).strip()
device = Device(name=name,
model=props.get('ro.product.model', ''),
sdk=props.get('ro.build.version.sdk', ''),
security_patch=props.get(
'ro.build.version.security_patch', ''),
release=props.get('ro.build.version.release',
''),
debuggable=props.get('ro.debuggable', ''),
abi=props.get('ro.product.cpu.abi', ''),
proc_version=proc_version,
secure=props.get('ro.secure', ''),
enforce=enforce)
devices.append(device)
return devices
except BaseException as e:
utils.nl_print(e)
def exec_poc(self, device_name, binary):
device = self.client.device(device_name)
dst = consts.DEVICE_TMP + binary.split('/')[-1]
device.push(binary, dst)
device.shell("chmod 777 %s" % dst)
# run poc on device
res = str(
device.shell("cd %s; %s &>/dev/null; echo $?" %
(consts.DEVICE_TMP, dst))).strip()
return res
import subprocess
from .noti import *
from adb.client import Client as AdbClient
from pathlib import Path
# More Better Solution...?
client = AdbClient(host='127.0.0.1', port=5037)
if Path.is_dir(Path.cwd() / 'backup') is False:
Path.mkdir(Path.cwd() / 'backup')
try:
list_device = client.devices()
except RuntimeError:
err_printer('adb_not')
subprocess.run(['adb', 'start-server'])
list_device = client.devices()
