From a88b8c8c0f591a3bfa8d7984343a27815184f495 Mon Sep 17 00:00:00 2001 From: "Jeremy T. Bouse" Date: Sun, 29 May 2011 08:16:54 -0400 Subject: Imported Upstream version 1.7.7.1 --- docs/paramiko.packet-pysrc.html | 528 ++++++++++++++++++---------------------- 1 file changed, 242 insertions(+), 286 deletions(-) (limited to 'docs/paramiko.packet-pysrc.html') diff --git a/docs/paramiko.packet-pysrc.html b/docs/paramiko.packet-pysrc.html index 232154b..8341e2c 100644 --- a/docs/paramiko.packet-pysrc.html +++ b/docs/paramiko.packet-pysrc.html @@ -115,7 +115,7 @@ 59 # they should probably be lower. 60 REKEY_PACKETS = pow(2, 30) 61 REKEY_BYTES = pow(2, 30) - 62 + 62
63 - def __init__(self, socket):
64 self.__socket = socket 65 self.__logger = None @@ -124,14 +124,14 @@ 68 self.__need_rekey = False 69 self.__init_count = 0 70 self.__remainder = '' - 71 + 71 72 # used for noticing when to re-key: 73 self.__sent_bytes = 0 74 self.__sent_packets = 0 75 self.__received_bytes = 0 76 self.__received_packets = 0 77 self.__received_packets_overflow = 0 - 78 + 78 79 # current inbound/outbound ciphering: 80 self.__block_size_out = 8 81 self.__block_size_in = 8 @@ -155,13 +155,13 @@ 99 self.__keepalive_interval = 0 100 self.__keepalive_last = time.time() 101 self.__keepalive_callback = None -
102 +102
103 - def set_log(self, log):
104 """ 105 Set the python log object to use for logging. 106 """ 107 self.__logger = log -
108 +108
109 - def set_outbound_cipher(self, block_engine, block_size, mac_engine, mac_size, mac_key):
110 """ 111 Switch outbound data cipher. @@ -178,7 +178,7 @@ 122 if self.__init_count == 3: 123 self.__init_count = 0 124 self.__need_rekey = False -
125 +125
126 - def set_inbound_cipher(self, block_engine, block_size, mac_engine, mac_size, mac_key):
127 """ 128 Switch inbound data cipher. @@ -196,13 +196,13 @@ 140 if self.__init_count == 3: 141 self.__init_count = 0 142 self.__need_rekey = False -
143 +143
144 - def set_outbound_compressor(self, compressor):
145 self.__compress_engine_out = compressor -
146 +146
147 - def set_inbound_compressor(self, compressor):
148 self.__compress_engine_in = compressor -
149 +149
150 - def close(self):
151 self.__closed = True 152 self.__socket.153
154 - def set_hexdump(self, hexdump):
155 self.__dump_packets = hexdump -
156 +
156
157 - def get_hexdump(self):
158 return self.__dump_packets -
159 +159
160 - def get_mac_size_in(self):
161 return self.__mac_size_in -
162 +162
163 - def get_mac_size_out(self):
164 return self.__mac_size_out
165 @@ -235,11 +235,11 @@ paramiko.win_pageant.PageantConnection.close" class="py-name" href="#" onclick=" 168 Returns C{True} if a new set of keys needs to be negotiated. This 169 will be triggered during a packet read or write, so it should be 170 checked after every read or write, or at least after every few. -171 +171 172 @return: C{True} if a new set of keys needs to be negotiated 173 """ 174 return self.__need_rekey -175 +175
176 - def set_keepalive(self, interval, callback):
177 """ 178 Turn on/off the callback keepalive. If C{interval} seconds pass with @@ -249,11 +249,11 @@ paramiko.win_pageant.PageantConnection.close" class="py-name" href="#" onclick=" 182 self.__keepalive_interval = interval 183 self.__keepalive_callback = callback 184 self.__keepalive_last = time.time() -
185 +185
186 - def read_all(self, n, check_rekey=False):
187 """ 188 Read as close to N bytes as possible, blocking as long as necessary. -189 +189 190 @param n: number of bytes to read 191 @type n: int 192 @return: the data read @@ -300,8 +300,7 @@ paramiko.win_pageant.PageantConnection.recv" class="py-name" href="#" onclick="r 212 n -= len(x) 213 except socket.timeout: 214 got_timeout = True -215 except socket.error, e: +215 except socket.error, e: 216 # on Linux, sometimes instead of socket.timeout, we get 217 # EAGAIN. this is a bug in recent (> 2.6.9) kernels but 218 # we need to work around it. @@ -318,7 +317,7 @@ paramiko.rng_win32.error" class="py-name" href="#" onclick="return doclink('link 229 if self.__closed: 230 raise EOFError() 231 if check_rekey and (len(out) == 0) and self.__need_rekey: -232 raise NeedRekeyException() +232 raise NeedRekeyException() 233 self._check_keepalive() 234 return out
235 @@ -327,12 +326,11 @@ paramiko.rng_win32.error" class="py-name" href="#" onclick="return doclink('link 238 while len(out) > 0: 239 got_timeout = False 240 try: -241 n = self.__socket.send(out) +241 n = self.__socket.send(out) 242 except socket.timeout: 243 got_timeout = True -244 except socket.error, e: +244 except socket.error, e: 245 if (type(e.args) is tuple) and (len(e.args) > 0) and (e.args[0] == errno.EAGAIN): 246 got_timeout = True 247 elif (type(e.args) is tuple) and (len(e.args) > 0) and (e.args[0] == errno.EINTR): @@ -353,7 +351,7 @@ paramiko.rng_win32.error" class="py-name" href="#" onclick="return doclink('link 262 break 263 out = out[n:] 264 return -265 +265
266 - def readline(self, timeout):
267 """ 268 Read a line from the socket. We assume no data is pending after the @@ -368,7 +366,7 @@ paramiko.rng_win32.error" class="py-name" href="#" onclick="return doclink('link 277 if (len(buf) > 0) and (buf[-1] == '\r'): 278 buf = buf[:-1] 279 return buf -
280 +280
281 - def send_message(self, data):
282 """ 283 Write a block of data using the current cipher, as an SSH block. @@ -376,7 +374,7 @@ paramiko.rng_win32.error" class="py-name" href="#" onclick="return doclink('link 285 # encrypt this sucka 286 data = str(data) 287 cmd = ord(data[0]) -288 if cmd in 288 if cmd in MSG_NAMES: -289 cmd_name = MSG_NAMES: +289 cmd_name = MSG_NAMES[cmd] +paramiko.util.MSG_NAMES" class="py-name" href="#" onclick="return doclink('link-22', 'MSG_NAMES', 'link-21');">MSG_NAMES[cmd] 290 else: 291 cmd_name = '$%x' % cmd 292 orig_len = len(data) @@ -425,9 +423,9 @@ paramiko.util.MSG_NAMES" class="py-name" href="#" onclick="return doclink('link- 294 try: 295 if self.__compress_engine_out is not None: 296 data = self.__compress_engine_out(data) -297 packet = self._build_packet(data) +297 packet = self._build_packet(data) 298 if self.__dump_packets: -299 self._log(299 self._log(DEBUG, 'Write packet <%s>, length %d' % (cmd_name, orig_len)) -300 self._log(DEBUG, 'Write packet <%s>, length %d' % (cmd_name, orig_len)) +300 self._log(DEBUG, util.format_binary(packet, 'OUT: ')) +paramiko.util.DEBUG" class="py-name" href="#" onclick="return doclink('link-25', 'DEBUG', 'link-24');">DEBUG, util.format_binary(packet, 'OUT: ')) 301 if self.__block_engine_out != None: -302 out = self.__block_engine_out.encrypt(packet) +302 out = self.__block_engine_out.encrypt(packet) 303 else: -304 out = packet +304 out = packet 305 # + mac 306 if self.__block_engine_out != None: -307 payload = struct.pack('>I', self.__sequence_number_out) + packet -308 out += compute_hmac(self.__mac_key_out, payload, self.__mac_engine_out)[:self.__mac_size_out] +307 payload = struct.pack('>I', self.__sequence_number_out) + packet +308 out += compute_hmac(self.__mac_key_out, payload, self.__mac_engine_out)[:self.__mac_size_out] 309 self.__sequence_number_out = (self.__sequence_number_out + 1) & 0xffffffffL 310 self.write_all(out) 311 312 self.__sent_bytes += len(out) 313 self.__sent_packets += 1 -314 if (self.__sent_packets % 100) == 0: -315 # stirring the randpool takes 30ms on my ibook!! -316 randpool.stir() -317 if ((self.__sent_packets >= self.REKEY_PACKETS) or (self.__sent_bytes >= self.REKEY_BYTES)) \ -318 and not self.__need_rekey: -319 # only ask once for rekeying -320 self._log(314 if ((self.__sent_packets >= self.REKEY_PACKETS) or (self.__sent_bytes >= self.REKEY_BYTES)) \ +315 and not self.__need_rekey: +316 # only ask once for rekeying +317 self._log(DEBUG, 'Rekeying (hit %d packets, %d bytes sent)' % -321 (self.__sent_packets, self.__sent_bytes)) -322 self.__received_packets_overflow = 0 -323 self._trigger_rekey() -324 finally: -325 self.__write_lock.release() -
326 -
327 - def read_message(self): -
328 """ -329 Only one thread should ever be in this function (no other locking is -330 done). -331 -332 @raise SSHException: if the packet is mangled -333 @raise NeedRekeyException: if the transport should rekey -334 """ -335 header = self.read_all(self.__block_size_in, check_rekey=True) -336 if self.__block_engine_in != None: -337 header = self.__block_engine_in.decrypt(header) -338 if self.__dump_packets: -339 self._log(DEBUG, 'Rekeying (hit %d packets, %d bytes sent)' % +318 (self.__sent_packets, self.__sent_bytes)) +319 self.__received_packets_overflow = 0 +320 self._trigger_rekey() +321 finally: +322 self.__write_lock.release() +
323 +
324 - def read_message(self): +
325 """ +326 Only one thread should ever be in this function (no other locking is +327 done). +328 +329 @raise SSHException: if the packet is mangled +330 @raise NeedRekeyException: if the transport should rekey +331 """ +332 header = self.read_all(self.__block_size_in, check_rekey=True) +333 if self.__block_engine_in != None: +334 header = self.__block_engine_in.decrypt(header) +335 if self.__dump_packets: +336 self._log(DEBUG, util.format_binary(header, 'IN: ')); -340 packet_size = struct.unpack('>I', header[:4])[0] -341 # leftover contains decrypted bytes from the first block (after the length field) -342 leftover = header[4:] -343 if (packet_size - len(leftover)) % self.__block_size_in != 0: -344 raise SSHException('Invalid packet blocking') -345 buf = self.read_all(packet_size + self.__mac_size_in - len(leftover)) -346 packet = buf[:packet_size - len(leftover)] -347 post_packet = buf[packet_size - len(leftover):] -348 if self.__block_engine_in != None: -349 packet = self.__block_engine_in.decrypt(packet) -350 if self.__dump_packets: -351 self._log(DEBUG, util.format_binary(header, 'IN: ')); +337 packet_size = struct.unpack('>I', header[:4])[0] +338 # leftover contains decrypted bytes from the first block (after the length field) +339 leftover = header[4:] +340 if (packet_size - len(leftover)) % self.__block_size_in != 0: +341 raise SSHException('Invalid packet blocking') +342 buf = self.read_all(packet_size + self.__mac_size_in - len(leftover)) +343 packet = buf[:packet_size - len(leftover)] +344 post_packet = buf[packet_size - len(leftover):] +345 if self.__block_engine_in != None: +346 packet = self.__block_engine_in.decrypt(packet) +347 if self.__dump_packets: +348 self._log(DEBUG, util.format_binary(packet, 'IN: ')); -352 packet = leftover + packet -353 -354 if self.__mac_size_in > 0: -355 mac = post_packet[:self.__mac_size_in] -356 mac_payload = struct.pack('>II', self.__sequence_number_in, packet_size) + packet -357 my_mac = compute_hmac(self.__mac_key_in, mac_payload, self.__mac_engine_in)[:self.__mac_size_in] -358 if my_mac != mac: -359 raise SSHException('Mismatched MAC') -360 padding = ord(packet[0]) -361 payload = packet[1:packet_size - padding] -362 randpool.add_event() -363 if self.__dump_packets: -364 self._log(DEBUG, util.format_binary(packet, 'IN: ')); +349 packet = leftover + packet +350 +351 if self.__mac_size_in > 0: +352 mac = post_packet[:self.__mac_size_in] +353 mac_payload = struct.pack('>II', self.__sequence_number_in, packet_size) + packet +354 my_mac = compute_hmac(self.__mac_key_in, mac_payload, self.__mac_engine_in)[:self.__mac_size_in] +355 if my_mac != mac: +356 raise SSHException('Mismatched MAC') +357 padding = ord(packet[0]) +358 payload = packet[1:packet_size - padding] +359 +360 if self.__dump_packets: +361 self._log(DEBUG, 'Got payload (%d bytes, %d padding)' % (packet_size, padding)) +paramiko.util.DEBUG" class="py-name" href="#" onclick="return doclink('link-52', 'DEBUG', 'link-24');">DEBUG, 'Got payload (%d bytes, %d padding)' % (packet_size, padding)) +362 +363 if self.__compress_engine_in is not None: +364 payload = self.__compress_engine_in(payload) 365 -366 if self.__compress_engine_in is not None: -367 payload = self.__compress_engine_in(payload) -368 -369 msg = Message(payload[1:]) -370 msg.seqno = self.__sequence_number_in -371 self.__sequence_number_in = (self.__sequence_number_in + 1) & 0xffffffffL -372 -373 # check for rekey -374 self.__received_bytes += packet_size + self.__mac_size_in + 4 -375 self.__received_packets += 1 -376 if self.__need_rekey: -377 # we've asked to rekey -- give them 20 packets to comply before -378 # dropping the connection -379 self.__received_packets_overflow += 1 -380 if self.__received_packets_overflow >= 20: -381 raise SSHException('Remote transport is ignoring rekey requests') -382 elif (self.__received_packets >= self.REKEY_PACKETS) or \ -383 (self.__received_bytes >= self.REKEY_BYTES): -384 # only ask once for rekeying -385 self._log(366 msg = Message(payload[1:]) +367 msg.seqno = self.__sequence_number_in +368 self.__sequence_number_in = (self.__sequence_number_in + 1) & 0xffffffffL +369 +370 # check for rekey +371 self.__received_bytes += packet_size + self.__mac_size_in + 4 +372 self.__received_packets += 1 +373 if self.__need_rekey: +374 # we've asked to rekey -- give them 20 packets to comply before +375 # dropping the connection +376 self.__received_packets_overflow += 1 +377 if self.__received_packets_overflow >= 20: +378 raise SSHException('Remote transport is ignoring rekey requests') +379 elif (self.__received_packets >= self.REKEY_PACKETS) or \ +380 (self.__received_bytes >= self.REKEY_BYTES): +381 # only ask once for rekeying +382 self._log(DEBUG, 'Rekeying (hit %d packets, %d bytes received)' % -386 (self.__received_packets, self.__received_bytes)) -387 self.__received_packets_overflow = 0 -388 self._trigger_rekey() -389 -390 cmd = ord(payload[0]) -391 if cmd in DEBUG, 'Rekeying (hit %d packets, %d bytes received)' % +383 (self.__received_packets, self.__received_bytes)) +384 self.__received_packets_overflow = 0 +385 self._trigger_rekey() +386 +387 cmd = ord(payload[0]) +388 if cmd in MSG_NAMES: -392 cmd_name = MSG_NAMES: +389 cmd_name = MSG_NAMES[cmd] -393 else: -394 cmd_name = '$%x' % cmd -395 if self.__dump_packets: -396 self._log(MSG_NAMES[cmd] +390 else: +391 cmd_name = '$%x' % cmd +392 if self.__dump_packets: +393 self._log(DEBUG, 'Read packet <%s>, length %d' % (cmd_name, len(payload))) -397 return cmd, msg -
398 +paramiko.util.DEBUG" class="py-name" href="#" onclick="return doclink('link-58', 'DEBUG', 'link-24');">DEBUG, 'Read packet <%s>, length %d' % (cmd_name, len(payload))) +394 return cmd, msg +395 +396 +397 ########## protected +398 399 -400 ########## protected -401 -402 -
403 - def _log(self, level, msg): -
404 if self.__logger is None: -405 return -406 if issubclass(type(msg), list): -407 for m in msg: -408 self.__logger.log(level, m) -409 else: -410 self.__logger.log(level, msg) -
411 -
412 - def _check_keepalive(self): -
413 if (not self.__keepalive_interval) or (not self.__block_engine_out) or \ -414 self.__need_rekey: -415 # wait till we're encrypting, and not in the middle of rekeying -416 return -417 now = time.time() -418 if now > self.__keepalive_last + self.__keepalive_interval: -419 self.__keepalive_callback() -420 self.__keepalive_last = now -
421 -
422 - def _py22_read_all(self, n, out): -
423 while n > 0: -424 r, w, e = select.select([self.__socket], [], [], 0.1) -425 if self.__socket not in r: -426 if self.__closed: -427 raise EOFError() -428 self._check_keepalive() -429 else: -430 x = self.__socket.recv(n) -431 if len(x) == 0: -432 raise EOFError() -433 out += x -434 n -= len(x) -435 return out -
436 -
437 - def _py22_read_timeout(self, timeout): -
438 start = time.time() -439 while True: -440 r, w, e = select.select([self.__socket], [], [], 0.1) -441 if self.__socket in r: -442 x = self.__socket.recv(1) -443 if len(x) == 0: -444 raise EOFError() -445 break -446 if self.__closed: -447 raise EOFError() -448 now = time.time() -449 if now - start >= timeout: -450 raise socket.timeout() -451 return x -
452 -
453 - def _read_timeout(self, timeout): -
454 if
400 - def _log(self, level, msg): +
401 if self.__logger is None: +402 return +403 if issubclass(type(msg), list): +404 for m in msg: +405 self.__logger.log(level, m) +406 else: +407 self.__logger.log(level, msg) +
408 +
409 - def _check_keepalive(self): +
410 if (not self.__keepalive_interval) or (not self.__block_engine_out) or \ +411 self.__need_rekey: +412 # wait till we're encrypting, and not in the middle of rekeying +413 return +414 now = time.time() +415 if now > self.__keepalive_last + self.__keepalive_interval: +416 self.__keepalive_callback() +417 self.__keepalive_last = now +
418 +
419 - def _py22_read_all(self, n, out): +
420 while n > 0: +421 r, w, e = select.select([self.__socket], [], [], 0.1) +422 if self.__socket not in r: +423 if self.__closed: +424 raise EOFError() +425 self._check_keepalive() +426 else: +427 x = self.__socket.recv(n) +428 if len(x) == 0: +429 raise EOFError() +430 out += x +431 n -= len(x) +432 return out +
433 +
434 - def _py22_read_timeout(self, timeout): +
435 start = time.time() +436 while True: +437 r, w, e = select.select([self.__socket], [], [], 0.1) +438 if self.__socket in r: +439 x = self.__socket.recv(1) +440 if len(x) == 0: +441 raise EOFError() +442 break +443 if self.__closed: +444 raise EOFError() +445 now = time.time() +446 if now - start >= timeout: +447 raise socket.timeout() +448 return x +
449 +
450 - def _read_timeout(self, timeout): +
451 if PY22: -455 return self._py22_read_timeout(timeout) -456 start = time.time() -457 while True: -458 try: -459 x = self.__socket.recv(128) -460 if len(x) == 0: -461 raise EOFError() -462 break -463 except socket.timeout: -464 pass -465 if self.__closed: -466 raise EOFError() -467 now = time.time() -468 if now - start >= timeout: -469 raise socket.timeout() -470 return x -
471 -
472 - def _build_packet(self, payload): -
473 # pad up at least 4 bytes, to nearest block-size (usually 8) -474 bsize = self.__block_size_out -475 padding = 3 + bsize - ((len(payload) + 8) % bsize) -476 packet = struct.pack('>IB', len(payload) + padding + 1, padding) -477 packet += payload -478 if self.__block_engine_out is not None: -479 packet += randpool.get_bytes(padding) -480 else: -481 # cute trick i caught openssh doing: if we're not encrypting, -482 # don't waste random bytes for the padding -483 packet += (chr(0) * padding) -484 return packet -
485 -
486 - def _trigger_rekey(self): -
487 # outside code should check for this flag -488 self.__need_rekey = True -
489