def kernel_version():
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device(options.device)
result = device.shell("uname -r")
#result = result.encode('ascii','ignore')
logging.info(" kernel_version() : result is %s", result)
result = result.split(".")
ver = result[0] + '.' + result[1]
ver = float(ver)
offset_selinux = []
# case kernel version is <= 3.10
if ver <= 3.10:
offset_to_comm = 0x288
offset_to_parent = 0xe0
offset_selinux.append(0xC0A77548)
offset_selinux.append(0xC0A7754C)
offset_selinux.append(0xC0A77550)
ps_cmd = "ps"
# case kernel version is > 3.10 et <=3.18
elif ver > 3.10 and ver <= 3.18:
offset_to_comm = 0x444
offset_to_parent = 0xe0
offset_selinux.append(0xC0C4F288)
offset_selinux.append(0xC0C4F28C)
offset_selinux.append(0XC0C4F280)
ps_cmd = "ps -A"
else:
logging.info("Sorry. Android kernel version %s not supported yet", ver)
raise NotImplementedError(
"Sorry. Android kernel version %s not supported yet", ver)
return ver, offset_to_comm, offset_to_parent, offset_selinux, ps_cmd
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 __init__(self):
# Default is "127.0.0.1" and 5037
client = AdbClient(host="127.0.0.1", port=5037)
self.device = client.device("ZY2239Q9MP")
self.GREEN = '\033[92m'
self.BLUE = '\033[94m'
self.YELLOW = '\033[93m'
self.RED = '\033[91m'
self.ENDC = '\033[0m'
def setConfig(cfg):
global config_dict, movementCount, client, device
config_dict = cfg
print(config_dict)
movementCount = random.choice(
range(config_dict["movement"]["stepsMin"],
config_dict["movement"]["stepsMax"], 1))
client = AdbClient(host=config_dict["device"]["host"],
port=config_dict["device"]["port"])
device = client.device(config_dict["device"]["name"])
def check_process_is_running(process):
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device("emulator-5554")
ps = device.shell("ps")
if process in ps:
logging.debug("[+] OK. %s is running" %(process))
else:
logging.debug("[+] NOK. It seems like %s is not running..." %(process))
logging.debug("[+] Android_Emuroot stopped")
exit(1)
def check_process_is_running(process, pscmd, device):
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device(device)
ps = device.shell(pscmd)
if process in ps:
logging.info("[+] OK. %s is running" % (process))
else:
logging.info("[+] NOK. It seems like %s is not running..." % (process))
logging.info("[+] Android_Emuroot stopped")
exit(1)
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
def screenshot(deviceAddress='ce031713383080fa0c',
destFolder='screenshot',
imageName="ADBScreenshot.png"):
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device(deviceAddress)
result = device.screencap()
try:
with open(destFolder + "/" + imageName, "wb") as fp:
fp.write(result)
except FileNotFoundError:
print("could not file file or folder")
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 adb_stager_process(load, devicename):
'''
Adb connexion
TODO specify the device id
'''
logging.info("[+] Launch the stager process")
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device(devicename)
device.shell("echo " + load + " > /data/local/tmp/load.sh")
device.shell("chmod +x /data/local/tmp/load.sh")
device.shell("ln -s /system/bin/sh /data/local/tmp/STAGER")
# Launch STAGER shell
device.shell("/data/local/tmp/STAGER /data/local/tmp/load.sh")
def check_process_is_running(process, pscmd, devicename):
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device(devicename)
if device == None:
logging.warning(
"Device name %s invalid. Check \"adb devices\" to get valid ones",
device)
raise Exception(
"Device name invalid. Check \"adb devices\" to get valid ones")
ps = device.shell(pscmd)
if process in ps:
logging.warning("[+] OK. %s is running" % (process))
else:
logging.warning("[+] NOK. It seems like %s is not running..." %
(process))
logging.warning("[+] Android_Emuroot stopped")
exit(1)
def kernel_version():
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device(options.device)
if device == None:
logging.warning(
"Device name %s invalid. Check \"adb devices\" to get valid ones",
options.device)
raise Exception(
"Device name invalid. Check \"adb devices\" to get valid ones")
result = device.shell("uname -r")
#result = result.encode('ascii','ignore')
logging.debug(" kernel_version() : %s", result)
result = result.split(".")
ver = result[0] + '.' + result[1]
ver = float(ver)
offset_selinux = []
# case kernel version is <= 3.10
if ver <= 3.10:
offset_to_comm = 0x288
offset_to_parent = 0xe0
offset_selinux.append(0xC0A77548)
offset_selinux.append(0xC0A7754C)
offset_selinux.append(0xC0A77550)
ps_cmd = "ps"
# case kernel version is > 3.10 et <=3.18
elif ver > 3.10 and ver <= 3.18:
offset_to_comm = 0x444
offset_to_parent = 0xe0
offset_selinux.append(0xC0C4F288)
offset_selinux.append(0xC0C4F28C)
offset_selinux.append(0XC0C4F280)
ps_cmd = "ps -A"
else:
logging.warning("Sorry. Android kernel version %s not supported yet",
str(ver))
raise NotImplementedError(
"Sorry. Android kernel version not supported yet")
return ver, offset_to_comm, offset_to_parent, offset_selinux, ps_cmd
def kernel_version():
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device("emulator-5554")
result = device.shell("uname -r")
result = result.encode('ascii','ignore')
logging.debug(" kernel_version() : result is %s", result)
result = result.split('.')
ver = result[0]+'.'+result[1]
ver = float(ver)
# case kernel version is <= 3.10
if ver <= 3.10 :
offset_to_comm = 0x288
offset_to_parent = 0xe0
# case kernel version is > 3.10 et <=3.18
elif ver > 3.10 and ver <= 3.18 :
offset_to_comm = 0x444
offset_to_parent = 0xe0
else :
logging.debug("Sorry. Android kernel version %s not supported yet", ver)
raise NotImplementedError("Sorry. Android kernel version %s not supported yet", ver)
return ver,offset_to_comm,offset_to_parent
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)
def record_event(device, filepath, timeout=5):
global event, cmd
event = ""
cmd = ""
signal.alarm(timeout)
try:
k = device.shell("getevent /dev/input/event1", handler=event_handler)
except:
pass
print("Event recorded")
# print(event)
generate_cmd()
# print(cmd)
write_cmd(filepath)
signal.signal(signal.SIGALRM, handler=sig_handler)
if __name__ == "__main__":
client = AdbClient(host="127.0.0.1", port=5037)
print(client.version())
device = client.device("10.42.0.231:5555")
signal.signal(signal.SIGALRM, handler=sig_handler)
record_event(device, "cmd.sh")
play_event(device, "cmd.sh")
# print(event)
from adb.client import Client as AdbClient
import time
import random
import datetime
# for image recognition
import cv2
import numpy as np
from matplotlib import pyplot as plt
# Connecting to BlueStacks
# Requires ./adb start-server; ./adb devices to be done prior
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device("emulator-5554")
def encounteredreCAPTCHA():
#template = cv2.imread('recaptcha.png',0)
template = cv2.imread('images/recaptcha.png',0)
w, h = template.shape[::-1]
result = device.screencap()
#with open("screen.png", "wb") as fp:
# fp.write(result)
npimg = np.fromstring(str(result), np.uint8)
img = cv2.imdecode(npimg,0)
#img = cv2.imread('screen.png',0)
sift = cv2.xfeatures2d.SIFT_create()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(template,None)
kp2, des2 = sift.detectAndCompute(img,None)
# BFMatcher with default params
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the androidtv platform."""
if DATA_KEY not in hass.data:
hass.data[DATA_KEY] = {}
from adb.client import Client as AdbClient
client = AdbClient(host="127.0.0.1", port=5037)
host = config.get(CONF_HOST)
name = config.get(CONF_NAME)
port = config.get(CONF_PORT)
uri = "{}:{}".format(host, port)
try:
adb_device = client.device(uri)
if adb_device is None:
_LOGGER.error(
"ADB server not connected to {}".format(name))
raise PlatformNotReady
androidtv = AndroidTv(name, uri, client, adb_device)
add_entities([androidtv])
if host in hass.data[DATA_KEY]:
_LOGGER.warning(
"Platform already setup on {}, skipping.".format(host))
else:
hass.data[DATA_KEY][host] = androidtv
except RuntimeError:
_LOGGER.error(
"Can't reach adb server, is it running ?")
raise PlatformNotReady
def service_action(service):
"""Dispatch service calls to target entities."""
params = {key: value for key, value in service.data.items()
if key != ATTR_ENTITY_ID}
entity_id = service.data.get(ATTR_ENTITY_ID)
target_devices = [dev for dev in hass.data[DATA_KEY].values()
if dev.entity_id in entity_id]
for target_device in target_devices:
target_device.do_action(params['action'])
def service_intent(service):
"""Dispatch service calls to target entities."""
params = {key: value for key, value in service.data.items()
if key != ATTR_ENTITY_ID}
entity_id = service.data.get(ATTR_ENTITY_ID)
target_devices = [dev for dev in hass.data[DATA_KEY].values()
if dev.entity_id in entity_id]
for target_device in target_devices:
target_device.start_intent(params['intent'])
def service_key(service):
"""Dispatch service calls to target entities."""
params = {key: value for key, value in service.data.items()
if key != ATTR_ENTITY_ID}
entity_id = service.data.get(ATTR_ENTITY_ID)
target_devices = [dev for dev in hass.data[DATA_KEY].values()
if dev.entity_id in entity_id]
for target_device in target_devices:
target_device.input_key(params['key'])
hass.services.register(
DOMAIN, ACTION_SERVICE, service_action, schema=SERVICE_ACTION_SCHEMA)
hass.services.register(
DOMAIN, INTENT_SERVICE, service_intent, schema=SERVICE_INTENT_SCHEMA)
hass.services.register(
DOMAIN, KEY_SERVICE, service_key, schema=SERVICE_KEY_SCHEMA)
def stager_clean(devicename):
logging.info("[+] Clean the stager process")
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device(devicename)
device.shell("rm /data/local/tmp/load.sh /data/local/tmp/STAGER")
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
import requests
import json
import time
from adb.client import Client as AdbClient
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device("57e6b612")
file = open("dane.txt","w")
with open(("konta.txt")) as f:
line = f.readlines()
emails = [x.strip() for x in line]
password=emails[0]
emails=emails[1:]
for email in emails:
s = requests.Session()
s.get('https://www.geekbuying.com/main/signin')
auth = {
'EmailAddress': email
, 'PassWord': password
, 'VerificationCode': ''
}
s.post('https://www.geekbuying.com/Main/AjaxSignIn', data=auth)
promo = {'day': '7'}
a=s.post('http://promotion.geekbuying.com/LuckyDraw/AddSigned', data=promo, timeout=1)
print(email)
print (a.content)
file.write(email)
file.write(": ")
def stager_clean():
logging.info("[+] Launch the stager process")
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device("emulator-5554")
device.shell("rm /data/local/tmp/load.sh /data/local/tmp/STAGER")
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
