| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033 |
- #!/usr/bin/env python3
- """fprintd-compatible D-Bus service backed by the Wine-sandbox driver.
- Drop-in replacement for fprintd's daemon for the Synaptics 06cb:0081 sensor
- that libfprint cannot drive yet. It serves the `net.reactivated.Fprint` bus
- name with the same Manager/Device API, so GNOME Shell (lock-screen
- re-authentication), gnome-control-center and pam_fprintd work unchanged.
- Verification shells out to work/fp-verify.sh (vendor driver under Wine, run
- as the Wine-prefix owner). Enrollment and deletion drive the harness
- binaries built by work/artifacts/make-enroll-delete.sh:
- enroll.exe - default flow trimmed to enrollment (touch ~10 times)
- delete.exe - default flow with enroll() redirected to deleteRecord()
- (real sensor-side delete, ioctl 0x442034)
- The sensor stores a single template (identity c5698517-.../subfactor 0xF6),
- so the per-user finger list in state.json is a mapping onto that one
- template: deleting the last reported finger deletes the sensor record,
- deleting one of several only updates the reported list.
- Run with --session for a session-bus smoke test (no root needed, see
- selftest.py / apitest.py).
- """
- import argparse
- import glob
- import json
- import logging
- import os
- import select
- import signal
- import subprocess
- import sys
- import threading
- import time
- import gi
- gi.require_version('Gio', '2.0')
- gi.require_version('GLib', '2.0')
- from gi.repository import Gio, GLib # noqa: E402
- # ---------------------------------------------------------------- constants
- BUS_NAME = 'net.reactivated.Fprint'
- MANAGER_PATH = '/net/reactivated/Fprint/Manager'
- DEVICE_PATH = '/net/reactivated/Fprint/Device/0'
- IFACE_MANAGER = 'net.reactivated.Fprint.Manager'
- IFACE_DEVICE = 'net.reactivated.Fprint.Device'
- HERE = os.path.dirname(os.path.abspath(__file__))
- ROOT = os.path.dirname(os.path.dirname(HERE))
- VERIFY_SCRIPT = os.path.join(ROOT, 'work', 'fp-verify.sh')
- SANDBOX = os.path.join(ROOT, 'work', 'synaWudfBioUsb-sandbox')
- WINE64 = os.path.join(ROOT, 'work', 'wine-build', 'install', 'bin', 'wine64')
- ENROLL_EXE = 'enroll.exe'
- DELETE_EXE = 'delete.exe'
- # same lock file as work/fp-verify.sh: one sensor access at a time
- VERIFY_LOCK = '/tmp/opencode/fp-verify.lock'
- RUN_USER = 'nebulon'
- STATE_DIR = os.environ.get('FP_SHIM_STATE_DIR', '/var/lib/fprintd-shim')
- STATE_FILE = os.path.join(STATE_DIR, 'state.json')
- DEVICE_NAME = 'Synaptics 06cb:0081'
- SCAN_TYPE = 'press'
- NUM_ENROLL_STAGES = 10
- # pam_fprintd's default per-attempt timeout is 30 s; end our run slightly
- # earlier so a no-touch attempt is a clean pam timeout instead of a bogus
- # "failed to match".
- VERIFY_TIMEOUT = int(os.environ.get('FP_SHIM_VERIFY_TIMEOUT', '26'))
- ENROLL_TIMEOUT = int(os.environ.get('FP_SHIM_ENROLL_TIMEOUT', '900'))
- DELETE_TIMEOUT = int(os.environ.get('FP_SHIM_DELETE_TIMEOUT', '180'))
- FINGERS = [
- 'left-thumb', 'left-index-finger', 'left-middle-finger', 'left-ring-finger',
- 'left-little-finger', 'right-thumb', 'right-index-finger',
- 'right-middle-finger', 'right-ring-finger', 'right-little-finger',
- ]
- # Bus errors
- E_ALREADY_IN_USE = 'net.reactivated.Fprint.Error.AlreadyInUse'
- E_CLAIM_DEVICE = 'net.reactivated.Fprint.Error.ClaimDevice'
- E_INTERNAL = 'net.reactivated.Fprint.Error.Internal'
- E_INVALID_FINGERNAME = 'net.reactivated.Fprint.Error.InvalidFingername'
- E_NO_ACTION = 'net.reactivated.Fprint.Error.NoActionInProgress'
- E_NO_ENROLLED_PRINTS = 'net.reactivated.Fprint.Error.NoEnrolledPrints'
- E_NO_SUCH_DEVICE = 'net.reactivated.Fprint.Error.NoSuchDevice'
- E_PERMISSION_DENIED = 'net.reactivated.Fprint.Error.PermissionDenied'
- E_PRINTS_NOT_DELETED = 'net.reactivated.Fprint.Error.PrintsNotDeleted'
- log = logging.getLogger('fprintd-shim')
- MANAGER_XML = """
- <node>
- <interface name="net.reactivated.Fprint.Manager">
- <method name="GetDevices">
- <arg type="ao" name="devices" direction="out"/>
- </method>
- <method name="GetDefaultDevice">
- <arg type="o" name="device" direction="out"/>
- </method>
- </interface>
- </node>
- """
- DEVICE_XML = """
- <node>
- <interface name="net.reactivated.Fprint.Device">
- <method name="ListEnrolledFingers">
- <arg type="s" name="username" direction="in"/>
- <arg type="as" name="enrolled_fingers" direction="out"/>
- </method>
- <method name="DeleteEnrolledFingers">
- <arg type="s" name="username" direction="in"/>
- </method>
- <method name="DeleteEnrolledFingers2"/>
- <method name="DeleteEnrolledFinger">
- <arg type="s" name="finger_name" direction="in"/>
- </method>
- <method name="Claim">
- <arg type="s" name="username" direction="in"/>
- </method>
- <method name="Release"/>
- <method name="VerifyStart">
- <arg type="s" name="finger_name" direction="in"/>
- </method>
- <method name="VerifyStop"/>
- <method name="EnrollStart">
- <arg type="s" name="finger_name" direction="in"/>
- </method>
- <method name="EnrollStop"/>
- <signal name="VerifyFingerSelected">
- <arg type="s" name="finger_name"/>
- </signal>
- <signal name="VerifyStatus">
- <arg type="s" name="result"/>
- <arg type="b" name="done"/>
- </signal>
- <signal name="EnrollStatus">
- <arg type="s" name="result"/>
- <arg type="b" name="done"/>
- </signal>
- <property name="name" type="s" access="read"/>
- <property name="num-enroll-stages" type="i" access="read"/>
- <property name="scan-type" type="s" access="read"/>
- <property name="finger-present" type="b" access="read"/>
- <property name="finger-needed" type="b" access="read"/>
- </interface>
- </node>
- """
- def sensor_present():
- """06cb:0081 attached? Mirrors fprintd's "no devices" behaviour."""
- try:
- for dev in glob.glob('/sys/bus/usb/devices/*'):
- try:
- with open(os.path.join(dev, 'idVendor')) as f:
- vid = f.read().strip()
- if vid != '06cb':
- continue
- with open(os.path.join(dev, 'idProduct')) as f:
- pid = f.read().strip()
- if pid == '0081':
- return True
- except OSError:
- continue
- except OSError:
- pass
- return False
- def default_fingers(user):
- """Before any enroll/delete through the shim the sensor already holds the
- template enrolled with run_aexe.sh; report it for the workstation user."""
- return ['right-index-finger'] if user == RUN_USER else []
- def load_state():
- try:
- with open(STATE_FILE, encoding='utf-8') as f:
- state = json.load(f)
- if isinstance(state, dict) and isinstance(state.get('users'), dict):
- return state
- log.warning('%s: unexpected layout, ignoring', STATE_FILE)
- except FileNotFoundError:
- pass
- except (OSError, ValueError) as e:
- log.warning('cannot read %s: %s', STATE_FILE, e)
- return {'users': {}}
- def save_state(state):
- os.makedirs(STATE_DIR, mode=0o700, exist_ok=True)
- tmp = f'{STATE_FILE}.tmp'
- with open(tmp, 'w', encoding='utf-8') as f:
- json.dump(state, f, indent=2, sort_keys=True)
- f.write('\n')
- os.replace(tmp, STATE_FILE)
- class ShimDevice:
- def __init__(self):
- self.conn = None
- self.claimed_by = None # unique bus name of the claiming client
- self.claimed_user = None
- self.lock = threading.Lock()
- self.verify_proc = None
- self.verify_thread = None
- self.verify_cancel = threading.Event()
- self.verifying = False
- self.enroll_proc = None
- self.enroll_thread = None
- self.enroll_cancel = threading.Event()
- self.enrolling = False
- self._enroll_commit_started = False
- self.delete_proc = None
- self.delete_cancel = threading.Event()
- self.deleting = False
- self.finger_present = False
- self.finger_needed = False
- # ------------------------------------------------------------ state
- def enrolled_fingers(self, user):
- if not user:
- user = RUN_USER
- users = load_state().get('users', {})
- if user in users:
- return list(users[user])
- return default_fingers(user)
- def _set_enrolled_fingers(self, user, fingers):
- state = load_state()
- state.setdefault('users', {})[user] = sorted(set(fingers))
- save_state(state)
- def _selected_finger(self, finger):
- """fprintd reports the concrete finger chosen for 'any'."""
- if finger != 'any':
- return finger
- fingers = self.enrolled_fingers(self.claimed_user)
- return fingers[0] if fingers else 'right-index-finger'
- def _busy(self):
- return self.verifying or self.enrolling or self.deleting
- # ------------------------------------------------------- emission
- def _emit(self, name, variant):
- GLib.idle_add(self._emit_now, name, variant)
- def _emit_now(self, name, variant):
- if self.conn is not None:
- try:
- self.conn.emit_signal(None, DEVICE_PATH, IFACE_DEVICE, name,
- variant)
- except GLib.Error as e:
- log.warning('cannot emit %s: %s', name, e.message)
- return GLib.SOURCE_REMOVE
- def _notify_properties(self, changed):
- if self.conn is None:
- return
- try:
- self.conn.emit_signal(
- None, DEVICE_PATH, 'org.freedesktop.DBus.Properties',
- 'PropertiesChanged',
- GLib.Variant('(sa{sv}as)', (IFACE_DEVICE, changed, [])))
- except GLib.Error as e:
- log.warning('cannot emit PropertiesChanged: %s', e.message)
- def _set_finger_present(self, value):
- if self.finger_present == value:
- return
- self.finger_present = value
- self._notify_properties({'finger-present': GLib.Variant('b', value)})
- def _set_finger_needed(self, value):
- if self.finger_needed == value:
- return
- self.finger_needed = value
- self._notify_properties({'finger-needed': GLib.Variant('b', value)})
- # ------------------------------------------------------- claim ops
- def _release_claim(self, shutdown=False):
- self._stop_verify(quiet=True)
- self._stop_enroll(quiet=True)
- # A running delete is deliberately left to finish: it mutates the
- # device and aborting it can leave a partially written record (the
- # client may already be gone; the state is updated when it completes).
- if shutdown:
- self._stop_delete(quiet=True)
- self.claimed_by = None
- self.claimed_user = None
- self._notify_properties({'num-enroll-stages': GLib.Variant('i', -1)})
- def _check_claim(self, sender, invocation):
- """fprintd's _fprint_device_check_claimed for STATE_CLAIMED calls."""
- if self.claimed_by is None:
- invocation.return_dbus_error(E_CLAIM_DEVICE,
- 'Device was not claimed before use')
- return False
- if self.claimed_by != sender:
- invocation.return_dbus_error(E_ALREADY_IN_USE,
- 'Device already in use by another user')
- return False
- return True
- # ------------------------------------------------------ process ops
- def _kill_proc(self, proc):
- if proc is None or proc.poll() is not None:
- return
- try:
- os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
- except (ProcessLookupError, PermissionError):
- return
- try:
- proc.wait(timeout=5)
- except subprocess.TimeoutExpired:
- try:
- os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
- except (ProcessLookupError, PermissionError):
- pass
- def _harness_env(self, binary):
- env = os.environ.copy()
- usb_script = f'/tmp/opencode/usb-{binary}-{int(time.time())}.txt'
- try:
- os.makedirs('/tmp/opencode', exist_ok=True)
- # The fake winusb opens USB_SCRIPT for write ("wt") *as the Wine
- # user* and does not check for failure - a root-owned file makes
- # the harness hang in init without a single message, so create it
- # as RUN_USER (verified: winusb.c WinUsb_Initialize).
- fd = os.open(usb_script, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o666)
- os.close(fd)
- if os.geteuid() == 0:
- import pwd
- pw = pwd.getpwnam(RUN_USER)
- os.chown(usb_script, pw.pw_uid, pw.pw_gid)
- except (OSError, KeyError) as e:
- log.warning('cannot prepare %s: %s', usb_script, e)
- env.update({
- 'HOME': os.path.join('/home', RUN_USER),
- 'WINEPREFIX': os.path.join(ROOT, 'work', 'wineprefix-48'),
- # keep wine quiet, but surface winusb/libfprint errors: a failed
- # libusb transfer makes the hacked winusb stub exit(0) silently
- 'WINEDEBUG': os.environ.get('FP_SHIM_WINEDEBUG', '-all,err+all'),
- 'USB_PLAYBACK': '',
- 'USB_SCRIPT': usb_script,
- })
- return env
- def _harness_cmd(self, binary):
- cmd = [WINE64, binary]
- if os.geteuid() == 0:
- cmd = ['setpriv', f'--reuid={RUN_USER}', f'--regid={RUN_USER}',
- '--init-groups'] + cmd
- # one sensor access at a time (same lock as work/fp-verify.sh)
- return ['flock', '-w', '60', VERIFY_LOCK] + cmd
- def _run_harness(self, binary, timeout, cancel, on_line, proc_slot=None,
- expect_markers=None, first_timeout=120):
- """Run the Wine harness, feed its stdout lines to on_line().
- Returns (status, returncode) with status in
- {'eof', 'cancelled', 'timeout', 'stalled'}; the process group is
- killed on cancel/timeout. 'stalled' means no line of
- expect_markers was seen within first_timeout (the winusb stub hangs
- silently when e.g. USB_SCRIPT is not writable by the Wine user).
- """
- env = self._harness_env(binary)
- harness_log = open(
- f'/tmp/opencode/harness-{binary}-{int(time.time())}.log',
- 'w', encoding='utf-8', errors='replace')
- log.info('%s: harness log %s', binary, harness_log.name)
- r, w = os.pipe()
- proc = subprocess.Popen(self._harness_cmd(binary), cwd=SANDBOX,
- env=env, stdin=subprocess.DEVNULL,
- stdout=w, stderr=w, start_new_session=True)
- os.close(w)
- if proc_slot is not None:
- proc_slot(proc)
- started = time.monotonic()
- deadline = started + timeout
- status = 'eof'
- buf = ''
- saw_first = not expect_markers
- def feed(chunk):
- nonlocal buf, saw_first
- buf += chunk
- while '\n' in buf:
- line, buf = buf.split('\n', 1)
- line = line.rstrip('\r')
- harness_log.write(line + '\n')
- harness_log.flush()
- if not saw_first and any(m in line for m in expect_markers):
- saw_first = True
- if on_line is not None:
- on_line(line)
- while True:
- if cancel.is_set():
- self._kill_proc(proc)
- status = 'cancelled'
- break
- if time.monotonic() > deadline:
- log.warning('%s: timeout after %ss', binary, timeout)
- self._kill_proc(proc)
- status = 'timeout'
- break
- if not saw_first and time.monotonic() - started > first_timeout:
- log.error('%s: no progress in %ss (winusb init hang?) - '
- 'killing; see %s', binary, first_timeout,
- harness_log.name)
- self._kill_proc(proc)
- status = 'stalled'
- break
- ready, _, _ = select.select([r], [], [], 0.2)
- if ready:
- try:
- chunk = os.read(r, 65536)
- except OSError:
- chunk = b''
- if not chunk:
- break
- feed(chunk.decode('utf-8', 'replace'))
- elif proc.poll() is not None:
- # child exited: drain whatever is left in the pipe
- while True:
- ready, _, _ = select.select([r], [], [], 0)
- if not ready:
- break
- try:
- chunk = os.read(r, 65536)
- except OSError:
- chunk = b''
- if not chunk:
- break
- feed(chunk.decode('utf-8', 'replace'))
- break
- code = proc.wait()
- os.close(r)
- harness_log.close()
- if proc_slot is not None:
- proc_slot(None)
- return status, code
- # ------------------------------------------------------ verify ops
- def _stop_verify(self, quiet=False):
- with self.lock:
- running = self.verifying
- self.verifying = False
- self.verify_cancel.set()
- proc = self.verify_proc
- self.verify_proc = None
- self._kill_proc(proc)
- if running and not quiet:
- log.info('verify stopped by client')
- return running
- def _verify_cmd(self):
- script = ['/bin/bash', VERIFY_SCRIPT]
- if os.geteuid() == 0:
- return ['setpriv', f'--reuid={RUN_USER}', f'--regid={RUN_USER}',
- '--init-groups'] + script
- # session-bus smoke test: we are already the prefix owner
- return script
- def _verify_worker(self, finger):
- try:
- self._emit('VerifyFingerSelected', GLib.Variant('(s)', (finger,)))
- env = os.environ.copy()
- env['FP_VERIFY_TIMEOUT'] = str(VERIFY_TIMEOUT)
- env['FP_VERIFY_QUIET'] = '1'
- env['FP_VERIFY_LOCK_WAIT'] = '20'
- for attempt in (1, 2): # one internal retry for flaky Wine/USB
- if self.verify_cancel.is_set():
- return
- started = time.monotonic()
- proc = subprocess.Popen(
- self._verify_cmd(), env=env, text=True,
- stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
- start_new_session=True)
- with self.lock:
- self.verify_proc = proc
- try:
- out, _ = proc.communicate(timeout=VERIFY_TIMEOUT + 20)
- except subprocess.TimeoutExpired:
- self._kill_proc(proc)
- out, _ = proc.communicate()
- rc = 124
- else:
- rc = proc.returncode
- elapsed = time.monotonic() - started
- for line in (out or '').splitlines():
- log.info('verify[%d]: %s', attempt, line)
- with self.lock:
- self.verify_proc = None
- if self.verify_cancel.is_set():
- return
- if rc == 0:
- self._emit('VerifyStatus',
- GLib.Variant('(sb)', ('verify-match', True)))
- return
- if rc == 1:
- self._emit('VerifyStatus',
- GLib.Variant('(sb)', ('verify-no-match', True)))
- return
- # rc 2: timeout (no finger) or Wine/USB error. A quick exit
- # means the sandbox failed before the touch window; retry once.
- if attempt == 1 and elapsed < VERIFY_TIMEOUT - 5:
- log.warning('verify run failed early (%.1fs, rc=%d), retrying',
- elapsed, rc)
- continue
- log.info('no terminal status (rc=%d after %.1fs); '
- 'pam_fprintd will time out', rc, elapsed)
- return
- finally:
- with self.lock:
- self.verify_proc = None
- # NOTE: keep self.verifying set after a terminal status: fprintd's
- # action stays ACTION_VERIFY until VerifyStop/Release (clients like
- # fprintd-verify call VerifyStop after the result and expect it to
- # succeed).
- def _start_verify(self, finger):
- with self.lock:
- if self._busy():
- return False
- self.verifying = True
- self.verify_cancel.clear()
- self.verify_thread = threading.Thread(
- target=self._verify_worker, args=(finger,), daemon=True)
- self.verify_thread.start()
- return True
- # ------------------------------------------------------ enroll ops
- def _stop_enroll(self, quiet=False):
- with self.lock:
- running = self.enrolling
- commit_started = self._enroll_commit_started
- proc = self.enroll_proc
- if commit_started and proc is not None and proc.poll() is None:
- # The template write is in flight: let it finish instead of
- # risking a partially written record. The action stays "in
- # progress" until the worker completes.
- log.info('enroll: commit in progress, not aborting')
- return running
- with self.lock:
- self.enrolling = False
- self.enroll_cancel.set()
- self.enroll_proc = None
- self._kill_proc(proc)
- self._set_finger_needed(False)
- self._set_finger_present(False)
- if running and not quiet:
- log.info('enrollment stopped by client')
- return running
- def _enroll_worker(self, user, finger):
- """Drive `wine enroll.exe`; map the harness output to EnrollStatus.
- Markers (see hello.cc enroll()/commitEnrollment()):
- "about to Create Enrollment"
- "about to IOCTL_BIOMETRIC_CAPTURE_DATA" <- waiting for a touch
- "about to Update Enrollment" <- capture accepted
- "Got back 0x.. bytes: <hex>" <- response; hex[1:2] is
- the stage state (00 = done)
- "about to Check For Duplicate" / "about to Commit Enrollment"
- A capture marker that follows another capture marker (without an
- Update Enrollment in between) is a rejected scan (SensorStatus 2).
- """
- st = {'capture_open': False, 'expect': None, 'stages': 0,
- 'complete': False, 'committed': False}
- def on_line(line):
- if line == 'about to IOCTL_BIOMETRIC_CAPTURE_DATA':
- if st['capture_open']:
- log.info('enroll: scan rejected, retry')
- self._emit('EnrollStatus',
- GLib.Variant('(sb)', ('enroll-retry-scan', False)))
- self._set_finger_present(False)
- st['capture_open'] = True
- st['expect'] = None
- self._set_finger_needed(True)
- elif line == 'about to Update Enrollment':
- st['capture_open'] = False
- st['expect'] = 'update'
- self._set_finger_needed(False)
- self._set_finger_present(True)
- elif line == 'about to Check For Duplicate':
- st['expect'] = 'duplicate'
- elif line == 'about to Commit Enrollment':
- st['expect'] = 'commit'
- self._enroll_commit_started = True
- elif line.startswith('Got back 0x') and st['expect']:
- kind, st['expect'] = st['expect'], None
- hexpart = line.split(':', 1)[1].strip() if ':' in line else ''
- first = hexpart[:2].lower()
- if kind == 'update':
- self._set_finger_present(False)
- if first == '00':
- st['complete'] = True
- else:
- st['stages'] += 1
- log.info('enroll: stage %d passed', st['stages'])
- self._emit('EnrollStatus',
- GLib.Variant('(sb)', ('enroll-stage-passed', False)))
- self._set_finger_needed(True)
- elif kind == 'commit':
- st['committed'] = True
- log.info('enroll: committed')
- self._set_finger_present(False)
- self._set_finger_needed(False)
- def slot(proc):
- with self.lock:
- self.enroll_proc = proc
- try:
- # A commit that replaces an existing record makes the device
- # re-enumerate mid-write; the hacked winusb stub cannot detect
- # reconnects and exits with LIBUSB_ERROR_NO_DEVICE (verified
- # 2026-10-15 13:11-13:12, harness logs). The delete ioctl does
- # not reset the device, and a fresh write commits reliably, so
- # clear any existing record first.
- if self.enrolled_fingers(user):
- log.info('enroll: existing record for %s, deleting it first',
- user)
- dstatus, dcode = self._run_harness(
- DELETE_EXE, DELETE_TIMEOUT, self.enroll_cancel, None, slot,
- expect_markers=('about to 442034',))
- d_ok = (dstatus == 'eof' and dcode == 0)
- log.info('enroll: pre-delete %s (harness %s rc=%s)',
- 'ok' if d_ok else 'FAILED', dstatus, dcode)
- if d_ok:
- # the device has no record now: report that honestly even if
- # the enrollment is aborted later on
- self._set_enrolled_fingers(user, [])
- if self.enroll_cancel.is_set():
- log.info('enroll: cancelled before start')
- return
- status, code = self._run_harness(
- ENROLL_EXE, ENROLL_TIMEOUT, self.enroll_cancel, on_line, slot,
- expect_markers=('about to setMode', 'about to Create Enrollment',
- 'about to IOCTL_BIOMETRIC_CAPTURE_DATA'))
- # A committed template is on the device even if the client went
- # away meanwhile: always record it and report completion.
- if st['committed']:
- self._set_enrolled_fingers(user, [finger])
- log.info('enroll: user %s -> %s (harness %s rc=%s)',
- user, finger, status, code)
- self._emit('EnrollStatus',
- GLib.Variant('(sb)', ('enroll-completed', True)))
- elif self.enroll_cancel.is_set():
- log.info('enroll: cancelled')
- else:
- log.warning('enroll: not committed (harness %s rc=%s, '
- '%d stages)', status, code, st['stages'])
- self._emit('EnrollStatus',
- GLib.Variant('(sb)', ('enroll-failed', True)))
- finally:
- with self.lock:
- self.enroll_proc = None
- if self.claimed_by is None or self.enroll_cancel.is_set():
- # no client is waiting for a stop reply any more
- self.enrolling = False
- self._set_finger_needed(False)
- self._set_finger_present(False)
- # NOTE: like verify, keep self.enrolling set (pending EnrollStop)
- # when the client is still connected after a terminal status.
- def _start_enroll(self, user, finger):
- with self.lock:
- if self._busy():
- return False
- self.enrolling = True
- self._enroll_commit_started = False
- self.enroll_cancel.clear()
- self.enroll_thread = threading.Thread(
- target=self._enroll_worker, args=(user, finger), daemon=True)
- self.enroll_thread.start()
- return True
- # ------------------------------------------------------ delete ops
- def _stop_delete(self, quiet=True):
- with self.lock:
- running = self.deleting
- self.deleting = False
- proc = self.delete_proc
- self.delete_proc = None
- self.delete_cancel.set()
- self._kill_proc(proc)
- if running and not quiet:
- log.info('delete cancelled')
- return running
- def _delete_worker(self, invocation, user, remove):
- """Remove fingers from the reported list; when the list becomes empty
- also delete the sensor-side template (delete.exe)."""
- ok, message = True, None
- try:
- fingers = self.enrolled_fingers(user)
- remaining = [f for f in fingers if f not in remove]
- if fingers and not remaining:
- # Optimistic state update: the client (gnome-control-center)
- # re-reads the list right after the call and gives up after
- # ~10 s - reflect the deletion immediately, restore below if
- # the harness fails.
- self._set_enrolled_fingers(user, remaining)
- def slot(proc):
- with self.lock:
- self.delete_proc = proc
- status, code = self._run_harness(
- DELETE_EXE, DELETE_TIMEOUT, self.delete_cancel, None, slot,
- expect_markers=('about to 442034',))
- ok = (status == 'eof' and code == 0)
- log.info('delete: sensor record removal %s (harness %s rc=%s)',
- 'ok' if ok else 'FAILED', status, code)
- if not ok:
- message = 'Could not delete the print from the device'
- self._set_enrolled_fingers(user, fingers) # restore
- elif remaining:
- self._set_enrolled_fingers(user, remaining)
- # NOTE: the state update happens even if the client released the
- # claim meanwhile - the device record is gone and must not be
- # reported as enrolled.
- except Exception:
- log.exception('delete failed')
- ok, message = False, 'Internal error while deleting'
- finally:
- with self.lock:
- self.delete_proc = None
- self.deleting = False
- GLib.idle_add(self._finish_delete, invocation, ok, message)
- def _finish_delete(self, invocation, ok, message):
- try:
- if ok:
- invocation.return_value(None)
- else:
- invocation.return_dbus_error(
- E_PRINTS_NOT_DELETED,
- message or 'Fingerprint was not deleted')
- except GLib.Error as e:
- # client already gave up / connection closed
- log.info('delete reply not delivered: %s', e.message)
- return GLib.SOURCE_REMOVE
- # ------------------------------------------------ D-Bus callbacks
- def on_method_call(self, conn, sender, path, iface, method, params, invocation):
- try:
- self._dispatch(sender, path, iface, method, params, invocation)
- except Exception: # never kill the service on a bug
- log.exception('method %s.%s failed', iface, method)
- invocation.return_dbus_error(E_INTERNAL, 'shim internal error')
- def _dispatch(self, sender, path, iface, method, params, invocation):
- if iface == IFACE_MANAGER:
- return self._dispatch_manager(method, invocation)
- if iface == IFACE_DEVICE:
- return self._dispatch_device(sender, method, params, invocation)
- invocation.return_dbus_error(E_INTERNAL, f'unknown interface {iface}')
- def _dispatch_manager(self, method, invocation):
- if method == 'GetDevices':
- devices = [DEVICE_PATH] if sensor_present() else []
- invocation.return_value(GLib.Variant('(ao)', (devices,)))
- elif method == 'GetDefaultDevice':
- if not sensor_present():
- invocation.return_dbus_error(E_NO_SUCH_DEVICE,
- 'No fingerprint device present')
- else:
- invocation.return_value(GLib.Variant('(o)', (DEVICE_PATH,)))
- else:
- invocation.return_dbus_error(E_INTERNAL, f'unknown method {method}')
- def _dispatch_device(self, sender, method, params, invocation):
- if method == 'ListEnrolledFingers':
- (user,) = params.unpack()
- fingers = self.enrolled_fingers(user)
- if not fingers:
- invocation.return_dbus_error(
- E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
- else:
- invocation.return_value(GLib.Variant('(as)', (fingers,)))
- elif method == 'Claim':
- (user,) = params.unpack()
- if self.claimed_by is not None:
- invocation.return_dbus_error(E_ALREADY_IN_USE,
- 'Device already in use')
- return
- self.claimed_by = sender
- self.claimed_user = user or RUN_USER
- log.info('claim by %s for user %s', sender, self.claimed_user)
- self._notify_properties(
- {'num-enroll-stages': GLib.Variant('i', NUM_ENROLL_STAGES)})
- invocation.return_value(None)
- elif method == 'Release':
- if not self._check_claim(sender, invocation):
- return
- self._release_claim()
- log.info('release by %s', sender)
- invocation.return_value(None)
- elif method == 'VerifyStart':
- (finger,) = params.unpack()
- if not self._check_claim(sender, invocation):
- return
- if finger not in FINGERS and finger != 'any':
- invocation.return_dbus_error(E_INVALID_FINGERNAME,
- f'Invalid finger name {finger}')
- return
- fingers = self.enrolled_fingers(self.claimed_user)
- if not fingers or (finger != 'any' and finger not in fingers):
- invocation.return_dbus_error(
- E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
- return
- if not self._start_verify(self._selected_finger(finger)):
- invocation.return_dbus_error(E_ALREADY_IN_USE,
- 'Another operation is in progress')
- return
- log.info('verify start (%s) by %s', finger, sender)
- invocation.return_value(None)
- elif method == 'VerifyStop':
- if not self._check_claim(sender, invocation):
- return
- if not self._stop_verify():
- invocation.return_dbus_error(E_NO_ACTION,
- 'No verification in progress')
- return
- invocation.return_value(None)
- elif method == 'EnrollStart':
- (finger,) = params.unpack()
- if not self._check_claim(sender, invocation):
- return
- if finger not in FINGERS:
- invocation.return_dbus_error(
- E_INVALID_FINGERNAME,
- f'Invalid finger name {finger} (not "any")')
- return
- if not self._start_enroll(self.claimed_user, finger):
- invocation.return_dbus_error(E_ALREADY_IN_USE,
- 'Another operation is in progress')
- return
- log.info('enroll start (%s) by %s', finger, sender)
- invocation.return_value(None)
- elif method == 'EnrollStop':
- if not self._check_claim(sender, invocation):
- return
- if not self._stop_enroll():
- invocation.return_dbus_error(E_NO_ACTION,
- 'No enrollment in progress')
- return
- invocation.return_value(None)
- elif method == 'DeleteEnrolledFinger':
- (finger,) = params.unpack()
- if not self._check_claim(sender, invocation):
- return
- if finger not in FINGERS:
- invocation.return_dbus_error(E_INVALID_FINGERNAME,
- f'Invalid finger name {finger}')
- return
- if self._busy():
- invocation.return_dbus_error(E_ALREADY_IN_USE,
- 'Another operation is in progress')
- return
- fingers = self.enrolled_fingers(self.claimed_user)
- if finger not in fingers:
- invocation.return_dbus_error(
- E_NO_ENROLLED_PRINTS,
- f'Finger {finger} is not enrolled for this user')
- return
- self._start_delete(invocation, self.claimed_user, [finger])
- elif method == 'DeleteEnrolledFingers2':
- if not self._check_claim(sender, invocation):
- return
- if self._busy():
- invocation.return_dbus_error(E_ALREADY_IN_USE,
- 'Another operation is in progress')
- return
- fingers = self.enrolled_fingers(self.claimed_user)
- if not fingers:
- invocation.return_dbus_error(
- E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
- return
- self._start_delete(invocation, self.claimed_user, fingers)
- elif method == 'DeleteEnrolledFingers':
- (user,) = params.unpack()
- user = user or self.claimed_user or RUN_USER
- if user != RUN_USER:
- invocation.return_dbus_error(
- E_PERMISSION_DENIED,
- 'Only the local user is supported by the shim')
- return
- if self.claimed_by is not None and self.claimed_by != sender:
- invocation.return_dbus_error(E_ALREADY_IN_USE,
- 'Device already in use by another user')
- return
- if self._busy():
- invocation.return_dbus_error(E_ALREADY_IN_USE,
- 'Another operation is in progress')
- return
- fingers = self.enrolled_fingers(user)
- if not fingers:
- invocation.return_dbus_error(
- E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
- return
- self._start_delete(invocation, user, fingers)
- else:
- invocation.return_dbus_error(E_INTERNAL, f'unknown method {method}')
- def _start_delete(self, invocation, user, remove):
- with self.lock:
- if self._busy():
- invocation.return_dbus_error(E_ALREADY_IN_USE,
- 'Another operation is in progress')
- return
- self.deleting = True
- self.delete_cancel.clear()
- log.info('delete start: user=%s fingers=%s', user, ','.join(remove))
- thread = threading.Thread(target=self._delete_worker,
- args=(invocation, user, remove), daemon=True)
- thread.start()
- def on_get_property(self, conn, sender, path, iface, prop):
- if iface != IFACE_DEVICE:
- return None
- if prop == 'name':
- return GLib.Variant('s', DEVICE_NAME)
- if prop == 'scan-type':
- return GLib.Variant('s', SCAN_TYPE)
- if prop == 'num-enroll-stages':
- stages = NUM_ENROLL_STAGES if self.claimed_by else -1
- return GLib.Variant('i', stages)
- if prop == 'finger-present':
- return GLib.Variant('b', self.finger_present)
- if prop == 'finger-needed':
- return GLib.Variant('b', self.finger_needed)
- return None
- def on_name_owner_changed(self, conn, sender, path, iface, signal_name, params):
- name, _old, new = params.unpack()
- if new:
- return
- if name == self.claimed_by:
- log.info('claiming client %s vanished, releasing device', name)
- self._release_claim()
- def main():
- parser = argparse.ArgumentParser(description=__doc__)
- parser.add_argument('--session', action='store_true',
- help='own the name on the session bus (smoke test)')
- parser.add_argument('--debug', action='store_true')
- args = parser.parse_args()
- logging.basicConfig(
- level=logging.DEBUG if args.debug else logging.INFO,
- format='fprintd-shim: %(levelname)s: %(message)s',
- stream=sys.stderr)
- bus_type = Gio.BusType.SESSION if args.session else Gio.BusType.SYSTEM
- device = ShimDevice()
- loop = GLib.MainLoop()
- manager_info = Gio.DBusNodeInfo.new_for_xml(MANAGER_XML).interfaces[0]
- device_info = Gio.DBusNodeInfo.new_for_xml(DEVICE_XML).interfaces[0]
- def on_bus_acquired(conn, _name):
- device.conn = conn
- conn.register_object(MANAGER_PATH, manager_info,
- device.on_method_call, device.on_get_property, None)
- conn.register_object(DEVICE_PATH, device_info,
- device.on_method_call, device.on_get_property, None)
- conn.signal_subscribe(
- 'org.freedesktop.DBus', 'org.freedesktop.DBus', 'NameOwnerChanged',
- '/org/freedesktop/DBus', None, Gio.DBusSignalFlags.NONE,
- device.on_name_owner_changed)
- log.info('serving %s (device %s, state %s, enroll/delete via %s)',
- BUS_NAME, DEVICE_PATH, STATE_FILE, SANDBOX)
- def on_name_lost(_conn, _name):
- log.warning('lost bus name %s', BUS_NAME)
- device._release_claim()
- loop.quit()
- def on_term(_signum, _frame):
- log.info('shutting down')
- device._release_claim()
- loop.quit()
- signal.signal(signal.SIGTERM, on_term)
- signal.signal(signal.SIGINT, on_term)
- Gio.bus_own_name(bus_type, BUS_NAME, Gio.BusNameOwnerFlags.NONE,
- on_bus_acquired, None, on_name_lost)
- loop.run()
- if __name__ == '__main__':
- main()
|