@mtcute/core 0.1.0 → 0.1.2

package/cjs/network/session-connection.js

@@ -19,6 +19,12 @@ const abstract_js_1 = require("./transports/abstract.js");
 const TEMP_AUTH_KEY_EXPIRY = 86400;
 // destroy_auth_key#d1435160 = DestroyAuthKeyRes;
 // const DESTROY_AUTH_KEY = Buffer.from('605134d1', 'hex')
+// gzip_packed#3072cfa1 packed_data:string = Object;
+const GZIP_PACKED_ID = 0x3072cfa1;
+// msg_container#73f1f8dc messages:vector<%Message> = MessageContainer;
+const MSG_CONTAINER_ID = 0x73f1f8dc;
+// rpc_result#f35c6d01 req_msg_id:long result:Object = RpcResult;
+const RPC_RESULT_ID = 0xf35c6d01;
 function makeNiceStack(error, stack, method) {
     error.stack = `RpcError (${error.code} ${error.text}): ${error.message}\n    at ${method}\n${stack
         .split('\n')
@@ -43,6 +49,7 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
         this._flushTimer.onTimeout(this._flush.bind(this));
         this._readerMap = params.readerMap;
         this._writerMap = params.writerMap;
+        this._crypto = params.crypto;
         this._handleRawMessage = this._handleRawMessage.bind(this);
     }
     getAuthKey(temp = false) {
@@ -178,9 +185,9 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
         }
         this._session.authorizationPending = true;
         this.emit('auth-begin');
-        (0, authorization_js_1.doAuthorization)(this, this.params.crypto)
-            .then(async ([authKey, serverSalt, timeOffset]) => {
-            await this._session._authKey.setup(authKey);
+        (0, authorization_js_1.doAuthorization)(this, this._crypto)
+            .then(([authKey, serverSalt, timeOffset]) => {
+            this._session._authKey.setup(authKey);
             this._session.serverSalt = serverSalt;
             this._session._timeOffset = timeOffset;
             this._session.authorizationPending = false;
@@ -218,14 +225,14 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
         else {
             this._isPfsBindingPending = true;
         }
-        (0, authorization_js_1.doAuthorization)(this, this.params.crypto, TEMP_AUTH_KEY_EXPIRY)
+        (0, authorization_js_1.doAuthorization)(this, this._crypto, TEMP_AUTH_KEY_EXPIRY)
             .then(async ([tempAuthKey, tempServerSalt]) => {
             if (!this._usePfs) {
                 this.log.info('pfs has been disabled while generating temp key');
                 return;
             }
             const tempKey = this._session._authKeyTempSecondary;
-            await tempKey.setup(tempAuthKey);
+            tempKey.setup(tempAuthKey);
             const msgId = this._session.getMessageId();
             this.log.debug('binding temp_auth_key (%h) to perm_auth_key (%h), msg_id = %l...', tempKey.id, this._session._authKey.id, msgId);
             // we now need to bind the key
@@ -240,18 +247,18 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
             // encrypt using mtproto v1 (fucking kill me plz)
             const writer = tl_runtime_1.TlBinaryWriter.alloc(this.params.writerMap, 80);
             // = 40 (inner length) + 32 (mtproto header) + 8 (pad 72 so mod 16 = 0)
-            writer.raw((0, index_js_2.randomBytes)(16));
+            writer.raw(this._crypto.randomBytes(16));
             writer.long(msgId);
             writer.int(0); // seq_no
             writer.int(40); // msg_len
             writer.object(inner);
             const msgWithoutPadding = writer.result();
-            writer.raw((0, index_js_2.randomBytes)(8));
+            writer.raw(this._crypto.randomBytes(8));
             const msgWithPadding = writer.result();
-            const hash = await this.params.crypto.sha1(msgWithoutPadding);
+            const hash = this._crypto.sha1(msgWithoutPadding);
             const msgKey = hash.subarray(4, 20);
-            const ige = await (0, mtproto_js_1.createAesIgeForMessageOld)(this.params.crypto, this._session._authKey.key, msgKey, true);
-            const encryptedData = await ige.encrypt(msgWithPadding);
+            const ige = (0, mtproto_js_1.createAesIgeForMessageOld)(this._crypto, this._session._authKey.key, msgKey, true);
+            const encryptedData = ige.encrypt(msgWithPadding);
             const encryptedMessage = (0, index_js_2.concatBuffers)([this._session._authKey.id, msgKey, encryptedData]);
             const promise = (0, index_js_2.createControllablePromise)();
             // encrypt the message using temp key and same msg id
@@ -283,7 +290,7 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
             reqWriter.uint(reqSize);
             reqWriter.object(request);
             // we can now send it as is
-            const requestEncrypted = await tempKey.encryptMessage(reqWriter.result(), tempServerSalt, this._session._sessionId);
+            const requestEncrypted = tempKey.encryptMessage(reqWriter.result(), tempServerSalt, this._session._sessionId);
             await this.send(requestEncrypted);
             const res = await promise;
             this._session.pendingMessages.delete(msgId);
@@ -335,7 +342,7 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
         this._pendingWaitForUnencrypted.push([promise, timeoutId]);
         return promise;
     }
-    async onMessage(data) {
+    onMessage(data) {
         if (this._pendingWaitForUnencrypted.length) {
             const int32 = new Int32Array(data.buffer, data.byteOffset, 2);
             if (int32[0] === 0 && int32[1] === 0) {
@@ -354,23 +361,18 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
             return;
         }
         try {
-            await this._session.decryptMessage(data, this._handleRawMessage);
+            this._session.decryptMessage(data, this._handleRawMessage);
         }
         catch (err) {
             this.log.error('failed to decrypt message: %s\ndata: %h', err, data);
         }
     }
     _handleRawMessage(messageId, seqNo, message) {
-        if (message.peekUint() === 0x3072cfa1) {
-            // gzip_packed
-            // we can't use message.gzip() because it may contain msg_container,
-            // so we parse it manually.
-            message.uint();
-            return this._handleRawMessage(messageId, seqNo, new tl_runtime_1.TlBinaryReader(this._readerMap, (0, tl_runtime_1.gzipInflate)(message.bytes())));
-        }
-        if (message.peekUint() === 0x73f1f8dc) {
-            // msg_container
-            message.uint();
+        const objectId = message.uint();
+        if (objectId === GZIP_PACKED_ID) {
+            return this._handleRawMessage(messageId, seqNo, new tl_runtime_1.TlBinaryReader(this._readerMap, this._crypto.gunzip(message.bytes())));
+        }
+        if (objectId === MSG_CONTAINER_ID) {
             const count = message.uint();
             for (let i = 0; i < count; i++) {
                 // msg_id:long seqno:int bytes:int
@@ -383,13 +385,11 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
             }
             return;
         }
-        if (message.peekUint() === 0xf35c6d01) {
-            // rpc_result
-            message.uint();
+        if (objectId === RPC_RESULT_ID) {
             return this._onRpcResult(messageId, message);
         }
         // we are safe.. i guess
-        this._handleMessage(messageId, message.object());
+        this._handleMessage(messageId, message.object(objectId));
     }
     _handleMessage(messageId, message_) {
         if (messageId.isEven()) {
@@ -535,7 +535,21 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
         }
         const rpc = msg.rpc;
         const customReader = this._readerMap._results[rpc.method];
-        const result = customReader ? customReader(message) : message.object();
+        let result;
+        if (customReader) {
+            result = customReader(message);
+        }
+        else {
+            const objectId = message.uint();
+            if (objectId === GZIP_PACKED_ID) {
+                const inner = this._crypto.gunzip(message.bytes());
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                result = tl_runtime_1.TlBinaryReader.deserializeObject(this._readerMap, inner);
+            }
+            else {
+                result = message.object(objectId);
+            }
+        }
         // initConnection call was definitely received and
         // processed by the server, so we no longer need to use it
         if (rpc.initConn) {
@@ -926,12 +940,13 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
             // test compression ratio for the middle part
             // if it is less than 0.9, then try to compress the whole request
             const middle = ~~((content.length - 1024) / 2);
-            const gzipped = (0, tl_runtime_1.gzipDeflate)(content.subarray(middle, middle + 1024), 0.9);
+            const middlePart = content.subarray(middle, middle + 1024);
+            const gzipped = this._crypto.gzip(middlePart, Math.floor(middlePart.length * 0.9));
             if (!gzipped)
                 shouldGzip = false;
         }
         if (shouldGzip) {
-            const gzipped = (0, tl_runtime_1.gzipDeflate)(content, 0.9);
+            const gzipped = this._crypto.gzip(content, Math.floor(content.length * 0.9));
             if (gzipped) {
                 this.log.debug('gzipped %s (%db -> %db)', method, content.length, gzipped.length);
                 content = gzipped;
@@ -1203,7 +1218,7 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
             // leave bytes for mtproto header (we'll write it later,
             // since we need seqno and msg_id to be larger than the content)
             writer.pos += 16;
-            writer.uint(0x73f1f8dc); // msg_container
+            writer.uint(MSG_CONTAINER_ID);
             writer.uint(messageCount);
         }
         const otherPendings = [];
@@ -1344,18 +1359,17 @@ class SessionConnection extends persistent_connection_js_1.PersistentConnection
             });
         }
         const result = writer.result();
-        // probably the easiest way lol
         this.log.debug('sending %d messages: size = %db, acks = %d (msg_id = %s), ping = %s (msg_id = %s), state_req = %s (msg_id = %s), resend = %s (msg_id = %s), cancels = %s (msg_id = %s), rpc = %s, container = %s, root msg_id = %l', messageCount, packetSize, ackMsgIds?.length || 'false', ackMsgIds?.map((it) => it.toString()), Boolean(pingRequest), pingMsgId, getStateMsgIds?.map((it) => it.toString()) || 'false', getStateMsgId, resendMsgIds?.map((it) => it.toString()) || 'false', cancelRpcs, cancelRpcs?.map((it) => it.toString()) || 'false', resendMsgId, rpcToSend.map((it) => it.method), useContainer, rootMsgId);
-        this._session
-            .encryptMessage(result)
-            .then((enc) => this.send(enc))
-            .catch((err) => {
+        const enc = this._session.encryptMessage(result);
+        this.send(enc).catch((err) => {
             this.log.error('error while sending pending messages (root msg_id = %l): %s', rootMsgId, err.stack);
             // put acks in the front so they are the first to be sent
             if (ackMsgIds) {
                 this._session.queuedAcks.splice(0, 0, ...ackMsgIds);
             }
-            this._onMessageFailed(rootMsgId, 'unknown error');
+            if (rootMsgId) {
+                this._onMessageFailed(rootMsgId, 'unknown error');
+            }
         });
     }
 }