def test_invalid_channel_open_failure_number(self):
"""Test invalid channel number in open failure"""
conn = yield from self.connect()
conn.send_packet(MSG_CHANNEL_OPEN_FAILURE, UInt32(0xff), UInt32(0),
String(''), String(''))
yield from conn.wait_closed()
def test_invalid_channel_open_failure_language(self):
"""Test invalid language in channel open failure"""
conn = yield from self.connect()
conn.send_packet(MSG_CHANNEL_OPEN_FAILURE, UInt32(0), UInt32(0),
String(''), String(b'\xff'))
yield from conn.wait_closed()
def test_unknown_channel_type(self):
"""Test unknown channel open type"""
conn = yield from self.connect()
conn.send_packet(MSG_CHANNEL_OPEN, String('xxx'), UInt32(0), UInt32(0),
UInt32(0))
yield from conn.wait_closed()
def test_invalid_channel_open_confirmation_number(self):
"""Test invalid channel number in open confirmation"""
conn = yield from self.connect()
conn.send_packet(MSG_CHANNEL_OPEN_CONFIRMATION, UInt32(0xff),
UInt32(0), UInt32(0), UInt32(0))
yield from conn.wait_closed()
def test_invalid_channel_open(self):
"""Test invalid channel open request"""
conn = yield from self.connect()
conn.send_packet(MSG_CHANNEL_OPEN, String(b'\xff'), UInt32(0),
UInt32(0), UInt32(0))
yield from conn.wait_closed()
def make_certificate(cert_version,
cert_type,
key,
signing_key,
principals,
key_id='name',
valid_after=0,
valid_before=0xffffffffffffffff,
options=None,
extensions=None,
bad_signature=False):
"""Construct an SSH certificate"""
keydata = key.encode_ssh_public()
principals = b''.join((String(p) for p in principals))
options = _encode_options(options) if options else b''
extensions = _encode_options(extensions) if extensions else b''
signing_keydata = b''.join(
(String(signing_key.algorithm), signing_key.encode_ssh_public()))
data = b''.join(
(String(cert_version), String(os.urandom(32)), keydata, UInt64(0),
UInt32(cert_type), String(key_id), String(principals),
UInt64(valid_after), UInt64(valid_before), String(options),
String(extensions), String(''), String(signing_keydata)))
if bad_signature:
data += String('')
else:
data += String(signing_key.sign(data, signing_key.algorithm))
return b''.join(
(cert_version.encode('ascii'), b' ', binascii.b2a_base64(data)))
def test_invalid_data_channel_number(self):
"""Test invalid channel number in channel data message"""
conn = yield from self.connect()
conn.send_packet(MSG_CHANNEL_DATA, UInt32(99), String(''))
yield from conn.wait_closed()
async def test_cancel_forward_remote_port_invalid_unicode(self):
"""Test canceling TCP/IP forwarding with invalid Unicode in host"""
with patch('asyncssh.connection.SSHClientConnection', _ClientConn):
async with self.connect() as conn:
pkttype, _ = await conn.make_global_request(
b'cancel-tcpip-forward', String(b'\xff'), UInt32(0))
self.assertEqual(pkttype, asyncssh.MSG_REQUEST_FAILURE)
def test_no_matching_host_key_algs(self):
"""Test no matching server host key algorithms"""
conn = yield from self.connect()
conn.send_packet(MSG_KEXINIT, os.urandom(16),
NameList([b'ecdh-sha2-nistp521']), NameList([b'xxx']),
NameList([]), NameList([]), NameList([]),
NameList([]), NameList([]), NameList([]),
NameList([]), NameList([]), Boolean(False), UInt32(0))
yield from conn.wait_closed()
def test_no_matching_kex_algs(self):
"""Test no matching key exchange algorithms"""
conn = yield from self.connect()
conn.send_packet(MSG_KEXINIT, os.urandom(16), NameList([b'xxx']),
NameList([]), NameList([]), NameList([]),
NameList([]), NameList([]), NameList([]),
NameList([]), NameList([]), NameList([]),
Boolean(False), UInt32(0))
yield from conn.wait_closed()
def authenticate(self, message_hash, app_hash, key_handle):
"""Sign a message with a security key using CTAP version 1"""
self._poll()
if self.dev.error == 'nocred':
raise ApduError(APDU.WRONG_DATA, b'')
elif self.dev.error == 'err':
raise ApduError(0, b'')
flags, counter, sig = self._sign(message_hash, app_hash, key_handle,
SSH_SK_USER_PRESENCE_REQD)
return Byte(flags) + UInt32(counter) + sig
async def test_get_sk_keys(self):
"""Test getting U2F security keys"""
key = asyncssh.generate_private_key(
'*****@*****.**')
cert = key.generate_user_certificate(key, 'test')
mock_agent = _Agent(Byte(SSH_AGENT_IDENTITIES_ANSWER) + UInt32(2) +
String(key.public_data) + String('') +
String(cert.public_data) + String(''))
await mock_agent.start('mock_agent')
async with asyncssh.connect_agent('mock_agent') as agent:
await agent.get_keys()
await mock_agent.stop()
def _sign(message_hash, app_hash, key_handle, flags):
"""Sign a message with a security key"""
alg, public_value, private_value = der_decode(key_handle)
if alg == SSH_SK_ECDSA:
key = ECDSAPrivateKey.construct(
b'nistp256', public_value,
int.from_bytes(private_value, 'big'))
else:
key = EdDSAPrivateKey.construct(b'ed25519', private_value)
counter = 0x12345678
sig = key.sign(app_hash + Byte(flags) + UInt32(counter) + message_hash)
return flags, counter, sig
async def _begin_session(self, stdin, stdout, stderr):
"""Begin processing a new session"""
# pylint: disable=too-many-statements
action = stdin.channel.get_command() or stdin.channel.get_subsystem()
if not action:
action = 'echo'
if action == 'echo':
await echo(stdin, stdout, stderr)
elif action == 'conn_close':
await stdin.read(1)
stdout.write('\n')
self._conn.close()
elif action == 'close':
await stdin.read(1)
stdout.write('\n')
elif action == 'agent':
try:
async with asyncssh.connect_agent(self._conn) as agent:
stdout.write(str(len((await agent.get_keys()))) + '\n')
except (OSError, asyncssh.ChannelOpenError):
stdout.channel.exit(1)
elif action == 'agent_sock':
agent_path = stdin.channel.get_agent_path()
if agent_path:
async with asyncssh.connect_agent(agent_path) as agent:
stdout.write(str(len((await agent.get_keys()))) + '\n')
else:
stdout.channel.exit(1)
elif action == 'rejected_agent':
agent_path = stdin.channel.get_agent_path()
stdout.write(str(bool(agent_path)) + '\n')
chan = self._conn.create_agent_channel()
try:
await chan.open(SSHUNIXStreamSession)
except asyncssh.ChannelOpenError:
stdout.channel.exit(1)
elif action == 'rejected_session':
chan = _ServerChannel(self._conn, asyncio.get_event_loop(), False,
False, 0, None, 'strict', 1, 32768)
try:
await chan.open_session()
except asyncssh.ChannelOpenError:
stdout.channel.exit(1)
elif action == 'rejected_tcpip_direct':
chan = self._conn.create_tcp_channel()
try:
await chan.connect(SSHTCPStreamSession, '', 0, '', 0)
except asyncssh.ChannelOpenError:
stdout.channel.exit(1)
elif action == 'unknown_tcpip_listener':
chan = self._conn.create_tcp_channel()
try:
await chan.accept(SSHTCPStreamSession, 'xxx', 0, '', 0)
except asyncssh.ChannelOpenError:
stdout.channel.exit(1)
elif action == 'invalid_tcpip_listener':
chan = self._conn.create_tcp_channel()
try:
await chan.accept(SSHTCPStreamSession, b'\xff', 0, '', 0)
except asyncssh.ChannelOpenError:
stdout.channel.exit(1)
elif action == 'rejected_unix_direct':
chan = self._conn.create_unix_channel()
try:
await chan.connect(SSHUNIXStreamSession, '')
except asyncssh.ChannelOpenError:
stdout.channel.exit(1)
elif action == 'unknown_unix_listener':
chan = self._conn.create_unix_channel()
try:
await chan.accept(SSHUNIXStreamSession, 'xxx')
except asyncssh.ChannelOpenError:
stdout.channel.exit(1)
elif action == 'invalid_unix_listener':
chan = self._conn.create_unix_channel()
try:
await chan.accept(SSHUNIXStreamSession, b'\xff')
except asyncssh.ChannelOpenError:
stdout.channel.exit(1)
elif action == 'late_auth_banner':
try:
self._conn.send_auth_banner('auth banner')
except OSError:
stdin.channel.exit(1)
elif action == 'invalid_open_confirm':
stdin.channel.send_packet(MSG_CHANNEL_OPEN_CONFIRMATION, UInt32(0),
UInt32(0), UInt32(0))
elif action == 'invalid_open_failure':
stdin.channel.send_packet(MSG_CHANNEL_OPEN_FAILURE, UInt32(0),
String(''), String(''))
elif action == 'env':
value = stdin.channel.get_environment().get('TEST', '')
stdout.write(value + '\n')
elif action == 'term':
chan = stdin.channel
info = str((chan.get_terminal_type(), chan.get_terminal_size(),
chan.get_terminal_mode(asyncssh.PTY_OP_OSPEED)))
stdout.write(info + '\n')
elif action == 'xon_xoff':
stdin.channel.set_xon_xoff(True)
elif action == 'no_xon_xoff':
stdin.channel.set_xon_xoff(False)
elif action == 'signals':
try:
await stdin.readline()
except asyncssh.BreakReceived as exc:
stdin.channel.exit_with_signal('ABRT', False, str(exc.msec))
except asyncssh.SignalReceived as exc:
stdin.channel.exit_with_signal('ABRT', False, exc.signal)
except asyncssh.TerminalSizeChanged as exc:
size = (exc.width, exc.height, exc.pixwidth, exc.pixheight)
stdin.channel.exit_with_signal('ABRT', False, str(size))
elif action == 'exit_status':
stdin.channel.exit(1)
elif action == 'closed_status':
stdin.channel.close()
stdin.channel.exit(1)
elif action == 'exit_signal':
stdin.channel.exit_with_signal('INT', False, 'exit_signal')
elif action == 'unknown_signal':
stdin.channel.exit_with_signal('unknown', False, 'unknown_signal')
elif action == 'closed_signal':
stdin.channel.close()
stdin.channel.exit_with_signal('INT', False, 'closed_signal')
elif action == 'invalid_exit_signal':
stdin.channel.exit_with_signal('invalid')
elif action == 'invalid_exit_lang':
stdin.channel.exit_with_signal('INT', False, '', 'invalid')
elif action == 'window_after_close':
stdin.channel.send_packet(MSG_CHANNEL_CLOSE)
stdin.channel.send_packet(MSG_CHANNEL_WINDOW_ADJUST, UInt32(0))
elif action == 'empty_data':
stdin.channel.send_packet(MSG_CHANNEL_DATA, String(''))
elif action == 'partial_unicode':
data = '\xff\xff'.encode('utf-8')
stdin.channel.send_packet(MSG_CHANNEL_DATA, String(data[:3]))
stdin.channel.send_packet(MSG_CHANNEL_DATA, String(data[3:]))
elif action == 'partial_unicode_at_eof':
data = '\xff\xff'.encode('utf-8')
stdin.channel.send_packet(MSG_CHANNEL_DATA, String(data[:3]))
elif action == 'unicode_error':
stdin.channel.send_packet(MSG_CHANNEL_DATA, String(b'\xff'))
elif action == 'data_past_window':
stdin.channel.send_packet(MSG_CHANNEL_DATA,
String(2 * 1025 * 1024 * '\0'))
elif action == 'data_after_eof':
stdin.channel.send_packet(MSG_CHANNEL_EOF)
stdout.write('xxx')
elif action == 'data_after_close':
await asyncio.sleep(0.1)
stdout.write('xxx')
elif action == 'ext_data_after_eof':
stdin.channel.send_packet(MSG_CHANNEL_EOF)
stdin.channel.write_stderr('xxx')
elif action == 'invalid_datatype':
stdin.channel.send_packet(MSG_CHANNEL_EXTENDED_DATA, UInt32(255),
String(''))
elif action == 'double_eof':
stdin.channel.send_packet(MSG_CHANNEL_EOF)
stdin.channel.write_eof()
elif action == 'double_close':
await asyncio.sleep(0.1)
stdout.write('xxx')
stdin.channel.send_packet(MSG_CHANNEL_CLOSE)
elif action == 'request_after_close':
stdin.channel.send_packet(MSG_CHANNEL_CLOSE)
stdin.channel.exit(1)
elif action == 'unexpected_auth':
self._conn.send_packet(MSG_USERAUTH_REQUEST, String('guest'),
String('ssh-connection'), String('none'))
elif action == 'invalid_response':
stdin.channel.send_packet(MSG_CHANNEL_SUCCESS)
else:
stdin.channel.exit(255)
stdin.channel.close()
await stdin.channel.wait_closed()
def make_x11_forwarding_request(self, proto, data, screen):
"""Make a request to enable X11 forwarding"""
return (yield from self._make_request(b'x11-req', Boolean(False),
String(proto), String(data),
UInt32(screen)))
def check_decode_errors(self):
"""Check error code paths in key decoding"""
private_errors = [
('Non-ASCII', '\xff'), ('Incomplete ASN.1', b''),
('Invalid PKCS#1', der_encode(None)),
('Invalid PKCS#1 params',
der_encode((1, b'', TaggedDERObject(0, b'')))),
('Invalid PKCS#1 EC named curve OID',
der_encode((1, b'', TaggedDERObject(0,
ObjectIdentifier('1.1'))))),
('Invalid PKCS#8',
der_encode((0, (self.privkey.pkcs8_oid, ()), der_encode(None)))),
('Invalid PKCS#8 ASN.1',
der_encode((0, (self.privkey.pkcs8_oid, None), b''))),
('Invalid PKCS#8 params',
der_encode(
(1, (self.privkey.pkcs8_oid, b''), der_encode((1, b''))))),
('Invalid PEM header', b'-----BEGIN XXX-----\n'),
('Missing PEM footer', b'-----BEGIN PRIVATE KEY-----\n'),
('Invalid PEM key type', b'-----BEGIN XXX PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(None)) +
b'-----END XXX PRIVATE KEY-----'),
('Invalid PEM Base64', b'-----BEGIN PRIVATE KEY-----\n'
b'X\n'
b'-----END PRIVATE KEY-----'),
('Missing PKCS#1 passphrase', b'-----BEGIN DSA PRIVATE KEY-----\n'
b'Proc-Type: 4,ENCRYPTED\n'
b'-----END DSA PRIVATE KEY-----'),
('Incomplete PEM ASN.1', b'-----BEGIN PRIVATE KEY-----\n'
b'-----END PRIVATE KEY-----'),
('Missing PEM PKCS#8 passphrase',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(None)) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#1 key', b'-----BEGIN DSA PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(None)) +
b'-----END DSA PRIVATE KEY-----'),
('Invalid PEM PKCS#8 key', b'-----BEGIN PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(None)) +
b'-----END PRIVATE KEY-----'),
('Unknown format OpenSSH key',
b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b'XXX') +
b'-----END OPENSSH PRIVATE KEY-----'),
('Incomplete OpenSSH key',
b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b'openssh-key-v1\0') +
b'-----END OPENSSH PRIVATE KEY-----'),
('Invalid OpenSSH nkeys',
b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String(''), String(''), String(''),
UInt32(2), String(''), String('')))) +
b'-----END OPENSSH PRIVATE KEY-----'),
('Missing OpenSSH passphrase',
b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String('xxx'), String(''), String(''),
UInt32(1), String(''), String('')))) +
b'-----END OPENSSH PRIVATE KEY-----'),
('Mismatched OpenSSH check bytes',
b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String('none'), String(''), String(''),
UInt32(1), String(''),
String(b''.join((UInt32(1), UInt32(2))))))) +
b'-----END OPENSSH PRIVATE KEY-----'),
('Invalid OpenSSH algorithm',
b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String('none'), String(''), String(''),
UInt32(1), String(''),
String(b''.join((UInt32(1), UInt32(1), String('xxx'))))))) +
b'-----END OPENSSH PRIVATE KEY-----'),
('Invalid OpenSSH pad', b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String('none'), String(''), String(''),
UInt32(1), String(''),
String(b''.join(
(UInt32(1), UInt32(1), String('ssh-dss'), 5 * MPInt(0),
String(''), b'\0')))))) +
b'-----END OPENSSH PRIVATE KEY-----')
]
decrypt_errors = [
('Invalid PKCS#1', der_encode(None)),
('Invalid PKCS#8',
der_encode((0, (self.privkey.pkcs8_oid, ()), der_encode(None)))),
('Invalid PEM params', b'-----BEGIN DSA PRIVATE KEY-----\n'
b'Proc-Type: 4,ENCRYPTED\n'
b'DEK-Info: XXX\n'
b'-----END DSA PRIVATE KEY-----'),
('Invalid PEM cipher', b'-----BEGIN DSA PRIVATE KEY-----\n'
b'Proc-Type: 4,ENCRYPTED\n'
b'DEK-Info: XXX,00\n'
b'-----END DSA PRIVATE KEY-----'),
('Invalid PEM IV', b'-----BEGIN DSA PRIVATE KEY-----\n'
b'Proc-Type: 4,ENCRYPTED\n'
b'DEK-Info: AES-256-CBC,XXX\n'
b'-----END DSA PRIVATE KEY-----'),
('Invalid PEM PKCS#8 encrypted data',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(None)) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 encrypted header',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(
(None, None))) + b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 encryption algorithm',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(((None, None), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES1 encryption parameters',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(((_ES1_SHA1_DES, None), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES1 PKCS#12 encryption parameters',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(((_P12_RC4_40, None), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES1 PKCS#12 salt',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(
((_P12_RC4_40,
(b'', 0)), b''))) + b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES1 PKCS#12 iteration count',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(((_P12_RC4_40, (b'x', 0)), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES2 encryption parameters',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' +
binascii.b2a_base64(der_encode(((_ES2, None), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES2 KDF algorithm',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' + binascii.b2a_base64(
der_encode(((_ES2, ((None, None), (None, None))), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES2 encryption algorithm',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' + binascii.b2a_base64(
der_encode(
((_ES2, ((_ES2_PBKDF2, None), (None, None))), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES2 PBKDF2 parameters',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' + binascii.b2a_base64(
der_encode(((_ES2, ((_ES2_PBKDF2, None),
(_ES2_AES128, None))), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES2 PBKDF2 salt',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' + binascii.b2a_base64(
der_encode(((_ES2, ((_ES2_PBKDF2, (None, None)),
(_ES2_AES128, None))), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES2 PBKDF2 iteration count',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' + binascii.b2a_base64(
der_encode(((_ES2, ((_ES2_PBKDF2, (b'', None)),
(_ES2_AES128, None))), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES2 PBKDF2 PRF',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' + binascii.b2a_base64(
der_encode(((_ES2, ((_ES2_PBKDF2, (b'', 0, None)),
(_ES2_AES128, None))), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Unknown PEM PKCS#8 PBES2 PBKDF2 PRF',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' + binascii.b2a_base64(
der_encode(
((_ES2, ((_ES2_PBKDF2, (b'', 0,
(ObjectIdentifier('1.1'), None))),
(_ES2_AES128, None))), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid PEM PKCS#8 PBES2 encryption parameters',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' + binascii.b2a_base64(
der_encode(((_ES2, ((_ES2_PBKDF2, (b'', 0)),
(_ES2_AES128, None))), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid length PEM PKCS#8 PBES2 IV',
b'-----BEGIN ENCRYPTED PRIVATE KEY-----\n' + binascii.b2a_base64(
der_encode(((_ES2, ((_ES2_PBKDF2, (b'', 0)),
(_ES2_AES128, b''))), b''))) +
b'-----END ENCRYPTED PRIVATE KEY-----'),
('Invalid OpenSSH cipher',
b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String('xxx'), String(''), String(''),
UInt32(1), String(''), String('')))) +
b'-----END OPENSSH PRIVATE KEY-----'),
('Invalid OpenSSH kdf', b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String('aes256-cbc'), String('xxx'),
String(''), UInt32(1), String(''), String('')))) +
b'-----END OPENSSH PRIVATE KEY-----'),
('Invalid OpenSSH kdf data',
b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String('aes256-cbc'), String('bcrypt'),
String(''), UInt32(1), String(''), String('')))) +
b'-----END OPENSSH PRIVATE KEY-----'),
('Invalid OpenSSH salt', b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String('aes256-cbc'), String('bcrypt'),
String(b''.join(
(String(b''), UInt32(1)))), UInt32(1), String(''),
String('')))) + b'-----END OPENSSH PRIVATE KEY-----'),
('Invalid OpenSSH encrypted data',
b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String('aes256-cbc'), String('bcrypt'),
String(b''.join(
(String(16 * b'\0'), UInt32(1)))), UInt32(1), String(''),
String('')))) + b'-----END OPENSSH PRIVATE KEY-----'),
('Unexpected OpenSSH trailing data',
b'-----BEGIN OPENSSH PRIVATE KEY-----\n' +
binascii.b2a_base64(b''.join(
(b'openssh-key-v1\0', String('aes256-cbc'), String('bcrypt'),
String(b''.join((String(16 * b'\0'), UInt32(1)))), UInt32(1),
String(''), String(''), String('xxx')))) +
b'-----END OPENSSH PRIVATE KEY-----')
]
public_errors = [
('Non-ASCII', '\xff'), ('Incomplete ASN.1', b''),
('Invalid ASN.1', b'\x30'), ('Invalid PKCS#1', der_encode(None)),
('Invalid PKCS#8',
der_encode(
((self.pubkey.pkcs8_oid, ()), BitString(der_encode(None))))),
('Invalid PKCS#8 ASN.1',
der_encode(((self.pubkey.pkcs8_oid, None), BitString(b'')))),
('Invalid PEM header', b'-----BEGIN XXX-----\n'),
('Missing PEM footer', b'-----BEGIN PUBLIC KEY-----\n'),
('Invalid PEM key type', b'-----BEGIN XXX PUBLIC KEY-----\n' +
binascii.b2a_base64(der_encode(None)) +
b'-----END XXX PUBLIC KEY-----'),
('Invalid PEM Base64', b'-----BEGIN PUBLIC KEY-----\n'
b'X\n'
b'-----END PUBLIC KEY-----'),
('Incomplete PEM ASN.1', b'-----BEGIN PUBLIC KEY-----\n'
b'-----END PUBLIC KEY-----'),
('Invalid PKCS#1 key data', b'-----BEGIN DSA PUBLIC KEY-----\n' +
binascii.b2a_base64(der_encode(None)) +
b'-----END DSA PUBLIC KEY-----'),
('Invalid PKCS#8 key data', b'-----BEGIN PUBLIC KEY-----\n' +
binascii.b2a_base64(der_encode(None)) +
b'-----END PUBLIC KEY-----'), ('Invalid OpenSSH', b'xxx'),
('Invalid OpenSSH Base64', b'ssh-dss X'),
('Unknown OpenSSH algorithm',
b'ssh-dss ' + binascii.b2a_base64(String('xxx'))),
('Invalid OpenSSH body',
b'ssh-dss ' + binascii.b2a_base64(String('ssh-dss'))),
('Invalid RFC4716 header', b'---- XXX ----\n'),
('Missing RFC4716 footer', b'---- BEGIN SSH2 PUBLIC KEY ----\n'),
('Invalid RFC4716 header', b'---- BEGIN SSH2 PUBLIC KEY ----\n'
b'XXX:\\\n'
b'---- END SSH2 PUBLIC KEY ----\n'),
('Invalid RFC4716 Base64', b'---- BEGIN SSH2 PUBLIC KEY ----\n'
b'X\n'
b'---- END SSH2 PUBLIC KEY ----\n')
]
for fmt, data in private_errors:
with self.subTest('Decode private (%s)' % fmt):
with self.assertRaises(KeyImportError):
import_private_key(data)
for fmt, data in decrypt_errors:
with self.subTest('Decrypt private (%s)' % fmt):
with self.assertRaises((KeyImportError, KeyEncryptionError)):
import_private_key(data, 'x')
for fmt, data in public_errors:
with self.subTest('Decode public (%s)' % fmt):
with self.assertRaises(KeyImportError):
import_public_key(data)
