verify device

diff --git a/Todo.md b/Todo.md
index 6698a4c331d6b49b613a1c416b5718a8e7c76484..23734f765c6fdc304c45ef904ded50a1942757e0 100644 (file)
--- a/Todo.md
+++ b/Todo.md
@@ -3,16 +3,18 @@
 + add esp build\r
 - (write script to build dependencies)\r
 - automate script to generate header with size defines\r
 + add esp build\r
 - (write script to build dependencies)\r
 - automate script to generate header with size defines\r

+- run on esp\r

 \r
 # Matrix Lib\r
 + manage keys\r
 + upload keys\r
 \r
 # Matrix Lib\r
 + manage keys\r
 + upload keys\r

-- create olm session\r
-  - incoming\r
++ create olm session\r
+  + incoming\r

   + outgoing\r
 + store keys/sessions\r
 - respond to events\r
   - room_key_request\r
 + add client saving/loading\r
   + outgoing\r
 + store keys/sessions\r
 - respond to events\r
   - room_key_request\r
 + add client saving/loading\r

+- overhaul client saving/loading\r

 + esp compatibility\r
 - http requests in chunks/dynamically allocated
\ No newline at end of file
 + esp compatibility\r
 - http requests in chunks/dynamically allocated
\ No newline at end of file

diff --git a/esp32/esp_project/main/main.c b/esp32/esp_project/main/main.c
index f4d3c8c81d373bf39aaf51f393dc7d2ce32f7fa0..b0908496082b3fef9001617fabc6a5fcb5876c32 100644 (file)
--- a/esp32/esp_project/main/main.c
+++ b/esp32/esp_project/main/main.c
@@ -17,9 +17,8 @@
 #include <esp_wifi.h>\r
 \r
 #define SERVER       "https://matrix.org"\r
 #include <esp_wifi.h>\r
 \r
 #define SERVER       "https://matrix.org"\r

-#define ACCESS_TOKEN "syt_cHNjaG8_yBvTjVTquGCikvsAenOJ_49mBMO"\r
-#define DEVICE_ID    "MAZNCCZLBR"\r
-#define ROOM_ID      "!koVStwyiiKcBVbXZYz:matrix.org"\r
+#define USER_ID      "@pscho:matrix.org"\r
+#define ROOM_ID      "!XKFUjAsGrSSrpDFIxB:matrix.org"\r

 \r
 void\r
 app_main(void)\r
 \r
 void\r
 app_main(void)\r


@@ -28,18 +27,37 @@ app_main(void)
     MatrixClientInit(&client,\r
         SERVER);\r
     \r
     MatrixClientInit(&client,\r
         SERVER);\r
     \r

-    void wifi_init(const char *ssid, const char *pass);\r
-    wifi_init("Hundehuette", "Affensicherespw55");\r
-\r

     MatrixHttpInit(&client);\r
 \r
     MatrixHttpInit(&client);\r
 \r

-    MatrixClientSetAccessToken(&client,\r
-        ACCESS_TOKEN);\r
+    MatrixClientSetUserId(&client, USER_ID);\r
+\r
+    MatrixClientLoginPassword(&client,\r
+        "pscho",\r
+        "Wc23EbmB9G3faMq",\r
+        "Test1");\r

 \r
 \r

-    MatrixClientSendEvent(&client,\r
+    MatrixClientUploadDeviceKey(&client);\r
+    MatrixClientGenerateOnetimeKeys(&client, 10);\r
+    MatrixClientUploadOnetimeKeys(&client);\r
+\r
+    // create megolmsession\r
+    MatrixMegolmOutSession * megolmOutSession;\r
+    MatrixClientGetMegolmOutSession(&client,\r
+        ROOM_ID,\r
+        &megolmOutSession);\r
+    printf("megolm session id: %.10s... key: %.10s...\n", megolmOutSession->id, megolmOutSession->key);\r
+\r
+    MatrixClientShareMegolmOutSession(&client,\r
+        USER_ID,\r
+        "ULZZOKJBYN",\r
+        megolmOutSession);\r
+\r
+    MatrixClientSendEventEncrypted(&client,\r

         ROOM_ID,\r
         "m.room.message",\r
         "{\"body\":\"Hello\",\"msgtype\":\"m.text\"}");\r
         \r
         ROOM_ID,\r
         "m.room.message",\r
         "{\"body\":\"Hello\",\"msgtype\":\"m.text\"}");\r
         \r

+    MatrixClientDeleteDevice(&client);\r
+\r

     MatrixHttpDeinit(&client);\r
 }\r
     MatrixHttpDeinit(&client);\r
 }\r

diff --git a/examples/Decrypt.c b/examples/Decrypt.c
index b496780ff01ad0a9ec6ccaf4423d6278a169097c..fe305cc6de0788191a6ff868d3de57b96fe94206 100644 (file)
--- a/examples/Decrypt.c
+++ b/examples/Decrypt.c
@@ -1,11 +1,26 @@
 #include <matrix.h>\r
 #include <stdio.h>\r
 \r
 #include <matrix.h>\r
 #include <stdio.h>\r
 \r

+#include <olm/sas.h>\r
+\r

 #define SERVER       "https://matrix.org"\r
 #define SERVER       "https://matrix.org"\r

-#define ACCESS_TOKEN "syt_cHNjaG8_yBvTjVTquGCikvsAenOJ_49mBMO"\r
-#define DEVICE_ID    "MAZNCCZLBR"\r
-#define ROOM_ID      "!koVStwyiiKcBVbXZYz:matrix.org"\r
-#define EVENT_ID     ""\r
+#define USER_ID      "@pscho:matrix.org"\r
+#define DEVICE_ID    "ULZZOKJBYN"\r
+#define SENDER_KEY   "LvVdoHsRRWNxRmG2GO2vky6o6S8RzADpPAaELsd1rjU"\r
+#define ROOM_ID      "!XKFUjAsGrSSrpDFIxB:matrix.org"\r
+#define EVENT_ID     "$_-y42DkC3OmJ_s40gYko7jMwrUQhoXfEut2pMV3E2J8"\r
+#define SESSION_ID   "tzdnJbDrm82D/RpgkZKpILTifQ5Rads+tVzp3ax8+Ls"\r
+\r
+void\r
+GetLine(char * buffer, int n) {\r
+    int c;\r
+    int len = 0;\r
+\r
+    while ((c = getchar()) != '\n' && len < n-1)\r
+        buffer[len++] = c;\r
+    \r
+    buffer[len] = '\0';\r
+}\r

 \r
 int\r
 main(void)\r
 \r
 int\r
 main(void)\r


@@ -16,30 +31,313 @@ main(void)
     \r
     MatrixHttpInit(&client);\r
 \r
     \r
     MatrixHttpInit(&client);\r
 \r

-    MatrixClientSetAccessToken(&client,\r
-        ACCESS_TOKEN);\r
+    MatrixClientSetUserId(&client, USER_ID);\r
+\r
+    MatrixClientLoginPassword(&client,\r
+        "pscho",\r
+        "Wc23EbmB9G3faMq",\r
+        "Test1");\r
+\r
+    printf("deviceId: %s\n", client.deviceId);\r
+\r
+    MatrixClientGenerateOnetimeKeys(&client, 10);\r
+    MatrixClientUploadOnetimeKeys(&client);\r
+    MatrixClientUploadDeviceKey(&client);\r

 \r
     static char eventBuffer[1024];\r
     MatrixClientGetRoomEvent(&client,\r
         ROOM_ID,\r
         EVENT_ID,\r
         eventBuffer, 1024);\r
 \r
     static char eventBuffer[1024];\r
     MatrixClientGetRoomEvent(&client,\r
         ROOM_ID,\r
         EVENT_ID,\r
         eventBuffer, 1024);\r

+    \r
+    printf("event: %s\n", eventBuffer);\r
+\r
+    // verify\r
+    char theirDeviceKey[DEVICE_KEY_SIZE];\r
+    MatrixClientRequestDeviceKey(&client,\r
+        DEVICE_ID,\r
+        theirDeviceKey, DEVICE_KEY_SIZE);\r
+    \r
+    char transactionId[256];\r
+    GetLine(transactionId, 128);\r
+\r
+    char verificationReadyBuffer[2048];\r
+    snprintf(verificationReadyBuffer, 2048,\r
+        "{"\r
+        "\"from_device\":\"%s\","\r
+        "\"methods\":[\"m.sas.v1\"],"\r
+        "\"transaction_id\":\"%s\""\r
+        "}",\r
+        client.deviceId,\r
+        transactionId);\r
+    \r
+    MatrixClientSendToDevice(&client,\r
+        USER_ID,\r
+        DEVICE_ID,\r
+        verificationReadyBuffer,\r
+        "m.key.verification.ready");\r
+    \r
+    OlmSAS * olmSas = olm_sas(malloc(olm_sas_size()));\r
+    void * sasRandomBytes = malloc(olm_create_sas_random_length(olmSas));\r
+    olm_create_sas(olmSas,\r
+        sasRandomBytes,\r
+        olm_create_sas_random_length(olmSas));\r
+    \r
+    OlmUtility * olmUtil = olm_utility(malloc(olm_utility_size()));\r
+    \r
+    char publicKey[128];\r
+    char keyStartJson[1024];\r
+    char concat[1024];\r
+    char commitment[256];\r
+    olm_sas_get_pubkey(olmSas,\r
+        publicKey,\r
+        128);\r
+    GetLine(keyStartJson, 1024);\r
+    printf("keyStartJson: %s\n", keyStartJson);\r
+    int concatLen =\r
+        snprintf(concat, 1024, "%s%s", publicKey, keyStartJson);\r
+    printf("concat: %s\n", concat);\r
+    olm_sha256(olmUtil, concat, strlen(concat), commitment, 256);\r
+    printf("hash: %s\n", commitment);\r
+    \r
+    char verificationAcceptBuffer[2048];\r
+    snprintf(verificationAcceptBuffer, 2048,\r
+        "{"\r
+        "\"commitment\":\"%s\","\r
+        "\"hash\":\"sha256\","\r
+        "\"key_agreement_protocol\":\"curve25519\","\r
+        "\"message_authentication_code\":\"hkdf-hmac-sha256.v2\","\r
+        "\"method\":\"m.sas.v1\","\r
+        "\"short_authentication_string\":[\"decimal\"],"\r
+        "\"transaction_id\":\"%s\""\r
+        "}",\r
+        commitment,\r
+        transactionId);\r
+    \r
+    MatrixClientSendToDevice(&client,\r
+        USER_ID,\r
+        DEVICE_ID,\r
+        verificationAcceptBuffer,\r
+        "m.key.verification.accept");\r
+    \r
+    char theirPublicKey[128];\r
+    GetLine(theirPublicKey, 128);\r
+    olm_sas_set_their_key(olmSas, theirPublicKey, strlen(theirPublicKey));\r
+    \r
+    char verificationKeyBuffer[2048];\r
+    snprintf(verificationKeyBuffer, 2048,\r
+        "{"\r
+        "\"key\":\"%s\","\r
+        "\"transaction_id\":\"%s\""\r
+        "}",\r
+        publicKey,\r
+        transactionId);\r
+    \r
+    MatrixClientSendToDevice(&client,\r
+        USER_ID,\r
+        DEVICE_ID,\r
+        verificationKeyBuffer,\r
+        "m.key.verification.key");\r
+\r
+    char hkdfInfo[1024];\r
+    int hkdfInfoLen =\r
+        snprintf(hkdfInfo, 1024,\r
+            "MATRIX_KEY_VERIFICATION_SAS%s%s%s%s%s",\r
+            USER_ID,\r
+            DEVICE_ID,\r
+            USER_ID,\r
+            client.deviceId,\r
+            transactionId);\r
+\r
+    unsigned char sasBytes[5];\r
+    olm_sas_generate_bytes(olmSas,\r
+        hkdfInfo, hkdfInfoLen,\r
+        sasBytes, 5);\r
+    int b0 = sasBytes[0];\r
+    int b1 = sasBytes[1];\r
+    int b2 = sasBytes[2];\r
+    int b3 = sasBytes[3];\r
+    int b4 = sasBytes[4];\r
+    \r
+    printf("%d %d %d %d %d\n", b0, b1, b2, b3, b4);\r

 \r
 \r

+    // https://spec.matrix.org/v1.7/client-server-api/#sas-method-decimal\r
+    printf("%d | %d | %d\n",\r
+        (b0 << 5 | b1 >> 3) + 1000,\r
+        ((b1 & 0x7) << 10 | b2 << 2 | b3 >> 6) + 1000,\r
+        ((b3 & 0x3F) << 7 | b4 >> 1) + 1000);\r
+    printf("%d | %d | %d\n",\r
+        ((b0 << 5) | (b1 >> 3)) + 1000,\r
+        (((b1 & 0x7) << 10) | (b2 << 2) | (b3 >> 6)) + 1000,\r
+        (((b3 & 0x3F) << 7) | (b4 >> 1)) + 1000);\r
+    \r
+    // mac\r
+    const char * masterKey = "vt8tJ5/SxqkvXS+XoGxr+4rJNe8fJfZT3/e/FTwlFsI";\r
+\r
+    char keyList[1024];\r
+    char keyListMac[1024];\r
+    char key1Id[1024];\r
+    char key1[1024];\r
+    char key1Mac[1024];\r
+    char key2Id[1024];\r
+    char key2[1024];\r
+    char key2Mac[1024];\r
+\r
+    if (strcmp(masterKey, client.deviceId) < 0) {\r
+        //strcpy(key1Id, masterKey);\r
+        snprintf(key1Id, 1024, "ed25519:%s", masterKey);\r
+        strcpy(key1, masterKey);\r
+        //strcpy(key2Id, client.deviceId);\r
+        snprintf(key2Id, 1024, "ed25519:%s", client.deviceId);\r
+        MatrixOlmAccountGetSigningKey(&client.olmAccount, key2, 1024);\r
+    }\r
+    else {\r
+        //strcpy(key1Id, client.deviceId);\r
+        snprintf(key1Id, 1024, "ed25519:%s", client.deviceId);\r
+        MatrixOlmAccountGetSigningKey(&client.olmAccount, key1, 1024);\r
+        //strcpy(key2Id, masterKey);\r
+        snprintf(key2Id, 1024, "ed25519:%s", masterKey);\r
+        strcpy(key2, masterKey);\r
+    }\r
+\r
+    snprintf(keyList, 1024,\r
+        "%s,%s", key1Id, key2Id);\r
+    \r
+    char macInfo[1024];\r
+    int macInfoLen;\r
+    {\r
+        macInfoLen =\r
+            snprintf(macInfo, 1024,\r
+                "MATRIX_KEY_VERIFICATION_MAC%s%s%s%s%s%s",\r
+                USER_ID,\r
+                client.deviceId,\r
+                USER_ID,\r
+                DEVICE_ID,\r
+                transactionId,\r
+                "KEY_IDS");\r
+        olm_sas_calculate_mac_fixed_base64(olmSas, keyList, strlen(keyList), macInfo, macInfoLen, keyListMac, 1024);\r
+    }\r
+    {\r
+        macInfoLen =\r
+            snprintf(macInfo, 1024,\r
+                "MATRIX_KEY_VERIFICATION_MAC%s%s%s%s%s%s",\r
+                USER_ID,\r
+                client.deviceId,\r
+                USER_ID,\r
+                DEVICE_ID,\r
+                transactionId,\r
+                key1Id);\r
+        olm_sas_calculate_mac_fixed_base64(olmSas, key1, strlen(key1), macInfo, macInfoLen, key1Mac, 1024);\r
+    }\r
+    {\r
+        macInfoLen =\r
+            snprintf(macInfo, 1024,\r
+                "MATRIX_KEY_VERIFICATION_MAC%s%s%s%s%s%s",\r
+                USER_ID,\r
+                client.deviceId,\r
+                USER_ID,\r
+                DEVICE_ID,\r
+                transactionId,\r
+                key2Id);\r
+        olm_sas_calculate_mac_fixed_base64(olmSas, key2, strlen(key2), macInfo, macInfoLen, key2Mac, 1024);\r
+    }\r
+\r
+    printf("send mac:");\r
+    getchar();\r
+\r
+    char verificationMacBuffer[2048];\r
+    snprintf(verificationMacBuffer, 2048,\r
+        "{"\r
+        "\"keys\":\"%s\","\r
+        "\"mac\":{"\r
+        "\"%s\":\"%s\","\r
+        "\"%s\":\"%s\""\r
+        "},"\r
+        "\"transaction_id\":\"%s\""\r
+        "}",\r
+        keyListMac,\r
+        key1Id,\r
+        key1Mac,\r
+        key2Id,\r
+        key2Mac,\r
+        transactionId);\r
+    \r
+    MatrixClientSendToDevice(&client,\r
+        USER_ID,\r
+        DEVICE_ID,\r
+        verificationMacBuffer,\r
+        "m.key.verification.mac");\r
+\r
+    printf("send done:");\r
+    getchar();\r
+\r
+    char verificationDoneBuffer[2048];\r
+    snprintf(verificationDoneBuffer, 2048,\r
+        "{"\r
+        "\"transaction_id\":\"%s\""\r
+        "}",\r
+        transactionId);\r
+    \r
+    MatrixClientSendToDevice(&client,\r
+        USER_ID,\r
+        DEVICE_ID,\r
+        verificationDoneBuffer,\r
+        "m.key.verification.done");\r
+    \r
+    // done\r
+\r
+    // request room key\r
+\r
+    getchar();\r
+    \r

     MatrixMegolmInSession megolmSession;\r
     \r
     MatrixMegolmInSession megolmSession;\r
     \r

-    MatrixClientRequestMegolmSession(&client,\r
+    MatrixClientRequestMegolmInSession(&client,\r

         ROOM_ID,\r
         ROOM_ID,\r

-        EVENT_ID,\r
+        SESSION_ID,\r
+        SENDER_KEY,\r
+        USER_ID,\r
+        DEVICE_ID,\r

         &megolmSession);\r
 \r
         &megolmSession);\r
 \r

-    static char decryptedBuffer[1024];\r
-    MatrixMegolmSessionDecrypt(&megolmSession,\r
-        eventBuffer,\r
-        decryptedBuffer, 1024);\r
+    // // decrypt room key\r
+\r
+    MatrixOlmSession * olmSession;\r
+    MatrixClientGetOlmSession(&client,\r
+        USER_ID,\r
+        DEVICE_ID,\r
+        &olmSession);\r
+    static char encrypted[2048];\r
+    static char decrypted[2048];\r
+    printf("encrypted:");\r
+    gets(encrypted);\r
+    printf("(%d) %s;\n", strlen(encrypted), encrypted);\r
+    MatrixOlmSessionDecrypt(olmSession,\r
+        1, encrypted, decrypted, 2048);\r
+    printf("decrypted: %s\n", decrypted);\r
+\r
+    // int c;\r
+    // while ((c = getchar()) != 'q') {\r
+    //     printf("c: %c (%d)\n", c, c);\r
+    //     static char syncBuffer[40000];\r
+    //     MatrixClientSync(&client,\r
+    //         syncBuffer, 40000);\r
+    //     printf("sync: %s", syncBuffer);\r
+    // }\r
+\r
+\r
+    // static char decryptedBuffer[1024];\r
+    // MatrixMegolmInSessionDecrypt(&megolmSession,\r
+    //     eventBuffer,\r
+    //     decryptedBuffer, 1024);\r
+\r
+    // printf("%s\n", decryptedBuffer);\r
+\r
+    getchar();\r

 \r
 \r

-    printf("%s\n", decryptedBuffer);\r
+    MatrixClientDeleteDevice(&client);\r

         \r
     MatrixHttpDeinit(&client);\r
 \r
     return 0;\r
         \r
     MatrixHttpDeinit(&client);\r
 \r
     return 0;\r

-}
\ No newline at end of file
+}\r

diff --git a/examples/Decrypt.rdbg b/examples/Decrypt.rdbg
new file mode 100644 (file)
index 0000000..4e83583
Binary files /dev/null and b/examples/Decrypt.rdbg differ

diff --git a/src/matrix.c b/src/matrix.c
index 06409b82ea3f3029d07c8f28dc267b98c900c0bb..18b700a2e412b1d3699b1781bb1a9cb40e7d0930 100644 (file)
--- a/src/matrix.c
+++ b/src/matrix.c
@@ -11,9 +11,11 @@
 \r
 #define ENCRYPTED_REQUEST_SIZE (1024*5)\r
 #define ENCRYPTED_EVENT_SIZE (1024*10)\r
 \r
 #define ENCRYPTED_REQUEST_SIZE (1024*5)\r
 #define ENCRYPTED_EVENT_SIZE (1024*10)\r

-#define ROOMEVENT_REQUEST_SIZE 256\r
-#define ROOMEVENT_RESPONSE_SIZE 1024\r
-#define ROOMEVENT_URL "/_matrix/client/v3/rooms/%s/send/%s/%d"\r
+#define ROOM_SEND_REQUEST_SIZE 256\r
+#define ROOM_SEND_RESPONSE_SIZE 1024\r
+#define ROOM_SEND_URL "/_matrix/client/v3/rooms/%s/send/%s/%d"\r
+\r
+#define ROOMKEY_REQUEST_SIZE (1024*4)\r

 \r
 #define TODEVICE_EVENT_SIZE (1024*5)\r
 #define TODEVICE_URL "/_matrix/client/v3/sendToDevice/%s/%d"\r
 \r
 #define TODEVICE_EVENT_SIZE (1024*5)\r
 #define TODEVICE_URL "/_matrix/client/v3/sendToDevice/%s/%d"\r


@@ -89,8 +91,8 @@ bool JsonSign(
     \r
     int signatureLen = res;\r
     \r
     \r
     int signatureLen = res;\r
     \r

-    char thisSigningKey[DEVICE_KEY_SIZE];\r
-    MatrixOlmAccountGetSigningKey(&client->olmAccount, thisSigningKey, DEVICE_KEY_SIZE);\r
+    static char thisSigningKey[SIGNING_KEY_SIZE];\r
+    MatrixOlmAccountGetSigningKey(&client->olmAccount, thisSigningKey, SIGNING_KEY_SIZE);\r

 \r
     static char signatureJson[JSON_SIGNATURE_SIZE];\r
     int signatureJsonLen =\r
 \r
     static char signatureJson[JSON_SIGNATURE_SIZE];\r
     int signatureJsonLen =\r


@@ -103,7 +105,8 @@ bool JsonSign(
                 "}"\r
             "}",\r
             client->userId,\r
                 "}"\r
             "}",\r
             client->userId,\r

-            "1",\r
+            //"1",\r
+            client->deviceId,\r

             signatureLen, signature);\r
 \r
     struct mjson_fixedbuf result = { sOut, sOutCap, 0 };\r
             signatureLen, signature);\r
 \r
     struct mjson_fixedbuf result = { sOut, sOutCap, 0 };\r


@@ -257,6 +260,28 @@ MatrixOlmSessionEncrypt(
     return res != olm_error();\r
 }\r
 \r
     return res != olm_error();\r
 }\r
 \r

+bool\r
+MatrixOlmSessionDecrypt(\r
+    MatrixOlmSession * session,\r
+    size_t messageType,\r
+    char * encrypted,\r
+    char * outBuffer, int outBufferCap)\r
+{\r
+    static uint8_t random[OLM_ENCRYPT_RANDOM_SIZE];\r
+    Randomize(random, OLM_ENCRYPT_RANDOM_SIZE);\r
+\r
+    size_t res =\r
+        olm_decrypt(session->session,\r
+            messageType,\r
+            encrypted, strlen(encrypted),\r
+            outBuffer, outBufferCap);\r
+    \r
+    if (res != olm_error() && res < outBufferCap)\r
+        outBuffer[outBufferCap] = '\0';\r
+\r
+    return res != olm_error();\r
+}\r
+\r

 // https://matrix.org/docs/guides/end-to-end-encryption-implementation-guide#starting-a-megolm-session\r
 bool\r
 MatrixMegolmOutSessionInit(\r
 // https://matrix.org/docs/guides/end-to-end-encryption-implementation-guide#starting-a-megolm-session\r
 bool\r
 MatrixMegolmOutSessionInit(\r


@@ -510,7 +535,7 @@ MatrixClientUploadOnetimeKeys(
     static char requestBuffer[KEYS_UPLOAD_REQUEST_SIZE];\r
 \r
     mjson_snprintf(requestBuffer, KEYS_UPLOAD_REQUEST_SIZE,\r
     static char requestBuffer[KEYS_UPLOAD_REQUEST_SIZE];\r
 \r
     mjson_snprintf(requestBuffer, KEYS_UPLOAD_REQUEST_SIZE,\r

-        "{\"one_time_keys\":{");\r
+        "{");\r

 \r
     static char onetimeKeysBuffer[1024];\r
     olm_account_one_time_keys(client->olmAccount.account,\r
 \r
     static char onetimeKeysBuffer[1024];\r
     olm_account_one_time_keys(client->olmAccount.account,\r


@@ -524,14 +549,15 @@ MatrixClientUploadOnetimeKeys(
     while ((off = mjson_next(keys, keysLen, off, &koff, &klen, &voff, &vlen, &vtype)) != 0) {\r
         static char keyJson[JSON_ONETIME_KEY_SIZE];\r
         \r
     while ((off = mjson_next(keys, keysLen, off, &koff, &klen, &voff, &vlen, &vtype)) != 0) {\r
         static char keyJson[JSON_ONETIME_KEY_SIZE];\r
         \r

-        snprintf(keyJson, JSON_ONETIME_KEY_SIZE,\r
-            "{\"key\":\"%.*s\"}",\r
-            vlen-2, keys + voff+1);\r
+        int keyJsonLen =\r
+            snprintf(keyJson, JSON_ONETIME_KEY_SIZE,\r
+                "{\"key\":\"%.*s\"}",\r
+                vlen-2, keys + voff+1);\r

 \r
         static char keyJsonSigned[JSON_ONETIME_KEY_SIGNED_SIZE];\r
 \r
         JsonSign(client,\r
 \r
         static char keyJsonSigned[JSON_ONETIME_KEY_SIGNED_SIZE];\r
 \r
         JsonSign(client,\r

-            keyJson, JSON_ONETIME_KEY_SIZE,\r
+            keyJson, keyJsonLen,\r

             keyJsonSigned, JSON_ONETIME_KEY_SIGNED_SIZE);\r
         \r
         mjson_snprintf(requestBuffer+strlen(requestBuffer), KEYS_UPLOAD_REQUEST_SIZE-strlen(requestBuffer),\r
             keyJsonSigned, JSON_ONETIME_KEY_SIGNED_SIZE);\r
         \r
         mjson_snprintf(requestBuffer+strlen(requestBuffer), KEYS_UPLOAD_REQUEST_SIZE-strlen(requestBuffer),\r


@@ -540,16 +566,33 @@ MatrixClientUploadOnetimeKeys(
             keyJsonSigned);\r
     }\r
 \r
             keyJsonSigned);\r
     }\r
 \r

-    mjson_snprintf(requestBuffer+strlen(requestBuffer)-1, KEYS_UPLOAD_REQUEST_SIZE-strlen(requestBuffer),\r
-        "}}");\r
+    if (requestBuffer[strlen(requestBuffer)-1] == ',')\r
+        requestBuffer[strlen(requestBuffer)-1] = '\0';\r
+\r
+    mjson_snprintf(requestBuffer+strlen(requestBuffer), KEYS_UPLOAD_REQUEST_SIZE-strlen(requestBuffer),\r
+        "}");\r
+        \r
+    // static char onetimeKeysSignedBuffer[KEYS_UPLOAD_REQUEST_SIGNED_SIZE];\r
+    // JsonSign(client,\r
+    //     requestBuffer, strlen(requestBuffer),\r
+    //     onetimeKeysSignedBuffer, KEYS_UPLOAD_REQUEST_SIZE);\r
+        \r
+    // static char finalEvent[KEYS_UPLOAD_REQUEST_SIGNED_SIZE];\r
+    // snprintf(finalEvent, KEYS_UPLOAD_REQUEST_SIGNED_SIZE,\r
+    // "{\"one_time_keys\":%s}", onetimeKeysSignedBuffer);\r
+    static char finalEvent[KEYS_UPLOAD_REQUEST_SIGNED_SIZE];\r
+    snprintf(finalEvent, KEYS_UPLOAD_REQUEST_SIGNED_SIZE,\r
+    "{\"one_time_keys\":%s}", requestBuffer);\r

 \r
     static char responseBuffer[KEYS_UPLOAD_RESPONSE_SIZE];\r
     MatrixHttpPost(client,\r
         KEYS_UPLOAD_URL,\r
 \r
     static char responseBuffer[KEYS_UPLOAD_RESPONSE_SIZE];\r
     MatrixHttpPost(client,\r
         KEYS_UPLOAD_URL,\r

-        requestBuffer,\r
+        finalEvent,\r

         responseBuffer, KEYS_UPLOAD_RESPONSE_SIZE,\r
         true);\r
 \r
         responseBuffer, KEYS_UPLOAD_RESPONSE_SIZE,\r
         true);\r
 \r

+    printf("%s\n", responseBuffer);\r
+\r

     return true;\r
 }\r
 \r
     return true;\r
 }\r
 \r


@@ -565,33 +608,39 @@ MatrixClientUploadDeviceKey(
 \r
     static char deviceKeysBuffer[KEYS_UPLOAD_REQUEST_SIZE];\r
 \r
 \r
     static char deviceKeysBuffer[KEYS_UPLOAD_REQUEST_SIZE];\r
 \r

-    mjson_snprintf(deviceKeysBuffer, KEYS_UPLOAD_REQUEST_SIZE,\r
-        "{\"device_keys\":{"\r
-            "\"algorithms\":[\"m.olm.v1.curve25519-aes-sha2\",\"m.megolm.v1.aes-sha2\"],"\r
-            "\"device_id\":\"%s\","\r
-            "\"keys\":{"\r
-                "\"curve25519:%s\":\"%s\","\r
-                "\"ed25519:%s\":\"%s\""\r
-            "},"\r
-            "\"user_id\":\"%s\""\r
-        "}}",\r
-        client->deviceId,\r
-        client->deviceId, thisDeviceKey,\r
-        client->deviceId, thisSigningKey,\r
-        client->userId);\r
+    int deviceKeysBufferLen =\r
+        mjson_snprintf(deviceKeysBuffer, KEYS_UPLOAD_REQUEST_SIZE,\r
+            "{"\r
+                "\"algorithms\":[\"m.olm.v1.curve25519-aes-sha2\",\"m.megolm.v1.aes-sha2\"],"\r
+                "\"device_id\":\"%s\","\r
+                "\"keys\":{"\r
+                    "\"curve25519:%s\":\"%s\","\r
+                    "\"ed25519:%s\":\"%s\""\r
+                "},"\r
+                "\"user_id\":\"%s\""\r
+            "}",\r
+            client->deviceId,\r
+            client->deviceId, thisDeviceKey,\r
+            client->deviceId, thisSigningKey,\r
+            client->userId);\r

 \r
     static char deviceKeysSignedBuffer[KEYS_UPLOAD_REQUEST_SIGNED_SIZE];\r
     JsonSign(client,\r
 \r
     static char deviceKeysSignedBuffer[KEYS_UPLOAD_REQUEST_SIGNED_SIZE];\r
     JsonSign(client,\r

-        deviceKeysBuffer, KEYS_UPLOAD_REQUEST_SIZE,\r
+        deviceKeysBuffer, deviceKeysBufferLen,\r

         deviceKeysSignedBuffer, KEYS_UPLOAD_REQUEST_SIZE);\r
         deviceKeysSignedBuffer, KEYS_UPLOAD_REQUEST_SIZE);\r

-\r
+    \r
+    static char finalEvent[KEYS_UPLOAD_REQUEST_SIGNED_SIZE];\r
+    snprintf(finalEvent, KEYS_UPLOAD_REQUEST_SIGNED_SIZE,\r
+    "{\"device_keys\":%s}", deviceKeysSignedBuffer);\r

 \r
     static char responseBuffer[KEYS_UPLOAD_RESPONSE_SIZE];\r
     MatrixHttpPost(client,\r
         KEYS_UPLOAD_URL,\r
 \r
     static char responseBuffer[KEYS_UPLOAD_RESPONSE_SIZE];\r
     MatrixHttpPost(client,\r
         KEYS_UPLOAD_URL,\r

-        deviceKeysSignedBuffer,\r
+        finalEvent,\r

         responseBuffer, KEYS_UPLOAD_RESPONSE_SIZE,\r
         true);\r
         responseBuffer, KEYS_UPLOAD_RESPONSE_SIZE,\r
         true);\r

+        \r
+    printf("%s\n", responseBuffer);\r

 \r
     return true;\r
 }\r
 \r
     return true;\r
 }\r


@@ -715,14 +764,14 @@ MatrixClientSendEvent(
 {    \r
     static char requestUrl[MAX_URL_LEN];\r
     sprintf(requestUrl,\r
 {    \r
     static char requestUrl[MAX_URL_LEN];\r
     sprintf(requestUrl,\r

-        ROOMEVENT_URL, roomId, msgType, (int)time(NULL));\r
+        ROOM_SEND_URL, roomId, msgType, (int)time(NULL));\r

 \r
 \r

-    static char responseBuffer[ROOMEVENT_RESPONSE_SIZE];\r
+    static char responseBuffer[ROOM_SEND_RESPONSE_SIZE];\r

     bool result =\r
         MatrixHttpPut(client,\r
             requestUrl,\r
             msgBody,\r
     bool result =\r
         MatrixHttpPut(client,\r
             requestUrl,\r
             msgBody,\r

-            responseBuffer, ROOMEVENT_RESPONSE_SIZE,\r
+            responseBuffer, ROOM_SEND_RESPONSE_SIZE,\r

             true);\r
     \r
     return result;\r
             true);\r
     \r
     return result;\r


@@ -738,7 +787,7 @@ MatrixClientSendEventEncrypted(
     const char * msgBody)\r
 {\r
     // event json\r
     const char * msgBody)\r
 {\r
     // event json\r

-    static char requestBuffer[ROOMEVENT_REQUEST_SIZE];\r
+    static char requestBuffer[ROOM_SEND_REQUEST_SIZE];\r

     sprintf(requestBuffer,\r
         "{"\r
         "\"type\":\"%s\","\r
     sprintf(requestBuffer,\r
         "{"\r
         "\"type\":\"%s\","\r


@@ -802,6 +851,27 @@ MatrixClientSync(
             true);\r
 }\r
 \r
             true);\r
 }\r
 \r

+// https://spec.matrix.org/v1.7/client-server-api/#get_matrixclientv3roomsroomideventeventid\r
+bool\r
+MatrixClientGetRoomEvent(\r
+    MatrixClient * client,\r
+    const char * roomId,\r
+    const char * eventId,\r
+    char * outEvent, int outEventCap)\r
+{\r
+    static char url[MAX_URL_LEN];\r
+    snprintf(url, MAX_URL_LEN,\r
+        "/_matrix/client/v3/rooms/%s/event/%s",\r
+            roomId,\r
+            eventId);\r
+\r
+    return\r
+        MatrixHttpGet(client,\r
+            url,\r
+            outEvent, outEventCap,\r
+            true);\r
+}\r
+\r

 bool\r
 MatrixClientShareMegolmOutSession(\r
     MatrixClient * client,\r
 bool\r
 MatrixClientShareMegolmOutSession(\r
     MatrixClient * client,\r


@@ -932,6 +1002,48 @@ MatrixClientInitMegolmOutSession(
     return false;\r
 }\r
 \r
     return false;\r
 }\r
 \r

+bool\r
+MatrixClientRequestMegolmInSession(\r
+    MatrixClient * client,\r
+    const char * roomId,\r
+    const char * sessionId,\r
+    const char * senderKey,\r
+    const char * userId,\r
+    const char * deviceId,\r
+    MatrixMegolmInSession * outMegolmInSession)\r
+{\r
+    // TODO: cancel requests\r
+    MatrixClientSendDummy(client, userId, deviceId);\r
+\r
+    static char event[ROOMKEY_REQUEST_SIZE];\r
+    snprintf(event, ROOMKEY_REQUEST_SIZE,\r
+        "{"\r
+            "\"action\":\"request\","\r
+            "\"body\":{"\r
+                "\"algorithm\":\"m.megolm.v1.aes-sha2\","\r
+                "\"room_id\":\"%s\","\r
+                "\"sender_key\":\"%s\","\r
+                "\"session_id\":\"%s\""\r
+            "},"\r
+            "\"request_id\":\"%d\","\r
+            "\"requesting_device_id\":\"%s\""\r
+        "}",\r
+        roomId,\r
+        senderKey,\r
+        sessionId,\r
+        time(NULL),\r
+        client->deviceId);\r
+\r
+    \r
+    MatrixClientSendToDevice(client,\r
+        userId,\r
+        deviceId,\r
+        event,\r
+        "m.room_key_request");\r
+\r
+    return true;\r
+}\r
+\r

 bool\r
 MatrixClientGetOlmSession(\r
     MatrixClient * client,\r
 bool\r
 MatrixClientGetOlmSession(\r
     MatrixClient * client,\r


@@ -1004,14 +1116,16 @@ MatrixClientSendToDevice(
         deviceId,\r
         message);\r
 \r
         deviceId,\r
         message);\r
 \r

-    static char responseBuffer[ROOMEVENT_RESPONSE_SIZE];\r
+    static char responseBuffer[ROOM_SEND_RESPONSE_SIZE];\r

     bool result =\r
         MatrixHttpPut(client,\r
             requestUrl,\r
             eventBuffer,\r
     bool result =\r
         MatrixHttpPut(client,\r
             requestUrl,\r
             eventBuffer,\r

-            responseBuffer, ROOMEVENT_RESPONSE_SIZE,\r
+            responseBuffer, ROOM_SEND_RESPONSE_SIZE,\r

             true);\r
     \r
             true);\r
     \r

+    printf("%s\n", responseBuffer);\r
+    \r

     return result;\r
 }\r
 \r
     return result;\r
 }\r
 \r


@@ -1097,6 +1211,20 @@ MatrixClientSendToDeviceEncrypted(
         "m.room.encrypted");\r
 }\r
 \r
         "m.room.encrypted");\r
 }\r
 \r

+bool\r
+MatrixClientSendDummy(\r
+    MatrixClient * client,\r
+    const char * userId,\r
+    const char * deviceId)\r
+{\r
+    return MatrixClientSendToDeviceEncrypted(\r
+        client,\r
+        userId,\r
+        deviceId,\r
+        "{}",\r
+        "m.dummy");\r
+}\r
+\r

 bool\r
 MatrixClientFindDevice(\r
     MatrixClient * client,\r
 bool\r
 MatrixClientFindDevice(\r
     MatrixClient * client,\r


@@ -1191,6 +1319,8 @@ MatrixClientRequestDeviceKeys(
     if (! requestResult)\r
         return false;\r
 \r
     if (! requestResult)\r
         return false;\r
 \r

+    printf("keys:\n%s\n", responseBuffer);\r
+\r

     // query for retrieving device keys for user id\r
     static char query[JSON_QUERY_SIZE];\r
     snprintf(query, JSON_QUERY_SIZE,\r
     // query for retrieving device keys for user id\r
     static char query[JSON_QUERY_SIZE];\r
     snprintf(query, JSON_QUERY_SIZE,\r

diff --git a/src/matrix.h b/src/matrix.h
index b51d0e99fc3469c612d21e09fd6c5312f7be0324..20cdc8ce94376c2cca113786dc9b11052c4692c7 100644 (file)
--- a/src/matrix.h
+++ b/src/matrix.h
@@ -119,6 +119,13 @@ MatrixOlmSessionEncrypt(
     const char * plaintext,\r
     char * outBuffer, int outBufferCap);\r
 \r
     const char * plaintext,\r
     char * outBuffer, int outBufferCap);\r
 \r

+bool\r
+MatrixOlmSessionDecrypt(\r
+    MatrixOlmSession * session,\r
+    size_t messageType,\r
+    char * encrypted,\r
+    char * outBuffer, int outBufferCap);\r
+\r

 \r
 // Matrix Megolm Session\r
 \r
 \r
 // Matrix Megolm Session\r
 \r


@@ -126,6 +133,12 @@ typedef struct MatrixMegolmInSession {
     OlmInboundGroupSession * session;\r
 } MatrixMegolmInSession;\r
 \r
     OlmInboundGroupSession * session;\r
 } MatrixMegolmInSession;\r
 \r

+bool\r
+MatrixMegolmInSessionDecrypt(\r
+    MatrixMegolmInSession * megolmInSession,\r
+    const char * encrypted,\r
+    char * outDecrypted, int outDecryptedCap);\r
+\r

 typedef struct MatrixMegolmOutSession {\r
     char roomId[ROOM_ID_SIZE];\r
 \r
 typedef struct MatrixMegolmOutSession {\r
     char roomId[ROOM_ID_SIZE];\r
 \r


@@ -264,6 +277,13 @@ MatrixClientSync(
     MatrixClient * client,\r
     char * outSync, int outSyncCap);\r
 \r
     MatrixClient * client,\r
     char * outSync, int outSyncCap);\r
 \r

+bool\r
+MatrixClientGetRoomEvent(\r
+    MatrixClient * client,\r
+    const char * roomId,\r
+    const char * eventId,\r
+    char * outEvent, int outEventCap);\r
+\r

 bool\r
 MatrixClientShareMegolmOutSession(\r
     MatrixClient * client,\r
 bool\r
 MatrixClientShareMegolmOutSession(\r
     MatrixClient * client,\r


@@ -294,6 +314,16 @@ bool
 MatrixClientInitMegolmOutSession(\r
     MatrixClient * client,\r
     const char * roomId);\r
 MatrixClientInitMegolmOutSession(\r
     MatrixClient * client,\r
     const char * roomId);\r

+    \r
+bool\r
+MatrixClientRequestMegolmInSession(\r
+    MatrixClient * client,\r
+    const char * roomId,\r
+    const char * sessionId,\r
+    const char * senderKey,\r
+    const char * userId,\r
+    const char * deviceId, // TODO: remove deviceId (query all devices)\r
+    MatrixMegolmInSession * outMegolmInSession);\r

 \r
 bool\r
 MatrixClientGetOlmSession(\r
 \r
 bool\r
 MatrixClientGetOlmSession(\r


@@ -318,6 +348,12 @@ MatrixClientSendToDeviceEncrypted(
     const char * message,\r
     const char * msgType);\r
 \r
     const char * message,\r
     const char * msgType);\r
 \r

+bool\r
+MatrixClientSendDummy(\r
+    MatrixClient * client,\r
+    const char * userId,\r
+    const char * deviceId);\r
+\r

 bool\r
 MatrixClientRequestDeviceKey(\r
     MatrixClient * client,\r
 bool\r
 MatrixClientRequestDeviceKey(\r
     MatrixClient * client,\r