basic udp: need a package defrag/bust layer, IP won't work well

2023-11-13 11:48:42 +03:00
74 changed files with 1478 additions and 1414 deletions
@@ -40,7 +40,3 @@ bin/
 ### Mac OS ###
 .DS_Store
 # More
 .kotlin
 /.idea/workspace.xml
@@ -0,0 +1,8 @@
 # Default ignored files
 /shelf/
 /workspace.xml
 # Editor-based HTTP Client requests
 /httpRequests/
 # Datasource local storage ignored files
 /dataSources/
 /dataSources.local.xml
@@ -1,7 +1,7 @@
 <component name="ArtifactManager">
-  <artifact type="jar" name="kiloparsec-js-0.2.1-SNAPSHOT">
+  <artifact type="jar" name="kiloparsec-js-0.1.0-SNAPSHOT">
    <output-path>$PROJECT_DIR$/build/libs</output-path>
-    <root id="archive" name="kiloparsec-js-0.2.1-SNAPSHOT.jar">
+    <root id="archive" name="kiloparsec-js-0.1.0-SNAPSHOT.jar">
      <element id="module-output" name="kiloparsec.jsMain" />
    </root>
  </artifact>
@@ -1,7 +1,7 @@
 <component name="ArtifactManager">
-  <artifact type="jar" name="kiloparsec-jvm-0.2.1-SNAPSHOT">
+  <artifact type="jar" name="kiloparsec-jvm-0.1.0-SNAPSHOT">
    <output-path>$PROJECT_DIR$/build/libs</output-path>
-    <root id="archive" name="kiloparsec-jvm-0.2.1-SNAPSHOT.jar">
+    <root id="archive" name="kiloparsec-jvm-0.1.0-SNAPSHOT.jar">
      <element id="module-output" name="kiloparsec.jvmMain" />
    </root>
  </artifact>
@@ -0,0 +1,6 @@
 <component name="InspectionProjectProfileManager">
  <profile version="1.0">
    <option name="myName" value="Project Default" />
    <inspection_tool class="ReplaceUntilWithRangeUntil" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
  </profile>
 </component>
@@ -0,0 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="KotlinJpsPluginSettings">
    <option name="version" value="1.9.20" />
  </component>
 </project>
@@ -1,7 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="ExternalStorageConfigurationManager" enabled="true" />
  <component name="FrameworkDetectionExcludesConfiguration">
    <file type="web" url="file://$PROJECT_DIR$" />
  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="corretto-17" project-jdk-type="JavaSDK" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="17 (5)" project-jdk-type="JavaSDK">
    <output url="file://$PROJECT_DIR$/out" />
  </component>
 </project>
@@ -0,0 +1,124 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="Palette2">
    <group name="Swing">
      <item class="com.intellij.uiDesigner.HSpacer" tooltip-text="Horizontal Spacer" icon="/com/intellij/uiDesigner/icons/hspacer.svg" removable="false" auto-create-binding="false" can-attach-label="false">
        <default-constraints vsize-policy="1" hsize-policy="6" anchor="0" fill="1" />
      </item>
      <item class="com.intellij.uiDesigner.VSpacer" tooltip-text="Vertical Spacer" icon="/com/intellij/uiDesigner/icons/vspacer.svg" removable="false" auto-create-binding="false" can-attach-label="false">
        <default-constraints vsize-policy="6" hsize-policy="1" anchor="0" fill="2" />
      </item>
      <item class="javax.swing.JPanel" icon="/com/intellij/uiDesigner/icons/panel.svg" removable="false" auto-create-binding="false" can-attach-label="false">
        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3" />
      </item>
      <item class="javax.swing.JScrollPane" icon="/com/intellij/uiDesigner/icons/scrollPane.svg" removable="false" auto-create-binding="false" can-attach-label="true">
        <default-constraints vsize-policy="7" hsize-policy="7" anchor="0" fill="3" />
      </item>
      <item class="javax.swing.JButton" icon="/com/intellij/uiDesigner/icons/button.svg" removable="false" auto-create-binding="true" can-attach-label="false">
        <default-constraints vsize-policy="0" hsize-policy="3" anchor="0" fill="1" />
        <initial-values>
          <property name="text" value="Button" />
        </initial-values>
      </item>
      <item class="javax.swing.JRadioButton" icon="/com/intellij/uiDesigner/icons/radioButton.svg" removable="false" auto-create-binding="true" can-attach-label="false">
        <default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
        <initial-values>
          <property name="text" value="RadioButton" />
        </initial-values>
      </item>
      <item class="javax.swing.JCheckBox" icon="/com/intellij/uiDesigner/icons/checkBox.svg" removable="false" auto-create-binding="true" can-attach-label="false">
        <default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
        <initial-values>
          <property name="text" value="CheckBox" />
        </initial-values>
      </item>
      <item class="javax.swing.JLabel" icon="/com/intellij/uiDesigner/icons/label.svg" removable="false" auto-create-binding="false" can-attach-label="false">
        <default-constraints vsize-policy="0" hsize-policy="0" anchor="8" fill="0" />
        <initial-values>
          <property name="text" value="Label" />
        </initial-values>
      </item>
      <item class="javax.swing.JTextField" icon="/com/intellij/uiDesigner/icons/textField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
          <preferred-size width="150" height="-1" />
        </default-constraints>
      </item>
      <item class="javax.swing.JPasswordField" icon="/com/intellij/uiDesigner/icons/passwordField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
          <preferred-size width="150" height="-1" />
        </default-constraints>
      </item>
      <item class="javax.swing.JFormattedTextField" icon="/com/intellij/uiDesigner/icons/formattedTextField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
          <preferred-size width="150" height="-1" />
        </default-constraints>
      </item>
      <item class="javax.swing.JTextArea" icon="/com/intellij/uiDesigner/icons/textArea.svg" removable="false" auto-create-binding="true" can-attach-label="true">
        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
          <preferred-size width="150" height="50" />
        </default-constraints>
      </item>
      <item class="javax.swing.JTextPane" icon="/com/intellij/uiDesigner/icons/textPane.svg" removable="false" auto-create-binding="true" can-attach-label="true">
        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
          <preferred-size width="150" height="50" />
        </default-constraints>
      </item>
      <item class="javax.swing.JEditorPane" icon="/com/intellij/uiDesigner/icons/editorPane.svg" removable="false" auto-create-binding="true" can-attach-label="true">
        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
          <preferred-size width="150" height="50" />
        </default-constraints>
      </item>
      <item class="javax.swing.JComboBox" icon="/com/intellij/uiDesigner/icons/comboBox.svg" removable="false" auto-create-binding="true" can-attach-label="true">
        <default-constraints vsize-policy="0" hsize-policy="2" anchor="8" fill="1" />
      </item>
      <item class="javax.swing.JTable" icon="/com/intellij/uiDesigner/icons/table.svg" removable="false" auto-create-binding="true" can-attach-label="false">
        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
          <preferred-size width="150" height="50" />
        </default-constraints>
      </item>
      <item class="javax.swing.JList" icon="/com/intellij/uiDesigner/icons/list.svg" removable="false" auto-create-binding="true" can-attach-label="false">
        <default-constraints vsize-policy="6" hsize-policy="2" anchor="0" fill="3">
          <preferred-size width="150" height="50" />
        </default-constraints>
      </item>
      <item class="javax.swing.JTree" icon="/com/intellij/uiDesigner/icons/tree.svg" removable="false" auto-create-binding="true" can-attach-label="false">
        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
          <preferred-size width="150" height="50" />
        </default-constraints>
      </item>
      <item class="javax.swing.JTabbedPane" icon="/com/intellij/uiDesigner/icons/tabbedPane.svg" removable="false" auto-create-binding="true" can-attach-label="false">
        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
          <preferred-size width="200" height="200" />
        </default-constraints>
      </item>
      <item class="javax.swing.JSplitPane" icon="/com/intellij/uiDesigner/icons/splitPane.svg" removable="false" auto-create-binding="false" can-attach-label="false">
        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
          <preferred-size width="200" height="200" />
        </default-constraints>
      </item>
      <item class="javax.swing.JSpinner" icon="/com/intellij/uiDesigner/icons/spinner.svg" removable="false" auto-create-binding="true" can-attach-label="true">
        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
      </item>
      <item class="javax.swing.JSlider" icon="/com/intellij/uiDesigner/icons/slider.svg" removable="false" auto-create-binding="true" can-attach-label="false">
        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
      </item>
      <item class="javax.swing.JSeparator" icon="/com/intellij/uiDesigner/icons/separator.svg" removable="false" auto-create-binding="false" can-attach-label="false">
        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3" />
      </item>
      <item class="javax.swing.JProgressBar" icon="/com/intellij/uiDesigner/icons/progressbar.svg" removable="false" auto-create-binding="true" can-attach-label="false">
        <default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1" />
      </item>
      <item class="javax.swing.JToolBar" icon="/com/intellij/uiDesigner/icons/toolbar.svg" removable="false" auto-create-binding="false" can-attach-label="false">
        <default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1">
          <preferred-size width="-1" height="20" />
        </default-constraints>
      </item>
      <item class="javax.swing.JToolBar$Separator" icon="/com/intellij/uiDesigner/icons/toolbarSeparator.svg" removable="false" auto-create-binding="false" can-attach-label="false">
        <default-constraints vsize-policy="0" hsize-policy="0" anchor="0" fill="1" />
      </item>
      <item class="javax.swing.JScrollBar" icon="/com/intellij/uiDesigner/icons/scrollbar.svg" removable="false" auto-create-binding="true" can-attach-label="false">
        <default-constraints vsize-policy="6" hsize-policy="0" anchor="0" fill="2" />
      </item>
    </group>
  </component>
 </project>
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
  </component>
 </project>
@@ -1,171 +0,0 @@
 # Kiloparsec
 The new generation of __PARanoid SECurity__ protocol, advanced, faster, more secure. It also allows connecting any "block device" transport to the same local interface. Out if the box it
 provides the following transports:
 | name           | JVM | JS | native |
 |----------------|-----|----|--------|
 | TCP/IP server  | *   |    |        |
 | TCP/IP client  | *   |    |        |
 | Websock server | *   |    |        |
 | Websock client | *   | *  | *      |
 At the moment we're working on supporting TCP/IP on most native targets. This feature is planned to rach public beta in August and production in early september 2024.
 ## TCP/IP transport
 It is the fastest. JVM implementation uses nio2 async sockets and optimizes TCP socket to play
 well with blocks (smart NO_DELAY mode). It is multiplatform, nut lacks of async TCP/IP support
 on natvic targetm this is where I need help having little time. I'd prefer to use something asyn like UV on native targets.
 I know no existing way to implement it in KotlinJS for the modern browsers.
 ## Websock server
 While it is much slower than pure TCP, it is still faster than any http-based transport. It uses binary frames based on the Ktor server framework to easily integrate with web services. We recommend using it instead of a classic HTTP API as it beats it in terms of speed and server load even with HTTP/2.
 We recommend to create the `KiloInterface<S>` instance and connect it to the websock and tcp servers in real applications to get easy access from anywhere.
 # Usage
 Th elibrary should be used as maven dependency, not as source.
 ## Adding dependency
 ### Declare maven repository:
 Add the private repository to your `build.gradle.kts`, like:
 ```kotlin
 repositories {
    maven("https://gitea.sergeych.net/api/packages/SergeychWorks/maven")
 }
 ```
 ### Add dependency block
 It could be, depending on your project structure, something like:
 ```kotlin
 val commonMain by getting {
    dependencies {
        api("net.sergeych:kiloparsec:0.2.3")
    }
 }
 ```
 ## Create shared interface for your server and the client
 It could be a multiplatform library that exports it or just a shared or copied source file declaring structures
 and functions available, like:
 ```kotlin
 // Api.kt
@Serializable
 class FooArgs(val text: String,val number: Int = 42)
 // Server-side interface
 val cmdSetFoo by command<FooArgs,Unit>()
 val cmdGetFoo by command<Unit,FooArgs>()
 val cmdPing by command<String,String>()
 val cmdCheckConnected by command<Unit,Boolean>()
 // client-side interface (called from the server)
 val cmdPushClient by command<String,Unit>()
 ```
 ## Call it from the client:
 Remember, we need to implement client interface `cmdPushClient` in our example, so we need to provide
 local interace too:
 ```kotlin
 // Unit: no session on the client:
 val client = websocketClient<Unit>("wss://your.host.com/kp") {
    // This is server-callable function we export:
    on(cmdPushClient) {
        "server push: $it"
    }
 }
 // If we want to collect connected state changes (this is optional)
 launch {
    client.connectedStateFlow.collect {
        if( it )
            println("I am connected")
        else
            println("trying to connect...")
    }
 }
 // now we can call server's functions
 client.call(cmdSetFoo, FooArgs("bar", 117))
 assertEquals(FooArgs("bar", 117), client.call(cmdGetFoo))
 ```
 ## Create ktor-based server
 Normally server side needs some session. It is convenient and avoid sending repeating data on each request speeding up
 the protocol. With KILOPARSEC it is rather basic operation:\
 ~~~kotlin
 // Our session just keeps Foo for cmd{Get|Set}Foo:
 data class Session(var fooState: FooArgs?=null)
 // Let's now provide interface we export, it will be used on each connection automatically:
 // Note server interface uses Session:
 val serverInterface = KiloInterface<Session>().apply {
    onConnected { 
        // Do some initialization
        session.fooState = null
    }
    // Exceptions are passed through the network and re-created (re-thrown) on other side:
    on(cmdGetFoo) { session.fooState ?: throw IllegalStateException("foo is not yet set") }
    on(cmdSetFoo) { session.fooState = it }
 }
 // now create server using ktor (see ktor project for more):
 val ns: NettyApplicationEngine = embeddedServer(Netty, port = 8080, host = "0.0.0.0", module = {
    setupWebsocketServer(serverInterface) { Session() }
 }).start(wait = false)
 ~~~
 # Details
 It is not compatible with parsec family and no more based on an Universa crypto library. To better fit
 the modern state of threats and rate of cyber crimes, KiloParsec uses more encryption and random key exchange on each
 and every connection (while parsec caches session keys to avoid time-consuming keys exchange). For the same reason,
 keys cryptography for session is shifted to use ed25519 curves which are supposed to provide agreeable strength with
 enough speed to protect every connection with a unique new keys. Also, we completely get rid of SHA2.
 Kiloparsec also uses a denser binary format [bipack](https://gitea.sergeych.net/SergeychWorks/mp_bintools), no more key-values, 
 which reveals much less on the inner data structure, providing advanced 
 typed RPC interfaces with kotlinx.serialization. There is also Rust implementation [bipack_ru](https://gitea.sergeych.net/DiWAN/bipack_ru). 
 The architecture allows connecting same functional interfaces to several various type channels at once.
 Also, the difference from parsecs is that there are no more unencrypted layer commands available to users. 
 All RPC is performed over the encrypted connection.
 # Technical description
 Kiloparsec is a dull-duplex fully async (coroutine based) Remote Procedure Call protocol with typed parameters
 and support for serializing exceptions (e.g. exception thrown while executing remote command will be caught and
 rethrown at the caller context).
 Kiloparsec is not REST, it _has advanced session mechanisms_ and built-in authentication based on the same curve keys.
 Integrated tools to prevent MITM attacks include also non-transferred independently generated token that is calculated
 independently on the ends and is never transferred with the network. Comparing it somehow (visually, with QR code, etc)
 could add a very robust guarantee of the connection safety and ingenuity.
 Kiloparsec has built-in completely asynchronous (coroutine based top-down) transport layer based on TCP (JVM only as for now) and the same async Websocket-based transport based on KTOR. Websocket client is multiplatform, though the server is JVM only insofar.
 # Licensing
 When the project reaches some stable state, it will be available under Apache or MIT license. I promise ;) I do
 write opensource ;)
@@ -1,23 +1,31 @@
 import org.jetbrains.kotlin.gradle.plugin.KotlinJsCompilerType
 plugins {
-    kotlin("multiplatform") version "2.0.0"
+    kotlin("multiplatform") version "1.9.20"
-    id("org.jetbrains.kotlin.plugin.serialization") version "2.0.0"
+    id("org.jetbrains.kotlin.plugin.serialization") version "1.9.20"
    `maven-publish`
 }
 group = "net.sergeych"
-version = "0.2.2-SNAPSHOT"
+version = "0.1.0-SNAPSHOT"
 repositories {
    mavenCentral()
    mavenLocal()
    maven("https://maven.universablockchain.com/")
    maven("https://gitea.sergeych.net/api/packages/SergeychWorks/maven")
 }
 kotlin {
-    jvm()
+    jvm {
-    js(IR) {
+        jvmToolchain(8)
        withJava()
        testRuns.named("test") {
            executionTask.configure {
                useJUnitPlatform()
            }
        }
    }
    js(KotlinJsCompilerType.IR) {
        browser {
 //            commonWebpackConfig {
 //                cssSupport {
@@ -26,29 +34,18 @@ kotlin {
 //            }
        }
    }
-//    val hostOs = System.getProperty("os.name")
+    val hostOs = System.getProperty("os.name")
-//    val isArm64 = System.getProperty("os.arch") == "aarch64"
+    val isArm64 = System.getProperty("os.arch") == "aarch64"
-//    val isMingwX64 = hostOs.startsWith("Windows")
+    val isMingwX64 = hostOs.startsWith("Windows")
-//    @Suppress("UNUSED_VARIABLE")
+    val nativeTarget = when {
-//    val nativeTarget = when {
+        hostOs == "Mac OS X" && isArm64 -> macosArm64("native")
-//        hostOs == "Mac OS X" && isArm64 -> macosArm64("native")
+        hostOs == "Mac OS X" && !isArm64 -> macosX64("native")
-//        hostOs == "Mac OS X" && !isArm64 -> macosX64("native")
+        hostOs == "Linux" && isArm64 -> linuxArm64("native")
-//        hostOs == "Linux" && isArm64 -> linuxArm64("native")
+        hostOs == "Linux" && !isArm64 -> linuxX64("native")
-//        hostOs == "Linux" && !isArm64 -> linuxX64("native")
+        isMingwX64 -> mingwX64("native")
-//        isMingwX64 -> mingwX64("native")
+        else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
-//        else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
+    }
 //    }
 //    macosArm64()
 //    iosX64()
 //    iosArm64()
 //    iosSimulatorArm64()
    linuxX64()
    linuxArm64()
 //    macosX64()
    val ktor_version = "2.3.6"
    sourceSets {
        all {
@@ -60,14 +57,13 @@ kotlin {
        val commonMain by getting {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
-                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.1")
+                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.1")
-//                api("com.ionspin.kotlin:bignum:0.3.9")
+                implementation("com.ionspin.kotlin:multiplatform-crypto-libsodium-bindings:0.9.0")
-                api("io.ktor:ktor-client-core:$ktor_version")
+                api("com.ionspin.kotlin:bignum:0.3.8")
-//                api("net.sergeych:mp_bintools:0.1.1")
+                api("net.sergeych:mp_bintools:0.0.6-SNAPSHOT")
-//                api("net.sergeych:mp_stools:1.4.7")
+                api("net.sergeych:mp_stools:1.4.1")
                api("net.sergeych:crypto2:0.4.1-SNAPSHOT")
            }
        }
        val commonTest by getting {
@@ -77,45 +73,11 @@ kotlin {
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3")
            }
        }
-        val jvmMain by getting {
+        val jvmMain by getting
            dependencies {
                implementation("io.ktor:ktor-server-core:$ktor_version")
                implementation("io.ktor:ktor-server-core-jvm:$ktor_version")
                implementation("io.ktor:ktor-server-websockets-jvm:$ktor_version")
                implementation("io.ktor:ktor-server-netty:$ktor_version")
                api("io.ktor:ktor-client-cio:$ktor_version")
            }
        }
        val jvmTest by getting
-        val jsMain by getting {
+        val jsMain by getting
            dependencies {
                implementation("io.ktor:ktor-client-js:$ktor_version")
            }
        }
        val jsTest by getting
-//        val nativeMain by getting {
+        val nativeMain by getting
-//            dependencies {
+        val nativeTest by getting
 //                implementation("io.ktor:ktor-client-cio:$ktor_version")
 //            }
 //        }
 //        val nativeTest by getting
    }
    publishing {
        val mavenToken by lazy {
            File("${System.getProperty("user.home")}/.gitea_token").readText()
        }
        repositories {
            maven {
                credentials(HttpHeaderCredentials::class) {
                    name = "Authorization"
                    value = mavenToken
                }
                url = uri("https://gitea.sergeych.net/api/packages/SergeychWorks/maven")
                authentication {
                    create("Authorization", HttpHeaderAuthentication::class)
                }
            }
        }
    }
 }
@@ -0,0 +1,27 @@
 package net.sergeych.crypto
 import com.ionspin.kotlin.crypto.LibsodiumInitializer
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 private var isReady = false
 private val readyAccess = Mutex()
 /**
 * Library initialization: should be called before all other calls.
 * It is safe and with little performance penalty to call it multiple times.
 */
 suspend fun initCrypto() {
    // faster to check with no lock
    if( !isReady) {
        readyAccess.withLock {
            // recheck with lock, it could be ready by now
            if( !isReady ) {
                LibsodiumInitializer.initialize()
                isReady = true
            }
        }
    }
 }
@@ -0,0 +1,81 @@
 package net.sergeych.crypto
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
 /**
 * Multi-signed data box. Use [SignedBox.invoke] to easily create
 * instances and [SignedBox.plus] to add more signatures (signing keys), and
 * [SignedBox.contains] to check for a specific key signature presence.
 *
 * It is serializable and checks integrity on deserialization. If any of seals does not
 * match the signed [message], it throws [IllegalSignatureException] _on deserialization_.
 * E.g., if you have it deserialized, it is ok, check it contains all needed keys among
 * signers.
 *
 * __The main constructor is used for deserializing only__. Don't use it directly unless you
 * know what you are doing as it may be dangerous.Use one of the above to create or change it.
 */
@Serializable
 class SignedBox(
    val message: UByteArray,
    private val seals: List<Seal>,
    @Transient
    private val checkOnInit: Boolean = true
 ) {
    /**
     * If this instance is not signed by a given key, return new instance signed also by this
     * key, or return unchanged (same) object if it is already signed by this key; you
     * _can't assume it always returns a copied object!_
     */
    operator fun plus(key: Key.Signing): SignedBox =
        if (key.verifying in this) this
        else SignedBox(message, seals + Seal.create(key, message), false)
    /**
     * Check that it is signed with a specified key.
     */
    operator fun contains(verifyingKey: Key.Verifying): Boolean {
        return seals.any { it.key == verifyingKey }
    }
    init {
        if (seals.isEmpty()) throw IllegalArgumentException("there should be at least one seal")
        if (checkOnInit) {
            if (!seals.all { it.verify(message) }) throw IllegalSignatureException()
        }
    }
    /**
     * A key + signature pair for [SignedBox] boxes, usually you don't use it
     * directly bug call [SignedBox] constructor or [SignedBox.plus] to
     * add seals.
     */
    @Serializable
    data class Seal(val key: Key.Verifying, val signature: UByteArray) {
        fun verify(message: UByteArray): Boolean = key.verify(signature, message)
        companion object {
            fun create(key: Key.Signing, message: UByteArray): Seal {
                return Seal(key.verifying, key.sign(message))
            }
        }
    }
    companion object {
        /**
         * Create a new instance with a specific data sealed by one or more
         * keys. At least one key is required to disallow providing not-signed
         * instances, e.g. [SignedBox] is guaranteed to be properly sealed when
         * successfully instantiated.
         *
         * @param data a message to sign
         * @param keys a list of keys to sign with, should be at least one key.
         * @throws IllegalArgumentException if keys are not specified.
         */
        operator fun invoke(data: UByteArray, vararg keys: Key.Signing): SignedBox =
            SignedBox(data, keys.map { Seal.create(it, data) }, false)
    }
 }
@@ -0,0 +1,7 @@
 package net.sergeych.crypto
 import net.sergeych.bintools.CRC
 fun isValidContrail(data: UByteArray): Boolean = CRC.crc8(data.copyOfRange(1, data.size)) == data[0]
 fun createContrail(data: UByteArray): UByteArray = ubyteArrayOf(CRC.crc8(data)) + data
@@ -0,0 +1,75 @@
 package net.sergeych.crypto
 import com.ionspin.kotlin.crypto.signature.InvalidSignatureException
 import com.ionspin.kotlin.crypto.signature.Signature
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import net.sergeych.crypto.Key.Signing
 /**
 * Keys in general: public, secret and later symmetric too.
 * Keys could be compared to each other for equality and used
 * as a Map keys (not sure about js).
 *
 * Use [Signing.pair] to create new keys.
 */
@Serializable
 sealed class Key {
    abstract val packed: UByteArray
    override fun equals(other: Any?): Boolean {
        return other is Key && other.packed contentEquals packed
    }
    override fun hashCode(): Int {
        return packed.contentHashCode()
    }
    override fun toString(): String = packed.encodeToBase64Url()
    /**
     * Public key to verify signatures only
     */
    @Serializable
    @SerialName("pvk")
    class Verifying(override val packed: UByteArray) : Key() {
        /**
         * Verify the signature and return true if it is correct.
         */
        fun verify(signature: UByteArray, message: UByteArray): Boolean = try {
            Signature.verifyDetached(signature, message, packed)
            true
        } catch (_: InvalidSignatureException) {
            false
        }
        override fun toString(): String = "Pub:${super.toString()}"
    }
    /**
     * Secret key to sign only
     */
    @Serializable
    @SerialName("ssk")
    class Signing(override val packed: UByteArray) : Key() {
        val verifying: Verifying by lazy {
            Verifying(Signature.ed25519SkToPk(packed))
        }
        fun sign(message: UByteArray): UByteArray = Signature.detached(message, packed)
        override fun toString(): String = "Sct:${super.toString()}"
        companion object {
            data class Pair(val signing: Signing, val verifying: Verifying)
            fun pair(): Pair {
                val p = Signature.keypair()
                return Pair(Signing(p.secretKey), Verifying(p.publicKey))
            }
        }
    }
 }
 class IllegalSignatureException: RuntimeException("signed data is tampered or signature is corrupted")
@@ -0,0 +1,85 @@
@file:Suppress("unused")
 package net.sergeych.crypto
 import com.ionspin.kotlin.crypto.secretbox.SecretBox
 import com.ionspin.kotlin.crypto.secretbox.crypto_secretbox_NONCEBYTES
 import com.ionspin.kotlin.crypto.util.LibsodiumRandom
 import kotlinx.serialization.Serializable
 import net.sergeych.bintools.toDataSource
 import net.sergeych.bipack.BipackDecoder
 import net.sergeych.bipack.BipackEncoder
 class DecryptionFailedException : RuntimeException("can't encrypt: wrong key or tampered message")
@Serializable
 data class WithNonce(
    val cipherData: UByteArray,
    val nonce: UByteArray,
 )
@Serializable
 data class WithFill(
    val data: UByteArray,
    val safetyFill: UByteArray? = null
 ) {
    constructor(data: UByteArray, fillSize: Int) : this(data, randomBytes(fillSize))
 }
 fun randomBytes(n: Int): UByteArray = if (n > 0) LibsodiumRandom.buf(n) else ubyteArrayOf()
 fun randomBytes(n: UInt): UByteArray = if (n > 0u) LibsodiumRandom.buf(n.toInt()) else ubyteArrayOf()
 /**
 * Uniform random in `0 ..< max` range
 */
 fun randomUInt(max: UInt) = LibsodiumRandom.uniform(max)
 fun randomUInt(max: Int) = LibsodiumRandom.uniform(max.toUInt())
 fun <T: Comparable<T>>T.limit(range: ClosedRange<T>) = when {
    this < range.start -> range.start
    this > range.endInclusive -> range.endInclusive
    else -> this
 }
 fun <T: Comparable<T>>T.limitMax(max: T) = if( this < max ) this else max
 fun <T: Comparable<T>>T.limitMin(min: T) = if( this > min ) this else min
 fun randomNonce(): UByteArray = randomBytes(crypto_secretbox_NONCEBYTES)
 /**
 * Secret-key encrypt with authentication.
 * Generates random nonce and add some random fill to protect
 * against some analysis attacks. Nonce is included in the result. To be
 * used with [decrypt].
 * @param secretKey a _secret_ key, see [SecretBox.keygen()] or like.
 * @param plain data to encrypt
 * @param fillSize number of random fill data to add. Use random value or default.
 */
 fun encrypt(
    secretKey: UByteArray,
    plain: UByteArray,
    fillSize: Int = randomUInt((plain.size * 3 / 10).limitMin(3)).toInt()
 ): UByteArray {
    val filled = BipackEncoder.encode(WithFill(plain, fillSize))
    val nonce = randomNonce()
    val encrypted = SecretBox.easy(filled.toUByteArray(), nonce, secretKey)
    return BipackEncoder.encode(WithNonce(encrypted, nonce)).toUByteArray()
 }
 /**
 * Decrypt a secret-key-based message, normally encrypted with [encrypt].
 * @throws DecryptionFailedException if the key is wrong or a message is tampered with (MAC
 *          check failed).
 */
 fun decrypt(secretKey: UByteArray, cipher: UByteArray): UByteArray {
    val wn: WithNonce = BipackDecoder.decode(cipher.toDataSource())
    try {
        return BipackDecoder.decode<WithFill>(
            SecretBox.openEasy(wn.cipherData, wn.nonce, secretKey).toDataSource()
        ).data
    }
    catch(_: com.ionspin.kotlin.crypto.secretbox.SecretBoxCorruptedOrTamperedDataExceptionOrInvalidKey) {
        throw DecryptionFailedException()
    }
 }
@@ -0,0 +1,8 @@
 package net.sergeych.crypto
 import net.sergeych.bintools.toDump
 import net.sergeych.mp_tools.encodeToBase64Url
 fun UByteArray.toDump(wide: Boolean = false) = toByteArray().toDump(wide)
 fun UByteArray.encodeToBase64Url(): String = toByteArray().encodeToBase64Url()
@@ -31,8 +31,7 @@ class Command<A, R>(
    suspend fun exec(packedArgs: UByteArray, handler: suspend (A) -> R): UByteArray =
        BipackEncoder.encode(
            resultSerializer,
-            handler(
+            handler(BipackDecoder.decode(packedArgs.toDataSource(), argsSerializer))
                BipackDecoder.decode(packedArgs.toDataSource(), argsSerializer))
        ).toUByteArray()
    companion object {
@@ -7,9 +7,6 @@ import kotlin.reflect.KProperty
 /**
 * delegate returning function that creates a [Command] in the current context which by default has the name of
 * the property.
 *
 * The Default name is a property name except the "cmd" prefix if present, which will be
 * removed automatically.
 */
 inline fun <reified A, reified R> command(overrideName: String? = null): CommandDelegate<A, R> {
    return CommandDelegate(
@@ -25,22 +22,13 @@ inline fun <reified A, reified R> command(overrideName: String? = null): Command
 class CommandDelegate<A, R>(
    private val argsSerializer: KSerializer<A>,
    private val resultSerializer: KSerializer<R>,
-    private val overrideName: String? = null,
+    private val overrideName: String? = null
 ) {
    private var name: String = ""
    operator fun getValue(nothing: Nothing?, property: KProperty<*>): Command<A, R> {
        if (name.isEmpty()) {
            name = overrideName ?: removeCmd(property.name)
        }
        return Command(
-            name,
+            overrideName ?: property.name,
            argsSerializer,
            resultSerializer
        )
    }
 }
 private fun removeCmd(name: String) =
    if (name.startsWith("cmd"))
        name.substring(3)
    else name
@@ -2,14 +2,10 @@ package net.sergeych.kiloparsec
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.isActive
-import kotlinx.coroutines.sync.Mutex
+import net.sergeych.crypto.Key
 import kotlinx.coroutines.sync.withLock
 import net.sergeych.crypto2.SigningKey
 import net.sergeych.crypto2.VerifyingPublicKey
 import net.sergeych.mp_logger.LogTag
 import net.sergeych.mp_logger.Loggable
 import net.sergeych.mp_logger.debug
@@ -23,8 +19,8 @@ import net.sergeych.mp_tools.globalLaunch
 * it manually when it is not needed, otherwise it will continue to reconnect.
 */
 class KiloClient<S>(
-    val localInterface: KiloInterface<S>,
+    localInterface: KiloInterface<S>,
-    secretKey: SigningKey? = null,
+    secretKey: Key.Signing? = null,
    connectionDataFactory: ConnectionDataFactory<S>,
 ) : RemoteInterface,
    Loggable by LogTag("CLIF") {
@@ -36,7 +32,7 @@ class KiloClient<S>(
     * to authenticate a client on connection restore, for example.
     */
    @Suppress("unused")
-    val connectedStateFlow = _state.asStateFlow()
+    val state = _state.asStateFlow()
    private var deferredClient = CompletableDeferred<KiloClientConnection<S>>()
@@ -51,48 +47,27 @@ class KiloClient<S>(
                    val client = KiloClientConnection(localInterface, kc,secretKey)
                    deferredClient.complete(client)
                    client.run {
-                        _state.value = it
+                        _state.value = false
                    }
                    resetDeferredClient()
                    debug { "client run finished" }
                } catch (_: RemoteInterface.ClosedException) {
                    debug { "remote closed" }
                    delay(1000)
                } catch (_: CancellationException) {
                    debug { "cancelled" }
                    break
                } catch (t: Throwable) {
                    exception { "unexpected exception" to t }
                    delay(1000)
                }
                _state.value = false
-                resetDeferredClient()
+                if (deferredClient.isActive)
-                delay(100)
+                    deferredClient = CompletableDeferred()
            }
        }
    fun close() {
        job.cancel()
        debug { "client is closed" }
    }
-    private val defMutex = Mutex()
+    override suspend fun <A, R> call(cmd: Command<A, R>, args: A): R = deferredClient.await().call(cmd, args)
    private suspend fun resetDeferredClient() {
        defMutex.withLock {
            if (!deferredClient.isActive) {
                deferredClient = CompletableDeferred()
            }
        }
    }
    override suspend fun <A, R> call(cmd: Command<A, R>, args: A): R =
        try {
            deferredClient.await().call(cmd, args)
        } catch (t: RemoteInterface.ClosedException) {
            resetDeferredClient()
            throw t
        }
    /**
     * Current session token. This is a per-connection unique random value same on the client and server part so
@@ -102,14 +77,14 @@ class KiloClient<S>(
    suspend fun token() = deferredClient.await().token()
    /**
-     * Remote party shared key ([VerifyingPublicKey]), could be used ti ensure server is what we expected and
+     * Remote party shared key ([Key.Verifying]]), could be used ti ensure server is what we expected and
     * there is no active MITM attack.
     *
     * Non-null value means the key was successfully authenticated, null means remote party did not provide
     * a key. Connection is established either with a properly authenticated key or no key at all.
     */
    @Suppress("unused")
-    suspend fun remoteId(): VerifyingPublicKey? = deferredClient.await().remoteId()
+    suspend fun remoteId() = deferredClient.await().remoteId()
    companion object {
        class Builder<S>() {
@@ -121,7 +96,7 @@ class KiloClient<S>(
            }
            private var connectionBuilder: (suspend () -> Transport.Device)? = null
-            var secretIdKey: SigningKey? = null
+            var secretIdKey: Key.Signing? = null
            /**
             * Build local command implementations (remotely callable ones), exception
@@ -131,21 +106,6 @@ class KiloClient<S>(
                interfaceBuilder = f
            }
            /**
             * Import exception (error) registrations from a shared LocalInterface (usually, server side one) to
             * DRY error registration on both server and client sides.
             * Normally you need to:
             *
             * - Register all your errors in server's LocalInterface
             *
             * - In the client builder call [addErrors(serverLocalInterface]
             *
             * See also [LocalInterface.registerError] for exception registration
             */
            fun addErrors(from: LocalInterface<*>) {
                errorProviders += from
            }
            /**
             * Create a new session object, otherwise Unit session will be used
             */
@@ -157,11 +117,8 @@ class KiloClient<S>(
                connectionBuilder = f
            }
            val errorProviders = mutableListOf<LocalInterface<*>>()
            internal fun build(): KiloClient<S> {
                val i = KiloInterface<S>()
                for (ep in errorProviders) i.addErrorProvider(ep)
                interfaceBuilder?.let { i.it() }
                val connector = connectionBuilder ?: throw IllegalArgumentException("connect handler was not set")
                return KiloClient(i,secretIdKey) {
@@ -1,9 +1,8 @@
 package net.sergeych.kiloparsec
 import com.ionspin.kotlin.crypto.keyexchange.KeyExchange
 import kotlinx.coroutines.*
-import net.sergeych.crypto2.SafeKeyExchange
+import net.sergeych.crypto.Key
 import net.sergeych.crypto2.SigningKey
 import net.sergeych.crypto2.VerifyingPublicKey
 import net.sergeych.mp_logger.LogTag
 import net.sergeych.mp_logger.Loggable
 import net.sergeych.mp_logger.debug
@@ -13,20 +12,20 @@ import net.sergeych.utools.pack
 private var clientIds = 0
 class KiloClientConnection<S>(
-    private val clientInterface: KiloInterface<S>,
+    private val clientInterface: LocalInterface<KiloScope<S>>,
    private val device: Transport.Device,
    private val session: S,
-    private val secretIdKey: SigningKey? = null,
+    private val secretIdKey: Key.Signing? = null,
 ) : RemoteInterface, Loggable by LogTag("KPC:${++clientIds}") {
-    constructor(localInterface: KiloInterface<S>, connection: KiloConnectionData<S>, secretIdKey: SigningKey? = null)
+    constructor(localInterface: KiloInterface<S>, connection: KiloConnectionData<S>, secretIdKey: Key.Signing? = null)
            : this(localInterface, connection.device, connection.session, secretIdKey)
    private val kiloRemoteInterface = CompletableDeferred<KiloRemoteInterface<S>>()
    private val deferredParams = CompletableDeferred<KiloParams<S>>()
-    suspend fun remoteId(): VerifyingPublicKey? = deferredParams.await().remoteIdentity
+    suspend fun remoteId(): Key.Verifying? = deferredParams.await().remoteIdentity
    /**
     * Run the client, blocking until the device is closed, or some critical exception
@@ -38,7 +37,7 @@ class KiloClientConnection<S>(
            var job: Job? = null
            try {
                // in parallel: keys and connection
-                val deferredKeyPair = async { SafeKeyExchange() }
+                val deferredKeyPair = async { KeyExchange.keypair() }
                debug { "opening device" }
                debug { "got a transport device $device" }
@@ -56,21 +55,23 @@ class KiloClientConnection<S>(
                val serverHe = transport.call(L0Request, Handshake(1u, pair.publicKey))
-                val sk = pair.clientSessionKey(serverHe.publicKey)
+                val sk = KeyExchange.clientSessionKeys(pair.publicKey, pair.secretKey, serverHe.publicKey)
                var params = KiloParams(false, transport, sk, session, null, this@KiloClientConnection)
                // Check ID if any
-                serverHe.signature?.let { s ->
+                serverHe.serverSharedKey?.let { k ->
-                    if (!s.isValid(params.token))
+                    if (serverHe.signature == null)
                        throw RemoteInterface.SecurityException("missing signature")
                    if (!k.verify(serverHe.signature, params.token))
                        throw RemoteInterface.SecurityException("wrong signature")
-                    params = params.copy(remoteIdentity = s.publicKey)
+                    params = params.copy(remoteIdentity = k)
                }
                transport.call(
                    L0ClientId, params.encrypt(
                        pack(
                            ClientIdentity(
-                                secretIdKey?.verifyingKey,
+                                secretIdKey?.verifying,
                                secretIdKey?.sign(params.token)
                            )
                        )
@@ -80,14 +81,12 @@ class KiloClientConnection<S>(
                kiloRemoteInterface.complete(
                    KiloRemoteInterface(deferredParams, clientInterface)
                )
                clientInterface.onConnectHandler?.invoke(params.scope)
                onConnectedStateChanged?.invoke(true)
                job.join()
            } catch (x: CancellationException) {
                info { "client is cancelled" }
            } catch (x: RemoteInterface.ClosedException) {
                x.printStackTrace()
                info { "connection closed by remote" }
            } finally {
                onConnectedStateChanged?.invoke(false)
@@ -6,17 +6,11 @@ package net.sergeych.kiloparsec
 *
 * BAse implementation registers relevant exceptions.
 */
-open class KiloInterface<S> : LocalInterface<KiloScope<S>>() {
+class KiloInterface<S> : LocalInterface<KiloScope<S>>() {
    internal var onConnectHandler: (KiloScope<S>.()->Unit) ? = null
    fun onConnected(f: KiloScope<S>.()->Unit) { onConnectHandler = f }
    init {
        registerError { RemoteInterface.UnknownCommand() }
        registerError { RemoteInterface.InternalError(it) }
        registerError { RemoteInterface.ClosedException(it) }
-//        registerError { RemoteInterface.SecurityException(it) }
+        registerError { RemoteInterface.SecurityException(it) }
        registerError { RemoteInterface.InvalidDataException(it) }
        registerError { RemoteInterface.RemoteException(it) }
        registerError { IllegalStateException() }
@@ -1,11 +1,8 @@
 package net.sergeych.kiloparsec
 import kotlinx.coroutines.CompletableDeferred
 import net.sergeych.tools.AtomicCounter
 import net.sergeych.utools.pack
 private val idCounter = AtomicCounter(0)
 /**
 * This class is not normally used directly. This is a local interface that supports
 * secure transport command layer (encrypted calls/results) to work with [KiloRemoteInterface].
@@ -16,9 +13,6 @@ internal class KiloL0Interface<T>(
    private val clientInterface: LocalInterface<KiloScope<T>>,
    private val deferredParams: CompletableDeferred<KiloParams<T>>,
 ): LocalInterface<Unit>() {
    override var logTag: String = "KL0:${idCounter.incrementAndGet()}"
    init {
        // local interface uses the same session as a client:
        addErrorProvider(clientInterface)
@@ -33,10 +27,7 @@ internal class KiloL0Interface<T>(
                    0u,
                    clientInterface.execute(params.scope, call.name, call.serializedArgs)
                )
-            } catch(t: BreakConnectionException) {
+            } catch (t: Throwable) {
                throw t
            }
            catch (t: Throwable) {
                clientInterface.encodeError(0u, t)
            }
            params.encrypt(pack(result))
@@ -1,13 +1,23 @@
 package net.sergeych.kiloparsec
 import com.ionspin.kotlin.crypto.keyexchange.KeyExchangeSessionKeyPair
 import com.ionspin.kotlin.crypto.secretbox.SecretBox
 import com.ionspin.kotlin.crypto.secretbox.crypto_secretbox_NONCEBYTES
 import com.ionspin.kotlin.crypto.util.decodeFromUByteArray
 import com.ionspin.kotlin.crypto.util.encodeToUByteArray
 import kotlinx.serialization.Serializable
 import net.sergeych.bintools.toDataSource
 import net.sergeych.bipack.BipackDecoder
-import net.sergeych.bipack.Unsigned
+import net.sergeych.bipack.BipackEncoder
-import net.sergeych.crypto2.*
+import net.sergeych.crypto.DecryptionFailedException
-import net.sergeych.synctools.ProtectedOp
+import net.sergeych.crypto.Key
-import net.sergeych.synctools.invoke
+import net.sergeych.crypto.randomBytes
 import net.sergeych.crypto.randomUInt
 import net.sergeych.tools.ProtectedOp
 import net.sergeych.utools.pack
 import net.sergeych.utools.unpack
 import org.komputing.khash.keccak.Keccak
 import org.komputing.khash.keccak.KeccakParameter
 import kotlin.math.roundToInt
 /**
@@ -22,18 +32,23 @@ import kotlin.math.roundToInt
 data class KiloParams<S>(
    val isServer: Boolean,
    val transport: RemoteInterface,
-    val sessionKey: SafeKeyExchange.SessionKey,
+    val sessionKeyPair: KeyExchangeSessionKeyPair,
    val scopeSession: S,
-    val remoteIdentity: VerifyingPublicKey?,
+    val remoteIdentity: Key.Verifying?,
-    val remoteTransport: RemoteInterface,
+    val remoteTransport: RemoteInterface
 ) {
    @Serializable
    data class Package(
        @Unsigned
        val nonce: ULong,
        val encryptedMessage: UByteArray,
    )
    @Serializable
    data class FilledData(
        val message: UByteArray,
        val fill: UByteArray,
    )
    private var nonce = 0UL
    val scope: KiloScope<S> by lazy {
@@ -41,39 +56,81 @@ data class KiloParams<S>(
            override val session = scopeSession
            override val remote: RemoteInterface = remoteTransport
            override val sessionToken: UByteArray = token
-            override val remoteIdentity: VerifyingPublicKey? = this@KiloParams.remoteIdentity
+            override val remoteIdentity: Key.Verifying? = this@KiloParams.remoteIdentity
        }
    }
    val token: UByteArray by lazy {
-        blake2b("token_".encodeToUByteArray() + sessionKey.sessionTag).sliceArray(0..<SymmetricKey.nonceLength)
+        val base = if (isServer) sessionKeyPair.sendKey + sessionKeyPair.receiveKey
        else sessionKeyPair.receiveKey + sessionKeyPair.sendKey
        Keccak.digest(
            base.toByteArray(), KeccakParameter.KECCAK_256
        ).toUByteArray().sliceArray(0..<crypto_secretbox_NONCEBYTES)
    }
-    private val numericNonce = NumericNonce(token)
+    private val sendBase by lazy {
        Keccak.digest(
            sessionKeyPair.sendKey.toByteArray(), KeccakParameter.KECCAK_256
        ).toUByteArray().sliceArray(0..<crypto_secretbox_NONCEBYTES)
    }
-    private val protectedOp = ProtectedOp()
+    private val receiveBase by lazy {
        Keccak.digest(
            sessionKeyPair.receiveKey.toByteArray(), KeccakParameter.KECCAK_256
        ).toUByteArray().sliceArray(0..<crypto_secretbox_NONCEBYTES)
    }
    private inline fun encodeNonce(base: UByteArray, nonce: ULong): UByteArray {
        val result = base.copyOf()
        var x = nonce
        var i = 0
        while (x > 0u) {
            result[i] = result[i] xor (x and 0xFFu).toUByte()
            x = x shr 8
            i++
        }
        return result
    }
    private inline fun encodeSendNonce(nonce: ULong): UByteArray = encodeNonce(sendBase, nonce)
    private inline fun encodeReceiveNonce(nonce: ULong): UByteArray = encodeNonce(receiveBase, nonce)
    fun encrypt(plainText: String): UByteArray = encrypt(plainText.encodeToUByteArray())
    private val proptectedOp = ProtectedOp()
    /**
     * Encrypt using send keys and proper nonce
     */
    fun encrypt(message: UByteArray, fillFactor: Float = 0f): UByteArray {
-        val fill = if (fillFactor > 0f)
+        val fill: UByteArray = if (fillFactor > 0f)
-            0..(message.size * fillFactor).roundToInt()
+            randomBytes(randomUInt((message.size * fillFactor).roundToInt()))
        else
-            null
+            ubyteArrayOf()
-        val n = protectedOp.invoke { nonce++ }
+        val withFill = BipackEncoder.encode(FilledData(message, fill)).toUByteArray()
        val n = proptectedOp { nonce++ }
        return pack(
-            Package(n, sessionKey.encryptWithNonce(message, numericNonce.withULong(n), fill))
+            Package(n, SecretBox.easy(withFill, encodeSendNonce(n), sessionKeyPair.sendKey))
        )
    }
-    //    fun decryptString(cipherText: UByteArray): String = decrypt(cipherText).decodeFromUByteArray()
+    fun decryptString(cipherText: UByteArray): String = decrypt(cipherText).decodeFromUByteArray()
-    fun decrypt(encryptedMessage: UByteArray): UByteArray =
+    fun decrypt(encryptedMessage: UByteArray): UByteArray {
        protectDecryption {
        val p: Package = BipackDecoder.decode(encryptedMessage.toDataSource())
-            sessionKey.decryptWithNonce(p.encryptedMessage, numericNonce.withULong(p.nonce))
+        try {
            return unpack<FilledData>(
                SecretBox.openEasy(
                    p.encryptedMessage,
                    encodeReceiveNonce(p.nonce),
                    sessionKeyPair.receiveKey
                )
            ).message
        } catch (_: com.ionspin.kotlin.crypto.secretbox.SecretBoxCorruptedOrTamperedDataExceptionOrInvalidKey) {
            throw DecryptionFailedException()
        }
    }
 }
@@ -7,13 +7,7 @@ import net.sergeych.utools.unpack
 private var L1IdCounter = 0
-/**
+// todo: We don't need it deferred here
 * Represents a remote interface for interacting with a Kiloparsec service.
 *
 * @param S the scope type of the Kiloparsec service which will be used to call local functions remotely
 * @property deferredParams a [CompletableDeferred] that resolves to the parameters required for making remote calls
 * @property clientInterface a [LocalInterface] used to communicate with the local client
 */
 class KiloRemoteInterface<S>(
    private val deferredParams: CompletableDeferred<KiloParams<S>>,
    private val clientInterface: LocalInterface<KiloScope<S>>,
@@ -1,7 +1,6 @@
 package net.sergeych.kiloparsec
-import net.sergeych.crypto2.SigningKey
+import net.sergeych.crypto.Key
 import net.sergeych.crypto2.VerifyingPublicKey
 /**
 * Scope for Kiloparsec client/server commands execution, contain per-connection specific data. The scope
@@ -27,8 +26,8 @@ interface KiloScope<S> {
    val sessionToken: UByteArray
    /**
-     * If the remote part has provided a secret key, e.g., gave non-null [SigningKey] on construction,
+     * If the remote part has provided a secret key, e.g., gave non-null [Key.Signing] on construction,
-     * the kiloparsec checks it in the MITM-safe way and provides its [VerifyingPublicKey] shared key here.
+     * the kiloparsec checks it in the MITM-safe way and provides its [Key.Verifying] shared key here.
     * Knowing a remote party shared key, it is possible to be sure that the connection is made directly
     * to this party with no middle point intruders.
     *
@@ -38,6 +37,6 @@ interface KiloScope<S> {
     * In spite of the above said, which means, non-null value in this field means the key is authorized, but
     * It is up to the caller to ensure it is expected key of the remote party.
     */
-    val remoteIdentity: VerifyingPublicKey?
+    val remoteIdentity: Key.Verifying?
 }
@@ -1,48 +0,0 @@
 package net.sergeych.kiloparsec
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.launch
 import net.sergeych.crypto2.SigningKey
 import net.sergeych.kiloparsec.adapter.InetTransportDevice
 import net.sergeych.mp_logger.LogTag
 import net.sergeych.mp_logger.debug
 import net.sergeych.mp_logger.exception
 import net.sergeych.mp_logger.info
 import net.sergeych.mp_tools.globalLaunch
 import net.sergeych.tools.AtomicCounter
 private val instances = AtomicCounter()
@Suppress("unused")
 class KiloServer<S>(
    private val clientInterface: KiloInterface<S>,
    private val connections: Flow<InetTransportDevice>,
    private val serverSecretKey: SigningKey? = null,
    private val sessionBuilder: ()->S,
    ): LogTag("KS:${instances.incrementAndGet()}") {
    private val job = globalLaunch {
        connections.collect { device ->
            launch {
                try {
                    info { "connected ${device}" }
                    KiloServerConnection(clientInterface, device, sessionBuilder(), serverSecretKey)
                        .apply { debug { "server connection is ready" }}
                        .run()
                }
                catch(_: CancellationException) {
                }
                catch(cce: LocalInterface.BreakConnectionException) {
                    info { "Closed exception caught, closing (${cce.flushSendQueue}" }
                }
                catch (t: Throwable) {
                    exception { "unexpected while creating kiloclient" to t }
                }
            }
        }
    }
    fun close() {
        job.cancel()
    }
 }
@@ -1,8 +1,8 @@
 package net.sergeych.kiloparsec
 import com.ionspin.kotlin.crypto.keyexchange.KeyExchange
 import kotlinx.coroutines.CompletableDeferred
-import net.sergeych.crypto2.SafeKeyExchange
+import net.sergeych.crypto.Key
 import net.sergeych.crypto2.SigningKey
 import net.sergeych.mp_logger.LogTag
 import net.sergeych.mp_logger.Loggable
 import net.sergeych.mp_logger.debug
@@ -23,15 +23,15 @@ class KiloServerConnection<S>(
    private val clientInterface: KiloInterface<S>,
    private val device: Transport.Device,
    private val session: S,
-    private val serverSigningKey: SigningKey? = null
+    private val serverSigningKey: Key.Signing? = null
 ) : RemoteInterface, Loggable by LogTag("SRV${++serverIds}") {
    /**
     * Shortcut to construct with [KiloConnectionData] intance
     */
    @Suppress("unused")
-    constructor(localInterface: KiloInterface<S>, connection: KiloConnectionData<S>, serverSecretKey: SigningKey? = null)
+    constructor(localInterface: KiloInterface<S>, connection: KiloConnectionData<S>, serverSigningKey: Key.Signing? = null)
-            : this(localInterface, connection.device, connection.session, serverSecretKey)
+            : this(localInterface, connection.device, connection.session, serverSigningKey)
    private val kiloRemoteInterface = CompletableDeferred<KiloRemoteInterface<S>>()
@@ -47,7 +47,9 @@ class KiloServerConnection<S>(
        val l0Interface = KiloL0Interface(clientInterface, deferredParams).apply {
            var params: KiloParams<S>? = null
            on(L0Request) {
-                val sk = pair.serverSessionKey(it.publicKey)
+                val sk = KeyExchange.serverSessionKeys(
                    pair.publicKey, pair.secretKey, it.publicKey
                )
                params = KiloParams(
                    true,
@@ -57,9 +59,15 @@ class KiloServerConnection<S>(
                    null,
                    this@KiloServerConnection
                )
                Handshake(1u, pair.publicKey, serverSigningKey?.seal(params!!.token))
            }
                var verifying: Key.Verifying? = null
                var signature: UByteArray? = null
                if( serverSigningKey != null ) {
                    verifying = serverSigningKey.verifying
                    signature = serverSigningKey.sign(params!!.token)
                }
                Handshake(1u, pair.publicKey, verifying, signature)
            }
            on(L0ClientId) {
                var p = params ?: throw RemoteInterface.ClosedException("wrong handshake sequence")
                val ci = unpack<ClientIdentity>(p.decrypt(it))
@@ -75,20 +83,19 @@ class KiloServerConnection<S>(
                kiloRemoteInterface.complete(
                    KiloRemoteInterface(deferredParams, clientInterface)
                )
                clientInterface.onConnectHandler?.invoke(p.scope)
            }
        }
        val transport = Transport(device, l0Interface, Unit)
            deferredTransport.complete(transport)
        kiloRemoteInterface.complete(KiloRemoteInterface(deferredParams,clientInterface))
-        debug { "starting the transport"}
+        debug { "starintg the transport"}
        transport.run()
        debug { "server transport finished" }
    }
    companion object {
-        val pair = SafeKeyExchange()
+        val pair = KeyExchange.keypair()
    }
    override suspend fun <A, R> call(cmd: Command<A, R>, args: A): R {
@@ -1,41 +1,14 @@
 package net.sergeych.kiloparsec
 import net.sergeych.mp_logger.LogTag
 import net.sergeych.mp_logger.Loggable
 import net.sergeych.mp_logger.exception
 import net.sergeych.mp_logger.info
 import net.sergeych.tools.AtomicCounter
 import net.sergeych.utools.firstNonNull
 import kotlin.reflect.KClass
 private typealias RawCommandHandler<C> = suspend (C, UByteArray) -> UByteArray
-private val idCounter = AtomicCounter()
+open class LocalInterface<S> {
 open class LocalInterface<S> : Loggable by LogTag("LocalInterface${idCounter.incrementAndGet()}") {
    private val commands = mutableMapOf<String, RawCommandHandler<S>>()
    /**
     * Instruct the transport to immediately break the connection.
     * This exception is not passed to the remote end, instead, transport device breaks
     * connection to remote when receiving it.
     *
     * Remote interface will throw [RemoteInterface.ClosedException] as the break will be detected. As reaction time
     * it depends on the transport in use, we recommend sending some registered exception first if you need
     * to pass important data, or implement special commands on both sides.
     *
     * __Important note:__ _it is not allowed to throw [RemoteInterface.ClosedException] directly!_
     * This exception is processed internally and can't be sent over the network.
     */
    open class BreakConnectionException(
        text: String = "break connection request",
        val flushSendQueue: Boolean = true,
    ) : RuntimeException(text) {
        override val message: String?
            get() = super.message + " (flush=$flushSendQueue)"
    }
    /**
     * New session creator. Rarely needed directlym it can be used for delegation
     * of local interfaces.
@@ -98,22 +71,15 @@ open class LocalInterface<S> : Loggable by LogTag("LocalInterface${idCounter.inc
        errorByClass[t::class] ?: errorProviders.firstNonNull { it.getErrorCode(t) }
    fun encodeError(forId: UInt, t: Throwable): Transport.Block.Error =
        if (t is RemoteInterface.ClosedException) {
            exception { "Illegal attempt to send ClosedException" to t }
            encodeError(forId, RemoteInterface.InternalError("TCE"))
        }
        else
        getErrorCode(t)?.let { Transport.Block.Error(forId, it, t.message) }
-                ?: Transport.Block.Error(forId, "UnknownError", "${t::class.simpleName}: ${t.message}")
+            ?: Transport.Block.Error(forId, "UnknownError", t.message)
    open fun getErrorBuilder(code: String): ((String, UByteArray?) -> Throwable)? =
        errorBuilder[code] ?: errorProviders.firstNonNull { it.getErrorBuilder(code) }
    fun decodeError(tbe: Transport.Block.Error): Throwable =
        getErrorBuilder(tbe.code)?.invoke(tbe.message, tbe.extra)
-            ?: RemoteInterface.RemoteException(tbe).also {
+            ?: RemoteInterface.RemoteException(tbe)
                info { "can't decode error ${tbe.code}: ${tbe.message}" }
            }
    fun decodeAndThrow(tbe: Transport.Block.Error): Nothing {
        throw decodeError(tbe)
@@ -0,0 +1,12 @@
 package net.sergeych.kiloparsec
 import kotlinx.coroutines.channels.Channel
 class ProxyDevice(capacity: Int=1024) : Transport.Device {
    override val input = Channel<UByteArray?>(capacity)
    override val output= Channel<UByteArray?>(capacity)
    override suspend fun close() {
        runCatching { input.close() }
        runCatching { output.close() }
    }
 }
@@ -15,12 +15,11 @@ interface RemoteInterface {
    /**
     * Is thrown when the channel is closed, in an attempt to execute a command, also to all pending
-     * calls (see [call]). Client code should never throw it. If command handler needs to break connection
+     * calls (see [call]).
     * it should throw [LocalInterface.BreakConnectionException]
     */
    open class ClosedException(t: String = "connection is closed") : Exception(t)
-    open class SecurityException(t: String = "invalid remote id and signature") : LocalInterface.BreakConnectionException(t)
+    open class SecurityException(t: String = "invalid remote id and signature") : ClosedException(t)
    open class InvalidDataException(msg: String="invalid data, can't unpack") : Exception(msg)
@@ -42,8 +41,6 @@ interface RemoteInterface {
     */
    class UnknownCommand : RemoteException("UnknownCommand")
    open class InternalError(code: String="0"): RemoteException("Internal error: $code")
    suspend fun <R> call(cmd: Command<Unit, R>): R = call(cmd, Unit)
    /**
@@ -1,8 +1,6 @@
 package net.sergeych.kiloparsec
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.channels.ClosedSendChannelException
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.SendChannel
 import kotlinx.coroutines.sync.Mutex
@@ -15,7 +13,7 @@ import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 import kotlinx.serialization.serializer
-import net.sergeych.crypto2.toDump
+import net.sergeych.crypto.toDump
 import net.sergeych.kiloparsec.Transport.Device
 import net.sergeych.mp_logger.*
 import net.sergeych.utools.pack
@@ -43,7 +41,7 @@ class Transport<S>(
         * Input blocks. When the device is disconnected, it should send one null to this channel
         * to notify the owner. When [close] is called, the channel should be closed.
         */
-        val input: ReceiveChannel<UByteArray>
+        val input: ReceiveChannel<UByteArray?>
        /**
         * Send a binary block to a remote party where it should be received and put into [input]
@@ -56,8 +54,6 @@ class Transport<S>(
         * possible. This method must not throw exceptions.
         */
        suspend fun close()
        suspend fun flush() {}
    }
    @Serializable(TransportBlockSerializer::class)
@@ -116,16 +112,8 @@ class Transport<S>(
        }
        // now we have mutex freed so we can call:
-        val r = runCatching {  device.output.send(pack(b).also { debug { ">>>\n${it.toDump()}" } }) }
+        val r = device.output.trySend(pack(b).also { debug { ">>>\n${it.toDump()}" } })
-        if (!r.isSuccess) {
+        if (!r.isSuccess) deferred.completeExceptionally(RemoteInterface.ClosedException())
            r.exceptionOrNull()?.let {
                exception { "failed to send output block" to it }
            } ?: run {
                error { "It should not happen: empty exception on block send failure" }
                throw RuntimeException("unexpected failure in sending block")
            }
            deferred.completeExceptionally(RemoteInterface.ClosedException())
        }
        // it returns packed result or throws a proper error:
        return deferred.await()
@@ -149,10 +137,9 @@ class Transport<S>(
    suspend fun run() {
        coroutineScope {
            debug { "awaiting incoming blocks" }
            // todo: rewrite it to close the job with no exceptions at all, always
            while (isActive && !isClosed) {
                try {
-                    device.input.receive().let { packed ->
+                    device.input.receive()?.let { packed ->
                        debug { "<<<\n${packed.toDump()}" }
                        val b = unpack<Block>(packed)
                        debug { "<<$ $b" }
@@ -182,12 +169,10 @@ class Transport<S>(
                                            localInterface.execute(commandContext, b.name, b.packedArgs)
                                        )
                                    )
-                                } catch (x: LocalInterface.BreakConnectionException) {
+                                } catch (x: RemoteInterface.ClosedException) {
-                                    // handler forced close
+                                    // strange case: handler throws closed?
-                                    warning { "handler requested closing of the connection (${x.flushSendQueue}"}
+                                    error { "not supported: command handler for $b has thrown ClosedException" }
-                                    isClosed = true
+                                    send(Block.Error(b.id, "UnexpectedException", x.message))
                                    if( x.flushSendQueue ) device.flush()
                                    device.close()
                                } catch (x: RemoteInterface.RemoteException) {
                                    send(Block.Error(b.id, x.code, x.text, x.extra))
                                } catch (t: Throwable) {
@@ -196,44 +181,24 @@ class Transport<S>(
                                    .also { debug { "command executed: ${b.name}" } }
                            }
                        }
-                        debug { "=---------------------------------------------"}
+                    } ?: run {
-                    }
+                        debug { "remote channel close received" }
                    debug { "input step performed closed=$isClosed active=$isActive"}
                } catch (_: ClosedSendChannelException) {
                    info { "closed send channel" }
                    isClosed = true
                } catch (_: ClosedReceiveChannelException) {
                    info { "closed receive channel"}
                        isClosed = true
                    }
-                catch(cce: LocalInterface.BreakConnectionException) {
+                } catch (_: CancellationException) {
-                    info { "closing connection by local request ($cce)"}
+                    info { "loop is cancelled" }
                    device.close()
                }
                catch(t: RemoteInterface.ClosedException) {
                    // it is ok: we just exit the coroutine normally
                    // and mark we're closing
                    isClosed = true
                }
                catch (_: CancellationException) {
                    info { "loop is cancelled with CancellationException" }
                    isClosed = true
                } catch (t: Throwable) {
                    exception { "channel closed on error" to t }
                    info { "isa? $isActive / $isClosed" }
                    isClosed = true
                }
            }
            debug { "leaving transport loop" }
            access.withLock {
                debug { "access lock obtained"}
                isClosed = true
                debug { "closing device $device, calls in queue ${calls.size}" }
                    runCatching { device.close() }
-                for (c in calls.values)
+                    isClosed = true
-                    c.completeExceptionally(RemoteInterface.ClosedException())
+                }
            }
            access.withLock {
                isClosed = true
                for (c in calls.values) c.completeExceptionally(RemoteInterface.ClosedException())
                calls.clear()
                debug { "calls clear has been called" }
            }
            debug { "no more active: $isActive / ${calls.size}" }
        }
@@ -241,13 +206,8 @@ class Transport<S>(
    }
    private suspend fun send(block: Block) {
        try {
        device.output.send(pack(block))
    }
        catch(_: ClosedSendChannelException) {
            throw RemoteInterface.ClosedException()
        }
    }
 }
@@ -0,0 +1,6 @@
 package net.sergeych.kiloparsec.adapter
 internal data class ConnectionId(
    val address: NetworkAddress,
    val id: UInt,
 )
@@ -0,0 +1,117 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.coroutines.*
 import net.sergeych.crypto.Key
 import net.sergeych.kiloparsec.KiloClientConnection
 import net.sergeych.kiloparsec.KiloInterface
 import net.sergeych.kiloparsec.ProxyDevice
 import net.sergeych.mp_logger.*
 import net.sergeych.mp_tools.globalLaunch
 import net.sergeych.tools.AtomicCounter
 import net.sergeych.utools.pack
 import net.sergeych.utools.unpack
 private val instanceCounter = AtomicCounter()
 class DatagramClient<S>(
    private val connector: DatagramConnector,
    val serverAddress: NetworkAddress,
    private val localInterface: KiloInterface<S>,
    private val clientSigningKey: Key.Signing? = null,
    private val createSession: () -> S,
 ) : LogTag("DGC:${instanceCounter.next()}") {
    private var sessionId = 0u
    private var isClosed = false
    val job = globalLaunch {
        while (isActive && !isClosed) {
            openSession()
            pumpSession()
            debug { "closing session $sessionId" }
            sessionId = 0u
        }
    }
    private suspend fun pumpSession() {
        try {
            val proxyDevice = ProxyDevice()
            val client = KiloClientConnection<S>(localInterface, proxyDevice, createSession(), clientSigningKey)
            coroutineScope {
                fun stop() {
                    cancel()
                }
                launch {
                    while (isActive) {
                        if (sessionId == 0u) {
                            error { "invalid zero sessionId in pump" }
                            stop()
                        } else {
                            val data = proxyDevice.output.receive()
                            if (data == null) {
                                warning { "kiloconnection send empty frame: closing" }
                                stop()
                            } else {
                                send(OuterPacket(sessionId, data))
                            }
                        }
                    }
                }
                while (isActive) {
                    val packet: OuterPacket = unpack(connector.incoming.receive().message)
                    if (packet.id == 0u) {
                        val result: DatagramResult = unpack(packet.payload)
                        if (result is DatagramResult.Error) {
                            if (result.error == DatagramError.Closed) {
                                info { "connection is closed on the remote part" }
                            } else {
                                warning { "unexpected error while pumping: ${result.error}" }
                            }
                        } else {
                            warning { "unexpected result: $result" }
                        }
                        stop()
                    } else {
                        proxyDevice.input.send(packet.payload)
                    }
                }
            }
            proxyDevice.close()
        } catch (x: CancellationException) {
            throw x
        } catch (x: Exception) {
            x.printStackTrace()
        }
    }
    private suspend fun openSession() {
        while (!isClosed) {
            send(OuterPacket(0u, ubyteArrayOf()))
            val packet: OuterPacket = unpack(connector.incoming.receive().message)
            if (packet.id == 0u) {
                when (val result: DatagramResult = unpack(packet.payload)) {
                    is DatagramResult.Error -> {
                        warning { "error opening connection: ${result.error}" }
                    }
                    is DatagramResult.Ok -> {
                        debug { "connection established, our id is ${result.id}" }
                        sessionId = result.id
                        break
                    }
                }
            } else {
                warning { "received unexpected openSession id: ${packet.id}" }
            }
            delay(500)
        }
    }
    private suspend fun send(packet: OuterPacket) {
        connector.send(pack(packet), serverAddress)
    }
    fun close() {
        job.cancel()
    }
 }
@@ -0,0 +1,7 @@
 package net.sergeych.kiloparsec.adapter
 enum class DatagramError {
    Closed,
    NotExists,
    Busy
 }
@@ -0,0 +1,15 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
@Serializable
 sealed class DatagramResult {
    @Serializable
    @SerialName("ok")
    data class Ok(val id: UInt) : DatagramResult()
    @Serializable
    @SerialName("err")
    data class Error(val error: DatagramError) : DatagramResult()
 }
@@ -0,0 +1,136 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.datetime.Instant
 import net.sergeych.crypto.Key
 import net.sergeych.kiloparsec.KiloInterface
 import net.sergeych.kiloparsec.KiloServerConnection
 import net.sergeych.kiloparsec.ProxyDevice
 import net.sergeych.mp_logger.LogTag
 import net.sergeych.mp_logger.debug
 import net.sergeych.mp_tools.globalLaunch
 import net.sergeych.tools.AtomicCounter
 import net.sergeych.utools.now
 import net.sergeych.utools.pack
 import net.sergeych.utools.unpack
 private val instanceCounter = AtomicCounter()
 private class Connection<S>(
    val server: DatagramServer<S>,
    val connection: KiloServerConnection<S>,
    val device: ProxyDevice,
    val connectionId: ConnectionId,
    var lastActiveAt: Instant = now(),
 ) {
    suspend fun proceedFrame(frame: OuterPacket) {
        lastActiveAt = now()
        if (frame.payload.isEmpty()) {
            // ping
            server.sendData(connectionId,ubyteArrayOf())
        } else
            device.input.send(frame.payload)
    }
    private val job = globalLaunch {
        while (isActive) {
            val x = device.output.receive() ?: break
            server.sendData(connectionId, x)
        }
    }
    suspend fun close() {
        job.cancel()
        server.remove(connectionId)
    }
 }
 class DatagramServer<S>(
    private val connector: DatagramConnector,
    private val localInterface: KiloInterface<S>,
    private val serverSigningKey: Key.Signing? = null,
    private val createSession: () -> S,
 ) : LogTag("DGS:${instanceCounter.next()}") {
    private val job = globalLaunch {
        while (isActive) {
            try {
                val datagram = connector.incoming.receive()
                val outer = unpack<OuterPacket>(datagram.message)
                if (outer.id == 0u)
                    setupNewConnection(datagram.address, outer)
                else
                    proceedExistingConnection(datagram.address, outer)
            } catch (_: ClosedReceiveChannelException) {
            }
        }
    }
    private val access = Mutex()
    private val connections = mutableMapOf<ConnectionId, Connection<S>>()
    private fun findFreeId(address: NetworkAddress): UInt {
        val existingIds = connections.keys.filter { it.address == address }.map { it.id }.toSet()
        debug { "existing connections from $address: $existingIds" }
        var i = 0u
        while (i in existingIds) i++
        debug { "found the free id: $i" }
        return i
    }
    private suspend fun setupNewConnection(address: NetworkAddress, packet: OuterPacket) {
        val id = access.withLock {
            val connectionId = ConnectionId(address, findFreeId(address))
            val proxy = ProxyDevice()
            connections[connectionId] = Connection(
                this,
                KiloServerConnection(localInterface, proxy, createSession(), serverSigningKey),
                proxy,
                connectionId,
            )
            connectionId
        }
        sendResult(id,DatagramResult.Ok(id.id))
    }
    private suspend fun proceedExistingConnection(address: NetworkAddress, outerPacket: OuterPacket) {
        val connectionId = ConnectionId(address, outerPacket.id)
        val c = access.withLock { connections[connectionId] }
        if (c == null) {
            sendResult(connectionId, DatagramResult.Error(DatagramError.NotExists))
        } else {
            c.proceedFrame(outerPacket)
        }
    }
    /**
     * Important. Closing the server also closes the connector which is supposed to be "owned"
     * exclusively by `DatagramServer`
     */
    fun close() {
        job.cancel()
        runCatching {
            connector.close()
        }
    }
    internal suspend fun remove(connectionId: ConnectionId) {
        access.withLock {
            connections.remove(connectionId)
        }
    }
    internal suspend fun sendData(connectionId: ConnectionId,data: UByteArray) {
        connector.send(pack(OuterPacket(connectionId.id, data)), connectionId.address)
    }
    internal suspend fun sendResult(connectionId: ConnectionId, result: DatagramResult) {
        connector.send(pack(OuterPacket(0u, pack(result))), connectionId.address)
    }
 }
@@ -1,17 +0,0 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.coroutines.channels.Channel
 /**
 * Transport device for inet protocol family with graceful shutdown on [close]
 */
@Suppress("unused")
 class InetTransportDevice(
    inputChannel: Channel<UByteArray>,
    outputChannel: Channel<UByteArray>,
    val remoteAddress: NetworkAddress,
    doClose: (suspend ()->Unit)? = null,
    doFlush: (suspend ()->Unit)? = null,
 ) : ProxyDevice(inputChannel, outputChannel, doClose, doFlush) {
    override fun toString(): String = "@$remoteAddress"
 }
@@ -1,7 +1,6 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.flow.Flow
 /**
 * Multiplatform implementation of an internet address.
@@ -25,6 +24,12 @@ interface Datagram {
     * Address from where the message was sent
     */
    val address: NetworkAddress
    /**
     * Send a datagram in response, e.g., to the [address].
     * This method is optimized per single per-datagram use. If you need to send many datagram, use [DatagramConnector].
     */
    suspend fun respondWith(message: UByteArray)
 }
@OptIn(ExperimentalStdlibApi::class)
@@ -34,7 +39,7 @@ interface DatagramConnector: AutoCloseable {
    suspend fun send(message: UByteArray, networkAddress: NetworkAddress)
    @Suppress("unused")
    suspend fun send(message: UByteArray, datagramAddress: String) {
-        send(message, datagramAddress.toNetworkAddress())
+        send(message, networkAddressOf(datagramAddress))
    }
    suspend fun send(message: UByteArray,host: String,port: Int) =
@@ -42,15 +47,5 @@ interface DatagramConnector: AutoCloseable {
    override fun close()
 }
 expect fun networkAddressOf(address: String): NetworkAddress
 expect fun NetworkAddress(host: String,port: Int): NetworkAddress
 fun String.toNetworkAddress() : NetworkAddress {
    val (host, port) = this.split(":").map { it.trim()}
    return NetworkAddress(host, port.toInt())
 }
 expect fun acceptTcpDevice(port: Int): Flow<InetTransportDevice>
 expect suspend fun connectTcpDevice(address: NetworkAddress): InetTransportDevice
 suspend fun connectTcpDevice(address: String) = connectTcpDevice(address.toNetworkAddress())
@@ -0,0 +1,9 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.serialization.Serializable
@Serializable
 internal data class OuterPacket(
    val id: UInt,
    val payload: UByteArray,
 )
@@ -1,40 +0,0 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.SendChannel
 import kotlinx.coroutines.delay
 import net.sergeych.kiloparsec.Transport
 import net.sergeych.tools.AtomicCounter
 private val counter = AtomicCounter()
 open class ProxyDevice(
    private val inputChannel: Channel<UByteArray>,
    private val outputChannel: Channel<UByteArray>,
    private val doClose: (suspend ()->Unit)? = null,
    private val doFlush: (suspend ()->Unit)? = null,
 ): Transport.Device {
    override val input: ReceiveChannel<UByteArray> = inputChannel
    override val output: SendChannel<UByteArray> = outputChannel
    override suspend fun close() {
        kotlin.runCatching {  doClose?.invoke() }
        runCatching { inputChannel.close() }
        runCatching { outputChannel.close() }
    }
    override suspend fun flush() {
        doFlush?.invoke()
        var cnt = 10
        while(!outputChannel.isEmpty) {
            if (cnt-- < 0) break
            delay(50)
        }
        super.flush()
    }
    private val id = counter.incrementAndGet()
    override fun toString(): String = "PX$id"
 }
@@ -1,114 +0,0 @@
 package net.sergeych.kiloparsec.adapter
 import io.ktor.client.*
 import io.ktor.client.plugins.websocket.*
 import io.ktor.http.*
 import io.ktor.websocket.*
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.channels.ClosedSendChannelException
 import kotlinx.coroutines.launch
 import net.sergeych.crypto2.SigningKey
 import net.sergeych.kiloparsec.KiloClient
 import net.sergeych.kiloparsec.KiloConnectionData
 import net.sergeych.kiloparsec.KiloInterface
 import net.sergeych.kiloparsec.RemoteInterface
 import net.sergeych.mp_logger.LogTag
 import net.sergeych.mp_logger.exception
 import net.sergeych.mp_logger.info
 import net.sergeych.mp_logger.warning
 import net.sergeych.mp_tools.globalLaunch
 import net.sergeych.tools.AtomicCounter
 private val counter = AtomicCounter()
 fun <S> websocketClient(
    path: String,
    clientInterface: KiloInterface<S> = KiloInterface(),
    client: HttpClient = HttpClient { install(WebSockets) },
    secretKey: SigningKey? = null,
    sessionMaker: () -> S = {
        @Suppress("UNCHECKED_CAST")
        Unit as S
    },
 ): KiloClient<S> {
    var u = Url(path)
    if (u.encodedPath.length <= 1)
        u = URLBuilder(u).apply {
            encodedPath = "/kp"
        }.build()
    return KiloClient(clientInterface, secretKey) {
        val input = Channel<UByteArray>()
        val output = Channel<UByteArray>()
        val closeHandle = CompletableDeferred<Boolean>()
        globalLaunch {
            val log = LogTag("KC:${counter.incrementAndGet()}")
            client.webSocket({
                url.protocol = u.protocol
                url.host = u.host
                url.port = u.port
                url.encodedPath = u.encodedPath
                url.parameters.appendAll(u.parameters)
                log.info { "kiloparsec server URL: $url" }
            }) {
                log.info { "connected to the server" }
 //                println("SENDING!!!")
 //                send("Helluva")
                launch {
                    try {
                        for (block in output) {
                            send(block.toByteArray())
                        }
                        log.info { "input is closed, closing the websocket" }
                        if (closeHandle.isActive) closeHandle.complete(true)
                    } catch (_: ClosedSendChannelException) {
                        log.info { "send channel closed" }
                    }
                    catch(_: CancellationException) {}
                    catch(t: Throwable) {
                        log.info { "unexpected exception in websock sender: ${t.stackTraceToString()}" }
                        closeHandle.completeExceptionally(t)
                    }
                    if (closeHandle.isActive) closeHandle.complete(false)
                }
                launch {
                    try {
                        for (f in incoming) {
                            if (f is Frame.Binary) {
                                input.send(f.readBytes().toUByteArray())
                            } else {
                                log.warning { "ignoring unexpected frame of type ${f.frameType}" }
                            }
                        }
                        if (closeHandle.isActive) closeHandle.complete(true)
                    } catch (_: CancellationException) {
                        if (closeHandle.isActive) closeHandle.complete(false)
                    } catch (_: ClosedReceiveChannelException) {
                        log.warning { "receive channel closed unexpectedly" }
                        if (closeHandle.isActive) closeHandle.complete(false)
                    } catch (t: Throwable) {
                        log.exception { "unexpected error" to t }
                        if (closeHandle.isActive) closeHandle.complete(false)
                    }
                }
                if(!closeHandle.await()) {
                    log.warning { "Client is closing with error" }
                    throw RemoteInterface.ClosedException()
                }
                output.close()
                input.close()
            }
            log.info { "closing connection" }
        }
        val device = ProxyDevice(input, output) {
            // we need to explicitly close the coroutine job, or it can hang for a long time
            // leaking resources.
            closeHandle.complete(true)
 //            job.cancel()
        }
        KiloConnectionData(device, sessionMaker())
    }
 }
@@ -1,17 +1,16 @@
 package net.sergeych.kiloparsec
 import kotlinx.serialization.Serializable
-import net.sergeych.crypto2.SafeKeyExchange
+import net.sergeych.crypto.Key
 import net.sergeych.crypto2.Seal
 import net.sergeych.crypto2.VerifyingPublicKey
 // L0 commands - key exchange and check:
@Serializable
-data class Handshake(val version: UInt, val publicKey: SafeKeyExchange.PublicKey,
+data class Handshake(val version: UInt, val publicKey: UByteArray,
-                     val signature: Seal? = null)
+                     val serverSharedKey: Key.Verifying? = null,
                     val signature: UByteArray? = null)
@Serializable
-data class ClientIdentity(val clientIdKey: VerifyingPublicKey?, val signature: UByteArray?)
+data class ClientIdentity(val clientIdKey: Key.Verifying?, val signature: UByteArray?)
 // Level 0 command: request key exchange
 internal val L0Request by command<Handshake, Handshake>()
@@ -1,6 +0,0 @@
 package net.sergeych.kiloparsec
 fun String.encodeToUByteArray() =
    encodeToByteArray().toUByteArray()
 fun UByteArray.decodeFromUByteArray(): String = toByteArray().decodeToString()
@@ -0,0 +1,8 @@
 package net.sergeych.tools
 class AtomicCounter(startWith: Long=0) {
    private var op = ProtectedOp()
    private var  counter = startWith
    fun next(): Long = op { counter++ }
 }
@@ -0,0 +1,21 @@
 package net.sergeych.tools
 /**
 * Multiplatform interface to perform a regular (not suspend) operation
 * protected by a platform mutex (where necessary). Get real implementation
 * with [ProtectedOp]
 */
 interface ProtectedOpImplementation {
    /**
     * Call [f] iin mutually exclusive mode, it means that only one invocation
     * can be active at a time, all the rest are waiting until the current operation
     * will finish.
     */
    operator fun <T>invoke(f: ()->T): T
 }
 /**
 * Get the platform-depended implementation of a mutex-protected operation.
 */
 expect fun ProtectedOp(): ProtectedOpImplementation
@@ -0,0 +1,12 @@
 package net.sergeych.utools
 /**
 * Scan the collection and return the first non-null result of the [predicate] on it.
 * If all the elements give null with predicate call, returns null.
 *
 * Note that collection is scanned only to the first non-null predicate result.
 */
 fun <T,R>Collection<T>.firstNonNull(predicate: (T)->R?): R? {
    for( x in this ) predicate(x)?.let { return it }
    return null
 }
@@ -0,0 +1,46 @@
 package net.sergeych.utools
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.serializer
 import net.sergeych.bintools.toDataSource
 import net.sergeych.bipack.BipackDecoder
 import net.sergeych.bipack.BipackEncoder
 /**
 * Effectively pack anyk nullable object. The result could be effectively packed
 * in turn as a part of a more complex structure.
 *
 * To avoid packing non-null mark,
 * we use a zero-size array, which, if in turn encoded, packs into a single
 * zero byte. Thus, we avoid extra byte spending for unnecessary null
 * check.
 */
 inline fun <reified T> pack(element: T?): UByteArray = pack(serializer<T>(), element)
 /**
 * Unpack nullable data packed with [pack]
 */
 inline fun <reified T: Any?> unpack(encoded: UByteArray): T =
    unpack(serializer<T>(), encoded)
 /**
 * Effectively pack anyk nullable object. The result could be effectively packed
 * in turn as a part of a more complex structure.
 *
 * To avoid packing non-null mark,
 * we use a zero-size array, which, if in turn encoded, packs into a single
 * zero byte. Thus, we avoid extra byte spending for unnecessary null
 * check.
 */
 fun <T>pack(serializer: KSerializer<T>, element: T?): UByteArray =
    if (element == null) ubyteArrayOf()
    else BipackEncoder.encode(serializer,element).toUByteArray()
 /**
 * Unpack nullable data packed with [pack]
 */
@Suppress("UNCHECKED_CAST")
 fun <T: Any?> unpack(serializer: KSerializer<T>, encoded: UByteArray): T =
    if (encoded.isEmpty()) null as T
    else BipackDecoder.decode(encoded.toByteArray().toDataSource(),serializer)
@@ -0,0 +1,12 @@
@file:Suppress("unused")
 package net.sergeych.utools
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 fun now(): Instant = Clock.System.now()
 fun nowToSeconds(): Instant = Clock.System.now().truncateToSeconds()
 fun Instant.truncateToSeconds(): Instant =
    Instant.fromEpochSeconds(toEpochMilliseconds()/1000)
@@ -0,0 +1,183 @@
 package org.komputing.khash.keccak
 import com.ionspin.kotlin.bignum.integer.BigInteger
 import org.komputing.khash.keccak.extensions.fillWith
 import kotlin.math.min
 object Keccak {
    private val BIT_65 = BigInteger.ONE shl (64)
    private val MAX_64_BITS = BIT_65 - BigInteger.ONE
    fun digest(value: ByteArray, parameter: KeccakParameter): ByteArray {
        val uState = IntArray(200)
        val uMessage = convertToUInt(value)
        var blockSize = 0
        var inputOffset = 0
        // Absorbing phase
        while (inputOffset < uMessage.size) {
            blockSize = min(uMessage.size - inputOffset, parameter.rateInBytes)
            for (i in 0 until blockSize) {
                uState[i] = uState[i] xor uMessage[i + inputOffset]
            }
            inputOffset += blockSize
            if (blockSize == parameter.rateInBytes) {
                doF(uState)
                blockSize = 0
            }
        }
        // Padding phase
        uState[blockSize] = uState[blockSize] xor parameter.d
        if (parameter.d and 0x80 != 0 && blockSize == parameter.rateInBytes - 1) {
            doF(uState)
        }
        uState[parameter.rateInBytes - 1] = uState[parameter.rateInBytes - 1] xor 0x80
        doF(uState)
        // Squeezing phase
        val byteResults = mutableListOf<Byte>()
        var tOutputLen = parameter.outputLengthInBytes
        while (tOutputLen > 0) {
            blockSize = min(tOutputLen, parameter.rateInBytes)
            for (i in 0 until blockSize) {
                byteResults.add(uState[i].toByte().toInt().toByte())
            }
            tOutputLen -= blockSize
            if (tOutputLen > 0) {
                doF(uState)
            }
        }
        return byteResults.toByteArray()
    }
    private fun doF(uState: IntArray) {
        val lState = Array(5) { Array(5) { BigInteger.ZERO } }
        for (i in 0..4) {
            for (j in 0..4) {
                val data = IntArray(8)
                val index = 8 * (i + 5 * j)
                uState.copyInto(data, 0, index, index + data.size)
                lState[i][j] = convertFromLittleEndianTo64(data)
            }
        }
        roundB(lState)
        uState.fillWith(0)
        for (i in 0..4) {
            for (j in 0..4) {
                val data = convertFrom64ToLittleEndian(lState[i][j])
                data.copyInto(uState, 8 * (i + 5 * j))
            }
        }
    }
    /**
     * Permutation on the given state.
     */
    private fun roundB(state: Array<Array<BigInteger>>) {
        var lfsrState = 1
        for (round in 0..23) {
            val c = arrayOfNulls<BigInteger>(5)
            val d = arrayOfNulls<BigInteger>(5)
            // θ step
            for (i in 0..4) {
                c[i] = state[i][0].xor(state[i][1]).xor(state[i][2]).xor(state[i][3]).xor(state[i][4])
            }
            for (i in 0..4) {
                d[i] = c[(i + 4) % 5]!!.xor(c[(i + 1) % 5]!!.leftRotate64(1))
            }
            for (i in 0..4) {
                for (j in 0..4) {
                    state[i][j] = state[i][j].xor(d[i]!!)
                }
            }
            // ρ and π steps
            var x = 1
            var y = 0
            var current = state[x][y]
            for (i in 0..23) {
                val tX = x
                x = y
                y = (2 * tX + 3 * y) % 5
                val shiftValue = current
                current = state[x][y]
                state[x][y] = shiftValue.leftRotate64Safely((i + 1) * (i + 2) / 2)
            }
            // χ step
            for (j in 0..4) {
                val t = arrayOfNulls<BigInteger>(5)
                for (i in 0..4) {
                    t[i] = state[i][j]
                }
                for (i in 0..4) {
                    // ~t[(i + 1) % 5]
                    val invertVal = t[(i + 1) % 5]!!.xor(MAX_64_BITS)
                    // t[i] ^ ((~t[(i + 1) % 5]) & t[(i + 2) % 5])
                    state[i][j] = t[i]!!.xor(invertVal.and(t[(i + 2) % 5]!!))
                }
            }
            // ι step
            for (i in 0..6) {
                lfsrState = (lfsrState shl 1 xor (lfsrState shr 7) * 0x71) % 256
                // pow(2, i) - 1
                val bitPosition = (1 shl i) - 1
                if (lfsrState and 2 != 0) {
                    state[0][0] = state[0][0].xor(BigInteger.ONE shl bitPosition)
                }
            }
        }
    }
    /**
     * Converts the given [data] array to an [IntArray] containing UInt values.
     */
    private fun convertToUInt(data: ByteArray) = IntArray(data.size) {
        data[it].toInt() and 0xFF
    }
    /**
     * Converts the given [data] array containing the little endian representation of a number to a [BigInteger].
     */
    private fun convertFromLittleEndianTo64(data: IntArray): BigInteger {
        val value = data.map { it.toString(16) }
            .map { if (it.length == 2) it else "0$it" }
            .reversed()
            .joinToString("")
        return BigInteger.parseString(value, 16)
    }
    /**
     * Converts the given [BigInteger] to a little endian representation as an [IntArray].
     */
    private fun convertFrom64ToLittleEndian(uLong: BigInteger): IntArray {
        val asHex = uLong.toString(16)
        val asHexPadded = "0".repeat((8 * 2) - asHex.length) + asHex
        return IntArray(8) {
            ((7 - it) * 2).let { pos ->
                asHexPadded.substring(pos, pos + 2).toInt(16)
            }
        }
    }
    private fun BigInteger.leftRotate64Safely(rotate: Int) = leftRotate64(rotate % 64)
    private fun BigInteger.leftRotate64(rotate: Int) = (this shr (64 - rotate)).add(this shl rotate).mod(BIT_65)
 }
@@ -0,0 +1,22 @@
@file:Suppress("unused")
 package org.komputing.khash.keccak
 /**
 * Parameters defining the FIPS 202 standard.
 */
 enum class KeccakParameter(val rateInBytes: Int,val outputLengthInBytes: Int, val d: Int) {
    KECCAK_224(144, 28, 0x01),
    KECCAK_256(136, 32, 0x01),
    KECCAK_384(104, 48, 0x01),
    KECCAK_512(72, 64, 0x01),
    SHA3_224(144, 28, 0x06),
    SHA3_256(136, 32, 0x06),
    SHA3_384(104, 48, 0x06),
    SHA3_512(72, 64, 0x06),
    SHAKE128(168, 32, 0x1F),
    SHAKE256(136, 64, 0x1F)
 }
@@ -0,0 +1,42 @@
 package org.komputing.khash.keccak.extensions
 /**
 * Assigns the specified int value to each element of the specified
 * range in the specified array of ints. The range to be filled
 * extends from index <tt>fromIndex</tt>, inclusive, to index
 * <tt>toIndex</tt>, exclusive.  (If <tt>fromIndex==toIndex</tt>, the
 * range to be filled is empty.)
 *
 * @param fromIndex the index of the first element (inclusive) to be
 *        filled with the specified value
 * @param toIndex the index of the last element (exclusive) to be
 *        filled with the specified value
 * @param value the value to be stored in all elements of the array
 * @throws IllegalArgumentException if <tt>fromIndex &gt; toIndex</tt>
 * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex &lt; 0</tt> or
 *         <tt>toIndex &gt; a.length</tt>
 */
 internal fun IntArray.fillWith(value: Int, fromIndex: Int = 0, toIndex: Int = this.size) {
    if (fromIndex > toIndex) {
        throw IllegalArgumentException(
            "fromIndex($fromIndex) > toIndex($toIndex)"
        )
    }
    if (fromIndex < 0) {
        throw ArrayIndexOutOfBoundsException(fromIndex)
    }
    if (toIndex > this.size) {
        throw ArrayIndexOutOfBoundsException(toIndex)
    }
    for (i in fromIndex until toIndex)
        this[i] = value
 }
 /**
 * Constructs a new [ArrayIndexOutOfBoundsException]
 * class with an argument indicating the illegal index.
 * @param index the illegal index.
 */
 internal class ArrayIndexOutOfBoundsException(index: Int) : Throwable("Array index out of range: $index")
@@ -0,0 +1,19 @@
@file:Suppress("unused")
 package org.komputing.khash.keccak.extensions
 import org.komputing.khash.keccak.Keccak
 import org.komputing.khash.keccak.KeccakParameter
 /**
 * Computes the proper Keccak digest of [this] byte array based on the given [parameter]
 */
 fun ByteArray.digestKeccak(parameter: KeccakParameter): ByteArray {
    return Keccak.digest(this, parameter)
 }
 /**
 * Computes the proper Keccak digest of [this] string based on the given [parameter]
 */
 fun String.digestKeccak(parameter: KeccakParameter): ByteArray {
    return Keccak.digest(encodeToByteArray(), parameter)
 }
@@ -1,9 +1,8 @@
 import com.ionspin.kotlin.crypto.secretbox.SecretBox
 import com.ionspin.kotlin.crypto.util.decodeFromUByteArray
 import com.ionspin.kotlin.crypto.util.encodeToUByteArray
 import kotlinx.coroutines.test.runTest
-import net.sergeych.crypto2.IllegalSignatureException
+import net.sergeych.crypto.*
 import net.sergeych.crypto2.SealedBox
 import net.sergeych.crypto2.SigningSecretKey
 import net.sergeych.crypto2.initCrypto
 import net.sergeych.kiloparsec.encodeToUByteArray
 import net.sergeych.utools.pack
 import net.sergeych.utools.unpack
 import kotlin.test.*
@@ -12,36 +11,47 @@ class KeysTest {
    @Test
    fun testCreationAndMap() = runTest {
        initCrypto()
-        val (stk,pbk) = SigningSecretKey.generatePair()
+        val (stk,pbk) = Key.Signing.pair()
        val x = mapOf( stk to "STK!", pbk to "PBK!")
        assertEquals("STK!", x[stk])
-        val s1 = SigningSecretKey(stk.keyBytes)
+        val s1 = Key.Signing(stk.packed)
        assertEquals(stk, s1)
        assertEquals("STK!", x[s1])
        assertEquals("PBK!", x[pbk])
        val data = "8 rays dev!".encodeToUByteArray()
        val data1 = "8 rays dev!".encodeToUByteArray()
-        val s = stk.seal(data)
+        val s = SignedBox.Seal.create(stk, data)
-        assertTrue(s.isValid(data))
+        assertTrue(s.verify(data))
        data1[0] = 0x01u
-        assertFalse(s.isValid(data1))
+        assertFalse(s.verify(data1))
-        val p2 = SigningSecretKey.generatePair()
+        val p2 = Key.Signing.pair()
-        val p3 = SigningSecretKey.generatePair()
+        val p3 = Key.Signing.pair()
-        val ms = SealedBox(data, s1) + p2.secretKey
+        val ms = SignedBox(data, s1) + p2.signing
        // non tampered:
-        val ms1 = unpack<SealedBox>(pack(ms))
+        val ms1 = unpack<SignedBox>(pack(ms))
        assertContentEquals(data, ms1.message)
        assertTrue(pbk in ms1)
-        assertTrue(p2.publicKey in ms1)
+        assertTrue(p2.verifying in ms1)
-        assertTrue(p3.publicKey !in ms1)
+        assertTrue(p3.verifying !in ms1)
        assertThrows<IllegalSignatureException> {
-            unpack<SealedBox>(pack(ms).also { it[3] = 1u })
+            unpack<SignedBox>(pack(ms).also { it[3] = 1u })
        }
    }
    @Test
    fun secretEncryptTest() = runTest {
        initCrypto()
        val key = SecretBox.keygen()
        val key1 = SecretBox.keygen()
        assertEquals("hello", decrypt(key, encrypt(key, "hello".encodeToUByteArray())).decodeFromUByteArray())
        assertThrows<DecryptionFailedException> {
            decrypt(key, encrypt(key1, "hello".encodeToUByteArray())).decodeFromUByteArray()
        }
    }
@@ -1,15 +1,11 @@
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
 import kotlinx.datetime.Instant
-import net.sergeych.bipack.BipackEncoder
+import net.sergeych.crypto.initCrypto
 import net.sergeych.crypto2.initCrypto
 import net.sergeych.kiloparsec.KiloParams
 import net.sergeych.kiloparsec.Transport
 import net.sergeych.utools.nowToSeconds
 import net.sergeych.utools.pack
 import net.sergeych.utools.unpack
 import kotlin.test.Test
 import kotlin.test.assertContentEquals
 import kotlin.test.assertEquals
 import kotlin.time.Duration.Companion.microseconds
@@ -44,10 +40,4 @@ class PackTest {
        val b2 = unpack<Transport.Block>(p1)
        assertEquals(b1,b2)
    }
    @Test
    fun packPackage() = runBlocking {
        val x = BipackEncoder.encode(KiloParams.Package(1u, ubyteArrayOf()))
        assertContentEquals(byteArrayOf(4, 0), x)
    }
 }
@@ -1,7 +1,20 @@
 import kotlinx.coroutines.test.runTest
 import net.sergeych.crypto.createContrail
 import net.sergeych.crypto.initCrypto
 import net.sergeych.crypto.isValidContrail
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 class ToolsTest {
-//    @Test
+    @Test
-//    fun testRemoceCmd() {
+    fun testContrails() = runTest {
-//        assertEquals("lalala", removeCmd("lalala"))
+        initCrypto()
-//        assertEquals("lalala", removeCmd("cmdlalala"))
+        val c = createContrail(ubyteArrayOf(1u, 2u, 3u, 4u, 5u))
-//    }
+        assertEquals(134u, c[0])
        assertTrue { isValidContrail(c) }
        c[2] = 11u
        assertFalse { isValidContrail(c) }
    }
 }
@@ -1,17 +1,15 @@
 import com.ionspin.kotlin.crypto.keyexchange.KeyExchange
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.SendChannel
 import kotlinx.coroutines.test.runTest
-import net.sergeych.crypto2.SigningSecretKey
+import net.sergeych.crypto.Key
-import net.sergeych.crypto2.VerifyingPublicKey
+import net.sergeych.crypto.initCrypto
-import net.sergeych.crypto2.initCrypto
+import net.sergeych.kiloparsec.command
 import net.sergeych.kiloparsec.*
 import net.sergeych.mp_logger.Log
-import kotlin.test.Test
+import kotlin.test.*
 import kotlin.test.assertContentEquals
 import kotlin.test.assertEquals
 import kotlin.test.fail
 private var dcnt = 0
 fun createTestDevice(): Pair<Transport.Device, Transport.Device> {
@@ -19,9 +17,8 @@ fun createTestDevice(): Pair<Transport.Device, Transport.Device> {
    val p2 = Channel<UByteArray>(256)
    val id = ++dcnt
    val d1 = object : Transport.Device {
-        override val input: ReceiveChannel<UByteArray> = p1
+        override val input: ReceiveChannel<UByteArray?> = p1
        override val output: SendChannel<UByteArray> = p2
        override suspend fun close() {
            p2.close()
        }
@@ -31,7 +28,7 @@ fun createTestDevice(): Pair<Transport.Device, Transport.Device> {
        }
    }
    val d2 = object : Transport.Device {
-        override val input: ReceiveChannel<UByteArray> = p2
+        override val input: ReceiveChannel<UByteArray?> = p2
        override val output: SendChannel<UByteArray> = p1
        override suspend fun close() {
            p1.close()
@@ -73,29 +70,29 @@ class TransportTest {
        val t1 = Transport(d1, l1, Unit)
        val t2 = Transport(d2, l2, Unit)
-//        val clip = KeyExchange.keypair()
+        val clip = KeyExchange.keypair()
-//        val serp = KeyExchange.keypair()
+        val serp = KeyExchange.keypair()
-//        val clisk = KeyExchange.clientSessionKeys(clip.publicKey, clip.secretKey, serp.publicKey)
+        val clisk = KeyExchange.clientSessionKeys(clip.publicKey, clip.secretKey, serp.publicKey)
-//        val sersk = KeyExchange.serverSessionKeys(serp.publicKey, serp.secretKey, clip.publicKey)
+        val sersk = KeyExchange.serverSessionKeys(serp.publicKey, serp.secretKey, clip.publicKey)
-//        val pser = KiloParams(true, t1, sersk, Unit, null, t1)
+        val pser = KiloParams(true, t1, sersk, Unit, null, t1)
-//        val pcli = KiloParams(false, t2, clisk, Unit, null, t2)
+        val pcli = KiloParams(false, t2, clisk, Unit, null, t2)
        assertContentEquals(pcli.token, pser.token)
        assertEquals(pser.decryptString(pcli.encrypt("hello!")), "hello!")
        assertEquals(pser.decryptString(pcli.encrypt("hello!")), "hello!")
        assertEquals(pser.decryptString(pcli.encrypt("hello2!")), "hello2!")
        assertEquals(pser.decryptString(pcli.encrypt("hello3!")), "hello3!")
        assertEquals(pser.decryptString(pcli.encrypt("hello!")), "hello!")
 //        assertContentEquals(pcli.token, pser.token)
 //        assertEquals(pser.decryptString(pcli.encrypt("hello!")), "hello!")
 //        assertEquals(pser.decryptString(pcli.encrypt("hello!")), "hello!")
 //        assertEquals(pser.decryptString(pcli.encrypt("hello2!")), "hello2!")
 //        assertEquals(pser.decryptString(pcli.encrypt("hello3!")), "hello3!")
 //        assertEquals(pser.decryptString(pcli.encrypt("hello!")), "hello!")
 //
        // test nonce increment
-//        assertFalse { pcli.encrypt("once") contentEquals pcli.encrypt("once") }
+        assertFalse { pcli.encrypt("once") contentEquals pcli.encrypt("once") }
-//        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
+        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
-//        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
+        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
-//        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
+        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
-//        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
+        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
-//        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
+        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
-//        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
+        assertEquals(pcli.decryptString(pser.encrypt("hello!")), "hello!")
        coroutineScope {
@@ -159,8 +156,6 @@ class TransportTest {
        d2.close()
    }
    class TestException(text: String) : Exception(text)
    @Test
    fun testClient() = runTest {
        initCrypto()
@@ -168,7 +163,7 @@ class TransportTest {
        val cmdPing by command<String, String>()
        val cmdPush by command<String, String>()
        val cmdGetToken by command<Unit, UByteArray>()
-        val cmdGetClientId by command<Unit, VerifyingPublicKey?>()
+        val cmdGetClientId by command<Unit, Key.Verifying?>()
        val cmdChainCallServer1 by command<String, String>()
        val cmdChainCallClient1 by command<String, String>()
        val cmdChainCallServer2 by command<String, String>()
@@ -177,12 +172,8 @@ class TransportTest {
 //        Log.defaultLevel = Log.Level.DEBUG
        val (d1, d2) = createTestDevice()
-        val serverId = SigningSecretKey.generatePair()
+        val serverId = Key.Signing.pair()
-        val clientId = SigningSecretKey.generatePair()
+        val clientId = Key.Signing.pair()
        val cmdException by command<Unit, Unit>()
        val cmdRemoteExceptionTest by command<Unit, String>()
        val cmdBreak by command<Unit, Unit>()
        val serverInterface = KiloInterface<String>().apply {
            on(cmdPing) {
@@ -200,28 +191,16 @@ class TransportTest {
            on(cmdChainCallServer2) {
                remote.call(cmdChainCallClient2, "$it-s2")
            }
-            on(cmdException) { throw TestException("te1") }
+            registerError { IllegalStateException() }
-            on(cmdRemoteExceptionTest) {
+            registerError { IllegalArgumentException(it) }
                try {
                    remote.call(cmdException)
                    "error!"
                } catch (e: TestException) {
                    "ok: ${e.message}"
        }
-            }
+        val kiloServerConnection = KiloServerConnection(serverInterface, d1, "server session", serverId.signing)
            on(cmdBreak) { throw LocalInterface.BreakConnectionException() }
            registerError { TestException(it) }
        }
        val kiloServerConnection = KiloServerConnection(
            serverInterface, d1, "server session", serverId.secretKey
        )
        launch { kiloServerConnection.run() }
        var cnt = 0
        val client = KiloClient {
            addErrors(serverInterface)
            session { "client session!" }
-            secretIdKey = clientId.secretKey
+            secretIdKey = clientId.signing
            local {
                on(cmdPush) {
                    "server push: $it"
@@ -233,10 +212,8 @@ class TransportTest {
                    remote.call(cmdChainCallServer2,"$it-c1")
                }
                on(cmdChainCallClient2) { "$it-c2" }
                on(cmdException) { throw TestException("te-local") }
            }
            connect {
                println("Called connect: $cnt")
                if (cnt++ > 0) {
                    cancel()
                    fail("connect called once again")
@@ -250,18 +227,6 @@ class TransportTest {
        assertEquals("server push: bar", kiloServerConnection.call(cmdPush, "bar"))
        assertEquals("**-s1-c1-s2-c2", client.call(cmdChainCallServer1, "**"))
        assertThrows<TestException> { client.call(cmdException) }
        assertEquals("ok: te-local", client.call(cmdRemoteExceptionTest))
        assertThrows<RemoteInterface.ClosedException> {
            client.call(cmdBreak)
        }
        // Note that current transport test is too simple,
        // therefore, we can't test reconnecting, also we need server and client instances
        // not connections, so that's all
        d1.close()
        d2.close()
        client.close()
@@ -8,7 +8,6 @@ inline fun <reified T: Throwable>assertThrows(f: ()->Unit): T {
    }
    catch(x: Throwable) {
        if( x is T ) return x
-        println("expected to throw $name but instead threw ${x::class.simpleName}: $x\b\n${x.stackTraceToString()}")
+        fail("expected to throw $name but instead threw ${x::class.simpleName}: $x")
        fail("expected to throw $name but instead threw ${x::class.simpleName}: $x\b\n${x.stackTraceToString()}")
    }
 }
@@ -1,2 +1,5 @@
 package net.sergeych.kiloparsec.adapter
 actual fun networkAddressOf(address: String): NetworkAddress {
    TODO("Not yet implemented")
 }
@@ -1,15 +1,5 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.coroutines.flow.Flow
 actual fun NetworkAddress(host: String, port: Int): NetworkAddress {
    TODO("Not yet implemented")
 }
 actual fun acceptTcpDevice(port: Int): Flow<InetTransportDevice> {
    TODO("Not yet implemented")
 }
 actual suspend fun connectTcpDevice(address: NetworkAddress): InetTransportDevice {
    TODO("Not yet implemented")
 }
@@ -0,0 +1,6 @@
 package net.sergeych.tools
 actual fun ProtectedOp(): ProtectedOpImplementation = object : ProtectedOpImplementation {
    // JS targets are inherently single-threaded, so we do noting:
    override fun <T> invoke(f: () -> T): T = f()
 }
@@ -1,20 +0,0 @@
 package net.sergeych.kiloparsec.adapter
 import java.nio.channels.CompletionHandler
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 open class ContinuationHandler<T> : CompletionHandler<T, Continuation<T>> {
    override fun completed(result: T, attachment: Continuation<T>) {
        attachment.resume(result)
    }
    override fun failed(exc: Throwable, attachment: Continuation<T>) {
        attachment.resumeWithException(exc)
    }
 }
 object VoidCompletionHandler: ContinuationHandler<Void>()
 object IntCompletionHandler: ContinuationHandler<Int>()
@@ -0,0 +1,8 @@
 package net.sergeych.kiloparsec.adapter
 import java.net.InetAddress
 actual fun networkAddressOf(address: String): NetworkAddress {
    val (host,port) = address.split(":")
    return JvmNetworkAddress(InetAddress.getByName(host), port.toInt())
 }
@@ -1,47 +1,6 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withContext
 import java.net.InetAddress
 import java.net.InetSocketAddress
 import java.nio.channels.AsynchronousServerSocketChannel
 import java.nio.channels.AsynchronousSocketChannel
 import kotlin.coroutines.suspendCoroutine
 actual fun NetworkAddress(host: String, port: Int): NetworkAddress =
    JvmNetworkAddress(InetAddress.getByName(host), port)
 actual fun acceptTcpDevice(port: Int): Flow<InetTransportDevice> {
    return flow {
        val socket = withContext(Dispatchers.IO) {
            AsynchronousServerSocketChannel.open().also {
                it.bind(InetSocketAddress(port))
            }
        }
        while (true) {
            val connectedSocket = suspendCancellableCoroutine { continuation ->
                continuation.invokeOnCancellation {
                    socket.close()
                }
                socket.accept(continuation, ContinuationHandler())
            }
            emit(asyncSocketToDevice(connectedSocket))
        }
    }
 }
@Suppress("unused")
 suspend fun connectTcpDevice(host: String, port: Int) = connectTcpDevice(NetworkAddress(host,port))
 actual suspend fun connectTcpDevice(address: NetworkAddress): InetTransportDevice {
    address as JvmNetworkAddress
    val socket = withContext(Dispatchers.IO) {
        AsynchronousSocketChannel.open()
    }
    suspendCoroutine { cont ->
        socket.connect(address.socketAddress, cont, VoidCompletionHandler)
    }
    return asyncSocketToDevice(socket)
 }
@@ -7,13 +7,15 @@ import net.sergeych.mp_logger.LogTag
 import net.sergeych.mp_logger.exception
 import net.sergeych.mp_logger.info
 import net.sergeych.mp_logger.warning
-import java.net.*
+import java.net.DatagramPacket
 import java.net.DatagramSocket
 import java.net.InetAddress
 import java.util.concurrent.atomic.AtomicInteger
 private val counter = AtomicInteger(0)
 class JvmNetworkAddress(val inetAddress: InetAddress, override val port: Int) : NetworkAddress {
-    override val host: String by lazy { inetAddress.canonicalHostName }
+    override val host: String by lazy { inetAddress.hostName }
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is JvmNetworkAddress) return false
@@ -24,15 +26,12 @@ class JvmNetworkAddress(val inetAddress: InetAddress, override val port: Int) :
        return true
    }
    val socketAddress: SocketAddress by lazy { InetSocketAddress(inetAddress,port) }
    override fun hashCode(): Int {
        var result = inetAddress.hashCode()
        result = 31 * result + port
        return result
    }
    override fun toString(): String = "$host:$port"
 }
 class UdpDatagram(override val message: UByteArray, val inetAddress: InetAddress, val port: Int) : Datagram {
@@ -41,6 +40,22 @@ class UdpDatagram(override val message: UByteArray, val inetAddress: InetAddress
        JvmNetworkAddress(inetAddress, port)
    }
    override suspend fun respondWith(message: UByteArray) {
        withContext(Dispatchers.IO) {
            // We expect datagram is most often respond once or not responded at all, and
            // we create and close a socket to send
            DatagramSocket().use { socket ->
                val packet = DatagramPacket(
                    message.toByteArray(),
                    message.size,
                    inetAddress,
                    port
                )
                socket.send(packet)
            }
        }
    }
 }
@@ -1,92 +0,0 @@
 package net.sergeych.kiloparsec.adapter
 import io.ktor.server.application.*
 import io.ktor.server.routing.*
 import io.ktor.server.websocket.*
 import io.ktor.websocket.*
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import net.sergeych.crypto2.SigningKey
 import net.sergeych.crypto2.toDump
 import net.sergeych.kiloparsec.KiloInterface
 import net.sergeych.kiloparsec.KiloServerConnection
 import net.sergeych.kiloparsec.RemoteInterface
 import net.sergeych.mp_logger.*
 import net.sergeych.tools.AtomicCounter
 import java.time.Duration
 fun <S> Application.setupWebsocketServer(
    localInterface: KiloInterface<S>,
    path: String = "/kp",
    serverKey: SigningKey? = null,
    createSession: () -> S,
 ) {
    install(Routing)
    install(WebSockets) {
        pingPeriod = Duration.ofSeconds(15)
        timeout = Duration.ofSeconds(15)
        maxFrameSize = Long.MAX_VALUE
        masking = false
    }
    val counter = AtomicCounter()
    routing {
        webSocket(path) {
            val log = LogTag("KWS:${counter.incrementAndGet()}")
            log.debug { "opening the connection" }
            val input = Channel<UByteArray>(256)
            val output = Channel<UByteArray>(256)
            launch {
                log.debug { "starting output pump" }
                while (isActive) {
                    try {
                        send(output.receive().toByteArray())
                    }
                    catch(_: ClosedReceiveChannelException) {
                        log.debug { "closing output pump as output channel is closed" }
                        break
                    }
                }
                log.debug { "closing output pump" }
            }
            val server = KiloServerConnection(
                localInterface,
                ProxyDevice(input, output),
                createSession(),
                serverKey
            )
            launch {
                server.run()
                close()
            }
            log.debug { "KSC started, looking for incoming frames" }
            for (f in incoming) {
                log.debug { "incoming frame: ${f.frameType}" }
                if (f is Frame.Binary)
                    try {
                        input.send(f.readBytes().toUByteArray().also {
                            log.debug { "in frame\n${it.toDump()}" }
                        })
                    } catch (_: RemoteInterface.ClosedException) {
                        log.warning { "caught local closed exception (strange!), closing" }
                        break
                    } catch (_: ClosedReceiveChannelException) {
                        log.info { "receive channel is closed, closing connection" }
                        break
                    } catch (t: Throwable) {
                        log.exception { "unexpected exception, server connection will close" to t }
                        break
                    }
                else
                    log.warning { "unknown frame type ${f.frameType}, ignoring" }
            }
            log.debug { "closing the server" }
            close()
            cancel()
            log.debug { "server wbesock processing done" }
        }
    }
 }
@@ -1,155 +0,0 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.flow.MutableStateFlow
 import net.sergeych.crypto2.Contrail
 import net.sergeych.crypto2.encodeVarUnsigned
 import net.sergeych.crypto2.readVarUnsigned
 import net.sergeych.kiloparsec.RemoteInterface
 import net.sergeych.kiloparsec.Transport
 import net.sergeych.mp_logger.LogTag
 import net.sergeych.mp_logger.warning
 import net.sergeych.mp_tools.globalLaunch
 import net.sergeych.tools.waitFor
 import java.net.InetSocketAddress
 import java.net.StandardSocketOptions.TCP_NODELAY
 import java.nio.ByteBuffer
 import java.nio.channels.AsynchronousSocketChannel
 import kotlin.coroutines.cancellation.CancellationException
 import kotlin.coroutines.suspendCoroutine
 private val log = LogTag("ASTD")
 /**
 * Prepend block with its size, varint-encoded
 */
 private fun encode(block: UByteArray): ByteArray {
    val c = Contrail.create(block)
    return (encodeVarUnsigned(c.size.toUInt()) + c).toByteArray()
 }
 /**
 * Convert asynchronous socket to a [Transport.Device] using non-blocking nio,
 * in a coroutine-effective manner. Note that it runs coroutines to read/write
 * to the socket in a global scope.These are closed when transport is closed
 *  or the socket is closed, for example, by network failure.
 */
 suspend fun asyncSocketToDevice(socket: AsynchronousSocketChannel): InetTransportDevice {
    val deferredDevice = CompletableDeferred<InetTransportDevice>()
    globalLaunch {
        coroutineScope {
            val sendQueueEmpty = MutableStateFlow(true)
            val receiving = MutableStateFlow(false)
            // We're in block mode, every block we send worth immediate sending, we do not
            // send partial blocks, so:
            socket.setOption(TCP_NODELAY, true)
            // socket input is to be parsed for blocks, so we receive bytes
            // and decode them to blocks
            val input = Channel<UByte>(1024)
            val inputBlocks = Channel<UByteArray>()
            // output is blocks, so we sent transformed, framed blocks:
            val outputBlocks = Channel<UByteArray>()
            fun stop() {
                kotlin.runCatching { inputBlocks.close(RemoteInterface.ClosedException()) }
                kotlin.runCatching { outputBlocks.close() }
                socket.close()
                cancel()
            }
            // copy incoming data from the socket to input channel:
            launch {
                val data = ByteArray(1024)
                val inb = ByteBuffer.wrap(data)
                kotlin.runCatching {
                    while (isActive) {
                        inb.position(0)
                        val size: Int = suspendCoroutine { continuation ->
                            socket.read(inb, continuation, IntCompletionHandler)
                        }
                        if (size < 0) stop()
                        else {
 //                        println("recvd:\n${data.sliceArray(0..<size).toDump()}\n------------------")
                            for (i in 0..<size) input.send(data[i].toUByte())
                        }
                    }
                }
            }
            // copy from output to socket:
            launch {
                try {
                    while (isActive) {
                        // wait for the first block to send
                        sendQueueEmpty.value = outputBlocks.isEmpty
                        var data = encode(outputBlocks.receive())
                        // now we're sending, so queue state is sending:
                        sendQueueEmpty.value = false
                        // if there are more, take them all (NO_DELAY optimization)
                        while (!outputBlocks.isEmpty)
                            data += encode(outputBlocks.receive())
                        // now send it all together:
                        val outBuff = ByteBuffer.wrap(data)
                        val cnt = suspendCoroutine { continuation ->
                            socket.write(outBuff, continuation, IntCompletionHandler)
                        }
                        // be sure it was all sent
                        if (outBuff.position() != data.size || cnt != data.size) {
                            throw RuntimeException("unexpected partial write")
                        }
                    }
                    // in the case of just breaking out of the loop:
                    sendQueueEmpty.value = true
                } catch (_: ClosedReceiveChannelException) {
                    stop()
                }
            }
            // transport device copes with blocks:
            // decode blocks from a byte channel read from the socket:
            launch {
                try {
                    while (isActive) {
                        receiving.value = !input.isEmpty
                        val size = readVarUnsigned(input)
                        receiving.value = true
                        if (size == 0u) log.warning { "zero size block is ignored!" }
                        else {
                            val block = UByteArray(size.toInt())
                            for (i in 0..<size.toInt()) {
                                block[i] = input.receive()
                            }
                            Contrail.unpack(block)?.let { inputBlocks.send(it) }
                                ?: log.warning { "skipping bad block ${block.size} bytes" }
                        }
                    }
                } catch (_: CancellationException) {
                } catch (_: ClosedReceiveChannelException) {
                    stop()
                }
                receiving.value = false
            }
            val addr = socket.remoteAddress as InetSocketAddress
            deferredDevice.complete(
                InetTransportDevice(inputBlocks, outputBlocks, JvmNetworkAddress(addr.address, addr.port), {
                    yield()
                    // wait until all received data are parsed, but not too long
                    withTimeoutOrNull(500) {
                        receiving.waitFor { !it }
                    }
                    // then stop it
                    stop()
                })
            )
        }
        globalLaunch { socket.close() }
    }
    return deferredDevice.await()
 }
@@ -0,0 +1,8 @@
 package net.sergeych.tools
 actual fun ProtectedOp(): ProtectedOpImplementation = object : ProtectedOpImplementation {
    private val lock = Object()
    override fun <T> invoke(f: () -> T): T {
        synchronized(lock) { return f() }
    }
 }
@@ -1,151 +1,10 @@
 package net.sergeych.kiloparsec
-import assertThrows
+import kotlin.test.Test
 import io.ktor.server.engine.*
 import io.ktor.server.netty.*
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.runTest
 import net.sergeych.crypto2.initCrypto
 import net.sergeych.kiloparsec.adapter.acceptTcpDevice
 import net.sergeych.kiloparsec.adapter.connectTcpDevice
 import net.sergeych.kiloparsec.adapter.setupWebsocketServer
 import net.sergeych.kiloparsec.adapter.websocketClient
 import net.sergeych.mp_logger.Log
 import java.net.InetAddress
 import kotlin.test.*
 class ClientTest {
    class TestException : Exception("test1")
    @Test
-    fun testAddresses() {
+    fun testClient() {
-        println(InetAddress.getLocalHost())
+        // Todo
        println(InetAddress.getByName("localhost"))
        println(InetAddress.getByName("127.0.0.1"))
        println(InetAddress.getByName("mail.ru"))
    }
    @Test
    fun testClient() = runTest {
        initCrypto()
        Log.connectConsole(Log.Level.DEBUG)
        data class Session(
            var data: String
        )
        val cmdSave by command<String,Unit>()
        val cmdLoad by command<Unit,String>()
        val cmdDrop by command<Unit,Unit>()
        val cmdException by command<Unit,Unit>()
        val cli = KiloInterface<Session>().apply {
            registerError { TestException() }
            onConnected { session.data = "start" }
            on(cmdSave) { session.data = it }
            on(cmdLoad) {
                session.data
            }
            on(cmdException) {
                throw TestException()
            }
            on(cmdDrop) {
                throw LocalInterface.BreakConnectionException()
            }
        }
        val server = KiloServer(cli, acceptTcpDevice(17101)) {
            Session("unknown")
        }
        val client = KiloClient<Unit>() {
            addErrors(cli)
            connect { connectTcpDevice("localhost:17101") }
        }
        println(client.call(cmdLoad))
        assertEquals("start", client.call(cmdLoad))
        client.call(cmdSave, "foobar")
        assertEquals("foobar", client.call(cmdLoad))
        val res = kotlin.runCatching {  client.call(cmdException) }
        println(res.exceptionOrNull())
        assertIs<TestException>(res.exceptionOrNull())
        assertEquals("foobar", client.call(cmdLoad))
        assertThrows<RemoteInterface.ClosedException> { client.call(cmdDrop) }
        // reconnect?
        assertEquals("start", client.call(cmdLoad))
        server.close()
    }
    @Test
    fun webSocketTest() = runTest {
        initCrypto()
 //        fun Application.
        val cmdClose by command<Unit,Unit>()
        val cmdGetFoo by command<Unit,String>()
        val cmdSetFoo by command<String,Unit>()
        val cmdCheckConnected by command<Unit,Boolean>()
        Log.connectConsole(Log.Level.DEBUG)
        data class Session(var foo: String="not set")
        var closeCounter = 0
        val serverInterface = KiloInterface<Session>().apply {
            var connectedCalled = false
            onConnected { connectedCalled = true }
            on(cmdGetFoo) { session.foo }
            on(cmdSetFoo) { session.foo = it }
            on(cmdCheckConnected) { connectedCalled }
            on(cmdClose) {
                throw LocalInterface.BreakConnectionException()
 //                if( closeCounter < 2 ) {
 //                    println("-------------------------- call close!")
 //                    throw RemoteInterface.ClosedException()
 //                }
 //                else {
 //                    println("close counter $closeCounter, ignoring")
 //                }
            }
        }
 //       val server = setupWebsoketServer()
        val ns: NettyApplicationEngine = embeddedServer(Netty, port = 8080, host = "0.0.0.0", module = {
            setupWebsocketServer(serverInterface) { Session() }
        }).start(wait = false)
        val client = websocketClient<Unit>("ws://localhost:8080/kp")
        val states = mutableListOf<Boolean>()
        val collector = launch {
            client.connectedStateFlow.collect {
                println("got: $closeCounter/$it")
                states += it
                if( !it) { closeCounter++ }
            }
        }
        assertEquals(true, client.call(cmdCheckConnected))
        assertTrue { client.connectedStateFlow.value }
        assertEquals("not set", client.call(cmdGetFoo))
        client.call(cmdSetFoo, "foo")
        assertEquals("foo", client.call(cmdGetFoo))
        assertTrue { client.connectedStateFlow.value }
        assertThrows<RemoteInterface.ClosedException> {
            client.call(cmdClose)
        }
        // connection should now be closed
        assertFalse { client.connectedStateFlow.value }
        // this should be run on automatically reopen connection
        client.call(cmdSetFoo,"superbar")
        assertTrue { client.connectedStateFlow.value }
        assertEquals("superbar", client.call(cmdGetFoo))
        client.close()
        ns.stop()
        collector.cancel()
 //        println("----= states: $states")
 //        println("stopped server")
 //        println("closed client")
    }
 }
@@ -1,87 +0,0 @@
 package net.sergeych.kiloparsec.adapters
 import kotlinx.coroutines.*
 import kotlinx.coroutines.test.runTest
 import net.sergeych.crypto2.initCrypto
 import net.sergeych.kiloparsec.adapter.UdpServer
 import net.sergeych.kiloparsec.adapter.acceptTcpDevice
 import net.sergeych.kiloparsec.adapter.connectTcpDevice
 import net.sergeych.kiloparsec.adapter.toNetworkAddress
 import net.sergeych.kiloparsec.decodeFromUByteArray
 import net.sergeych.kiloparsec.encodeToUByteArray
 import net.sergeych.mp_logger.Log
 import net.sergeych.synctools.ProtectedOp
 import net.sergeych.synctools.invoke
 import kotlin.test.Test
 import kotlin.test.assertContains
 import kotlin.test.assertEquals
 class NetworkTest {
    @Test
    fun udpProviderTest() = runTest {
        Log.connectConsole(Log.Level.DEBUG)
        val s1 = UdpServer(17120)
        val s2 = UdpServer(17121)
        s1.send("Hello".encodeToUByteArray(), "localhost", 17121)
        val d1 = s2.incoming.receive()
        assertEquals(d1.address.port, 17120)
        assertEquals("Hello", d1.message.toByteArray().decodeToString())
        s1.send("world".encodeToUByteArray(), d1.address)
        assertEquals("world", s1.incoming.receive().message.toByteArray().decodeToString())
        //        println("s1: ${s1.bindAddress()}")
    }
    @Test
    fun tcpAsyncConnectionTest() = runTest {
        initCrypto()
        Log.connectConsole(Log.Level.DEBUG)
        coroutineScope {
            val serverFlow = acceptTcpDevice(17171)
            val op = ProtectedOp()
            var pills = setOf<String>()
            val j = launch {
                serverFlow.collect { device ->
                    launch {
                        device.output.send("Hello, world!".encodeToUByteArray())
                        device.output.send("Great".encodeToUByteArray())
                        while (true) {
                            val x = device.input.receive().decodeFromUByteArray()
                            if (x.startsWith("die")) {
                                op.invoke {
                                    pills += x
                                }
                                cancel()
                            }
                            else
                                println("ignoring unexpected input: $x")
                        }
                    }
                }
            }
            yield()
            run {
                val s = connectTcpDevice("127.0.1.1:17171".toNetworkAddress())
                assertEquals("Hello, world!", s.input.receive().decodeFromUByteArray())
                assertEquals("Great", s.input.receive().decodeFromUByteArray())
                s.output.send("Goodbye".encodeToUByteArray())
                s.output.send("die1".encodeToUByteArray())
                s.close()
            }
            val s1 = connectTcpDevice("127.0.1.1:17171".toNetworkAddress())
            assertEquals("Hello, world!", s1.input.receive().decodeFromUByteArray())
            assertEquals("Great", s1.input.receive().decodeFromUByteArray())
            s1.output.send("die2".encodeToUByteArray())
            s1.close()
            // check that channels were flushed prior to closed:
            assertContains(pills, "die1")
            assertContains(pills, "die2")
            // Check that server jobs are closed
            j.cancelAndJoin()
        }
    }
 }
@@ -0,0 +1,26 @@
 package net.sergeych.kiloparsec.adapters
 import com.ionspin.kotlin.crypto.util.encodeToUByteArray
 import kotlinx.coroutines.test.runTest
 import net.sergeych.kiloparsec.adapter.UdpServer
 import net.sergeych.mp_logger.Log
 import org.junit.jupiter.api.Assertions.assertEquals
 import kotlin.test.Test
 class UServerTest {
    @Test
    fun udpProvider() = runTest {
        Log.connectConsole(Log.Level.DEBUG)
        val s1 = UdpServer(17120)
        val s2 = UdpServer(17121)
        s1.send("Hello".encodeToUByteArray(), "localhost",17121)
        val d1 = s2.incoming.receive()
        assertEquals(d1.address.port, 17120)
        assertEquals("Hello", d1.message.toByteArray().decodeToString())
        d1.respondWith("world".encodeToUByteArray())
        assertEquals("world", s1.incoming.receive().message.toByteArray().decodeToString())
    //        println("s1: ${s1.bindAddress()}")
    }
 }
@@ -1,2 +1,5 @@
 package net.sergeych.kiloparsec.adapter
 actual fun networkAddressOf(address: String): NetworkAddress {
    TODO("Not yet implemented")
 }
@@ -1,15 +1,5 @@
 package net.sergeych.kiloparsec.adapter
 import kotlinx.coroutines.flow.Flow
 actual fun NetworkAddress(host: String, port: Int): NetworkAddress {
    TODO("Not yet implemented")
 }
 actual fun acceptTcpDevice(port: Int): Flow<InetTransportDevice> {
    TODO("Not yet implemented")
 }
 actual suspend fun connectTcpDevice(address: NetworkAddress): InetTransportDevice {
    TODO("Not yet implemented")
 }
@@ -0,0 +1,13 @@
 package net.sergeych.tools
 import kotlinx.atomicfu.locks.SynchronizedObject
 import kotlinx.atomicfu.locks.synchronized
 actual fun ProtectedOp(): ProtectedOpImplementation = object : ProtectedOpImplementation {
    private val lock = SynchronizedObject()
    override fun <T> invoke(f: () -> T): T {
        synchronized(lock) {
            return f()
        }
    }
 }