fprintd-shim.py 41 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033
  1. #!/usr/bin/env python3
  2. """fprintd-compatible D-Bus service backed by the Wine-sandbox driver.
  3. Drop-in replacement for fprintd's daemon for the Synaptics 06cb:0081 sensor
  4. that libfprint cannot drive yet. It serves the `net.reactivated.Fprint` bus
  5. name with the same Manager/Device API, so GNOME Shell (lock-screen
  6. re-authentication), gnome-control-center and pam_fprintd work unchanged.
  7. Verification shells out to work/fp-verify.sh (vendor driver under Wine, run
  8. as the Wine-prefix owner). Enrollment and deletion drive the harness
  9. binaries built by work/artifacts/make-enroll-delete.sh:
  10. enroll.exe - default flow trimmed to enrollment (touch ~10 times)
  11. delete.exe - default flow with enroll() redirected to deleteRecord()
  12. (real sensor-side delete, ioctl 0x442034)
  13. The sensor stores a single template (identity c5698517-.../subfactor 0xF6),
  14. so the per-user finger list in state.json is a mapping onto that one
  15. template: deleting the last reported finger deletes the sensor record,
  16. deleting one of several only updates the reported list.
  17. Run with --session for a session-bus smoke test (no root needed, see
  18. selftest.py / apitest.py).
  19. """
  20. import argparse
  21. import glob
  22. import json
  23. import logging
  24. import os
  25. import select
  26. import signal
  27. import subprocess
  28. import sys
  29. import threading
  30. import time
  31. import gi
  32. gi.require_version('Gio', '2.0')
  33. gi.require_version('GLib', '2.0')
  34. from gi.repository import Gio, GLib # noqa: E402
  35. # ---------------------------------------------------------------- constants
  36. BUS_NAME = 'net.reactivated.Fprint'
  37. MANAGER_PATH = '/net/reactivated/Fprint/Manager'
  38. DEVICE_PATH = '/net/reactivated/Fprint/Device/0'
  39. IFACE_MANAGER = 'net.reactivated.Fprint.Manager'
  40. IFACE_DEVICE = 'net.reactivated.Fprint.Device'
  41. HERE = os.path.dirname(os.path.abspath(__file__))
  42. ROOT = os.path.dirname(os.path.dirname(HERE))
  43. VERIFY_SCRIPT = os.path.join(ROOT, 'work', 'fp-verify.sh')
  44. SANDBOX = os.path.join(ROOT, 'work', 'synaWudfBioUsb-sandbox')
  45. WINE64 = os.path.join(ROOT, 'work', 'wine-build', 'install', 'bin', 'wine64')
  46. ENROLL_EXE = 'enroll.exe'
  47. DELETE_EXE = 'delete.exe'
  48. # same lock file as work/fp-verify.sh: one sensor access at a time
  49. VERIFY_LOCK = '/tmp/opencode/fp-verify.lock'
  50. RUN_USER = 'nebulon'
  51. STATE_DIR = os.environ.get('FP_SHIM_STATE_DIR', '/var/lib/fprintd-shim')
  52. STATE_FILE = os.path.join(STATE_DIR, 'state.json')
  53. DEVICE_NAME = 'Synaptics 06cb:0081'
  54. SCAN_TYPE = 'press'
  55. NUM_ENROLL_STAGES = 10
  56. # pam_fprintd's default per-attempt timeout is 30 s; end our run slightly
  57. # earlier so a no-touch attempt is a clean pam timeout instead of a bogus
  58. # "failed to match".
  59. VERIFY_TIMEOUT = int(os.environ.get('FP_SHIM_VERIFY_TIMEOUT', '26'))
  60. ENROLL_TIMEOUT = int(os.environ.get('FP_SHIM_ENROLL_TIMEOUT', '900'))
  61. DELETE_TIMEOUT = int(os.environ.get('FP_SHIM_DELETE_TIMEOUT', '180'))
  62. FINGERS = [
  63. 'left-thumb', 'left-index-finger', 'left-middle-finger', 'left-ring-finger',
  64. 'left-little-finger', 'right-thumb', 'right-index-finger',
  65. 'right-middle-finger', 'right-ring-finger', 'right-little-finger',
  66. ]
  67. # Bus errors
  68. E_ALREADY_IN_USE = 'net.reactivated.Fprint.Error.AlreadyInUse'
  69. E_CLAIM_DEVICE = 'net.reactivated.Fprint.Error.ClaimDevice'
  70. E_INTERNAL = 'net.reactivated.Fprint.Error.Internal'
  71. E_INVALID_FINGERNAME = 'net.reactivated.Fprint.Error.InvalidFingername'
  72. E_NO_ACTION = 'net.reactivated.Fprint.Error.NoActionInProgress'
  73. E_NO_ENROLLED_PRINTS = 'net.reactivated.Fprint.Error.NoEnrolledPrints'
  74. E_NO_SUCH_DEVICE = 'net.reactivated.Fprint.Error.NoSuchDevice'
  75. E_PERMISSION_DENIED = 'net.reactivated.Fprint.Error.PermissionDenied'
  76. E_PRINTS_NOT_DELETED = 'net.reactivated.Fprint.Error.PrintsNotDeleted'
  77. log = logging.getLogger('fprintd-shim')
  78. MANAGER_XML = """
  79. <node>
  80. <interface name="net.reactivated.Fprint.Manager">
  81. <method name="GetDevices">
  82. <arg type="ao" name="devices" direction="out"/>
  83. </method>
  84. <method name="GetDefaultDevice">
  85. <arg type="o" name="device" direction="out"/>
  86. </method>
  87. </interface>
  88. </node>
  89. """
  90. DEVICE_XML = """
  91. <node>
  92. <interface name="net.reactivated.Fprint.Device">
  93. <method name="ListEnrolledFingers">
  94. <arg type="s" name="username" direction="in"/>
  95. <arg type="as" name="enrolled_fingers" direction="out"/>
  96. </method>
  97. <method name="DeleteEnrolledFingers">
  98. <arg type="s" name="username" direction="in"/>
  99. </method>
  100. <method name="DeleteEnrolledFingers2"/>
  101. <method name="DeleteEnrolledFinger">
  102. <arg type="s" name="finger_name" direction="in"/>
  103. </method>
  104. <method name="Claim">
  105. <arg type="s" name="username" direction="in"/>
  106. </method>
  107. <method name="Release"/>
  108. <method name="VerifyStart">
  109. <arg type="s" name="finger_name" direction="in"/>
  110. </method>
  111. <method name="VerifyStop"/>
  112. <method name="EnrollStart">
  113. <arg type="s" name="finger_name" direction="in"/>
  114. </method>
  115. <method name="EnrollStop"/>
  116. <signal name="VerifyFingerSelected">
  117. <arg type="s" name="finger_name"/>
  118. </signal>
  119. <signal name="VerifyStatus">
  120. <arg type="s" name="result"/>
  121. <arg type="b" name="done"/>
  122. </signal>
  123. <signal name="EnrollStatus">
  124. <arg type="s" name="result"/>
  125. <arg type="b" name="done"/>
  126. </signal>
  127. <property name="name" type="s" access="read"/>
  128. <property name="num-enroll-stages" type="i" access="read"/>
  129. <property name="scan-type" type="s" access="read"/>
  130. <property name="finger-present" type="b" access="read"/>
  131. <property name="finger-needed" type="b" access="read"/>
  132. </interface>
  133. </node>
  134. """
  135. def sensor_present():
  136. """06cb:0081 attached? Mirrors fprintd's "no devices" behaviour."""
  137. try:
  138. for dev in glob.glob('/sys/bus/usb/devices/*'):
  139. try:
  140. with open(os.path.join(dev, 'idVendor')) as f:
  141. vid = f.read().strip()
  142. if vid != '06cb':
  143. continue
  144. with open(os.path.join(dev, 'idProduct')) as f:
  145. pid = f.read().strip()
  146. if pid == '0081':
  147. return True
  148. except OSError:
  149. continue
  150. except OSError:
  151. pass
  152. return False
  153. def default_fingers(user):
  154. """Before any enroll/delete through the shim the sensor already holds the
  155. template enrolled with run_aexe.sh; report it for the workstation user."""
  156. return ['right-index-finger'] if user == RUN_USER else []
  157. def load_state():
  158. try:
  159. with open(STATE_FILE, encoding='utf-8') as f:
  160. state = json.load(f)
  161. if isinstance(state, dict) and isinstance(state.get('users'), dict):
  162. return state
  163. log.warning('%s: unexpected layout, ignoring', STATE_FILE)
  164. except FileNotFoundError:
  165. pass
  166. except (OSError, ValueError) as e:
  167. log.warning('cannot read %s: %s', STATE_FILE, e)
  168. return {'users': {}}
  169. def save_state(state):
  170. os.makedirs(STATE_DIR, mode=0o700, exist_ok=True)
  171. tmp = f'{STATE_FILE}.tmp'
  172. with open(tmp, 'w', encoding='utf-8') as f:
  173. json.dump(state, f, indent=2, sort_keys=True)
  174. f.write('\n')
  175. os.replace(tmp, STATE_FILE)
  176. class ShimDevice:
  177. def __init__(self):
  178. self.conn = None
  179. self.claimed_by = None # unique bus name of the claiming client
  180. self.claimed_user = None
  181. self.lock = threading.Lock()
  182. self.verify_proc = None
  183. self.verify_thread = None
  184. self.verify_cancel = threading.Event()
  185. self.verifying = False
  186. self.enroll_proc = None
  187. self.enroll_thread = None
  188. self.enroll_cancel = threading.Event()
  189. self.enrolling = False
  190. self._enroll_commit_started = False
  191. self.delete_proc = None
  192. self.delete_cancel = threading.Event()
  193. self.deleting = False
  194. self.finger_present = False
  195. self.finger_needed = False
  196. # ------------------------------------------------------------ state
  197. def enrolled_fingers(self, user):
  198. if not user:
  199. user = RUN_USER
  200. users = load_state().get('users', {})
  201. if user in users:
  202. return list(users[user])
  203. return default_fingers(user)
  204. def _set_enrolled_fingers(self, user, fingers):
  205. state = load_state()
  206. state.setdefault('users', {})[user] = sorted(set(fingers))
  207. save_state(state)
  208. def _selected_finger(self, finger):
  209. """fprintd reports the concrete finger chosen for 'any'."""
  210. if finger != 'any':
  211. return finger
  212. fingers = self.enrolled_fingers(self.claimed_user)
  213. return fingers[0] if fingers else 'right-index-finger'
  214. def _busy(self):
  215. return self.verifying or self.enrolling or self.deleting
  216. # ------------------------------------------------------- emission
  217. def _emit(self, name, variant):
  218. GLib.idle_add(self._emit_now, name, variant)
  219. def _emit_now(self, name, variant):
  220. if self.conn is not None:
  221. try:
  222. self.conn.emit_signal(None, DEVICE_PATH, IFACE_DEVICE, name,
  223. variant)
  224. except GLib.Error as e:
  225. log.warning('cannot emit %s: %s', name, e.message)
  226. return GLib.SOURCE_REMOVE
  227. def _notify_properties(self, changed):
  228. if self.conn is None:
  229. return
  230. try:
  231. self.conn.emit_signal(
  232. None, DEVICE_PATH, 'org.freedesktop.DBus.Properties',
  233. 'PropertiesChanged',
  234. GLib.Variant('(sa{sv}as)', (IFACE_DEVICE, changed, [])))
  235. except GLib.Error as e:
  236. log.warning('cannot emit PropertiesChanged: %s', e.message)
  237. def _set_finger_present(self, value):
  238. if self.finger_present == value:
  239. return
  240. self.finger_present = value
  241. self._notify_properties({'finger-present': GLib.Variant('b', value)})
  242. def _set_finger_needed(self, value):
  243. if self.finger_needed == value:
  244. return
  245. self.finger_needed = value
  246. self._notify_properties({'finger-needed': GLib.Variant('b', value)})
  247. # ------------------------------------------------------- claim ops
  248. def _release_claim(self, shutdown=False):
  249. self._stop_verify(quiet=True)
  250. self._stop_enroll(quiet=True)
  251. # A running delete is deliberately left to finish: it mutates the
  252. # device and aborting it can leave a partially written record (the
  253. # client may already be gone; the state is updated when it completes).
  254. if shutdown:
  255. self._stop_delete(quiet=True)
  256. self.claimed_by = None
  257. self.claimed_user = None
  258. self._notify_properties({'num-enroll-stages': GLib.Variant('i', -1)})
  259. def _check_claim(self, sender, invocation):
  260. """fprintd's _fprint_device_check_claimed for STATE_CLAIMED calls."""
  261. if self.claimed_by is None:
  262. invocation.return_dbus_error(E_CLAIM_DEVICE,
  263. 'Device was not claimed before use')
  264. return False
  265. if self.claimed_by != sender:
  266. invocation.return_dbus_error(E_ALREADY_IN_USE,
  267. 'Device already in use by another user')
  268. return False
  269. return True
  270. # ------------------------------------------------------ process ops
  271. def _kill_proc(self, proc):
  272. if proc is None or proc.poll() is not None:
  273. return
  274. try:
  275. os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
  276. except (ProcessLookupError, PermissionError):
  277. return
  278. try:
  279. proc.wait(timeout=5)
  280. except subprocess.TimeoutExpired:
  281. try:
  282. os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
  283. except (ProcessLookupError, PermissionError):
  284. pass
  285. def _harness_env(self, binary):
  286. env = os.environ.copy()
  287. usb_script = f'/tmp/opencode/usb-{binary}-{int(time.time())}.txt'
  288. try:
  289. os.makedirs('/tmp/opencode', exist_ok=True)
  290. # The fake winusb opens USB_SCRIPT for write ("wt") *as the Wine
  291. # user* and does not check for failure - a root-owned file makes
  292. # the harness hang in init without a single message, so create it
  293. # as RUN_USER (verified: winusb.c WinUsb_Initialize).
  294. fd = os.open(usb_script, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o666)
  295. os.close(fd)
  296. if os.geteuid() == 0:
  297. import pwd
  298. pw = pwd.getpwnam(RUN_USER)
  299. os.chown(usb_script, pw.pw_uid, pw.pw_gid)
  300. except (OSError, KeyError) as e:
  301. log.warning('cannot prepare %s: %s', usb_script, e)
  302. env.update({
  303. 'HOME': os.path.join('/home', RUN_USER),
  304. 'WINEPREFIX': os.path.join(ROOT, 'work', 'wineprefix-48'),
  305. # keep wine quiet, but surface winusb/libfprint errors: a failed
  306. # libusb transfer makes the hacked winusb stub exit(0) silently
  307. 'WINEDEBUG': os.environ.get('FP_SHIM_WINEDEBUG', '-all,err+all'),
  308. 'USB_PLAYBACK': '',
  309. 'USB_SCRIPT': usb_script,
  310. })
  311. return env
  312. def _harness_cmd(self, binary):
  313. cmd = [WINE64, binary]
  314. if os.geteuid() == 0:
  315. cmd = ['setpriv', f'--reuid={RUN_USER}', f'--regid={RUN_USER}',
  316. '--init-groups'] + cmd
  317. # one sensor access at a time (same lock as work/fp-verify.sh)
  318. return ['flock', '-w', '60', VERIFY_LOCK] + cmd
  319. def _run_harness(self, binary, timeout, cancel, on_line, proc_slot=None,
  320. expect_markers=None, first_timeout=120):
  321. """Run the Wine harness, feed its stdout lines to on_line().
  322. Returns (status, returncode) with status in
  323. {'eof', 'cancelled', 'timeout', 'stalled'}; the process group is
  324. killed on cancel/timeout. 'stalled' means no line of
  325. expect_markers was seen within first_timeout (the winusb stub hangs
  326. silently when e.g. USB_SCRIPT is not writable by the Wine user).
  327. """
  328. env = self._harness_env(binary)
  329. harness_log = open(
  330. f'/tmp/opencode/harness-{binary}-{int(time.time())}.log',
  331. 'w', encoding='utf-8', errors='replace')
  332. log.info('%s: harness log %s', binary, harness_log.name)
  333. r, w = os.pipe()
  334. proc = subprocess.Popen(self._harness_cmd(binary), cwd=SANDBOX,
  335. env=env, stdin=subprocess.DEVNULL,
  336. stdout=w, stderr=w, start_new_session=True)
  337. os.close(w)
  338. if proc_slot is not None:
  339. proc_slot(proc)
  340. started = time.monotonic()
  341. deadline = started + timeout
  342. status = 'eof'
  343. buf = ''
  344. saw_first = not expect_markers
  345. def feed(chunk):
  346. nonlocal buf, saw_first
  347. buf += chunk
  348. while '\n' in buf:
  349. line, buf = buf.split('\n', 1)
  350. line = line.rstrip('\r')
  351. harness_log.write(line + '\n')
  352. harness_log.flush()
  353. if not saw_first and any(m in line for m in expect_markers):
  354. saw_first = True
  355. if on_line is not None:
  356. on_line(line)
  357. while True:
  358. if cancel.is_set():
  359. self._kill_proc(proc)
  360. status = 'cancelled'
  361. break
  362. if time.monotonic() > deadline:
  363. log.warning('%s: timeout after %ss', binary, timeout)
  364. self._kill_proc(proc)
  365. status = 'timeout'
  366. break
  367. if not saw_first and time.monotonic() - started > first_timeout:
  368. log.error('%s: no progress in %ss (winusb init hang?) - '
  369. 'killing; see %s', binary, first_timeout,
  370. harness_log.name)
  371. self._kill_proc(proc)
  372. status = 'stalled'
  373. break
  374. ready, _, _ = select.select([r], [], [], 0.2)
  375. if ready:
  376. try:
  377. chunk = os.read(r, 65536)
  378. except OSError:
  379. chunk = b''
  380. if not chunk:
  381. break
  382. feed(chunk.decode('utf-8', 'replace'))
  383. elif proc.poll() is not None:
  384. # child exited: drain whatever is left in the pipe
  385. while True:
  386. ready, _, _ = select.select([r], [], [], 0)
  387. if not ready:
  388. break
  389. try:
  390. chunk = os.read(r, 65536)
  391. except OSError:
  392. chunk = b''
  393. if not chunk:
  394. break
  395. feed(chunk.decode('utf-8', 'replace'))
  396. break
  397. code = proc.wait()
  398. os.close(r)
  399. harness_log.close()
  400. if proc_slot is not None:
  401. proc_slot(None)
  402. return status, code
  403. # ------------------------------------------------------ verify ops
  404. def _stop_verify(self, quiet=False):
  405. with self.lock:
  406. running = self.verifying
  407. self.verifying = False
  408. self.verify_cancel.set()
  409. proc = self.verify_proc
  410. self.verify_proc = None
  411. self._kill_proc(proc)
  412. if running and not quiet:
  413. log.info('verify stopped by client')
  414. return running
  415. def _verify_cmd(self):
  416. script = ['/bin/bash', VERIFY_SCRIPT]
  417. if os.geteuid() == 0:
  418. return ['setpriv', f'--reuid={RUN_USER}', f'--regid={RUN_USER}',
  419. '--init-groups'] + script
  420. # session-bus smoke test: we are already the prefix owner
  421. return script
  422. def _verify_worker(self, finger):
  423. try:
  424. self._emit('VerifyFingerSelected', GLib.Variant('(s)', (finger,)))
  425. env = os.environ.copy()
  426. env['FP_VERIFY_TIMEOUT'] = str(VERIFY_TIMEOUT)
  427. env['FP_VERIFY_QUIET'] = '1'
  428. env['FP_VERIFY_LOCK_WAIT'] = '20'
  429. for attempt in (1, 2): # one internal retry for flaky Wine/USB
  430. if self.verify_cancel.is_set():
  431. return
  432. started = time.monotonic()
  433. proc = subprocess.Popen(
  434. self._verify_cmd(), env=env, text=True,
  435. stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
  436. start_new_session=True)
  437. with self.lock:
  438. self.verify_proc = proc
  439. try:
  440. out, _ = proc.communicate(timeout=VERIFY_TIMEOUT + 20)
  441. except subprocess.TimeoutExpired:
  442. self._kill_proc(proc)
  443. out, _ = proc.communicate()
  444. rc = 124
  445. else:
  446. rc = proc.returncode
  447. elapsed = time.monotonic() - started
  448. for line in (out or '').splitlines():
  449. log.info('verify[%d]: %s', attempt, line)
  450. with self.lock:
  451. self.verify_proc = None
  452. if self.verify_cancel.is_set():
  453. return
  454. if rc == 0:
  455. self._emit('VerifyStatus',
  456. GLib.Variant('(sb)', ('verify-match', True)))
  457. return
  458. if rc == 1:
  459. self._emit('VerifyStatus',
  460. GLib.Variant('(sb)', ('verify-no-match', True)))
  461. return
  462. # rc 2: timeout (no finger) or Wine/USB error. A quick exit
  463. # means the sandbox failed before the touch window; retry once.
  464. if attempt == 1 and elapsed < VERIFY_TIMEOUT - 5:
  465. log.warning('verify run failed early (%.1fs, rc=%d), retrying',
  466. elapsed, rc)
  467. continue
  468. log.info('no terminal status (rc=%d after %.1fs); '
  469. 'pam_fprintd will time out', rc, elapsed)
  470. return
  471. finally:
  472. with self.lock:
  473. self.verify_proc = None
  474. # NOTE: keep self.verifying set after a terminal status: fprintd's
  475. # action stays ACTION_VERIFY until VerifyStop/Release (clients like
  476. # fprintd-verify call VerifyStop after the result and expect it to
  477. # succeed).
  478. def _start_verify(self, finger):
  479. with self.lock:
  480. if self._busy():
  481. return False
  482. self.verifying = True
  483. self.verify_cancel.clear()
  484. self.verify_thread = threading.Thread(
  485. target=self._verify_worker, args=(finger,), daemon=True)
  486. self.verify_thread.start()
  487. return True
  488. # ------------------------------------------------------ enroll ops
  489. def _stop_enroll(self, quiet=False):
  490. with self.lock:
  491. running = self.enrolling
  492. commit_started = self._enroll_commit_started
  493. proc = self.enroll_proc
  494. if commit_started and proc is not None and proc.poll() is None:
  495. # The template write is in flight: let it finish instead of
  496. # risking a partially written record. The action stays "in
  497. # progress" until the worker completes.
  498. log.info('enroll: commit in progress, not aborting')
  499. return running
  500. with self.lock:
  501. self.enrolling = False
  502. self.enroll_cancel.set()
  503. self.enroll_proc = None
  504. self._kill_proc(proc)
  505. self._set_finger_needed(False)
  506. self._set_finger_present(False)
  507. if running and not quiet:
  508. log.info('enrollment stopped by client')
  509. return running
  510. def _enroll_worker(self, user, finger):
  511. """Drive `wine enroll.exe`; map the harness output to EnrollStatus.
  512. Markers (see hello.cc enroll()/commitEnrollment()):
  513. "about to Create Enrollment"
  514. "about to IOCTL_BIOMETRIC_CAPTURE_DATA" <- waiting for a touch
  515. "about to Update Enrollment" <- capture accepted
  516. "Got back 0x.. bytes: <hex>" <- response; hex[1:2] is
  517. the stage state (00 = done)
  518. "about to Check For Duplicate" / "about to Commit Enrollment"
  519. A capture marker that follows another capture marker (without an
  520. Update Enrollment in between) is a rejected scan (SensorStatus 2).
  521. """
  522. st = {'capture_open': False, 'expect': None, 'stages': 0,
  523. 'complete': False, 'committed': False}
  524. def on_line(line):
  525. if line == 'about to IOCTL_BIOMETRIC_CAPTURE_DATA':
  526. if st['capture_open']:
  527. log.info('enroll: scan rejected, retry')
  528. self._emit('EnrollStatus',
  529. GLib.Variant('(sb)', ('enroll-retry-scan', False)))
  530. self._set_finger_present(False)
  531. st['capture_open'] = True
  532. st['expect'] = None
  533. self._set_finger_needed(True)
  534. elif line == 'about to Update Enrollment':
  535. st['capture_open'] = False
  536. st['expect'] = 'update'
  537. self._set_finger_needed(False)
  538. self._set_finger_present(True)
  539. elif line == 'about to Check For Duplicate':
  540. st['expect'] = 'duplicate'
  541. elif line == 'about to Commit Enrollment':
  542. st['expect'] = 'commit'
  543. self._enroll_commit_started = True
  544. elif line.startswith('Got back 0x') and st['expect']:
  545. kind, st['expect'] = st['expect'], None
  546. hexpart = line.split(':', 1)[1].strip() if ':' in line else ''
  547. first = hexpart[:2].lower()
  548. if kind == 'update':
  549. self._set_finger_present(False)
  550. if first == '00':
  551. st['complete'] = True
  552. else:
  553. st['stages'] += 1
  554. log.info('enroll: stage %d passed', st['stages'])
  555. self._emit('EnrollStatus',
  556. GLib.Variant('(sb)', ('enroll-stage-passed', False)))
  557. self._set_finger_needed(True)
  558. elif kind == 'commit':
  559. st['committed'] = True
  560. log.info('enroll: committed')
  561. self._set_finger_present(False)
  562. self._set_finger_needed(False)
  563. def slot(proc):
  564. with self.lock:
  565. self.enroll_proc = proc
  566. try:
  567. # A commit that replaces an existing record makes the device
  568. # re-enumerate mid-write; the hacked winusb stub cannot detect
  569. # reconnects and exits with LIBUSB_ERROR_NO_DEVICE (verified
  570. # 2026-10-15 13:11-13:12, harness logs). The delete ioctl does
  571. # not reset the device, and a fresh write commits reliably, so
  572. # clear any existing record first.
  573. if self.enrolled_fingers(user):
  574. log.info('enroll: existing record for %s, deleting it first',
  575. user)
  576. dstatus, dcode = self._run_harness(
  577. DELETE_EXE, DELETE_TIMEOUT, self.enroll_cancel, None, slot,
  578. expect_markers=('about to 442034',))
  579. d_ok = (dstatus == 'eof' and dcode == 0)
  580. log.info('enroll: pre-delete %s (harness %s rc=%s)',
  581. 'ok' if d_ok else 'FAILED', dstatus, dcode)
  582. if d_ok:
  583. # the device has no record now: report that honestly even if
  584. # the enrollment is aborted later on
  585. self._set_enrolled_fingers(user, [])
  586. if self.enroll_cancel.is_set():
  587. log.info('enroll: cancelled before start')
  588. return
  589. status, code = self._run_harness(
  590. ENROLL_EXE, ENROLL_TIMEOUT, self.enroll_cancel, on_line, slot,
  591. expect_markers=('about to setMode', 'about to Create Enrollment',
  592. 'about to IOCTL_BIOMETRIC_CAPTURE_DATA'))
  593. # A committed template is on the device even if the client went
  594. # away meanwhile: always record it and report completion.
  595. if st['committed']:
  596. self._set_enrolled_fingers(user, [finger])
  597. log.info('enroll: user %s -> %s (harness %s rc=%s)',
  598. user, finger, status, code)
  599. self._emit('EnrollStatus',
  600. GLib.Variant('(sb)', ('enroll-completed', True)))
  601. elif self.enroll_cancel.is_set():
  602. log.info('enroll: cancelled')
  603. else:
  604. log.warning('enroll: not committed (harness %s rc=%s, '
  605. '%d stages)', status, code, st['stages'])
  606. self._emit('EnrollStatus',
  607. GLib.Variant('(sb)', ('enroll-failed', True)))
  608. finally:
  609. with self.lock:
  610. self.enroll_proc = None
  611. if self.claimed_by is None or self.enroll_cancel.is_set():
  612. # no client is waiting for a stop reply any more
  613. self.enrolling = False
  614. self._set_finger_needed(False)
  615. self._set_finger_present(False)
  616. # NOTE: like verify, keep self.enrolling set (pending EnrollStop)
  617. # when the client is still connected after a terminal status.
  618. def _start_enroll(self, user, finger):
  619. with self.lock:
  620. if self._busy():
  621. return False
  622. self.enrolling = True
  623. self._enroll_commit_started = False
  624. self.enroll_cancel.clear()
  625. self.enroll_thread = threading.Thread(
  626. target=self._enroll_worker, args=(user, finger), daemon=True)
  627. self.enroll_thread.start()
  628. return True
  629. # ------------------------------------------------------ delete ops
  630. def _stop_delete(self, quiet=True):
  631. with self.lock:
  632. running = self.deleting
  633. self.deleting = False
  634. proc = self.delete_proc
  635. self.delete_proc = None
  636. self.delete_cancel.set()
  637. self._kill_proc(proc)
  638. if running and not quiet:
  639. log.info('delete cancelled')
  640. return running
  641. def _delete_worker(self, invocation, user, remove):
  642. """Remove fingers from the reported list; when the list becomes empty
  643. also delete the sensor-side template (delete.exe)."""
  644. ok, message = True, None
  645. try:
  646. fingers = self.enrolled_fingers(user)
  647. remaining = [f for f in fingers if f not in remove]
  648. if fingers and not remaining:
  649. # Optimistic state update: the client (gnome-control-center)
  650. # re-reads the list right after the call and gives up after
  651. # ~10 s - reflect the deletion immediately, restore below if
  652. # the harness fails.
  653. self._set_enrolled_fingers(user, remaining)
  654. def slot(proc):
  655. with self.lock:
  656. self.delete_proc = proc
  657. status, code = self._run_harness(
  658. DELETE_EXE, DELETE_TIMEOUT, self.delete_cancel, None, slot,
  659. expect_markers=('about to 442034',))
  660. ok = (status == 'eof' and code == 0)
  661. log.info('delete: sensor record removal %s (harness %s rc=%s)',
  662. 'ok' if ok else 'FAILED', status, code)
  663. if not ok:
  664. message = 'Could not delete the print from the device'
  665. self._set_enrolled_fingers(user, fingers) # restore
  666. elif remaining:
  667. self._set_enrolled_fingers(user, remaining)
  668. # NOTE: the state update happens even if the client released the
  669. # claim meanwhile - the device record is gone and must not be
  670. # reported as enrolled.
  671. except Exception:
  672. log.exception('delete failed')
  673. ok, message = False, 'Internal error while deleting'
  674. finally:
  675. with self.lock:
  676. self.delete_proc = None
  677. self.deleting = False
  678. GLib.idle_add(self._finish_delete, invocation, ok, message)
  679. def _finish_delete(self, invocation, ok, message):
  680. try:
  681. if ok:
  682. invocation.return_value(None)
  683. else:
  684. invocation.return_dbus_error(
  685. E_PRINTS_NOT_DELETED,
  686. message or 'Fingerprint was not deleted')
  687. except GLib.Error as e:
  688. # client already gave up / connection closed
  689. log.info('delete reply not delivered: %s', e.message)
  690. return GLib.SOURCE_REMOVE
  691. # ------------------------------------------------ D-Bus callbacks
  692. def on_method_call(self, conn, sender, path, iface, method, params, invocation):
  693. try:
  694. self._dispatch(sender, path, iface, method, params, invocation)
  695. except Exception: # never kill the service on a bug
  696. log.exception('method %s.%s failed', iface, method)
  697. invocation.return_dbus_error(E_INTERNAL, 'shim internal error')
  698. def _dispatch(self, sender, path, iface, method, params, invocation):
  699. if iface == IFACE_MANAGER:
  700. return self._dispatch_manager(method, invocation)
  701. if iface == IFACE_DEVICE:
  702. return self._dispatch_device(sender, method, params, invocation)
  703. invocation.return_dbus_error(E_INTERNAL, f'unknown interface {iface}')
  704. def _dispatch_manager(self, method, invocation):
  705. if method == 'GetDevices':
  706. devices = [DEVICE_PATH] if sensor_present() else []
  707. invocation.return_value(GLib.Variant('(ao)', (devices,)))
  708. elif method == 'GetDefaultDevice':
  709. if not sensor_present():
  710. invocation.return_dbus_error(E_NO_SUCH_DEVICE,
  711. 'No fingerprint device present')
  712. else:
  713. invocation.return_value(GLib.Variant('(o)', (DEVICE_PATH,)))
  714. else:
  715. invocation.return_dbus_error(E_INTERNAL, f'unknown method {method}')
  716. def _dispatch_device(self, sender, method, params, invocation):
  717. if method == 'ListEnrolledFingers':
  718. (user,) = params.unpack()
  719. fingers = self.enrolled_fingers(user)
  720. if not fingers:
  721. invocation.return_dbus_error(
  722. E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
  723. else:
  724. invocation.return_value(GLib.Variant('(as)', (fingers,)))
  725. elif method == 'Claim':
  726. (user,) = params.unpack()
  727. if self.claimed_by is not None:
  728. invocation.return_dbus_error(E_ALREADY_IN_USE,
  729. 'Device already in use')
  730. return
  731. self.claimed_by = sender
  732. self.claimed_user = user or RUN_USER
  733. log.info('claim by %s for user %s', sender, self.claimed_user)
  734. self._notify_properties(
  735. {'num-enroll-stages': GLib.Variant('i', NUM_ENROLL_STAGES)})
  736. invocation.return_value(None)
  737. elif method == 'Release':
  738. if not self._check_claim(sender, invocation):
  739. return
  740. self._release_claim()
  741. log.info('release by %s', sender)
  742. invocation.return_value(None)
  743. elif method == 'VerifyStart':
  744. (finger,) = params.unpack()
  745. if not self._check_claim(sender, invocation):
  746. return
  747. if finger not in FINGERS and finger != 'any':
  748. invocation.return_dbus_error(E_INVALID_FINGERNAME,
  749. f'Invalid finger name {finger}')
  750. return
  751. fingers = self.enrolled_fingers(self.claimed_user)
  752. if not fingers or (finger != 'any' and finger not in fingers):
  753. invocation.return_dbus_error(
  754. E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
  755. return
  756. if not self._start_verify(self._selected_finger(finger)):
  757. invocation.return_dbus_error(E_ALREADY_IN_USE,
  758. 'Another operation is in progress')
  759. return
  760. log.info('verify start (%s) by %s', finger, sender)
  761. invocation.return_value(None)
  762. elif method == 'VerifyStop':
  763. if not self._check_claim(sender, invocation):
  764. return
  765. if not self._stop_verify():
  766. invocation.return_dbus_error(E_NO_ACTION,
  767. 'No verification in progress')
  768. return
  769. invocation.return_value(None)
  770. elif method == 'EnrollStart':
  771. (finger,) = params.unpack()
  772. if not self._check_claim(sender, invocation):
  773. return
  774. if finger not in FINGERS:
  775. invocation.return_dbus_error(
  776. E_INVALID_FINGERNAME,
  777. f'Invalid finger name {finger} (not "any")')
  778. return
  779. if not self._start_enroll(self.claimed_user, finger):
  780. invocation.return_dbus_error(E_ALREADY_IN_USE,
  781. 'Another operation is in progress')
  782. return
  783. log.info('enroll start (%s) by %s', finger, sender)
  784. invocation.return_value(None)
  785. elif method == 'EnrollStop':
  786. if not self._check_claim(sender, invocation):
  787. return
  788. if not self._stop_enroll():
  789. invocation.return_dbus_error(E_NO_ACTION,
  790. 'No enrollment in progress')
  791. return
  792. invocation.return_value(None)
  793. elif method == 'DeleteEnrolledFinger':
  794. (finger,) = params.unpack()
  795. if not self._check_claim(sender, invocation):
  796. return
  797. if finger not in FINGERS:
  798. invocation.return_dbus_error(E_INVALID_FINGERNAME,
  799. f'Invalid finger name {finger}')
  800. return
  801. if self._busy():
  802. invocation.return_dbus_error(E_ALREADY_IN_USE,
  803. 'Another operation is in progress')
  804. return
  805. fingers = self.enrolled_fingers(self.claimed_user)
  806. if finger not in fingers:
  807. invocation.return_dbus_error(
  808. E_NO_ENROLLED_PRINTS,
  809. f'Finger {finger} is not enrolled for this user')
  810. return
  811. self._start_delete(invocation, self.claimed_user, [finger])
  812. elif method == 'DeleteEnrolledFingers2':
  813. if not self._check_claim(sender, invocation):
  814. return
  815. if self._busy():
  816. invocation.return_dbus_error(E_ALREADY_IN_USE,
  817. 'Another operation is in progress')
  818. return
  819. fingers = self.enrolled_fingers(self.claimed_user)
  820. if not fingers:
  821. invocation.return_dbus_error(
  822. E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
  823. return
  824. self._start_delete(invocation, self.claimed_user, fingers)
  825. elif method == 'DeleteEnrolledFingers':
  826. (user,) = params.unpack()
  827. user = user or self.claimed_user or RUN_USER
  828. if user != RUN_USER:
  829. invocation.return_dbus_error(
  830. E_PERMISSION_DENIED,
  831. 'Only the local user is supported by the shim')
  832. return
  833. if self.claimed_by is not None and self.claimed_by != sender:
  834. invocation.return_dbus_error(E_ALREADY_IN_USE,
  835. 'Device already in use by another user')
  836. return
  837. if self._busy():
  838. invocation.return_dbus_error(E_ALREADY_IN_USE,
  839. 'Another operation is in progress')
  840. return
  841. fingers = self.enrolled_fingers(user)
  842. if not fingers:
  843. invocation.return_dbus_error(
  844. E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
  845. return
  846. self._start_delete(invocation, user, fingers)
  847. else:
  848. invocation.return_dbus_error(E_INTERNAL, f'unknown method {method}')
  849. def _start_delete(self, invocation, user, remove):
  850. with self.lock:
  851. if self._busy():
  852. invocation.return_dbus_error(E_ALREADY_IN_USE,
  853. 'Another operation is in progress')
  854. return
  855. self.deleting = True
  856. self.delete_cancel.clear()
  857. log.info('delete start: user=%s fingers=%s', user, ','.join(remove))
  858. thread = threading.Thread(target=self._delete_worker,
  859. args=(invocation, user, remove), daemon=True)
  860. thread.start()
  861. def on_get_property(self, conn, sender, path, iface, prop):
  862. if iface != IFACE_DEVICE:
  863. return None
  864. if prop == 'name':
  865. return GLib.Variant('s', DEVICE_NAME)
  866. if prop == 'scan-type':
  867. return GLib.Variant('s', SCAN_TYPE)
  868. if prop == 'num-enroll-stages':
  869. stages = NUM_ENROLL_STAGES if self.claimed_by else -1
  870. return GLib.Variant('i', stages)
  871. if prop == 'finger-present':
  872. return GLib.Variant('b', self.finger_present)
  873. if prop == 'finger-needed':
  874. return GLib.Variant('b', self.finger_needed)
  875. return None
  876. def on_name_owner_changed(self, conn, sender, path, iface, signal_name, params):
  877. name, _old, new = params.unpack()
  878. if new:
  879. return
  880. if name == self.claimed_by:
  881. log.info('claiming client %s vanished, releasing device', name)
  882. self._release_claim()
  883. def main():
  884. parser = argparse.ArgumentParser(description=__doc__)
  885. parser.add_argument('--session', action='store_true',
  886. help='own the name on the session bus (smoke test)')
  887. parser.add_argument('--debug', action='store_true')
  888. args = parser.parse_args()
  889. logging.basicConfig(
  890. level=logging.DEBUG if args.debug else logging.INFO,
  891. format='fprintd-shim: %(levelname)s: %(message)s',
  892. stream=sys.stderr)
  893. bus_type = Gio.BusType.SESSION if args.session else Gio.BusType.SYSTEM
  894. device = ShimDevice()
  895. loop = GLib.MainLoop()
  896. manager_info = Gio.DBusNodeInfo.new_for_xml(MANAGER_XML).interfaces[0]
  897. device_info = Gio.DBusNodeInfo.new_for_xml(DEVICE_XML).interfaces[0]
  898. def on_bus_acquired(conn, _name):
  899. device.conn = conn
  900. conn.register_object(MANAGER_PATH, manager_info,
  901. device.on_method_call, device.on_get_property, None)
  902. conn.register_object(DEVICE_PATH, device_info,
  903. device.on_method_call, device.on_get_property, None)
  904. conn.signal_subscribe(
  905. 'org.freedesktop.DBus', 'org.freedesktop.DBus', 'NameOwnerChanged',
  906. '/org/freedesktop/DBus', None, Gio.DBusSignalFlags.NONE,
  907. device.on_name_owner_changed)
  908. log.info('serving %s (device %s, state %s, enroll/delete via %s)',
  909. BUS_NAME, DEVICE_PATH, STATE_FILE, SANDBOX)
  910. def on_name_lost(_conn, _name):
  911. log.warning('lost bus name %s', BUS_NAME)
  912. device._release_claim()
  913. loop.quit()
  914. def on_term(_signum, _frame):
  915. log.info('shutting down')
  916. device._release_claim()
  917. loop.quit()
  918. signal.signal(signal.SIGTERM, on_term)
  919. signal.signal(signal.SIGINT, on_term)
  920. Gio.bus_own_name(bus_type, BUS_NAME, Gio.BusNameOwnerFlags.NONE,
  921. on_bus_acquired, None, on_name_lost)
  922. loop.run()
  923. if __name__ == '__main__':
  924. main()