def test_encode_decode_sequence(self): """ When decoding an encoded list, the original list should be returned """ sequence = [1, 2, 3, 4, 5] encoded = BER.encode_sequence(sequence) decoded = BER.decode_sequence(encoded) self.assertEqual(decoded, sequence)
def test_encode_works_on_lists_directly(self): """ Encode should raise exception when used with string """ ber = BER() original_list = [1, 2, 3, 4, 5] ber.encode(original_list) self.assertEqual(ber.decode(), original_list)
def test_encode_decode(self): """ When decoding an encoded integer, the original integer should be returned """ ber = BER() ber.encode(1337) decoded = ber.decode() self.assertEqual(decoded, 1337)
def write_private_key_file(self, filename, password=None): keylist = [ 0, self.p, self.q, self.g, self.y, self.x ] try: b = BER() b.encode(keylist) except BERException: raise SSHException('Unable to create ber encoding of key') self._write_private_key_file('DSA', filename, str(b), password)
def _encode_key(self): if self.x is None: raise SSHException('Not enough key information') keylist = [0, self.p, self.q, self.g, self.y, self.x] try: b = BER() b.encode(keylist) except BERException: raise SSHException('Unable to create ber encoding of key') return b.asbytes()
def write_private_key_file(self, filename, password=None): keylist = [ 0, self.n, self.e, self.d, self.p, self.q, self.d % (self.p - 1), self.d % (self.q - 1), util.mod_inverse(self.q, self.p) ] try: b = BER() b.encode(keylist) except BERException: raise SSHException('Unable to create ber encoding of key') self._write_private_key_file('RSA', filename, str(b), password)
def _encode_key(self): if self.x is None: raise SSHException("Not enough key information") keylist = [0, self.p, self.q, self.g, self.y, self.x] try: b = BER() b.encode(keylist) except BERException: raise SSHException("Unable to create ber encoding of key") return str(b)
def _encode_key(self): if (self.p is None) or (self.q is None): raise SSHException('Not enough key info to write private key file') keylist = [ 0, self.n, self.e, self.d, self.p, self.q, self.d % (self.p - 1), self.d % (self.q - 1), util.mod_inverse(self.q, self.p) ] try: b = BER() b.encode(keylist) except BERException: raise SSHException('Unable to create ber encoding of key') return b.asbytes()
def _encode_key(self): if (self.p is None) or (self.q is None): raise SSHException('Not enough key info to write private key file') keylist = [0, self.n, self.e, self.d, self.p, self.q, self.d % (self.p - 1), self.d % (self.q - 1), util.mod_inverse(self.q, self.p)] try: b = BER() b.encode(keylist) except BERException: raise SSHException('Unable to create ber encoding of key') return b.asbytes()
def _decode_key(self, data): pkformat, data = data # private key file contains: # DSAPrivateKey = { version = 0, p, q, g, y, x } if pkformat == self.FORMAT_ORIGINAL: try: keylist = BER(data).decode() except BERException as e: raise SSHException("Unable to parse key file: " + str(e)) elif pkformat == self.FORMAT_OPENSSH: msg = Message(data) keylist = [0] + [msg.get_mpint() for _ in range(5)] else: raise SSHException('private key format.') if type(keylist) is not list or len(keylist) < 6 or keylist[0] != 0: raise SSHException( 'not a valid DSA private key file (bad ber encoding)') self.p = keylist[1] self.q = keylist[2] self.g = keylist[3] self.y = keylist[4] self.x = keylist[5] self.size = util.bit_length(self.p)
def _decode_key(self, data): # private key file contains: # DSAPrivateKey = { version = 0, p, q, g, y, x } try: keylist = BER(data).decode() except BERException, x: raise SSHException('Unable to parse key file: ' + str(x))
def _from_private_key_file(self, filename, password): # private key file contains: # DSAPrivateKey = { version = 0, p, q, g, y, x } data = self._read_private_key_file('DSA', filename, password) try: keylist = BER(data).decode() except BERException, x: raise SSHException('Unable to parse key file: ' + str(x))
def _decode_key(self, data): # private key file contains: # DSAPrivateKey = { version = 0, p, q, g, y, x } try: keylist = BER(data).decode() except BERException as e: raise SSHException('Unable to parse key file: ' + str(e)) if (type(keylist) is not list) or (len(keylist) < 6) or (keylist[0] != 0): raise SSHException('not a valid DSA private key file (bad ber encoding)') self.p = keylist[1] self.q = keylist[2] self.g = keylist[3] self.y = keylist[4] self.x = keylist[5] self.size = util.bit_length(self.p)
def _decode_key(self, data): # private key file contains: # RSAPrivateKey = { version = 0, n, e, d, p, q, d mod p-1, d mod q-1, q**-1 mod p } try: keylist = BER(data).decode() except BERException: raise SSHException('Unable to parse key file') if (type(keylist) is not list) or (len(keylist) < 4) or (keylist[0] != 0): raise SSHException('Not a valid RSA private key file (bad ber encoding)') self.n = keylist[1] self.e = keylist[2] self.d = keylist[3] # not really needed self.p = keylist[4] self.q = keylist[5] self.size = util.bit_length(self.n)
def _decode_key(self, data): pkformat, data = data # private key file contains: # DSAPrivateKey = { version = 0, p, q, g, y, x } if pkformat == self._PRIVATE_KEY_FORMAT_ORIGINAL: try: keylist = BER(data).decode() except BERException as e: raise SSHException("Unable to parse key file: {}".format(e)) elif pkformat == self._PRIVATE_KEY_FORMAT_OPENSSH: keylist = self._uint32_cstruct_unpack(data, "iiiii") keylist = [0] + list(keylist) else: self._got_bad_key_format_id(pkformat) if type(keylist) is not list or len(keylist) < 6 or keylist[0] != 0: raise SSHException( "not a valid DSA private key file (bad ber encoding)") self.p = keylist[1] self.q = keylist[2] self.g = keylist[3] self.y = keylist[4] self.x = keylist[5] self.size = util.bit_length(self.p)
def test_encode_with_illegal_types(self): """ Encode should raise exception when used with float """ ber = BER() self.assertRaises(BERException, ber.encode, 0.1337)