ledger-rig 0.2.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- ledger_rig/__init__.py +0 -0
- ledger_rig/__main__.py +89 -0
- ledger_rig/bridge.py +125 -0
- ledger_rig/buttons.py +47 -0
- ledger_rig/framing.py +56 -0
- ledger_rig/hold.py +23 -0
- ledger_rig/rig.py +98 -0
- ledger_rig/seeds.py +22 -0
- ledger_rig/uhid.py +42 -0
- ledger_rig-0.2.0.dist-info/METADATA +22 -0
- ledger_rig-0.2.0.dist-info/RECORD +13 -0
- ledger_rig-0.2.0.dist-info/WHEEL +4 -0
- ledger_rig-0.2.0.dist-info/licenses/LICENSE +21 -0
ledger_rig/__init__.py
ADDED
|
File without changes
|
ledger_rig/__main__.py
ADDED
|
@@ -0,0 +1,89 @@
|
|
|
1
|
+
import argparse
|
|
2
|
+
import logging
|
|
3
|
+
import os
|
|
4
|
+
|
|
5
|
+
from ledger_rig import buttons, rig
|
|
6
|
+
from ledger_rig.bridge import Bridge, control
|
|
7
|
+
from ledger_rig.hold import hold, node
|
|
8
|
+
from ledger_rig.seeds import SEEDS
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
def _address(value: str) -> tuple[str, int]:
|
|
12
|
+
host, port = value.rsplit(":", 1)
|
|
13
|
+
return host, int(port)
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
def main(argv: list[str] | None = None) -> None:
|
|
17
|
+
parser = argparse.ArgumentParser(prog="ledger_rig")
|
|
18
|
+
commands = parser.add_subparsers(dest="command", required=True)
|
|
19
|
+
bridge = commands.add_parser("bridge")
|
|
20
|
+
bridge.add_argument("--apdu", type=_address, required=True)
|
|
21
|
+
bridge.add_argument("--serial", required=True)
|
|
22
|
+
bridge.add_argument("--locked", action="store_true")
|
|
23
|
+
bridge.add_argument("--dashboard", action="store_true")
|
|
24
|
+
up = commands.add_parser("up")
|
|
25
|
+
up.add_argument("--count", type=int, required=True)
|
|
26
|
+
up.add_argument("--app", required=True)
|
|
27
|
+
up.add_argument("--seeds", nargs="+")
|
|
28
|
+
up.add_argument("--locked", action="store_true")
|
|
29
|
+
up.add_argument("--dashboard", action="store_true")
|
|
30
|
+
commands.add_parser("down")
|
|
31
|
+
for command in ("lock", "unlock"):
|
|
32
|
+
commands.add_parser(command).add_argument("serial")
|
|
33
|
+
press = commands.add_parser("press")
|
|
34
|
+
press.add_argument("serial")
|
|
35
|
+
press.add_argument("button", choices=["left", "right", "both"])
|
|
36
|
+
commands.add_parser("approve").add_argument("serial")
|
|
37
|
+
commands.add_parser("reject").add_argument("serial")
|
|
38
|
+
holding = commands.add_parser("hold")
|
|
39
|
+
holding.add_argument("serial")
|
|
40
|
+
holding.add_argument("--every", type=float, default=2)
|
|
41
|
+
args = parser.parse_args(argv)
|
|
42
|
+
if args.command == "up":
|
|
43
|
+
seeds = args.seeds or SEEDS[: args.count]
|
|
44
|
+
if len(seeds) != args.count:
|
|
45
|
+
parser.error(f"--count {args.count} needs {args.count} seeds")
|
|
46
|
+
devices = rig.up(args.app, seeds, args.locked, args.dashboard)
|
|
47
|
+
for path, serial, port, api in devices:
|
|
48
|
+
print(f"{path} {serial} {port} {api}")
|
|
49
|
+
return
|
|
50
|
+
if args.command == "down":
|
|
51
|
+
rig.down()
|
|
52
|
+
return
|
|
53
|
+
if args.command in ("lock", "unlock"):
|
|
54
|
+
try:
|
|
55
|
+
control(args.serial, args.command)
|
|
56
|
+
except OSError:
|
|
57
|
+
parser.error(f"no bridge {args.serial}")
|
|
58
|
+
return
|
|
59
|
+
if args.command in ("press", "approve", "reject"):
|
|
60
|
+
try:
|
|
61
|
+
api = buttons.port(args.serial)
|
|
62
|
+
except LookupError:
|
|
63
|
+
parser.error(f"no device {args.serial}: run up first")
|
|
64
|
+
if args.command == "press":
|
|
65
|
+
buttons.press(api, args.button)
|
|
66
|
+
elif args.command == "approve":
|
|
67
|
+
buttons.walk(api, buttons.APPROVE)
|
|
68
|
+
else:
|
|
69
|
+
buttons.walk(api, buttons.REJECT)
|
|
70
|
+
return
|
|
71
|
+
if args.command == "hold":
|
|
72
|
+
path = node(args.serial)
|
|
73
|
+
if path is None:
|
|
74
|
+
parser.error(f"no hidraw node for serial {args.serial}")
|
|
75
|
+
fd = os.open(path, os.O_RDWR)
|
|
76
|
+
try:
|
|
77
|
+
hold(fd, args.every)
|
|
78
|
+
except KeyboardInterrupt:
|
|
79
|
+
pass
|
|
80
|
+
finally:
|
|
81
|
+
os.close(fd)
|
|
82
|
+
return
|
|
83
|
+
host, port = args.apdu
|
|
84
|
+
logging.basicConfig(level=logging.INFO, format="%(message)s")
|
|
85
|
+
Bridge(host, port, args.serial, locked=args.locked, dashboard=args.dashboard).run()
|
|
86
|
+
|
|
87
|
+
|
|
88
|
+
if __name__ == "__main__":
|
|
89
|
+
main()
|
ledger_rig/bridge.py
ADDED
|
@@ -0,0 +1,125 @@
|
|
|
1
|
+
import logging
|
|
2
|
+
import os
|
|
3
|
+
import select
|
|
4
|
+
import socket
|
|
5
|
+
from datetime import datetime
|
|
6
|
+
from pathlib import Path
|
|
7
|
+
|
|
8
|
+
from ledger_rig import framing, rig, uhid
|
|
9
|
+
|
|
10
|
+
VENDOR = 0x2C97
|
|
11
|
+
OPENED = b"\x90\x00"
|
|
12
|
+
|
|
13
|
+
log = logging.getLogger(__name__)
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
class Bridge:
|
|
17
|
+
def __init__(
|
|
18
|
+
self,
|
|
19
|
+
apdu_host: str,
|
|
20
|
+
apdu_port: int,
|
|
21
|
+
serial: str,
|
|
22
|
+
pid: int = 0x5011,
|
|
23
|
+
name: str = "Ledger Nano S Plus",
|
|
24
|
+
locked: bool = False,
|
|
25
|
+
dashboard: bool = False,
|
|
26
|
+
) -> None:
|
|
27
|
+
self.address = (apdu_host, apdu_port)
|
|
28
|
+
self.serial = serial
|
|
29
|
+
self.pid = pid
|
|
30
|
+
self.name = name
|
|
31
|
+
self.locked = locked
|
|
32
|
+
self.dashboard = dashboard
|
|
33
|
+
|
|
34
|
+
def run(self) -> None:
|
|
35
|
+
path = _control_path(self.serial)
|
|
36
|
+
with (
|
|
37
|
+
socket.create_connection(self.address) as sock,
|
|
38
|
+
socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) as control,
|
|
39
|
+
):
|
|
40
|
+
rig.LOGS.mkdir(exist_ok=True)
|
|
41
|
+
path.unlink(missing_ok=True)
|
|
42
|
+
control.bind(str(path))
|
|
43
|
+
fd = os.open("/dev/uhid", os.O_RDWR)
|
|
44
|
+
create = uhid.create2(self.name, self.serial, VENDOR, self.pid)
|
|
45
|
+
try:
|
|
46
|
+
os.write(fd, create)
|
|
47
|
+
_serve(
|
|
48
|
+
fd, sock, control, self.locked, create if self.dashboard else None
|
|
49
|
+
)
|
|
50
|
+
finally:
|
|
51
|
+
os.write(fd, uhid.destroy())
|
|
52
|
+
os.close(fd)
|
|
53
|
+
path.unlink()
|
|
54
|
+
|
|
55
|
+
|
|
56
|
+
def control(serial: str, command: str) -> None:
|
|
57
|
+
with socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) as client:
|
|
58
|
+
client.sendto(command.encode(), str(_control_path(serial)))
|
|
59
|
+
|
|
60
|
+
|
|
61
|
+
def _control_path(serial: str) -> Path:
|
|
62
|
+
return rig.LOGS / f"bridge-{serial}.sock"
|
|
63
|
+
|
|
64
|
+
|
|
65
|
+
def _serve(
|
|
66
|
+
fd: int,
|
|
67
|
+
sock: socket.socket,
|
|
68
|
+
control: socket.socket,
|
|
69
|
+
locked: bool,
|
|
70
|
+
recreate: bytes | None,
|
|
71
|
+
) -> None:
|
|
72
|
+
decoder = framing.Decoder()
|
|
73
|
+
while sock not in (ready := select.select([fd, sock, control], [], [])[0]):
|
|
74
|
+
if control in ready:
|
|
75
|
+
locked = control.recv(16) == b"lock"
|
|
76
|
+
if fd not in ready:
|
|
77
|
+
continue
|
|
78
|
+
report = uhid.output(os.read(fd, uhid.EVENT_SIZE))
|
|
79
|
+
if report is None:
|
|
80
|
+
continue
|
|
81
|
+
if len(report) == framing.REPORT_SIZE + 1:
|
|
82
|
+
report = report[1:]
|
|
83
|
+
apdu = decoder.feed(report)
|
|
84
|
+
if apdu is None:
|
|
85
|
+
continue
|
|
86
|
+
log.info("%s -> %d %s", _now(), len(apdu), apdu[:16].hex())
|
|
87
|
+
if locked:
|
|
88
|
+
reply = b"\x55\x15"
|
|
89
|
+
elif recreate is not None:
|
|
90
|
+
reply = _dashboard(apdu)
|
|
91
|
+
else:
|
|
92
|
+
reply = _exchange(sock, apdu)
|
|
93
|
+
if reply is None:
|
|
94
|
+
return
|
|
95
|
+
log.info(
|
|
96
|
+
"%s <- %d %s %s", _now(), len(reply), reply[-2:].hex(), reply[:16].hex()
|
|
97
|
+
)
|
|
98
|
+
for chunk in framing.encode(reply):
|
|
99
|
+
os.write(fd, uhid.input2(chunk))
|
|
100
|
+
if recreate is not None and reply == OPENED:
|
|
101
|
+
os.write(fd, uhid.destroy())
|
|
102
|
+
os.write(fd, recreate)
|
|
103
|
+
recreate = None
|
|
104
|
+
|
|
105
|
+
|
|
106
|
+
def _dashboard(apdu: bytes) -> bytes:
|
|
107
|
+
if apdu[:2] == b"\xb0\x01":
|
|
108
|
+
return b"\x01\x05BOLOS\x051.0.0\x90\x00"
|
|
109
|
+
if apdu[:2] == b"\xe0\xd8":
|
|
110
|
+
return OPENED if apdu[5:] == b"Solana" else b"\x68\x07"
|
|
111
|
+
return b"\x6e\x00"
|
|
112
|
+
|
|
113
|
+
|
|
114
|
+
def _now() -> str:
|
|
115
|
+
return datetime.now().isoformat(timespec="milliseconds")
|
|
116
|
+
|
|
117
|
+
|
|
118
|
+
def _exchange(sock: socket.socket, apdu: bytes) -> bytes | None:
|
|
119
|
+
sock.sendall(len(apdu).to_bytes(4, "big") + apdu)
|
|
120
|
+
header = sock.recv(4, socket.MSG_WAITALL)
|
|
121
|
+
if len(header) < 4:
|
|
122
|
+
return None
|
|
123
|
+
size = int.from_bytes(header, "big") + 2
|
|
124
|
+
reply = sock.recv(size, socket.MSG_WAITALL)
|
|
125
|
+
return reply if len(reply) == size else None
|
ledger_rig/buttons.py
ADDED
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
import json
|
|
2
|
+
import re
|
|
3
|
+
import urllib.request
|
|
4
|
+
from functools import partial
|
|
5
|
+
|
|
6
|
+
from ledger_rig import rig
|
|
7
|
+
|
|
8
|
+
# ragger@6e106094 src/ragger/navigator/navigation_scenario.py, nano TX_REVIEW on NBGL
|
|
9
|
+
APPROVE = (
|
|
10
|
+
r"^((Accept risk and (sign (transaction|message|operation))?)"
|
|
11
|
+
r"|(Sign (transaction|message|operation)))$"
|
|
12
|
+
)
|
|
13
|
+
REJECT = r"^(Reject( (transaction|message|operation))?)$"
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
def port(serial: str) -> int:
|
|
17
|
+
try:
|
|
18
|
+
return int((rig.LOGS / f"api-{serial}").read_text())
|
|
19
|
+
except FileNotFoundError:
|
|
20
|
+
raise LookupError(serial) from None
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
def press(port: int, button: str) -> None:
|
|
24
|
+
body = json.dumps({"action": "press-and-release"}).encode()
|
|
25
|
+
url = f"http://127.0.0.1:{port}/button/{button}"
|
|
26
|
+
urllib.request.urlopen(url, body, timeout=rig.TIMEOUT).close()
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
def screen(port: int) -> list[str]:
|
|
30
|
+
url = f"http://127.0.0.1:{port}/events?currentscreenonly=true"
|
|
31
|
+
with urllib.request.urlopen(url, timeout=rig.TIMEOUT) as reply:
|
|
32
|
+
return [event["text"] for event in json.load(reply)["events"]]
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
def walk(port: int, pattern: str) -> None:
|
|
36
|
+
rig._poll(lambda: any(text.startswith("Review") for text in screen(port)))
|
|
37
|
+
rig._poll(partial(_step, port, pattern))
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
def _step(port: int, pattern: str) -> bool:
|
|
41
|
+
texts = screen(port)
|
|
42
|
+
if any(re.fullmatch(pattern, text) for text in texts):
|
|
43
|
+
press(port, "both")
|
|
44
|
+
return True
|
|
45
|
+
if texts:
|
|
46
|
+
press(port, "right")
|
|
47
|
+
return False
|
ledger_rig/framing.py
ADDED
|
@@ -0,0 +1,56 @@
|
|
|
1
|
+
REPORT_SIZE = 64
|
|
2
|
+
CHANNEL = b"\x01\x01"
|
|
3
|
+
TAG = 0x05
|
|
4
|
+
HEADER_SIZE = 5
|
|
5
|
+
CHUNK_SIZE = REPORT_SIZE - HEADER_SIZE
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
class FramingError(ValueError):
|
|
9
|
+
pass
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
def encode(message: bytes) -> list[bytes]:
|
|
13
|
+
data = len(message).to_bytes(2, "big") + message
|
|
14
|
+
reports = []
|
|
15
|
+
for seq, start in enumerate(range(0, len(data), CHUNK_SIZE)):
|
|
16
|
+
chunk = data[start : start + CHUNK_SIZE]
|
|
17
|
+
header = CHANNEL + bytes([TAG]) + seq.to_bytes(2, "big")
|
|
18
|
+
reports.append((header + chunk).ljust(REPORT_SIZE, b"\x00"))
|
|
19
|
+
return reports
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
class Decoder:
|
|
23
|
+
def __init__(self) -> None:
|
|
24
|
+
self._reset()
|
|
25
|
+
|
|
26
|
+
def _reset(self) -> None:
|
|
27
|
+
self._seq = 0
|
|
28
|
+
self._length = 0
|
|
29
|
+
self._buffer = bytearray()
|
|
30
|
+
|
|
31
|
+
def feed(self, report: bytes) -> bytes | None:
|
|
32
|
+
try:
|
|
33
|
+
return self._feed(report)
|
|
34
|
+
except FramingError:
|
|
35
|
+
self._reset()
|
|
36
|
+
raise
|
|
37
|
+
|
|
38
|
+
def _feed(self, report: bytes) -> bytes | None:
|
|
39
|
+
if report[:2] != CHANNEL:
|
|
40
|
+
raise FramingError(f"channel {report[:2].hex()}")
|
|
41
|
+
if report[2] != TAG:
|
|
42
|
+
raise FramingError(f"tag {report[2]:#04x}")
|
|
43
|
+
seq = int.from_bytes(report[3:5], "big")
|
|
44
|
+
if seq != self._seq:
|
|
45
|
+
raise FramingError(f"sequence {seq}, expected {self._seq}")
|
|
46
|
+
if seq == 0:
|
|
47
|
+
self._length = int.from_bytes(report[5:7], "big")
|
|
48
|
+
self._buffer += report[7:]
|
|
49
|
+
else:
|
|
50
|
+
self._buffer += report[HEADER_SIZE:]
|
|
51
|
+
self._seq += 1
|
|
52
|
+
if len(self._buffer) < self._length:
|
|
53
|
+
return None
|
|
54
|
+
message = bytes(self._buffer[: self._length])
|
|
55
|
+
self._reset()
|
|
56
|
+
return message
|
ledger_rig/hold.py
ADDED
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
import glob
|
|
2
|
+
import os
|
|
3
|
+
import time
|
|
4
|
+
from pathlib import Path
|
|
5
|
+
|
|
6
|
+
from ledger_rig import framing
|
|
7
|
+
|
|
8
|
+
APDU = bytes.fromhex("e001000000")
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
def node(serial: str) -> str | None:
|
|
12
|
+
for uevent in glob.glob("/sys/class/hidraw/*/device/uevent"):
|
|
13
|
+
if f"HID_UNIQ={serial}" in Path(uevent).read_text().splitlines():
|
|
14
|
+
return f"/dev/{Path(uevent).parts[4]}"
|
|
15
|
+
return None
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
def hold(fd: int, every: float) -> None:
|
|
19
|
+
while True:
|
|
20
|
+
os.write(fd, framing.encode(APDU)[0])
|
|
21
|
+
if not os.read(fd, framing.REPORT_SIZE):
|
|
22
|
+
return
|
|
23
|
+
time.sleep(every)
|
ledger_rig/rig.py
ADDED
|
@@ -0,0 +1,98 @@
|
|
|
1
|
+
import glob
|
|
2
|
+
import socket
|
|
3
|
+
import subprocess
|
|
4
|
+
import sys
|
|
5
|
+
import time
|
|
6
|
+
import urllib.request
|
|
7
|
+
from collections.abc import Callable, Sequence
|
|
8
|
+
from functools import partial
|
|
9
|
+
from pathlib import Path
|
|
10
|
+
from typing import TypeVar
|
|
11
|
+
|
|
12
|
+
IMAGE = "ghcr.io/ledgerhq/speculos"
|
|
13
|
+
LABEL = "ledger-rig"
|
|
14
|
+
TIMEOUT = 60
|
|
15
|
+
LOGS = Path("/tmp/ledger-rig")
|
|
16
|
+
|
|
17
|
+
T = TypeVar("T")
|
|
18
|
+
|
|
19
|
+
|
|
20
|
+
def up(
|
|
21
|
+
app: str, seeds: Sequence[str], locked: bool = False, dashboard: bool = False
|
|
22
|
+
) -> list[tuple[str, str, int, int]]:
|
|
23
|
+
elf = Path(app).resolve()
|
|
24
|
+
LOGS.mkdir(exist_ok=True)
|
|
25
|
+
devices = []
|
|
26
|
+
for i, seed in enumerate(seeds):
|
|
27
|
+
apdu, api = _free_ports()
|
|
28
|
+
subprocess.run(
|
|
29
|
+
["docker", "run", "-d", "--rm", "--network", "host", "--label", LABEL]
|
|
30
|
+
+ ["-v", f"{elf}:/app.elf:ro", IMAGE, "/app.elf", "--model", "nanosp"]
|
|
31
|
+
+ ["--seed", seed, "--display", "headless"]
|
|
32
|
+
+ ["--apdu-port", str(apdu), "--api-port", str(api)],
|
|
33
|
+
stdout=subprocess.DEVNULL,
|
|
34
|
+
check=True,
|
|
35
|
+
)
|
|
36
|
+
_poll(partial(_answers, api))
|
|
37
|
+
serial = f"{i:04d}"
|
|
38
|
+
(LOGS / f"api-{serial}").write_text(str(api))
|
|
39
|
+
with (LOGS / f"bridge-{serial}.log").open("ab") as stderr:
|
|
40
|
+
bridge = subprocess.Popen(
|
|
41
|
+
[sys.executable, "-m", "ledger_rig", "bridge"]
|
|
42
|
+
+ ["--apdu", f"127.0.0.1:{apdu}", "--serial", serial]
|
|
43
|
+
+ (["--locked"] if locked else [])
|
|
44
|
+
+ (["--dashboard"] if dashboard else []),
|
|
45
|
+
stdin=subprocess.DEVNULL,
|
|
46
|
+
stdout=subprocess.DEVNULL,
|
|
47
|
+
stderr=stderr,
|
|
48
|
+
start_new_session=True,
|
|
49
|
+
)
|
|
50
|
+
devices.append((_poll(partial(_hidraw, serial, bridge)), serial, apdu, api))
|
|
51
|
+
return devices
|
|
52
|
+
|
|
53
|
+
|
|
54
|
+
def down() -> None:
|
|
55
|
+
ps = subprocess.run(
|
|
56
|
+
["docker", "ps", "-q", "--filter", f"label={LABEL}"],
|
|
57
|
+
capture_output=True,
|
|
58
|
+
text=True,
|
|
59
|
+
check=True,
|
|
60
|
+
)
|
|
61
|
+
ids = ps.stdout.split()
|
|
62
|
+
if ids:
|
|
63
|
+
subprocess.run(
|
|
64
|
+
["docker", "rm", "-f", *ids], stdout=subprocess.DEVNULL, check=True
|
|
65
|
+
)
|
|
66
|
+
|
|
67
|
+
|
|
68
|
+
def _free_ports() -> tuple[int, int]:
|
|
69
|
+
with socket.socket() as apdu, socket.socket() as api:
|
|
70
|
+
apdu.bind(("127.0.0.1", 0))
|
|
71
|
+
api.bind(("127.0.0.1", 0))
|
|
72
|
+
return apdu.getsockname()[1], api.getsockname()[1]
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
def _poll(check: Callable[[], T]) -> T:
|
|
76
|
+
deadline = time.monotonic() + TIMEOUT
|
|
77
|
+
while not (result := check()):
|
|
78
|
+
if time.monotonic() > deadline:
|
|
79
|
+
raise TimeoutError
|
|
80
|
+
time.sleep(0.1)
|
|
81
|
+
return result
|
|
82
|
+
|
|
83
|
+
|
|
84
|
+
def _answers(port: int) -> bool:
|
|
85
|
+
try:
|
|
86
|
+
urllib.request.urlopen(f"http://127.0.0.1:{port}/", timeout=1).close()
|
|
87
|
+
except OSError:
|
|
88
|
+
return False
|
|
89
|
+
return True
|
|
90
|
+
|
|
91
|
+
|
|
92
|
+
def _hidraw(serial: str, bridge: subprocess.Popen) -> str | None:
|
|
93
|
+
for uevent in glob.glob("/sys/class/hidraw/*/device/uevent"):
|
|
94
|
+
if f"HID_UNIQ={serial}" in Path(uevent).read_text().splitlines():
|
|
95
|
+
return f"/dev/{Path(uevent).parts[4]}"
|
|
96
|
+
if bridge.poll() is not None:
|
|
97
|
+
raise RuntimeError(f"bridge {serial} exited with {bridge.returncode}")
|
|
98
|
+
return None
|
ledger_rig/seeds.py
ADDED
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
SEEDS = (
|
|
2
|
+
# public test mnemonic: never hold funds
|
|
3
|
+
(
|
|
4
|
+
"glory promote mansion idle axis finger extra february uncover one trip"
|
|
5
|
+
" resource lawn turtle enact monster seven myth punch hobby comfort wild"
|
|
6
|
+
" raise skin"
|
|
7
|
+
),
|
|
8
|
+
# public test mnemonic: never hold funds
|
|
9
|
+
" ".join(["abandon"] * 11 + ["about"]),
|
|
10
|
+
# public test mnemonic: never hold funds
|
|
11
|
+
"legal winner thank year wave sausage worth useful legal winner thank yellow",
|
|
12
|
+
# public test mnemonic: never hold funds
|
|
13
|
+
"letter advice cage absurd amount doctor acoustic avoid letter advice cage above",
|
|
14
|
+
# public test mnemonic: never hold funds
|
|
15
|
+
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
|
|
16
|
+
# public test mnemonic: never hold funds
|
|
17
|
+
"ozone drill grab fiber curtain grace pudding thank cruise elder eight picnic",
|
|
18
|
+
# public test mnemonic: never hold funds
|
|
19
|
+
"scheme spot photo card baby mountain device kick cradle pact join borrow",
|
|
20
|
+
# public test mnemonic: never hold funds
|
|
21
|
+
"jelly better achieve collect unaware mountain thought cargo oxygen act hood bridge",
|
|
22
|
+
)
|
ledger_rig/uhid.py
ADDED
|
@@ -0,0 +1,42 @@
|
|
|
1
|
+
import struct
|
|
2
|
+
|
|
3
|
+
UHID_DESTROY = 1
|
|
4
|
+
UHID_OUTPUT = 6
|
|
5
|
+
UHID_CREATE2 = 11
|
|
6
|
+
UHID_INPUT2 = 12
|
|
7
|
+
EVENT_SIZE = 4376
|
|
8
|
+
|
|
9
|
+
# vendor usage page 0xFF00, 64-byte input and output reports
|
|
10
|
+
REPORT_DESCRIPTOR = bytes.fromhex(
|
|
11
|
+
"0600ff 0901 a101"
|
|
12
|
+
" 0903 1500 26ff00 7508 9540 8108"
|
|
13
|
+
" 0904 1500 26ff00 7508 9540 9108"
|
|
14
|
+
" c0"
|
|
15
|
+
)
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
def create2(name: str, serial: str, vendor: int, product: int) -> bytes:
|
|
19
|
+
return (
|
|
20
|
+
struct.pack("<I", UHID_CREATE2)
|
|
21
|
+
+ name.encode().ljust(128, b"\0")
|
|
22
|
+
+ b"".ljust(64, b"\0")
|
|
23
|
+
+ serial.encode().ljust(64, b"\0")
|
|
24
|
+
+ struct.pack("<HHIIII", len(REPORT_DESCRIPTOR), 0x03, vendor, product, 0, 0)
|
|
25
|
+
+ REPORT_DESCRIPTOR.ljust(4096, b"\0")
|
|
26
|
+
)
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
def input2(report: bytes) -> bytes:
|
|
30
|
+
return struct.pack("<IH", UHID_INPUT2, len(report)) + report
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
def destroy() -> bytes:
|
|
34
|
+
return struct.pack("<I", UHID_DESTROY)
|
|
35
|
+
|
|
36
|
+
|
|
37
|
+
def output(event: bytes) -> bytes | None:
|
|
38
|
+
(kind,) = struct.unpack_from("<I", event)
|
|
39
|
+
if kind != UHID_OUTPUT:
|
|
40
|
+
return None
|
|
41
|
+
(size,) = struct.unpack_from("<H", event, 4100)
|
|
42
|
+
return event[4 : 4 + size]
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
Metadata-Version: 2.5
|
|
2
|
+
Name: ledger-rig
|
|
3
|
+
Version: 0.2.0
|
|
4
|
+
Summary: Speculos Solana Ledger Nano S Plus devices as Linux hidraw devices, for CI
|
|
5
|
+
Project-URL: Homepage, https://github.com/caliperforge/ledger-rig
|
|
6
|
+
Project-URL: Source, https://github.com/caliperforge/ledger-rig
|
|
7
|
+
Project-URL: Changelog, https://github.com/caliperforge/ledger-rig/blob/main/CHANGELOG.md
|
|
8
|
+
Project-URL: Issues, https://github.com/caliperforge/ledger-rig/issues
|
|
9
|
+
License-Expression: MIT
|
|
10
|
+
License-File: LICENSE
|
|
11
|
+
Classifier: Development Status :: 3 - Alpha
|
|
12
|
+
Classifier: Intended Audience :: Developers
|
|
13
|
+
Classifier: Operating System :: POSIX :: Linux
|
|
14
|
+
Classifier: Programming Language :: Python :: 3
|
|
15
|
+
Classifier: Programming Language :: Python :: 3.11
|
|
16
|
+
Classifier: Topic :: Software Development :: Testing
|
|
17
|
+
Requires-Python: >=3.11
|
|
18
|
+
Provides-Extra: test
|
|
19
|
+
Requires-Dist: hid; extra == 'test'
|
|
20
|
+
Requires-Dist: pytest; extra == 'test'
|
|
21
|
+
Requires-Dist: pyyaml; extra == 'test'
|
|
22
|
+
Requires-Dist: ruff; extra == 'test'
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
ledger_rig/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
2
|
+
ledger_rig/__main__.py,sha256=6KZlai01BB1BFjYBUzkO_hGlIfnTKlatLcyQ7Mkt5VQ,3261
|
|
3
|
+
ledger_rig/bridge.py,sha256=2nY8UxD_C1MAIGk7cRGE3BjEw0jrqXLje49NRJQFj3Y,3705
|
|
4
|
+
ledger_rig/buttons.py,sha256=ppVzEEG8ZD1INGfeKJVtza8WmKmC0me2fMHELPAlp0A,1433
|
|
5
|
+
ledger_rig/framing.py,sha256=B7lypM61ozWxpKHkzqc9DSwZsGoDx9OnXFd8NilkqJc,1651
|
|
6
|
+
ledger_rig/hold.py,sha256=a8X246ASITCzPDGr8sVTHfXaF6dCjV9JxQMD-FUHwIM,572
|
|
7
|
+
ledger_rig/rig.py,sha256=k7ZTPTh8cxfb_5B8J8__67QhGlXwf1y7E2XAQPVd3y0,3108
|
|
8
|
+
ledger_rig/seeds.py,sha256=ll6nCPbc-a9_eFmMRm84n5J_0s0XDgKsvIkw__zPt84,1095
|
|
9
|
+
ledger_rig/uhid.py,sha256=4GEc-Hk2EJWaqaX3LpLLnJ5PC3CcKbpc8APaPDjK5jY,1087
|
|
10
|
+
ledger_rig-0.2.0.dist-info/METADATA,sha256=RVZ9uDnxI4-ok5b8EbK8w-wsfZh1oU4-sAGhprC5pHw,958
|
|
11
|
+
ledger_rig-0.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
|
|
12
|
+
ledger_rig-0.2.0.dist-info/licenses/LICENSE,sha256=HMXQxBAyJZfhDUZnseR0QGBQUIqX3xhLNlRPNnLj6tY,1069
|
|
13
|
+
ledger_rig-0.2.0.dist-info/RECORD,,
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 CaliperForge
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|