def pack(self): return bytes( integer_to_bytes(self.duration, 2) + integer_to_bytes(self.tracksOffset, 2) + integer_to_bytes(self.trackCount, 2) + integer_to_bytes(self.animationEvent, 1) + integer_to_bytes(self.specialColorType, 1))
def light_up_face(self, face, color: Color32, remapFace=0, layoutIndex=255, remapRot=255): data = [] data.extend(integer_to_bytes(face, 1)) data.extend(integer_to_bytes(remapFace, 1)) data.extend(integer_to_bytes(layoutIndex, 1)) data.extend(integer_to_bytes(remapRot, 1)) data.extend(integer_to_bytes(color.to_rgb(), 4)) self._send(MessageType.LightUpFace, *data)
def confirm_call(self, call): self._discard_ended_voips() if self.call_status(call.id) != VoIP.CALL_STATE_REQUESTED: return False voip = self.get_voip(call.id) dhc = self._get_dh_config() g_b = int.from_bytes(call.g_b, 'big') check_g(g_b, dhc.p) key = pow(g_b, voip.storage['a'], dhc.p) bytes_key = integer_to_bytes(key) key_fingerprint = calc_fingerprint(integer_to_bytes(key)) call = self.client.send( ConfirmCall(key_fingerprint=key_fingerprint, peer=InputPhoneCall(call.id, call.access_hash), g_a=voip.storage['g_a'], protocol=self._get_protocol())).phone_call return self._configure_voip(voip, call, bytes_key, key_fingerprint, voip.storage['g_a'])
def request_call(self, user_id): self._discard_ended_voips() peer = self.client.resolve_peer(user_id) dhc = self._get_dh_config() a = random.randint(2, dhc.p - 1) g_a = pow(dhc.g, a, dhc.p) check_g(g_a, dhc.p) g_a_hash = hashlib.sha256(integer_to_bytes(g_a)).digest() protocol = self._get_protocol() call = self.client.send( RequestCall( user_id=peer, random_id=random.randint(0, 0x7fffffff - 1), g_a_hash=g_a_hash, protocol=protocol, )) voip = self.voips[call.phone_call.id] = VoIP( True, peer.user_id, InputPhoneCall(call.phone_call.id, call.phone_call.access_hash), self, VoIP.CALL_STATE_REQUESTED, protocol) voip.storage = {'a': a, 'g_a': integer_to_bytes(g_a).ljust(256, b'\0')} return voip
async def _upload_bulk_data(self, data: bytes, progress_callback, timeout=DEFAULT_TIMEOUT): assert (len(data)) assert (timeout >= 0) # Send setup message await self._send_and_ack(MessageType.BulkSetup, integer_to_bytes(len(data), 2), MessageType.BulkSetupAck, timeout) # Then transfer data total_size = len(data) remainingSize = total_size offset = 0 while remainingSize > 0: size = min(remainingSize, PixelLink.PIXELS_MESSAGE_BULK_DATA_SIZE) header = [size] + integer_to_bytes(offset, 2) await self._send_and_ack(MessageType.BulkData, header + data[offset:offset + size], MessageType.BulkDataAck, timeout) if progress_callback != None: progress_callback(offset, total_size) remainingSize -= size offset += size
def find_smallest_s(lower_bound, c): """ Find the smallest s >= lower_bound, such that (c * s^e) (mod n) decrypts to a PKCS conforming string """ s = lower_bound while True: attempt = (c * pow(s, e, n)) % n attempt = utils.integer_to_bytes(attempt) if oracle(attempt): return s s += 1
def complete_call(self, call): self._discard_ended_voips() voip = self.get_voip(call.id) if self.call_status( call.id) != VoIP.CALL_STATE_ACCEPTED or not voip.storage.get( 'b'): return False dhc = self._get_dh_config() if hashlib.sha256(call.g_a_or_b).digest() != voip.storage['g_a_hash']: raise RuntimeError('Invalid g_a') g_a_or_b = int.from_bytes(call.g_a_or_b, 'big') check_g(g_a_or_b, dhc.p) key = pow(g_a_or_b, voip.storage['b'], dhc.p) bytes_key = integer_to_bytes(key) key_fingerprint = calc_fingerprint(bytes_key) if key_fingerprint != call.key_fingerprint: raise RuntimeError('Invalid fingerprint') return self._configure_voip(voip, call, bytes_key, key_fingerprint, call.g_a_or_b)
def accept_call(self, call): self._discard_ended_voips() if self.call_status(call.id) != VoIP.CALL_STATE_ACCEPTED: return False dhc = self._get_dh_config() b = random.randint(2, dhc.p - 1) g_b = pow(dhc.g, b, dhc.p) check_g(g_b, dhc.p) try: res = self.client.send( AcceptCall(peer=call, g_b=integer_to_bytes(g_b), protocol=self._get_protocol())) except errors.Error as e: if e.CODE == 'CALL_ALREADY_ACCEPTED': return True elif e.CODE == 'CALL_ALREADY_DECLINED': return False raise e self.get_voip(res.phone_call.id).storage['b'] = b return True
def find_s_in_range(a, b, prev_s, B, c): """ Given the interval [a, b], reduce the search only to relevant regions (determined by r) and stop when an s value that gives a PKCS1 conforming string is found. """ ri = ceil(2 * (b * prev_s - 2 * B), n) while True: si_lower = ceil(2 * B + ri * n, b) si_upper = ceil(3 * B + ri * n, a) for si in range(si_lower, si_upper): attempt = (c * pow(si, e, n)) % n attempt = utils.integer_to_bytes(attempt) if oracle(attempt): return si ri += 1
def bleichenbacher(ciphertext): """ Perform Bleichenbacher attack as described in his paper. """ # Step 1. is only needed when the ciphertext is # not PKCS1 conforming # integer value of ciphertext c = utils.bytes_to_integer(ciphertext) B = 2**(8 * (k - 2)) M = [Interval(2 * B, 3 * B - 1)] # Step 2.A. s = find_smallest_s(ceil(n, 3 * B), c) M = update_intervals(M, s, B) while True: # Step 2.B. if len(M) >= 2: s = find_smallest_s(s + 1, c) # Step 2.C. elif len(M) == 1: a, b = M[0] # Step 4. if a == b: return utils.integer_to_bytes(a % n) s = find_s_in_range(a, b, s, B, c) M = update_intervals(M, s, B)
def encrypt_string(public_key, message): integer = utils.bytes_to_integer(message) enc_integer = encrypt_integer(public_key, integer) enc_string = utils.integer_to_bytes(enc_integer) return enc_string
def decrypt_string(secret_key, ciphertext): enc_integer = utils.bytes_to_integer(ciphertext) integer = decrypt_integer(secret_key, enc_integer) message = utils.integer_to_bytes(integer) return message
def force_LED_color(self, ledIndex, color: Color32): """ Led index starts at 0 """ data = [] data.extend(integer_to_bytes(ledIndex, 1)) data.extend(integer_to_bytes(color.to_rgb(), 4)) self._send(MessageType.SetLEDToColor, *data)
def force_LEDs_color(self, color: Color32): c = integer_to_bytes(color.to_rgb(), 4) self._send(MessageType.SetAllLEDsToColor, *c)
def append(dword): data.extend(integer_to_bytes(dword, 2))
def pack(self): return bytes( integer_to_bytes(self.trackOffset, 2) + integer_to_bytes(self.ledIndex, 1) + [0]) # padding
def pack(self): return bytes( integer_to_bytes(self.keyframesOffset, 2) + integer_to_bytes(self.keyFrameCount, 1) + [0]) # padding
def pack(self): return integer_to_bytes(self.timeAndColor, 2)