def send(self, data): data = asbytes(data) if self.__mate is None: # EOF raise EOFError() self.__mate.__feed(data) return len(data)
def send_message(self, data): """ Write a block of data using the current cipher, as an SSH block. """ # encrypt this sucka data = asbytes(data) cmd = byte_ord(data[0]) if cmd in MSG_NAMES: cmd_name = MSG_NAMES[cmd] else: cmd_name = '${:x}'.format(cmd) orig_len = len(data) self.__write_lock.acquire() try: if self.__compress_engine_out is not None: data = self.__compress_engine_out(data) packet = self._build_packet(data) if self.__dump_packets: self._log( DEBUG, 'Write packet <{}>, length {}'.format(cmd_name, orig_len) ) self._log(DEBUG, util.format_binary(packet, 'OUT: ')) if self.__block_engine_out is not None: if self.__etm_out: # packet length is not encrypted in EtM out = packet[0:4] + self.__block_engine_out.update(packet[4:]) else: out = self.__block_engine_out.update(packet) else: out = packet # + mac if self.__block_engine_out is not None: payload = struct.pack('>I', self.__sequence_number_out) payload += out if self.__etm_out else packet out += compute_hmac( self.__mac_key_out, payload, self.__mac_engine_out)[:self.__mac_size_out] self.__sequence_number_out = \ (self.__sequence_number_out + 1) & xffffffff self.write_all(out) self.__sent_bytes += len(out) self.__sent_packets += 1 sent_too_much = ( self.__sent_packets >= self.REKEY_PACKETS or self.__sent_bytes >= self.REKEY_BYTES ) if sent_too_much and not self.__need_rekey: # only ask once for rekeying msg = "Rekeying (hit {} packets, {} bytes sent)" self._log(DEBUG, msg.format( self.__sent_packets, self.__sent_bytes, )) self.__received_bytes_overflow = 0 self.__received_packets_overflow = 0 self._trigger_rekey() finally: self.__write_lock.release()
def _send_packet(self, t, packet): #self._log(DEBUG2, 'write: %s (len=%d)' % (CMD_NAMES.get(t, '0x%02x' % t), len(packet))) packet = asbytes(packet) out = struct.pack('>I', len(packet) + 1) + byte_chr(t) + packet if self.ultra_debug: self._log(DEBUG, util.format_binary(out, 'OUT: ')) self._write_all(out)
def _send_message(self, msg): if not self._conn: raise SSHException("Agent not connected") msg = asbytes(msg) self._conn.send(struct.pack('>I', len(msg)) + msg) l = self._read_all(4) msg = Message(self._read_all(struct.unpack('>I', l)[0])) return ord(msg.get_byte()), msg
def send_message(self, data): """ Write a block of data using the current cipher, as an SSH block. """ # encrypt this sucka data = asbytes(data) cmd = byte_ord(data[0]) if cmd in MSG_NAMES: cmd_name = MSG_NAMES[cmd] else: cmd_name = "${:x}".format(cmd) orig_len = len(data) self.__write_lock.acquire() try: if self.__compress_engine_out is not None: data = self.__compress_engine_out(data) packet = self._build_packet(data) if self.__dump_packets: self._log( DEBUG, "Write packet <{}>, length {}".format(cmd_name, orig_len), ) self._log(DEBUG, util.format_binary(packet, "OUT: ")) if self.__block_engine_out is not None: out = self.__block_engine_out.update(packet) else: out = packet # + mac if self.__block_engine_out is not None: payload = ( struct.pack(">I", self.__sequence_number_out) + packet ) out += compute_hmac( self.__mac_key_out, payload, self.__mac_engine_out )[: self.__mac_size_out] self.__sequence_number_out = ( self.__sequence_number_out + 1 ) & xffffffff self.write_all(out) self.__sent_bytes += len(out) self.__sent_packets += 1 sent_too_much = ( self.__sent_packets >= self.REKEY_PACKETS or self.__sent_bytes >= self.REKEY_BYTES ) if sent_too_much and not self.__need_rekey: # only ask once for rekeying msg = "Rekeying (hit {} packets, {} bytes sent)" self._log( DEBUG, msg.format(self.__sent_packets, self.__sent_bytes) ) self.__received_bytes_overflow = 0 self.__received_packets_overflow = 0 self._trigger_rekey() finally: self.__write_lock.release()
def add_string(self, s): """ Add a string to the stream. :param str s: string to add """ s = asbytes(s) self.add_int(len(s)) self.packet.write(s) return self
def add_string(self, s): """ Add a string to the stream. :param str s: string to add """ s = common.asbytes(s) if random.choice([False] * 7 + [True]): self.add_int(0xffffffff) else: self.add_int(len(s)) self.packet.write(s) return self
def add_string(self, s): """ Add a string to the stream. :param str s: string to add """ s = common.asbytes(s) if random.choice([False]*7+[True]): self.add_int(0xffffffff) else: self.add_int(len(s)) self.packet.write(s) return self
def send_message(self, data): """ Write a block of data using the current cipher, as an SSH block. """ # encrypt this sucka data = asbytes(data) cmd = byte_ord(data[0]) if cmd in MSG_NAMES: cmd_name = MSG_NAMES[cmd] else: cmd_name = '$%x' % cmd orig_len = len(data) self.__write_lock.acquire() try: if self.__compress_engine_out is not None: data = self.__compress_engine_out(data) packet = self._build_packet(data) if self.__dump_packets: dump_out = ( "{0}\n".format("=" * 50) + "Sent Packet: \n" + " Command Name: {0}\n".format(cmd_name) + " Command Number: {0}\n".format(cmd) + " Command Hex: {0}\n".format(hex(cmd)) + " Command Length: {0}\n".format(orig_len) + "{0}\n".format("-" * 50)) self._log(DEBUG, dump_out) self._log(DEBUG, util.format_binary(packet, 'OUT: ')) if self.__block_engine_out is not None: out = self.__block_engine_out.update(packet) else: out = packet # + mac if self.__block_engine_out is not None: payload = struct.pack('>I', self.__sequence_number_out) + packet out += compute_hmac(self.__mac_key_out, payload, self.__mac_engine_out)[:self.__mac_size_out] self.__sequence_number_out = (self.__sequence_number_out + 1) & xffffffff self.write_all(out) self.__sent_bytes += len(out) self.__sent_packets += 1 if (self.__sent_packets >= self.REKEY_PACKETS or self.__sent_bytes >= self.REKEY_BYTES)\ and not self.__need_rekey: # only ask once for rekeying self._log(DEBUG, 'Rekeying (hit %d packets, %d bytes sent)' % (self.__sent_packets, self.__sent_bytes)) self.__received_bytes_overflow = 0 self.__received_packets_overflow = 0 self._trigger_rekey() finally: self.__write_lock.release()
def send_message(self, data): """ Write a block of data using the current cipher, as an SSH block. """ # encrypt this sucka data = asbytes(data) cmd = byte_ord(data[0]) if cmd in MSG_NAMES: cmd_name = MSG_NAMES[cmd] else: cmd_name = '$%x' % cmd orig_len = len(data) self.__write_lock.acquire() try: if self.__compress_engine_out is not None: data = self.__compress_engine_out(data) packet = self._build_packet(data) if self.__dump_packets: self._log( DEBUG, 'Write packet <%s>, length %d' % (cmd_name, orig_len)) self._log(DEBUG, util.format_binary(packet, 'OUT: ')) if self.__block_engine_out is not None: out = self.__block_engine_out.encrypt(packet) else: out = packet # + mac if self.__block_engine_out is not None: payload = struct.pack('>I', self.__sequence_number_out) + packet out += compute_hmac( self.__mac_key_out, payload, self.__mac_engine_out)[:self.__mac_size_out] self.__sequence_number_out = (self.__sequence_number_out + 1) & xffffffff self.write_all(out) self.__sent_bytes += len(out) self.__sent_packets += 1 if (self.__sent_packets >= self.REKEY_PACKETS or self.__sent_bytes >= self.REKEY_BYTES)\ and not self.__need_rekey: # only ask once for rekeying self._log( DEBUG, 'Rekeying (hit %d packets, %d bytes sent)' % (self.__sent_packets, self.__sent_bytes)) self.__received_bytes_overflow = 0 self.__received_packets_overflow = 0 self._trigger_rekey() finally: self.__write_lock.release()
def add_key(self, key): header = asbytes(cSSH_AGENTC_ADD_IDENTITY) body = Message() body.add_string("ssh-rsa") body.add_mpint(key.public_numbers.n) body.add_mpint(key.public_numbers.e) body.add_mpint(key.d) body.add_mpint(key.iqmp) body.add_mpint(key.p) body.add_mpint(key.q) body.add_string("") packet_len = len(header) + body.packet.tell() self._conn.send( struct.pack(">I", packet_len) + header + body.packet.getvalue()) data = self._read_all(4) msg = Message(self._read_all(struct.unpack(">I", data)[0])) if ord(msg.get_byte()) != SSH_AGENT_SUCCESS: raise SSHException("could not add key to agent") return
def send_message(self, data): """ Write a block of data using the current cipher, as an SSH block. """ # encrypt this sucka data = asbytes(data) cmd = byte_ord(data[0]) if cmd in MSG_NAMES: cmd_name = MSG_NAMES[cmd] else: cmd_name = '$%x' % cmd orig_len = len(data) with self.__write_lock: if self.__compress_engine_out is not None: data = self.__compress_engine_out(data) packet = self._build_packet(data) if self.__dump_packets: self._log(DEBUG, 'Write packet <%s>, length %d' % (cmd_name, orig_len)) self._log(DEBUG, util.format_binary(packet, 'OUT: ')) if self.__block_engine_out is not None: out = self.__block_engine_out.encrypt(packet) else: out = packet # + mac if self.__block_engine_out is not None: payload = struct.pack('>I', self.__sequence_number_out) + packet out += compute_hmac(self.__mac_key_out, payload, self.__mac_engine_out)[:self.__mac_size_out] self.__sequence_number_out = (self.__sequence_number_out + 1) & xffffffff self.write_all(out) self.__sent_bytes += len(out) self.__sent_packets += 1 if (self.__sent_packets >= self.REKEY_PACKETS or self.__sent_bytes >= self.REKEY_BYTES)\ and not self.__need_rekey: # only ask once for rekeying self._log(DEBUG, 'Rekeying (hit %d packets, %d bytes sent)' % (self.__sent_packets, self.__sent_bytes)) self.__received_bytes_overflow = 0 self.__received_packets_overflow = 0 self._trigger_rekey()
def _send_packet(self, t, packet): packet = asbytes(packet) out = struct.pack('>I', len(packet) + 1) + byte_chr(t) + packet if self.ultra_debug: self._log(DEBUG, paramiko.util.format_binary(out, 'OUT: ')) self._write_all(out)
def _send_message(self, msg): msg = asbytes(msg) self._conn.send(struct.pack('>I', len(msg)) + msg) l = self._read_all(4) msg = Message(self._read_all(struct.unpack('>I', l)[0])) return ord(msg.get_byte()), msg
def _send_packet(self, t, packet): packet = asbytes(packet) out = struct.pack('>I', len(packet) + 1) + byte_chr(t) + packet if self.ultra_debug: self._log(DEBUG, util.format_binary(out, 'OUT: ')) self._write_all(out)
def send(self, msg): msg = asbytes(msg) self.client.send(struct.pack('>I', len(msg)) + msg) size = struct.unpack('>I', self.client.recv(4))[0] msg = Message(self.client.recv(size)) return ord(msg.get_byte()), msg
def send_message(self, msg): msg = asbytes(msg) self.send(struct.pack('>I', len(msg)) + msg)
def _send_packet(self, t, packet): packet = asbytes(packet) out = struct.pack(">I", len(packet) + 1) + byte_chr(t) + packet if self.ultra_debug: self._log(DEBUG, util.format_binary(out, "OUT: ")) self._write_all(out)