Python ECDSAKey.from_private_key_file方法代码示例

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
 def test_11_load_ecdsa_password(self):
     key = ECDSAKey.from_private_key_file('tests/test_ecdsa_password.key', 'television')
     self.assertEquals(b'ecdsa-sha2-nistp256', key.get_name())
     exp_ecdsa = FINGER_ECDSA.split()[1].replace(b':', b'')
     my_ecdsa = hexlify(key.get_fingerprint())
     self.assertEquals(exp_ecdsa, my_ecdsa)
     self.assertEquals(PUB_ECDSA.split()[1], key.get_base64())
     self.assertEquals(256, key.get_bits())

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
 def test_12_compare_ecdsa(self):
     # verify that the private & public keys compare equal
     key = ECDSAKey.from_private_key_file('tests/test_ecdsa.key')
     self.assertEquals(key, key)
     pub = ECDSAKey(data=bytes(key))
     self.assert_(key.can_sign())
     self.assert_(not pub.can_sign())
     self.assertEquals(key, pub)

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
 def test_19_load_ecdsa_password_521(self):
     key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_password_521.key'), b'television')
     self.assertEqual('ecdsa-sha2-nistp521', key.get_name())
     exp_ecdsa = b(FINGER_ECDSA_521.split()[1].replace(':', ''))
     my_ecdsa = hexlify(key.get_fingerprint())
     self.assertEqual(exp_ecdsa, my_ecdsa)
     self.assertEqual(PUB_ECDSA_521.split()[1], key.get_base64())
     self.assertEqual(521, key.get_bits())

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
 def test_20_compare_ecdsa_521(self):
     # verify that the private & public keys compare equal
     key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_521.key'))
     self.assertEqual(key, key)
     pub = ECDSAKey(data=key.asbytes())
     self.assertTrue(key.can_sign())
     self.assertTrue(not pub.can_sign())
     self.assertEqual(key, pub)

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
 def test_16_compare_ecdsa_384(self):
     # verify that the private & public keys compare equal
     key = ECDSAKey.from_private_key_file(_support("test_ecdsa_384.key"))
     self.assertEqual(key, key)
     pub = ECDSAKey(data=key.asbytes())
     self.assertTrue(key.can_sign())
     self.assertTrue(not pub.can_sign())
     self.assertEqual(key, pub)

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
 def test_15_load_ecdsa_password_384(self):
     key = ECDSAKey.from_private_key_file(_support('test_ecdsa_password_384.key'), b'television')
     self.assertEqual('ecdsa-sha2-nistp384', key.get_name())
     exp_ecdsa = b(FINGER_ECDSA_384.split()[1].replace(':', ''))
     my_ecdsa = hexlify(key.get_fingerprint())
     self.assertEqual(exp_ecdsa, my_ecdsa)
     self.assertEqual(PUB_ECDSA_384.split()[1], key.get_base64())
     self.assertEqual(384, key.get_bits())

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
 def test_11_load_ecdsa_password(self):
     key = ECDSAKey.from_private_key_file(test_path("test_ecdsa_password.key"), b"television")
     self.assertEqual("ecdsa-sha2-nistp256", key.get_name())
     exp_ecdsa = b(FINGER_ECDSA.split()[1].replace(":", ""))
     my_ecdsa = hexlify(key.get_fingerprint())
     self.assertEqual(exp_ecdsa, my_ecdsa)
     self.assertEqual(PUB_ECDSA.split()[1], key.get_base64())
     self.assertEqual(256, key.get_bits())

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
 def test_19_load_ecdsa_password_521(self):
     key = ECDSAKey.from_private_key_file(
         _support("test_ecdsa_password_521.key"), b"television"
     )
     self.assertEqual("ecdsa-sha2-nistp521", key.get_name())
     exp_ecdsa = b(FINGER_ECDSA_521.split()[1].replace(":", ""))
     my_ecdsa = hexlify(key.get_fingerprint())
     self.assertEqual(exp_ecdsa, my_ecdsa)
     self.assertEqual(PUB_ECDSA_521.split()[1], key.get_base64())
     self.assertEqual(521, key.get_bits())

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
    def test_13_sign_ecdsa(self):
        # verify that the rsa private key can sign and verify
        key = ECDSAKey.from_private_key_file('tests/test_ecdsa.key')
        msg = key.sign_ssh_data(rng, b'ice weasels')
        self.assert_(type(msg) is Message)
        msg.rewind()
        self.assertEquals(b'ecdsa-sha2-nistp256', msg.get_string())
        # ECDSA signatures, like DSS signatures, tend to be different
        # each time, so we can't compare against a "known correct"
        # signature.
        # Even the length of the signature can change.

        msg.rewind()
        pub = ECDSAKey(data=bytes(key))
        self.assert_(pub.verify_ssh_sig(b'ice weasels', msg))

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
    def test_10_load_ecdsa(self):
        key = ECDSAKey.from_private_key_file('tests/test_ecdsa.key')
        self.assertEquals(b'ecdsa-sha2-nistp256', key.get_name())
        exp_ecdsa = FINGER_ECDSA.split()[1].replace(b':', b'')
        my_ecdsa = hexlify(key.get_fingerprint())
        self.assertEquals(exp_ecdsa, my_ecdsa)
        self.assertEquals(PUB_ECDSA.split()[1], key.get_base64())
        self.assertEquals(256, key.get_bits())

        s = BytesIO()
        key.write_private_key(s)
        self.assertEquals(ECDSA_PRIVATE_OUT, s.getvalue())
        s.seek(0)
        key2 = ECDSAKey.from_private_key(StringIO(s.getvalue().decode()))
        self.assertEquals(key, key2)

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
    def test_21_sign_ecdsa_521(self):
        # verify that the rsa private key can sign and verify
        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_521.key'))
        msg = key.sign_ssh_data(b'ice weasels')
        self.assertTrue(type(msg) is Message)
        msg.rewind()
        self.assertEqual('ecdsa-sha2-nistp521', msg.get_text())
        # ECDSA signatures, like DSS signatures, tend to be different
        # each time, so we can't compare against a "known correct"
        # signature.
        # Even the length of the signature can change.

        msg.rewind()
        pub = ECDSAKey(data=key.asbytes())
        self.assertTrue(pub.verify_ssh_sig(b'ice weasels', msg))

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
    def test_14_load_ecdsa_384(self):
        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_384.key'))
        self.assertEqual('ecdsa-sha2-nistp384', key.get_name())
        exp_ecdsa = b(FINGER_ECDSA_384.split()[1].replace(':', ''))
        my_ecdsa = hexlify(key.get_fingerprint())
        self.assertEqual(exp_ecdsa, my_ecdsa)
        self.assertEqual(PUB_ECDSA_384.split()[1], key.get_base64())
        self.assertEqual(384, key.get_bits())

        s = StringIO()
        key.write_private_key(s)
        self.assertEqual(ECDSA_PRIVATE_OUT_384, s.getvalue())
        s.seek(0)
        key2 = ECDSAKey.from_private_key(s)
        self.assertEqual(key, key2)

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
    def test_10_load_ecdsa_256(self):
        key = ECDSAKey.from_private_key_file(_support("test_ecdsa_256.key"))
        self.assertEqual("ecdsa-sha2-nistp256", key.get_name())
        exp_ecdsa = b(FINGER_ECDSA_256.split()[1].replace(":", ""))
        my_ecdsa = hexlify(key.get_fingerprint())
        self.assertEqual(exp_ecdsa, my_ecdsa)
        self.assertEqual(PUB_ECDSA_256.split()[1], key.get_base64())
        self.assertEqual(256, key.get_bits())

        s = StringIO()
        key.write_private_key(s)
        self.assertEqual(ECDSA_PRIVATE_OUT_256, s.getvalue())
        s.seek(0)
        key2 = ECDSAKey.from_private_key(s)
        self.assertEqual(key, key2)

# 需要导入模块: from paramiko import ECDSAKey [as 别名]
# 或者: from paramiko.ECDSAKey import from_private_key_file [as 别名]
    def test_18_load_ecdsa_521(self):
        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_521.key'))
        self.assertEqual('ecdsa-sha2-nistp521', key.get_name())
        exp_ecdsa = b(FINGER_ECDSA_521.split()[1].replace(':', ''))
        my_ecdsa = hexlify(key.get_fingerprint())
        self.assertEqual(exp_ecdsa, my_ecdsa)
        self.assertEqual(PUB_ECDSA_521.split()[1], key.get_base64())
        self.assertEqual(521, key.get_bits())

        s = StringIO()
        key.write_private_key(s)
        # Different versions of OpenSSL (SSLeay versions 0x1000100f and
        # 0x1000207f for instance) use different apparently valid (as far as
        # ssh-keygen is concerned) padding. So we can't check the actual value
        # of the pem encoded key.
        s.seek(0)
        key2 = ECDSAKey.from_private_key(s)
        self.assertEqual(key, key2)