Valutazione di sicurezza CyberScope
Loading...
CyberScope
Scansione di sicurezzaDisconnessoConnetti
REVISIONE OBIETTIVO DI SICUREZZA

Trova i punti deboli.
Risolvili per primi.

Inserisci un sito web o un IP per creare un report di sicurezza mirato con risultati prioritari e soluzioni pratiche.

URL del sito web o indirizzo IP
⌁
↗Crea report
Inserisci un dominio, un URL o un indirizzo IPv4
Ho il permesso di esaminare questo target.

PRONTO QUANDO LO SEI TU

Inizia con un target

Il tuo report organizzerà i segnali di rischio visibili e i passaggi successivi consigliati in un unico posto.

Creazione del report in corso...

Revisione dei segnali dell'obiettivo
SIMULAZIONE SICUREZZA MOBILE

Esamina il numero.
Rafforza l'account.

Inserisci un numero di telefono per generare una simulazione di sicurezza locale con contesto dell'operatore, punteggi di rischio e azioni pratiche.

Numero di telefono
+
✦Esegui simulazione
Qualsiasi formato comune di numero di telefono funziona

SIMULAZIONE LOCALE PRONTA

Inizia con un numero

Ottieni una panoramica compatta del contesto dell'operatore, della forza di recupero e delle azioni di protezione dell'account.

Generazione simulazione in corso…

Calcolo dei segnali di rischio demo in locale
LABORATORIO DISPOSITIVO REMOTO

Gestisci la vista.
Osserva il segnale.

Apri una dashboard di gestione dispositivi basata su risposte WebSocket in tempo reale.

Numero di telefono del dispositivo
⌘
◉Apri dashboard
Inserisci il numero di telefono registrato con il dispositivo connesso
SESSIONE DISPOSITIVO / PRONTA

SESSIONE IN STANDBY

Apri una sessione dispositivo

Usa il campo qui sopra per visualizzare i dati del dispositivo restituiti dal WebSocket.

AGGIUNGI UN APK ALLA CONSEGNA APERTA Scegli un file APK locale per creare un link di download privato.
File APK
↑Carica
I file APK rimangono in questa pagina e non vengono mai caricati su un server.
CONSEGNA APK LOCALE

Consegna

Prepara un link APK e un codice QR localmente per un dispositivo autorizzato.

▣
Link di download
⌘ Copia link▦ Genera codice QR✉ Invia via SMS↻ Riprova

Invia via email

Invia il link dell'APK generato tramite il servizio di consegna.

Indirizzo email
✉Invia
Il messaggio include il link per il download dell'APK generato.
↻ Riprova

Invia tramite SMS Twilio

Invia il link APK generato tramite il servizio di consegna Twilio.

Numero di telefono di destinazione
✉Invia via Twilio
Il messaggio include il link per il download dell'APK generato.
↻ Riprova

Invia tramite Webhook

Invia il link dell'APK generato a una piattaforma webhook.

URL Webhook
Piattaforma
↗Invia via Webhook
Il link APK generato viene inviato come messaggio JSON compatibile con la piattaforma.
↻ Riprova

CONSEGNA CODICE QR

Consegna tramite codice QR

Fai scansionare il link dell'APK generato a un dispositivo autorizzato.

↓ Scarica codice QR ⎙ Stampa codice QR
Link di download dell'APK generato

iIl destinatario scansiona il codice QR con la fotocamera del telefono per scaricare l'APK.

Riferimento server di backend

Distribuisci server.js separatamente, quindi sostituisci le credenziali del servizio segnaposto prima di connettere un backend di produzione.

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'));
Riferimento client Android basato sul consenso

Questo riferimento è una struttura di supporto per il controllo parentale sicuro: richiede il consenso esplicito, utilizza una notifica in primo piano visibile, si connette solo tramite TLS, supporta la disconnessione e l'avvio all'avvio su richiesta, e registra una traccia di controllo.

Confine di sicurezza

Lo streaming remoto di fotocamera o microfono, la raccolta di SMS e registri chiamate, la navigazione arbitraria dei file e il blocco segreto del dispositivo non sono intenzionalmente implementati. Utilizza i flussi di autorizzazione visibili e avviati dall'utente di Android e i selettori di sistema per qualsiasi funzionalità futura.

Sostituisci l'URL del server e il provisioning del token, aggiungi la dipendenza Android di Socket.IO e rivedi le attuali regole del servizio in primo piano di Android prima della distribuzione. L'esempio accetta solo un comando ping innocuo.

// 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>