Package paramiko :: Class RSAKey |
[frames] | no frames]

# Class RSAKey

source code

    object --+
             |
          PKey --+
                 |
                RSAKey

Representation of an RSA key which can be used to sign and verify SSH2 data.

Instance Methods
__hash__(self) hash(x) | source code
__init__(self, msg=None, data=None, filename=None, password=None, vals=None, file_obj=None) Create a new instance of this public key type. | source code
str |
__str__(self) Return a string of an SSH Message made up of the public part(s) of this key. | source code
bool |
can_sign(self) Return `True` if this key has the private part necessary for signing data. | source code
int |
get_bits(self) Return the number of significant bits in this key. | source code
str |
get_name(self) Return the name of this private key implementation. | source code
Message |
sign_ssh_data(self, rpool, data) Sign a blob of data with this private key, and return a Message representing an SSH signature message. | source code
boolean |
verify_ssh_sig(self, data, msg) Given a blob of data, and an SSH message representing a signature of that data, verify that it was signed with this key. | source code
write_private_key(self, file_obj, password=None) Write private key contents into a file (or file-like) object. | source code
write_private_key_file(self, filename, password=None) Write private key contents into a file. | source code
Inherited from `PKey`: `__cmp__`, `get_base64`, `get_fingerprint` Inherited from `object`: `__delattr__`, `__format__`, `__getattribute__`, `__new__`, `__reduce__`, `__reduce_ex__`, `__repr__`, `__setattr__`, `__sizeof__`, `__subclasshook__`

Class Methods
Inherited from `PKey`: `from_private_key`, `from_private_key_file`

Static Methods
RSAKey |
generate(bits, progress_func=None) Generate a new private RSA key. | source code

Properties
Inherited from `object`: `__class__`

Method Details

### __hash__(self) (Hashing function) | source code
hash(x) Overrides: object.__hash__ (inherited documentation)

### __init__(self, msg=None, data=None, filename=None, password=None, vals=None, file_obj=None) (Constructor) | source code
Create a new instance of this public key type. If `msg` is given, the key's public part(s) will be filled in from the message. If `data` is given, the key's public part(s) will be filled in from the string. Parameters: `msg` - an optional SSH Message containing a public key of this type. `data` - an optional string containing a public key of this type Raises: `SSHException` - if a key cannot be created from the `data` or `msg` given, or no key was passed in. Overrides: object.__init__ (inherited documentation)

### __str__(self) (Informal representation operator) | source code
Return a string of an SSH Message made up of the public part(s) of this key. This string is suitable for passing to __init__ to re-create the key object later. Returns: str string representation of an SSH key message. Overrides: object.__str__ (inherited documentation)

### can_sign(self) | source code
Return `True` if this key has the private part necessary for signing data. Returns: bool `True` if this is a private key. Overrides: PKey.can_sign (inherited documentation)

### generate(bits, progress_func=None) Static Method | source code
Generate a new private RSA key. This factory function can be used to generate a new host key or authentication key. Parameters: `bits` (int) - number of bits the generated key should be. `progress_func` (function) - an optional function to call at key points in key generation (used by `pyCrypto.PublicKey`). Returns: RSAKey new private key

### get_bits(self) | source code
Return the number of significant bits in this key. This is useful for judging the relative security of a key. Returns: int bits in the key. Overrides: PKey.get_bits (inherited documentation)

### get_name(self) | source code
Return the name of this private key implementation. Returns: str name of this private key type, in SSH terminology (for example, `"ssh-rsa"`). Overrides: PKey.get_name (inherited documentation)

### sign_ssh_data(self, rpool, data) | source code
Sign a blob of data with this private key, and return a Message representing an SSH signature message. Parameters: `randpool` - a secure random number generator. `data` - the data to sign. Returns: Message an SSH signature message. Overrides: PKey.sign_ssh_data (inherited documentation)

### verify_ssh_sig(self, data, msg) | source code
Given a blob of data, and an SSH message representing a signature of that data, verify that it was signed with this key. Parameters: `data` - the data that was signed. `msg` - an SSH signature message Returns: boolean `True` if the signature verifies correctly; `False` otherwise. Overrides: PKey.verify_ssh_sig (inherited documentation)

### write_private_key(self, file_obj, password=None) | source code
Write private key contents into a file (or file-like) object. If the password is not `None`, the key is encrypted before writing. Parameters: `file_obj` - the file object to write into `password` - an optional password to use to encrypt the key Raises: `IOError` - if there was an error writing to the file `SSHException` - if the key is invalid Overrides: PKey.write_private_key (inherited documentation)

### write_private_key_file(self, filename, password=None) | source code
Write private key contents into a file. If the password is not `None`, the key is encrypted before writing. Parameters: `filename` - name of the file to write `password` - an optional password to use to encrypt the key file Raises: `IOError` - if there was an error writing the file `SSHException` - if the key is invalid Overrides: PKey.write_private_key_file (inherited documentation)