Skip to content

Support request: Synaptics 06cb:00cb (HP Pavilion x360 14-dh0xxx) #263

Open

Description

@satviktiwari

Device info

Laptop: HP Pavilion x360 Convertible 14-dh0xxx
OS: Zorin OS (Ubuntu 24.04 Noble base)
Sensor: Synaptics, Inc. Fingerprint scanner

lsusb output:
Bus 001 Device 007: ID 06cb:00cb Synaptics, Inc. Fingerprint scanner

What was tried

Installed python3-validity + open-fprintd from the uunicorn PPA.
Manually added 06cb:00cb to usb.py, firmware_tables.py, and udev rules,
mapping it to the same firmware as DEV_9a (nz3gf07w.exe).

Firmware downloaded successfully. Service starts but fails with USB timeout:

usb.core.USBTimeoutError: [Errno 110] Operation timed out
  File "tls.py", line 124, in cmd
  File "usb.py", line 105, in cmd
    self.dev.write(1, out)   <-- times out on cmd 0x3e

Manual USB probing results

Probed the device directly with pyusb. Key findings:

Command Response Notes
0x01 0000f0b05e54a40000000607013000010000a488c96870600023000000000100000003d10007 ROM info — works
0x02 0404 error status
0x03 0104 error status
0x04 0404 error status
0x05 0000 OK
0x06 device disconnects reboot command
0x07 device disconnects reboot command
0x08 write OK, no response —
0x09–0x20 0104 mostly not supported
0x19 65 bytes (see below) TLS/session info — works!
0x44 1503030002022f version/caps
0x43 0x02 0504 fwext not loaded
0x3e write timeout flash info — fails

0x01 decoded (ROM Info):

chip_id:   0x545eb0f0
fw_ver:    0x000000a4
sensor?:   06070130
full:      0000f0b05e54a40000000607013000010000a488c96870600023000000000100000003d10007

0x19 response (65 bytes):

000000030102000100000000000000000000000070548ded
0200000000000000000000000000000000000000000000
000000000000000000000000000000000000000000

0x44 response:

1503030002022f  (version/capability info)

Key observations

  • Sensor accepts 0x01 write but gives NO response (unlike 009a which responds immediately)
  • After sending 0x01 + reading all endpoints for 15 seconds: no response on any endpoint
  • Sensor locks up after first command sequence — requires USB deauthorize/authorize to reset
  • The 009a init_hardcoded blob (581 bytes, starts 06020000...) times out on write
  • The send_init() sequence (01 -> 19 -> 4302) fails at step 1 unless sensor is freshly reset
  • 0x06 and 0x07 both trigger a USB disconnect/reboot of the sensor

Hypothesis

The 00cb chip appears to be a newer Prometheus variant that requires a
different initialization sequence before it will accept further commands.
It may need a different hardcoded blob or a pre-auth handshake not present
in the 009a driver path.

Windows USB traffic capture (Wireshark + USBPcap) would be the most
effective next step to identify the correct init sequence — unfortunately
not available in this case.

Happy to test patches if anyone wants to take this further.

Activity

  1. Karloss1234 commented on Jun 27, 2026

    @Karloss1234

    Take a look at PR #256. It is a very stable, updated fork waiting to be merged into the Python-Validity project. It successfully caters for Synaptics sensors with 'PurePrint' (06cb:00b7, similar ID to yours). The communication steps between the host driver and these Pureprint sensors is different to the current Python-Validity release. Without the PR #256 fork code, the sensors just stall. You just need to add a few lines of exception code to the sensor.py file in two or three locations, below where there are already lines of code for other devices. In the Windows device manager, it will refer to your device as 'Pureprint'. 06cb:00bc has very similar architecture to 06cb:00b7, according to Grok, so PR #256 with a few extra lines of code might work.

  2. ggiesen commented on Jul 7, 2026

    @ggiesen

    06cb:00cb (HP Pavilion x360 14-dh) is sensor type 0x969 -- the same silicon as 138a:00ab (HP ZBook Studio x360 G5, cf. #238 / the SimpleX-T fork). Confirmed on hardware: it identifies as "57K0 ...", and with DEV_CB = (0x06cb, 0x00cb) registered plus the 0x969 handling (alias to the 0x199 profile), python-validity gets through identify -> alias -> TLS all the way to the pairing step.

    Where it's blocked: this unit's sensor is paired with a previous host ("Signature verification failed... paired with another computer") and can't be reformatted to claim it for Linux:

    • init_flash() skips reformatting when the flash already has partitions (if len(info.partitions) > 0: return), so it never wipes the foreign pairing.
    • Forcing the reformat fails because 0x00cb needs a device-specific reset_blob: I tried reset_blob from blobs_90/97/9a/9d against the chip and all are rejected (0404, and 04be for blobs_90); factory_reset() -> 0404 too.

    So 0x00cb needs its own reset_blob / init_hardcoded / clean_slate / db_write_enable. These are not statically extractable from the HP driver: the current SoftPaqs (sp101524, sp138431) all ship the SGX variant (synaWudfBioUsb116SGX + the synaTEE116 enclave), and none of the known blobs appear anywhere in the package -- they're generated in the enclave at runtime. The only route is a USB capture of the Windows driver reformatting/enrolling the sensor (the way the existing blobs were captured). The sensor firmware (6_07f_hp_mis_qm.xpfwext) is in the SoftPaq.

    I have this hardware and plan to capture 0x00cb's blobs via a bare-metal Windows-To-Go boot (so SGX works natively) + USBPcap, then contribute them. Flagging here in case anyone with the same reader (or easier Windows/SGX access) wants to collaborate.

  3. ggiesen commented on Jul 8, 2026

    @ggiesen

    Correction + follow-up: the init/reset blobs ARE in the HP driver DLL (06cb:00cb)

    Correction to my comment above: I said 06cb:00cb's blobs are "generated in the enclave at
    runtime" and "not statically extractable from the HP driver." That was wrong. init_hardcoded
    and init_hardcoded_clean_slate are byte-identical to blobs_9a and sit in plain sight in
    synaWudfBioUsb116SGX.dll; the reset_blob is in the same table (details in section 4). Sorry
    for the detour.

    For context: 06cb:00cb is sensor type 0x969 (57K0 family), the same silicon as 138a:00ab
    on the ZBook. python-validity gets through identify -> alias -> TLS to the pairing step but can't
    yet claim the sensor for Linux because it needs a 06cb:00cb-specific reset_blob (the ones in
    blobs_90/97/9a/9d are rejected with 0404).

    I have this hardware, so I captured what the Windows Synaptics SGX driver does, then pulled the
    blobs out of the driver statically. A few findings that should help here and for anyone else
    RE'ing a modern Windows Hello sensor.

    1. The capture was blocked by Windows Enhanced Sign-in Security (VBS), not by tooling

    This is the part that cost the most time and is probably the most reusable result. On a stock
    Windows 11 install, USBPcap/Wireshark capture nothing of the fingerprint data path -- you
    see the device descriptors at capture start and then not a single bulk transfer, no matter how
    you time it. The reason is Enhanced Sign-in Security (ESS): Windows routes the biometric USB
    path through VBS / the secure kernel (VTL1), below where a normal-kernel filter driver like
    USBPcap can see it. The enumeration happens in VTL0 (visible), the actual I/O in VTL1 (invisible).

    To make it capturable you have to turn both off and reboot:

    reg add "HKLM\SOFTWARE\Microsoft\Policies\PassportForWork\Biometrics" /v EnableESSwithSupportedPeripherals /t REG_DWORD /d 0 /f
    bcdedit /set hypervisorlaunchtype off
    reg add "HKLM\SYSTEM\CurrentControlSet\Control\DeviceGuard" /v EnableVirtualizationBasedSecurity /t REG_DWORD /d 0 /f
    reg add "HKLM\SYSTEM\CurrentControlSet\Control\DeviceGuard\Scenarios\HypervisorEnforcedCodeIntegrity" /v Enabled /t REG_DWORD /d 0 /f
    

    After that reboot, the full cleartext init sequence plus the bootstrap TLS session is visible in
    USBPcap. (Filter by USB device address, not usb.idVendor -- idVendor only matches the
    descriptor packet, which is a trap that makes it look like there's only ever one packet.)

    2. Cleartext init sequence

    On the sensor's bulk endpoints (OUT 0x01, IN 0x81/0x83), before any TLS:

    OUT 01                             -> IN 38B  (version/info; response echoes the sensor serial)
    OUT 19                             -> IN 64B
    OUT 4302  (get_flash_info)         -> IN 108B (partition table)
    OUT 06 <581 bytes>                 -> IN 2B   (looks like init_hardcoded)
    OUT 3e                             -> IN 76B
    OUT 40 01 01 00.. (flash read)     -> IN 4096B
    

    then a TLS 1.2-style session (16 03 03 handshake / 17 03 03 app-data). The 581-byte 06...
    command is the same in every capture and is the obvious init_hardcoded candidate.

    3. Forcing the sensor foreign again (and why the reset isn't on the wire)

    The flash pairing is persistent -- the BIOS "Clear/Erase Fingerprint" option only wipes enrolled
    templates, not the partitions or the host pairing, so get_flash_info is byte-identical before
    and after and the driver never reformats. What actually makes the sensor foreign again (so the
    driver reclaims/reformats it) is:

    1. Settings > Accounts > Sign-in options > Fingerprint (Windows Hello) > "Remove this sign-in
      option"
      -- this wipes the host's pairing key.
    2. Reboot, then BIOS -> Clear/Erase Fingerprint.
    3. Next enroll: the fresh driver no longer has the matching host key, sees the sensor as foreign,
      and reclaims/reformats it.

    Note the reformat USB-resets the sensor so it re-enumerates under a new device address -- easy
    to miss.

    With that trigger, the "foreign" capture shows a double init (the driver re-claiming the
    sensor) versus the single init of a normal paired enroll. One caveat, so nobody goes hunting in
    the pcap for something that isn't there: reset_blob is a raw, pre-TLS usb.cmd, and it does
    not show up in the cleartext here -- both get_flash_info responses are byte-identical
    (partitions unchanged), so what this capture actually shows is a re-pair over TLS, not a captured
    factory-reset. The reset command itself never hits the wire in the clear. That's what pushed me to
    pull the blob out of the driver statically instead (next section).

    4. Where the reset_blob is, and what I have

    As noted up top, the signed blobs are stored in synaWudfBioUsb116SGX.dll -- just without their
    leading 06 command byte
    , which is why my first grep (searching for the on-wire form) came up
    empty. They live in a 30-entry descriptor table (80-byte entries: opcode@+0, flags@+12, blob
    length @+36, blob VA @+40, group id @+68).

    06cb:00cb uses blobs_9a's init blobs, and they're in the driver:

    • init_hardcoded (580B) -- byte-identical to blobs_9a.init_hardcoded, and it matches the blob
      I captured off the wire. Descriptor group +28=7, opcode 5, @0x150dc0.
    • init_hardcoded_clean_slate (740B) -- byte-identical to blobs_9a's. Group 7, opcode 2,
      @0x1478e0.

    So 06cb:00cb -> blobs_9a (usb.py SupportedDevices + blobs.py __load_blob) is correct for
    both init blobs.

    reset_blob: narrowed to two candidates, needs a hardware trial to pick. blobs_9a.reset_blob
    (12036B) is not in the DLL and is rejected 0404 on this chip, so 00cb has its own. Both known
    init blobs are in descriptor group +28=7 (8 blobs), and the reset_blob is almost certainly the
    group-7 ~12KB entry -- two candidates:

    • opcode 18, 12100B, @0x147bd0
    • opcode 3, 11972B, @0x151010

    I can't pick between them by static structure alone: the 02 00 00 01 bodies are opaque signed
    payloads (only the 4-byte header aligns), and the opcode->role dispatch lives in the signed SGX
    enclave
    (synaTEE116.signed.dll, no cleartext strings/code). So my "it's in the enclave" hunch
    was right about the selection logic, wrong about the blob data. The clean way to resolve it:
    map 00cb to the confirmed init blobs, then patch reset_blob to each candidate and run
    factory_reset() on the foreign sensor until the 0404 clears. db_write_enable is still open
    (blobs_9a's isn't in the DLL and group 7 has no ~3.6KB entry).

    (For completeness: decrypting the foreign capture is a dead end -- the bootstrap session is
    TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA (0xc005), ephemeral ECDH, so the session key needs the
    host's enclave-generated ephemeral private key or the sensor's static key, neither of which is in
    a passive pcap. Confirmed against the ServerHello.)

    I can share the pcaps, the two verified init blobs, and the extracted reset_blob candidates. If
    anyone with this reader on Linux wants to run the factory_reset() candidate trial, that pins
    down the last blob.

  4. ggiesen commented on Jul 8, 2026

    @ggiesen

    Resolved -- 06cb:00cb now works end-to-end on Linux via python-validity (enroll + verify, reboot-persistent). The reset_blob was the last unknown from my previous comment, and it's confirmed on hardware.

    reset_blob for 06cb:00cb: the two ~12 KB candidates I'd extracted from the driver's signed-blob table (the group-7 opcode-18 / 12100-byte and opcode-3 / 11972-byte entries) -- trialled both as a raw usb.cmd against the foreign-paired sensor:

    • 12100-byte candidate -> rejected (0x04aa)
    • 11972-byte candidate -> accepted (0x0000), and it wiped the flash (5 partitions -> 0)

    So 00cb's reset_blob is that 11972-byte blob. The other three are byte-identical to blobs_9a: init_hardcoded (581 B, also matches the on-wire capture), init_hardcoded_clean_slate (741 B), and db_write_enable (confirmed by init_db succeeding on hardware).

    Full working recipe (06cb:00cb, sensor type 0x969, identifies "57K0"):

    • usb.py: DEV_CB = (0x06cb, 0x00cb).
    • blobs.py: 00cb -> blobs_9a for init_hardcoded / init_hardcoded_clean_slate / db_write_enable, plus the extracted 00cb-specific reset_blob (the 11972-byte driver blob).
    • sensor.py: 0x969 has no native SensorTypeInfo / SensorCaptureProg, so alias it to 0xd51 right before real_device_type is set -- that routes it through the existing 0xd51 -> 0x199 capture-profile path (same 57K0 geometry: bytes_per_line=0x78, repeat_multiplier=2, 112 lines).
    • firmware_tables.py: DEV_CB -> '6_07f_hp_mis_qm.xpfwext', extracted from the HP SoftPaq (validity-sensors-firmware doesn't cover this device, so the xpfwext has to be provided separately).

    With that, on the foreign-paired sensor: factory_reset() wipes it, init_flash re-partitions, TLS re-pairs to the host, the firmware uploads, calibration runs, and enroll + verify both work (verify accepts the enrolled finger and rejects others). Confirmed reboot-persistent (the firmware just has to be restored into /run before the daemon starts, since it lives on tmpfs).

    Note on the earlier "capture the reset_blob over USB" plan: that turned out to be a dead end. The driver's reset path rides the encrypted bootstrap TLS session, and that session is ephemeral-ECDH, so a passive pcap can't recover the key -- the reset never appears on the wire in an extractable form. Static RE of synaWudfBioUsb116SGX.dll was the productive route: the signed blobs are stored there (without their leading 06 command byte) in a 30-entry descriptor table, and trialling the size-matched reset_blob candidates on hardware disambiguated the two ~12 KB entries.

    I'm happy to turn this into a PR adding 06cb:00cb (device registration + the 0x969 alias + a blobs_00cb carrying the extracted reset_blob). One question before I do: are the reset_blob / firmware bytes OK to include in-tree the way the existing blobs_* modules are, or would you prefer them provisioned another way? I can also share the capture + the extracted blobs if useful.

  5. ggiesen commented on Jul 9, 2026

    @ggiesen

    Opened as SimpleX-T#3 -- based on that fork's feat/sensor-type-0xd51 branch, which already carries the 0x969/0xd51 groundwork this builds on. Validated end-to-end on the hardware (enroll + verify working). Happy to port it here too if that's preferred.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions