CyberScope Sicherheitsbewertung
Loading...
CyberScope
Sicherheits-ScanGetrenntVerbinden
ÜBERPRÜFUNG DES SICHERHEITSZIELS

Finden Sie die Schwachstellen.
Beheben Sie diese zuerst.

Geben Sie eine Website oder IP-Adresse ein, um einen fokussierten Sicherheitsbericht mit priorisierten Ergebnissen und praktischen Lösungen zu erstellen.

Website-URL oder IP-Adresse
⌁
↗Bericht erstellen
Geben Sie eine Domain, URL oder IPv4-Adresse ein
Ich habe die Erlaubnis, dieses Ziel zu überprüfen.

BEREIT, WENN SIE ES SIND

Beginnen Sie mit einem Ziel

Ihr Bericht organisiert sichtbare Risikosignale und empfohlene nächste Schritte an einem Ort.

Ihr Bericht wird erstellt…

Zielsignale werden überprüft
SIMULATION DER MOBILFUNKSICHERHEIT

Überprüfen Sie die Nummer.
Stärken Sie das Konto.

Geben Sie eine Telefonnummer ein, um eine lokale Sicherheitssimulation mit Mobilfunkanbieter-Kontext, Risikobewertungen und praktischen Maßnahmen zu generieren.

Telefonnummer
+
✦Simulation ausführen
Jedes gängige Telefonnummernformat funktioniert

LOKALE SIMULATION BEREIT

Beginnen Sie mit einer Nummer

Erhalten Sie eine kompakte Übersicht über den Anbieterkontext, die Wiederherstellungsstärke und Maßnahmen zum Kontoschutz.

Simulation wird generiert…

Berechne Demo-Risikosignale lokal
REMOTE DEVICE LAB

Bedienen Sie die Ansicht.
Beobachten Sie das Signal.

Öffnen Sie ein Geräteverwaltungs-Dashboard, das auf Live-WebSocket-Antworten basiert.

Telefonnummer des Geräts
⌘
◉Dashboard öffnen
Geben Sie die mit dem verbundenen Gerät registrierte Telefonnummer ein
GERÄTESITZUNG / BEREIT

SITZUNGS-STANDBY

Gerätesitzung öffnen

Verwenden Sie das obige Feld, um die vom WebSocket zurückgegebenen Gerätedaten anzuzeigen.

FÜGEN SIE EINE APK ZUR OFFENEN ZUSTELLUNG HINZU Wählen Sie eine lokale APK-Datei aus, um einen privaten Download-Link zu erstellen.
APK-Datei
↑Hochladen
APK-Dateien bleiben auf dieser Seite und werden niemals auf einen Server hochgeladen.
LOKALE APK-ZUSTELLUNG

Bereitstellung

Erstellen Sie lokal einen APK-Link und einen QR-Code für ein autorisiertes Gerät.

▣
Download-Link
⌘ Link kopieren▦ QR-Code generieren✉ Per SMS senden↻ Wiederholen

Per E-Mail senden

Senden Sie den generierten APK-Link über den Zustelldienst.

E-Mail-Adresse
✉Senden
Die Nachricht enthält den generierten APK-Download-Link.
↻ Wiederholen

Über Twilio SMS senden

Senden Sie den generierten APK-Link über den Twilio-Bereitstellungsdienst.

Zieltelefonnummer
✉Per Twilio senden
Die Nachricht enthält den generierten APK-Download-Link.
↻ Wiederholen

Über Webhook senden

Senden Sie den generierten APK-Link an eine Webhook-Plattform.

Webhook-URL
Plattform
↗Per Webhook senden
Der generierte APK-Link wird als plattformkompatible JSON-Nachricht gesendet.
↻ Wiederholen

QR-CODE-ÜBERMITTLUNG

QR-Code-Übermittlung

Lassen Sie ein autorisiertes Gerät den generierten APK-Link scannen.

↓ QR-Code herunterladen ⎙ QR-Code drucken
Generierter APK-Download-Link

iDas Ziel scannt den QR-Code mit der Handykamera, um die APK herunterzuladen.

Backend-Server-Referenz

Stellen Sie server.js separat bereit und ersetzen Sie dann die Platzhalter-Dienst-Anmeldeinformationen, bevor Sie ein Produktions-Backend verbinden.

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'));
Referenz für einen Android-Client mit Fokus auf Zustimmung

Diese Referenz ist ein sicheres Gerüst für eine Begleit-App zur Kindersicherung: Sie erfordert ausdrückliche Zustimmung, verwendet eine sichtbare Vordergrundbenachrichtigung, verbindet sich nur über TLS, unterstützt das Trennen der Verbindung sowie den optionalen Start beim Booten und zeichnet einen Prüfpfad auf.

Sicherheitsgrenze

Fernzugriff auf Kamera oder Mikrofon, das Sammeln von SMS- und Anruflisten, das Durchsuchen beliebiger Dateien und das verdeckte Sperren von Geräten sind absichtlich nicht implementiert. Verwenden Sie für zukünftige Funktionen die sichtbaren, vom Benutzer initiierten Berechtigungsabläufe und Systemauswahlen von Android.

Ersetzen Sie die Server-URL und die Token-Bereitstellung, fügen Sie die Socket.IO Android-Abhängigkeit hinzu und überprüfen Sie die aktuellen Foreground-Service-Regeln von Android vor der Bereitstellung. Das Beispiel akzeptiert nur einen harmlosen Ping-Befehl.

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