LRU sensors are small USB fingerprint modules developed by Shenzhen Lirox Information Technology Co., Ltd., designed for access-control and embedded security devices. Each module has its own onboard processor that captures the fingerprint image and extracts its features, communicating with the host computer solely over USB. Recently, I had the chance to work with the LRU1011, a thin, inexpensive capacitive fingerprint sensor.
![]() |
| LRU1011 Fingerprint sensor. |
The vendor provides a closed-source Linux library for this sensor, which cannot be ported to architectures other than amd64.
To use the sensor on other architectures, I decided to build a lightweight C library for it. Because the vendor does not publish the protocol, I had to reverse-engineer it myself using two complementary methods:
- Hardware USB sniffing: I captured the USB traffic between the vendor's software and the sensor using an external hardware USB sniffer.
- Binary analysis: I studied the vendor's closed-source Linux library to identify commands, opcodes, and error codes, and to generalize the implementation.
Using both methods together worked especially well: the sniffed traffic confirmed what I found in the library, and the library explained what I observed on the wire.
From what I gathered, the protocol is split into two layers:
- Packets: The commands and replies themselves, which are consistent across models.
- Transport: How a packet is framed and carried over USB, which varies on some models.
Every command and reply uses a single frame:
| Offset | Size | Field |
|---|---|---|
| 0 | 2 | Header, always EF 01 |
| 2 | 4 | Chip address, always FF FF FF FF |
| 6 | 1 | Packet id: 01 = command, 07 = reply |
| 7 | 2 | Length (payload size + 2), big endian |
| 9 | n | Payload |
| 9+n | 2 | Checksum (big endian) |
The checksum is a simple 16-bit sum starting at the packet ID and ending at the last payload byte.
For example, here is the command to obtain the fingerprint image:
EF 01 FF FF FF FF 01 00 03 01 00 05
The first payload byte is the opcode. In a reply, the first byte is the confirmation code, where 00 means OK.
I mainly focused on the following commands:
| Opcode | Function |
|---|---|
0x13 or 0x33 |
Check that the sensor answers |
0x01 or 0x32 |
Capture an image. 00 = captured, 02 = no finger |
0x0A |
Upload the raw image (73728 bytes) |
0x02 |
Extract the feature template |
0x08 |
Upload the template (512 bytes) |
As I noticed, upload commands do not send an ACK packet; they send raw data directly.
The most interesting part of this sensor is its transport mechanism. I found that the same packets travel in two different ways:
- Bulk transport mode (models 0453:9005 and 0618:9018): Before every transfer, the host sends a vendor control request and then uses the bulk endpoints. The image is read in two halves of 36,864 bytes. The vendor library also resets the device after opening it and waits about 200ms.
- MSC mode (models 2009:7638 and 2109:7638): The device presents itself as a USB mass-storage device, even though it has no storage media, using the storage interface as a command pipe. Each transfer is wrapped in a mass-storage command: a 31-byte command block starting with USBC, a data stage, and a 13-byte status block starting with USBS. The image is read in 8 chunks of 9,216 bytes.
This is a clever trick by the vendor that lets the device work with basic drivers, though it requires care in the library since some ordinary USB drives share the same USB IDs.
Based on these findings, I built a generic C library for LRU sensors called openlru-lib. Written in C with zero external library dependencies, it doesn't even require libusb - it talks to the Linux usbfs interface directly.
The full source code, binary releases, and documentation are available in the project repository at https://github.com/dilshan/openlru-lib. The wiki covers the API, architecture, USB protocol, and troubleshooting in more detail.
This is an independent project and is not affiliated with or endorsed by the vendor. It is licensed under the BSD-3-Clause license.
Bug reports, test results on other models, and pull requests are all welcome.

Comments