SSH connection failed: SSH connection closed

[marcosurbanski]

Hi Ron i'm try to execute a list in for, but ssh connection return closed in a cisco router whats wrong ? when i start a single command i receive success return, another question how a i get all data output include banner, hostname, etc.

import asyncio, asyncssh, subprocess, sys

@asyncio.coroutine
async def run_client():
    async with asyncssh.connect(hostname='', known_hosts=None, username='', password='', client_keys=None ) as conn:
        local_proc = subprocess.Popen('', bufsize=1024, shell=True, stdout=subprocess.PIPE)
        var = ''
        cmd = ['sh cable modem summ', 'sh version', 'sh users']
        for p in cmd:
            remote_result = await conn.run(p + '\r\n', stdin=local_proc.stdout.read())
            print (remote_result.stdout)

try:
    asyncio.get_event_loop().run_until_complete(run_client())
except (OSError, asyncssh.Error) as exc:
    sys.exit('SSH connection failed: ' + str(exc))

Thanks,
Marcos

[ronf]

I don't quite understand what you're trying to do here. From the look of the code you pasted, you're running a local shell and trying to call read() on stdout from that shell, but I don't see you writing any commands to the shell before you do that. Even if you did write a command, I would expect the read() call to block on you until the shell exited, preventing you from ever getting past the first command (unless the command told the shell to exit).

Also, you seem to be trying to take the output from the local shell and use it as an argument to stdin on the SSH process, but if you pass a string as the stdin argument, it's going to be treated as a filename. If you want the data itself to be fed to the SSH connection, you'd want to use the "input" argument instead of "stdin". I still don't quite know how that would work here though, given you are trying to run multiple commands and you're blocking reading all of the input from the local process before you start the SSH session.

There are some other small things as well, like when passing a command you really shouldn't add the "\r\n" to the end of it. You'd only do that if you were trying to use an interactive shell on the SSH connection, where all the commands were run in a single session instead of starting one session per command.

I don't quite know why the connection is being closed. It could be because it doesn't like the command you are ending (perhaps due to the '\r\n' on it), but I've also seen some Cisco devices not support opening multiple SSH sessions on a single connection. It may be that it is closing the connection just as soon as the first SSH session ends, in which case you'd ether have to open multiple SSH connections or you'd have to open a single interactive shell over SSH and do your own sending of commands and parsing of prompts and potentially echo in the output.

Also, it's not a good idea to mix subprocess and asyncio. If you need to use local subprocesses, you should really be using asyncio's version of subprocess (documented at https://docs.python.org/3/library/asyncio-subprocess.html).

Finally, you shouldn't be mixing the "@asyncio.coroutine" decorator with "async def". When using the async keyword, you don't need the decorator.

[marcosurbanski]

Hi Ron, Thanks for your return, i used Paramiko for this job and resolved my problems, follow my solution, you have another solution ?

i used this "buffer" because sometimes i receive droped packets when i reduce the time.sleep, for example when i set time.sleep to "0.01" i received the output below,

HOSTNAME#show contrshow controllers cable 1/0/10 upstream | inc Cont
^
% Invalid input detected at '^' marker.

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(host, port=22, username='', password='')
connection = ssh.invoke_shell()

cmd = ['sh cable modem summ', 'sh version', 'sh users']

var = ''
buffer = 0


for p in cmd:
	connection.send(p + '\n')
        time.sleep(0.5)
	result = connection.recv(1024).decode(encoding='utf-8')
        var = var + result        
        buffer = buffer + 1
        if buffer == 50:
        	buffer = 0
        	result = ''
        	time.sleep(3)

outFile = open(dir + request + "_" + str(date_time) + ".txt", "w")
outFile.writelines(var[0:])
outFile.close()

[ronf]

All the indentation is getting lost in the code you are pasting here -- you might want to try surrounding it in lines that contain three back-quotes (```).

I'm not completely sure why you'd get the specific error you mention here, but one of the problems with what you're trying to do is that it is hard to know exactly when the command has finished generating all of the output. If the "HOSTNAME#" prompt is unique enough, though, you might using that as a way to detect the end of the output. I'm thinking about something like:

import asyncio, asyncssh, sys

async def save_output(process, prompt, outfile):
    output = await process.stdout.readuntil(prompt)

    with open(outfile, 'w') as f:
        f.write(output[:-len(prompt)])

async def run_client():
    host = 'localhost'
    port = 22
    prompt = 'HOSTNAME#'
    outfile = 1 

    async with asyncssh.connect(host, port) as conn:
        process = await conn.create_process()

        await save_output(process, prompt, 'initial_output.txt')
        
        for cmd in ['sh cable modem summ', 'sh version', 'sh users']:
            process.stdin.write(cmd + '\n')

            await save_output(process, prompt, 'output_%03d.txt' % outfile)
            outfile += 1
    
try:
    asyncio.get_event_loop().run_until_complete(run_client())
except (OSError, asyncssh.Error) as exc:
    sys.exit('SSH connection failed: ' + str(exc))

This will write the initial output received when connecting to the server to "initial_output.txt" and then write the output of each of the commands to a numbered file such as "output_001.txt", "output_002.txt", etc. You can adjust the filename to whatever you need pretty easily. The key is that it reads the output using readuntil(), looking for a command prompt. As long as that text doesn't appear in the command output anywhere, you should be good. By doing it this way, you don't have to worry about getting the sleep times right, or looping multiple times reading the output.

[marcosurbanski]

Hi Ron, thanks again for your advice, your ideia works for me, best regards. Have a nice day.

import asyncio, asyncssh, sys
import sys

async def save_output(process, prompt, outfile):
    output = await process.stdout.readuntil(prompt)

    with open(outfile, 'a+') as f:
        f.write(output[0:])

async def run_client():
    host = 'ip'
    prompt = 'namehost'
    user = ''
    pass = ''
    
   
    async with asyncssh.connect(host=host, port=22, username=user, password=pass, known_hosts=None, client_keys=None) as conn:
        process = await conn.create_process()

        output = await  process.stdout.readuntil("*")
        outFile = open('namehost', "w")
        outFile.write(output + '\n')

        for cmd in ['sh cable modem summ', 'sh version', 'sh users']:
            process.stdin.write(cmd + '\n')
            await save_output(process, prompt, prompt)

try:
    asyncio.get_event_loop().run_until_complete(run_client())
except (OSError, asyncssh.Error) as exc:
    sys.exit('SSH connection failed: ' + str(exc))

[ronf]

Glad to hear it! A few quick thoughts on the final code you posted:

• The "[0:]" after output in the first call to f.write() is unnecessary.
• The open() you do in run_client() has no corresponding close() call. If you just want to append all the output to a single file, though, you could probably pass in the already open outFile instead of a filename to save_output(), and you could remove the "with open()" line in there and just call readutil() and outFile.write(). The open() in run_client() should either be turned into a "with", though, or you should call close() explicitly, after the for loop if you want to pass outFile to save_output().
• I'm not sure why you are looking for '*' in the initial readuntil(). It seems like that might not capture all the initial output and might try to send the first command too early.
• I'd recommend making the prompt as specific as possible (adding something like the '#' at the end, for instance, if that's in the prompt) to minimize th chance of it matching some other part of the output if the hostname showed up there.

[marcosurbanski]

Thanks again for your return, i made as requested. Now i have another question, my script connect to different vendor equipments and a unique equipment it is presenting this error when I try to make the connection:
"p must be exactly 1024, 2048, or 3072 bits long"

When i put the path known_hosts=(['/home/****/known_hosts.pub']), i get:

Invalid DER private key

[ronf]

This indicates you have a DSA key in your "known_hosts.pub" which is of an unsupported size. The PyCA cryptography library has had a check in it going back to at least 2014 that only the listed sizes are supported. See #192 for more information.

For other reasons, the SSH DSA key exchange can't support key sizes larger than 1024 bits, so really the only DSA key size which will work with PyCA and AsyncSSH is exactly 1024 bits.

To fix the problem, you'll need to look for keys in known_hosts.pub of type "ssh-dss" and remove them if they are not one of the supported sizes. If the device you are connecting to is actually using a DSA key which is not 1024 bits long, you may need to see if you can reconfigure the device's host key to be a 1024-bit DSA key or switch to another key type such as RSA which doesn't have this restriction.

[marcosurbanski]

Hey Ron, i changed de to RSA key and it worked, Thanks for your time. Greetings from Brazil, Marcos.