path: root/src/cssh.c

#include <libssh/libssh.h> 
#include <libssh/callbacks.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdbool.h>
#include <unistd.h>

#include "cssh_options.h"
#include "msleep.h"

#define CSSH_VERSION "0.0.1"

static int parse_options_and_arguments( int argc, char *argv[], struct gengetopt_args_info *args_info ) {
        cmdline_parser_init( args_info );

        if( cmdline_parser2( argc, argv, args_info, 1, 0, 1 ) != 0 ) {
        	cmdline_parser_free( args_info );
        	return 1;
        }

        return 0;
}

static bool get_yes_or_no( )
{
	char buf[10];
	
ASK_AGAIN:
	if( fgets( buf, sizeof( buf ), stdin ) == NULL ) {
		fprintf( stderr, "ERROR: fgets failed in 'accept_server'\n" );
		return -1;
	}
	
	if( strncmp( buf, "yes", 3 ) == 0 ) {
		return true;
	} else if( strncmp( buf, "no", 2 ) == 0 ) {
		return false;
	} else {
		fprintf( stderr, "ERROR: expecting 'yes' or 'no' as answer\n" );
		goto ASK_AGAIN;
	}
	
	return true;
}

static int accept_server( ssh_session session, unsigned char *hash, size_t hlen )
{
	char *hexa;
	
	hexa = ssh_get_hexa( hash, hlen );
	fprintf( stderr, "The server is unknown. Do you trust the host key?\n" );
	fprintf( stderr, "The server public hash key is: %s\n", hexa );
	ssh_string_free_char( hexa );
	
	if( !get_yes_or_no( ) ) {
		fprintf( stderr, "INFO: Server key not accepted.. terminating now.\n" );
		return -1;
	}
	
	fprintf( stderr, "Do you want to write this new key into the known host file for future usage?\n" );
	if( get_yes_or_no( ) ) {
		if( ssh_write_knownhost( session ) < 0 ) {
			fprintf( stderr, "ERROR: error while writing known host file: %s\n",
				strerror( errno ) );
			return -1;
		}
	}
	
	return 0;
}

static int verify_knownhost( ssh_session session )
{
	int state;
	
	state = ssh_is_server_known( session );

	ssh_key srv_pubkey;
	int rc = ssh_get_publickey( session, &srv_pubkey );
	if( rc < 0 ) {
		fprintf( stderr, "ERROR: Failed to get public key of host: %s\n",
			ssh_get_error( session ) );
		return -1;
	}

	unsigned char *hash;
	size_t hlen;
	rc = ssh_get_publickey_hash( srv_pubkey, SSH_PUBLICKEY_HASH_SHA1, &hash, &hlen );
	if( rc < 0 ) {
		fprintf( stderr, "ERROR: Failed to get hash of public key of host: %s\n",
			ssh_get_error( session ) );
		return -1;
	}

	ssh_key_free( srv_pubkey );

	switch( state ) {
		case SSH_SERVER_KNOWN_OK:
			ssh_clean_pubkey_hash( &hash );
			return 0;
		
		case SSH_SERVER_KNOWN_CHANGED:
			fprintf( stderr, "ERROR: Host key for server changed : server's one is now:\n" );
			ssh_print_hexa( "Public key hash", hash, hlen );
			ssh_clean_pubkey_hash( &hash );
			return -1;		

		case SSH_SERVER_FOUND_OTHER:
			fprintf( stderr, "ERROR: The server gave us an unexpected host key, this could be an attack\n" );
			return -1;
		
		case SSH_SERVER_FILE_NOT_FOUND:
			fprintf( stderr, "ERROR: Could not find a known host file.\n" );
			rc = accept_server( session, hash, hlen );
			ssh_clean_pubkey_hash( &hash );
			return rc;
			
		case SSH_SERVER_NOT_KNOWN:
			fprintf( stderr, "ERROR: The server is unknown.\n" );
			rc = accept_server( session, hash, hlen );
			ssh_clean_pubkey_hash( &hash );
			return rc;

		case SSH_SERVER_ERROR:
			ssh_clean_pubkey_hash( &hash );
			fprintf( stderr, "ERROR: 'ssh_is_server_known' failed with: %s",
				ssh_get_error( session ) );
			return -1;

		default:
			ssh_clean_pubkey_hash( &hash );
			fprintf( stderr, "ERROR: Unknown check host state %d\n", state );
			return -1;
			
	}
	
	return 0;
}

static int authenticate_pubkey( ssh_session session )
{
	int rc = ssh_userauth_publickey_auto( session, NULL, NULL );
	switch( rc ) {
		case SSH_AUTH_SUCCESS:
			return SSH_AUTH_SUCCESS;
			
		case SSH_AUTH_DENIED:
			fprintf( stderr, "ERROR: authentication with public key denied\n" );
			return SSH_AUTH_DENIED;
		
		case SSH_AUTH_PARTIAL:
			return SSH_AUTH_PARTIAL;
			
		case SSH_AUTH_ERROR:
			fprintf( stderr, "ERROR: authentication with public key failed: %s\n",
				ssh_get_error( session ) );
			return SSH_AUTH_ERROR;
	}
	
	return -1;
}

static int authenticate_password( ssh_session session, const char *user )
{	
	char pass[128];
	memset( pass, 0, sizeof( pass ) );
	if( ssh_getpass( "Password: ", pass, sizeof( pass ), 0, 0 ) < 0 ) {
		fprintf( stderr, "ERROR: ssh_getpass failed\n" );
		ssh_disconnect( session );
		ssh_free( session );
		return -1;
	}	

	int rc = ssh_userauth_password( session, user, pass );
		
	switch( rc ) {
		case SSH_AUTH_SUCCESS:
			return SSH_AUTH_SUCCESS;
		
		case SSH_AUTH_PARTIAL:
			return SSH_AUTH_PARTIAL;
			
		case SSH_AUTH_DENIED:
			fprintf( stderr, "ERROR: Password authentication failed.\n" );
			return SSH_AUTH_DENIED;
			
		case SSH_AUTH_ERROR:
			fprintf( stderr, "ERROR: Failed to authenticate with password: %s\n",
				ssh_get_error( session ) );
			ssh_disconnect( session );
			ssh_free( session );
			return SSH_AUTH_ERROR;
	}
	
	return -1;
}

int main( int argc, char *argv[] )
{
	struct gengetopt_args_info args_info;
	ssh_session session;
	int port = 22;
	const char *host = "localhost";
	int rc;

	if( parse_options_and_arguments( argc, argv, &args_info ) != 0 ) {
		exit( EXIT_FAILURE );
	}

	ssh_threads_set_callbacks( ssh_threads_get_pthread( ) );
	ssh_init( );
	
	if( args_info.long_version_given ) {
		printf( "cssh version: %s\n", CSSH_VERSION );
		printf( "libssh version: %s\n", ssh_copyright( ) );
		exit( EXIT_SUCCESS );
	}
	
	session = ssh_new( );
	if( session == NULL ) {
		exit( EXIT_FAILURE );
	}

	if( args_info.inputs_num > 1 ) {
		host = args_info.inputs[0];
	}
	ssh_options_set( session, SSH_OPTIONS_HOST, host );
	
	if( args_info.port_given ) {
		port = args_info.port_arg;
	}
	ssh_options_set( session, SSH_OPTIONS_PORT, &port );

	if( args_info.verbose_given ) {
		int verbosity = SSH_LOG_NOLOG;
		verbosity += args_info.verbose_given;
		ssh_options_set( session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity );
	}
	
	rc = ssh_connect( session );
	if( rc != SSH_OK ) {
		fprintf( stderr, "ERROR: error connecting to '%s', port '%d': %s\n",
			host, port, ssh_get_error( session ) );
		ssh_free( session );
		exit( EXIT_FAILURE );
	}
		
	if( verify_knownhost( session ) < 0 ) {
		fprintf( stderr, "ERROR: closing connection to '%s', port '%d' due to security reasons\n",
			host, port );
		ssh_disconnect( session );
		ssh_free( session );
		exit( EXIT_FAILURE );
	}

	rc = ssh_userauth_none( session, NULL );
	if( rc == SSH_AUTH_ERROR ) {
		fprintf( stderr, "ERROR: ssh_userauth_none to '%s', port '%d' failed: %s\n",
			host, port, ssh_get_error( session ) );
		ssh_free( session );
		exit( EXIT_FAILURE );
	}

	char *banner = ssh_get_issue_banner( session );
	if( banner ) {
		puts( banner );
		free( banner );
	}	

	rc = authenticate_pubkey( session );
	if( rc == SSH_AUTH_ERROR ) {
		ssh_disconnect( session );
		ssh_free( session );
		exit( EXIT_FAILURE );
	}

	if( rc != SSH_AUTH_SUCCESS ) {
		rc = authenticate_password( session, args_info.login_given ? args_info.login_arg : NULL );
		if( rc < 0 ) {
			ssh_disconnect( session );
			ssh_free( session );
			exit( EXIT_FAILURE );
		}
	}
	
	ssh_channel channel = ssh_channel_new( session );
	if( channel == NULL ) {
		fprintf( stderr, "ERROR: Unable to open SSH channel: %s\n",
			ssh_get_error( session ) );
		ssh_disconnect( session );
		ssh_free( session );
		exit( EXIT_FAILURE );
	}

	rc = ssh_channel_open_session( channel );
	if( rc != SSH_OK ) {
		ssh_channel_free( channel );
		ssh_disconnect( session );
		ssh_free( session );
		exit( EXIT_FAILURE );
	}

	char cmd[1024];
	cmd[0] = '\0';
	if( args_info.inputs_num > 1 ) {
		for( int i = 1; i < args_info.inputs_num; i++ ) {
			if( i != 1 ) {
				strncat( cmd, " ", sizeof( cmd ) - strlen( cmd ) - 1 );
			}
			strncat( cmd, args_info.inputs[i], sizeof( cmd ) - strlen( cmd ) - 1 );
		}
	}
	if( cmd[0] == '\0' ) {
		fprintf( stderr, "ERROR: Empty command, no interactive CLI supported currently\n" );
		ssh_channel_free( channel );
		ssh_disconnect( session );
		ssh_free( session );
		exit( EXIT_FAILURE );
	}
	
	rc = ssh_channel_request_exec( channel, cmd );
	if( rc != SSH_OK ) {
		ssh_channel_close( channel );
		ssh_channel_free( channel );
		ssh_disconnect( session );
		ssh_free( session );
		exit( EXIT_FAILURE );
	}
	
	while( ssh_channel_is_open( channel ) && !ssh_channel_is_eof( channel ) ) {
		char buffer[256];
		bool must_sleep = false;
		
		rc = ssh_channel_poll( channel, 0 );
		if( rc == SSH_ERROR ) {
			fprintf( stderr, "ERROR: ssh_channel_poll on stdout failed: %s\n",
				ssh_get_error( session ) );
			ssh_channel_close( channel );
			ssh_channel_free( channel );
			ssh_disconnect( session );
			ssh_free( session );
			exit( EXIT_FAILURE );
		}
		
		if( rc == 0 ) {
			cssh_msleep( 10 );
		}
		
		if( rc > 0 ) {
			unsigned int nread = ssh_channel_read_nonblocking( channel, buffer, sizeof( buffer ), 0 );
			if( nread == SSH_ERROR ) {
				fprintf( stderr, "ERROR: ssh_channel_read_nonblocking on stdout failed: %s\n",
					ssh_get_error( session ) );
				ssh_channel_close( channel );
				ssh_channel_free( channel );
				ssh_disconnect( session );
				ssh_free( session );
				exit( EXIT_FAILURE );
			}

			if( nread > 0 ) {
				size_t wrc = fwrite( buffer, 1, nread, stdout );
				if( wrc < 0 ) {
					fprintf( stderr, "ERROR: while writting to stdout: %s\n",
						strerror( errno ) );
					ssh_channel_close( channel );
					ssh_channel_free( channel );
					ssh_disconnect( session );
					ssh_free( session );
					exit( EXIT_FAILURE );
				}

				if( wrc != nread ) {
					fprintf( stderr, "ERROR: Write mismatch on stdout (%zu != %d)\n",
						wrc, nread );
					ssh_channel_close( channel );
					ssh_channel_free( channel );
					ssh_disconnect( session );
					ssh_free( session );
					exit( EXIT_FAILURE );
				}
			}
		}

		rc = ssh_channel_poll( channel, 1 );
		if( rc == SSH_ERROR ) {
			fprintf( stderr, "ERROR: ssh_channel_poll on stderr failed: %s\n",
				ssh_get_error( session ) );
			ssh_channel_close( channel );
			ssh_channel_free( channel );
			ssh_disconnect( session );
			ssh_free( session );
			exit( EXIT_FAILURE );
		}
				
		if( rc > 0 ) {
			unsigned int nread = ssh_channel_read_nonblocking( channel, buffer, sizeof( buffer ), 1 );
			if( nread == SSH_ERROR ) {
				fprintf( stderr, "ERROR: ssh_channel_read_nonblocking on stderr failed: %s\n",
					ssh_get_error( session ) );
				ssh_channel_close( channel );
				ssh_channel_free( channel );
				ssh_disconnect( session );
				ssh_free( session );
				exit( EXIT_FAILURE );
			}

			if( nread > 0 ) {
				size_t wrc = fwrite( buffer, 1, nread, stderr );
				if( wrc < 0 ) {
					fprintf( stderr, "ERROR: while writting to stderr: %s\n",
						strerror( errno ) );
					ssh_channel_close( channel );
					ssh_channel_free( channel );
					ssh_disconnect( session );
					ssh_free( session );
					exit( EXIT_FAILURE );
				}

				if( wrc != nread ) {
					fprintf( stderr, "ERROR: Write mismatch on stderr (%zu != %d)\n",
						wrc, nread );
					ssh_channel_close( channel );
					ssh_channel_free( channel );
					ssh_disconnect( session );
					ssh_free( session );
					exit( EXIT_FAILURE );
				}
			}
		}

		if( must_sleep ) {
			cssh_msleep( 10 );
		}
	}
	
	ssh_channel_send_eof( channel );
	ssh_channel_close( channel );
	ssh_channel_free( channel );	
	ssh_disconnect( session );
	ssh_free( session );
	
	exit( EXIT_SUCCESS );
}