312 lines
9.4 KiB
Python
312 lines
9.4 KiB
Python
# Copyright (C) 2003-2007 Robey Pointer <robeypointer@gmail.com>
|
|
#
|
|
# This file is part of paramiko.
|
|
#
|
|
# Paramiko is free software; you can redistribute it and/or modify it under the
|
|
# terms of the GNU Lesser General Public License as published by the Free
|
|
# Software Foundation; either version 2.1 of the License, or (at your option)
|
|
# any later version.
|
|
#
|
|
# Paramiko is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
# A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
|
|
# details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public License
|
|
# along with Paramiko; if not, write to the Free Software Foundation, Inc.,
|
|
# 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
|
|
|
"""
|
|
Useful functions used by the rest of paramiko.
|
|
"""
|
|
|
|
from __future__ import generators
|
|
|
|
import array
|
|
from binascii import hexlify, unhexlify
|
|
import errno
|
|
import sys
|
|
import struct
|
|
import traceback
|
|
import threading
|
|
|
|
from paramiko.common import *
|
|
from paramiko.config import SSHConfig
|
|
|
|
|
|
# Change by RogerB - python < 2.3 doesn't have enumerate so we implement it
|
|
if sys.version_info < (2,3):
|
|
class enumerate:
|
|
def __init__ (self, sequence):
|
|
self.sequence = sequence
|
|
def __iter__ (self):
|
|
count = 0
|
|
for item in self.sequence:
|
|
yield (count, item)
|
|
count += 1
|
|
|
|
|
|
def inflate_long(s, always_positive=False):
|
|
"turns a normalized byte string into a long-int (adapted from Crypto.Util.number)"
|
|
out = 0L
|
|
negative = 0
|
|
if not always_positive and (len(s) > 0) and (ord(s[0]) >= 0x80):
|
|
negative = 1
|
|
if len(s) % 4:
|
|
filler = '\x00'
|
|
if negative:
|
|
filler = '\xff'
|
|
s = filler * (4 - len(s) % 4) + s
|
|
for i in range(0, len(s), 4):
|
|
out = (out << 32) + struct.unpack('>I', s[i:i+4])[0]
|
|
if negative:
|
|
out -= (1L << (8 * len(s)))
|
|
return out
|
|
|
|
def deflate_long(n, add_sign_padding=True):
|
|
"turns a long-int into a normalized byte string (adapted from Crypto.Util.number)"
|
|
# after much testing, this algorithm was deemed to be the fastest
|
|
s = ''
|
|
n = long(n)
|
|
while (n != 0) and (n != -1):
|
|
s = struct.pack('>I', n & 0xffffffffL) + s
|
|
n = n >> 32
|
|
# strip off leading zeros, FFs
|
|
for i in enumerate(s):
|
|
if (n == 0) and (i[1] != '\000'):
|
|
break
|
|
if (n == -1) and (i[1] != '\xff'):
|
|
break
|
|
else:
|
|
# degenerate case, n was either 0 or -1
|
|
i = (0,)
|
|
if n == 0:
|
|
s = '\000'
|
|
else:
|
|
s = '\xff'
|
|
s = s[i[0]:]
|
|
if add_sign_padding:
|
|
if (n == 0) and (ord(s[0]) >= 0x80):
|
|
s = '\x00' + s
|
|
if (n == -1) and (ord(s[0]) < 0x80):
|
|
s = '\xff' + s
|
|
return s
|
|
|
|
def format_binary_weird(data):
|
|
out = ''
|
|
for i in enumerate(data):
|
|
out += '%02X' % ord(i[1])
|
|
if i[0] % 2:
|
|
out += ' '
|
|
if i[0] % 16 == 15:
|
|
out += '\n'
|
|
return out
|
|
|
|
def format_binary(data, prefix=''):
|
|
x = 0
|
|
out = []
|
|
while len(data) > x + 16:
|
|
out.append(format_binary_line(data[x:x+16]))
|
|
x += 16
|
|
if x < len(data):
|
|
out.append(format_binary_line(data[x:]))
|
|
return [prefix + x for x in out]
|
|
|
|
def format_binary_line(data):
|
|
left = ' '.join(['%02X' % ord(c) for c in data])
|
|
right = ''.join([('.%c..' % c)[(ord(c)+63)//95] for c in data])
|
|
return '%-50s %s' % (left, right)
|
|
|
|
def hexify(s):
|
|
return hexlify(s).upper()
|
|
|
|
def unhexify(s):
|
|
return unhexlify(s)
|
|
|
|
def safe_string(s):
|
|
out = ''
|
|
for c in s:
|
|
if (ord(c) >= 32) and (ord(c) <= 127):
|
|
out += c
|
|
else:
|
|
out += '%%%02X' % ord(c)
|
|
return out
|
|
|
|
# ''.join([['%%%02X' % ord(c), c][(ord(c) >= 32) and (ord(c) <= 127)] for c in s])
|
|
|
|
def bit_length(n):
|
|
norm = deflate_long(n, 0)
|
|
hbyte = ord(norm[0])
|
|
if hbyte == 0:
|
|
return 1
|
|
bitlen = len(norm) * 8
|
|
while not (hbyte & 0x80):
|
|
hbyte <<= 1
|
|
bitlen -= 1
|
|
return bitlen
|
|
|
|
def tb_strings():
|
|
return ''.join(traceback.format_exception(*sys.exc_info())).split('\n')
|
|
|
|
def generate_key_bytes(hashclass, salt, key, nbytes):
|
|
"""
|
|
Given a password, passphrase, or other human-source key, scramble it
|
|
through a secure hash into some keyworthy bytes. This specific algorithm
|
|
is used for encrypting/decrypting private key files.
|
|
|
|
@param hashclass: class from L{Crypto.Hash} that can be used as a secure
|
|
hashing function (like C{MD5} or C{SHA}).
|
|
@type hashclass: L{Crypto.Hash}
|
|
@param salt: data to salt the hash with.
|
|
@type salt: string
|
|
@param key: human-entered password or passphrase.
|
|
@type key: string
|
|
@param nbytes: number of bytes to generate.
|
|
@type nbytes: int
|
|
@return: key data
|
|
@rtype: string
|
|
"""
|
|
keydata = ''
|
|
digest = ''
|
|
if len(salt) > 8:
|
|
salt = salt[:8]
|
|
while nbytes > 0:
|
|
hash_obj = hashclass.new()
|
|
if len(digest) > 0:
|
|
hash_obj.update(digest)
|
|
hash_obj.update(key)
|
|
hash_obj.update(salt)
|
|
digest = hash_obj.digest()
|
|
size = min(nbytes, len(digest))
|
|
keydata += digest[:size]
|
|
nbytes -= size
|
|
return keydata
|
|
|
|
def load_host_keys(filename):
|
|
"""
|
|
Read a file of known SSH host keys, in the format used by openssh, and
|
|
return a compound dict of C{hostname -> keytype ->} L{PKey <paramiko.pkey.PKey>}.
|
|
The hostname may be an IP address or DNS name. The keytype will be either
|
|
C{"ssh-rsa"} or C{"ssh-dss"}.
|
|
|
|
This type of file unfortunately doesn't exist on Windows, but on posix,
|
|
it will usually be stored in C{os.path.expanduser("~/.ssh/known_hosts")}.
|
|
|
|
Since 1.5.3, this is just a wrapper around L{HostKeys}.
|
|
|
|
@param filename: name of the file to read host keys from
|
|
@type filename: str
|
|
@return: dict of host keys, indexed by hostname and then keytype
|
|
@rtype: dict(hostname, dict(keytype, L{PKey <paramiko.pkey.PKey>}))
|
|
"""
|
|
from paramiko.hostkeys import HostKeys
|
|
return HostKeys(filename)
|
|
|
|
def parse_ssh_config(file_obj):
|
|
"""
|
|
Provided only as a backward-compatible wrapper around L{SSHConfig}.
|
|
"""
|
|
config = SSHConfig()
|
|
config.parse(file_obj)
|
|
return config
|
|
|
|
def lookup_ssh_host_config(hostname, config):
|
|
"""
|
|
Provided only as a backward-compatible wrapper around L{SSHConfig}.
|
|
"""
|
|
return config.lookup(hostname)
|
|
|
|
def mod_inverse(x, m):
|
|
# it's crazy how small python can make this function.
|
|
u1, u2, u3 = 1, 0, m
|
|
v1, v2, v3 = 0, 1, x
|
|
|
|
while v3 > 0:
|
|
q = u3 // v3
|
|
u1, v1 = v1, u1 - v1 * q
|
|
u2, v2 = v2, u2 - v2 * q
|
|
u3, v3 = v3, u3 - v3 * q
|
|
if u2 < 0:
|
|
u2 += m
|
|
return u2
|
|
|
|
_g_thread_ids = {}
|
|
_g_thread_counter = 0
|
|
_g_thread_lock = threading.Lock()
|
|
def get_thread_id():
|
|
global _g_thread_ids, _g_thread_counter, _g_thread_lock
|
|
tid = id(threading.currentThread())
|
|
try:
|
|
return _g_thread_ids[tid]
|
|
except KeyError:
|
|
_g_thread_lock.acquire()
|
|
try:
|
|
_g_thread_counter += 1
|
|
ret = _g_thread_ids[tid] = _g_thread_counter
|
|
finally:
|
|
_g_thread_lock.release()
|
|
return ret
|
|
|
|
def log_to_file(filename, level=DEBUG):
|
|
"send paramiko logs to a logfile, if they're not already going somewhere"
|
|
l = logging.getLogger("paramiko")
|
|
if len(l.handlers) > 0:
|
|
return
|
|
l.setLevel(level)
|
|
f = open(filename, 'w')
|
|
lh = logging.StreamHandler(f)
|
|
lh.setFormatter(logging.Formatter('%(levelname)-.3s [%(asctime)s.%(msecs)03d] thr=%(_threadid)-3d %(name)s: %(message)s',
|
|
'%Y%m%d-%H:%M:%S'))
|
|
l.addHandler(lh)
|
|
|
|
# make only one filter object, so it doesn't get applied more than once
|
|
class PFilter (object):
|
|
def filter(self, record):
|
|
record._threadid = get_thread_id()
|
|
return True
|
|
_pfilter = PFilter()
|
|
|
|
def get_logger(name):
|
|
l = logging.getLogger(name)
|
|
l.addFilter(_pfilter)
|
|
return l
|
|
|
|
def retry_on_signal(function):
|
|
"""Retries function until it doesn't raise an EINTR error"""
|
|
while True:
|
|
try:
|
|
return function()
|
|
except EnvironmentError, e:
|
|
if e.errno != errno.EINTR:
|
|
raise
|
|
|
|
class Counter (object):
|
|
"""Stateful counter for CTR mode crypto"""
|
|
def __init__(self, nbits, initial_value=1L, overflow=0L):
|
|
self.blocksize = nbits / 8
|
|
self.overflow = overflow
|
|
# start with value - 1 so we don't have to store intermediate values when counting
|
|
# could the iv be 0?
|
|
if initial_value == 0:
|
|
self.value = array.array('c', '\xFF' * self.blocksize)
|
|
else:
|
|
x = deflate_long(initial_value - 1, add_sign_padding=False)
|
|
self.value = array.array('c', '\x00' * (self.blocksize - len(x)) + x)
|
|
|
|
def __call__(self):
|
|
"""Increament the counter and return the new value"""
|
|
i = self.blocksize - 1
|
|
while i > -1:
|
|
c = self.value[i] = chr((ord(self.value[i]) + 1) % 256)
|
|
if c != '\x00':
|
|
return self.value.tostring()
|
|
i -= 1
|
|
# counter reset
|
|
x = deflate_long(self.overflow, add_sign_padding=False)
|
|
self.value = array.array('c', '\x00' * (self.blocksize - len(x)) + x)
|
|
return self.value.tostring()
|
|
|
|
def new(cls, nbits, initial_value=1L, overflow=0L):
|
|
return cls(nbits, initial_value=initial_value, overflow=overflow)
|
|
new = classmethod(new)
|