Évaluation de sécurité CyberScope
Loading...
CyberScope
Analyse de sécuritéDéconnectéConnecter
EXAMEN DE LA CIBLE DE SÉCURITÉ

Trouvez les points faibles.
Corrigez-les en priorité.

Entrez un site web ou une adresse IP pour créer un rapport de sécurité ciblé avec des conclusions hiérarchisées et des correctifs pratiques.

URL du site web ou adresse IP
⌁
↗Créer un rapport
Entrez un domaine, une URL ou une adresse IPv4
J'ai la permission d'examiner cette cible.

PRÊT QUAND VOUS L'ÊTES

Commencez avec une cible

Votre rapport organisera les signaux de risque visibles et les prochaines étapes recommandées en un seul endroit.

Génération de votre rapport…

Examen des signaux cibles
SIMULATION DE SÉCURITÉ MOBILE

Vérifiez le numéro.
Renforcez le compte.

Entrez un numéro de téléphone pour générer une simulation de sécurité locale avec le contexte de l'opérateur, les scores de risque et les actions pratiques.

Numéro de téléphone
+
✦Exécuter la simulation
Tout format de numéro de téléphone courant fonctionne

SIMULATION LOCALE PRÊTE

Commencez avec un numéro

Obtenez une vue compacte du contexte de l'opérateur, de la force de récupération et des actions de protection du compte.

Génération de la simulation…

Calcul des signaux de risque de démonstration localement
LABORATOIRE D'APPAREILS DISTANTS

Utilisez la vue.
Observez le signal.

Ouvrez un tableau de bord de gestion d'appareils alimenté par des réponses WebSocket en direct.

Numéro de téléphone de l'appareil
⌘
◉Ouvrir le tableau de bord
Entrez le numéro de téléphone enregistré avec l'appareil connecté
SESSION APPAREIL / PRÊT

SESSION EN VEILLE

Ouvrir une session d'appareil

Utilisez le champ ci-dessus pour afficher les données de l'appareil renvoyées par le WebSocket.

AJOUTER UN APK À OPEN DELIVERY Choisissez un fichier APK local pour créer un lien de téléchargement privé.
Fichier APK
↑Télécharger
Les fichiers APK restent sur cette page et ne sont jamais téléchargés sur un serveur.
LIVRAISON D'APK LOCAL

Livraison

Préparez un lien APK et un code QR localement pour un appareil autorisé.

▣
Lien de téléchargement
⌘ Copier le lien▦ Générer un code QR✉ Envoyer par SMS↻ Réessayer

Envoyer par e-mail

Envoyez le lien de l'APK généré via le service de livraison.

Adresse e-mail
✉Envoyer
Le message inclut le lien de téléchargement de l'APK généré.
↻ Réessayer

Envoyer via SMS Twilio

Envoyez le lien APK généré via le service de livraison Twilio.

Numéro de téléphone cible
✉Envoyer via Twilio
Le message inclut le lien de téléchargement de l'APK généré.
↻ Réessayer

Envoyer via Webhook

Envoyez le lien APK généré vers une plateforme de webhook.

URL du webhook
Plateforme
↗Envoyer via Webhook
Le lien APK généré est envoyé sous forme de message JSON compatible avec la plateforme.
↻ Réessayer

LIVRAISON PAR CODE QR

Livraison par code QR

Laissez un appareil autorisé scanner le lien APK généré.

↓ Télécharger le code QR ⎙ Imprimer le code QR
Lien de téléchargement de l'APK généré

iLa cible scanne le code QR avec l'appareil photo de son téléphone pour télécharger l'APK.

Référence du serveur backend

Déployez server.js séparément, puis remplacez les identifiants de service fictifs avant de connecter un backend de production.

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'));
Référence client Android axée sur le consentement

Cette référence est un échafaudage compagnon de contrôle parental sécurisé : elle nécessite un consentement explicite, utilise une notification visible au premier plan, se connecte uniquement via TLS, prend en charge la déconnexion et le démarrage automatique sur demande, et enregistre une piste d'audit.

Limite de sécurité

La diffusion à distance de la caméra ou du microphone, la collecte des SMS et des journaux d'appels, la navigation arbitraire dans les fichiers et le verrouillage secret des appareils ne sont intentionnellement pas implémentés. Utilisez les flux d'autorisation visibles et initiés par l'utilisateur d'Android ainsi que les sélecteurs système pour toute fonctionnalité future.

Remplacez l'URL du serveur et le provisionnement du jeton, ajoutez la dépendance Android Socket.IO et examinez les règles actuelles de service de premier plan d'Android avant le déploiement. L'exemple n'accepte qu'une commande ping inoffensive.

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