RemoteRF 0.0.7.40__tar.gz → 0.0.7.41__tar.gz

{remoterf-0.0.7.40/src/remoteRF.egg-info → remoterf-0.0.7.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 0.0.7.40
+Version: 0.0.7.41
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
 Author: Ethan Ge
 Author-email: ethoGalaxy@gmail.com

{remoterf-0.0.7.40 → remoterf-0.0.7.41}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="remoterf",
-    version="0.0.7.40",
+    version="0.0.7.41",
     author="Ethan Ge",
     author_email="ethoGalaxy@gmail.com",
     description="A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.",
@@ -28,7 +28,8 @@ setup(
     entry_points={
         'console_scripts': [
             'remoterf-login=remoteRF.core.acc_login:main',
-            'remoterf-v=remoteRF.core.version:main'
+            'remoterf-v=remoteRF.core.version:main',
+            'remoterf-config=remoteRF.core.config:main',
         ],
     },
 )

remoterf-0.0.7.41/src/remoteRF/core/cert_fetcher.py

@@ -0,0 +1,140 @@
+# cert_fetcher.py
+"""
+RemoteRF Client-Side Cert Fetcher (bootstrap)
+
+Purpose:
+- Fetch the public CA certificate (ca.crt) from a server's bootstrap endpoint
+  (your cert_provider) and save it locally for later use in:
+      grpc.ssl_channel_credentials(root_certificates=ca_bytes)
+
+Security note (TOFU):
+- This fetch is typically done over plaintext HTTP (or raw TCP). The CA cert is public,
+  but authenticity is not guaranteed on first fetch. If you want TOFU done "right",
+  you should display the SHA256 fingerprint and require user confirmation elsewhere.
+  This module focuses only on: fetch + save + return success.
+
+Behavior:
+- Attempts HTTP GET first: http://{host}:{port}/ca.crt
+- If HTTP fails, falls back to raw TCP (reads until EOF).
+- Saves to a per-profile file under ~/.config/remoterf/certs/ by default.
+
+Exported API:
+- fetch_and_save_ca_cert(host, port, *, out_path=None, profile=None, timeout_sec=3.0) -> bool
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import socket
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+
+CERT_FILENAME_DEFAULT = "ca.crt"
+
+
+def _default_config_dir() -> Path:
+    # Cross-platform-ish default; adjust if you already have a standard in your project.
+    # Linux: ~/.config/remoterf
+    # macOS: also acceptable; if you want Apple-standard, use ~/Library/Application Support/remoterf
+    base = Path(os.path.expanduser("~")) / ".config" / "remoterf"
+    return base
+
+
+def _ensure_parent_dir(p: Path) -> None:
+    p.parent.mkdir(parents=True, exist_ok=True)
+
+
+def _looks_like_pem_cert(data: bytes) -> bool:
+    return b"BEGIN CERTIFICATE" in data and b"END CERTIFICATE" in data
+
+
+def sha256_fingerprint_pem(pem_bytes: bytes) -> str:
+    h = hashlib.sha256(pem_bytes).hexdigest()
+    return ":".join(h[i:i+2] for i in range(0, len(h), 2))
+
+
+def _fetch_http(host: str, port: int, timeout_sec: float) -> bytes:
+    url = f"http://{host}:{port}/ca.crt"
+    req = urllib.request.Request(url, method="GET")
+    with urllib.request.urlopen(req, timeout=timeout_sec) as resp:
+        data = resp.read()
+    return data
+
+
+def _fetch_raw_tcp(host: str, port: int, timeout_sec: float) -> bytes:
+    chunks: list[bytes] = []
+    with socket.create_connection((host, port), timeout=timeout_sec) as s:
+        s.settimeout(timeout_sec)
+        while True:
+            try:
+                b = s.recv(4096)
+            except socket.timeout:
+                break
+            if not b:
+                break
+            chunks.append(b)
+    return b"".join(chunks)
+
+
+def fetch_and_save_ca_cert(
+    host: str,
+    port: int,
+    *,
+    out_path: Optional[str | Path] = None,
+    profile: Optional[str] = None,
+    timeout_sec: float = 3.0,
+    overwrite: bool = True,
+) -> bool:
+    """
+    Fetch CA cert from the server bootstrap endpoint and save it to disk.
+
+    Args:
+        host: server host/ip running cert_provider
+        port: cert_provider port (NOT the TLS gRPC port)
+        out_path: explicit output path (overrides profile/default location)
+        profile: if provided, saves as ~/.config/remoterf/certs/<profile>.crt
+        timeout_sec: network timeout
+        overwrite: whether to overwrite existing file
+
+    Returns:
+        True on success, False on any failure.
+    """
+    try:
+        if not isinstance(port, int):
+            port = int(port)
+
+        # Determine destination path
+        if out_path is not None:
+            dest = Path(out_path).expanduser().resolve()
+        else:
+            cfg = _default_config_dir()
+            certs_dir = cfg / "certs"
+            name = f"{profile}.crt" if profile else CERT_FILENAME_DEFAULT
+            dest = certs_dir / name
+
+        _ensure_parent_dir(dest)
+
+        if dest.exists() and not overwrite:
+            return True  # already present, treat as success
+
+        # Fetch (HTTP first, then raw TCP fallback)
+        data = b""
+        try:
+            data = _fetch_http(host, port, timeout_sec)
+        except Exception:
+            data = _fetch_raw_tcp(host, port, timeout_sec)
+
+        if not data or not _looks_like_pem_cert(data):
+            return False
+
+        # Save
+        dest.write_bytes(data)
+
+        # Optional: you may want to return/print fingerprint, but requested API is bool.
+        return True
+
+    except Exception:
+        return False

remoterf-0.0.7.41/src/remoteRF/core/config.py

@@ -0,0 +1,143 @@
+# src/remoteRF/core/remoterf_config.py
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import Tuple
+
+from .cert_fetcher import fetch_and_save_ca_cert  # your earlier module
+
+# -----------------------------
+# Local config locations
+# -----------------------------
+def _config_root() -> Path:
+    # Keep it simple and consistent with earlier suggestions.
+    return Path(os.path.expanduser("~")) / ".config" / "remoterf"
+
+def _env_path() -> Path:
+    return _config_root() / ".env"
+
+def _certs_dir() -> Path:
+    return _config_root() / "certs"
+
+def _parse_hostport(s: str) -> Tuple[str, int]:
+    s = s.strip()
+    if "://" in s:
+        s = s.split("://", 1)[1]
+
+    if ":" not in s:
+        raise ValueError("Expected format host:port")
+
+    host, port_str = s.rsplit(":", 1)
+    host = host.strip()
+    port = int(port_str.strip())
+    if not host:
+        raise ValueError("Host is empty")
+    if port <= 0 or port > 65535:
+        raise ValueError("Port out of range")
+    return host, port
+
+
+def _write_env_kv(path: Path, kv: dict[str, str]) -> None:
+    """
+    Writes/overwrites a simple dotenv-style file.
+    (We overwrite the whole file for simplicity and correctness.)
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = []
+    for k, v in kv.items():
+        # Quote only if needed; keep simple and safe.
+        if any(c.isspace() for c in v) or any(c in v for c in ['"', "'"]):
+            v = v.replace('"', '\\"')
+            lines.append(f'{k}="{v}"')
+        else:
+            lines.append(f"{k}={v}")
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="remoterf-config",
+        description="Configure RemoteRF client to talk to a specific server (fetch CA cert + save target)."
+    )
+    parser.add_argument(
+        "addr",
+        help="Server gRPC address in host:port form (this is the TLS gRPC port)."
+    )
+    parser.add_argument(
+        "--cert-port",
+        type=int,
+        default=None,
+        help="Bootstrap cert-provider port. If omitted, defaults to <grpc_port + 1>."
+    )
+    parser.add_argument(
+        "--profile",
+        default="default",
+        help="Profile name (controls CA cert filename). Default: default"
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=3.0,
+        help="Network timeout seconds. Default: 3.0"
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Overwrite existing cert/config if present."
+    )
+    args = parser.parse_args()
+
+    try:
+        host, grpc_port = _parse_hostport(args.addr)
+    except Exception as e:
+        print(f"Error: invalid addr '{args.addr}': {e}", file=sys.stderr)
+        sys.exit(2)
+
+    cert_port = args.cert_port if args.cert_port is not None else (grpc_port + 1)
+
+    # Destination CA cert file
+    certs_dir = _certs_dir()
+    certs_dir.mkdir(parents=True, exist_ok=True)
+    ca_out = certs_dir / f"{args.profile}.crt"
+
+    if ca_out.exists() and not (args.overwrite):
+        # Treat as OK; still (re)write env target.
+        fetched_ok = True
+    else:
+        fetched_ok = fetch_and_save_ca_cert(
+            host,
+            cert_port,
+            out_path=ca_out,
+            timeout_sec=args.timeout,
+            overwrite=True,
+        )
+
+    if not fetched_ok:
+        print(
+            f"Failed to fetch CA cert from {host}:{cert_port}.\n"
+            f"Expected cert provider at: http://{host}:{cert_port}/ca.crt (or raw TCP).\n"
+            f"Server must be running cert_provider on that port.",
+            file=sys.stderr
+        )
+        sys.exit(1)
+
+    # Write local .env (or config) with chosen server and CA path
+    env_file = _env_path()
+    _write_env_kv(env_file, {
+        "REMOTERF_ADDR": f"{host}:{grpc_port}",
+        "REMOTERF_CA_CERT": str(ca_out),
+        "REMOTERF_PROFILE": args.profile,
+    })
+
+    print("RemoteRF configured successfully.")
+    print(f"  gRPC target : {host}:{grpc_port}")
+    print(f"  cert port   : {host}:{cert_port}")
+    print(f"  CA cert     : {ca_out}")
+    print(f"  env file    : {env_file}")
+
+if __name__ == "__main__":
+    main()

{remoterf-0.0.7.40 → remoterf-0.0.7.41/src/remoteRF.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 0.0.7.40
+Version: 0.0.7.41
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
 Author: Ethan Ge
 Author-email: ethoGalaxy@gmail.com

{remoterf-0.0.7.40 → remoterf-0.0.7.41}/src/remoteRF.egg-info/SOURCES.txt

@@ -21,6 +21,8 @@ src/remoteRF/common/utils/process_arg.py
 src/remoteRF/core/__init__.py
 src/remoteRF/core/acc_login.py
 src/remoteRF/core/app.py
+src/remoteRF/core/cert_fetcher.py
+src/remoteRF/core/config.py
 src/remoteRF/core/grpc_acc.py
 src/remoteRF/core/grpc_client.py
 src/remoteRF/core/version.py

{remoterf-0.0.7.40 → remoterf-0.0.7.41}/src/remoteRF.egg-info/entry_points.txt

@@ -1,3 +1,4 @@
 [console_scripts]
+remoterf-config = remoteRF.core.config:main
 remoterf-login = remoteRF.core.acc_login:main
 remoterf-v = remoteRF.core.version:main