基于Hyperledger Fabric的Web及移动应用用户认证实现技术问询

Great question—let’s break this down step by step for both web and Android apps, since Hyperledger Fabric’s authentication model leans heavily on PKI (Public Key Infrastructure) rather than traditional password systems.

1. Web Application Authentication Options #

Can We Use Password-Based Authentication? #

Short answer: Yes, but not directly with Fabric CA as a standalone solution. Fabric CA supports enrollment with an "enrollment secret" (a password-like value) during user registration, but this is meant for initial setup, not ongoing app authentication.

For a password-based flow in your web app, you’ll need to layer a password system on top of Fabric’s PKI:

• Let users create an account in your app with a password.
• Your backend uses this password to enroll the user with Fabric CA, retrieving their private key and X.509 certificate.
• Encrypt the private key using the user’s password (via a key derivation function like PBKDF2) and store the encrypted key either in your backend database or the user’s browser (use IndexedDB—avoid localStorage, it’s insecure).
• On subsequent logins, the user enters their password, you decrypt the private key, then use it to sign Fabric transactions or authenticate with peers.

Private Key-Based Authentication (Fabric’s Native Flow) #

This is the most secure and idiomatic approach for Fabric apps. Here’s how to implement it:

• Initial Enrollment: After user registration, your app (via backend proxy, ideally) interacts with Fabric CA to get the user’s private key and certificate. Never send plaintext private keys over the network.
• Secure Storage:
  • Encrypt the private key with a user-specific passphrase using the Web Crypto API (avoid client-side libraries for encryption—stick to browser-native tools).
  • Store the encrypted key in IndexedDB (persistent, secure) or your backend.
• Authenticating with Fabric:
  • When the user needs to interact with the ledger (submit a transaction, query data), retrieve the encrypted private key and decrypt it with their passphrase.
  • Use the private key to sign a transaction proposal (or any payload) and send it to Fabric peers along with the user’s certificate.
  • Peers verify the signature using the public key from the certificate (trusted because it’s issued by your Fabric CA) to authenticate the user.

Web Code Snippet (Web Crypto + Fabric SDK)

// Assume we have the encrypted private key and user's passphrase from storage/login
const userPassphrase = "user-secure-passphrase";
const storedEncryptedKey = await getEncryptedKeyFromIndexedDB();

// Derive encryption key from passphrase using PBKDF2
const keyMaterial = await crypto.subtle.importKey(
  "raw",
  new TextEncoder().encode(userPassphrase),
  { name: "PBKDF2" },
  false,
  ["deriveKey"]
);
const encryptionKey = await crypto.subtle.deriveKey(
  { name: "PBKDF2", salt: new Uint8Array(16), iterations: 100000, hash: "SHA-256" },
  keyMaterial,
  { name: "AES-GCM", length: 256 },
  false,
  ["decrypt"]
);

// Decrypt the Fabric private key
const decryptedKey = await crypto.subtle.decrypt(
  { name: "AES-GCM", iv: storedEncryptedKey.iv },
  encryptionKey,
  storedEncryptedKey.data
);

// Import key for ECDSA signing (Fabric uses ECDSA by default)
const privateKey = await crypto.subtle.importKey(
  "pkcs8",
  decryptedKey,
  { name: "ECDSA", namedCurve: "P-256" },
  true,
  ["sign"]
);

// Sign a Fabric transaction proposal
const proposal = await contract.createTransaction("transferAsset").buildProposal();
const signature = await crypto.subtle.sign(
  { name: "ECDSA", hash: "SHA-256" },
  privateKey,
  proposal.payload
);

// Attach signature to proposal and send to peers...

2. Android Application Authentication #

Implementing Private Key-Based Auth #

The core flow mirrors web apps, but Android has platform-specific tools to secure private keys:

• Initial Enrollment: Use your app’s backend to proxy requests to Fabric CA (direct CA calls from mobile are possible but riskier). Retrieve the user’s private key and certificate.
• Authenticating with Fabric: Use the Fabric SDK for Java/Kotlin to sign transactions with the private key. The SDK handles peer signature verification automatically.

Securing Private Keys on Android #

Never store plaintext private keys—use these Android-native security features:

• Android Keystore System: The gold standard. It stores keys in hardware-backed storage (if available) and prevents extraction from the device. You can either:
  • Generate a key pair directly in Keystore, then use it to encrypt the Fabric private key before storing it in SharedPreferences or Room.
  • Import the Fabric private key into Keystore (ensure it’s marked as non-exportable).
• Biometric Authentication: Tie Keystore key usage to biometric verification (fingerprint, face) to ensure only the authorized user can access the private key.
• Encrypted SharedPreferences: Use Jetpack Security’s EncryptedSharedPreferences to store encrypted private keys with AES encryption.

Android Code Snippet (Keystore + Fabric SDK)

// Generate an AES key in Android Keystore to encrypt the Fabric private key
val keyGenSpec = KeyGenParameterSpec.Builder(
  "fabric-key-encryptor",
  KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
)
  .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
  .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
  .setUserAuthenticationRequired(true) // Require biometrics to use this key
  .build()

val keyGenerator = KeyGenerator.getInstance(
  KeyProperties.KEY_ALGORITHM_AES,
  "AndroidKeyStore"
)
keyGenerator.init(keyGenSpec)
val encryptionKey = keyGenerator.generateKey()

// Encrypt the Fabric private key
val cipher = Cipher.getInstance("AES/GCM/NoPadding")
cipher.init(Cipher.ENCRYPT_MODE, encryptionKey)
val encryptedPrivateKey = cipher.doFinal(fabricPrivateKeyBytes)

// Store encrypted key and IV in EncryptedSharedPreferences
val masterKey = MasterKey.Builder(context)
  .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
  .build()
val encryptedPrefs = EncryptedSharedPreferences.create(
  "fabric-auth-prefs",
  masterKey,
  context,
  EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
  EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)
encryptedPrefs.edit()
  .putString("encrypted_private_key", Base64.encodeToString(encryptedPrivateKey, Base64.DEFAULT))
  .putString("iv", Base64.encodeToString(cipher.iv, Base64.DEFAULT))
  .apply()

// Later, decrypt the key (triggers biometric prompt)
val decryptCipher = Cipher.getInstance("AES/GCM/NoPadding")
val iv = Base64.decode(encryptedPrefs.getString("iv", ""), Base64.DEFAULT)
val gcmSpec = GCMParameterSpec(128, iv)
decryptCipher.init(Cipher.DECRYPT_MODE, encryptionKey, gcmSpec)
val decryptedKey = decryptCipher.doFinal(
  Base64.decode(encryptedPrefs.getString("encrypted_private_key", ""), Base64.DEFAULT)
)

// Initialize Fabric Gateway with the decrypted key
val privateKey = SecurityUtils.loadPrivateKeyFromBytes(decryptedKey)
val credentials = X509Credentials.create(privateKey, fabricCertificate)
val gateway = Gateway.Builder()
  .identity(credentials)
  .networkConfig(NetworkConfig.fromJsonFile(File(context.filesDir, "connection.json")))
  .connect()

3. Key Takeaways #

• Web Apps: Layer password auth on top of Fabric’s PKI, use Web Crypto for encryption, and avoid insecure storage like localStorage.
• Android Apps: Prioritize Android Keystore and biometrics for private key security—never expose plaintext keys to the app’s runtime.
• Fabric CA’s Role: It issues trusted certificates, but your app manages the user authentication flow. Fabric only cares that requests are signed with a valid, CA-issued private key.

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