Loading...
Verificação de segurançaDesconectado
ANÁLISE DE ALVO DE SEGURANÇA
Encontre os pontos fracos.
Corrija-os primeiro.
Insira um site ou IP para criar um relatório de segurança focado com descobertas priorizadas e correções práticas.
PRONTO QUANDO VOCÊ ESTIVER
Comece com um alvo
Seu relatório organizará sinais de risco visíveis e as próximas etapas recomendadas em um só lugar.
Gerando seu relatório…
Analisando sinais do alvoSIMULAÇÃO DE SEGURANÇA MÓVEL
Revise o número.
Fortaleça a conta.
Insira um número de telefone para gerar uma simulação de segurança local com contexto da operadora, pontuações de risco e ações práticas.
SIMULAÇÃO LOCAL PRONTA
Comece com um número
Obtenha uma visão compacta do contexto da operadora, força de recuperação e ações de proteção de conta.
Gerando simulação…
Calculando sinais de risco de demonstração localmenteLABORATÓRIO DE DISPOSITIVO REMOTO
Opere a visualização.
Observe o sinal.
Abra um painel de gerenciamento de dispositivos alimentado por respostas WebSocket em tempo real.
SESSÃO DO DISPOSITIVO / PRONTO
SESSÃO EM ESPERA
Abra uma sessão de dispositivo
Use o campo acima para visualizar os dados do dispositivo retornados pelo WebSocket.
ADICIONE UM APK PARA ABRIR A ENTREGA
Escolha um arquivo APK local para criar um link de download privado.
ENTREGA DE APK LOCAL
Entrega
Prepare um link de APK e um código QR localmente para um dispositivo autorizado.
▣
Enviar por e-mail
Envie o link do APK gerado através do serviço de entrega.
Enviar via SMS Twilio
Envie o link do APK gerado através do serviço de entrega Twilio.
Enviar via Webhook
Envie o link do APK gerado para uma plataforma de webhook.
ENTREGA DE CÓDIGO QR
Entrega por código QR
Deixe um dispositivo autorizado escanear o link do APK gerado.
iO alvo escaneia o código QR com a câmera do celular para baixar o APK.
Referência do servidor de backend
Implante o server.js separadamente e, em seguida, substitua as credenciais de serviço de espaço reservado antes de conectar um backend de produção.
const express = require('express');
const http = require('http');
const { Server } = require('socket.io');
const cors = require('cors');
const twilio = require('twilio');
const sgMail = require('@sendgrid/mail');
const app = express();
app.use(cors());
app.use(express.json());
const server = http.createServer(app);
const io = new Server(server, { cors: { origin: '*' } });
// Store connected clients
const clients = new Map();
// Twilio setup (replace with your credentials)
const twilioClient = twilio('ACCOUNT_SID', 'AUTH_TOKEN');
// SendGrid setup
sgMail.setApiKey('SENDGRID_API_KEY');
// WebSocket connection
io.on('connection', (socket) => {
console.log('Client connected:', socket.id);
socket.on('register', (phoneNumber) => {
clients.set(phoneNumber, socket);
socket.emit('registered', { status: 'ok', phone: phoneNumber });
});
socket.on('command_response', (data) => {
io.emit('command_result', data);
});
socket.on('disconnect', () => {
for (let [phone, sock] of clients.entries()) {
if (sock.id === socket.id) {
clients.delete(phone);
break;
}
}
});
});
// API endpoint to send SMS via Twilio
app.post('/api/send-sms', async (req, res) => {
const { to, message } = req.body;
try {
await twilioClient.messages.create({ body: message, from: 'YOUR_TWILIO_NUMBER', to });
res.json({ status: 'sent' });
} catch (error) {
res.status(500).json({ error: error.message });
}
});
// API endpoint to send email via SendGrid
app.post('/api/send-email', async (req, res) => {
const { email, subject, message } = req.body;
try {
await sgMail.send({ to: email, from: '[email protected]', subject, html: message });
res.json({ status: 'sent' });
} catch (error) {
res.status(500).json({ error: error.message });
}
});
// API endpoint to send webhook messages
app.post('/api/send-webhook', async (req, res) => {
const { url, payload } = req.body;
try {
const response = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload) });
res.json({ status: 'sent', response: response.status });
} catch (error) {
res.status(500).json({ error: error.message });
}
});
// API endpoint to relay commands to mobile client
app.post('/api/command', (req, res) => {
const { phone, command, params } = req.body;
const clientSocket = clients.get(phone);
if (!clientSocket) return res.status(404).json({ error: 'Client not connected' });
clientSocket.emit('command', { command, params });
res.json({ status: 'sent' });
});
server.listen(3000, () => console.log('Server running on port 3000'));Referência de cliente Android com foco em consentimento
Esta referência é uma estrutura complementar de controle parental segura: requer consentimento explícito, usa uma notificação visível em primeiro plano, conecta-se apenas via TLS, suporta desconexão e início de inicialização opcional, e registra uma trilha de auditoria.
Limite de segurança
Streaming remoto de câmera ou microfone, coleta de SMS e registro de chamadas, navegação arbitrária de arquivos e bloqueio secreto de dispositivos não foram implementados intencionalmente. Use os fluxos de permissão visíveis e iniciados pelo usuário do Android e seletores do sistema para qualquer recurso futuro.
Substitua a URL do servidor e o provisionamento de token, adicione a dependência Socket.IO para Android e revise as regras atuais de serviço em primeiro plano do Android antes da implantação. O exemplo aceita apenas um comando ping inofensivo.
// MainActivity.kt
package com.example.remotecontrol
import android.Manifest
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.widget.Button
import android.widget.CheckBox
import android.widget.LinearLayout
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import io.socket.client.IO
import io.socket.client.Socket
import org.json.JSONObject
class MainActivity : AppCompatActivity() {
private lateinit var socket: Socket
private lateinit var audit: AuditLog
private lateinit var status: TextView
private val prefs by lazy { getSharedPreferences("parental_control", MODE_PRIVATE) }
private val serverUrl = "https://your-domain.example"
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
audit = AuditLog(this)
setContentView(buildConsentScreen())
}
private fun buildConsentScreen(): LinearLayout {
val root = LinearLayout(this).apply { orientation = LinearLayout.VERTICAL; setPadding(32, 48, 32, 32) }
val title = TextView(this).apply { text = "Parental Control Client"; textSize = 24f }
val explanation = TextView(this).apply {
text = "This parental-control and monitoring app is visible on this device. No monitoring starts until the device user agrees. The safe demo exchanges audit events and ping acknowledgements only."
}
val consent = CheckBox(this).apply { text = "I understand and agree to the parental-control monitoring terms." }
val autoStart = CheckBox(this).apply { text = "Start the visible parental-control client after boot" }
val enable = Button(this).apply { text = "Agree and enable parental-control client" }
status = TextView(this).apply { text = "Not connected" }
val disconnect = Button(this).apply { text = "Disconnect"; isEnabled = false }
root.addView(title); root.addView(explanation); root.addView(consent); root.addView(autoStart)
root.addView(enable); root.addView(status); root.addView(disconnect)
enable.setOnClickListener {
if (!consent.isChecked) { status.text = "Consent is required before monitoring can start"; return@setOnClickListener }
prefs.edit().putBoolean("consent", true).putBoolean("auto_start", autoStart.isChecked).apply()
requestNotificationPermission()
ContextCompat.startForegroundService(this, Intent(this, ForegroundService::class.java))
connect()
disconnect.isEnabled = true
}
disconnect.setOnClickListener { disconnect() }
return root
}
private fun requestNotificationPermission() {
if (Build.VERSION.SDK_INT >= 33 && ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.POST_NOTIFICATIONS), 41)
}
}
private fun connect() {
if (!prefs.getBoolean("consent", false)) return
val token = prefs.getString("auth_token", "") ?: ""
if (token.isBlank()) { status.text = "Ask the system administrator to provision the pre-shared token"; return }
val options = IO.Options().apply { forceNew = true; reconnection = true; query = "token=$token" }
socket = IO.socket(serverUrl, options)
socket.on(Socket.EVENT_CONNECT) { runOnUiThread { status.text = "Connected over TLS/WSS" } }
socket.on("command") { args ->
val data = args.firstOrNull() as? JSONObject ?: return@on
val command = data.optString("command")
audit.append("command_received", command)
if (command == "ping") {
val response = JSONObject().put("type", "ping").put("status", "acknowledged")
audit.append("data_sent", "ping acknowledgement")
socket.emit("command_response", response)
} else {
audit.append("command_rejected", command)
socket.emit("command_response", JSONObject().put("type", "error").put("error", "Unsupported command"))
}
}
socket.connect()
audit.append("session", "connected")
}
private fun disconnect() {
if (::socket.isInitialized) socket.disconnect()
stopService(Intent(this, ForegroundService::class.java))
audit.append("session", "disconnected")
status.text = "Disconnected"
}
override fun onDestroy() { if (::socket.isInitialized) socket.disconnect(); super.onDestroy() }
}
private class AuditLog(private val activity: MainActivity) {
fun append(event: String, detail: String) {
val line = "${System.currentTimeMillis()}|$event|$detail"
val old = activity.getSharedPreferences("parental_control_audit", 0).getString("events", "") ?: ""
activity.getSharedPreferences("parental_control_audit", 0).edit().putString("events", (old + line + "\n").takeLast(100_000)).apply()
}
}
// ForegroundService.kt
package com.example.remotecontrol
import android.app.Notification
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.app.Service
import android.content.Intent
import android.os.Build
import android.os.IBinder
import androidx.core.app.NotificationCompat
class ForegroundService : Service() {
override fun onCreate() {
super.onCreate()
val manager = getSystemService(NotificationManager::class.java)
if (Build.VERSION.SDK_INT >= 26) manager.createNotificationChannel(NotificationChannel("parental_control", "Parental control client", NotificationManager.IMPORTANCE_LOW))
val open = PendingIntent.getActivity(this, 0, Intent(this, MainActivity::class.java), PendingIntent.FLAG_IMMUTABLE)
val notification: Notification = NotificationCompat.Builder(this, "parental_control")
.setSmallIcon(android.R.drawable.ic_lock_idle_lock)
.setContentTitle("Parental Control Client is active")
.setContentText("Monitoring is visible and can be disconnected from the app")
.setContentIntent(open)
.setOngoing(true)
.build()
startForeground(7, notification)
}
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int) = START_NOT_STICKY
override fun onBind(intent: Intent?): IBinder? = null
}
// DeviceAdminReceiver.kt
package com.example.remotecontrol
import android.app.admin.DeviceAdminReceiver
class DeviceAdminReceiver : DeviceAdminReceiver()
// BootReceiver.kt — only starts after the user enabled the setting.
package com.example.remotecontrol
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import androidx.core.content.ContextCompat
class BootReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
if (intent.action == Intent.ACTION_BOOT_COMPLETED && context.getSharedPreferences("parental_control", 0).getBoolean("auto_start", false) && context.getSharedPreferences("parental_control", 0).getBoolean("consent", false)) {
ContextCompat.startForegroundService(context, Intent(context, ForegroundService::class.java))
}
}
}
// AndroidManifest.xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<application android:theme="@style/Theme.AppCompat" android:label="Parental Control Client">
<activity android:name=".MainActivity" android:exported="true">
<intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="android.intent.category.LAUNCHER" /></intent-filter>
</activity>
<service android:name=".ForegroundService" android:exported="false" android:foregroundServiceType="dataSync" />
<receiver android:name=".DeviceAdminReceiver" android:permission="android.permission.BIND_DEVICE_ADMIN" android:exported="true" />
<receiver android:name=".BootReceiver" android:enabled="true" android:exported="false">
<intent-filter><action android:name="android.intent.action.BOOT_COMPLETED" /></intent-filter>
</receiver>
</application>
</manifest>