Semi-auto, bad sizes and need adjustments

Demo call page avec les features de base:
- Haut parleur
- Couper/activer micro
- keypad
- raccrocher
- Display Icing state (toucher pour switch l'état)

S'active en faisant un appui long sur le bouton d'appel depuis les détails du contact.
Compatible avec l'obfuscation des contacts.

Co-authored-by: AlexisDanlos <91090088+AlexisDanlos@users.noreply.github.com>
Reviewed-on: #37
Co-authored-by: alexis <alexis.danlos@epitech.eu>
Co-committed-by: alexis <alexis.danlos@epitech.eu>

.gitea/workflows/apk.yaml

@@ -10,8 +10,22 @@ jobs:
       - uses: actions/checkout@v1
         with:
           subpath: dialer/
-      - uses: icing/flutter@main
+      - uses: docker://git.gmoker.com/icing/flutter:main
       - uses: actions/upload-artifact@v1
         with:
           name: icing-dialer-${{ gitea.ref_name }}-${{ gitea.run_id }}.apk
           path: build/app/outputs/flutter-apk/app-release.apk
+
+  build-stealth:
+    runs-on: debian
+    steps:
+      - uses: actions/checkout@v1
+        with:
+          subpath: dialer/
+      - uses: docker://git.gmoker.com/icing/flutter:main
+        with:
+          args: "build apk --dart-define=STEALTH=true"
+      - uses: actions/upload-artifact@v1
+        with:
+          name: icing-dialer-stealth-${{ gitea.ref_name }}-${{ gitea.run_id }}.apk
+          path: build/app/outputs/flutter-apk/app-release.apk

dialer/android/.gitignore

@@ -7,6 +7,7 @@ gradle-wrapper.jar
 /gradle.properties
 GeneratedPluginRegistrant.java
 gradle.properties
+.cxx
 
 # Remember to never publicly share your keystore.
 # See https://flutter.dev/to/reference-keystore

dialer/android/app/src/main/AndroidManifest.xml

@@ -1,13 +1,17 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.icing.dialer">
-    <uses-permission android:name="android.permission.READ_CONTACTS"/>
-    <uses-permission android:name="android.permission.WRITE_CONTACTS"/>
+    <uses-feature android:name="android.hardware.telephony" android:required="true" />
+
+    <uses-permission android:name="android.permission.READ_CONTACTS" />
+    <uses-permission android:name="android.permission.WRITE_CONTACTS" />
     <uses-permission android:name="android.permission.CALL_PHONE" />
     <uses-permission android:name="android.permission.SEND_SMS" />
     <uses-permission android:name="android.permission.READ_BLOCKED_NUMBERS" />
     <uses-permission android:name="android.permission.WRITE_BLOCKED_NUMBERS" />
-    <uses-permission android:name="android.permission.READ_CALL_LOG"/>
-    <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
-
+    <uses-permission android:name="android.permission.READ_CALL_LOG" />
+    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+    <uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
+    <uses-permission android:name="android.permission.ANSWER_PHONE_CALLS" />
+    <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS" />
 
     <application
         android:label="Icing Dialer"
@@ -23,34 +27,65 @@
             android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
             android:hardwareAccelerated="true"
             android:windowSoftInputMode="adjustResize">
-            <!-- Specifies an Android theme to apply to this Activity as soon as
-                 the Android process has started. This theme is visible to the user
-                 while the Flutter UI initializes. After that, this theme continues
-                 to determine the Window background behind the Flutter UI. -->
             <meta-data
-              android:name="io.flutter.embedding.android.NormalTheme"
-              android:resource="@style/NormalTheme"
-              />
+                android:name="io.flutter.embedding.android.NormalTheme"
+                android:resource="@style/NormalTheme" />
             <intent-filter>
-                <action android:name="android.intent.action.MAIN"/>
-                <category android:name="android.intent.category.LAUNCHER"/>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+            <!-- Dialer intent filters (required for default dialer eligibility) -->
+            <intent-filter>
+                <action android:name="android.intent.action.DIAL" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.DIAL" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:scheme="tel" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.CALL" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="tel" />
             </intent-filter>
         </activity>
+        <service
+            android:name=".services.MyInCallService"
+            android:permission="android.permission.BIND_INCALL_SERVICE"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.telecom.InCallService" />
+            </intent-filter>
+            <meta-data
+                android:name="android.telecom.IN_CALL_SERVICE_UI"
+                android:value="true" />
+        </service>
+        <!-- Custom ConnextionService, will be needed at some point when we implement our own protocol -->
+        <!-- <service
+            android:name=".services.CallConnectionService"
+            android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.telecom.ConnectionService" />
+            </intent-filter>
+        </service> -->
+
         <!-- Don't delete the meta-data below.
              This is used by the Flutter tool to generate GeneratedPluginRegistrant.java -->
         <meta-data
             android:name="flutterEmbedding"
             android:value="2" />
     </application>
-    <!-- Required to query activities that can process text, see:
-         https://developer.android.com/training/package-visibility and
-         https://developer.android.com/reference/android/content/Intent#ACTION_PROCESS_TEXT.
-
-         In particular, this is used by the Flutter engine in io.flutter.plugin.text.ProcessTextPlugin. -->
     <queries>
         <intent>
-            <action android:name="android.intent.action.PROCESS_TEXT"/>
-            <data android:mimeType="text/plain"/>
+            <action android:name="android.intent.action.PROCESS_TEXT" />
+            <data android:mimeType="text/plain" />
         </intent>
     </queries>
-</manifest>
+</manifest>

dialer/android/app/src/main/kotlin/com/icing/dialer/activities/MainActivity.kt

@@ -1,54 +1,91 @@
 package com.icing.dialer.activities
 
+import android.Manifest
+import android.app.role.RoleManager
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
 import android.database.Cursor
+import android.net.Uri
+import android.os.Build
 import android.os.Bundle
 import android.provider.CallLog
-import io.flutter.embedding.android.FlutterActivity
-import io.flutter.embedding.engine.FlutterEngine
-import io.flutter.plugin.common.MethodCall
-import io.flutter.plugin.common.MethodChannel
+import android.telecom.TelecomManager
+import android.util.Log
+import androidx.core.content.ContextCompat
 import com.icing.dialer.KeystoreHelper
 import com.icing.dialer.services.CallService
+import com.icing.dialer.services.MyInCallService
+import io.flutter.embedding.android.FlutterActivity
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.plugin.common.MethodChannel
 
-class MainActivity: FlutterActivity() {
-    // Existing channel for keystore operations.
+class MainActivity : FlutterActivity() {
     private val KEYSTORE_CHANNEL = "com.example.keystore"
-    // New channel for call log access.
     private val CALLLOG_CHANNEL = "com.example.calllog"
-    
     private val CALL_CHANNEL = "call_service"
+    private val TAG = "MainActivity"
+    private val REQUEST_CODE_SET_DEFAULT_DIALER = 1001
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        Log.d(TAG, "onCreate started")
+        Log.d(TAG, "Waiting for Flutter to signal permissions")
+    }
 
     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
         super.configureFlutterEngine(flutterEngine)
+        Log.d(TAG, "Configuring Flutter engine")
 
-        // Call service channel
-        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL).setMethodCallHandler { call, result ->
-            when (call.method) {
-                "makeGsmCall" -> {
-                    val phoneNumber = call.argument<String>("phoneNumber")
-                    if (phoneNumber != null) {
-                        CallService.makeGsmCall(this, phoneNumber)
-                        result.success("Calling $phoneNumber")
-                    } else {
-                        result.error("INVALID_PHONE_NUMBER", "Phone number is required", null)
-                    }
-                }
-                "hangUpCall" -> {
-                    CallService.hangUpCall(this)
-                    result.success("Call ended")
-                }
-                else -> result.notImplemented()
-            }
-        }
-
-        // Set up the keystore channel.
-        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, KEYSTORE_CHANNEL)
+        MyInCallService.channel = MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL)
+        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL)
             .setMethodCallHandler { call, result ->
-                // Delegate method calls to KeystoreHelper.
-                KeystoreHelper(call, result).handleMethodCall()
+                when (call.method) {
+                    "permissionsGranted" -> {
+                        Log.d(TAG, "Received permissionsGranted from Flutter")
+                        checkAndRequestDefaultDialer()
+                        result.success(true)
+                    }
+                    "makeGsmCall" -> {
+                        val phoneNumber = call.argument<String>("phoneNumber")
+                        if (phoneNumber != null) {
+                            val success = CallService.makeGsmCall(this, phoneNumber)
+                            if (success) {
+                                result.success(mapOf("status" to "calling", "phoneNumber" to phoneNumber))
+                            } else {
+                                result.error("CALL_FAILED", "Failed to initiate call", null)
+                            }
+                        } else {
+                            result.error("INVALID_PHONE_NUMBER", "Phone number is required", null)
+                        }
+                    }
+                    "hangUpCall" -> {
+                        val success = CallService.hangUpCall(this)
+                        if (success) {
+                            result.success(mapOf("status" to "ended"))
+                        } else {
+                            result.error("HANGUP_FAILED", "Failed to end call", null)
+                        }
+                    }
+                    "answerCall" -> {
+                        val success = MyInCallService.currentCall?.let {
+                            it.answer(0) // 0 for default video state (audio-only)
+                            Log.d(TAG, "Answered call")
+                            true
+                        } ?: false
+                        if (success) {
+                            result.success(mapOf("status" to "answered"))
+                        } else {
+                            result.error("ANSWER_FAILED", "No active call to answer", null)
+                        }
+                    }
+                    else -> result.notImplemented()
+                }
             }
 
-        // Set up the call log channel.
+        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, KEYSTORE_CHANNEL)
+            .setMethodCallHandler { call, result -> KeystoreHelper(call, result).handleMethodCall() }
+
         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALLLOG_CHANNEL)
             .setMethodCallHandler { call, result ->
                 if (call.method == "getCallLogs") {
@@ -60,35 +97,78 @@ class MainActivity: FlutterActivity() {
             }
     }
 
-    /**
-     * Queries the Android call log and returns a list of maps.
-     * Each map contains keys: "number", "type", "date", and "duration".
-     */
+    private fun checkAndRequestDefaultDialer() {
+        val telecomManager = getSystemService(TELECOM_SERVICE) as TelecomManager
+        val currentDefault = telecomManager.defaultDialerPackage
+        Log.d(TAG, "Current default dialer: $currentDefault, My package: $packageName")
+
+        if (currentDefault != packageName) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                val roleManager = getSystemService(Context.ROLE_SERVICE) as RoleManager
+                if (roleManager.isRoleAvailable(RoleManager.ROLE_DIALER) && !roleManager.isRoleHeld(RoleManager.ROLE_DIALER)) {
+                    val intent = roleManager.createRequestRoleIntent(RoleManager.ROLE_DIALER)
+                    startActivityForResult(intent, REQUEST_CODE_SET_DEFAULT_DIALER)
+                    Log.d(TAG, "Launched RoleManager intent for default dialer on API 29+")
+                } else {
+                    Log.d(TAG, "RoleManager: Available=${roleManager.isRoleAvailable(RoleManager.ROLE_DIALER)}, Held=${roleManager.isRoleHeld(RoleManager.ROLE_DIALER)}")
+                }
+            } else {
+                val intent = Intent(TelecomManager.ACTION_CHANGE_DEFAULT_DIALER)
+                    .putExtra(TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME, packageName)
+                    .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                try {
+                    startActivityForResult(intent, REQUEST_CODE_SET_DEFAULT_DIALER)
+                    Log.d(TAG, "Launched TelecomManager intent for default dialer")
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to launch default dialer prompt: ${e.message}", e)
+                    launchDefaultAppsSettings()
+                }
+            }
+        } else {
+            Log.d(TAG, "Already the default dialer")
+        }
+    }
+
+    private fun launchDefaultAppsSettings() {
+        val settingsIntent = Intent(android.provider.Settings.ACTION_MANAGE_DEFAULT_APPS_SETTINGS)
+        startActivity(settingsIntent)
+        Log.d(TAG, "Opened default apps settings as fallback")
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        Log.d(TAG, "onActivityResult: requestCode=$requestCode, resultCode=$resultCode, data=$data")
+        if (requestCode == REQUEST_CODE_SET_DEFAULT_DIALER) {
+            if (resultCode == RESULT_OK) {
+                Log.d(TAG, "User accepted default dialer change")
+            } else {
+                Log.w(TAG, "Default dialer prompt canceled or failed (resultCode=$resultCode)")
+                launchDefaultAppsSettings()
+            }
+        }
+    }
+
     private fun getCallLogs(): List<Map<String, Any?>> {
         val logsList = mutableListOf<Map<String, Any?>>()
         val cursor: Cursor? = contentResolver.query(
-            CallLog.Calls.CONTENT_URI,
-            null,
-            null,
-            null,
-            CallLog.Calls.DATE + " DESC"
+            CallLog.Calls.CONTENT_URI, null, null, null, CallLog.Calls.DATE + " DESC"
         )
-        if (cursor != null) {
-            while (cursor.moveToNext()) {
-                val number = cursor.getString(cursor.getColumnIndexOrThrow(CallLog.Calls.NUMBER))
-                val type = cursor.getInt(cursor.getColumnIndexOrThrow(CallLog.Calls.TYPE))
-                val date = cursor.getLong(cursor.getColumnIndexOrThrow(CallLog.Calls.DATE))
-                val duration = cursor.getLong(cursor.getColumnIndexOrThrow(CallLog.Calls.DURATION))
+        cursor?.use {
+            while (it.moveToNext()) {
+                val number = it.getString(it.getColumnIndexOrThrow(CallLog.Calls.NUMBER))
+                val type = it.getInt(it.getColumnIndexOrThrow(CallLog.Calls.TYPE))
+                val date = it.getLong(it.getColumnIndexOrThrow(CallLog.Calls.DATE))
+                val duration = it.getLong(it.getColumnIndexOrThrow(CallLog.Calls.DURATION))
 
-                val map = HashMap<String, Any?>()
-                map["number"] = number
-                map["type"] = type  // Typically: 1 for incoming, 2 for outgoing, 3 for missed.
-                map["date"] = date
-                map["duration"] = duration
+                val map = mutableMapOf<String, Any?>(
+                    "number" to number,
+                    "type" to type,
+                    "date" to date,
+                    "duration" to duration
+                )
                 logsList.add(map)
             }
-            cursor.close()
         }
         return logsList
     }
-}
+}

dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallConnectionService.kt

@@ -0,0 +1,82 @@
+// package com.icing.dialer.services
+
+// import android.telecom.Connection
+// import android.telecom.ConnectionService
+// import android.telecom.PhoneAccountHandle
+// import android.telecom.TelecomManager
+// import android.telecom.DisconnectCause
+// import android.util.Log
+// import io.flutter.plugin.common.MethodChannel
+
+// class CallConnectionService : ConnectionService() {
+//     companion object {
+//         var channel: MethodChannel? = null
+//         private const val TAG = "CallConnectionService"
+//     }
+
+//     init {
+//         Log.d(TAG, "CallConnectionService initialized")
+//     }
+
+//     override fun onCreate() {
+//         super.onCreate()
+//         Log.d(TAG, "Service created")
+//     }
+
+//     override fun onDestroy() {
+//         super.onDestroy()
+//         Log.d(TAG, "Service destroyed")
+//     }
+
+//     override fun onCreateOutgoingConnection(
+//         connectionManagerPhoneAccount: PhoneAccountHandle?,
+//         request: android.telecom.ConnectionRequest
+//     ): Connection {
+//         Log.d(TAG, "Creating outgoing connection for ${request.address}, account: $connectionManagerPhoneAccount")
+//         val connection = object : Connection() {
+//             override fun onStateChanged(state: Int) {
+//                 super.onStateChanged(state)
+//                 Log.d(TAG, "Connection state changed: $state")
+//                 val stateStr = when (state) {
+//                     STATE_DIALING -> "dialing"
+//                     STATE_ACTIVE -> "active"
+//                     STATE_DISCONNECTED -> "disconnected"
+//                     else -> "unknown"
+//                 }
+//                 channel?.invokeMethod("callStateChanged", mapOf("state" to stateStr, "phoneNumber" to request.address.toString()))
+//             }
+
+//             override fun onDisconnect() {
+//                 Log.d(TAG, "Connection disconnected")
+//                 setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+//                 destroy()
+//             }
+//         }
+//         connection.setAddress(request.address, TelecomManager.PRESENTATION_ALLOWED)
+//         connection.setInitialized()
+//         connection.setDialing()
+//         return connection
+//     }
+
+//     override fun onCreateIncomingConnection(
+//         connectionManagerPhoneAccount: PhoneAccountHandle?,
+//         request: android.telecom.ConnectionRequest
+//     ): Connection {
+//         Log.d(TAG, "Creating incoming connection for ${request.address}, account: $connectionManagerPhoneAccount")
+//         val connection = object : Connection() {
+//             override fun onAnswer() {
+//                 Log.d(TAG, "Connection answered")
+//                 setActive()
+//             }
+
+//             override fun onDisconnect() {
+//                 Log.d(TAG, "Connection disconnected")
+//                 setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+//                 destroy()
+//             }
+//         }
+//         connection.setAddress(request.address, TelecomManager.PRESENTATION_ALLOWED)
+//         connection.setRinging()
+//         return connection
+//     }
+// }

dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallService.kt

@@ -1,30 +1,55 @@
 package com.icing.dialer.services
 
 import android.content.Context
-import android.content.Intent
 import android.net.Uri
-import android.telecom.TelecomManager
 import android.os.Build
+import android.os.Bundle
+import android.telecom.TelecomManager
 import android.util.Log
+import androidx.core.content.ContextCompat
+import android.content.pm.PackageManager
+import android.Manifest
 
 object CallService {
-    
-    fun makeGsmCall(context: Context, phoneNumber: String) {
-        try {
-            val intent = Intent(Intent.ACTION_CALL)
-            intent.data = Uri.parse("tel:$phoneNumber")
-            context.startActivity(intent)
+    private val TAG = "CallService"
+
+    fun makeGsmCall(context: Context, phoneNumber: String): Boolean {
+        return try {
+            val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+            val uri = Uri.parse("tel:$phoneNumber")
+
+            if (ContextCompat.checkSelfPermission(context, Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED) {
+                telecomManager.placeCall(uri, Bundle())
+                Log.d(TAG, "Initiated call to $phoneNumber")
+                true
+            } else {
+                Log.e(TAG, "CALL_PHONE permission not granted")
+                false
+            }
         } catch (e: Exception) {
-            Log.e("CallService", "Error making GSM call: ${e.message}")
+            Log.e(TAG, "Error making GSM call: ${e.message}", e)
+            false
         }
     }
 
-    fun hangUpCall(context: Context) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-            val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-            telecomManager.endCall()
-        } else {
-            Log.e("CallService", "Hangup call is only supported on Android P or later.")
+    fun hangUpCall(context: Context): Boolean {
+        return try {
+            if (MyInCallService.currentCall != null) {
+                MyInCallService.currentCall?.disconnect()
+                Log.d(TAG, "Disconnected active call via MyInCallService")
+                true
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+                telecomManager.endCall()
+                Log.d(TAG, "Ended call via TelecomManager (no active call in MyInCallService)")
+                true
+            } else {
+                Log.e(TAG, "No active call and hangup not supported below Android P")
+                false
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error hanging up call: ${e.message}", e)
+            false
         }
     }
 }

dialer/android/app/src/main/kotlin/com/icing/dialer/services/MyInCallService.kt

@@ -0,0 +1,69 @@
+package com.icing.dialer.services
+
+import android.telecom.Call
+import android.telecom.InCallService
+import android.util.Log
+import io.flutter.plugin.common.MethodChannel
+
+class MyInCallService : InCallService() {
+    companion object {
+        var channel: MethodChannel? = null
+        var currentCall: Call? = null
+        private const val TAG = "MyInCallService"
+    }
+
+    private val callCallback = object : Call.Callback() {
+        override fun onStateChanged(call: Call, state: Int) {
+            super.onStateChanged(call, state)
+            val stateStr = when (state) {
+                Call.STATE_DIALING -> "dialing"
+                Call.STATE_ACTIVE -> "active"
+                Call.STATE_DISCONNECTED -> "disconnected"
+                Call.STATE_DISCONNECTING -> "disconnecting"
+                Call.STATE_RINGING -> "ringing"
+                else -> "unknown"
+            }
+            Log.d(TAG, "State changed: $stateStr for call ${call.details.handle}")
+            channel?.invokeMethod("callStateChanged", mapOf(
+                "callId" to call.details.handle.toString(),
+                "state" to stateStr
+            ))
+            if (state == Call.STATE_DISCONNECTED || state == Call.STATE_DISCONNECTING) {
+                Log.d(TAG, "Call ended: ${call.details.handle}")
+                channel?.invokeMethod("callEnded", mapOf("callId" to call.details.handle.toString()))
+                currentCall = null
+            }
+        }
+    }
+
+    override fun onCallAdded(call: Call) {
+        super.onCallAdded(call)
+        currentCall = call
+        val stateStr = when (call.state) {
+            Call.STATE_DIALING -> "dialing"
+            Call.STATE_ACTIVE -> "active"
+            Call.STATE_RINGING -> "ringing"
+            else -> "dialing" // Default for outgoing
+        }
+        Log.d(TAG, "Call added: ${call.details.handle}, state: $stateStr")
+        channel?.invokeMethod("callAdded", mapOf(
+            "callId" to call.details.handle.toString(),
+            "state" to stateStr
+        ))
+        call.registerCallback(callCallback)
+    }
+
+    override fun onCallRemoved(call: Call) {
+        super.onCallRemoved(call)
+        Log.d(TAG, "Call removed: ${call.details.handle}")
+        call.unregisterCallback(callCallback)
+        channel?.invokeMethod("callRemoved", mapOf("callId" to call.details.handle.toString()))
+        currentCall = null
+    }
+
+    override fun onCallAudioStateChanged(state: android.telecom.CallAudioState) {
+        super.onCallAudioStateChanged(state)
+        Log.d(TAG, "Audio state changed: route=${state.route}")
+        channel?.invokeMethod("audioStateChanged", mapOf("route" to state.route))
+    }
+}

dialer/build.sh

@@ -2,4 +2,9 @@
 
 IMG=git.gmoker.com/icing/flutter:main
 
-docker run --rm -v "$PWD:/app/" "$IMG" build apk
+if [ "$1" == '-s' ]; then
+    OPT+=(--dart-define=STEALTH=true)
+fi
+
+set -x
+docker run --rm -v "$PWD:/app/" "$IMG" build apk "${OPT[@]}"

dialer/lib/features/call/call_page.dart

@@ -0,0 +1,324 @@
+import 'dart:typed_data';
+import 'package:flutter/material.dart';
+import 'package:dialer/services/call_service.dart';
+import 'package:dialer/services/obfuscate_service.dart';
+import 'package:dialer/widgets/username_color_generator.dart';
+
+class CallPage extends StatefulWidget {
+  final String displayName;
+  final String phoneNumber;
+  final Uint8List? thumbnail;
+
+  const CallPage({
+    super.key,
+    required this.displayName,
+    required this.phoneNumber,
+    this.thumbnail,
+  });
+
+  @override
+  _CallPageState createState() => _CallPageState();
+}
+
+class _CallPageState extends State<CallPage> {
+  final ObfuscateService _obfuscateService = ObfuscateService();
+  final CallService _callService = CallService();
+  bool isMuted = false;
+  bool isSpeakerOn = false;
+  bool isKeypadVisible = false;
+  bool icingProtocolOk = true;
+  String _typedDigits = "";
+
+  void _addDigit(String digit) {
+    setState(() {
+      _typedDigits += digit;
+    });
+  }
+
+  void _toggleMute() {
+    setState(() {
+      isMuted = !isMuted;
+    });
+  }
+
+  void _toggleSpeaker() {
+    setState(() {
+      isSpeakerOn = !isSpeakerOn;
+    });
+  }
+
+  void _toggleKeypad() {
+    setState(() {
+      isKeypadVisible = !isKeypadVisible;
+    });
+  }
+
+  void _toggleIcingProtocol() {
+    setState(() {
+      icingProtocolOk = !icingProtocolOk;
+    });
+  }
+
+  void _hangUp() async {
+    try {
+      await _callService.hangUpCall(context);
+    } catch (e) {
+      print("Error hanging up: $e");
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final double avatarRadius = isKeypadVisible ? 45.0 : 45.0;
+    final double nameFontSize = isKeypadVisible ? 24.0 : 24.0;
+    final double statusFontSize = isKeypadVisible ? 16.0 : 16.0;
+
+    return Scaffold(
+      body: Container(
+        color: Colors.black,
+        child: SafeArea(
+          child: Column(
+            children: [
+              Container(
+                padding: const EdgeInsets.symmetric(vertical: 8.0),
+                child: Column(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    SizedBox(height: 35),
+                    ObfuscatedAvatar(
+                      imageBytes: widget.thumbnail, // Uses thumbnail if provided
+                      radius: avatarRadius,
+                      backgroundColor: generateColorFromName(widget.displayName),
+                      fallbackInitial: widget.displayName,
+                    ),
+                    const SizedBox(height: 4),
+                    Row(
+                      mainAxisAlignment: MainAxisAlignment.center,
+                      children: [
+                        Icon(
+                          icingProtocolOk ? Icons.lock : Icons.lock_open,
+                          color: icingProtocolOk ? Colors.green : Colors.red,
+                          size: 16,
+                        ),
+                        const SizedBox(width: 4),
+                        Text(
+                          'Icing protocol: ${icingProtocolOk ? "ok" : "ko"}',
+                          style: TextStyle(
+                            color: icingProtocolOk ? Colors.green : Colors.red,
+                            fontSize: 12,
+                            fontWeight: FontWeight.bold,
+                          ),
+                        ),
+                      ],
+                    ),
+                    const SizedBox(height: 4),
+                    Text(
+                      _obfuscateService.obfuscateData(widget.displayName),
+                      style: TextStyle(
+                        fontSize: nameFontSize,
+                        color: Colors.white,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    Text(
+                      widget.phoneNumber,
+                      style: TextStyle(fontSize: statusFontSize, color: Colors.white70),
+                    ),
+                    Text(
+                      'Calling...',
+                      style: TextStyle(fontSize: statusFontSize, color: Colors.white70),
+                    ),
+                  ],
+                ),
+              ),
+              Expanded(
+                child: Column(
+                  children: [
+                    if (isKeypadVisible) ...[
+                      const Spacer(flex: 2),
+                      Padding(
+                        padding: const EdgeInsets.symmetric(horizontal: 20.0),
+                        child: Row(
+                          mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                          children: [
+                            Expanded(
+                              child: Text(
+                                _typedDigits,
+                                maxLines: 1,
+                                textAlign: TextAlign.right,
+                                overflow: TextOverflow.ellipsis,
+                                style: const TextStyle(
+                                  fontSize: 24,
+                                  color: Colors.white,
+                                  fontWeight: FontWeight.bold,
+                                ),
+                              ),
+                            ),
+                            IconButton(
+                              padding: EdgeInsets.zero,
+                              onPressed: _toggleKeypad,
+                              icon: const Icon(Icons.close, color: Colors.white),
+                            ),
+                          ],
+                        ),
+                      ),
+                      Container(
+                        height: MediaQuery.of(context).size.height * 0.35,
+                        margin: const EdgeInsets.symmetric(horizontal: 20),
+                        child: GridView.count(
+                          shrinkWrap: true,
+                          physics: const NeverScrollableScrollPhysics(),
+                          crossAxisCount: 3,
+                          childAspectRatio: 1.3,
+                          mainAxisSpacing: 8,
+                          crossAxisSpacing: 8,
+                          children: List.generate(12, (index) {
+                            String label;
+                            if (index < 9) {
+                              label = '${index + 1}';
+                            } else if (index == 9) {
+                              label = '*';
+                            } else if (index == 10) {
+                              label = '0';
+                            } else {
+                              label = '#';
+                            }
+                            return GestureDetector(
+                              onTap: () => _addDigit(label),
+                              child: Container(
+                                decoration: const BoxDecoration(
+                                  shape: BoxShape.circle,
+                                  color: Colors.transparent,
+                                ),
+                                child: Center(
+                                  child: Text(
+                                    label,
+                                    style: const TextStyle(fontSize: 32, color: Colors.white),
+                                  ),
+                                ),
+                              ),
+                            );
+                          }),
+                        ),
+                      ),
+                      const Spacer(flex: 1),
+                    ] else ...[
+                      const Spacer(),
+                      Padding(
+                        padding: const EdgeInsets.symmetric(horizontal: 32.0),
+                        child: Column(
+                          mainAxisSize: MainAxisSize.min,
+                          children: [
+                            Row(
+                              mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+                              children: [
+                                Column(
+                                  mainAxisSize: MainAxisSize.min,
+                                  children: [
+                                    IconButton(
+                                      onPressed: _toggleMute,
+                                      icon: Icon(
+                                        isMuted ? Icons.mic_off : Icons.mic,
+                                        color: Colors.white,
+                                        size: 32,
+                                      ),
+                                    ),
+                                    Text(
+                                      isMuted ? 'Unmute' : 'Mute',
+                                      style: const TextStyle(color: Colors.white, fontSize: 14),
+                                    ),
+                                  ],
+                                ),
+                                Column(
+                                  mainAxisSize: MainAxisSize.min,
+                                  children: [
+                                    IconButton(
+                                      onPressed: _toggleKeypad,
+                                      icon: const Icon(Icons.dialpad, color: Colors.white, size: 32),
+                                    ),
+                                    const Text(
+                                      'Keypad',
+                                      style: TextStyle(color: Colors.white, fontSize: 14),
+                                    ),
+                                  ],
+                                ),
+                                Column(
+                                  mainAxisSize: MainAxisSize.min,
+                                  children: [
+                                    IconButton(
+                                      onPressed: _toggleSpeaker,
+                                      icon: Icon(
+                                        isSpeakerOn ? Icons.volume_up : Icons.volume_off,
+                                        color: isSpeakerOn ? Colors.amber : Colors.white,
+                                        size: 32,
+                                      ),
+                                    ),
+                                    const Text(
+                                      'Speaker',
+                                      style: TextStyle(color: Colors.white, fontSize: 14),
+                                    ),
+                                  ],
+                                ),
+                              ],
+                            ),
+                            const SizedBox(height: 20),
+                            Row(
+                              mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+                              children: [
+                                Column(
+                                  mainAxisSize: MainAxisSize.min,
+                                  children: [
+                                    IconButton(
+                                      onPressed: () {},
+                                      icon: const Icon(Icons.person_add, color: Colors.white, size: 32),
+                                    ),
+                                    const Text('Add Contact',
+                                        style: TextStyle(color: Colors.white, fontSize: 14)),
+                                  ],
+                                ),
+                                Column(
+                                  mainAxisSize: MainAxisSize.min,
+                                  children: [
+                                    IconButton(
+                                      onPressed: () {},
+                                      icon: const Icon(Icons.sim_card, color: Colors.white, size: 32),
+                                    ),
+                                    const Text('Change SIM',
+                                        style: TextStyle(color: Colors.white, fontSize: 14)),
+                                  ],
+                                ),
+                              ],
+                            ),
+                          ],
+                        ),
+                      ),
+                      const Spacer(flex: 3),
+                    ],
+                  ],
+                ),
+              ),
+              Padding(
+                padding: const EdgeInsets.only(bottom: 16.0),
+                child: GestureDetector(
+                  onTap: _hangUp,
+                  child: Container(
+                    padding: const EdgeInsets.all(12),
+                    decoration: const BoxDecoration(
+                      color: Colors.red,
+                      shape: BoxShape.circle,
+                    ),
+                    child: const Icon(
+                      Icons.call_end,
+                      color: Colors.white,
+                      size: 32,
+                    ),
+                  ),
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}

dialer/lib/features/call/incoming_call_page.dart

@@ -0,0 +1,181 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:dialer/services/call_service.dart';
+import 'package:dialer/services/obfuscate_service.dart';
+import 'package:dialer/widgets/username_color_generator.dart';
+import 'package:dialer/features/call/call_page.dart';
+
+class IncomingCallPage extends StatefulWidget {
+  final String displayName;
+  final String phoneNumber;
+  final Uint8List? thumbnail;
+
+  const IncomingCallPage({
+    super.key,
+    required this.displayName,
+    required this.phoneNumber,
+    this.thumbnail,
+  });
+
+  @override
+  _IncomingCallPageState createState() => _IncomingCallPageState();
+}
+
+class _IncomingCallPageState extends State<IncomingCallPage> {
+  static const MethodChannel _channel = MethodChannel('call_service');
+  final ObfuscateService _obfuscateService = ObfuscateService();
+  final CallService _callService = CallService();
+  bool icingProtocolOk = true;
+
+  void _toggleIcingProtocol() {
+    setState(() {
+      icingProtocolOk = !icingProtocolOk;
+    });
+  }
+
+  void _answerCall() async {
+    try {
+      final result = await _channel.invokeMethod('answerCall');
+      print('IncomingCallPage: Answer call result: $result');
+      if (result["status"] == "answered") {
+        Navigator.pushReplacement(
+          context,
+          MaterialPageRoute(
+            builder: (context) => CallPage(
+              displayName: widget.displayName,
+              phoneNumber: widget.phoneNumber,
+              thumbnail: widget.thumbnail,
+            ),
+          ),
+        );
+      }
+    } catch (e) {
+      print("IncomingCallPage: Error answering call: $e");
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text("Error answering call: $e")),
+      );
+    }
+  }
+
+  void _declineCall() async {
+    try {
+      await _callService.hangUpCall(context);
+    } catch (e) {
+      print("IncomingCallPage: Error declining call: $e");
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text("Error declining call: $e")),
+      );
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    const double avatarRadius = 45.0;
+    const double nameFontSize = 24.0;
+    const double statusFontSize = 16.0;
+
+    return Scaffold(
+      body: Container(
+        color: Colors.black,
+        child: SafeArea(
+          child: Column(
+            children: [
+              Container(
+                padding: const EdgeInsets.symmetric(vertical: 8.0),
+                child: Column(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    const SizedBox(height: 35),
+                    ObfuscatedAvatar(
+                      imageBytes: widget.thumbnail,
+                      radius: avatarRadius,
+                      backgroundColor: generateColorFromName(widget.displayName),
+                      fallbackInitial: widget.displayName,
+                    ),
+                    const SizedBox(height: 4),
+                    Row(
+                      mainAxisAlignment: MainAxisAlignment.center,
+                      children: [
+                        Icon(
+                          icingProtocolOk ? Icons.lock : Icons.lock_open,
+                          color: icingProtocolOk ? Colors.green : Colors.red,
+                          size: 16,
+                        ),
+                        const SizedBox(width: 4),
+                        Text(
+                          'Icing protocol: ${icingProtocolOk ? "ok" : "ko"}',
+                          style: TextStyle(
+                            color: icingProtocolOk ? Colors.green : Colors.red,
+                            fontSize: 12,
+                            fontWeight: FontWeight.bold,
+                          ),
+                        ),
+                      ],
+                    ),
+                    const SizedBox(height: 4),
+                    Text(
+                      _obfuscateService.obfuscateData(widget.displayName),
+                      style: const TextStyle(
+                        fontSize: nameFontSize,
+                        color: Colors.white,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    Text(
+                      widget.phoneNumber,
+                      style: const TextStyle(fontSize: statusFontSize, color: Colors.white70),
+                    ),
+                    const Text(
+                      'Incoming Call...',
+                      style: TextStyle(fontSize: statusFontSize, color: Colors.white70),
+                    ),
+                  ],
+                ),
+              ),
+              const Spacer(),
+              Padding(
+                padding: const EdgeInsets.symmetric(horizontal: 32.0, vertical: 16.0),
+                child: Row(
+                  mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+                  children: [
+                    GestureDetector(
+                      onTap: _declineCall,
+                      child: Container(
+                        padding: const EdgeInsets.all(12),
+                        decoration: const BoxDecoration(
+                          color: Colors.red,
+                          shape: BoxShape.circle,
+                        ),
+                        child: const Icon(
+                          Icons.call_end,
+                          color: Colors.white,
+                          size: 32,
+                        ),
+                      ),
+                    ),
+                    GestureDetector(
+                      onTap: _answerCall,
+                      child: Container(
+                        padding: const EdgeInsets.all(12),
+                        decoration: const BoxDecoration(
+                          color: Colors.green,
+                          shape: BoxShape.circle,
+                        ),
+                        child: const Icon(
+                          Icons.call,
+                          color: Colors.white,
+                          size: 32,
+                        ),
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+              const SizedBox(height: 16),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}

dialer/lib/features/composition/composition.dart

@@ -76,7 +76,7 @@ class _CompositionPageState extends State<CompositionPage> {
   // Function to call a contact's number using the CallService
   void _makeCall(String phoneNumber) async {
     try {
-      await _callService.makeGsmCall(phoneNumber);
+      await _callService.makeGsmCall(context, phoneNumber: phoneNumber);
       setState(() {
         dialedNumber = phoneNumber;
       });

dialer/lib/features/contacts/widgets/contact_modal.dart

@@ -5,7 +5,7 @@ import 'package:url_launcher/url_launcher.dart';
 import 'package:dialer/widgets/username_color_generator.dart';
 import '../../../services/block_service.dart';
 import '../../../services/contact_service.dart';
-import '../../../services/call_service.dart'; // Import CallService
+import '../../../services/call_service.dart';
 
 class ContactModal extends StatefulWidget {
   final Contact contact;
@@ -29,7 +29,7 @@ class _ContactModalState extends State<ContactModal> {
   late String phoneNumber;
   bool isBlocked = false;
   final ObfuscateService _obfuscateService = ObfuscateService();
-  final CallService _callService = CallService(); // Instantiate CallService
+  final CallService _callService = CallService();
 
   @override
   void initState() {
@@ -126,7 +126,9 @@ class _ContactModalState extends State<ContactModal> {
 
         // Show success message
         ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('${_obfuscateService.obfuscateData(widget.contact.displayName)} deleted')),
+          SnackBar(
+              content: Text(
+                  '${_obfuscateService.obfuscateData(widget.contact.displayName)} deleted')),
         );
 
         // Close the modal
@@ -134,7 +136,9 @@ class _ContactModalState extends State<ContactModal> {
       } catch (e) {
         // Handle errors and show a failure message
         ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Failed to delete ${widget.contact.displayName}: $e')),
+          SnackBar(
+              content:
+                  Text('Failed to delete ${widget.contact.displayName}: $e')),
         );
       }
     }
@@ -162,7 +166,7 @@ class _ContactModalState extends State<ContactModal> {
               decoration: BoxDecoration(
                 color: Colors.grey[900],
                 borderRadius:
-                const BorderRadius.vertical(top: Radius.circular(20)),
+                    const BorderRadius.vertical(top: Radius.circular(20)),
               ),
               child: Column(
                 mainAxisSize: MainAxisSize.min,
@@ -216,7 +220,7 @@ class _ContactModalState extends State<ContactModal> {
                                 const PopupMenuItem<String>(
                                   value: 'create_shortcut',
                                   child:
-                                  Text('Create shortcut (to home screen)'),
+                                      Text('Create shortcut (to home screen)'),
                                 ),
                                 const PopupMenuItem<String>(
                                   value: 'set_ringtone',
@@ -238,12 +242,13 @@ class _ContactModalState extends State<ContactModal> {
                           imageBytes: widget.contact.thumbnail,
                           radius: 50,
                           backgroundColor:
-                          generateColorFromName(widget.contact.displayName),
+                              generateColorFromName(widget.contact.displayName),
                           fallbackInitial: widget.contact.displayName,
                         ),
                         const SizedBox(height: 10),
                         Text(
-                          _obfuscateService.obfuscateData(widget.contact.displayName),
+                          _obfuscateService
+                              .obfuscateData(widget.contact.displayName),
                           style: const TextStyle(
                               fontSize: 24,
                               fontWeight: FontWeight.bold,
@@ -262,7 +267,8 @@ class _ContactModalState extends State<ContactModal> {
                     ),
                     onTap: () async {
                       if (widget.contact.phones.isNotEmpty) {
-                        await _callService.makeGsmCall(phoneNumber);
+                        await _callService.makeGsmCall(context,
+                            phoneNumber: phoneNumber);
                       }
                     },
                   ),
@@ -307,9 +313,8 @@ class _ContactModalState extends State<ContactModal> {
                             icon: Icon(widget.isFavorite
                                 ? Icons.star
                                 : Icons.star_border),
-                            label: Text(widget.isFavorite
-                                ? 'Unfavorite'
-                                : 'Favorite'),
+                            label: Text(
+                                widget.isFavorite ? 'Unfavorite' : 'Favorite'),
                           ),
                         ),
                         const SizedBox(height: 10),

dialer/lib/features/history/history_page.dart

@@ -11,6 +11,7 @@ import 'package:dialer/features/contacts/contact_state.dart';
 import 'package:dialer/widgets/username_color_generator.dart';
 import '../../services/block_service.dart';
 import '../contacts/widgets/contact_modal.dart';
+import '../../services/call_service.dart';
 
 class History {
   final Contact contact;
@@ -20,12 +21,12 @@ class History {
   final int attempts;
 
   History(
-      this.contact,
-      this.date,
-      this.callType,
-      this.callStatus,
-      this.attempts,
-      );
+    this.contact,
+    this.date,
+    this.callType,
+    this.callStatus,
+    this.attempts,
+  );
 }
 
 class HistoryPage extends StatefulWidget {
@@ -41,6 +42,7 @@ class _HistoryPageState extends State<HistoryPage>
   bool loading = true;
   int? _expandedIndex;
   final ObfuscateService _obfuscateService = ObfuscateService();
+  final CallService _callService = CallService();
 
   // Create a MethodChannel instance.
   static const MethodChannel _channel = MethodChannel('com.example.calllog');
@@ -83,8 +85,8 @@ class _HistoryPageState extends State<HistoryPage>
       }
     } catch (e) {
       print("Error updating favorite status: $e");
-      ScaffoldMessenger.of(context)
-          .showSnackBar(SnackBar(content: Text('Failed to update favorite status')));
+      ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Failed to update favorite status')));
     }
   }
 
@@ -155,7 +157,7 @@ class _HistoryPageState extends State<HistoryPage>
 
       // Convert timestamp to DateTime.
       DateTime callDate =
-      DateTime.fromMillisecondsSinceEpoch(entry['date'] ?? 0);
+          DateTime.fromMillisecondsSinceEpoch(entry['date'] ?? 0);
 
       int typeInt = entry['type'] ?? 0;
       int duration = entry['duration'] ?? 0;
@@ -193,7 +195,8 @@ class _HistoryPageState extends State<HistoryPage>
         );
       }
 
-      callHistories.add(History(matchedContact, callDate, callType, callStatus, 1));
+      callHistories
+          .add(History(matchedContact, callDate, callType, callStatus, 1));
     }
 
     // Sort histories by most recent.
@@ -218,7 +221,7 @@ class _HistoryPageState extends State<HistoryPage>
 
     for (var history in historyList) {
       final callDate =
-      DateTime(history.date.year, history.date.month, history.date.day);
+          DateTime(history.date.year, history.date.month, history.date.day);
       if (callDate == today) {
         todayHistories.add(history);
       } else if (callDate == yesterday) {
@@ -291,7 +294,7 @@ class _HistoryPageState extends State<HistoryPage>
     }
 
     List<History> missedCalls =
-    histories.where((h) => h.callStatus == 'missed').toList();
+        histories.where((h) => h.callStatus == 'missed').toList();
 
     final allItems = _buildGroupedList(histories);
     final missedItems = _buildGroupedList(missedCalls);
@@ -360,7 +363,8 @@ class _HistoryPageState extends State<HistoryPage>
                           onEdit: () async {
                             if (await FlutterContacts.requestPermission()) {
                               final updatedContact =
-                              await FlutterContacts.openExternalEdit(contact.id);
+                                  await FlutterContacts.openExternalEdit(
+                                      contact.id);
                               if (updatedContact != null) {
                                 await _refreshContacts();
                                 Navigator.of(context).pop();
@@ -415,18 +419,11 @@ class _HistoryPageState extends State<HistoryPage>
                       icon: const Icon(Icons.phone, color: Colors.green),
                       onPressed: () async {
                         if (contact.phones.isNotEmpty) {
-                          final Uri callUri =
-                          Uri(scheme: 'tel', path: contact.phones.first.number);
-                          if (await canLaunchUrl(callUri)) {
-                            await launchUrl(callUri);
-                          } else {
-                            ScaffoldMessenger.of(context).showSnackBar(
-                              const SnackBar(content: Text('Could not launch call')),
-                            );
-                          }
+                          _callService.makeGsmCall(context, phoneNumber: contact.phones.first.number);
                         } else {
                           ScaffoldMessenger.of(context).showSnackBar(
-                            const SnackBar(content: Text('Contact has no phone number')),
+                            const SnackBar(
+                                content: Text('Contact has no phone number')),
                           );
                         }
                       },
@@ -444,7 +441,9 @@ class _HistoryPageState extends State<HistoryPage>
                   color: Colors.grey[850],
                   child: FutureBuilder<bool>(
                     future: BlockService().isNumberBlocked(
-                        contact.phones.isNotEmpty ? contact.phones.first.number : ''),
+                        contact.phones.isNotEmpty
+                            ? contact.phones.first.number
+                            : ''),
                     builder: (context, snapshot) {
                       final isBlocked = snapshot.data ?? false;
                       return Row(
@@ -460,29 +459,37 @@ class _HistoryPageState extends State<HistoryPage>
                                   await launchUrl(smsUri);
                                 } else {
                                   ScaffoldMessenger.of(context).showSnackBar(
-                                    const SnackBar(content: Text('Could not send message')),
+                                    const SnackBar(
+                                        content:
+                                            Text('Could not send message')),
                                   );
                                 }
                               } else {
                                 ScaffoldMessenger.of(context).showSnackBar(
-                                  const SnackBar(content: Text('Contact has no phone number')),
+                                  const SnackBar(
+                                      content:
+                                          Text('Contact has no phone number')),
                                 );
                               }
                             },
-                            icon: const Icon(Icons.message, color: Colors.white),
-                            label: const Text('Message', style: TextStyle(color: Colors.white)),
+                            icon:
+                                const Icon(Icons.message, color: Colors.white),
+                            label: const Text('Message',
+                                style: TextStyle(color: Colors.white)),
                           ),
                           TextButton.icon(
                             onPressed: () {
                               Navigator.push(
                                 context,
                                 MaterialPageRoute(
-                                  builder: (_) => CallDetailsPage(history: history),
+                                  builder: (_) =>
+                                      CallDetailsPage(history: history),
                                 ),
                               );
                             },
                             icon: const Icon(Icons.info, color: Colors.white),
-                            label: const Text('Details', style: TextStyle(color: Colors.white)),
+                            label: const Text('Details',
+                                style: TextStyle(color: Colors.white)),
                           ),
                           TextButton.icon(
                             onPressed: () async {
@@ -491,24 +498,29 @@ class _HistoryPageState extends State<HistoryPage>
                                   : null;
                               if (phoneNumber == null) {
                                 ScaffoldMessenger.of(context).showSnackBar(
-                                  const SnackBar(content: Text('Contact has no phone number')),
+                                  const SnackBar(
+                                      content:
+                                          Text('Contact has no phone number')),
                                 );
                                 return;
                               }
                               if (isBlocked) {
                                 await BlockService().unblockNumber(phoneNumber);
                                 ScaffoldMessenger.of(context).showSnackBar(
-                                  SnackBar(content: Text('$phoneNumber unblocked')),
+                                  SnackBar(
+                                      content: Text('$phoneNumber unblocked')),
                                 );
                               } else {
                                 await BlockService().blockNumber(phoneNumber);
                                 ScaffoldMessenger.of(context).showSnackBar(
-                                  SnackBar(content: Text('$phoneNumber blocked')),
+                                  SnackBar(
+                                      content: Text('$phoneNumber blocked')),
                                 );
                               }
                               setState(() {});
                             },
-                            icon: Icon(isBlocked ? Icons.lock_open : Icons.block,
+                            icon: Icon(
+                                isBlocked ? Icons.lock_open : Icons.block,
                                 color: Colors.white),
                             label: Text(isBlocked ? 'Unblock' : 'Block',
                                 style: const TextStyle(color: Colors.white)),
@@ -554,21 +566,22 @@ class CallDetailsPage extends StatelessWidget {
               children: [
                 (contact.thumbnail != null && contact.thumbnail!.isNotEmpty)
                     ? ObfuscatedAvatar(
-                  imageBytes: contact.thumbnail,
-                  radius: 30,
-                  backgroundColor: contactBg,
-                  fallbackInitial: contact.displayName,
-                )
+                        imageBytes: contact.thumbnail,
+                        radius: 30,
+                        backgroundColor: contactBg,
+                        fallbackInitial: contact.displayName,
+                      )
                     : CircleAvatar(
-                  backgroundColor: generateColorFromName(contact.displayName),
-                  radius: 30,
-                  child: Text(
-                    contact.displayName.isNotEmpty
-                        ? contact.displayName[0].toUpperCase()
-                        : '?',
-                    style: TextStyle(color: contactLetter),
-                  ),
-                ),
+                        backgroundColor:
+                            generateColorFromName(contact.displayName),
+                        radius: 30,
+                        child: Text(
+                          contact.displayName.isNotEmpty
+                              ? contact.displayName[0].toUpperCase()
+                              : '?',
+                          style: TextStyle(color: contactLetter),
+                        ),
+                      ),
                 const SizedBox(width: 16),
                 Expanded(
                   child: Text(
@@ -600,7 +613,8 @@ class CallDetailsPage extends StatelessWidget {
             if (contact.phones.isNotEmpty)
               DetailRow(
                 label: 'Number:',
-                value: _obfuscateService.obfuscateData(contact.phones.first.number),
+                value: _obfuscateService
+                    .obfuscateData(contact.phones.first.number),
               ),
           ],
         ),

dialer/lib/features/home/home_page.dart

@@ -8,6 +8,7 @@ import 'package:flutter_contacts/flutter_contacts.dart';
 import 'package:dialer/features/settings/settings.dart';
 import '../../services/contact_service.dart';
 import 'package:dialer/features/voicemail/voicemail_page.dart';
+import '../contacts/widgets/contact_modal.dart';
 
 
 class _MyHomePageState extends State<MyHomePage>
@@ -17,6 +18,8 @@ class _MyHomePageState extends State<MyHomePage>
   List<Contact> _contactSuggestions = [];
   final ContactService _contactService = ContactService();
   final ObfuscateService _obfuscateService = ObfuscateService();
+  final TextEditingController _searchController = TextEditingController();
+
 
   @override
   void initState() {
@@ -32,12 +35,15 @@ class _MyHomePageState extends State<MyHomePage>
     setState(() {});
   }
 
-  void _onSearchChanged(String query) {
-    print("Search query: $query");
+  void _clearSearch() {
+    _searchController.clear();
+    _onSearchChanged('');
+  }
 
+  void _onSearchChanged(String query) {
     setState(() {
       if (query.isEmpty) {
-        _contactSuggestions = List.from(_allContacts);
+        _contactSuggestions = List.from(_allContacts); // Reset suggestions
       } else {
         _contactSuggestions = _allContacts.where((contact) {
           return contact.displayName
@@ -50,6 +56,7 @@ class _MyHomePageState extends State<MyHomePage>
 
   @override
   void dispose() {
+    _searchController.dispose();
     _tabController.removeListener(_handleTabIndex);
     _tabController.dispose();
     super.dispose();
@@ -59,6 +66,34 @@ class _MyHomePageState extends State<MyHomePage>
     setState(() {});
   }
 
+  void _toggleFavorite(Contact contact) async {
+    try {
+      if (await FlutterContacts.requestPermission()) {
+        Contact? fullContact = await FlutterContacts.getContact(contact.id,
+            withProperties: true,
+            withAccounts: true,
+            withPhoto: true,
+            withThumbnail: true);
+
+        if (fullContact != null) {
+          fullContact.isStarred = !fullContact.isStarred;
+          await FlutterContacts.updateContact(fullContact);
+          setState(() {
+            // Updating the contact list after toggling the favorite
+            _fetchContacts();
+          });
+        }
+      } else {
+        print("Could not fetch contact details");
+      }
+    } catch (e) {
+      print("Error updating favorite status: $e");
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Failed to update contact favorite status')),
+      );
+    }
+  }
+
   @override
   Widget build(BuildContext context) {
     return Scaffold(
@@ -80,63 +115,109 @@ class _MyHomePageState extends State<MyHomePage>
                     decoration: BoxDecoration(
                       color: const Color.fromARGB(255, 30, 30, 30),
                       borderRadius: BorderRadius.circular(12.0),
-                      border: Border(
-                        top: BorderSide(color: Colors.grey.shade800, width: 1),
-                        left: BorderSide(color: Colors.grey.shade800, width: 1),
-                        right: BorderSide(color: Colors.grey.shade800, width: 1),
-                        bottom:
-                        BorderSide(color: Colors.grey.shade800, width: 2),
-                      ),
+                      border: Border.all(color: Colors.grey.shade800, width: 1),
                     ),
                     child: SearchAnchor(
                       builder:
                           (BuildContext context, SearchController controller) {
-                        return SearchBar(
-                          controller: controller,
-                          padding:
-                          WidgetStateProperty.all<EdgeInsetsGeometry>(
-                            const EdgeInsets.only(
-                              top: 6.0,
-                              bottom: 6.0,
-                              left: 16.0,
-                              right: 16.0,
-                            ),
-                          ),
+                        return GestureDetector(
                           onTap: () {
-                            controller.openView();
-                            _onSearchChanged('');
+                            controller.openView(); // Open the search view
                           },
-                          backgroundColor: WidgetStateProperty.all(
-                              const Color.fromARGB(255, 30, 30, 30)),
-                          hintText: 'Search contacts',
-                          hintStyle: WidgetStateProperty.all(
-                            const TextStyle(color: Colors.grey, fontSize: 16.0),
-                          ),
-                          leading: const Icon(
-                            Icons.search,
-                            color: Colors.grey,
-                            size: 24.0,
-                          ),
-                          shape:
-                          WidgetStateProperty.all<RoundedRectangleBorder>(
-                            RoundedRectangleBorder(
+                          child: Container(
+                            decoration: BoxDecoration(
+                              color: const Color.fromARGB(255, 30, 30, 30),
                               borderRadius: BorderRadius.circular(12.0),
+                              border: Border.all(
+                                  color: Colors.grey.shade800, width: 1),
+                            ),
+                            padding: const EdgeInsets.symmetric(
+                                vertical: 12.0, horizontal: 16.0),
+                            child: Row(
+                              children: [
+                                const Icon(Icons.search,
+                                    color: Colors.grey, size: 24.0),
+                                const SizedBox(width: 8.0),
+                                Text(
+                                  _searchController.text.isEmpty
+                                      ? 'Search contacts'
+                                      : _searchController.text,
+                                  style: const TextStyle(
+                                      color: Colors.grey, fontSize: 16.0),
+                                ),
+                                const Spacer(),
+                                if (_searchController.text.isNotEmpty)
+                                  GestureDetector(
+                                    onTap: _clearSearch,
+                                    child: const Icon(
+                                      Icons.clear,
+                                      color: Colors.grey,
+                                      size: 24.0,
+                                    ),
+                                  ),
+                              ],
                             ),
                           ),
                         );
                       },
                       viewOnChanged: (query) {
-                        _onSearchChanged(query);
+                        _onSearchChanged(query); // Update immediately
                       },
                       suggestionsBuilder:
                           (BuildContext context, SearchController controller) {
                         return _contactSuggestions.map((contact) {
-                          return  ListTile(
+                          return ListTile(
                             key: ValueKey(contact.id),
                             title: Text(_obfuscateService.obfuscateData(contact.displayName),
                                 style: const TextStyle(color: Colors.white)),
                             onTap: () {
+                              // Clear the search text input
+                              controller.text = '';
+
+                              // Close the search view
                               controller.closeView(contact.displayName);
+
+                              // Show the ContactModal when a contact is tapped
+                              showModalBottomSheet(
+                                context: context,
+                                isScrollControlled: true,
+                                backgroundColor: Colors.transparent,
+                                builder: (context) {
+                                  return ContactModal(
+                                    contact: contact,
+                                    onEdit: () async {
+                                      if (await FlutterContacts
+                                          .requestPermission()) {
+                                        final updatedContact =
+                                            await FlutterContacts
+                                                .openExternalEdit(contact.id);
+                                        if (updatedContact != null) {
+                                          _fetchContacts();
+                                          Navigator.of(context).pop();
+                                          ScaffoldMessenger.of(context)
+                                              .showSnackBar(
+                                            SnackBar(
+                                              content: Text(
+                                                  '${contact.displayName} updated successfully!'),
+                                            ),
+                                          );
+                                        } else {
+                                          ScaffoldMessenger.of(context)
+                                              .showSnackBar(
+                                            SnackBar(
+                                              content: Text(
+                                                  'Edit canceled or failed.'),
+                                            ),
+                                          );
+                                        }
+                                      }
+                                    },
+                                    onToggleFavorite: () =>
+                                        _toggleFavorite(contact),
+                                    isFavorite: contact.isStarred,
+                                  );
+                                },
+                              );
                             },
                           );
                         }).toList();

dialer/lib/main.dart

@@ -1,8 +1,11 @@
 import 'package:dialer/features/home/home_page.dart';
 import 'package:flutter/material.dart';
 import 'package:dialer/features/contacts/contact_state.dart';
+import 'package:dialer/services/call_service.dart';
+import 'package:flutter/services.dart';
 import 'globals.dart' as globals;
 import 'package:dialer/services/cryptography/asymmetric_crypto_service.dart';
+import 'package:permission_handler/permission_handler.dart';
 import 'package:provider/provider.dart';
 
 void main() async {
@@ -13,19 +16,38 @@ void main() async {
   final AsymmetricCryptoService cryptoService = AsymmetricCryptoService();
   await cryptoService.initializeDefaultKeyPair();
 
+  // Request permissions before running the app
+  await _requestPermissions();
+
+  CallService();
+
   runApp(
     MultiProvider(
       providers: [
         Provider<AsymmetricCryptoService>(
           create: (_) => cryptoService,
         ),
-        // Add other providers here
       ],
       child: Dialer(),
     ),
   );
 }
 
+Future<void> _requestPermissions() async {
+  Map<Permission, PermissionStatus> statuses = await [
+    Permission.phone,
+    Permission.contacts,
+    Permission.microphone,
+  ].request();
+  if (statuses.values.every((status) => status.isGranted)) {
+    print("All required permissions granted");
+    const channel = MethodChannel('call_service');
+    await channel.invokeMethod('permissionsGranted');
+  } else {
+    print("Permissions denied: ${statuses.entries.where((e) => !e.value.isGranted).map((e) => e.key).join(', ')}");
+  }
+}
+
 class Dialer extends StatelessWidget {
   const Dialer({super.key});
 
@@ -33,11 +55,12 @@ class Dialer extends StatelessWidget {
   Widget build(BuildContext context) {
     return ContactState(
       child: MaterialApp(
+        navigatorKey: CallService.navigatorKey,
         theme: ThemeData(
-          brightness: Brightness.dark
+          brightness: Brightness.dark,
         ),
         home: SafeArea(child: MyHomePage()),
-      )
+      ),
     );
   }
-}
+}

dialer/lib/services/call_service.dart

@@ -1,26 +1,154 @@
+import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
+import '../features/call/call_page.dart';
+import '../features/call/incoming_call_page.dart'; // Import the new page
 
-// Service to manage call-related operations
 class CallService {
   static const MethodChannel _channel = MethodChannel('call_service');
+  static String? currentPhoneNumber;
+  static bool _isCallPageVisible = false;
 
-  // Function to make a GSM call
-  Future<void> makeGsmCall(String phoneNumber) async {
+  static final GlobalKey<NavigatorState> navigatorKey = GlobalKey<NavigatorState>();
+
+  CallService() {
+    _channel.setMethodCallHandler((call) async {
+      final context = navigatorKey.currentContext;
+      print('CallService: Received method ${call.method} with args ${call.arguments}');
+      if (context == null) {
+        print('CallService: Navigator context is null, cannot navigate');
+        return;
+      }
+
+      switch (call.method) {
+        case "callAdded":
+          final phoneNumber = call.arguments["callId"] as String;
+          final state = call.arguments["state"] as String;
+          currentPhoneNumber = phoneNumber.replaceFirst('tel:', '');
+          print('CallService: Call added, number: $currentPhoneNumber, state: $state');
+          if (state == "ringing") {
+            _navigateToIncomingCallPage(context);
+          } else {
+            _navigateToCallPage(context);
+          }
+          break;
+        case "callStateChanged":
+          final state = call.arguments["state"] as String;
+          print('CallService: State changed to $state');
+          if (state == "disconnected" || state == "disconnecting") {
+            _closeCallPage(context);
+          } else if (state == "active" || state == "dialing") {
+            _navigateToCallPage(context);
+          } else if (state == "ringing") {
+            _navigateToIncomingCallPage(context);
+          }
+          break;
+        case "callEnded":
+        case "callRemoved":
+          print('CallService: Call ended/removed');
+          _closeCallPage(context);
+          currentPhoneNumber = null;
+          break;
+      }
+    });
+  }
+
+  void _navigateToCallPage(BuildContext context) {
+    if (_isCallPageVisible && ModalRoute.of(context)?.settings.name == '/call') {
+      print('CallService: CallPage already visible, skipping navigation');
+      return;
+    }
+    print('CallService: Navigating to CallPage');
+    Navigator.pushReplacement(
+      context,
+      MaterialPageRoute(
+        settings: const RouteSettings(name: '/call'),
+        builder: (context) => CallPage(
+          displayName: currentPhoneNumber!,
+          phoneNumber: currentPhoneNumber!,
+          thumbnail: null,
+        ),
+      ),
+    ).then((_) {
+      _isCallPageVisible = false;
+    });
+    _isCallPageVisible = true;
+  }
+
+  void _navigateToIncomingCallPage(BuildContext context) {
+    if (_isCallPageVisible && ModalRoute.of(context)?.settings.name == '/incoming_call') {
+      print('CallService: IncomingCallPage already visible, skipping navigation');
+      return;
+    }
+    print('CallService: Navigating to IncomingCallPage');
+    Navigator.push(
+      context,
+      MaterialPageRoute(
+        settings: const RouteSettings(name: '/incoming_call'),
+        builder: (context) => IncomingCallPage(
+          displayName: currentPhoneNumber!,
+          phoneNumber: currentPhoneNumber!,
+          thumbnail: null,
+        ),
+      ),
+    ).then((_) {
+      _isCallPageVisible = false;
+    });
+    _isCallPageVisible = true;
+  }
+
+  void _closeCallPage(BuildContext context) {
+    if (!_isCallPageVisible) {
+      print('CallService: CallPage not visible, skipping pop');
+      return;
+    }
+    if (Navigator.canPop(context)) {
+      print('CallService: Popping CallPage');
+      Navigator.pop(context);
+      _isCallPageVisible = false;
+    }
+  }
+
+  Future<void> makeGsmCall(
+    BuildContext context, {
+    required String phoneNumber,
+    String? displayName,
+    Uint8List? thumbnail,
+  }) async {
     try {
-      await _channel.invokeMethod('makeGsmCall', {"phoneNumber": phoneNumber});
+      currentPhoneNumber = phoneNumber;
+      print('CallService: Making GSM call to $phoneNumber');
+      final result = await _channel.invokeMethod('makeGsmCall', {"phoneNumber": phoneNumber});
+      print('CallService: makeGsmCall result: $result');
+      if (result["status"] != "calling") {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text("Failed to initiate call")),
+        );
+      }
     } catch (e) {
-      print("Error making call: $e");
+      print("CallService: Error making call: $e");
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text("Error making call: $e")),
+      );
       rethrow;
     }
   }
 
-  // Function to hang up the current call
-  Future<void> hangUpCall() async {
+  Future<void> hangUpCall(BuildContext context) async {
     try {
-      await _channel.invokeMethod('hangUpCall');
+      print('CallService: Hanging up call');
+      final result = await _channel.invokeMethod('hangUpCall');
+      print('CallService: hangUpCall result: $result');
+      if (result["status"] != "ended") {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text("Failed to end call")),
+        );
+      }
     } catch (e) {
-      print("Error hanging up call: $e");
+      print("CallService: Error hanging up call: $e");
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text("Error hanging up call: $e")),
+      );
       rethrow;
     }
   }
-}
+}

dialer/run.sh

@@ -2,4 +2,9 @@
 
 IMG=git.gmoker.com/icing/flutter:main
 
-docker run --rm -p 5037:5037 -v "$PWD:/app/" "$IMG" run
+if [ "$1" == '-s' ]; then
+    OPT+=(--dart-define=STEALTH=true)
+fi
+
+set -x
+docker run --rm -p 5037:5037 -v "$PWD:/app/" "$IMG" run "${OPTS[@]}"

dialer/stealth_local_run.sh

@@ -1,3 +1,4 @@
 #!/usr/bin/env bash
+
 echo "Running Icing Dialer in STEALTH mode..."
-flutter run --dart-define=STEALTH=true
+flutter run --dart-define=STEALTH=true

protocol_prototype/IcingProtocol.drawio

@@ -0,0 +1,459 @@
+<mxfile host="app.diagrams.net" agent="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36" version="26.1.1" pages="2">
+  <diagram id="C5RBs43oDa-KdzZeNtuy" name="Logique">
+    <mxGraphModel dx="735" dy="407" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
+      <root>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-0" />
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-1" parent="WIyWlLk6GJQsqaUBKTNV-0" />
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-2" value="" style="rounded=0;html=1;jettySize=auto;orthogonalLoop=1;fontSize=11;endArrow=block;endFill=0;endSize=8;strokeWidth=1;shadow=0;labelBackgroundColor=none;edgeStyle=orthogonalEdgeStyle;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-3" target="WIyWlLk6GJQsqaUBKTNV-6" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-3" value="Alice appelle Bob" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=3;shadow=0;strokeColor=light-dark(#000000,#370FFF);" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="300" y="90" width="120" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-4" value="Yes" style="rounded=0;html=1;jettySize=auto;orthogonalLoop=1;fontSize=11;endArrow=block;endFill=0;endSize=8;strokeWidth=1;shadow=0;labelBackgroundColor=none;edgeStyle=orthogonalEdgeStyle;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-0" target="WIyWlLk6GJQsqaUBKTNV-10" edge="1">
+          <mxGeometry y="20" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-5" value="No" style="edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;jettySize=auto;orthogonalLoop=1;fontSize=11;endArrow=block;endFill=0;endSize=8;strokeWidth=1;shadow=0;labelBackgroundColor=none;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-6" target="WIyWlLk6GJQsqaUBKTNV-7" edge="1">
+          <mxGeometry y="10" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-6" value="Bob répond ?" style="rhombus;whiteSpace=wrap;html=1;shadow=0;fontFamily=Helvetica;fontSize=12;align=center;strokeWidth=1;spacing=6;spacingTop=-4;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="310" y="180" width="100" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-7" value="Rien ne se passe" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="460" y="200" width="120" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-8" value="Négativement" style="rounded=0;html=1;jettySize=auto;orthogonalLoop=1;fontSize=11;endArrow=block;endFill=0;endSize=8;strokeWidth=1;shadow=0;labelBackgroundColor=none;edgeStyle=orthogonalEdgeStyle;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-10" target="WIyWlLk6GJQsqaUBKTNV-11" edge="1">
+          <mxGeometry y="40" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-9" value="Positivement" style="edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;jettySize=auto;orthogonalLoop=1;fontSize=11;endArrow=block;endFill=0;endSize=8;strokeWidth=1;shadow=0;labelBackgroundColor=none;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-10" target="WIyWlLk6GJQsqaUBKTNV-12" edge="1">
+          <mxGeometry y="10" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-10" value="Bob ping..." style="whiteSpace=wrap;html=1;shadow=0;fontFamily=Helvetica;fontSize=12;align=center;strokeWidth=1;spacing=6;spacingTop=-4;shape=hexagon;perimeter=hexagonPerimeter2;fixedSize=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="310" y="390" width="100" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-11" value="Protocole échoué&lt;div&gt;-&lt;/div&gt;&lt;div&gt;Passage en clair&lt;/div&gt;" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=3;shadow=0;strokeColor=light-dark(#000000,#FF1414);" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="300" y="520" width="120" height="50" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-7" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=0;entryDx=0;entryDy=0;endArrow=block;endFill=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-12" target="FXGPDhTRSO2FZSW48CnP-8" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="599.9999999999998" y="500" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-12" value="Alice envoi son&lt;span style=&quot;background-color: transparent; color: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));&quot;&gt;&amp;nbsp;handshake a Bob&lt;/span&gt;" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="540" y="410" width="120" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-1" value="" style="rounded=0;html=1;jettySize=auto;orthogonalLoop=1;fontSize=11;endArrow=block;endFill=0;endSize=8;strokeWidth=1;shadow=0;labelBackgroundColor=none;edgeStyle=orthogonalEdgeStyle;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-6" target="FXGPDhTRSO2FZSW48CnP-0" edge="1">
+          <mxGeometry y="20" relative="1" as="geometry">
+            <mxPoint as="offset" />
+            <mxPoint x="360" y="260" as="sourcePoint" />
+            <mxPoint x="360" y="390" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-0" value="Le dialer d&#39;Alice envoi un PING a Bob" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="300" y="300" width="120" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-2" value="" style="endArrow=block;html=1;rounded=0;exitX=0;exitY=0.5;exitDx=0;exitDy=0;endFill=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;edgeStyle=orthogonalEdgeStyle;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-10" target="FXGPDhTRSO2FZSW48CnP-4" edge="1">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="480" y="450" as="sourcePoint" />
+            <mxPoint x="190" y="430" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="280" y="430" />
+              <mxPoint x="280" y="460" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-3" value="Ne ping pas" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-2" vertex="1" connectable="0">
+          <mxGeometry x="-0.2695" relative="1" as="geometry">
+            <mxPoint x="-16" y="-10" as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-5" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-4" target="FXGPDhTRSO2FZSW48CnP-0" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="130" y="320" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-6" value="Reping" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-5" vertex="1" connectable="0">
+          <mxGeometry x="0.0817" relative="1" as="geometry">
+            <mxPoint x="23" y="-10" as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-4" value="Attendre 1s ? 0.5s ?" style="rounded=1;whiteSpace=wrap;html=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="70" y="440" width="120" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-12" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;endArrow=block;endFill=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-8" target="FXGPDhTRSO2FZSW48CnP-11" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="530.0380952380951" y="585.0038095238094" as="sourcePoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-13" value="Non" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-12" vertex="1" connectable="0">
+          <mxGeometry x="-0.4964" y="-1" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-43" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;endArrow=block;endFill=0;strokeColor=light-dark(#000000,#FF0000);" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-8" target="FXGPDhTRSO2FZSW48CnP-27" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="600" y="800" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="600" y="660" />
+              <mxPoint x="570" y="660" />
+              <mxPoint x="570" y="700" />
+              <mxPoint x="210" y="700" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-44" value="Oui" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-43" vertex="1" connectable="0">
+          <mxGeometry x="-0.8049" y="1" relative="1" as="geometry">
+            <mxPoint x="8" y="-25" as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-8" value="Bob reconnait la clé publique d&#39;Alice ?" style="rhombus;whiteSpace=wrap;html=1;fontSize=10;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="540" y="545" width="120" height="75" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-16" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=block;endFill=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-11" target="WIyWlLk6GJQsqaUBKTNV-11" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="360" y="600" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-17" value="Non" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-16" vertex="1" connectable="0">
+          <mxGeometry x="-0.1233" y="-2" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-20" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=block;endFill=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-11" target="FXGPDhTRSO2FZSW48CnP-19" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-21" value="Oui" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-20" vertex="1" connectable="0">
+          <mxGeometry x="-0.275" y="1" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-11" value="Bob accepte la clé d&#39;Alice?" style="rhombus;whiteSpace=wrap;html=1;fontSize=10;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="354" y="620" width="120" height="75" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-23" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=block;endFill=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-19" target="FXGPDhTRSO2FZSW48CnP-22" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-19" value="Bob envoi sa clé publique en handshake" style="whiteSpace=wrap;html=1;fontSize=10;rounded=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="160" y="636.25" width="120" height="42.5" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-24" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;endArrow=block;endFill=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-22" target="WIyWlLk6GJQsqaUBKTNV-11" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="70" y="545" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-25" value="Non" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-24" vertex="1" connectable="0">
+          <mxGeometry x="-0.7543" y="3" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-28" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=block;endFill=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-22" target="FXGPDhTRSO2FZSW48CnP-27" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="70" y="750" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-22" value="Alice accepte la clé publique de Bob&lt;span style=&quot;background-color: transparent; color: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));&quot;&gt;&amp;nbsp;?&lt;/span&gt;" style="rhombus;whiteSpace=wrap;html=1;fontSize=10;rounded=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="30" y="617.5" width="80" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-47" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-26" target="FXGPDhTRSO2FZSW48CnP-46" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-26" value="Alice et Bob sont d&#39;accord sur la clé symmétrique a utiliser" style="rounded=0;whiteSpace=wrap;html=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="340" y="820" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-31" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;endArrow=block;endFill=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-27" target="FXGPDhTRSO2FZSW48CnP-30" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-45" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;strokeColor=light-dark(#000000,#FF1616);endArrow=block;endFill=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-27" target="FXGPDhTRSO2FZSW48CnP-26" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="210" y="850" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-27" value="Alice et Bob calculent le secret partagé de leur côté" style="whiteSpace=wrap;html=1;fontSize=10;rounded=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="150" y="720" width="120" height="50" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-33" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=1;entryDx=0;entryDy=0;jumpStyle=sharp;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-29" target="FXGPDhTRSO2FZSW48CnP-34" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="640" y="680" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="700" y="745" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-36" value="Non" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-33" vertex="1" connectable="0">
+          <mxGeometry x="-0.1536" y="1" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-41" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=1;entryY=0.5;entryDx=0;entryDy=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-29" target="FXGPDhTRSO2FZSW48CnP-26" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="525" y="798" />
+              <mxPoint x="510" y="798" />
+              <mxPoint x="510" y="850" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-42" value="Oui" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-41" vertex="1" connectable="0">
+          <mxGeometry x="-0.7774" y="1" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-29" value="Ils sont d&#39;accord ?" style="rhombus;whiteSpace=wrap;html=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="460" y="715" width="130" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-32" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-30" target="FXGPDhTRSO2FZSW48CnP-29" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-30" value="Alice et Bob lisent à haute voix la phrase de sécurité" style="whiteSpace=wrap;html=1;fontSize=10;rounded=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="300" y="720" width="120" height="50" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-37" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=1;entryY=0.5;entryDx=0;entryDy=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-34" target="WIyWlLk6GJQsqaUBKTNV-12" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-38" value="Oui" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-37" vertex="1" connectable="0">
+          <mxGeometry x="-0.3086" y="-2" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-39" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=1;entryY=0.5;entryDx=0;entryDy=0;jumpStyle=sharp;jumpSize=8;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-34" target="WIyWlLk6GJQsqaUBKTNV-11" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="530" y="690" />
+              <mxPoint x="530" y="545" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-40" value="Non" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="FXGPDhTRSO2FZSW48CnP-39" vertex="1" connectable="0">
+          <mxGeometry x="-0.7617" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-34" value="Ré-essayer ?" style="rhombus;whiteSpace=wrap;html=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="660" y="650" width="80" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-49" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="FXGPDhTRSO2FZSW48CnP-46" target="FXGPDhTRSO2FZSW48CnP-48" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-46" value="Alice et Bob utilisent la clé symmétrique pour chiffrer leurs transmissions" style="whiteSpace=wrap;html=1;rounded=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="340" y="920" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="FXGPDhTRSO2FZSW48CnP-48" value="" style="rhombus;whiteSpace=wrap;html=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="360" y="1020" width="80" height="80" as="geometry" />
+        </mxCell>
+      </root>
+    </mxGraphModel>
+  </diagram>
+  <diagram id="4Sb7mgJDpsadGym-U4wz" name="Echanges">
+    <mxGraphModel dx="700" dy="387" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="850" pageHeight="1100" math="0" shadow="0">
+      <root>
+        <mxCell id="0" />
+        <mxCell id="1" parent="0" />
+        <mxCell id="b_xV4iUWIxmdZCAYY4YR-1" value="0" style="html=1;shadow=0;dashed=0;align=center;verticalAlign=middle;shape=mxgraph.arrows2.arrow;dy=0;dx=10;notch=0;" parent="1" vertex="1">
+          <mxGeometry x="160" y="120" width="440" height="120" as="geometry" />
+        </mxCell>
+        <mxCell id="O_eM33N56VtHnDaMz1H4-1" value="ALICE" style="shape=umlLifeline;perimeter=lifelinePerimeter;whiteSpace=wrap;html=1;container=1;dropTarget=0;collapsible=0;recursiveResize=0;outlineConnect=0;portConstraint=eastwest;newEdgeStyle={&quot;curved&quot;:0,&quot;rounded&quot;:0};participant=umlEntity;strokeWidth=2;" parent="1" vertex="1">
+          <mxGeometry x="120" y="40" width="40" height="3110" as="geometry" />
+        </mxCell>
+        <mxCell id="O_eM33N56VtHnDaMz1H4-2" value="BOB" style="shape=umlLifeline;perimeter=lifelinePerimeter;whiteSpace=wrap;html=1;container=1;dropTarget=0;collapsible=0;recursiveResize=0;outlineConnect=0;portConstraint=eastwest;newEdgeStyle={&quot;curved&quot;:0,&quot;rounded&quot;:0};participant=umlEntity;strokeWidth=2;" parent="1" vertex="1">
+          <mxGeometry x="690" y="40" width="40" height="3110" as="geometry" />
+        </mxCell>
+        <mxCell id="b_xV4iUWIxmdZCAYY4YR-2" value="PING" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;fontSize=23;" parent="1" vertex="1">
+          <mxGeometry x="385" y="65" width="80" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="n3lF8vaYaHAhAfaeaFZn-1" value="Nonce" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="180" y="130" width="105" height="80" as="geometry">
+            <mxRectangle x="210" y="130" width="80" height="30" as="alternateBounds" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="n3lF8vaYaHAhAfaeaFZn-6" value="&lt;div&gt;sha256 (&lt;/div&gt;&lt;div&gt;numéro alice +&lt;/div&gt;&lt;div&gt;numéro bob +&lt;/div&gt;&lt;div&gt;timestamp +&lt;/div&gt;&lt;div&gt;random&lt;br&gt;&lt;/div&gt;&lt;div&gt;)&lt;br&gt;&lt;/div&gt;" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=7;" parent="n3lF8vaYaHAhAfaeaFZn-1" vertex="1">
+          <mxGeometry y="25" width="100" height="55" as="geometry" />
+        </mxCell>
+        <mxCell id="n3lF8vaYaHAhAfaeaFZn-2" value="Version" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="312.5" y="130" width="105" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="n3lF8vaYaHAhAfaeaFZn-4" value="Checksum" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="440" y="130" width="105" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="n3lF8vaYaHAhAfaeaFZn-7" value="CRC-32" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="n3lF8vaYaHAhAfaeaFZn-4" vertex="1">
+          <mxGeometry x="23" y="25" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-1" value="" style="html=1;shadow=0;dashed=0;align=center;verticalAlign=middle;shape=mxgraph.arrows2.arrow;dy=0;dx=10;notch=0;rotation=-180;" parent="1" vertex="1">
+          <mxGeometry x="280" y="300" width="410" height="120" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-2" value="Timestamp" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="300" y="310" width="90" height="80" as="geometry">
+            <mxRectangle x="210" y="130" width="80" height="30" as="alternateBounds" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-3" value="timestamp" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=10;strokeWidth=1;" parent="XvZTtdEB18xY6m2a5fJO-2" vertex="1">
+          <mxGeometry x="11.25" y="32.5" width="67.5" height="25" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-4" value="Version" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="410" y="310" width="58.75" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-11" value="0" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="XvZTtdEB18xY6m2a5fJO-4" vertex="1">
+          <mxGeometry x="-1.25" y="30" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-5" value="Checksum" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="560" y="310" width="105" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-6" value="CRC-32" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="XvZTtdEB18xY6m2a5fJO-5" vertex="1">
+          <mxGeometry x="23" y="25" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-9" value="Answer" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="486.25" y="310" width="57.5" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-10" value="&lt;div&gt;YES&lt;/div&gt;&lt;div&gt;NO&lt;br&gt;&lt;/div&gt;" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="486.25" y="340" width="53.75" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-13" value="HANDSHAKE" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;fontSize=23;" parent="1" vertex="1">
+          <mxGeometry x="350" y="430" width="170" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-14" value="" style="html=1;shadow=0;dashed=0;align=center;verticalAlign=middle;shape=mxgraph.arrows2.arrow;dy=0;dx=10;notch=0;" parent="1" vertex="1">
+          <mxGeometry x="160" y="490" width="410" height="220" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-15" value="Clé éphémère" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="170" y="500" width="105" height="80" as="geometry">
+            <mxRectangle x="210" y="130" width="80" height="30" as="alternateBounds" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-13" value="Clé (publique) générée aléatoirement" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=11;" parent="XvZTtdEB18xY6m2a5fJO-15" vertex="1">
+          <mxGeometry y="30" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-17" value="Signature" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="285" y="500" width="105" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-14" value="PubkeyFixe. sign(clé éphémère)" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="XvZTtdEB18xY6m2a5fJO-17" vertex="1">
+          <mxGeometry y="20" width="100" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-18" value="Checksum" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="486.25" y="500" width="65" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="XvZTtdEB18xY6m2a5fJO-19" value="CRC-32" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="XvZTtdEB18xY6m2a5fJO-18" vertex="1">
+          <mxGeometry x="2.5" y="30" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-15" value="PFS" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="402.81" y="500" width="71.88" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-16" value="hash( preuve de convo précédente)" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=10;" parent="pP7SjZfcCiBg3d1TCkzP-15" vertex="1">
+          <mxGeometry x="6.57" y="30" width="60" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-17" value="" style="html=1;shadow=0;dashed=0;align=center;verticalAlign=middle;shape=mxgraph.arrows2.arrow;dy=0;dx=10;notch=0;rotation=-180;" parent="1" vertex="1">
+          <mxGeometry x="285" y="750" width="410" height="180" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-43" value="Clé éphémère" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="305" y="760" width="105" height="80" as="geometry">
+            <mxRectangle x="210" y="130" width="80" height="30" as="alternateBounds" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-44" value="Clé (publique) générée aléatoirement" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=11;" parent="pP7SjZfcCiBg3d1TCkzP-43" vertex="1">
+          <mxGeometry y="30" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-45" value="Signature" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="420" y="760" width="105" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-46" value="PubkeyFixe. sign(clé éphémère)" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="pP7SjZfcCiBg3d1TCkzP-45" vertex="1">
+          <mxGeometry y="20" width="100" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-47" value="Checksum" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="621.25" y="760" width="65" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-48" value="CRC-32" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="pP7SjZfcCiBg3d1TCkzP-47" vertex="1">
+          <mxGeometry x="2.5" y="30" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-49" value="PFS" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="537.81" y="760" width="71.88" height="80" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-50" value="hash( preuve de convo précédente )" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=10;" parent="pP7SjZfcCiBg3d1TCkzP-49" vertex="1">
+          <mxGeometry x="6.57" y="30" width="60" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-54" value="Timestamp" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="182.5" y="610" width="80" height="70" as="geometry">
+            <mxRectangle x="210" y="130" width="80" height="30" as="alternateBounds" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-55" value="timestamp" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=10;strokeWidth=1;" parent="pP7SjZfcCiBg3d1TCkzP-54" vertex="1">
+          <mxGeometry x="6.25" y="32.5" width="67.5" height="25" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-56" value="Timestamp" style="swimlane;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="606.25" y="850" width="80" height="70" as="geometry">
+            <mxRectangle x="210" y="130" width="80" height="30" as="alternateBounds" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-57" value="timestamp" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=10;strokeWidth=1;" parent="pP7SjZfcCiBg3d1TCkzP-56" vertex="1">
+          <mxGeometry x="6.25" y="32.5" width="67.5" height="25" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-58" value="" style="html=1;shadow=0;dashed=0;align=center;verticalAlign=middle;shape=mxgraph.arrows2.arrow;dy=0;dx=10;notch=0;" parent="1" vertex="1">
+          <mxGeometry x="160" y="1080" width="360" height="110" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-59" value="ENCRYPTED COMS" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;fontSize=23;" parent="1" vertex="1">
+          <mxGeometry x="305" y="1020" width="240" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-60" value="256b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="200" y="210" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-61" value="7b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="335" y="210" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-62" value="32b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="463" y="210" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-63" value="= 295&lt;span style=&quot;background-color: transparent; color: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));&quot;&gt;b&lt;/span&gt;" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="530" y="210" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-66" value="32b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="315" y="390" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-67" value="7b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="408.75" y="390" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-68" value="1b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="484" y="390" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-69" value="32b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="582.5" y="390" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-70" value="= 72b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="630" y="390" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-71" value="264b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="193" y="580" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-72" value="512b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="307.5" y="580" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-73" value="256b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="409.38" y="580" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-74" value="32b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="488.75" y="580" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-75" value="32b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="192.5" y="680" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-76" value="=1096b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="315" y="670" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="pP7SjZfcCiBg3d1TCkzP-77" value="=1096b" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
+          <mxGeometry x="327.5" y="890" width="60" height="30" as="geometry" />
+        </mxCell>
+      </root>
+    </mxGraphModel>
+  </diagram>
+</mxfile>

protocol_prototype/cli.py

@@ -0,0 +1,113 @@
+import sys
+from protocol import IcingProtocol
+
+RED = "\033[91m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+BLUE = "\033[94m"
+RESET = "\033[0m"
+
+
+def main():
+    protocol = IcingProtocol()
+
+    print(f"{YELLOW}\n======================================")
+    print("   Icing Protocol - Manual CLI Demo   ")
+    print("======================================\n" + RESET)
+
+    print(f"Listening on port: {protocol.local_port}")
+    print(f"Your identity public key (hex): {protocol.identity_pubkey.hex()}")
+    print("\nAvailable commands:")
+    print("  set_peer_identity <hex_pubkey>")
+    print("  connect <port>")
+    print("  generate_ephemeral_keys")
+    print("  send_ping")
+    print("  send_handshake")
+    print("  respond_ping <index> <answer_code>")
+    print("  generate_ecdhe <index>   # formerly respond_handshake")
+    print("  auto_responder <on|off>")
+    print("  show_state")
+    print("  exit\n")
+
+    while True:
+        try:
+            line = input("Cmd> ").strip()
+        except EOFError:
+            break
+        if not line:
+            continue
+
+        parts = line.split()
+        cmd = parts[0].lower()
+
+        if cmd == "exit":
+            protocol.stop()
+            sys.exit(0)
+
+        elif cmd == "show_state":
+            protocol.show_state()
+
+        elif cmd == "set_peer_identity":
+            if len(parts) != 2:
+                print(f"{RED}Usage: set_peer_identity <hex_pubkey>{RESET}")
+                continue
+            protocol.set_peer_identity(parts[1])
+
+        elif cmd == "connect":
+            if len(parts) != 2:
+                print(f"{RED}Usage: connect <port>{RESET}")
+                continue
+            try:
+                port = int(parts[1])
+                protocol.connect_to_peer(port)
+            except ValueError:
+                print(f"{RED}Invalid port.{RESET}")
+
+        elif cmd == "generate_ephemeral_keys":
+            protocol.generate_ephemeral_keys()
+
+        elif cmd == "send_ping":
+            protocol.send_ping_request()
+
+        elif cmd == "send_handshake":
+            protocol.send_handshake()
+
+        elif cmd == "respond_ping":
+            if len(parts) != 3:
+                print(f"{RED}Usage: respond_ping <index> <answer_code>{RESET}")
+                continue
+            try:
+                idx = int(parts[1])
+                ac = int(parts[2])
+                protocol.respond_to_ping(idx, ac)
+            except ValueError:
+                print(f"{RED}Index and answer_code must be integers.{RESET}")
+
+        elif cmd == "generate_ecdhe":
+            if len(parts) != 2:
+                print(f"{RED}Usage: generate_ecdhe <index>{RESET}")
+                continue
+            try:
+                idx = int(parts[1])
+                protocol.generate_ecdhe(idx)
+            except ValueError:
+                print(f"{RED}Index must be an integer.{RESET}")
+
+        elif cmd == "auto_responder":
+            if len(parts) != 2:
+                print(f"{RED}Usage: auto_responder <on|off>{RESET}")
+                continue
+            arg = parts[1].lower()
+            if arg == "on":
+                protocol.enable_auto_responder(True)
+            elif arg == "off":
+                protocol.enable_auto_responder(False)
+            else:
+                print(f"{RED}Usage: auto_responder <on|off>{RESET}")
+
+        else:
+            print(f"{RED}[ERROR]{RESET} Unknown command: {cmd}")
+
+
+if __name__ == "__main__":
+    main()

protocol_prototype/crypto_utils.py

@@ -0,0 +1,81 @@
+import os
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric.ec import ECDH
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import utils
+from cryptography.exceptions import InvalidSignature
+
+
+def generate_identity_keys():
+    """
+    Generate an ECDSA (P-256) identity key pair.
+    Return (private_key, public_key_bytes).
+    public_key_bytes is raw x||y each 32 bytes (uncompressed minus the 0x04 prefix).
+    """
+    private_key = ec.generate_private_key(ec.SECP256R1())
+    public_numbers = private_key.public_key().public_numbers()
+
+    x_bytes = public_numbers.x.to_bytes(32, byteorder='big')
+    y_bytes = public_numbers.y.to_bytes(32, byteorder='big')
+    pubkey_bytes = x_bytes + y_bytes  # 64 bytes
+
+    return private_key, pubkey_bytes
+
+
+def load_peer_identity_key(pubkey_bytes: bytes):
+    """
+    Given 64 bytes (x||y) for P-256, return a cryptography public key object.
+    """
+    if len(pubkey_bytes) != 64:
+        raise ValueError("Peer identity pubkey must be exactly 64 bytes (x||y).")
+    x_int = int.from_bytes(pubkey_bytes[:32], byteorder='big')
+    y_int = int.from_bytes(pubkey_bytes[32:], byteorder='big')
+    public_numbers = ec.EllipticCurvePublicNumbers(x_int, y_int, ec.SECP256R1())
+    return public_numbers.public_key()
+
+
+def sign_data(private_key, data: bytes) -> bytes:
+    """
+    Sign 'data' with ECDSA using P-256 private key.
+    Returns DER-encoded signature (variable length, up to ~70-72 bytes).
+    """
+    signature = private_key.sign(data, ec.ECDSA(hashes.SHA256()))
+    return signature
+
+
+def verify_signature(public_key, signature: bytes, data: bytes) -> bool:
+    """
+    Verify DER-encoded ECDSA signature with the given public key.
+    Return True if valid, False otherwise.
+    """
+    try:
+        public_key.verify(signature, data, ec.ECDSA(hashes.SHA256()))
+        return True
+    except InvalidSignature:
+        return False
+
+
+def get_ephemeral_keypair():
+    """
+    Generate ephemeral ECDH keypair (P-256).
+    Return (private_key, pubkey_bytes).
+    """
+    private_key = ec.generate_private_key(ec.SECP256R1())
+    numbers = private_key.public_key().public_numbers()
+    x_bytes = numbers.x.to_bytes(32, 'big')
+    y_bytes = numbers.y.to_bytes(32, 'big')
+    return private_key, x_bytes + y_bytes  # 64 bytes
+
+
+def compute_ecdh_shared_key(private_key, peer_pubkey_bytes: bytes) -> bytes:
+    """
+    Given a local ECDH private_key and the peer's ephemeral pubkey (64 bytes),
+    compute the shared secret.
+    """
+    x_int = int.from_bytes(peer_pubkey_bytes[:32], 'big')
+    y_int = int.from_bytes(peer_pubkey_bytes[32:], 'big')
+    peer_public_numbers = ec.EllipticCurvePublicNumbers(x_int, y_int, ec.SECP256R1())
+    peer_public_key = peer_public_numbers.public_key()
+    shared_key = private_key.exchange(ec.ECDH(), peer_public_key)
+    return shared_key

protocol_prototype/messages.py

@@ -0,0 +1,126 @@
+import os
+import struct
+import time
+import zlib
+
+
+def crc32_of(data: bytes) -> int:
+    """
+    Compute CRC-32 of 'data'.
+    """
+    return zlib.crc32(data) & 0xffffffff
+
+
+# -----------------------------------------------------------------------------
+# Ping
+# -----------------------------------------------------------------------------
+
+def build_ping_request(version: int = 0) -> bytes:
+    """
+    Build a Ping request:
+      - Nonce (32 bytes)
+      - Version (1 byte)
+      - CRC-32 (4 bytes)
+    Total = 37 bytes
+    """
+    nonce = os.urandom(32)
+    partial = nonce + struct.pack("!B", version)
+    crc_val = crc32_of(partial)
+    return partial + struct.pack("!I", crc_val)
+
+
+def parse_ping_request(data: bytes):
+    """
+    Parse a Ping request (37 bytes).
+    Return (nonce, version) or None if invalid.
+    """
+    if len(data) != 37:
+        return None
+    nonce = data[:32]
+    version = data[32]
+    crc_in = struct.unpack("!I", data[33:37])[0]
+    partial = data[:33]
+    crc_calc = crc32_of(partial)
+    if crc_calc != crc_in:
+        return None
+    return (nonce, version)
+
+
+def build_ping_response(version: int, answer_code: int) -> bytes:
+    """
+    Build a Ping response:
+      - Timestamp (8 bytes)
+      - Version (1 byte)
+      - Answer code (1 byte)
+      - CRC-32 (4 bytes)
+    Total = 14 bytes
+    """
+    timestamp = struct.pack("!d", time.time())
+    partial = timestamp + struct.pack("!B", version) + struct.pack("!B", answer_code)
+    crc_val = crc32_of(partial)
+    return partial + struct.pack("!I", crc_val)
+
+
+def parse_ping_response(data: bytes):
+    """
+    Parse a Ping response (14 bytes).
+    Return (timestamp, version, answer_code) or None if invalid.
+    """
+    if len(data) != 14:
+        return None
+    timestamp = struct.unpack("!d", data[:8])[0]
+    version = data[8]
+    answer_code = data[9]
+    crc_in = struct.unpack("!I", data[10:14])[0]
+    partial = data[:10]
+    crc_calc = crc32_of(partial)
+    if crc_calc != crc_in:
+        return None
+    return (timestamp, version, answer_code)
+
+
+# -----------------------------------------------------------------------------
+# Handshake
+# -----------------------------------------------------------------------------
+
+def build_handshake_message(ephemeral_pubkey: bytes, ephemeral_signature: bytes, timestamp: float) -> bytes:
+    """
+    Build a handshake message:
+      - ephemeral_pubkey (64 bytes)
+      - ephemeral_signature (72 bytes, DER + zero-pad)
+      - timestamp (8 bytes)
+      - CRC-32 (4 bytes)
+    Total = 148 bytes
+    """
+    if len(ephemeral_pubkey) != 64:
+        raise ValueError("ephemeral_pubkey must be 64 bytes")
+    if len(ephemeral_signature) > 72:
+        raise ValueError("ephemeral_signature too large")
+
+    sig_padded = ephemeral_signature.ljust(72, b'\x00')
+    ts_bytes = struct.pack("!d", timestamp)
+    partial = ephemeral_pubkey + sig_padded + ts_bytes
+    crc_val = crc32_of(partial)
+    return partial + struct.pack("!I", crc_val)
+
+
+def parse_handshake_message(data: bytes):
+    """
+    Parse a handshake message (148 bytes).
+    Return (ephemeral_pubkey, ephemeral_signature, timestamp) or None if invalid.
+    """
+    if len(data) != 148:
+        return None
+    ephemeral_pubkey = data[:64]
+    sig_padded = data[64:136]
+    ts_bytes = data[136:144]
+    crc_in = struct.unpack("!I", data[144:148])[0]
+
+    partial = data[:144]
+    crc_calc = crc32_of(partial)
+    if crc_calc != crc_in:
+        return None
+
+    ephemeral_signature = sig_padded.rstrip(b'\x00')
+    timestamp = struct.unpack("!d", ts_bytes)[0]
+    return (ephemeral_pubkey, ephemeral_signature, timestamp)

protocol_prototype/protocol.py

@@ -0,0 +1,354 @@
+import random
+import time
+import threading
+from typing import List, Dict, Any
+
+from crypto_utils import (
+    generate_identity_keys,
+    load_peer_identity_key,
+    sign_data,
+    verify_signature,
+    get_ephemeral_keypair,
+    compute_ecdh_shared_key
+)
+from messages import (
+    build_ping_request, parse_ping_request,
+    build_ping_response, parse_ping_response,
+    build_handshake_message, parse_handshake_message
+)
+import transmission
+
+# ANSI colors for pretty printing
+RED = "\033[91m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+BLUE = "\033[94m"
+RESET = "\033[0m"
+
+
+class IcingProtocol:
+    def __init__(self):
+        # Identity keys
+        self.identity_privkey, self.identity_pubkey = generate_identity_keys()
+
+        # Peer identity (public key) for verifying ephemeral signatures
+        self.peer_identity_pubkey_obj = None
+        self.peer_identity_pubkey_bytes = None
+
+        # Ephemeral keys (our side)
+        self.ephemeral_privkey = None
+        self.ephemeral_pubkey = None
+
+        # Store the last computed shared secret (hex) from ECDH
+        self.shared_secret = None
+
+        # Track open connections
+        self.connections = []
+
+        # A random listening port
+        self.local_port = random.randint(30000, 40000)
+
+        # Inbound messages are stored for manual or auto handling
+        # Each entry: { 'type': str, 'raw': bytes, 'parsed': Any, 'connection': PeerConnection }
+        self.inbound_messages: List[Dict[str, Any]] = []
+
+        # Simple dictionary to track protocol flags
+        self.state = {
+            "ping_sent": False,
+            "ping_received": False,
+            "handshake_sent": False,
+            "handshake_received": False,
+        }
+
+        # Auto-responder toggle
+        self.auto_responder = False
+
+        # Start the listener
+        self.server_listener = transmission.ServerListener(
+            host="127.0.0.1",
+            port=self.local_port,
+            on_new_connection=self.on_new_connection,
+            on_data_received=self.on_data_received
+        )
+        self.server_listener.start()
+
+    # -------------------------------------------------------------------------
+    # Transport callbacks
+    # -------------------------------------------------------------------------
+
+    def on_new_connection(self, conn: transmission.PeerConnection):
+        print(f"{GREEN}[IcingProtocol]{RESET} New incoming connection.")
+        self.connections.append(conn)
+
+    def on_data_received(self, conn: transmission.PeerConnection, data: bytes):
+        """
+        Called whenever data arrives on any open PeerConnection.
+        We'll parse and store the message, then handle automatically if auto_responder is on.
+        """
+        # Print data size in bits, not bytes
+        bits_count = len(data) * 8
+        print(f"{GREEN}[RECV]{RESET} {bits_count} bits from peer: {data.hex()[:60]}{'...' if len(data.hex())>60 else ''}")
+
+        # Attempt to parse Ping request
+        if len(data) == 37:
+            parsed = parse_ping_request(data)
+            if parsed:
+                nonce, version = parsed
+                self.state["ping_received"] = True
+                index = len(self.inbound_messages)
+                msg = {
+                    "type": "PING_REQUEST",
+                    "raw": data,
+                    "parsed": {"nonce": nonce, "version": version},
+                    "connection": conn
+                }
+                self.inbound_messages.append(msg)
+                print(f"{YELLOW}[NOTICE]{RESET} Stored inbound PING request (nonce={nonce.hex()}) at index={index}.")
+
+                if self.auto_responder:
+                    # Schedule an automatic response after 2 seconds
+                    threading.Timer(2.0, self._auto_respond_ping, args=(index,)).start()
+
+                return
+
+        # Attempt to parse Ping response
+        if len(data) == 14:
+            parsed = parse_ping_response(data)
+            if parsed:
+                ts, version, answer_code = parsed
+                index = len(self.inbound_messages)
+                msg = {
+                    "type": "PING_RESPONSE",
+                    "raw": data,
+                    "parsed": {"timestamp": ts, "version": version, "answer_code": answer_code},
+                    "connection": conn
+                }
+                self.inbound_messages.append(msg)
+                print(f"{YELLOW}[NOTICE]{RESET} Stored inbound PING response (answer_code={answer_code}) at index={index}.")
+                return
+
+        # Attempt to parse handshake
+        if len(data) == 148:
+            parsed = parse_handshake_message(data)
+            if parsed:
+                ephemeral_pub, ephemeral_sig, ts = parsed
+                self.state["handshake_received"] = True
+                index = len(self.inbound_messages)
+                msg = {
+                    "type": "HANDSHAKE",
+                    "raw": data,
+                    "parsed": {
+                        "ephemeral_pub": ephemeral_pub,
+                        "ephemeral_sig": ephemeral_sig,
+                        "timestamp": ts
+                    },
+                    "connection": conn
+                }
+                self.inbound_messages.append(msg)
+                print(f"{YELLOW}[NOTICE]{RESET} Stored inbound HANDSHAKE at index={index}. ephemeral_pub={ephemeral_pub.hex()[:20]}...")
+
+                if self.auto_responder:
+                    # Schedule an automatic handshake "response" after 2 seconds
+                    threading.Timer(2.0, self._auto_respond_handshake, args=(index,)).start()
+
+                return
+
+        # Otherwise, unrecognized
+        index = len(self.inbound_messages)
+        msg = {
+            "type": "UNKNOWN",
+            "raw": data,
+            "parsed": None,
+            "connection": conn
+        }
+        self.inbound_messages.append(msg)
+        print(f"{RED}[WARNING]{RESET} Unrecognized or malformed message stored at index={index}.")
+
+    # -------------------------------------------------------------------------
+    # Auto-responder helpers
+    # -------------------------------------------------------------------------
+
+    def _auto_respond_ping(self, index: int):
+        """
+        Called by a Timer to respond automatically to a PING_REQUEST after 2s.
+        """
+        print(f"{BLUE}[AUTO]{RESET} Delayed responding to PING at index={index}")
+        self.respond_to_ping(index, answer_code=0)
+        self.show_state()
+
+    def _auto_respond_handshake(self, index: int):
+        """
+        Called by a Timer to handle inbound HANDSHAKE automatically.
+        1) Generate ephemeral keys if not already set
+        2) Compute ECDH with the inbound ephemeral pub (generate_ecdhe)
+        3) Send our handshake back
+        4) Show state
+        """
+        print(f"{BLUE}[AUTO]{RESET} Delayed ECDH process for HANDSHAKE at index={index}")
+
+        # 1) Generate ephemeral keys if we don't have them
+        if not self.ephemeral_privkey or not self.ephemeral_pubkey:
+            self.generate_ephemeral_keys()
+
+        # 2) Compute ECDH from inbound ephemeral pub
+        self.generate_ecdhe(index)
+
+        # 3) Send our handshake to the peer
+        self.send_handshake()
+
+        # 4) Show final state
+        self.show_state()
+
+    # -------------------------------------------------------------------------
+    # Public Methods
+    # -------------------------------------------------------------------------
+
+    def connect_to_peer(self, port: int):
+        conn = transmission.connect_to_peer("127.0.0.1", port, self.on_data_received)
+        self.connections.append(conn)
+        print(f"{GREEN}[IcingProtocol]{RESET} Outgoing connection to port {port} established.")
+
+    def set_peer_identity(self, peer_pubkey_hex: str):
+        pubkey_bytes = bytes.fromhex(peer_pubkey_hex)
+        self.peer_identity_pubkey_obj = load_peer_identity_key(pubkey_bytes)
+        self.peer_identity_pubkey_bytes = pubkey_bytes
+        print(f"{GREEN}[IcingProtocol]{RESET} Stored peer identity pubkey (hex={peer_pubkey_hex[:16]}...).")
+
+    def generate_ephemeral_keys(self):
+        self.ephemeral_privkey, self.ephemeral_pubkey = get_ephemeral_keypair()
+        print(f"{GREEN}[IcingProtocol]{RESET} Generated ephemeral key pair: pubkey={self.ephemeral_pubkey.hex()[:16]}...")
+
+    def send_ping_request(self):
+        if not self.connections:
+            print(f"{RED}[ERROR]{RESET} No active connections.")
+            return
+        pkt = build_ping_request(version=0)
+        self._send_packet(self.connections[0], pkt, "PING_REQUEST")
+        self.state["ping_sent"] = True
+
+    def send_handshake(self):
+        """
+        Build and send a handshake message with ephemeral keys.
+        """
+        if not self.connections:
+            print(f"{RED}[ERROR]{RESET} No active connections.")
+            return
+        if not self.ephemeral_privkey or not self.ephemeral_pubkey:
+            print(f"{RED}[ERROR]{RESET} Ephemeral keys not generated. Call 'generate_ephemeral_keys' first.")
+            return
+
+        ephemeral_signature = sign_data(self.identity_privkey, self.ephemeral_pubkey)
+        ts_now = time.time()
+        pkt = build_handshake_message(self.ephemeral_pubkey, ephemeral_signature, ts_now)
+        self._send_packet(self.connections[0], pkt, "HANDSHAKE")
+        self.state["handshake_sent"] = True
+
+    def enable_auto_responder(self, enable: bool):
+        self.auto_responder = enable
+        print(f"{BLUE}[AUTO]{RESET} Auto responder set to {enable}.")
+
+    # -------------------------------------------------------------------------
+    # Manual Responses
+    # -------------------------------------------------------------------------
+
+    def respond_to_ping(self, index: int, answer_code: int):
+        """
+        Manually respond to an inbound PING_REQUEST in inbound_messages[index].
+        """
+        if index < 0 or index >= len(self.inbound_messages):
+            print(f"{RED}[ERROR]{RESET} Invalid index {index}.")
+            return
+        msg = self.inbound_messages[index]
+        if msg["type"] != "PING_REQUEST":
+            print(f"{RED}[ERROR]{RESET} inbound_messages[{index}] is not a PING_REQUEST.")
+            return
+
+        version = msg["parsed"]["version"]
+        conn = msg["connection"]
+        resp = build_ping_response(version, answer_code)
+        self._send_packet(conn, resp, "PING_RESPONSE")
+        print(f"{BLUE}[MANUAL]{RESET} Responded to ping with answer_code={answer_code}.")
+
+    def generate_ecdhe(self, index: int):
+        """
+        Formerly 'respond_to_handshake' - this verifies the inbound ephemeral signature
+        and computes the ECDH shared secret, storing it in self.shared_secret.
+        It does NOT send a handshake back.
+        """
+        if index < 0 or index >= len(self.inbound_messages):
+            print(f"{RED}[ERROR]{RESET} Invalid index {index}.")
+            return
+        msg = self.inbound_messages[index]
+        if msg["type"] != "HANDSHAKE":
+            print(f"{RED}[ERROR]{RESET} inbound_messages[{index}] is not a HANDSHAKE.")
+            return
+
+        ephemeral_pub = msg["parsed"]["ephemeral_pub"]
+        ephemeral_sig = msg["parsed"]["ephemeral_sig"]
+
+        # Verify ephemeral signature
+        if not self.peer_identity_pubkey_obj:
+            print(f"{RED}[ERROR]{RESET} Peer identity not set, cannot verify ephemeral signature.")
+            return
+        ok = verify_signature(self.peer_identity_pubkey_obj, ephemeral_sig, ephemeral_pub)
+        if not ok:
+            print(f"{RED}[ERROR]{RESET} Ephemeral signature is invalid.")
+            return
+        print(f"{GREEN}[OK]{RESET} Ephemeral signature verified successfully.")
+
+        # If we have ephemeral_privkey, compute ECDH shared key
+        if self.ephemeral_privkey:
+            shared = compute_ecdh_shared_key(self.ephemeral_privkey, ephemeral_pub)
+            self.shared_secret = shared.hex()
+            print(f"{GREEN}[OK]{RESET} Derived ECDH shared key = {self.shared_secret}")
+        else:
+            print(f"{YELLOW}[WARN]{RESET} No ephemeral_privkey available, cannot compute ECDH shared key.")
+
+    # -------------------------------------------------------------------------
+    # Utility
+    # -------------------------------------------------------------------------
+
+    def _send_packet(self, conn: transmission.PeerConnection, data: bytes, label: str):
+        bits_count = len(data) * 8
+        print(f"{BLUE}[SEND]{RESET} {label} -> {bits_count} bits: {data.hex()[:60]}{'...' if len(data.hex())>60 else ''}")
+        conn.send(data)
+
+    def show_state(self):
+        print(f"\n{YELLOW}=== Global State ==={RESET}")
+        print(f"Listening Port: {self.local_port}")
+        print(f"Identity PubKey: {self.identity_pubkey.hex()[:16]}... (64 bytes)")
+        if self.peer_identity_pubkey_bytes:
+            print(f"Peer Identity PubKey: {self.peer_identity_pubkey_bytes.hex()[:16]}... (64 bytes)")
+        else:
+            print("Peer Identity PubKey: [None]")
+
+        print("\nEphemeral Keys:")
+        if self.ephemeral_pubkey:
+            print(f"  ephemeral_pubkey={self.ephemeral_pubkey.hex()[:16]}...")
+        else:
+            print("  ephemeral_pubkey=[None]")
+
+        print(f"\nShared Secret: {self.shared_secret if self.shared_secret else '[None]'}")
+
+        print("\nProtocol Flags:")
+        for k, v in self.state.items():
+            print(f"  {k}: {v}")
+
+        print("\nAuto Responder:", self.auto_responder)
+
+        print("\nActive Connections:")
+        for i, c in enumerate(self.connections):
+            print(f"  [{i}] Alive={c.alive}")
+
+        print("\nInbound Message Queue:")
+        for i, m in enumerate(self.inbound_messages):
+            print(f"  [{i}] type={m['type']} len={len(m['raw'])} bytes")
+        print()
+
+    def stop(self):
+        self.server_listener.stop()
+        for c in self.connections:
+            c.close()
+        self.connections.clear()
+        self.inbound_messages.clear()
+        print(f"{RED}[STOP]{RESET} Protocol stopped.")

protocol_prototype/transmission.py

@@ -0,0 +1,100 @@
+import socket
+import threading
+from typing import Callable
+
+class PeerConnection:
+    """
+    Represents a live, two-way connection to a peer.
+    We keep a socket open, read data in a background thread,
+    and can send data from the main thread at any time.
+    """
+    def __init__(self, sock: socket.socket, on_data_received: Callable[['PeerConnection', bytes], None]):
+        self.sock = sock
+        self.on_data_received = on_data_received
+        self.alive = True
+
+        self.read_thread = threading.Thread(target=self.read_loop, daemon=True)
+        self.read_thread.start()
+
+    def read_loop(self):
+        while self.alive:
+            try:
+                data = self.sock.recv(4096)
+                if not data:
+                    break
+                self.on_data_received(self, data)
+            except OSError:
+                break
+        self.alive = False
+        self.sock.close()
+        print("[PeerConnection] Connection closed.")
+
+    def send(self, data: bytes):
+        if not self.alive:
+            print("[PeerConnection.send] Cannot send, connection not alive.")
+            return
+        try:
+            self.sock.sendall(data)
+        except OSError:
+            print("[PeerConnection.send] Send failed, connection might be closed.")
+            self.alive = False
+
+    def close(self):
+        self.alive = False
+        try:
+            self.sock.shutdown(socket.SHUT_RDWR)
+        except OSError:
+            pass
+        self.sock.close()
+
+
+class ServerListener(threading.Thread):
+    """
+    A thread that listens on a given port. When a new client connects,
+    it creates a PeerConnection for that client.
+    """
+    def __init__(self, host: str, port: int,
+                 on_new_connection: Callable[[PeerConnection], None],
+                 on_data_received: Callable[[PeerConnection, bytes], None]):
+        super().__init__(daemon=True)
+        self.host = host
+        self.port = port
+        self.on_new_connection = on_new_connection
+        self.on_data_received = on_data_received
+        self.server_socket = None
+        self.stop_event = threading.Event()
+
+    def run(self):
+        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.server_socket.bind((self.host, self.port))
+        self.server_socket.listen(5)
+        self.server_socket.settimeout(1.0)
+        print(f"[ServerListener] Listening on {self.host}:{self.port}")
+
+        while not self.stop_event.is_set():
+            try:
+                client_sock, addr = self.server_socket.accept()
+                print(f"[ServerListener] Accepted connection from {addr}")
+                conn = PeerConnection(client_sock, self.on_data_received)
+                self.on_new_connection(conn)
+            except socket.timeout:
+                pass
+            except OSError:
+                break
+
+        if self.server_socket:
+            self.server_socket.close()
+
+    def stop(self):
+        self.stop_event.set()
+        if self.server_socket:
+            self.server_socket.close()
+
+
+def connect_to_peer(host: str, port: int,
+                    on_data_received: Callable[[PeerConnection, bytes], None]) -> PeerConnection:
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.connect((host, port))
+    print(f"[connect_to_peer] Connected to {host}:{port}")
+    conn = PeerConnection(sock, on_data_received)
+    return conn