如何通过Secugen Web API对比实时指纹TemplateBase64与数据库存储模板

Alright, let's figure out how to compare your live-captured SecuGen Hamster Plus fingerprint against the templates stored in your SQL database—since the SDK's example only covers on-the-fly client-side matching, we'll need to extend it a bit. Here's a practical, actionable approach:

Step-by-Step Solution #

1. Capture the Live Fingerprint Template #

First, reuse (or adapt) the SDK's existing capture logic to get the base64-encoded template of the real-time fingerprint. This is likely similar to the example code you already have:

// Wrapper function to capture a live fingerprint and return its base64 template
async function captureLiveFingerprint() {
  return new Promise((resolve, reject) => {
    secugenSDK.captureFinger({
      qualityThreshold: 80 // Adjust based on your needs
    }, (error, result) => {
      if (error) {
        reject(`Capture failed: ${error.message}`);
        return;
      }
      // Resolve with the live template's base64 string
      resolve(result.templateBase64);
    });
  });
}

2. Fetch the Stored Template from Your SQL Database #

You'll need a simple backend endpoint to retrieve the stored base64 template for the user you want to verify. Here's how to set this up:

Frontend (Fetch Request)

// Fetch the stored fingerprint template for a given user ID
async function getStoredTemplate(userId) {
  try {
    const response = await fetch(`/api/fingerprints/${userId}`, {
      method: 'GET',
      headers: { 'Content-Type': 'application/json' }
    });
    
    if (!response.ok) throw new Error('Failed to fetch stored template');
    const data = await response.json();
    return data.templateBase64;
  } catch (err) {
    console.error(err);
    throw err;
  }
}

Backend Example (Node.js/Express + MySQL)

const mysql = require('mysql2/promise');
const express = require('express');
const app = express();

// Set up database connection pool
const dbPool = mysql.createPool({
  host: 'your-db-host',
  user: 'your-db-username',
  password: 'your-db-password',
  database: 'your-db-name'
});

// Endpoint to fetch stored fingerprint template
app.get('/api/fingerprints/:userId', async (req, res) => {
  try {
    const { userId } = req.params;
    const [rows] = await dbPool.query(
      'SELECT templateBase64 FROM fingerprints WHERE userId = ?',
      [userId]
    );
    
    if (rows.length === 0) {
      return res.status(404).json({ error: 'No fingerprint template found for this user' });
    }
    
    res.json({ templateBase64: rows[0].templateBase64 });
  } catch (err) {
    res.status(500).json({ error: 'Database query failed' });
    console.error(err);
  }
});

app.listen(3000, () => console.log('Backend server running on port 3000'));

3. Convert Templates & Run the Comparison #

SecuGen's SDK likely requires binary data (not base64 strings) for comparison. We'll convert both the live and stored base64 templates to Uint8Array, then use the SDK's underlying comparison function (even if the example only used it for client-side pairs).

// Convert base64 string to Uint8Array (required by most fingerprint SDKs)
function base64ToUint8Array(base64) {
  const binaryStr = atob(base64);
  const byteArray = new Uint8Array(binaryStr.length);
  for (let i = 0; i < binaryStr.length; i++) {
    byteArray[i] = binaryStr.charCodeAt(i);
  }
  return byteArray;
}

// Core comparison function
async function verifyFingerprint(userId) {
  try {
    // Get both templates
    const liveTemplateBase64 = await captureLiveFingerprint();
    const storedTemplateBase64 = await getStoredTemplate(userId);
    
    // Convert to binary format
    const liveTemplate = base64ToUint8Array(liveTemplateBase64);
    const storedTemplate = base64ToUint8Array(storedTemplateBase64);
    
    // Run comparison using SecuGen SDK's built-in function
    const comparisonResult = secugenSDK.compareTemplates(liveTemplate, storedTemplate);
    
    // Adjust the threshold based on your security needs (typically 70-90)
    const matchThreshold = 80;
    if (comparisonResult.score >= matchThreshold) {
      console.log(`Fingerprint matched! Score: ${comparisonResult.score}`);
      return { success: true, score: comparisonResult.score };
    } else {
      console.log(`Fingerprint mismatch. Score: ${comparisonResult.score}`);
      return { success: false, score: comparisonResult.score };
    }
  } catch (err) {
    console.error('Verification failed:', err);
    return { success: false, error: err.message };
  }
}

4. Key Notes to Avoid Pitfalls #

• Check SDK Parameter Requirements: Some versions of SecuGen's Web SDK might accept base64 strings directly for comparison—double-check the compareTemplates (or equivalent) function's docs to skip the Uint8Array conversion if needed.
• Security Best Practices: Always use HTTPS to transmit fingerprint templates, add authentication to your backend endpoint, and avoid exposing raw templates to unauthorized users.
• Template Format Consistency: Ensure the base64 string stored in SQL is identical to the format output by the SDK's capture function (no extra encoding/decoding steps added accidentally).

内容的提问来源于stack exchange，提问作者Aliyu Abdullahi