扩展隐私分析、攻击面扫描配置文件以及 GitHub 源代码映射改进

// VULNERABLE IMPLEMENTATION: Biometric authentication with CryptoObject but without actually using it

public class MisusedCryptoObjectAuthenticator {
    private static final String ENCRYPTED_DATA_KEY = "encrypted_data";
    private SharedPreferences preferences;
    private Cipher cipher;
    private SecretKey secretKey;

    public MisusedCryptoObjectAuthenticator(Context context) {
        this.preferences = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE);
        try {
            // Initialize crypto components
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(256);
            secretKey = keyGenerator.generateKey();
            cipher = Cipher.getInstance("AES/GCM/NoPadding");
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void authenticateUser(final AuthenticationCallback callback) {
        try {
            // We create a CryptoObject and pass it to the biometric prompt
            BiometricPrompt.CryptoObject cryptoObject = new BiometricPrompt.CryptoObject(cipher);

            BiometricPrompt biometricPrompt = new BiometricPrompt(activity,
                    executor,
                    new BiometricPrompt.AuthenticationCallback() {
                        @Override
                        public void onAuthenticationSucceeded(BiometricPrompt.AuthenticationResult result) {
                            // VULNERABILITY: We have the cryptoObject but don't use it!
                            // Instead, we just set a flag or retrieve data directly

                            // The CryptoObject from the result is ignored
                            BiometricPrompt.CryptoObject cryptoResult = result.getCryptoObject();

                            // Simply set authentication flag without using the CryptoObject
                            setAuthenticated(true);
                            callback.onSuccess();
                        }

                        @Override
                        public void onAuthenticationFailed() {
                            callback.onFailure("Authentication failed");
                        }
                    });

            // We pass the cryptoObject to authenticate
            biometricPrompt.authenticate(promptInfo, cryptoObject);

        } catch (Exception e) {
            callback.onFailure("Error: " + e.getMessage());
        }
    }

    private void setAuthenticated(boolean authenticated) {
        preferences.edit().putBoolean("is_authenticated", authenticated).apply();
    }

    // VULNERABILITY: This method retrieves sensitive data without requiring the
    // cryptoObject that was used during authentication
    public String getSensitiveData() {
        // Simply checks a boolean flag instead of using crypto binding
        if (preferences.getBoolean("is_authenticated", false)) {
            // Get data without using the CryptoObject for decryption
            String encryptedData = preferences.getString(ENCRYPTED_DATA_KEY, null);
            // We manually decrypt using our stored secretKey instead of
            // using the key bound to biometric authentication
            return decryptWithStoredKey(encryptedData);
        }
        return null;
    }

    private String decryptWithStoredKey(String encryptedData) {
        // Decrypt using the stored key, not the one from biometric authentication
        try {
            // This uses the class-level secretKey, not anything from the biometric result
            Cipher decryptCipher = Cipher.getInstance("AES/GCM/NoPadding");
            decryptCipher.init(Cipher.DECRYPT_MODE, secretKey);
            return new String(decryptCipher.doFinal(Base64.decode(encryptedData, Base64.DEFAULT)));
        } catch (Exception e) {
            return null;
        }
    }
}