linux-fingerprint-r503 — Linux के लिए फिंगरप्रिंट लॉगिन, Grow R503 + Arduino का उपयोग करके

लिनक्स डेस्कटॉप के लिए एक पार्ट्स-से-बना USB फिंगरप्रिंट रीडर। कुल पार्ट्स की लागत $15 से कम। अपस्ट्रीम fprintd के लिए ड्रॉप-इन रिप्लेसमेंट — PAM, KDE Settings, GNOME Settings, fprintd-verify, फिंगर से sudo, फिंगर से स्क्रीन-अनलॉक सब काम करते हैं।

fw=1.0 / r503d 1.0.0 के अनुसार Arduino↔होस्ट वायर प्रमाणित है: हर कमांड और प्रतिक्रिया में एक SipHash-2-4 MAC होता है जो EEPROM में TOFU-युग्मित रहस्य से कुंजीबद्ध होता है। USB सीरियल लिंक के खिलाफ रीप्ले और हॉट-स्वैप हमलों को अवरुद्ध किया जाता है। पूर्ण डिज़ाइन के लिए देखें SPEC.md §13, जिसमें यह भी शामिल है कि थ्रेट मॉडल क्या कवर नहीं करता।

R503 सेंसर हाथ से काटे गए लकड़ी के बक्से में लगा हुआ, नीली रिंग चमक रही है

काश मेरे पास 3d प्रिंटर होता…``` ┌──────────┐ UART ┌─────────────┐ USB-CDC ┌──────────────────┐ │ Grow │ 57600 8N1│ Arduino │ /dev/r503 │ r503d daemon │ │ R503 │◀─────────▶│ (firmware) │◀──────────▶│ net.reactivated │ │ sensor │ 3.3V TTL │ │ framed, │ .Fprint on D-Bus│ └──────────┘ └─────────────┘ MAC'd └──────────────────┘ │ ▼ PAM, KDE, GNOME, fprintd-verify, …

## क्यों

Linux के लिए हार्डवेयर USB फिंगरप्रिंट रीडर दुर्लभ, महंगे होते हैं, और जो मौजूद हैं (Validity, Synaptics, आदि) वे अस्थिर libfprint ड्राइवरों के माध्यम से रिवर्स-इंजीनियर किए गए हैं जो विक्रेता फर्मवेयर अपडेट से टूट जाते हैं।

Grow R503 का प्रोटोकॉल **सार्वजनिक** है, Arduino पक्ष आपका अपना कोड है, और libfprint अनुकूलता परत सिर्फ D-Bus है।

आपके पास एक फिंगरप्रिंट रीडर होता है जिसका स्रोत आप ऊपर से नीचे तक पढ़ सकते हैं।

## सामग्री सूची

| भाग | नोट्स | अनुमानित लागत |
|------|-------|------|
| Grow R503 कैपेसिटिव फिंगरप्रिंट सेंसर | RGB रिंग वाला गोल सेंसर | ~$10 |
| Arduino Uno R3 / Nano / Mega / कोई भी ATmega328 बोर्ड | कोई भी जो SoftwareSerial चला सके | $5–$25 |
| 4–6 जम्पर तार | Dupont / ब्रेडबोर्ड | नगण्य |

बस इतना ही। **कोई लेवल शिफ्टर नहीं, कोई वोल्टेज डिवाइडर नहीं** — कारण जानने के लिए [`SPEC.md` §3.1](https://github.com/matpb/linux-fingerprint-r503/blob/HEAD/SPEC.md) देखें (R503 की RX लाइन व्यवहार में 5V-सहिष्णु है; डेटाशीट झूठ बोलती है)।

## वायरिंग```
R503             Arduino (Uno R3 / Nano / etc.)
----             ------------------------------
Red (VCC)        3V3
White (3.3VT)    3V3                  (touch-IC supply; shares rail with red)
Black (GND)      GND
Yellow (TXD)     D2  ── SoftwareSerial RX
Brown (RXD)      D3  ── SoftwareSerial TX   (direct — no divider!)
Blue (WAKEUP)    D4                          (optional; not used by firmware yet)

यदि आपका R503 JST-SH कनेक्टर के साथ आता है, तो 6-पिन JST-SH-से-Dupont पिगटेल को काटकर तारों को अलग करें। ब्राउन कभी-कभी ग्रीन होता है (विक्रेता पर निर्भर करता है) — JST हेडर के RXD पिन में जाने वाले तार के अनुसार जांचें, रंग के अनुसार नहीं।

पूर्वापेक्षाएँ

Fedora 44 KDE पर परीक्षित; fprintd, pam_fprintd, और एक नवीनतम Rust टूलचेन के साथ किसी भी systemd-आधारित डिस्ट्रो पर काम करना चाहिए।

सिस्टम पैकेज:

डिस्ट्रो	बिल्ड	रनटाइम
Fedora / RHEL	`rust cargo arduino-cli tpm2-tss-devel`	`fprintd pam fprintd-pam tpm2-tss`
Debian / Ubuntu	`rustc cargo arduino-cli libtss2-dev`	`fprintd libpam-fprintd libtss2-esys-3.0.2-0`

tss-esapi पैकेज केवल तभी आवश्यक हैं यदि आप --pair --seal-tpm (SPEC §13.12) का उपयोग करने की योजना बनाते हैं। डेमन TPM के बिना भी बिल्ड और रन करता है — tss-esapi एक हार्ड बिल्ड निर्भरता है लेकिन एक सॉफ्ट रनटाइम निर्भरता है (कोड पथ केवल तभी प्रवेश किया जाता है जब /var/lib/r503d/key.tpm मौजूद हो)।

Rust 1.95+, arduino-cli आपके $PATH पर।

क्या आपके पास TPM2 है?```bash ls /dev/tpmrm0 && tpm2_pcrread sha256:7 | head -3

यदि दोनों सफल होते हैं, तो आपका होस्ट सील की गई-कुंजी पथ का उपयोग कर सकता है। यदि `/dev/tpmrm0` गायब है (पुराना हार्डवेयर, BIOS में TPM अक्षम, या वर्चुअल TPM के बिना VM), तो डिफ़ॉल्ट प्लेनटेक्स्ट-कुंजी प्रवाह के साथ रहें।

## बिल्ड और इंस्टॉल करें

### 1. फर्मवेयर फ्लैश करें

`firmware/r503fp/r503fp.ino` को Arduino IDE में खोलें और अपलोड करें। या फिर `arduino-cli` के साथ:```bash
# Uno R3:
arduino-cli compile --fqbn arduino:avr:uno firmware/r503fp/
arduino-cli upload  --fqbn arduino:avr:uno --port /dev/ttyACM0 firmware/r503fp/

# Nano (modern Optiboot, including most Elegoo / WAVGAT clones):
arduino-cli compile --fqbn arduino:avr:nano:cpu=atmega328 firmware/r503fp/
arduino-cli upload  --fqbn arduino:avr:nano:cpu=atmega328 --port /dev/ttyUSB0 firmware/r503fp/

# Nano with legacy 57600-baud bootloader (older clones):
#   replace `cpu=atmega328` with `cpu=atmega328old`

फ़र्मवेयर Adafruit_Fingerprint का उपयोग करता है। IDE पहली बार कंपाइल करने पर इसे इंस्टॉल करने का विकल्प देगा।

यदि arduino-cli upload के साथ not in sync: resp=0x7e विफल होता है, तो आपका बूटलोडर दूसरा वैरिएंट है — atmega328 ↔ atmega328old को बदलें और पुनः प्रयास करें। दोनों काम करते हैं; अंतर केवल बूटलोडर बॉड रेट का है।

2. डेमन बनाएँ

Rust 1.95+ आवश्यक है।```bash cd pcside/daemon cargo build --release

### 3. स्थापित करें```bash
sudo bash pcside/daemon/dist/install.sh

वह स्क्रिप्ट:

स्थापित करता है target/release/r503d को /usr/local/bin/r503d पर
बनाता है /var/lib/r503d/ (मोड 0700 root:root) कुंजी, स्थिति, और उपयोगकर्ता-स्लॉट रजिस्ट्री के लिए
लिखता है udev नियम जो Arduino को /dev/r503 के रूप में प्रकट करता है और डिवाइस नोड को root:root 0600 पर लॉक करता है (केवल डेमॉन, जो root के रूप में चल रहा है, को इसकी आवश्यकता है; यह डिफ़ॉल्ट 0660 root:dialout पथ को बंद करता है ताकि कोई अन्य स्थानीय उपयोगकर्ता पोर्ट न खोल सके — सुरक्षा ऑडिट 2026-05-28 / H1)। परिणाम: स्थापना के बाद, /dev/r503 के विरुद्ध कोई भी मैन्युअल arduino-cli/serial-monitor कमांड sudo की आवश्यकता होगी।
स्थापित करता है systemd यूनिट (/etc/systemd/system/r503d.service)
ओवरराइड करता है D-Bus ऑटोलॉन्च एंट्री net.reactivated.Fprint के लिए
स्थापित करता है polkit क्रिया (/usr/share/polkit-1/actions/net.reactivated.fprint.device.r503d.policy) जिसका उपयोग कॉलर-आइडेंटिटी गेट द्वारा किया जाता है

यह आइडेम्पोटेंट है — हर cargo build --release के बाद इसे पुनः चलाएँ नए बाइनरी को पुनः तैनात करने के लिए।

4. नैनो को डेमॉन के साथ जोड़ें

ताज़ा-फ्लैश किया गया नैनो अनपेयर्ड है — डेमॉन उससे बात करेगा लेकिन फर्मवेयर हर फ्रेम किए गए कमांड को अस्वीकार कर देगा। नीचे दिए गए दो प्रवाहों में से एक चुनें; दोनों एक जोड़े गए नैनो और एक काम करने वाले डेमॉन के साथ समाप्त होते हैं। TPM-सील किया गया प्रवाह अनुशंसित है यदि आपके होस्ट में TPM2 है (त्वरित जांच के लिए पूर्वापेक्षाएँ देखें)।

दोनों प्रवाहों में उपयोग की जाने वाली ऑप्ट-इन फ़ाइल (/etc/r503d/allow-pair) एक हमलावर को आपकी डेस्क पर अपने स्वयं के नैनो के साथ दौड़ने से रोकने के लिए मौजूद है — रूट के बिना पेयरिंग असंभव है। r503d --pair नैनो को कुंजी भेजने से पहले मार्कर को हटा देता है: यदि होस्ट नैनो-साइड कमिट और होस्ट-साइड पर्सिस्टेंस के बीच क्रैश हो जाता है, तो गेट पहले से ही बंद है, इसलिए अगले पेयर प्रयास के लिए एडमिन को मार्कर को फिर से touch करने की आवश्यकता होती है। प्री-सेंड बेल (कोई मार्कर नहीं, या "पहले से जोड़ा गया") पुनः प्रयास के लिए मार्कर को बरकरार छोड़ देता है।

4a. सादा-पाठ कुंजी जोड़ना (डिफ़ॉल्ट)

इसका उपयोग करें यदि आपके पास TPM2 डिवाइस नहीं है, या यदि आपको ऑफ़लाइन-डिस्क हमला प्रतिरोध की आवश्यकता नहीं है।```bash sudo systemctl stop r503d sudo mkdir -p /etc/r503d sudo touch /etc/r503d/allow-pair # opt-in (see SPEC §13.5) sudo r503d --pair # 128-bit key → /var/lib/r503d/key sudo systemctl start r503d

## रिवर्स इंजीनियरिंग

- **पूर्ण-सुविधायुक्त बहु-आर्किटेक्चर डिसअसेंबलर** - व्यापक श्रेणी की आर्किटेक्चरों को डिसअसेंबल करने में सक्षम, जिनमें x86, x86_64, ARM, Thumb, PowerPC, MIPS, MSP430, EBC, और RISC-V शामिल हैं, और अधिक सक्रिय विकास के अधीन हैं।
- **डोमेन हेडर विश्लेषण** - DOS, Rich Header, COFF, COFF BigObj, AXP, और A64 प्रतीक और डीबग जानकारी का विश्लेषण और प्रदर्शन करने के लिए निष्पादन योग्य पार्सर्स।
- **डेटा पैटर्न** - सामान्य डेटा पैटर्न, जैसे UUID, UEFI LZMA, Windows BSOD `TriageData`, CRC-16 CCITT, CRC-32 (MPEG2) को स्थिरांकों से पहचानें और डिकोड करें।
- **इंटरैक्टिव कंट्रोल फ्लो ग्राफ** - सहज और इंटरैक्टिव कंट्रोल फ्लो ग्राफ जो डिसअसेंबली के साथ एकीकरण के साथ अन्वेषण और नेविगेशन की अनुमति देते हैं।
- **PDB लोडर** - स्थानीय फ़ाइल संग्रहण और बाहरी प्रतीक सर्वरों से PDB प्रतीक फ़ाइलें पुनर्प्राप्त करता है और लोड करता है।
- **स्वचालित कोड-ऑब्जेक्ट डिटेक्शन** - एक एकीकृत प्रकार लाइब्रेरी प्रणाली के साथ, C++ vtables जैसे कोड ऑब्जेक्ट्स को स्वचालित रूप से पहचानता और लेबल करता है।
- **C++ हेडर और IDA टाइप लाइब्रेरीज़** - Windows, UEFI, और सामान्य लाइब्रेरीज़ के लिए C++ हेडर जानकारी युक्त पूर्ण प्रकार की लाइब्रेरीज़ का सेट, साथ ही IDA के लिए प्रकार लाइब्रेरीज़ शामिल हैं।
- **कोड विश्लेषण प्लगइन्स** - रिवर्स इंजीनियरिंग के लिए `Re` नेमस्पेस का उपयोग करके कोड का विश्लेषण और एनोटेट करने के लिए प्लगइन्स का बढ़ता संग्रह।```bash
sudo r503d --status
# port:             /dev/r503
# firmware:         fw=1.1 fmt=2
# firmware paired:  true
# firmware counter: 42
# host key.tpm:     (absent)
# host key:         /var/lib/r503d/key
# host key.bak:     /var/lib/r503d/key.bak
# tpm device:       (absent)
# allow-pair:       (absent)

4b. TPM-सीलबंद जोड़ी (TPM2 होस्ट पर अनुशंसित, SPEC §13.12)

वही प्रक्रिया, साथ ही --seal-tpm। उत्पन्न कुंजी PCR7 (सिक्योर बूट नीति + कुंजियाँ) पर सील की जाती है और सादे पाठ key फ़ाइल के बजाय /var/lib/r503d/key.tpm पर लिखी जाती है। ऑफ़लाइन-डिस्क हमलावरों (एक अनमाउंटेड पार्टीशन का dd, एक शत्रुतापूर्ण होस्ट में SSD स्वैप) को केवल सिफ़रटेक्स्ट मिलता है।```bash sudo systemctl stop r503d sudo mkdir -p /etc/r503d sudo touch /etc/r503d/allow-pair sudo r503d --pair --seal-tpm # seals new key to current PCR7 sudo systemctl start r503d

INPUT:```bash
sudo r503d --status
# port:             /dev/r503
# firmware:         fw=1.1 fmt=2
# firmware paired:  true
# firmware counter: 12
# host key.tpm:     /var/lib/r503d/key.tpm
# host key:         (missing)
# host key.bak:     (missing)
# tpm device:       /dev/tpmrm0
# allow-pair:       (absent)

कर्नेल अपडेट, इनिट्रैम्फ़्स अपडेट, fwupd UEFI फ़र्मवेयर अपडेट, और grub2 अपडेट PCR7 को नहीं बदलते हैं और रिसील की आवश्यकता नहीं होती। PCR7 केवल सिक्योर बूट नीति संपादन, MOK एनरोलमेंट, या डिस्क को किसी अन्य होस्ट पर ले जाने पर बदलता है — ऐसे में डेमॉन TPM_RC_POLICY_FAIL के साथ प्रारंभ करने से इनकार करता है और dist/reseal-tpm.sh ~90 सेकंड में रिकवर करता है। देखें रिकवरी: PCR7 बदल गया।

5. एनरोल और सत्यापित करें```bash

Enroll a finger (use KDE Settings → Users → Fingerprint Auth for a GUI):

fprintd-enroll mat

Verify:

fprintd-verify mat

sudo with finger:

sudo whoami

KDE सेटिंग्स (प्लाज़्मा 6) और GNOME नियंत्रण केंद्र के उपयोगकर्ता-खाता फिंगरप्रिंट संवाद दोनों ही `r503d` को ठीक उसी तरह चलाते हैं जैसे वे अपस्ट्रीम `fprintd` को चलाते हैं।

### पुनः जोड़ना / कुंजी रोटेशन

यदि आप एक नई कुंजी चाहते हैं (कुंजी से समझौता, नियोजित हार्डवेयर स्वैप, व्यामोह):```bash
sudo systemctl stop r503d
sudo r503d --unpair                        # framed; wipes Nano EEPROM + host key
sudo touch /etc/r503d/allow-pair
sudo r503d --pair                          # plaintext-key rotation
#  - or -
sudo r503d --pair --seal-tpm               # TPM-sealed rotation
sudo systemctl start r503d

अपने मूल पेयरिंग पथ से मेल खाएं। यदि आपने मूल रूप से --seal-tpm का उपयोग किया है, तो --seal-tpm के साथ रोटेट करें — अन्यथा रोटेशन चुपचाप आपको डिस्क पर एक प्लेनटेक्स्ट कुंजी पर डाउनग्रेड कर देगा।

पुनर्प्राप्ति: PCR7 बदल गया, पुनः सील करने की आवश्यकता

यदि आपने --pair --seal-tpm का उपयोग किया और बाद में PCR7 द्वारा मापी जाने वाली किसी चीज़ को बदल दिया (Secure Boot बंद/चालू किया गया, नया MOK नामांकित, डिस्क दूसरे बॉक्स में ले जाया गया), तो डेमॉन प्रारंभ होने से मना कर देगा और journal में TPM_RC_POLICY_FAIL के बारे में संदेश दिखाई देगा। पुनर्प्राप्ति एक कमांड है:```bash sudo bash pcside/daemon/dist/reseal-tpm.sh

स्क्रिप्ट `r503d` को रोकती है, नैनो EEPROM को मिटाने के लिए `firmware/r503fp_wipe/` को फिर से फ्लैश करती है, मुख्य फर्मवेयर को फिर से फ्लैश करती है, `/etc/r503d/allow-pair` बनाती है, वर्तमान PCR7 पर सील एक नई कुंजी उत्पन्न करने के लिए `r503d --reseal-tpm` चलाती है, और डेमॉन को वापस शुरू करती है। वॉल-क्लॉक: ~90 सेकंड। पंजीकृत उंगलियां संरक्षित रहती हैं — टेम्पलेट्स R503 सेंसर की फ्लैश पर रहते हैं, नैनो पर नहीं।

स्क्रिप्ट को `arduino-cli` उपलब्ध होना चाहिए। यदि यह आपके उपयोगकर्ता के `$HOME/.local/bin` में स्थापित है, तो यह `$SUDO_USER` के माध्यम से स्वचालित रूप से पता लगा लिया जाता है; अन्यथा चलाने से पहले `ARDUINO_CLI=/full/path/to/arduino-cli` सेट करें।

### पुनर्प्राप्ति: खोया हुआ `state.json` (काउंटर डीसिंक)

यदि होस्ट कुंजी बरकरार है लेकिन `/var/lib/r503d/state.json` गायब है या वापस रोल किया गया है (पुराना बैकअप पुनर्स्थापित, आकस्मिक rm), तो डेमॉन का काउंटर नैनो के `last_seen` से पीछे रह जाता है और हर फ्रेम कमांड `ERR replay` से टकराता है। `r503d --status` इसे चिह्नित करता है; समाधान एक कमांड है:```bash
sudo systemctl stop r503d
sudo r503d --resync                         # reads Nano last_seen, sets host counter to last_seen+1
sudo systemctl start r503d

कोई री-पेयर नहीं, कोई रीफ्लैश नहीं — कुंजी कभी नहीं हिलती। status क्वेरी --resync जिस पर निर्भर करती है, वह अप्रमाणित है, लेकिन यह केवल होस्ट काउंटर को आगे बढ़ा सकता है ताकि नैनो (Nano) ने जो पहले से प्रतिबद्ध किया है उससे मेल खाए, इसलिए यह कभी भी किसी पुराने फ्रेम को पुनःचलाने योग्य (replayable) नहीं बना सकता (सबसे बुरी स्थिति में, एक झूठा MITM एक और ERR replay को मजबूर कर सकता है, जो वह फ्रेम्स को विकृत करके पहले से ही कर सकता था)। देखें SPEC.md §13.11।

पुनर्प्राप्ति (Recovery): होस्ट कुंजी पूरी तरह खो जाना

प्रमाणित --unpair को अधिकृत करने के लिए कुंजी की आवश्यकता होती है। यदि सभी डिस्क-स्थित प्रतियां चली गई हैं (डिस्क क्रैश, आकस्मिक rm, key + key.bak दोनों हटा दिए गए, या key.tpm ब्लॉब खो गया), तो आपको reflash-to-wipe एस्केप हैच की आवश्यकता है — वही प्रक्रिया जो dist/reseal-tpm.sh PCR7-बदले गए मामले के लिए स्वचालित करता है:```bash sudo systemctl stop r503d

/dev/r503 is root:root 0600 since install (audit H1), so the uploads need root.

sudo arduino-cli upload --fqbn arduino:avr:nano:cpu=atmega328 --port /dev/r503 firmware/r503fp_wipe/

Wait ~1s for the wipe to complete (LED starts blinking — that's the wipe sketch).

sudo arduino-cli upload --fqbn arduino:avr:nano:cpu=atmega328 --port /dev/r503 firmware/r503fp/ sudo touch /etc/r503d/allow-pair sudo r503d --pair sudo systemctl start r503d

यदि `sudo arduino-cli` कमांड-नॉट-फाउंड रिपोर्ट करता है (arduino-cli आपके `~/.local/bin` में रहता है, रूट की `PATH` पर नहीं), तो इसे `sudo env "PATH=$PATH" arduino-cli …` के रूप में चलाएं या पूर्ण पथ दें।

यह कोई बैकडोर नहीं है जिसका उपयोग कोई हमलावर कर सके: पुनः-युग्मन के लिए होस्ट पर रूट की आवश्यकता होती है (ऑप्ट-इन फ़ाइल और `--pair` CLI दोनों को रूट चाहिए), इसलिए एक रीफ्लैश किया गया Nano आपके पहले से रूट हुए बिना विश्वास में नहीं लाया जा सकता।

### अनइंस्टॉल```bash
sudo bash pcside/daemon/dist/uninstall.sh

सब कुछ वापस लेता है, fprintd को अनमास्क करता है, /var/lib/r503d/ (कुंजी, स्थिति, उपयोगकर्ता) को जगह पर छोड़ता है यदि आप बाद में पुनः स्थापित करना चाहते हैं। यदि आप वास्तविक साफ स्लेट चाहते हैं तो उस निर्देशिका को मैन्युअल रूप से हटा दें।

यह कैसे काम करता है

Arduino एक छोटा ASCII-प्रोटोकॉल फर्मवेयर (firmware/r503fp/) चलाता है जो अपने UART पक्ष पर R503 के मूल R30x ("Sync Word") बाइनरी प्रोटोकॉल से बात करता है और USB-CDC पर होस्ट के साथ लाइन-उन्मुख टेक्स्ट कमांड का आदान-प्रदान करता है: ping, info, enroll N, verify, delete N, clear, led off। पूरा v1 प्रोटोकॉल SPEC.md §5 में।

fw=1.0 (v2 प्रमाणित-चैनल कार्य का माइलस्टोन E) के बाद से, प्रत्येक कमांड और प्रतिक्रिया एक C <counter> <body> M <mac> / R <counter> <seq> <body> M <mac> फ्रेम में लपेटी जाती है, जिसे TOFU-युग्मित 128-बिट कुंजी पर SipHash-2-4 से MAC किया जाता है। Nano EEPROM में एक वियर-लेवल्ड मोनोटोनिक काउंटर रखता है; डेमॉन /var/lib/r503d/state.json में एक मिलान काउंटर रखता है। रीप्ले प्रयास (फर्मवेयर-पक्ष incoming <= last_seen) को ERR replay के रूप में अस्वीकार कर दिया जाता है; छेड़छाड़ किए गए फ्रेम को ERR mac_invalid मिलता है। पूरा स्पेक, खतरा मॉडल, और ज्ञात सीमाएं SPEC.md §13 में।

Rust डेमॉन (r503d) net.reactivated.Fprint पर D-Bus बोलता है - बिल्कुल वही इंटरफ़ेस जो अपस्ट्रीम fprintd प्रदर्शित करता है - इसलिए प्रत्येक fprintd क्लाइंट बिना संशोधन के काम करता है। /var/lib/r503d/users.json पर एक JSON साइडकार (user, finger) को R503 की आंतरिक फ्लैश में स्लॉट इंडेक्स से मैप करता है।

लेआउट:``` firmware/r503fp/ Arduino firmware (v2 framed ASCII protocol) firmware/r503fp_wipe/ Emergency one-shot EEPROM wipe (lost-key recovery) firmware/* Diagnostic / development sketches (ping, loopback, ...) pcside/daemon/ Rust daemon (the fprintd replacement) pcside/daemon/src/{crypto,framing,keystore,state,pairing}.rs v2 wire protocol implementation pcside/daemon/src/auth.rs caller-identity gating for D-Bus methods pcside/daemon/dist/ udev rule, systemd unit, polkit + bus policy, install scripts docs/ Decision logs + troubleshooting SPEC.md Full architecture + protocol spec (§13 = v2 auth)

## सुरक्षा मॉडल — त्वरित सारांश

वायर-स्तरीय प्रमाणीकरण एक विशिष्ट खतरे को लक्षित करता है —
**"एक दुष्ट नौकरानी के पास पाँच मिनट और एक अतिरिक्त Nano"** और `/dev/r503` पर एक शत्रुतापूर्ण स्थानीय प्रक्रिया
— राष्ट्र-राज्यों या प्रयोगशाला वाले हार्डवेयर हमलावरों को नहीं। एकल-उपयोगकर्ता डेस्कटॉप तैनाती जिसमें दस्तावेज़ीकृत आउट-ऑफ-स्कोप सूची है।
पूरा खतरा मॉडल [`SPEC.md` §13.1](https://github.com/matpb/linux-fingerprint-r503/blob/HEAD/SPEC.md) में है; कार्यान्वयन-और-समीक्षा साक्ष्य
[`docs/REVIEW-2026-05-28.md`](https://github.com/matpb/linux-fingerprint-r503/blob/HEAD/docs/REVIEW-2026-05-28.md) में है। एक अलग
प्रतिकूल विशेषाधिकार-वृद्धि ऑडिट (2026-05-28) और उसका प्रति-दावा
सत्यापन/सुधार पास
[`docs/SECURITY-AUDIT-2026-05-28.html`](https://github.com/matpb/linux-fingerprint-r503/blob/HEAD/docs/SECURITY-AUDIT-2026-05-28.html)
और
[`docs/SECURITY-AUDIT-2026-05-28-VALIDATION.html`](https://github.com/matpb/linux-fingerprint-r503/blob/HEAD/docs/SECURITY-AUDIT-2026-05-28-VALIDATION.html) पर है।

**रक्षित:**
- Nano को एक शत्रुतापूर्ण इकाई से हॉट-स्वैप करना (कोई कुंजी नहीं → सभी फ्रेम MAC में विफल)।
- `/dev/r503` पर नकली मैच प्रतिक्रियाओं को इंजेक्ट करने वाली स्थानीय प्रक्रिया। दो परतें:
  डिवाइस नोड `root:root 0600` (udev नियम) है और डेमॉन इसे
  `TIOCEXCL` के साथ रखता है, इसलिए एक गैर-root प्रक्रिया इसे खोल नहीं सकती — और भले ही
  यह कर सके, इसके पास कोई कुंजी नहीं है, इसलिए फ्रेम MAC सत्यापन में विफल रहता है।
- भविष्य के सत्र में रिकॉर्ड किए गए `OK match=...` फ्रेम्स का पुनर्प्ले।
- किसी भी फ्रेम फील्ड का बिट-फ्लिप छेड़छाड़ (लगातार-समय MAC तुलना)।
- काउंटर-समाप्ति अवरोध: एक सहकर्मी (या `--resync` के दौरान एक-शॉट MITM)
  मोनोटोनिक काउंटर को `u64::MAX` तक ले जाकर और चैनल को स्थायी रूप से अवरुद्ध करना
  दोनों सिरों पर लागू एक आरक्षित काउंटर सीमा द्वारा अवरुद्ध किया जाता है
  (`fw=1.1+`; SPEC §13.4 / 2026-05-28 ऑडिट DoS-2)।
- सेंसर का स्थानीय-उपयोगकर्ता सेवा-अस्वीकार: एक एकल कैप्चर-स्लॉट गेट
  इन-फ्लाइट enroll/verify कार्य को सीमित करता है और डिलीट पथ कार्रवाई-गेटेड हैं,
  इसलिए `Start`/`Stop` (या समवर्ती-डिलीट) बाढ़ auth को अवरुद्ध नहीं कर सकती।
- क्रॉस-यूज़र फिंगरप्रिंट प्लांट / वाइप / एन्यूमरेशन एक स्थानीय गैर-root
  उपयोगकर्ता द्वारा (जैसे `mallory` `Claim "root"` कॉल करके फिर अपनी उंगली enroll करना) —
  हर `username` लेने वाली D-Bus विधि पर कॉलर पहचान की जाँच की जाती है,
  और सिस्टम बस नीति ब्रोकर परत पर गैर-`wheel` कॉलर को अस्वीकार करती है।
- **होस्ट कुंजी पर ऑफ़लाइन-डिस्क हमले** *जब `--seal-tpm` के साथ जोड़ा जाए*:
  डिस्क पर कुंजी PCR7 पर TPM2-सील होती है, इसलिए अनमाउंटेड पार्टीशन का `dd`
  या शत्रुतापूर्ण होस्ट में SSD स्वैप केवल सिफरटेक्स्ट देता है।
  केवल उसी मशीन पर उसी सिक्योर बूट नीति के तहत अनरैप होता है।
  देखें [SPEC §13.12](https://github.com/matpb/linux-fingerprint-r503/blob/HEAD/SPEC.md)।

**रक्षित नहीं:**
- होस्ट रूट समझौता (कुंजी `/var/lib/r503d/key` में है, `0600 root:root`)।
  चालू होस्ट पर रूट TPM-सील किए गए वेरिएंट को भी अनसील कर सकता है — सीलिंग
  *ऑफ़लाइन* हमलों को कुंद करती है, ऑनलाइन हमलों को नहीं।
- Nano पर भौतिक हमला (ISP के साथ EEPROM रीडबैक ~30 सेकंड; चिप डिकैप; आदि)।
- फर्मवेयर-रिफ्लैश हमला (Arduino बूटलोडर में कोई हस्ताक्षर नहीं है — लेकिन
  री-पेयरिंग के लिए होस्ट पर रूट की आवश्यकता होती है, इसलिए रिफ्लैश किया गया Nano
  होस्ट समझौते के बिना विश्वास में नहीं लाया जा सकता)।
- R503-साइड समझौता (R30x प्रोटोकॉल में कोई प्रमाणीकरण नहीं है; हमारे दायरे से बाहर)।
- **क्रिप्टो मुद्रा।** SipHash-2-4 MACs, 128-बिट साझा कुंजी, 64-बिट MAC
  आउटपुट, डोमेन-पृथक MAC इनपुट। दो स्वतंत्र कार्यान्वयन
  (AVR पर हाथ से बनाया गया C++ जिसमें बूट-टाइम KAT स्व-परीक्षण है; होस्ट पर हाथ से बनाया गया
  Rust, CI में 1024 यादृच्छिक वैक्टर पर तीसरे पक्ष के `siphasher`
  क्रेट के खिलाफ बिट-दर-बिट क्रॉस-सत्यापित)। होस्ट MAC तुलना
  `subtle::ConstantTimeEq` का उपयोग करती है। वायर पार्सर हर CI रन पर प्रॉपर्टी-फ़ज़ किए जाते हैं
  (~135 000 इनपुट)। `cargo audit` क्लीन। SipHash कुंजी
  `zeroize::Zeroizing<...>` में लिपटी होती है ताकि ड्रॉप पर यह साफ हो जाए (प्रति-फ्रेम
  MAC-इनपुट बफ़र्स के रूप में भी)। एक `cargo fuzz`
  libFuzzer लक्ष्य नाइटली पर लंबे-कोर्पस रन के लिए `pcside/daemon/fuzz/` पर शिप करता है।
  कोई भुगतान किया हुआ तृतीय-पक्ष मानव ऑडिट नहीं — वह अभी भी मूल्यवान होगा, PRs स्वागत है।

पूर्ण खतरा मॉडल तर्क सहित: [`SPEC.md` §13.1](https://github.com/matpb/linux-fingerprint-r503/blob/HEAD/SPEC.md)।

## सीमाएँ

- **बहु-उपयोगकर्ता काम करता है, लेकिन केवल `wheel` सदस्यों के लिए।** हर D-Bus विधि पर कॉलर पहचान की जाँच की जाती है जो `username` लेती है (`Claim`,
  `EnrollStart`, `VerifyStart`, `ListEnrolledFingers`,
  `DeleteEnrolledFingers`); स्व-अनुरोध और `uid 0` (PAM) चुपचाप सफल होते हैं, गैर-root कॉलर से क्रॉस-यूज़र को `net.reactivated.Fprint.Error.PermissionDenied` के साथ अस्वीकार कर दिया जाता है। सिस्टम बस नीति आगे सीमित करती है कि कौन से खाते वार्तालाप शुरू कर सकते हैं: केवल
  `root` और `wheel` सदस्य डेमॉन तक पहुँचते हैं, बाकी सभी को
  ब्रोकर परत पर `org.freedesktop.DBus.Error.AccessDenied` मिलता है।
  क्रॉस-यूज़र enroll चाहिए? रूट बनें: `sudo fprintd-enroll target-user`।
  किसी कियोस्क / बहु-उपयोगकर्ता प्रयोगशाला के लिए क्रॉस-यूज़र गेट को ढीला करना चाहिए?
  `/etc/polkit-1/rules.d/` में एक JS नियम डालें जो
  [`net.reactivated.fprint.device.setusername`](https://gitlab.freedesktop.org/libfprint/fprintd/-/blob/master/src/net.reactivated.fprint.device.policy.in) को लक्षित करता है
  — कार्रवाई का नाम अपस्ट्रीम fprintd से शब्दशः मेल खाता है।
- **एक रीडर।** डेमॉन D-Bus पर एक एकल डिवाइस ऑब्जेक्ट प्रस्तुत करता है।
  बहु-रीडर सेटअप के लिए प्रबंधक के विस्तार की आवश्यकता है।
- **`finger-present` / `finger-needed` हिंट प्रॉपर्टीज़ के लिए कोई `PropertiesChanged` उत्सर्जन नहीं।** हर सामान्य fprintd क्लाइंट (PAM, KDE Settings, GNOME)
  उन पोल्ड हिंट्स पर नहीं, बल्कि `EnrollStatus` / `VerifyStatus` सिग्नल (जो उत्सर्जित होते हैं) पर चलता है
  — लेकिन एक सख्त क्लाइंट जो
  `Get + PropertiesChanged` करता है, वह पुराने मान देखेगा।
- **एकल Nano = विफलता का एकल बिंदु।** यदि Nano मर जाता है, तो फिंगरप्रिंट
  लॉगिन तब तक गायब है जब तक आप एक अतिरिक्त को रिफ्लैश नहीं करते और फिर से पेयर नहीं करते। बैकअप के रूप में पासवर्ड प्रमाणीकरण विधि सक्षम रखें।
- **State.json का नुकसान एक कमांड में पुनर्प्राप्त किया जा सकता है।** यदि `state.json` खो जाता है
  जबकि फर्मवेयर में अभी भी उच्च `last_seen` है, तो डेमॉन पहले भेजने पर `ERR replay` हिट करता है। नैनो के काउंटर को पढ़ने और होस्ट को फिर से संरेखित करने के लिए `sudo r503d --resync` चलाएँ
  — कोई पुनः-पेयरिंग आवश्यक नहीं है। देखें [`SPEC.md` §13.11](https://github.com/matpb/linux-fingerprint-r503/blob/HEAD/SPEC.md)।

## समस्या निवारण```bash
# Daemon logs:
sudo journalctl -u r503d.service -f

# Confirm the sensor enumerates correctly:
ls -l /dev/r503
busctl --system call net.reactivated.Fprint /net/reactivated/Fprint/Device/0 \
    net.reactivated.Fprint.Device ListEnrolledFingers s ""

# Confirm fprintd is masked and r503d owns the bus name:
systemctl is-enabled fprintd  # should print "masked"
busctl --system list | grep -i fprint

यदि डेमन प्रारंभ नहीं होता है या सेंसर कभी प्रतिक्रिया नहीं देता है, तो सबसे सामान्य समाधान वायरिंग है — SPEC.md §3 देखें, विशेष रूप से §3.1 में "no voltage divider" नोट। docs/TROUBLESHOOTING.md में अधिक विस्तृत रनबुक है।

लाइसेंस

MIT — देखें LICENSE।

क्रेडिट

Adafruit_Fingerprint — Arduino-पक्ष R30x प्रोटोकॉल कार्यान्वयन।
zbus, serialport-rs, tokio — Rust D-Bus / serial / async स्टैक।
fprintd प्रोजेक्ट — एक स्वच्छ D-Bus इंटरफ़ेस डिज़ाइन करने के लिए जो इस डेमन libfprint के स्रोत को पढ़े बिना उसके विरुद्ध कार्यान्वित कर सके।

linux-fingerprint-r503

सबसे लोकप्रिय