Take the 2-minute tour ×
Cryptography Stack Exchange is a question and answer site for software developers, mathematicians and others interested in cryptography. It's 100% free, no registration required.

How would one go about generating Encryption Keys from Biometric Fingerprint Templates extracted from a fingerprint using either Griaule SDK or DigitalPersona SDK or any other SDK that will return the fingerprint template in either ISO or ANSI fingerprint templates format? Is there a way one would do that using Fuzzy Extractors, Secure Sketch, Bio Hashing or any other approach? I will appreciate if anyone can show me how to go about this in any programming language? I intend to use the obtained Encryption Keys in encryption and decryption of data.

share|improve this question

2 Answers 2

Caution: this answer is tentative, and touches only a minuscule part of the subject.

Everyone, please fell free to incorporate it in your own answer, or edit it.

A common misconception is that there are known methods to capture biometric data (like a fingerprint), apply some transformation, and get a reproducible cryptographic key. Fact seems to be: something vaguely related to the curse of dimensionality makes the error rate plain unacceptable for a cryptographic key of any useful size (like 80 bit of entropy).

The best achieved is like: in an enrollment phase, we acquire biometric data, apply some transformation, and get error-correction data and a cryptographic key; later, we combine freshly acquired biometric data and that error-correction data into a cryptographic key, such that

  • the cryptographic key output is quite reproducible from one use to another;
  • knowledge of the error-correction data alone does not much help finding the cryptographic key.

That's the job of Fuzzy Extractors; try this query for relevant articles.

Note: I second mikeazo's advice that Security with Noisy Data (alternate link with more free material) is spot-on.

share|improve this answer
    
Any references on the entropy rate of fingerprints and the error rates seen with COTS scanners? –  mikeazo May 27 at 18:58
    
@mikeazo: sorry, I have nothing. –  fgrieu May 27 at 19:08

There is a pretty good introductory book that strongly relates to the topic area: Security with Noisy Data that I would recommend you take a look at. The book has constructions for how you would do this (turn fingerprint readings into keys), information on different adversary models you might consider, and information on related topic areas.

I am not familiar with either of the SDKs you mention, or the formats. So, for the sake of simplicity, I'll assume that each time you read the fingerprint, you get back a binary string. Since the scanners are not perfect, each time you read from it, you will get back a slightly different binary string. Let $\rho$ be the maximum error rate you see between binary strings which come from scanning the same fingerprint. One chapter in the book (which is freely available here) gives constructions for how you can generate and publish some helper data which can be stored in plaintext. This helper data allows you to recover the original key so that you can, for example, decrypt.

Let $C$ be an $[n, k, 2t+1]$ linear error correction code defined over some finite field $\mathcal{F}$. $t$ is the number of errors that can be corrected, so we need $t$ to be large enough to correct $n\rho$ errors. The syndrome construction for secure sketches works as follows.

We have 2 phases (enrollment and reconstruction or GEN and REP). GEN: Let $H$ be the parity check metric of $C$. We take a sample from the reader to get the binary string representing the fingerprint, call it $w$. The length of $w$ is $n$. Let $H$ be the parity check matrix of $C$, we compute the syndrome of $w$ as $wH=s$. We then run $w$ through an extractor (e.g., a hash function) to get the key. We publish $s$ publicly as the helper data.

REP: At some later point in time, we want to reconstruct the key (do do a decryption or further encryption). This time we take another sample using the reader and get $w'$. We decode $w'$ using $s$ to get back $w$, and rerun $w$ through the extractor to get the key. As long as the hamming distance between $w$ and $w'$ is less than or equal to $t$ we are guaranteed to get the same key. For more information on coding, and some source code, see here.

In practice there can be issues. The helper data $s$ leaks information. So, to get 80 bits of security, $w$ is going to have to be larger than 80 bits long. Using the syndrome construction, we can quantify the amount of information leaked by $s$. It is $n-k$ which happens to also be the length of $s$. I am not sure what the error rate is for fingerprint scans or the entropy rate. It could very well be that by the time we have published $s$ there is no usable entropy left. Recent work tries to deal with this case. But, if the error rate is too high, and the number bits in a single fingerprint is too low, we could be in a case where there is just not enough entropy to get a strong key. Therefore, you really need to analyze and think about if this will work. Theoretical constructions are there, but physical limitations might make it impossible.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.