libfprint API Reference

libfprint is an open source library to provide access to fingerprint scanning devices. For more info, see the libfprint project homepage.

This documentation is aimed at application developers who wish to integrate fingerprint-related functionality into their software. libfprint has been designed so that you only have to do this once - by integrating your software with libfprint, you'll be supporting all the fingerprint readers that we have got our hands on. As such, the API is rather general (and therefore hopefully easy to comprehend!), and does it's best to hide the technical details that required to operate the hardware.

This documentation is not aimed at developers wishing to develop and contribute fingerprint device drivers to libfprint.

Feedback on this API and it's associated documentation is appreciated. Was anything unclear? Does anything seem unreasonably complicated? Is anything missing? Let us know on the mailing list.

Before you dive into the API, it's worth introducing a couple of concepts.

The process of enrolling a finger is where you effectively scan your finger for the purposes of teaching the system what your finger looks like. This means that you scan your fingerprint, then the system processes it and stores some data about your fingerprint to refer to later.

Verification is what most people think of when they think about fingerprint scanning. The process of verification is effectively performing a fresh fingerprint scan, and then comparing that scan to a finger that was previously enrolled.

As an example scenario, verification can be used to implement what people would picture as fingerprint login (i.e. fingerprint replaces password). For example:

I enroll my fingerprint through some software that trusts I am who I say I am. This is a prerequisite before I can perform fingerprint-based login for my account.

Some time later, I want to login to my computer. I enter my username, but instead of prompting me for a password, it asks me to scan my finger. I scan my finger.

The system compares the finger I just scanned to the one that was enrolled earlier. If the system decides that the fingerprints match, I am successfully logged in. Otherwise, the system informs me that I am not authorised to login as that user.

Identification is the process of comparing a freshly scanned fingerprint to a collection of previously enrolled fingerprints. For example, imagine there are 100 people in an organisation, and they all have enrolled their fingerprints. One user walks up to a fingerprint scanner and scans their finger. With no other knowledge of who that user might be, the system examines their fingerprint, looks in the database, and determines that the user is user number #61.

In other words, verification might be seen as a one-to-one fingerprint comparison where you know the identity of the user that you wish to authenticate, whereas identification is a one-to-many comparison where you do not know the identity of the user that you wish to authenticate.

Moving off generic conceptual ideas and onto libfprint-specific implementation details, here are some introductory notes regarding how libfprint copes with compatibility of fingerprints.

libfprint deals with a whole variety of different fingerprint readers and the design includes considerations of compatibility and interoperability between multiple devices. Your application should also be prepared to work with more than one type of fingerprint reader and should consider that enrolled fingerprint X may not be compatible with the device the user has plugged in today.

libfprint implements the principle that fingerprints from different devices are not necessarily compatible. For example, different devices may see significantly different areas of fingerprint surface, and comparing images between the devices would be unreliable. Also, devices can stretch and distort images in different ways.

libfprint also implements the principle that in some cases, fingerprints are compatible between different devices. If you go and buy two identical fingerprint readers, it seems logical that you should be able to enroll on one and verify on another without problems.

libfprint takes a fairly simplistic approach to these issues. Internally, fingerprint hardware is driven by individual drivers. libfprint enforces that a fingerprint that came from a device backed by driver X is never compared to a fingerprint that came from a device backed by driver Y.

Additionally, libfprint is designed for the situation where a single driver may support a range of devices which differ in imaging or scanning properties. For example, a driver may support two ranges of devices which even though are programmed over the same interface, one device sees substantially less of the finger flesh, therefore images from the two device types should be incompatible despite being from the same driver. To implement this, each driver assigns a device type to each device that it detects based on its imaging characteristics. libfprint ensures that two prints being compared have the same device type.

In summary, libfprint represents fingerprints in several internal structures and each representation will offer you a way of determining the driver ID and devtype of the print in question. Prints are only compatible if the driver ID and devtypes match. libfprint does offer you some "is this print compatible?" helper functions, so you don't have to worry about these details too much.

Currently, all data acquisition operations are synchronous and can potentially block for extended periods of time. For example, the enroll function will block for an unpredictable amount of time until the user scans their finger.

Alternative asynchronous/non-blocking functionality will be offered in future but has not been implemented yet.