Fingerprint-Based Biometric Authentication using Gabor Filters and Fuzzy Vaults

This repository contains the implementation of a novel biometric authentication system that leverages Gabor filters for robust fingerprint feature extraction and a Fuzzy Vault scheme for secure key storage and verification. The system enhances security by integrating a Pseudo-Random Function (PRF) to create a two-factor authentication mechanism, requiring both the user's biometric data and a secret key.

---

Overview

This project addresses the inherent intra-user variability of biometric data by designing a security system that is tolerant to minor changes in fingerprint scans. Instead of storing raw biometric templates, which is a significant security risk, we lock a secret key within a "vault" using the user's fingerprint features. Authentication is successful only if a new fingerprint scan is close enough to the original, unlocking the vault.

1. Feature Extraction with Gabor Filters

The core of the biometric processing lies in the use of Gabor filters. These filters are ideal for fingerprint analysis because their frequency and orientation parameters mimic the properties of the human visual system, making them excellent for capturing the distinct ridge and valley patterns in a fingerprint.

• Process: The input fingerprint image is convolved with a bank of Gabor filters at various orientations ($\theta$) and wavelengths ($\lambda$). This process generates a set of filtered images, each highlighting features at a specific orientation. The image gabor_image.jpg shows a fingerprint after being processed by one such filter.

• Output: The resulting feature vectors capture a rich, multi-dimensional representation of the fingerprint's unique texture, providing a robust template for the next stage. The script gabor.py handles this feature extraction.

2. The Fuzzy Vault Scheme & Polynomial Reconstruction

The Fuzzy Vault is a cryptographic construct designed to handle noisy biometric data. It works by "locking" a secret within a set of points derived from the biometric template.

• Encoding (Vault Creation):

  1. We define a polynomial of degree $n$ whose coefficients represent the secret to be protected.
  2. The Gabor feature vectors (minutiae points) from the user's fingerprint are projected onto this polynomial, creating a set of points $(x_i, y_i)$.
  3. To obscure the real points, a large number of random "chaff" points are added to the vault. These points do not lie on the secret polynomial.
  4. The final vault consists of this mixed set of genuine and chaff points.

• Decoding (Authentication):

  1. A new fingerprint scan is provided, and its Gabor features are extracted.
  2. The user's feature set is used to identify the genuine points from the chaff points within the vault.
  3. If a sufficient number of genuine points are identified, Lagrange interpolation or another polynomial reconstruction algorithm can be used to rebuild the original polynomial.
  4. The coefficients of the reconstructed polynomial are compared to the stored secret. If they match within a predefined tolerance, authentication is successful.

The encryption.py and authentication.py scripts manage the vault creation and verification logic.

3. Two-Factor Security with a Pseudo-Random Function (PRF)

To elevate the system beyond single-factor biometrics, we introduce a user-specific secret key that is combined with the biometric template.

• Mechanism: A Pseudo-Random Function (PRF), implemented using SHA-256, takes the user's secret key and the Gabor feature coefficients as input. output = PRF(secret_key, gabor_features)
• Integration: The output of the PRF is a deterministic but unpredictable hash. This hash is then added to the polynomial coefficients before they are stored in the vault.
• Security Benefit: This process ensures that for authentication, both the correct fingerprint (to unlock the vault) and the original secret key (to correctly generate the PRF output for comparison) are required. This protects against scenarios where either the biometric data or the key is compromised alone. The prf.py and prf_user.py scripts contain this implementation.

biometric_authentication/
├── biometric_auth/
│   ├── .gitkeep
│   ├── authentication.py
│   ├── encryption.py
│   ├── gabor.py
│   ├── prf_user.py
│   ├── prf.py
│   └── user.py
├── data/
│   ├── gabor_image.jpg
│   ├── og_gabor_image.jpg
│   ├── og_vault.pickle
│   ├── right_print1.tif
│   ├── right_print2.png
│   ├── test_gabor_image.jpg
│   ├── test_vault.pickle
│   ├── user_gabor_image.jpg
│   ├── wrong_print1.tif
│   └── wrong_print2.tif
├── datasets/
│   ├── CrossMatch_Sample_DB.zip
│   ├── Augmented_CrossMatch_Sample_DB/
│   │   └── [many .tif files]
│   └── CrossMatch_Sample_DB/
│       └── [many .tif files]
├── notebooks/
│   ├── authenticationnb.ipynb
│   ├── imgaug.ipynb
│   ├── testing.ipynb
│   └── vault_generation.ipynb
├── scripts/
│   └── testing.py
└── README.md