@mtcute/core 0.1.0 → 0.1.2

package/esm/network/session-connection.js

@@ -2,10 +2,10 @@
 // will be reworked in MTQ-32
 import Long from 'long';
 import { tl } from '@mtcute/tl';
-import { gzipDeflate, gzipInflate, TlBinaryReader, TlBinaryWriter, TlSerializationCounter, } from '@mtcute/tl-runtime';
+import { TlBinaryReader, TlBinaryWriter, TlSerializationCounter } from '@mtcute/tl-runtime';
 import { MtArgumentError, MtcuteError, MtTimeoutError } from '../types/index.js';
 import { createAesIgeForMessageOld } from '../utils/crypto/mtproto.js';
-import { concatBuffers, createControllablePromise, EarlyTimer, longFromBuffer, randomBytes, randomLong, removeFromLongArray, } from '../utils/index.js';
+import { concatBuffers, createControllablePromise, EarlyTimer, longFromBuffer, randomLong, removeFromLongArray, } from '../utils/index.js';
 import { reportUnknownError } from '../utils/platform/error-reporting.js';
 import { doAuthorization } from './authorization.js';
 import { PersistentConnection } from './persistent-connection.js';
@@ -13,6 +13,12 @@ import { TransportError } from './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')
@@ -37,6 +43,7 @@ export class SessionConnection extends 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) {
@@ -172,9 +179,9 @@ export class SessionConnection extends PersistentConnection {
         }
         this._session.authorizationPending = true;
         this.emit('auth-begin');
-        doAuthorization(this, this.params.crypto)
-            .then(async ([authKey, serverSalt, timeOffset]) => {
-            await this._session._authKey.setup(authKey);
+        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;
@@ -212,14 +219,14 @@ export class SessionConnection extends PersistentConnection {
         else {
             this._isPfsBindingPending = true;
         }
-        doAuthorization(this, this.params.crypto, TEMP_AUTH_KEY_EXPIRY)
+        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
@@ -234,18 +241,18 @@ export class SessionConnection extends PersistentConnection {
             // encrypt using mtproto v1 (fucking kill me plz)
             const writer = TlBinaryWriter.alloc(this.params.writerMap, 80);
             // = 40 (inner length) + 32 (mtproto header) + 8 (pad 72 so mod 16 = 0)
-            writer.raw(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(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 createAesIgeForMessageOld(this.params.crypto, this._session._authKey.key, msgKey, true);
-            const encryptedData = await ige.encrypt(msgWithPadding);
+            const ige = createAesIgeForMessageOld(this._crypto, this._session._authKey.key, msgKey, true);
+            const encryptedData = ige.encrypt(msgWithPadding);
             const encryptedMessage = concatBuffers([this._session._authKey.id, msgKey, encryptedData]);
             const promise = createControllablePromise();
             // encrypt the message using temp key and same msg id
@@ -277,7 +284,7 @@ export class SessionConnection extends 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);
@@ -329,7 +336,7 @@ export class SessionConnection extends 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) {
@@ -348,23 +355,18 @@ export class SessionConnection extends 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 TlBinaryReader(this._readerMap, 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 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
@@ -377,13 +379,11 @@ export class SessionConnection extends 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()) {
@@ -529,7 +529,21 @@ export class SessionConnection extends 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 = 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) {
@@ -920,12 +934,13 @@ export class SessionConnection extends 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 = 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 = 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;
@@ -1197,7 +1212,7 @@ export class SessionConnection extends 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 = [];
@@ -1338,18 +1353,17 @@ export class SessionConnection extends 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');
+            }
         });
     }
 }