Package paramiko :: Module rsakey |
[frames] | no frames]

# Source Code for Module paramiko.rsakey

      1  # Copyright (C) 2003-2007  Robey Pointer <robeypointer@gmail.com>
      2  #
      3  # This file is part of paramiko.
      4  #
      5  # Paramiko is free software; you can redistribute it and/or modify it under the
      6  # terms of the GNU Lesser General Public License as published by the Free
      7  # Software Foundation; either version 2.1 of the License, or (at your option)
      8  # any later version.
      9  #
     10  # Paramiko is distrubuted in the hope that it will be useful, but WITHOUT ANY
     11  # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
     12  # A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
     13  # details.
     14  #
     15  # You should have received a copy of the GNU Lesser General Public License
     16  # along with Paramiko; if not, write to the Free Software Foundation, Inc.,
     17  # 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
     18
     19  """
     20  L{RSAKey}
     21  """
     22
     23  from Crypto.PublicKey import RSA
     24  from Crypto.Hash import SHA, MD5
     25  from Crypto.Cipher import DES3
     26
     27  from paramiko.common import *
     28  from paramiko import util
     29  from paramiko.message import Message
     30  from paramiko.ber import BER, BERException
     31  from paramiko.pkey import PKey
     32  from paramiko.ssh_exception import SSHException
     33
     34
     35 -class RSAKey (PKey):
     36      """
     37      Representation of an RSA key which can be used to sign and verify SSH2
     38      data.
     39      """
     40
     41 -    def __init__(self, msg=None, data=None, filename=None, password=None, vals=None, file_obj=None):
     42          self.n = None
     43          self.e = None
     44          self.d = None
     45          self.p = None
     46          self.q = None
     47          if file_obj is not None:
     48              self._from_private_key(file_obj, password)
     49              return
     50          if filename is not None:
     51              self._from_private_key_file(filename, password)
     52              return
     53          if (msg is None) and (data is not None):
     54              msg = Message(data)
     55          if vals is not None:
     56              self.e, self.n = vals
     57          else:
     58              if msg is None:
     59                  raise SSHException('Key object may not be empty')
     60              if msg.get_string() != 'ssh-rsa':
     61                  raise SSHException('Invalid key')
     62              self.e = msg.get_mpint()
     63              self.n = msg.get_mpint()
     64          self.size = util.bit_length(self.n)
     65
     66 -    def __str__(self):
     67          m = Message()
     68          m.add_string('ssh-rsa')
     69          m.add_mpint(self.e)
     70          m.add_mpint(self.n)
     71          return str(m)
     72
     73 -    def __hash__(self):
     74          h = hash(self.get_name())
     75          h = h * 37 + hash(self.e)
     76          h = h * 37 + hash(self.n)
     77          return hash(h)
     78
     79 -    def get_name(self):
     80          return 'ssh-rsa'
     81
     82 -    def get_bits(self):
     83          return self.size
     84
     85 -    def can_sign(self):
     86          return self.d is not None
     87
     88 -    def sign_ssh_data(self, rpool, data):
     89          digest = SHA.new(data).digest()
     90          rsa = RSA.construct((long(self.n), long(self.e), long(self.d)))
     91          sig = util.deflate_long(rsa.sign(self._pkcs1imify(digest), '')[0], 0)
     92          m = Message()
     93          m.add_string('ssh-rsa')
     94          m.add_string(sig)
     95          return m
     96
     97 -    def verify_ssh_sig(self, data, msg):
     98          if msg.get_string() != 'ssh-rsa':
     99              return False
    100          sig = util.inflate_long(msg.get_string(), True)
    101          # verify the signature by SHA'ing the data and encrypting it using the
    102          # public key.  some wackiness ensues where we "pkcs1imify" the 20-byte
    103          # hash into a string as long as the RSA key.
    104          hash_obj = util.inflate_long(self._pkcs1imify(SHA.new(data).digest()), True)
    105          rsa = RSA.construct((long(self.n), long(self.e)))
    106          return rsa.verify(hash_obj, (sig,))
    107
    108 -    def _encode_key(self):
    109          if (self.p is None) or (self.q is None):
    110              raise SSHException('Not enough key info to write private key file')
    111          keylist = [ 0, self.n, self.e, self.d, self.p, self.q,
    112                      self.d % (self.p - 1), self.d % (self.q - 1),
    113                      util.mod_inverse(self.q, self.p) ]
    114          try:
    115              b = BER()
    116              b.encode(keylist)
    117          except BERException:
    118              raise SSHException('Unable to create ber encoding of key')
    119          return str(b)
    120
    121 -    def write_private_key_file(self, filename, password=None):
    122          self._write_private_key_file('RSA', filename, self._encode_key(), password)
    123
    124 -    def write_private_key(self, file_obj, password=None):
    125          self._write_private_key('RSA', file_obj, self._encode_key(), password)
    126
    127 -    def generate(bits, progress_func=None):
    128          """
    129          Generate a new private RSA key.  This factory function can be used to
    130          generate a new host key or authentication key.
    131
    132          @param bits: number of bits the generated key should be.
    133          @type bits: int
    134          @param progress_func: an optional function to call at key points in
    135              key generation (used by C{pyCrypto.PublicKey}).
    136          @type progress_func: function
    137          @return: new private key
    138          @rtype: L{RSAKey}
    139          """
    140          rsa = RSA.generate(bits, rng.read, progress_func)
    141          key = RSAKey(vals=(rsa.e, rsa.n))
    142          key.d = rsa.d
    143          key.p = rsa.p
    144          key.q = rsa.q
    145          return key
    146      generate = staticmethod(generate)
    147
    148
    149      ###  internals...
    150
    151
    152 -    def _pkcs1imify(self, data):
    153          """
    154          turn a 20-byte SHA1 hash into a blob of data as large as the key's N,
    155          using PKCS1's \"emsa-pkcs1-v1_5\" encoding.  totally bizarre.
    156          """
    157          SHA1_DIGESTINFO = '\x30\x21\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x04\x14'
    158          size = len(util.deflate_long(self.n, 0))
    159          filler = '\xff' * (size - len(SHA1_DIGESTINFO) - len(data) - 3)
    160          return '\x00\x01' + filler + '\x00' + SHA1_DIGESTINFO + data
    161
    162 -    def _from_private_key_file(self, filename, password):
    163          data = self._read_private_key_file('RSA', filename, password)
    164          self._decode_key(data)
    165
    166 -    def _from_private_key(self, file_obj, password):
    167          data = self._read_private_key('RSA', file_obj, password)
    168          self._decode_key(data)
    169
    170 -    def _decode_key(self, data):
    171          # private key file contains:
    172          # RSAPrivateKey = { version = 0, n, e, d, p, q, d mod p-1, d mod q-1, q**-1 mod p }
    173          try:
    174              keylist = BER(data).decode()
    175          except BERException:
    176              raise SSHException('Unable to parse key file')
    177          if (type(keylist) is not list) or (len(keylist) < 4) or (keylist[0] != 0):
    178              raise SSHException('Not a valid RSA private key file (bad ber encoding)')
    179          self.n = keylist[1]
    180          self.e = keylist[2]
    181          self.d = keylist[3]
    182          # not really needed
    183          self.p = keylist[4]
    184          self.q = keylist[5]
    185          self.size = util.bit_length(self.n)
    186