Wrote unit tests and found and fixed bugs

utils/binary_reader.py

@@ -1,5 +1,6 @@
 from io import BytesIO, BufferedReader
 from tl.all_tlobjects import tlobjects
+from struct import unpack
 import os
 
 
@@ -20,17 +21,30 @@ class BinaryReader:
 
     # region Reading
 
+    def read_byte(self):
+        """Reads a single byte value"""
+        return self.reader.read(1)[0]
+
     def read_int(self, signed=True):
         """Reads an integer (4 bytes) value"""
-        return int.from_bytes(self.reader.read(4), signed=signed, byteorder='big')
+        return int.from_bytes(self.reader.read(4), byteorder='big', signed=signed)
 
     def read_long(self, signed=True):
         """Reads a long integer (8 bytes) value"""
-        return int.from_bytes(self.reader.read(8), signed=signed, byteorder='big')
+        return int.from_bytes(self.reader.read(8), byteorder='big', signed=signed)
 
-    def read_large_int(self, bits):
+    # Network is always big-endian, this is, '>'
+    def read_float(self):
+        """Reads a real floating point (4 bytes) value"""
+        return unpack('>f', self.reader.read(4))[0]
+
+    def read_double(self):
+        """Reads a real floating point (8 bytes) value"""
+        return unpack('>d', self.reader.read(8))[0]
+
+    def read_large_int(self, bits, signed=True):
         """Reads a n-bits long integer value"""
-        return int.from_bytes(self.reader.read(bits // 8), byteorder='big')
+        return int.from_bytes(self.reader.read(bits // 8), byteorder='big', signed=signed)
 
     def read(self, length):
         """Read the given amount of bytes"""
@@ -38,7 +52,7 @@ class BinaryReader:
 
     def get_bytes(self):
         """Gets the byte array representing the current buffer as a whole"""
-        return self.stream.getbuffer()
+        return self.stream.getvalue()
 
     # endregion
 
@@ -46,9 +60,9 @@ class BinaryReader:
 
     def tgread_bytes(self):
         """Reads a Telegram-encoded byte array, without the need of specifying its length"""
-        first_byte = self.read(1)
+        first_byte = self.read_byte()
         if first_byte == 254:
-            length = self.read(1) | (self.read(1) << 8) | (self.read(1) << 16)
+            length = self.read_byte() | (self.read_byte() << 8) | (self.read_byte() << 16)
             padding = length % 4
         else:
             length = first_byte

utils/binary_writer.py

@@ -23,31 +23,28 @@ class BinaryWriter:
 
     def write_int(self, value, signed=True):
         """Writes an integer value (4 bytes), which can or cannot be signed"""
-        if signed:
-            self.writer.write(pack('i', value))
-        else:
+        if not signed:
             value &= 0xFFFFFFFF  # Ensure it's unsigned (see http://stackoverflow.com/a/30092291/4759433)
-            self.writer.write(pack('I', value))
+        self.writer.write(int.to_bytes(value, length=4, byteorder='big', signed=signed))
 
     def write_long(self, value, signed=True):
         """Writes a long integer value (8 bytes), which can or cannot be signed"""
-        if signed:
-            self.writer.write(pack('q', value))
-        else:
+        if not signed:
             value &= 0xFFFFFFFFFFFFFFFF
-            self.writer.write(pack('Q', value))
+        self.writer.write(int.to_bytes(value, length=8, byteorder='big', signed=signed))
 
+    # Network is always big-endian, this is, '>' when packing
     def write_float(self, value):
         """Writes a floating point value (4 bytes)"""
-        self.writer.write(pack('f', value))
+        self.writer.write(pack('>f', value))
 
     def write_double(self, value):
         """Writes a floating point value (8 bytes)"""
-        self.writer.write(pack('d', value))
+        self.writer.write(pack('>d', value))
 
-    def write_large_int(self, value, bits):
+    def write_large_int(self, value, bits, signed=True):
         """Writes a n-bits long integer value"""
-        self.writer.write(pack('{}B'.format(bits // 8), value))
+        self.writer.write(int.to_bytes(value, length=bits // 8, byteorder='big', signed=signed))
 
     def write(self, data):
         """Writes the given bytes array"""
@@ -111,7 +108,7 @@ class BinaryWriter:
         """Get the current bytes array content from the buffer, optionally flushing first"""
         if flush:
             self.writer.flush()
-        self.stream.getbuffer()
+        return self.stream.getvalue()
 
     # with block
     def __enter__(self):

utils/helpers.py

@@ -1,24 +1,16 @@
-import random
+import os
 from utils.binary_writer import BinaryWriter
 from hashlib import sha1
 
 
 def generate_random_long(signed=True):
     """Generates a random long integer (8 bytes), which is optionally signed"""
-    result = random.getrandbits(64)
-    if not signed:
-        result &= 0xFFFFFFFFFFFFFFFF  # Ensure it's unsigned
-
-    return result
+    return int.from_bytes(os.urandom(8), signed=signed)
 
 
 def generate_random_bytes(count):
     """Generates a random bytes array"""
-    with BinaryWriter() as writer:
-        for _ in range(count):
-            writer.write(random.getrandbits(8))
-
-    return writer.get_bytes()
+    return os.urandom(count)
 
 
 def calc_key(shared_key, msg_key, client):