import 'package:engine_security/engine_security.dart'; void main() async { // Detectar Frida final fridaDetector = EngineFridaDetector(); final fridaResult = await fridaDetector.performCheck(); if (!fridaResult.isSecure) { print('⚠️ Frida detectado: ${fridaResult.details}'); print('🎯 Confiança: ${fridaResult.confidence}'); } // Detectar Root/Jailbreak final rootDetector = EngineRootDetector(); final rootResult = await rootDetector.performCheck(); if (!rootResult.isSecure) { print('⚠️ Device comprometido: ${rootResult.details}'); } // Verificação completa await performFullSecurityCheck(); } Future<void> performFullSecurityCheck() async { final detectors = [ EngineFridaDetector(), EngineRootDetector(), EngineHttpsPinningDetector(), EngineGpsFakeDetector(), EngineEmulatorDetector(), EngineDebuggerDetector(), ]; print('🔍 Executando verificação completa de segurança...\n'); for (final detector in detectors) { if (detector.isAvailable) { final result = await detector.performCheck(); final status = result.isSecure ? '✅' : '❌'; print('$status ${detector.detectorName}'); print(' Confiança: ${(result.confidence * 100).toStringAsFixed(1)}%'); print(' Detalhes: ${result.details ?? 'N/A'}'); print(''); } } }

import 'package:engine_security/engine_security.dart'; import 'dart:io'; void setupCertificatePinning() { // Configurar pins para diferentes domínios final pins = [ EngineCertificatePinModel( hostname: 'api.example.com', pins: [ 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=', // SHA-256 em base64 '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', // SHA-256 em hex ], includeSubdomains: true, enforcePinning: true, ), EngineCertificatePinModel( hostname: 'stmr.tech', pins: [ '17a8d38a1f559246194bccae62a794ff80d419e849fa78811a4910d7283c1f75', // SHA-256 fingerprint real ], includeSubdomains: true, enforcePinning: true, ), ]; // Configurar HttpOverrides global final httpOverrides = EngineSecurityHttpOverrides( pinnedCertificates: pins, onPinningValidation: (hostname, isValid, error) { print('Validação de pin para $hostname: ${isValid ? 'OK' : 'FALHA'}'); if (error != null) print('Erro: $error'); }, ); HttpOverrides.global = httpOverrides; }

Future<void> checkCertificatePinning() async { final detector = EngineHttpsPinningDetector( enabled: true, pinnedCertificates: [ EngineCertificatePinModel( hostname: 'stmr.tech', pins: ['17a8d38a1f559246194bccae62a794ff80d419e849fa78811a4910d7283c1f75'], includeSubdomains: true, ), ], testConnectivity: false, strictMode: false, // true = só valida pins existentes ); final result = await detector.performCheck(); if (!result.isSecure) { print('Certificate pinning não está configurado!'); print('Detalhes: ${result.details}'); } else { print('Certificate pinning configurado corretamente!'); print('Sites protegidos: ${result.details}'); } }

// Obter o fingerprint diretamente do servidor ativo final pinModel = await EngineHttpsPinningDetector.createPinFromLiveHost('stmr.tech'); print('Fingerprints obtidos: ${pinModel?.pins}');

// Se você tem um arquivo .crt ou .pem final pinModel = await EngineHttpsPinningDetector.createPinFromCertificateFile( 'api.example.com', '/path/to/certificate.crt', );

// Se você já tem o hash SHA-256 final pinModel = EngineHttpsPinningDetector.createPinFromHash( 'stmr.tech', '17a8d38a1f559246194bccae62a794ff80d419e849fa78811a4910d7283c1f75', );

import 'package:engine_security/engine_security.dart'; Future<void> checkGPSFake() async { final gpsDetector = EngineGpsFakeDetector(); // Verificação básica final result = await gpsDetector.performCheck(); if (!result.isSecure) { print('⚠️ GPS Fake detectado!'); print('📍 Detalhes: ${result.details}'); print('🔍 Método: ${result.detectionMethod}'); print('🎯 Confiança: ${(result.confidence * 100).toStringAsFixed(1)}%'); } else { print('✅ GPS é confiável'); } }

class EngineSecurityCheckModel { final bool isSecure; final EngineSecurityThreatType threatType; final double confidence; final String? details; final String? detectionMethod; final DateTime? timestamp; EngineSecurityCheckModel.secure({...}); EngineSecurityCheckModel.threat({required EngineSecurityThreatType threatType, ...}); }

class EngineDetectorInfoModel { final String name; final EngineSecurityThreatType threatType; final bool enabled; final String platform; }

class EngineCertificatePinModel { final String hostname; final List<String> pins; // SHA-256 em base64 ou hexadecimal final bool includeSubdomains; final bool enforcePinning; // Métodos de validação bool isValidPinFormat(String pin); bool matchesHostname(String host); }

enum EngineSecurityThreatType { unknown, // Severidade: 5 frida, // Severidade: 9 rootJailbreak, // Severidade: 8 httpsPinning, // Severidade: 8 gpsFake, // Severidade: 7 emulator, // Severidade: 6 debugger, // Severidade: 2 }

abstract class IEngineSecurityDetector { EngineSecurityThreatType get threatType; String get detectorName; Future<EngineSecurityCheckModel> performCheck(); bool get isAvailable; EngineDetectorInfoModel get detectorInfo; }

class MySecurityManager { final List<IEngineSecurityDetector> _detectors = [ EngineFridaDetector(), EngineRootDetector(), EngineHttpsPinningDetector(), EngineGpsFakeDetector(), EngineEmulatorDetector(), EngineDebuggerDetector(), ]; Future<List<EngineSecurityCheckModel>> scanAllThreats() async { final results = <EngineSecurityCheckModel>[]; for (final detector in _detectors) { if (detector.isAvailable) { try { final result = await detector.performCheck(); results.add(result); } catch (e) { results.add(EngineSecurityCheckModel.threat( threatType: detector.threatType, details: 'Erro na detecção: $e', confidence: 0.5, )); } } } return results; } Future<bool> isDeviceSecure({double minimumConfidence = 0.8}) async { final results = await scanAllThreats(); for (final result in results) { if (!result.isSecure && result.confidence >= minimumConfidence) { return false; } } return true; } }