mirror of
https://git.libssh.org/projects/libssh.git
synced 2025-07-31 00:03:07 +03:00
tests: Added test server
The server can be configured through command line options or by providing a state structure with the desired values set. Currently supports only password based authentication. Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
This commit is contained in:
Anderson Toshiyuki Sasaki
committed by
Andreas Schneider
Andreas Schneider
parent
e91e221d02
commit
37262b98ef
588
tests/server/test_server/main.c
Normal file
588
tests/server/test_server/main.c
Normal file
@ -0,0 +1,588 @@
|
||||
/*
|
||||
* This file is part of the SSH Library
|
||||
*
|
||||
* Copyright (c) 2018 by Red Hat, Inc.
|
||||
*
|
||||
* Author: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
|
||||
*
|
||||
* The SSH Library is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser General Public License as published by
|
||||
* the Free Software Foundation; either version 2.1 of the License, or (at your
|
||||
* option) any later version.
|
||||
*
|
||||
* The SSH Library is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with the SSH Library; see the file COPYING. If not, write to
|
||||
* the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
#include "test_server.h"
|
||||
#include "default_cb.h"
|
||||
|
||||
#include <libssh/priv.h>
|
||||
|
||||
#include <libssh/libssh.h>
|
||||
#include <libssh/server.h>
|
||||
#include <libssh/callbacks.h>
|
||||
|
||||
#ifdef HAVE_ARGP_H
|
||||
#include <argp.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
struct arguments_st {
|
||||
char *address;
|
||||
char *port;
|
||||
|
||||
char *ecdsa_key;
|
||||
char *dsa_key;
|
||||
char *ed25519_key;
|
||||
char *rsa_key;
|
||||
char *host_key;
|
||||
|
||||
char *verbosity;
|
||||
char *auth_methods;
|
||||
bool with_pcap;
|
||||
|
||||
char *pcap_file;
|
||||
|
||||
char *username;
|
||||
char *password;
|
||||
};
|
||||
|
||||
static void free_arguments(struct arguments_st *arguments)
|
||||
{
|
||||
if (arguments == NULL) {
|
||||
goto end;
|
||||
}
|
||||
|
||||
SAFE_FREE(arguments->address);
|
||||
SAFE_FREE(arguments->port);
|
||||
|
||||
SAFE_FREE(arguments->ecdsa_key);
|
||||
SAFE_FREE(arguments->dsa_key);
|
||||
SAFE_FREE(arguments->ed25519_key);
|
||||
SAFE_FREE(arguments->rsa_key);
|
||||
SAFE_FREE(arguments->host_key);
|
||||
|
||||
SAFE_FREE(arguments->verbosity);
|
||||
SAFE_FREE(arguments->auth_methods);
|
||||
SAFE_FREE(arguments->pcap_file);
|
||||
|
||||
SAFE_FREE(arguments->username);
|
||||
SAFE_FREE(arguments->password);
|
||||
|
||||
end:
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef HAVE_ARGP_H
|
||||
|
||||
static void print_auth_methods(int auth_methods)
|
||||
{
|
||||
printf("auth_methods = \n");
|
||||
if (auth_methods & SSH_AUTH_METHOD_NONE) {
|
||||
printf("\tSSH_AUTH_METHOD_NONE\n");
|
||||
}
|
||||
if (auth_methods & SSH_AUTH_METHOD_PASSWORD) {
|
||||
printf("\tSSH_AUTH_METHOD_PASSWORD\n");
|
||||
}
|
||||
if (auth_methods & SSH_AUTH_METHOD_PUBLICKEY) {
|
||||
printf("\tSSH_AUTH_METHOD_PUBLICKEY\n");
|
||||
}
|
||||
if (auth_methods & SSH_AUTH_METHOD_HOSTBASED) {
|
||||
printf("\tSSH_AUTH_METHOD_HOSTBASED\n");
|
||||
}
|
||||
if (auth_methods & SSH_AUTH_METHOD_INTERACTIVE) {
|
||||
printf("\tSSH_AUTH_METHOD_INTERACTIVE\n");
|
||||
}
|
||||
if (auth_methods & SSH_AUTH_METHOD_GSSAPI_MIC) {
|
||||
printf("\tSSH_AUTH_METHOD_GSSAPI_MIC\n");
|
||||
}
|
||||
}
|
||||
|
||||
static void print_verbosity(int verbosity)
|
||||
{
|
||||
printf("verbosity = ");
|
||||
switch(verbosity) {
|
||||
case SSH_LOG_NOLOG:
|
||||
printf("NO LOG\n");
|
||||
break;
|
||||
case SSH_LOG_WARNING:
|
||||
printf("WARNING\n");
|
||||
break;
|
||||
case SSH_LOG_PROTOCOL:
|
||||
printf("PROTOCOL\n");
|
||||
break;
|
||||
case SSH_LOG_PACKET:
|
||||
printf("PACKET\n");
|
||||
break;
|
||||
case SSH_LOG_FUNCTIONS:
|
||||
printf("FUNCTIONS\n");
|
||||
break;
|
||||
default:
|
||||
printf("UNKNOWN\n");;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void print_server_state(struct server_state_st *state)
|
||||
{
|
||||
if (state) {
|
||||
printf("===================| STATE |=====================\n");
|
||||
printf("address = %s\n",
|
||||
state->address? state->address: "NULL");
|
||||
printf("port = %d\n",
|
||||
state->port? state->port: 0);
|
||||
printf("=================================================\n");
|
||||
printf("ecdsa_key = %s\n",
|
||||
state->ecdsa_key? state->ecdsa_key: "NULL");
|
||||
printf("dsa_key = %s\n",
|
||||
state->dsa_key? state->dsa_key: "NULL");
|
||||
printf("ed25519_key = %s\n",
|
||||
state->ed25519_key? state->ed25519_key: "NULL");
|
||||
printf("rsa_key = %s\n",
|
||||
state->rsa_key? state->rsa_key: "NULL");
|
||||
printf("host_key = %s\n",
|
||||
state->host_key? state->host_key: "NULL");
|
||||
printf("=================================================\n");
|
||||
print_auth_methods(state->auth_methods);
|
||||
print_verbosity(state->verbosity);
|
||||
printf("with_pcap = %s\n",
|
||||
state->with_pcap? "TRUE": "FALSE");
|
||||
printf("pcap_file = %s\n",
|
||||
state->pcap_file? state->pcap_file: "NULL");
|
||||
printf("=================================================\n");
|
||||
printf("username = %s\n",
|
||||
state->expected_username? state->expected_username: "NULL");
|
||||
printf("password = %s\n",
|
||||
state->expected_password? state->expected_password: "NULL");
|
||||
printf("=================================================\n");
|
||||
}
|
||||
}
|
||||
|
||||
static int init_server_state(struct server_state_st *state,
|
||||
struct arguments_st *arguments)
|
||||
{
|
||||
int rc = 0;
|
||||
|
||||
if (state == NULL) {
|
||||
rc = SSH_ERROR;
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* Initialize server state. The "arguments structure" */
|
||||
if (arguments->address) {
|
||||
state->address = arguments->address;
|
||||
arguments->address = NULL;
|
||||
} else {
|
||||
state->address = strdup(SSHD_DEFAULT_ADDRESS);
|
||||
if (state->address == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = SSH_ERROR;
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
if (arguments->port) {
|
||||
state->port = atoi(arguments->port);
|
||||
} else {
|
||||
state->port = SSHD_DEFAULT_PORT;
|
||||
}
|
||||
|
||||
if (arguments->ecdsa_key) {
|
||||
state->ecdsa_key = arguments->ecdsa_key;
|
||||
arguments->ecdsa_key = NULL;
|
||||
} else {
|
||||
state->ecdsa_key = NULL;
|
||||
}
|
||||
|
||||
if (arguments->dsa_key) {
|
||||
state->dsa_key = arguments->dsa_key;
|
||||
arguments->dsa_key = NULL;
|
||||
} else {
|
||||
state->dsa_key = NULL;
|
||||
}
|
||||
|
||||
if (arguments->ed25519_key) {
|
||||
state->ed25519_key = arguments->ed25519_key;
|
||||
arguments->ed25519_key = NULL;
|
||||
} else {
|
||||
state->ed25519_key = NULL;
|
||||
}
|
||||
|
||||
if (arguments->rsa_key) {
|
||||
state->rsa_key = arguments->rsa_key;
|
||||
arguments->rsa_key = NULL;
|
||||
} else {
|
||||
state->rsa_key = NULL;
|
||||
}
|
||||
|
||||
if (arguments->host_key) {
|
||||
state->host_key = arguments->host_key;
|
||||
arguments->host_key = NULL;
|
||||
} else {
|
||||
state->host_key = NULL;
|
||||
}
|
||||
|
||||
if (arguments->username) {
|
||||
state->expected_username = arguments->username;
|
||||
arguments->username = NULL;
|
||||
} else {
|
||||
state->expected_username = strdup(SSHD_DEFAULT_USER);
|
||||
if (state->expected_username == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = SSH_ERROR;
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
if (arguments->password) {
|
||||
state->expected_password = arguments->password;
|
||||
arguments->password = NULL;
|
||||
} else {
|
||||
state->expected_password = strdup(SSHD_DEFAULT_PASSWORD);
|
||||
if (state->expected_password == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = SSH_ERROR;
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
if (arguments->verbosity) {
|
||||
state->verbosity = atoi(arguments->verbosity);
|
||||
} else {
|
||||
state->verbosity = 0;
|
||||
}
|
||||
|
||||
if (arguments->auth_methods) {
|
||||
state->auth_methods = atoi(arguments->auth_methods);
|
||||
} else {
|
||||
state->auth_methods = 0;
|
||||
}
|
||||
|
||||
state->with_pcap = arguments->with_pcap;
|
||||
|
||||
if (arguments->pcap_file) {
|
||||
state->pcap_file = arguments->pcap_file;
|
||||
arguments->pcap_file = NULL;
|
||||
} else {
|
||||
if (arguments->with_pcap) {
|
||||
state->pcap_file = strdup(SSHD_DEFAULT_PCAP_FILE);
|
||||
if (state->pcap_file == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = SSH_ERROR;
|
||||
goto end;
|
||||
}
|
||||
} else {
|
||||
state->pcap_file = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* TODO make configurable */
|
||||
state->max_tries = 3;
|
||||
state->error = 0;
|
||||
|
||||
if (state) {
|
||||
print_server_state(state);
|
||||
}
|
||||
|
||||
/* TODO make callbacks configurable through command line ? */
|
||||
/* Set callbacks to be used */
|
||||
state->handle_session = default_handle_session_cb;
|
||||
|
||||
/* Check required parameters */
|
||||
if (state->address == NULL) {
|
||||
rc = SSH_ERROR;
|
||||
goto end;
|
||||
}
|
||||
|
||||
end:
|
||||
if (rc != 0) {
|
||||
free_server_state(state);
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
const char *argp_program_version = "libssh test server "
|
||||
SSH_STRINGIFY(LIBSSH_VERSION);
|
||||
const char *argp_program_bug_address = "<libssh@libssh.org>";
|
||||
|
||||
/* Program documentation. */
|
||||
static char doc[] = "libssh -- a Secure Shell protocol implementation";
|
||||
|
||||
/* A description of the arguments we accept. */
|
||||
static char args_doc[] = "BINDADDR";
|
||||
|
||||
/* The options we understand. */
|
||||
static struct argp_option options[] = {
|
||||
{
|
||||
.name = "port",
|
||||
.key = 'p',
|
||||
.arg = "PORT",
|
||||
.flags = 0,
|
||||
.doc = "Set the port to bind.",
|
||||
.group = 0
|
||||
},
|
||||
{
|
||||
.name = "ecdsakey",
|
||||
.key = 'c',
|
||||
.arg = "FILE",
|
||||
.flags = 0,
|
||||
.doc = "Set the ECDSA key.",
|
||||
.group = 0
|
||||
},
|
||||
{
|
||||
.name = "dsakey",
|
||||
.key = 'd',
|
||||
.arg = "FILE",
|
||||
.flags = 0,
|
||||
.doc = "Set the DSA key.",
|
||||
.group = 0
|
||||
},
|
||||
{
|
||||
.name = "ed25519key",
|
||||
.key = 'e',
|
||||
.arg = "FILE",
|
||||
.flags = 0,
|
||||
.doc = "Set the ed25519 key.",
|
||||
.group = 0
|
||||
},
|
||||
{
|
||||
.name = "rsakey",
|
||||
.key = 'r',
|
||||
.arg = "FILE",
|
||||
.flags = 0,
|
||||
.doc = "Set the RSA key.",
|
||||
.group = 0
|
||||
},
|
||||
{
|
||||
.name = "hostkey",
|
||||
.key = 'k',
|
||||
.arg = "FILE",
|
||||
.flags = 0,
|
||||
.doc = "Set the host key.",
|
||||
.group = 0
|
||||
},
|
||||
{
|
||||
.name = "pcapfile",
|
||||
.key = 'f',
|
||||
.arg = "FILE",
|
||||
.flags = 0,
|
||||
.doc = "Set the pcap output file.",
|
||||
.group = 0
|
||||
},
|
||||
{
|
||||
.name = "auth-methods",
|
||||
.key = 'a',
|
||||
.arg = "METHODS",
|
||||
.flags = 0,
|
||||
.doc = "Set supported authentication methods.",
|
||||
.group = 0
|
||||
},
|
||||
{
|
||||
.name = "user",
|
||||
.key = 'u',
|
||||
.arg = "USERNAME",
|
||||
.flags = 0,
|
||||
.doc = "Set expected username.",
|
||||
.group = 0
|
||||
},
|
||||
{
|
||||
.name = "verbosity",
|
||||
.key = 'v',
|
||||
.arg = "VERBOSITY",
|
||||
.flags = 0,
|
||||
.doc = "Set output verbosity [0-4].",
|
||||
.group = 0
|
||||
},
|
||||
{
|
||||
.name = "with-pcap",
|
||||
.key = 'w',
|
||||
.arg = NULL,
|
||||
.flags = 0,
|
||||
.doc = "Use PCAP.",
|
||||
.group = 0
|
||||
},
|
||||
{ .name = NULL }
|
||||
};
|
||||
|
||||
/* Parse a single option. */
|
||||
static error_t parse_opt (int key, char *arg, struct argp_state *state)
|
||||
{
|
||||
/* Get the input argument from argp_parse, which we
|
||||
* know is a pointer to our arguments structure.
|
||||
*/
|
||||
struct arguments_st *arguments = state->input;
|
||||
error_t rc = 0;
|
||||
|
||||
if (arguments == NULL) {
|
||||
fprintf(stderr, "NULL pointer to arguments structure provided\n");
|
||||
rc = EINVAL;
|
||||
goto end;
|
||||
}
|
||||
|
||||
switch (key) {
|
||||
case 'c':
|
||||
arguments->ecdsa_key = strdup(arg);
|
||||
if (arguments->ecdsa_key == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case 'd':
|
||||
arguments->dsa_key = strdup(arg);
|
||||
if (arguments->dsa_key == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case 'e':
|
||||
arguments->ed25519_key = strdup(arg);
|
||||
if (arguments->ed25519_key == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case 'f':
|
||||
arguments->pcap_file = strdup(arg);
|
||||
if (arguments->pcap_file == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case 'k':
|
||||
arguments->host_key = strdup(arg);
|
||||
if (arguments->host_key == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case 'a':
|
||||
arguments->auth_methods = strdup(arg);
|
||||
if (arguments->auth_methods == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case 'p':
|
||||
arguments->port = strdup(arg);
|
||||
if (arguments->port == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case 'r':
|
||||
arguments->rsa_key = strdup(arg);
|
||||
if (arguments->rsa_key == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case 'u':
|
||||
arguments->username = strdup(arg);
|
||||
if (arguments->username == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case 'v':
|
||||
arguments->verbosity = strdup(arg);
|
||||
if (arguments->verbosity == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case 'w':
|
||||
arguments->with_pcap = true;
|
||||
break;
|
||||
case ARGP_KEY_ARG:
|
||||
if (state->arg_num >= 1) {
|
||||
/* Too many arguments. */
|
||||
printf("Too many arguments\n");
|
||||
argp_usage(state);
|
||||
}
|
||||
arguments->address = strdup(arg);
|
||||
if (arguments->address == NULL) {
|
||||
fprintf(stderr, "Out of memory\n");
|
||||
rc = ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
break;
|
||||
case ARGP_KEY_END:
|
||||
if (state->arg_num < 1) {
|
||||
printf("Too few arguments\n");
|
||||
/* Not enough arguments. */
|
||||
argp_usage(state);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return ARGP_ERR_UNKNOWN;
|
||||
}
|
||||
|
||||
end:
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* Our argp parser. */
|
||||
static struct argp argp = {options, parse_opt, args_doc, doc, NULL, NULL, NULL};
|
||||
|
||||
#endif /* HAVE_ARGP_H */
|
||||
|
||||
int main(UNUSED_PARAM(int argc), UNUSED_PARAM(char **argv))
|
||||
{
|
||||
int rc;
|
||||
|
||||
struct arguments_st arguments = {
|
||||
.address = NULL,
|
||||
};
|
||||
struct server_state_st state = {
|
||||
.address = NULL,
|
||||
};
|
||||
|
||||
#ifdef HAVE_ARGP_H
|
||||
argp_parse (&argp, argc, argv, 0, 0, &arguments);
|
||||
#endif
|
||||
|
||||
/* Initialize the state using default or given parameters */
|
||||
rc = init_server_state(&state, &arguments);
|
||||
if (rc != 0) {
|
||||
goto free_arguments;
|
||||
}
|
||||
|
||||
/* Free the arguments used to initialize the state before fork */
|
||||
free_arguments(&arguments);
|
||||
|
||||
/* Run the server */
|
||||
rc = run_server(&state);
|
||||
if (rc != 0) {
|
||||
goto free_state;
|
||||
}
|
||||
|
||||
free_state:
|
||||
free_server_state(&state);
|
||||
free_arguments:
|
||||
free_arguments(&arguments);
|
||||
return rc;
|
||||
}
|
||||
Reference in New Issue
Block a user