Boolean ssh_channel_start_local_tcp_forward(SshCommon common,
const char *address_to_bind,
const char *port,
const char *connect_to_host,
const char *connect_to_port)
{
SshLocalTcpForward fwd;
SshChannelTypeTcpDirect ct;
long portnumber;
SshUser user;
SSH_DEBUG(5, ("requesting local forwarding for port %s to %s:%s",
port, connect_to_host, connect_to_port));
portnumber = atol(port);
user = ssh_user_initialize(NULL, FALSE);
/* If user is not logged in as a privileged user, don't allow
forwarding of privileged ports. */
if (portnumber < 1024)
{
if (ssh_user_uid(user))
{
ssh_warning("Tried to forward " \
"privileged port %d as an ordinary user.",
portnumber);
return FALSE;
}
}
if (portnumber >= 65536)
{
ssh_warning("Tried to forward " \
"port above 65535 (%d).",
portnumber);
return FALSE;
}
ct = ssh_channel_dtcp_ct(common);
fwd = ssh_xcalloc(1, sizeof(*fwd));
fwd->common = common;
fwd->listener = ssh_tcp_make_listener(address_to_bind, port,
ssh_channel_dtcp_incoming_connection,
(void *)fwd);
if (!fwd->listener)
{
SSH_DEBUG(5, ("creating listener failed"));
ssh_xfree(fwd);
return FALSE;
}
fwd->port = ssh_xstrdup(port);
fwd->connect_to_host = ssh_xstrdup(connect_to_host);
fwd->connect_to_port = ssh_xstrdup(connect_to_port);
fwd->next = ct->local_forwards;
ct->local_forwards = fwd;
return TRUE;
}
Boolean ssh_server_update_transport_params(SshConfig config,
SshTransportParams params)
{
char *hlp;
if (config->ciphers != NULL)
{
hlp = ssh_cipher_list_canonialize(config->ciphers);
if (hlp)
{
ssh_xfree(params->ciphers_c_to_s);
params->ciphers_c_to_s = ssh_xstrdup(hlp);
ssh_xfree(params->ciphers_s_to_c);
params->ciphers_s_to_c = ssh_xstrdup(hlp);
ssh_xfree(hlp);
}
}
hlp = ssh_public_key_list_canonialize(params->host_key_algorithms);
ssh_xfree(params->host_key_algorithms);
params->host_key_algorithms = hlp;
hlp = ssh_hash_list_canonialize(params->hash_algorithms);
ssh_xfree(params->hash_algorithms);
params->hash_algorithms = hlp;
return TRUE;
}
static void
read_censor_list()
{
FILE *fp;
char buf[1024];
fp = fopen(censor_file, "rb");
if (fp == NULL)
{
SSH_DEBUG(SSH_D_ERROR, ("could not open censor file `%s'",
censor_file));
return;
}
while (fgets(buf, sizeof(buf), fp) != NULL)
{
char *cp;
ProxyCensor *c = ssh_xcalloc(1, sizeof(*c));
cp = strchr(buf, '\n');
if (cp)
*cp = '\0';
c->next = censor;
censor = c;
c->pattern = ssh_xstrdup(buf);
}
fclose(fp);
}
Boolean ssh_user_password_must_be_changed(SshUser uc,
char **prompt_return)
{
if (uc->password_needs_change)
*prompt_return = ssh_xstrdup("Your password has expired.");
return uc->password_needs_change;
}
void ssh_local_connect(const char *path,
SshLocalCallback callback,
void *context)
{
int sock;
SshLocalConnect c;
/* Create a unix-domain socket. */
sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (sock < 0)
{
/* Failed to create the socket. */
(*callback)(NULL, context);
return;
}
/* Allocate and initialize a context structure. */
c = ssh_xmalloc(sizeof(*c));
c->path = ssh_xstrdup(path);
c->sock = sock;
c->callback = callback;
c->context = context;
/* Register the file descriptor. Note that this also makes it
non-blocking. */
ssh_io_register_fd(sock, ssh_local_connect_try, c);
/* Fake a callback to start asynchronous connect. This connect could be
done on this current routine, but we want this to be similar with
tcp/ip socket code, so we use the try-routines */
ssh_local_connect_try(SSH_IO_WRITE, (void *)c);
}
void update_algs(SshTransportParams params, const char *algs)
{
char *copy;
char *cp, **dest;
int i;
if (algs == NULL)
return;
copy = ssh_xstrdup(algs);
for (i = 0, cp = strtok(copy, ":"); cp; i++, cp = strtok(NULL, ":"))
{
switch (i)
{
case 0: /* c_to_s_cipher */
dest = ¶ms->ciphers_c_to_s;
break;
case 1: /* s_to_c_cipher */
dest = ¶ms->ciphers_s_to_c;
break;
case 2: /* c_to_s_mac */
dest = ¶ms->macs_c_to_s;
break;
case 3: /* s_to_c_mac */
dest = ¶ms->macs_s_to_c;
break;
case 4: /* c_to_s_compression */
dest = ¶ms->compressions_c_to_s;
break;
case 5: /* s_to_c_compression */
dest = ¶ms->compressions_s_to_c;
break;
default:
dest = NULL; /* to avoid compiler warning... */
ssh_fatal("too many algorithms: %s", cp);
}
#ifdef DEBUG
ssh_debug("alg: %s\n", cp);
#endif
if (*dest)
ssh_xfree(*dest);
*dest = ssh_xstrdup(cp);
}
ssh_xfree(copy);
}
SshLocalListener ssh_local_make_listener(const char *path,
SshLocalCallback callback,
void *context)
{
int sock;
struct sockaddr_un sunaddr;
SshLocalListener listener;
/* Create a socket for the listener. */
sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (sock < 0)
{
ssh_warning("Can not create local domain socket: %.200s",
strerror(errno));
return NULL;
}
/* Initialize a unix-domain address structure. */
memset(&sunaddr, 0, sizeof(sunaddr));
sunaddr.sun_family = AF_UNIX;
strncpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path));
/* Bind the socket to the address. This will create the socket in the file
system, and will fail if the socket already exists. */
if (bind(sock, (struct sockaddr *)&sunaddr, AF_UNIX_SIZE(sunaddr)) < 0)
{
close(sock);
ssh_warning("Can not bind local address %.200s: %.200s",
path, strerror(errno));
return NULL;
}
/* Start listening for connections to the socket. */
if (listen(sock, 5) < 0)
{
close(sock);
ssh_warning("Can not listen to local address %.200s: %.200s",
path, strerror(errno));
return NULL;
}
/* Allocate and initialize the listener structure. */
listener = ssh_xmalloc(sizeof(*listener));
listener->sock = sock;
listener->path = ssh_xstrdup(path);
listener->callback = callback;
listener->context = context;
/* ssh_local_listen_callback will call the user supplied callback
when after new connection is accepted. It also creates stream
object for the new connection and calls callback. */
ssh_io_register_fd(sock, ssh_local_listen_callback, (void *)listener);
ssh_io_set_fd_request(sock, SSH_IO_READ);
return listener;
}
void store_delimited_strings(SshBuffer *packet, const char *arg)
{
char *copy, *part;
copy = ssh_xstrdup(arg);
for (part = strtok(copy, ":"); part; part = strtok(NULL, ":"))
buffer_put_uint32_string(packet, part, strlen(part));
ssh_xfree(copy);
}
SshCondition ssh_xcondition_create (const char *name, SshUInt32 flags)
{
SshCondition cond;
cond = ssh_xcalloc(1, sizeof(*cond));
if (name)
cond->name = ssh_xstrdup(name);
return cond;
}
void byaddr_cb(SshIpError error, const char *result, void *context)
{
char *name = (char *)context, *addr, *addrs;
if (error == SSH_IP_OK)
{
addrs = ssh_xstrdup(result);
fprintf(stderr, "++ NAME=%s, ADDRS=%s\n", name, addrs);
addr = strtok(addrs, ",");
while (addr)
{
ssh_tcp_get_host_by_addr(addr, byname_cb, ssh_xstrdup(addr));
addr = strtok(NULL, ",");
}
ssh_xfree(addrs);
}
else
fprintf(stderr, "-- NAME=%s, ADDRS=none\n", name);
}
SshTransportParams ssh_transport_create_params(void)
{
SshTransportParams params;
char *hlp;
params = ssh_xmalloc(sizeof(*params));
params->kex_algorithms = ssh_xstrdup(DEFAULT_KEXS);
hlp = ssh_public_key_get_supported();
params->host_key_algorithms = ssh_public_key_list_canonialize(hlp);
ssh_xfree(hlp);
params->hash_algorithms = ssh_hash_get_supported();
params->compressions_c_to_s = ssh_xstrdup(DEFAULT_COMPRESSIONS);
params->compressions_s_to_c = ssh_xstrdup(DEFAULT_COMPRESSIONS);
params->ciphers_c_to_s = ssh_name_list_intersection_cipher(DEFAULT_CIPHERS);
params->ciphers_s_to_c = ssh_name_list_intersection_cipher(DEFAULT_CIPHERS);
params->macs_c_to_s = ssh_name_list_intersection_mac(DEFAULT_MACS);
params->macs_s_to_c = ssh_name_list_intersection_mac(DEFAULT_MACS);
return params;
}
void ssh_snlist_append(char **list, const char *item)
{
char *to_be_deleted;
if (*list == NULL)
{
*list = ssh_xstrdup(item);
return;
}
if (strlen(*list) == 0)
{
ssh_xfree(*list);
*list = ssh_xstrdup(item);
return;
}
to_be_deleted = *list;
ssh_xdsprintf((unsigned char **)list, "%s,%s", *list, item);
ssh_xfree(to_be_deleted);
}
/* separate (commandline)options from their parameters */
void ssh_split_arguments(int argc, char **argv, int *dest_ac, char ***dest_av)
{
int temp_ac = 0, i;
char **temp_av;
int alloc = argc + 1;
temp_av = ssh_xcalloc(alloc, sizeof(char*));
/* count possible options and parameters */
for (i = 0; i < argc ; i++)
{
if ( alloc < temp_ac + 3)
{
alloc = temp_ac + 3;
temp_av = ssh_xrealloc(temp_av, alloc*sizeof(char*));
}
if (argv[i][0] == '-' || argv[i][0] == '+')
{
if(argv[i][1] && argv[i][2])
{
temp_av[temp_ac] = ssh_xstrdup(argv[i]);
temp_av[temp_ac][2] = '\0';
temp_av[++temp_ac] = ssh_xstrdup(argv[i] + 2);
}
else
{
temp_av[temp_ac] = ssh_xstrdup(argv[i]);
}
}
else
{
temp_av[temp_ac] = ssh_xstrdup(argv[i]);
}
temp_ac++;
}
temp_av[ temp_ac ] = NULL;
(*dest_ac) = temp_ac;
(*dest_av) = temp_av;
}
void ssh_channel_start_remote_tcp_forward(SshCommon common,
const char *address_to_bind,
const char *port,
const char *connect_to_host,
const char *connect_to_port,
void (*completion)(Boolean ok,
void *context),
void *context)
{
SshRemoteTcpForward fwd;
SshBuffer buffer;
SshChannelTypeTcpForward ct;
SSH_DEBUG(5, ("requesting remote forwarding for port %s", port));
ct = ssh_channel_ftcp_ct(common);
/* Create a context for the forwarding. */
fwd = ssh_xcalloc(1, sizeof(*fwd));
fwd->common = common;
fwd->address_to_bind = ssh_xstrdup(address_to_bind);
fwd->port = ssh_xstrdup(port);
fwd->connect_to_host = ssh_xstrdup(connect_to_host);
fwd->connect_to_port = ssh_xstrdup(connect_to_port);
/* Add it to the list of remote forwardings. */
fwd->next = ct->remote_forwards;
ct->remote_forwards = fwd;
/* Send a forwarding request to the remote side. */
ssh_buffer_init(&buffer);
ssh_encode_buffer(&buffer,
SSH_FORMAT_UINT32_STR,
address_to_bind, strlen(address_to_bind),
SSH_FORMAT_UINT32, (SshUInt32) atol(port),
SSH_FORMAT_END);
ssh_conn_send_global_request(common->conn, "tcpip-forward",
ssh_buffer_ptr(&buffer), ssh_buffer_len(&buffer),
completion, context);
ssh_buffer_uninit(&buffer);
}
char *dual_policy(const char *user, const char *service, const char *client_ip,
const char *client_port,
const char *completed_authentications, void *context)
{
#ifdef DEBUG
ssh_debug("dual_policy: user '%s' service '%s' client_ip '%s' "
"client_port '%s' completed '%s'",
user, service, client_ip, client_port, completed_authentications);
#endif
if (strcmp(completed_authentications, "") == 0)
return ssh_xstrdup("password1");
if (strcmp(completed_authentications, "password1") == 0)
return ssh_xstrdup("password2");
if (strcmp(completed_authentications, "password2") == 0)
return ssh_xstrdup("password1");
if (strcmp(completed_authentications, "password1,password2") == 0 ||
strcmp(completed_authentications, "password2,password1") == 0)
return NULL;
return "";
}
SshMutex ssh_mutex_create(const char *name, SshUInt32 flags)
{
SshMutex mutex;
mutex = ssh_xmalloc(sizeof(*mutex));
InitializeCriticalSection(&mutex->critical);
if (name)
mutex->name = ssh_xstrdup(name);
else
mutex->name = NULL;
mutex->locked = 0;
return mutex;
}
char *ssh_snlist_exclude(const char *original,
const char *excluded)
{
const char *ptr;
char *current;
char *new_list;
new_list = ssh_xstrdup("");
for (ptr = original; ptr != NULL; ptr = ssh_snlist_step_forward(ptr))
{
current = ssh_snlist_get_name(ptr);
if (!ssh_snlist_contains(excluded, current))
{
ssh_snlist_append(&new_list, current);
}
ssh_xfree(current);
}
return new_list;
}
char *ssh_read_passphrase(const char *prompt, int from_stdin)
{
char buf[1024], *cp;
unsigned char quoted_prompt[512];
unsigned const char *p;
#ifdef USING_TERMIOS
struct termios tio;
#endif
#ifdef USING_SGTTY
struct sgttyb tio;
#endif
FILE *f;
int i;
if (from_stdin)
f = stdin;
else
{
/* Read the passphrase from /dev/tty to make it possible to ask it even
when stdin has been redirected. */
f = fopen("/dev/tty", "r");
if (!f)
{
if (getenv("DISPLAY"))
{
char command[512];
fprintf(stderr,
"Executing ssh-askpass to query the password...\n");
fflush(stdout);
fflush(stderr);
for(p = (unsigned const char *) prompt, i = 0;
i < sizeof(quoted_prompt) - 5 && *p;
i++, p++)
{
if (*p == '\'')
{
quoted_prompt[i++] = '\'';
quoted_prompt[i++] = '\\';
quoted_prompt[i++] = '\'';
quoted_prompt[i] = '\'';
}
else if (isprint(*p) || isspace(*p))
quoted_prompt[i] = *p;
else if (iscntrl(*p))
{
quoted_prompt[i++] = '^';
if (*p < ' ')
quoted_prompt[i] = *p + '@';
else
quoted_prompt[i] = '?';
}
else if (*p > 128)
quoted_prompt[i] = *p;
}
quoted_prompt[i] = '\0';
snprintf(command, sizeof(command),
"ssh-askpass '%.400s'", quoted_prompt);
f = popen(command, "r");
if (f == NULL)
{
fprintf(stderr, "Could not query passphrase: '%.200s' failed.\n",
command);
return NULL;
}
if (!fgets(buf, sizeof(buf), f))
{
pclose(f);
fprintf(stderr, "No passphrase supplied.\n");
return NULL;
}
pclose(f);
if (strchr(buf, '\n'))
*strchr(buf, '\n') = 0;
return ssh_xstrdup(buf);
}
/* No controlling terminal and no DISPLAY. Nowhere to read. */
fprintf(stderr, "You have no controlling tty and no DISPLAY. Cannot read passphrase.\n");
return NULL;
}
}
for(p = (unsigned const char *) prompt, i = 0;
i < sizeof(quoted_prompt) - 4 && *p; i++, p++)
{
if (isprint(*p) || isspace(*p))
quoted_prompt[i] = *p;
else if (iscntrl(*p))
{
quoted_prompt[i++] = '^';
if (*p < ' ')
quoted_prompt[i] = *p + '@';
else
quoted_prompt[i] = '?';
}
else if (*p > 128)
quoted_prompt[i] = *p;
}
quoted_prompt[i] = '\0';
/* Display the prompt (on stderr because stdout might be redirected). */
fflush(stdout);
fprintf(stderr, "%s", quoted_prompt);
fflush(stderr);
/* Get terminal modes. */
#ifdef USING_TERMIOS
tcgetattr(fileno(f), &tio);
#endif
#ifdef USING_SGTTY
ioctl(fileno(f), TIOCGETP, &tio);
#endif
saved_tio = tio;
/* Save signal handler and set the new handler. */
old_handler = signal(SIGINT, ssh_rp_intr_handler);
/* Set new terminal modes disabling all echo. */
#ifdef USING_TERMIOS
tio.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
tcsetattr(fileno(f), TCSANOW, &tio);
#endif
#ifdef USING_SGTTY
tio.sg_flags &= ~(ECHO);
ioctl(fileno(f), TIOCSETP, &tio);
#endif
/* Read the passphrase from the terminal. */
if (fgets(buf, sizeof(buf), f) == NULL)
{
/* Got EOF. Just return NULL. */
/* Restore terminal modes. */
#ifdef USING_TERMIOS
tcsetattr(fileno(f), TCSANOW, &saved_tio);
#endif
#ifdef USING_SGTTY
ioctl(fileno(f), TIOCSETP, &saved_tio);
#endif
/* Restore the signal handler. */
signal(SIGINT, old_handler);
/* Print a newline (the prompt probably didn\'t have one). */
fprintf(stderr, "\n");
/* Close the file. */
if (f != stdin)
fclose(f);
return NULL;
}
/* Restore terminal modes. */
#ifdef USING_TERMIOS
tcsetattr(fileno(f), TCSANOW, &saved_tio);
#endif
#ifdef USING_SGTTY
ioctl(fileno(f), TIOCSETP, &saved_tio);
#endif
/* Restore the signal handler. */
(void)signal(SIGINT, old_handler);
/* Remove newline from the passphrase. */
if (strchr(buf, '\n'))
*strchr(buf, '\n') = 0;
/* Allocate a copy of the passphrase. */
cp = ssh_xstrdup(buf);
/* Clear the buffer so we don\'t leave copies of the passphrase laying
around. */
memset(buf, 0, sizeof(buf));
/* Print a newline since the prompt probably didn\'t have one. */
fprintf(stderr, "\n");
/* Close the file. */
if (f != stdin)
fclose(f);
return cp;
}
Boolean ssh_channel_remote_tcp_forward_request(const char *type,
const unsigned char *data,
size_t len,
void *context)
{
SshCommon common = (SshCommon)context;
char *address_to_bind;
SshUInt32 port;
char port_string[20];
SshRemoteTcpForward fwd;
SshChannelTypeTcpForward ct;
SSH_DEBUG(5, ("remote TCP/IP forwarding request received"));
ssh_log_event(common->config->log_facility,
SSH_LOG_INFORMATIONAL,
"Remote TCP/IP forwarding request received from host \"%s\", "\
"by authenticated user \"%s\".",
common->remote_host,
ssh_user_name(common->user_data));
ct = ssh_channel_ftcp_ct(common);
/* Don't allow a server to send remote forwarding requests to the client. */
if (common->client)
{
ssh_warning("Remote TCP/IP forwarding request from server denied.");
return FALSE;
}
/* Parse the request. */
if (ssh_decode_array(data, len,
SSH_FORMAT_UINT32_STR, &address_to_bind, NULL,
SSH_FORMAT_UINT32, &port,
SSH_FORMAT_END) != len)
{
SSH_DEBUG(0, ("bad data"));
return FALSE;
}
/* Convert port number to a string. */
snprintf(port_string, sizeof(port_string), "%ld", (unsigned long) port);
/* If user is not logged in as a privileged user, don't allow
forwarding of privileged ports. */
if (port < 1024)
{
if (ssh_user_uid(common->user_data))
{
SSH_TRACE(2, ("User \"%s\" not root, tried to forward " \
"privileged port %ld.",
ssh_user_name(common->user_data),
(unsigned long) port));
ssh_log_event(common->config->log_facility,
SSH_LOG_WARNING,
"User \"%s\" not root, tried to forward " \
"privileged port %ld.",
ssh_user_name(common->user_data),
(unsigned long) port);
return FALSE;
}
else
{
ssh_log_event(common->config->log_facility,
SSH_LOG_NOTICE,
"Privileged user \"%s\" forwarding a privileged port.",
ssh_user_name(common->user_data));
}
}
if (port >= 65536)
{
SSH_TRACE(2, ("User \"%s\" tried to forward " \
"port above 65535 (%ld).",
ssh_user_name(common->user_data), (unsigned long) port));
ssh_log_event(common->config->log_facility,
SSH_LOG_WARNING,
"User \"%s\" tried to forward " \
"port above 65535 (%ld).",
ssh_user_name(common->user_data), (unsigned long) port);
return FALSE;
}
/* Create a socket listener. */
fwd = ssh_xcalloc(1, sizeof(*fwd));
fwd->listener = ssh_tcp_make_listener(address_to_bind, port_string,
ssh_channel_ftcp_incoming_connection,
(void *)fwd);
if (fwd->listener == NULL)
{
ssh_debug("Creating remote listener for %s:%s failed.",
address_to_bind, port_string);
ssh_log_event(common->config->log_facility,
SSH_LOG_NOTICE,
"Creating remote listener for %s:%s failed.",
address_to_bind, port_string);
ssh_xfree(address_to_bind);
ssh_xfree(fwd);
return FALSE;
}
/* Fill the remaining fields. */
fwd->common = common;
fwd->address_to_bind = address_to_bind;
fwd->port = ssh_xstrdup(port_string);
fwd->connect_to_host = NULL;
fwd->connect_to_port = NULL;
/* Add to list of forwardings. */
fwd->next = ct->remote_forwards;
ct->remote_forwards = fwd;
ssh_log_event(common->config->log_facility,
SSH_LOG_INFORMATIONAL,
"Port %ld set up for remote forwarding.",
(unsigned long) port);
return TRUE;
}
int main(int ac, char **av)
{
unsigned int pass, i;
SshBuffer buffer, buffer2;
SocksInfo socksinfo, socksreturn;
SocksError ret;
ssh_buffer_init(&buffer);
ssh_buffer_init(&buffer2);
for(pass = 0; pass < 20000; pass++)
{
ssh_buffer_clear(&buffer);
socksinfo = ssh_xmalloc(sizeof(struct SocksInfoRec));
socksinfo->socks_version_number = 4;
socksinfo->command_code = (pass & 1) + 1;
socksinfo->ip =
ssh_xstrdup(ip_numbers[pass % (sizeof(ip_numbers) /
sizeof(ip_numbers[0]))]);
socksinfo->port =
ssh_xstrdup(port_numbers[pass % (sizeof(port_numbers) /
sizeof(port_numbers[0]))]);
socksinfo->username =
ssh_xstrdup(usernames[pass % (sizeof(usernames) /
sizeof(usernames[0]))]);
if (ssh_socks_client_generate_open(&buffer, socksinfo) !=
SSH_SOCKS_SUCCESS)
ssh_fatal("ssh_socks_client_generate_open fails");
if (pass & 1)
{
unsigned char *p;
unsigned int len;
ssh_buffer_clear(&buffer2);
p = ssh_buffer_ptr(&buffer);
len = ssh_buffer_len(&buffer);
/* Give partial buffer */
for(i = 0; i + 1 < len; i++)
{
ssh_buffer_append(&buffer2, p + i, 1);
if (ssh_socks_server_parse_open(&buffer2, &socksreturn) !=
SSH_SOCKS_TRY_AGAIN)
ssh_fatal("ssh_socks_server_parse_open fails in partial data (should return try_again)");
}
ssh_buffer_append(&buffer2, p + i, 1);
if (ssh_socks_server_parse_open(&buffer2, &socksreturn) !=
SSH_SOCKS_SUCCESS)
ssh_fatal("ssh_socks_server_parse_open fails for partial data (should return success)");
if (ssh_buffer_len(&buffer2) != 0)
ssh_fatal("Junk left to buffer after server_parse_open");
}
else
{
if (ssh_socks_server_parse_open(&buffer, &socksreturn) !=
SSH_SOCKS_SUCCESS)
ssh_fatal("ssh_socks_server_parse_open fails for partial data (should return success)");
if (ssh_buffer_len(&buffer) != 0)
ssh_fatal("Junk left to buffer after server_parse_open");
}
if (socksinfo->socks_version_number != socksreturn->socks_version_number)
ssh_fatal("socks_version_numbers differ request");
if (socksinfo->command_code != socksreturn->command_code)
ssh_fatal("command_codes differ request");
if (strcmp(socksinfo->ip, socksreturn->ip) != 0)
ssh_fatal("ip numbers differ request");
if (strcmp(socksinfo->port, socksreturn->port) != 0)
ssh_fatal("port numbers differ request");
if (strcmp(socksinfo->username, socksreturn->username) != 0)
ssh_fatal("usernames differ request");
ssh_socks_free(&socksreturn);
ssh_socks_free(&socksinfo);
ssh_buffer_clear(&buffer);
socksinfo = ssh_xmalloc(sizeof(struct SocksInfoRec));
socksinfo->socks_version_number = 0;
socksinfo->command_code = (pass % 4) + 90;
socksinfo->ip =
ssh_xstrdup(ip_numbers[pass % (sizeof(ip_numbers) /
sizeof(ip_numbers[0]))]);
socksinfo->port =
ssh_xstrdup(port_numbers[pass % (sizeof(port_numbers) /
sizeof(port_numbers[0]))]);
socksinfo->username =
ssh_xstrdup(usernames[pass % (sizeof(usernames) /
sizeof(usernames[0]))]);
if (ssh_socks_server_generate_reply(&buffer, socksinfo) !=
SSH_SOCKS_SUCCESS)
ssh_fatal("ssh_socks_server_generate_reply fails");
if (pass & 1)
{
unsigned char *p;
unsigned int len;
ssh_buffer_clear(&buffer2);
p = ssh_buffer_ptr(&buffer);
len = ssh_buffer_len(&buffer);
/* Give partial buffer */
for(i = 0; i + 1 < len; i++)
{
ssh_buffer_append(&buffer2, p + i, 1);
if (ssh_socks_client_parse_reply(&buffer2, &socksreturn) !=
SSH_SOCKS_TRY_AGAIN)
ssh_fatal("ssh_socks_server_parse_open fails in partial data (should return try_again)");
}
ssh_buffer_append(&buffer2, p + i, 1);
ret = ssh_socks_client_parse_reply(&buffer2, &socksreturn);
if (((pass % 4) == 0 && ret != SSH_SOCKS_SUCCESS) ||
((pass % 4) == 1 && ret != SSH_SOCKS_FAILED_REQUEST) ||
((pass % 4) == 2 && ret != SSH_SOCKS_FAILED_IDENTD) ||
((pass % 4) == 3 && ret != SSH_SOCKS_FAILED_USERNAME))
ssh_fatal("ssh_socks_client_parse_reply fails for partial data");
if (ret == SSH_SOCKS_SUCCESS && ssh_buffer_len(&buffer2) != 0)
ssh_fatal("Junk left to buffer after server_parse_open");
}
else
{
ret = ssh_socks_client_parse_reply(&buffer, &socksreturn);
if (((pass % 4) == 0 && ret != SSH_SOCKS_SUCCESS) ||
((pass % 4) == 1 && ret != SSH_SOCKS_FAILED_REQUEST) ||
((pass % 4) == 2 && ret != SSH_SOCKS_FAILED_IDENTD) ||
((pass % 4) == 3 && ret != SSH_SOCKS_FAILED_USERNAME))
ssh_fatal("ssh_socks_client_parse_reply fails");
if (ret == SSH_SOCKS_SUCCESS && ssh_buffer_len(&buffer) != 0)
ssh_fatal("Junk left to buffer after server_parse_open");
}
if (ret == SSH_SOCKS_SUCCESS)
{
if (socksinfo->socks_version_number !=
socksreturn->socks_version_number)
ssh_fatal("socks_version_numbers differ reply");
if (socksinfo->command_code != socksreturn->command_code)
ssh_fatal("command_codes differ reply");
if (strcmp(socksinfo->ip, socksreturn->ip) != 0)
ssh_fatal("ip numbers differ reply");
if (strcmp(socksinfo->port, socksreturn->port) != 0)
ssh_fatal("port numbers differ reply");
ssh_socks_free(&socksreturn);
}
ssh_socks_free(&socksinfo);
}
ssh_buffer_clear(&buffer);
for(pass = 0;
pass < (sizeof(ip_invalid_numbers) / sizeof(ip_invalid_numbers[0]));
pass++)
{
socksinfo = ssh_xmalloc(sizeof(struct SocksInfoRec));
socksinfo->socks_version_number = 4;
socksinfo->command_code = (pass & 1) + 1;
socksinfo->ip =
ssh_xstrdup(ip_invalid_numbers[pass % (sizeof(ip_invalid_numbers) /
sizeof(ip_invalid_numbers[0]))]);
socksinfo->port =
ssh_xstrdup(port_numbers[pass % (sizeof(port_numbers) /
sizeof(port_numbers[0]))]);
socksinfo->username =
ssh_xstrdup(usernames[pass % (sizeof(usernames) /
sizeof(usernames[0]))]);
if (ssh_socks_client_generate_open(&buffer, socksinfo) ==
SSH_SOCKS_SUCCESS)
ssh_fatal("ssh_socks_client_generate_open success (should fail, ip)");
socksinfo->socks_version_number = 0;
socksinfo->command_code = (pass % 4) + 90;
if (ssh_socks_server_generate_reply(&buffer, socksinfo) ==
SSH_SOCKS_SUCCESS)
ssh_fatal("ssh_socks_server_generate_reply success (should fail, ip)");
ssh_socks_free(&socksinfo);
}
for(pass = 0;
pass < (sizeof(port_invalid_numbers) / sizeof(port_invalid_numbers[0]));
pass++)
{
socksinfo = ssh_xmalloc(sizeof(struct SocksInfoRec));
socksinfo->socks_version_number = 4;
socksinfo->command_code = (pass & 1) + 1;
socksinfo->ip =
ssh_xstrdup(ip_numbers[pass % (sizeof(ip_numbers) /
sizeof(ip_numbers[0]))]);
socksinfo->port =
ssh_xstrdup(port_invalid_numbers[pass % (sizeof(port_invalid_numbers) /
sizeof(port_invalid_numbers[0]))]);
socksinfo->username =
ssh_xstrdup(usernames[pass % (sizeof(usernames) /
sizeof(usernames[0]))]);
if (ssh_socks_client_generate_open(&buffer, socksinfo) ==
SSH_SOCKS_SUCCESS)
ssh_fatal("ssh_socks_client_generate_open success (should fail, port)");
socksinfo->command_code = (pass % 4) + 90;
socksinfo->socks_version_number = 0;
if (ssh_socks_server_generate_reply(&buffer, socksinfo) ==
SSH_SOCKS_SUCCESS)
ssh_fatal("ssh_socks_server_generate_reply success (should fail, port)");
ssh_socks_free(&socksinfo);
}
if (ssh_buffer_len(&buffer) != 0)
ssh_fatal("some of the failed ssh_socks_*_generate_* function wrote something to buffer, size != 0");
ssh_buffer_uninit(&buffer);
ssh_buffer_uninit(&buffer2);
return 0;
}
int main()
{
int i, j, k, d, y, p;
char *a, *b, *first, *last, *rfirst, *rlast;
SshTime t, t2;
struct SshCalendarTimeRec ct[1], mt[1];
ssh_debug_set_level_string("*=6");
ssh_rand_seed(1234);
for (i = 0; i < 1000; i++)
{
ct->year = 1900 + ssh_rand() % 200;
ct->month = ssh_rand() % 12;
ct->monthday = 1 + ssh_rand() % 28;
ct->hour = ssh_rand() % 24;
ct->minute = ssh_rand() % 60;
ct->second = ssh_rand() % 60;
ct->utc_offset = ((ssh_rand() % 96) - 48) * 900;
ct->dst = (ssh_rand() % 3) - 1;
if (!ssh_make_time(ct, &t, FALSE))
ssh_fatal("ssh_make_time failed");
ssh_calendar_time(t, mt, FALSE);
if (ct->year != mt->year ||
ct->month != mt->month ||
ct->monthday != mt->monthday ||
ct->hour != mt->hour ||
ct->minute != mt->minute ||
ct->second != mt->second ||
ct->weekday != mt->weekday ||
ct->yearday != mt->yearday)
ssh_fatal("Time values are different in struct");
if (!ssh_make_time(mt, &t2, TRUE))
ssh_fatal("ssh_make_time failed");
if (ct->year != mt->year ||
ct->month != mt->month ||
ct->monthday != mt->monthday ||
ct->hour != mt->hour ||
ct->minute != mt->minute ||
ct->second != mt->second ||
ct->weekday != mt->weekday ||
ct->yearday != mt->yearday)
ssh_fatal("Time values are different in struct with local time");
if (mt->dst)
t2 -= 3600;
if (t2 - t != mt->utc_offset)
ssh_fatal("Localtime vs gmtime values does not match!");
}
t = ssh_time();
a = ssh_time_string(t);
first = ssh_xstrdup(a);
rfirst = ssh_readable_time_string(t, TRUE);
printf("First value was \"%s\" (%s).\n", first, rfirst);
for (i = 0; i < 5; i++)
{
for (j = 0; j < 100; j++)
for (k = 0; k < 1000; k++)
{
b = ssh_time_string(ssh_time());
if (strcmp(a, b) > 0)
{
fprintf(stderr,
"t-time: ssh_time_string returned value "
"\"%s\" after \"%s\", which doesn't sort right.\n",
b, a);
exit(1);
}
ssh_xfree(a);
a = b;
}
printf("Intermediate value #%d was \"%s\".\n", i + 1, a);
}
ssh_xfree(a);
t = ssh_time();
last = ssh_time_string(t);
rlast = ssh_readable_time_string(t, TRUE);
printf("First value was \"%s\" (%s).\n", first, rfirst);
printf("Last value was \"%s\" (%s).\n", last, rlast);
ssh_xfree(first);
ssh_xfree(rfirst);
ssh_xfree(last);
ssh_xfree(rlast);
check_time((SshTime)23200, 1970, 1, 1); /* 01.01.1970 */
check_time((SshTime)68212800, 1972, 2, 29); /* 29.02.1972 */
check_time((SshTime)946641600, 1999, 12, 31); /* 31.12.1999 */
check_time((SshTime)946728000, 2000, 1, 1); /* 01.01.2000 */
check_time((SshTime)951825600, 2000, 2, 29); /* 29.02.2000 */
check_time((SshTime)2147428800, 2038, 1, 18); /* 18.01.2038 */
#define T_TIME_TEST_COUNT 25000
{
t = ((SshTime)43200) - (((SshTime)86400) * ((SshTime)T_TIME_TEST_COUNT));
ssh_calendar_time(t, ct, FALSE);
a = ssh_readable_time_string(t, TRUE);
printf("Testing weekday consistency from: %s\n", a);
printf("Be aware that days are in the Gregorian system "
"even before the Gregorian era.\n");
ssh_xfree(a);
d = ct->weekday;
y = ct->year;
if ((d < 0) || (d > 6))
{
fprintf(stderr,
"ssh_calendar_time returns %04d-%02d-%02d "
"with wrong weekday %d\n",
(int)ct->year,
(int)ct->month + 1,
(int)ct->monthday,
(int)ct->weekday);
exit(1);
}
p = d;
for (i = 0; i < (T_TIME_TEST_COUNT * 2); i++)
{
t += 86400;
ssh_calendar_time(t, ct, FALSE);
d = (int)ct->weekday;
if ((d < 0) || (d > 6) || (d != ((p + 1) % 7)))
{
fprintf(stderr,
"ssh_calendar_time returns %04d-%02d-%02d "
"with inconsistent weekday %d\n",
(int)ct->year,
(int)ct->month + 1,
(int)ct->monthday,
(int)ct->weekday);
exit(1);
}
#if 1
if ((((ct->year % 100) == 0) &&
(ct->month == 0) &&
(ct->monthday == 1)) ||
(((((ct->year - 20) % 100) == 0) &&
(ct->month == 5) &&
(ct->monthday == 24))))
#endif
{
a = ssh_readable_time_string(t, TRUE);
b = ssh_readable_time_string(t, FALSE);
printf("Intermediate: %s (universal)\n",b);
printf(" %s (local)\n", a);
ssh_xfree(a);
ssh_xfree(b);
}
p = d;
y = ct->year;
}
}
a = ssh_readable_time_string(t, TRUE);
printf("Weekday consistency tested until: %s\n", a);
ssh_xfree(a);
ssh_util_uninit();
exit(0);
}
void ssh_client_auth_hostbased(SshAuthClientOperation op,
const char *user,
unsigned int packet_type,
SshBuffer *packet_in,
const unsigned char *session_id,
size_t session_id_len,
void **state_placeholder,
SshAuthClientCompletionProc completion,
void *completion_context,
void *method_context)
{
SshClientHostbasedAuth state;
SshClient client;
SshStream stdio_stream;
char hostkeyfile[512];
/* char *keytype;
SshPublicKey pubkey;*/
char **signer_argv;
char config_filename[512];
size_t hostname_len;
SSH_DEBUG(6, ("auth_hostbased op = %d user = %s", op, user));
client = (SshClient)method_context;
state = *state_placeholder;
switch (op)
{
/* This operation is always non-interactive, as hostkeys
shouldn't have passphrases. Check for it, though. XXX */
case SSH_AUTH_CLIENT_OP_START_NONINTERACTIVE:
/* XXX There is a bug in sshauthc.c (or
elsewhere). Authentication methods, that are not allowed,
should not be tried. Now it calls
SSH_AUTH_CLIENT_OP_START_NONINTERACTIVE for every
authentication method before checking.*/
(*completion)(SSH_AUTH_CLIENT_FAIL, user, NULL, completion_context);
break;
case SSH_AUTH_CLIENT_OP_START:
/* This is the first operation for doing hostbased authentication.
We should not have any previous saved state when we come here. */
SSH_ASSERT(*state_placeholder == NULL);
/* Initialize a context. */
state = ssh_xcalloc(1, sizeof(*state));
state->session_id = session_id;
state->session_id_len = session_id_len;
state->user = ssh_xstrdup(user);
/* We have to dig up the server configuration to get the place
for the client host's publickey. This is a very kludgeish
solution. XXX*/
state->server_conf = ssh_server_create_config();
/* Dig up hosts publickey. */
snprintf(config_filename, sizeof(config_filename), "%s/%s",
SSH_SERVER_DIR, SSH_SERVER_CONFIG_FILE);
if (!ssh_config_read_file(client->user_data, state->server_conf,
NULL, config_filename, NULL))
SSH_TRACE(2, ("Failed to read config file %s", \
config_filename));
if(state->server_conf->public_host_key_file[0] != '/')
{
snprintf(hostkeyfile, sizeof(hostkeyfile), "%s/%s", SSH_SERVER_DIR,
state->server_conf->public_host_key_file);
}
else
{
snprintf(hostkeyfile, sizeof(hostkeyfile), "%s",
state->server_conf->public_host_key_file);
}
/* This pubkey*-stuff is for the client _host's_ public
hostkey. */
SSH_DEBUG(4, ("Reading pubkey-blob from %s...", hostkeyfile));
if (ssh2_key_blob_read(client->user_data, hostkeyfile, NULL,
&state->pubkeyblob,
&state->pubkeyblob_len, NULL)
!= SSH_KEY_MAGIC_PUBLIC)
{
goto error;
}
SSH_DEBUG(4, ("done."));
if ((state->pubkey_algorithm =
ssh_pubkeyblob_type(state->pubkeyblob,
state->pubkeyblob_len))
== NULL)
{
goto error;
}
state->local_user_name = ssh_user_name(client->user_data);
state->local_host_name = ssh_xmalloc(MAXHOSTNAMELEN + 1);
ssh_tcp_get_host_name(state->local_host_name, MAXHOSTNAMELEN + 1);
hostname_len = strlen(state->local_host_name);
/* Sanity check */
SSH_ASSERT(hostname_len + 2 < MAXHOSTNAMELEN);
/* We want FQDN. */
state->local_host_name[hostname_len] = '.';
state->local_host_name[hostname_len + 1] = '\0';
state->completion = completion;
state->completion_context = completion_context;
state->state_placeholder = state_placeholder;
/* Assign the state to the placeholder that survives across
calls. (this is actually not needed, as hostbased
authentication procedure is very simple. Just one packet from
client to server, and server's response in one packet.) */
*state_placeholder = state;
/* Open a pipestream connection to ssh-signer. */
switch (ssh_pipe_create_and_fork(&stdio_stream, NULL))
{
case SSH_PIPE_ERROR:
/* Something went wrong. */
ssh_warning("Couldn't create pipe to connect to %s.",
client->config->signer_path);
goto error;
break;
case SSH_PIPE_CHILD_OK:
/* Exec ssh-signer */
SSH_TRACE(0, ("Child: Execing ssh-signer...(path: %s)", \
client->config->signer_path));
signer_argv = ssh_xcalloc(2, sizeof(char *));
signer_argv[0] = client->config->signer_path;
signer_argv[1] = NULL;
execvp(client->config->signer_path, signer_argv);
fprintf(stderr, "Couldn't exec '%s' (System error message: %s)",
client->config->signer_path, strerror(errno));
ssh_fatal("Executing ssh-signer failed.");
break;
case SSH_PIPE_PARENT_OK:
state->wrapper = ssh_packet_wrap(stdio_stream,
auth_hostbased_received_packet,
auth_hostbased_received_eof,
auth_hostbased_can_send,
state);
/* We don't check wrapper's validity, as ssh_packet_wrap
should always succeed.*/
break;
}
/* Here we continue as parent. */
/* sign packet with ssh-signer (a suid-program). */
if (ssh_packet_wrapper_can_send(state->wrapper))
{
ssh_client_auth_hostbased_send_to_signer(state);
}
/* If ssh_packet_wrapper_can_send returns FALSE,
auth_hostbased_can_send will call the ...send_to_signer
function above. */
/* Rest is done in callbacks. */
break;
case SSH_AUTH_CLIENT_OP_CONTINUE:
SSH_TRACE(2, ("Invalid message. We didn't return " \
"SSH_AUTH_CLIENT_SEND_AND_CONTINUE at any stage!"));
/* Send failure message.*/
(*completion)(SSH_AUTH_CLIENT_FAIL, user, NULL, completion_context);
return;
case SSH_AUTH_CLIENT_OP_ABORT:
/* Abort the authentication operation immediately. */
/* XXX Destroy 'state'-object. */
*state_placeholder = NULL;
break;
default:
/* something weird is going on.. */
ssh_fatal("ssh_client_auth_hostbased: unknown op %d", (int)op);
}
return;
error:
/* XXX Destroy state. */
/* Send failure message.*/
(*completion)(SSH_AUTH_CLIENT_FAIL, user, NULL, completion_context);
return;
}
void add_file(SshAgent agent, const char *filename)
{
SshPrivateKey key = NULL;
char *saved_comment, *comment = NULL, *pass;
int query_cnt;
unsigned char *certs = NULL;
size_t certs_len;
char privname[500], pubname[500];
unsigned long magic;
struct stat st;
if (action == ADD_URL)
{
printf("Adding URL identity: %s\n", filename);
snprintf(privname, sizeof(privname), "%s", filename);
if (have_attrs)
ssh_agent_add_with_attrs(agent, NULL, NULL, 0, privname,
path_limit, path_constraint, use_limit,
forbid_compat, key_timeout,
agent_completion, (void *)agent);
else
ssh_agent_add(agent, NULL, NULL, 0, privname,
agent_completion, (void *)agent);
return;
}
else if (action == DELETE_URL)
{
printf("Deleting URL identity: %s\n", filename);
snprintf(privname, sizeof(privname), "%s", filename);
ssh_agent_delete(agent, NULL, 0, privname,
agent_completion, (void *)agent);
return;
}
#ifdef WITH_PGP
if (pgp_mode == PGP_KEY_NONE)
#endif /* WITH_PGP */
{
/* Construct the names of the public and private key files. */
if (strlen(filename) > 4 &&
strcmp(filename + strlen(filename) - 4, ".pub") == 0)
{
snprintf(pubname, sizeof(pubname), "%s", filename);
snprintf(privname, sizeof(privname), "%s", filename);
privname[strlen(privname) - 4] = '\0';
}
else
{
snprintf(pubname, sizeof(pubname), "%s.pub", filename);
snprintf(privname, sizeof(privname), "%s", filename);
}
if (action == ADD)
printf("Adding identity: %s\n", pubname);
else if (action == DELETE)
printf("Deleting identity: %s\n", pubname);
if (stat(pubname, &st) < 0)
{
printf("Public key file %s does not exist.\n", pubname);
(*agent_completion)(SSH_AGENT_ERROR_OK, (void *)agent);
return;
}
if (stat(privname, &st) < 0)
{
printf("Private key file %s does not exist.\n", privname);
(*agent_completion)(SSH_AGENT_ERROR_OK, (void *)agent);
return;
}
/* Read the public key blob. */
magic = ssh2_key_blob_read(user,
pubname,
TRUE,
&saved_comment,
&certs,
&certs_len,
NULL);
if (magic != SSH_KEY_MAGIC_PUBLIC)
{
printf("Bad public key file %s\n", pubname);
ssh_xfree(certs);
(*agent_completion)(SSH_AGENT_ERROR_OK, (void *)agent);
return;
}
if (action == ADD)
{
/* Loop until we manage to load the file, or a maximum number of
attempts have been made. First try with an empty passphrase. */
pass = ssh_xstrdup("");
query_cnt = 0;
while ((key = ssh_privkey_read(user,
privname,
pass,
&comment,
NULL)) == NULL)
{
char buf[1024];
FILE *f;
/* Free the old passphrase. */
memset(pass, 0, strlen(pass));
ssh_xfree(pass);
query_cnt++;
if (query_cnt > 5)
{
fprintf(stderr,
"You don't seem to know the correct passphrase.\n");
exit(EXIT_STATUS_BADPASS);
}
/* Ask for a passphrase. */
if (!use_stdin && getenv("DISPLAY") && !isatty(fileno(stdin)))
{
snprintf(buf, sizeof(buf),
"ssh-askpass2 '%sEnter passphrase for %.100s'",
((query_cnt <= 1) ?
"" :
"You entered wrong passphrase. "),
saved_comment);
f = popen(buf, "r");
if (!fgets(buf, sizeof(buf), f))
{
pclose(f);
ssh_xfree(saved_comment);
exit(EXIT_STATUS_BADPASS);
}
pclose(f);
if (strchr(buf, '\n'))
*strchr(buf, '\n') = 0;
pass = ssh_xstrdup(buf);
}
else
{
if (query_cnt <= 1)
{
if ((strcmp(privname, saved_comment) == 0) ||
(((strlen(privname) + 4) == strlen(saved_comment)) &&
(strncmp(privname,
saved_comment,
strlen(privname)) == 0)))
{
printf("Need passphrase for %s.\n",
privname);
}
else
{
printf("Need passphrase for %s (%s).\n",
privname, saved_comment);
}
}
else
{
printf("Bad passphrase.\n");
}
pass = ssh_read_passphrase("Enter passphrase: ", use_stdin);
if (pass == NULL || strcmp(pass, "") == 0)
{
ssh_xfree(saved_comment);
ssh_xfree(pass);
exit(EXIT_STATUS_BADPASS);
}
}
}
memset(pass, 0, strlen(pass));
ssh_xfree(pass);
ssh_xfree(saved_comment);
/* Construct a comment for the key by combining file name and
comment in the file. */
if ((saved_comment = strrchr(privname, '/')) != NULL)
saved_comment++;
else
saved_comment = privname;
saved_comment = ssh_string_concat_3(saved_comment, ": ", comment);
}
else
{
/* Construct a comment for the key by combining file name and
comment in the file. */
if ((saved_comment = strrchr(privname, '/')) != NULL)
saved_comment++;
else
saved_comment = privname;
if (comment)
saved_comment = ssh_string_concat_3(saved_comment, ": ", comment);
else
saved_comment = ssh_xstrdup(saved_comment);
}
if (action == ADD)
{
/* Send the key to the authentication agent. */
if (have_attrs)
ssh_agent_add_with_attrs(agent, key, certs, certs_len,
saved_comment, path_limit,
path_constraint, use_limit,
forbid_compat, key_timeout,
agent_completion, (void *)agent);
else
ssh_agent_add(agent, key, certs, certs_len, saved_comment,
agent_completion, (void *)agent);
ssh_private_key_free(key);
}
else if (action == DELETE)
{
ssh_agent_delete(agent, certs, certs_len, saved_comment,
agent_completion, (void *)agent);
}
ssh_xfree(saved_comment);
}
#ifdef WITH_PGP
else
{
unsigned char *blob, *public_blob;
size_t blob_len, public_blob_len;
Boolean found = FALSE;
unsigned long id;
char *endptr;
SshPgpSecretKey pgp_key;
SshPrivateKey key;
char buf[1024];
FILE *f;
comment = NULL;
switch (pgp_mode)
{
case PGP_KEY_NAME:
found = ssh2_find_pgp_secret_key_with_name(user,
pgp_keyring,
filename,
&blob,
&blob_len,
&comment);
break;
case PGP_KEY_FINGERPRINT:
found = ssh2_find_pgp_secret_key_with_fingerprint(user,
pgp_keyring,
filename,
&blob,
&blob_len,
&comment);
break;
case PGP_KEY_ID:
id = strtoul(filename, &endptr, 0);
if ((*filename != '\0') && (*endptr == '\0'))
{
found = ssh2_find_pgp_secret_key_with_id(user,
pgp_keyring,
id,
&blob,
&blob_len,
&comment);
}
else
{
fprintf(stderr, "%s: invalid pgp key id \"%s\".\n",
av0, filename);
found = FALSE;
}
break;
default:
ssh_fatal("internal error");
}
if (! found)
{
fprintf(stderr, "%s: pgp key \"%s\" not found.\n",
av0, filename);
(*agent_completion)(SSH_AGENT_ERROR_OK, (void *)agent);
return;
}
if (ssh_pgp_secret_key_decode(blob, blob_len, &pgp_key) == 0)
{
fprintf(stderr, "%s: unable to decode pgp key \"%s\".\n",
av0, filename);
memset(blob, 'F', blob_len);
ssh_xfree(blob);
(*agent_completion)(SSH_AGENT_ERROR_OK, (void *)agent);
return;
}
if ((public_blob_len = ssh_encode_pubkeyblob(pgp_key->public_key->key,
&public_blob)) == 0)
{
fprintf(stderr, "%s: unable to encode pgp key \"%s\".\n",
av0, filename);
ssh_pgp_secret_key_free(pgp_key);
memset(blob, 'F', blob_len);
ssh_xfree(blob);
(*agent_completion)(SSH_AGENT_ERROR_OK, (void *)agent);
return;
}
if (action == ADD)
{
query_cnt = 0;
while ((pgp_key->key == NULL) &&
(pgp_key->decryption_failed == TRUE))
{
query_cnt++;
if (query_cnt > 5)
{
fprintf(stderr,
"You don't seem to know the correct passphrase.\n");
exit(EXIT_STATUS_BADPASS);
}
/* Ask for a passphrase. */
if (!use_stdin && getenv("DISPLAY") && !isatty(fileno(stdin)))
{
snprintf(buf, sizeof(buf),
"ssh-askpass2 '%sEnter passphrase for \"%.100s\"'",
((query_cnt <= 1) ?
"" :
"You entered wrong passphrase. "),
comment);
f = popen(buf, "r");
if (!fgets(buf, sizeof(buf), f))
{
pclose(f);
fprintf(stderr, "No passphrase.\n");
exit(EXIT_STATUS_BADPASS);
}
pclose(f);
if (strchr(buf, '\n'))
*strchr(buf, '\n') = 0;
pass = ssh_xstrdup(buf);
}
else
{
if (query_cnt <= 1)
printf("Need passphrase for \"%s\".\n", comment);
else
printf("Bad passphrase.\n");
pass = ssh_read_passphrase("Enter passphrase: ", use_stdin);
if (pass == NULL || strcmp(pass, "") == 0)
{
ssh_xfree(pass);
fprintf(stderr, "No passphrase.\n");
exit(EXIT_STATUS_BADPASS);
}
}
ssh_pgp_secret_key_free(pgp_key);
if (ssh_pgp_secret_key_decode_with_passphrase(blob,
blob_len,
pass,
&pgp_key) == 0)
{
memset(pass, 0, strlen(pass));
ssh_xfree(pass);
fprintf(stderr, "%s: unable to decode pgp key \"%s\".\n",
av0, filename);
memset(blob, 'F', blob_len);
ssh_xfree(blob);
ssh_xfree(public_blob);
(*agent_completion)(SSH_AGENT_ERROR_OK, (void *)agent);
return;
}
memset(pass, 0, strlen(pass));
ssh_xfree(pass);
}
if (pgp_key->key == NULL)
{
fprintf(stderr, "%s: unable to decode pgp key \"%s\".\n",
av0, filename);
ssh_xfree(public_blob);
ssh_pgp_secret_key_free(pgp_key);
(*agent_completion)(SSH_AGENT_ERROR_OK, (void *)agent);
return;
}
memset(blob, 'F', blob_len);
ssh_xfree(blob);
if (ssh_private_key_copy(pgp_key->key, &key) != SSH_CRYPTO_OK)
{
fprintf(stderr, "%s: unable to export pgp key \"%s\".\n",
av0, filename);
ssh_pgp_secret_key_free(pgp_key);
(*agent_completion)(SSH_AGENT_ERROR_OK, (void *)agent);
return;
}
ssh_pgp_secret_key_free(pgp_key);
if (have_attrs)
ssh_agent_add_with_attrs(agent, key,
public_blob, public_blob_len,
comment, path_limit,
path_constraint, use_limit,
forbid_compat, key_timeout,
agent_completion, (void *)agent);
else
ssh_agent_add(agent, key,
public_blob, public_blob_len, comment,
agent_completion, (void *)agent);
ssh_xfree(comment);
ssh_xfree(public_blob);
ssh_private_key_free(key);
return;
}
else if (action == DELETE)
{
ssh_agent_delete(agent,
public_blob,
public_blob_len,
filename,
agent_completion,
(void *)agent);
ssh_pgp_secret_key_free(pgp_key);
memset(blob, 'F', blob_len);
ssh_xfree(blob);
ssh_xfree(public_blob);
return;
}
}
#endif /* WITH_PGP */
}
int main(int argc, char* argv[])
{
t_tcpc_context pcontext = 0;
SshGetOptData pgetoptdata = 0;
int i;
SSH_TRACE(SSH_D_MY, ("%s", "main"));
pcontext = ssh_xmalloc(sizeof (*pcontext));
memset(pcontext, 0, sizeof (*pcontext));
pgetoptdata = ssh_xmalloc(sizeof (*pgetoptdata));
memset(pgetoptdata, 0, sizeof (*pgetoptdata));
ssh_getopt_init_data(pgetoptdata);
pcontext->pport_or_service = "23242";
while ((i = ssh_getopt(argc, argv, "p:h:d:D:G:t:", pgetoptdata)) != -1)
{
switch (i)
{
case 'p':
pcontext->pport_or_service = ssh_xstrdup(pgetoptdata->arg);
break;
case 'h':
pcontext->phost_name_or_address = ssh_xstrdup(pgetoptdata->arg);
break;
case 'd':
pcontext->pdata = ssh_xstrdup(pgetoptdata->arg);
break;
case 'D':
ssh_debug_set_module_level(SSH_DEBUG_MODULE, atoi(pgetoptdata->arg));
break;
case 'G':
ssh_debug_set_global_level(atoi(pgetoptdata->arg));
break;
case 't':
pcontext->timeout = atoi(pgetoptdata->arg);
break;
default:
SSH_NOTREACHED;
break;
}
}
ssh_xfree(pgetoptdata);
ssh_event_loop_initialize();
pcontext->pbuffer = ssh_buffer_allocate();
if (pcontext->phost_name_or_address)
{
ssh_tcp_connect(pcontext->phost_name_or_address,
pcontext->pport_or_service,
NULL,
t_tcpc_tcp_callback,
pcontext);
}
else
{
pcontext->ptcplistener =
ssh_tcp_make_listener(SSH_IPADDR_ANY_IPV4,
pcontext->pport_or_service,
NULL,
t_tcpc_tcp_callback,
pcontext);
}
ssh_event_loop_run();
ssh_name_server_uninit();
ssh_event_loop_uninitialize();
ssh_buffer_free(pcontext->pbuffer);
ssh_xfree(pcontext);
ssh_util_uninit();
return 0;
}
void agent_open_callback(SshAgent agent, void *context)
{
char buf[1024];
FILE *f;
char *password, *password_vrfy;
if (!agent)
{
fprintf(stderr,
"Failed to connect to authentication agent - agent not running?\n");
exit(EXIT_STATUS_NOAGENT);
}
switch (action)
{
case DELETE_ALL:
fprintf(stderr, "Deleting all identities.\n");
ssh_agent_delete_all(agent, agent_completion, (void *)agent);
break;
case LIST:
fprintf(stderr, "Listing identities.\n");
ssh_agent_list(agent, agent_list_callback, (void *)agent);
break;
case LOCK:
if (!use_stdin && getenv("DISPLAY") && !isatty(fileno(stdin)))
{
snprintf(buf, sizeof (buf),
"ssh-askpass2 'Enter lock passphrase'");
f = popen(buf, "r");
if (! fgets(buf, sizeof (buf), f))
{
pclose(f);
exit(EXIT_STATUS_BADPASS);
}
pclose(f);
if (strchr(buf, '\n'))
*strchr(buf, '\n') = 0;
password = ssh_xstrdup(buf);
}
else
{
password = ssh_read_passphrase("Enter lock password: "******"Unable to read password.\n");
exit(EXIT_STATUS_BADPASS);
}
password_vrfy = ssh_read_passphrase("Again: ", use_stdin);
if (password_vrfy == NULL)
{
fprintf(stderr, "Unable to read password.\n");
exit(EXIT_STATUS_BADPASS);
}
if (strcmp(password, password_vrfy) != 0)
{
fprintf(stderr, "Passwords don't match.\n");
exit(EXIT_STATUS_BADPASS);
}
}
ssh_agent_lock(agent, password, agent_completion, (void *)agent);
break;
case UNLOCK:
if (!use_stdin && getenv("DISPLAY") && !isatty(fileno(stdin)))
{
snprintf(buf, sizeof (buf),
"ssh-askpass2 'Enter unlock passphrase'");
f = popen(buf, "r");
if (! fgets(buf, sizeof (buf), f))
{
pclose(f);
exit(EXIT_STATUS_BADPASS);
}
pclose(f);
if (strchr(buf, '\n'))
*strchr(buf, '\n') = 0;
password = ssh_xstrdup(buf);
}
else
{
password = ssh_read_passphrase("Enter lock password: "******"agent_open_callback: bad action %d\n", (int)action);
}
}
int main(int ac, char **av)
{
int opt, i;
DIR *ssh2dir = NULL;
char *ssh2dirname;
Boolean dynamic_array = FALSE;
struct dirent * cand;
/* Save program name. */
if (strchr(av[0], '/'))
av0 = strrchr(av[0], '/') + 1;
else
av0 = av[0];
user = ssh_user_initialize(NULL, FALSE);
#ifdef WITH_PGP
pgp_keyring = ssh_xstrdup(SSH_PGP_SECRET_KEY_FILE);
#endif /* WITH_PGP */
action = ADD;
while ((opt = ssh_getopt(ac, av, "ldDput:f:F:1LUNPI", NULL)) != EOF)
{
if (!ssh_optval)
{
usage();
exit(EXIT_STATUS_ERROR);
}
switch (opt)
{
case 'N':
#ifdef WITH_PGP
pgp_mode = PGP_KEY_NAME;
#else /* WITH_PGP */
fprintf(stderr, "%s: PGP keys not supported.\n", av0);
exit(EXIT_STATUS_ERROR);
#endif /* WITH_PGP */
break;
case 'P':
#ifdef WITH_PGP
pgp_mode = PGP_KEY_FINGERPRINT;
#else /* WITH_PGP */
fprintf(stderr, "%s: PGP keys not supported.\n", av0);
exit(EXIT_STATUS_ERROR);
#endif /* WITH_PGP */
break;
case 'I':
#ifdef WITH_PGP
pgp_mode = PGP_KEY_ID;
#else /* WITH_PGP */
fprintf(stderr, "%s: PGP keys not supported.\n", av0);
exit(EXIT_STATUS_ERROR);
#endif /* WITH_PGP */
break;
case 'R':
#ifdef WITH_PGP
ssh_xfree(pgp_keyring);
pgp_keyring = ssh_xstrdup(ssh_optarg);
#else /* WITH_PGP */
fprintf(stderr, "%s: PGP keys not supported.\n", av0);
exit(EXIT_STATUS_ERROR);
#endif /* WITH_PGP */
break;
case 'l':
action = LIST;
break;
case 'p':
use_stdin = TRUE;
break;
case 'd':
if (action == ADD_URL)
action = DELETE_URL;
else
action = DELETE;
break;
case 'D':
action = DELETE_ALL;
break;
case 't':
if (ssh_optargnum)
{
key_timeout = (SshTime)(ssh_optargval * 60);
}
else
{
usage();
exit(EXIT_STATUS_ERROR);
}
have_attrs = TRUE;
break;
case 'f':
if (ssh_optargnum)
{
path_limit = (SshUInt32)ssh_optargval;
}
else
{
usage();
exit(EXIT_STATUS_ERROR);
}
have_attrs = TRUE;
break;
case 'F':
path_constraint = ssh_xstrdup(ssh_optarg);
have_attrs = TRUE;
break;
case '1':
forbid_compat = TRUE;
have_attrs = TRUE;
break;
case 'u':
if (action == DELETE)
action = DELETE_URL;
else
action = ADD_URL;
break;
case 'L':
action = LOCK;
break;
case 'U':
action = UNLOCK;
break;
default:
usage();
exit(EXIT_STATUS_ERROR);
}
}
#ifdef WITH_PGP
if (pgp_keyring[0] != '/')
{
char buf[1024];
snprintf(buf, sizeof (buf), "%s/%s/%s",
ssh_user_dir(user),
SSH_USER_DIR,
pgp_keyring);
ssh_xfree(pgp_keyring);
pgp_keyring = ssh_xstrdup(buf);
}
#endif /* WITH_PGP */
files = &av[ssh_optind];
num_files = ac - ssh_optind;
/* Fetch default from ~/.ssh2/id_* (the first that we happen to get) */
#define ID_PREFIX "id"
if (num_files == 0 && action != LIST && action != DELETE_ALL &&
action != LOCK && action != UNLOCK)
{
#ifdef WITH_PGP
if (pgp_mode != PGP_KEY_NONE)
{
fprintf(stderr, "%s: Nothing to do!\n", av0);
exit(EXIT_STATUS_ERROR);
}
#endif /* WITH_PGP */
ssh_dsprintf(&ssh2dirname, "%s/%s", ssh_user_dir(user), SSH_USER_DIR);
ssh2dir = opendir(ssh2dirname);
if (!ssh2dir)
{
fprintf(stderr, "%s: Can't open directory \"%s\"", av0, ssh2dirname);
exit(EXIT_STATUS_ERROR);
}
while ((cand = readdir(ssh2dir)) != NULL)
{
if ((strlen(cand->d_name) > strlen(ID_PREFIX)) &&
(strncmp(cand->d_name, ID_PREFIX, strlen(ID_PREFIX)) == 0) &&
((strlen(cand->d_name) < 4) ||
(strcmp(cand->d_name + strlen(cand->d_name) - 4,
".pub") != 0)) &&
((((cand->d_name)[strlen(ID_PREFIX)]) == '_') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '-') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '.') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '(') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '[') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '<') ||
(((cand->d_name)[strlen(ID_PREFIX)]) == '>')))
{
files = ssh_xcalloc(2, sizeof(char *));
ssh_dsprintf(&files[0], "%s/%s", ssh2dirname, cand->d_name);
ssh_xfree(ssh2dirname);
num_files++;
dynamic_array = TRUE;
break;
}
}
(void)closedir(ssh2dir);
}
signal(SIGPIPE, SIG_IGN);
ssh_event_loop_initialize();
ssh_agent_open(agent_open_callback, NULL);
ssh_event_loop_run();
ssh_event_loop_uninitialize();
if (dynamic_array)
{
for(i = 0; i < num_files ; i++)
{
ssh_xfree(files[i]);
}
ssh_xfree(files);
}
ssh_user_free(user, FALSE);
exit(EXIT_STATUS_OK);
}
void signer_received_packet(SshPacketType type,
const unsigned char *data, size_t len,
void *context)
{
/* Received. */
unsigned int msg_byte; /* This is unsigned int because
SSH_FORMAT_CHAR expects uint; caused a
rather nasty bug during development (I
used SshUInt8, which wasn't long
enough => ssh_decode_array blew the
stack).*/
char *userauth_str, *hostbased_str, *recv_pubkey_alg, *recv_hostname;
char *recv_username;
unsigned char *recv_pubkeyblob;
size_t recv_pubkeyblob_len;
/* Dug up by us. */
char *pubkey_alg, *hostname, *username;
unsigned char *pubkeyblob;
size_t pubkeyblob_len;
size_t hostname_len;
/* Internal stuff*/
SshSigner signer = (SshSigner) context;
char hostkeyfile[512];
char *comment;
SshPrivateKey privkey;
size_t sig_len, length_return;
unsigned char *signature_buffer;
SshCryptoStatus result;
SshUser real_user;
SSH_TRACE(2, ("Packet received."));
switch(type)
{
case SSH_AUTH_HOSTBASED_PACKET:
/* Check packet out, and if it's ok, sign it and send
signature to ssh2. */
#ifdef HEXDUMPS
SSH_DEBUG_HEXDUMP(3, ("packet:"), \
data, len);
#endif /* HEXDUMPS */
if (ssh_decode_array(data, len,
/* session id */
SSH_FORMAT_UINT32_STR, NULL, NULL,
/* SSH_MSG_USERAUTH_REQUEST (must be checked)*/
SSH_FORMAT_CHAR, &msg_byte,
/* user name */
SSH_FORMAT_UINT32_STR, NULL, NULL,
/* service "ssh-userauth" (must be checked)*/
SSH_FORMAT_UINT32_STR, &userauth_str, NULL,
/* "hostbased" (must be checked)*/
SSH_FORMAT_UINT32_STR, &hostbased_str, NULL,
/* public key algorithm for hostkey (must
be checked)*/
SSH_FORMAT_UINT32_STR, &recv_pubkey_alg, NULL,
/* public hostkey and certificates (must be
checked)*/
SSH_FORMAT_UINT32_STR, &recv_pubkeyblob,
&recv_pubkeyblob_len,
/* client host name (must be checked)*/
SSH_FORMAT_UINT32_STR, &recv_hostname, NULL,
/* user name on client host (must be checked) */
SSH_FORMAT_UINT32_STR, &recv_username, NULL,
SSH_FORMAT_END) != len || len == 0)
{
/* There was an error. */
SSH_TRACE(0, ("Invalid packet."));
goto error;
}
/* Get pubkeyblob, pubkeyblob_len, pubkey_alg, hostname and
username. */
/* Dig up hosts publickey. */
if(signer->config->public_host_key_file[0] != '/')
{
snprintf(hostkeyfile, sizeof(hostkeyfile), "%s/%s", SSH_SERVER_DIR,
signer->config->public_host_key_file);
}
else
{
snprintf(hostkeyfile, sizeof(hostkeyfile), "%s",
signer->config->public_host_key_file);
}
SSH_TRACE(2, ("place to look for public key: %s", hostkeyfile));
/* This pubkey*-stuff is for the client _host's_ public
hostkey. */
/* Getting pubkeyblob, pubkeyblob_len */
SSH_DEBUG(4, ("Reading pubkey-blob from %s...", hostkeyfile));
if (ssh2_key_blob_read(signer->effective_user_data, hostkeyfile, NULL,
&pubkeyblob,
&pubkeyblob_len, NULL)
!= SSH_KEY_MAGIC_PUBLIC)
{
SSH_TRACE(1, ("Reading public key failed."));
goto error;
}
SSH_DEBUG(4, ("done."));
if ((pubkey_alg =
ssh_pubkeyblob_type(pubkeyblob, pubkeyblob_len))
== NULL)
{
SSH_TRACE(1, ("Couldn't figure out public key algorithm."));
goto error;
}
/* Getting hostname. */
hostname = ssh_xmalloc(MAXHOSTNAMELEN + 1);
ssh_tcp_get_host_name(hostname, MAXHOSTNAMELEN + 1);
hostname_len = strlen(hostname);
/* Sanity check */
SSH_ASSERT(hostname_len + 2 < MAXHOSTNAMELEN);
/* We want FQDN. */
hostname[hostname_len] = '.';
hostname[hostname_len + 1] = '\0';
/* Getting username. */
real_user = ssh_user_initialize(NULL, FALSE);
username = ssh_xstrdup(ssh_user_name(real_user));
ssh_user_free(real_user, FALSE);
/* Check all parameters. */
if (msg_byte != SSH_MSG_USERAUTH_REQUEST)
{
SSH_TRACE(1, ("Invalid packet."));
SSH_DEBUG(1, ("msg_byte != SSH_MSG_USERAUTH_REQUEST " \
"(msg_byte = %d)", msg_byte));
goto error;
}
if (strcmp(userauth_str, SSH_USERAUTH_SERVICE) != 0)
{
SSH_TRACE(1, ("Invalid packet."));
SSH_DEBUG(1, ("userauth_str != \"ssh-userauth\" (it was '%s')", \
userauth_str));
goto error;
}
if (strcmp(hostbased_str, SSH_AUTH_HOSTBASED) != 0)
{
SSH_TRACE(1, ("Invalid packet."));
SSH_DEBUG(1, ("hostbased_str != \"hostbased\" (it was '%s')", \
hostbased_str));
goto error;
}
/* XXX has to be change when adding support for multiple hostkeys */
if (strcmp(recv_pubkey_alg, pubkey_alg) != 0)
{
SSH_TRACE(1, ("Invalid packet."));
SSH_DEBUG(1, ("Client gave us invalid pubkey-algorithms for our " \
"hostkey."));
goto error;
}
if (recv_pubkeyblob_len == pubkeyblob_len)
{
if (memcmp(recv_pubkeyblob, pubkeyblob, pubkeyblob_len) != 0)
{
SSH_TRACE(1, ("Invalid packet."));
SSH_DEBUG(1, ("client gave us wrong (or corrupted) " \
"public key."));
#ifdef HEXDUMPS
SSH_DEBUG_HEXDUMP(3, ("client gave us:"), \
recv_pubkeyblob, pubkeyblob_len);
SSH_DEBUG_HEXDUMP(3, ("our pubkey:"), \
recv_pubkeyblob, pubkeyblob_len);
#endif /* HEXDUMPS */
goto error;
}
}
else
{
SSH_TRACE(1, ("Invalid packet."));
SSH_DEBUG(1, ("Client gave us wrong (or corrupted) public key. " \
"Lengths differ (received: %d ; ours: %d)", \
recv_pubkeyblob_len, pubkeyblob_len));
goto error;
}
if (strcmp(recv_hostname, hostname) != 0)
{
SSH_TRACE(1, ("Invalid packet."));
SSH_DEBUG(1, ("Wethinks the client gave us the wrong hostname. " \
"(client's opinion: '%s' ours: '%s'", \
recv_hostname, hostname));
goto error;
}
if (strcmp(recv_username, username) != 0)
{
SSH_TRACE(1, ("Invalid packet."));
SSH_DEBUG(1, ("Client definitely gave us the wrong user name. " \
"(it says: '%s' we know: '%s')", recv_username, \
username));
goto error;
}
/* Sign the packet and send it to client. */
/* If we've gotten this far, the packet is ok, and it can be
signed. */
SSH_TRACE(0, ("Received packet ok."));
if(signer->config->public_host_key_file[0] != '/')
{
snprintf(hostkeyfile, sizeof(hostkeyfile), "%s/%s", SSH_SERVER_DIR,
signer->config->host_key_file);
}
else
{
snprintf(hostkeyfile, sizeof(hostkeyfile), "%s",
signer->config->host_key_file);
}
SSH_TRACE(2, ("place to look for private key: %s", hostkeyfile));
if ((privkey = ssh_privkey_read(signer->effective_user_data, hostkeyfile, "",
&comment, NULL)) == NULL)
ssh_fatal("ssh_privkey_read from %s failed.", hostkeyfile);
/* Check how big a chunk our private key can sign (this is
purely a sanity check, as both of our signature schemas do
their own hashing) */
sig_len = ssh_private_key_max_signature_input_len(privkey);
SSH_TRACE(2, ("max input length for signing: %d", sig_len));
if (sig_len == 0)
{
SSH_TRACE(0, ("private key not capable of signing! " \
"(definitely an error)"));
goto error;
}
else if (sig_len != -1 && sig_len < len)
{
SSH_TRACE(0, ("private key can't sign our data. (too much " \
"data (data_len %d, max input len for signing " \
"%d))", len, sig_len));
goto error;
}
/* Now check how much we much buffer we must allocate for the
signature. */
sig_len = ssh_private_key_max_signature_output_len(privkey);
SSH_TRACE(2, ("max output length for signature: %d", sig_len));
signature_buffer = ssh_xcalloc(sig_len, sizeof(unsigned char));
/* Do the actual signing. */
#ifdef HEXDUMPS
SSH_DEBUG_HEXDUMP(5, ("Signing following data"),
data + 4, len - 4);
#endif /* HEXDUMPS */
if ((result = ssh_private_key_sign(privkey,
data,
len,
signature_buffer,
sig_len,
&length_return,
signer->random_state))
!= SSH_CRYPTO_OK)
{
SSH_TRACE(0, ("ssh_private_key_sign() returned %d.", result));
goto error;
}
#ifdef HEXDUMPS
SSH_DEBUG_HEXDUMP(5, ("Signature"), signature_buffer, length_return);
#endif /* HEXDUMPS */
/* Send it to client. */
signer->packet_payload = signature_buffer;
signer->packet_payload_len = length_return;
signer->packet_waiting = TRUE;
if (ssh_packet_wrapper_can_send(signer->wrapper))
signer_can_send(signer);
/* XXX free dynamically allocated data. */
ssh_xfree(username);
break;
case SSH_AUTH_HOSTBASED_SIGNATURE:
/* We shouldn't get this type of packet. This is an error.*/
SSH_TRACE(0, ("client sent us SSH_AUTH_HOSTBASED_SIGNATURE. This " \
"is an error."));
goto error;
break;
case SSH_AUTH_HOSTBASED_ERROR:
/* We shouldn't be getting this either. This is an error. */
SSH_TRACE(0, ("client sent us SSH_AUTH_HOSTBASED_SIGNATURE_ERROR. " \
"This is an error. (This message can be sent by " \
"ssh-signer2 only)"));
goto error;
break;
}
return;
/* We come here after errors. */
error:
/* Send error message to ssh2, and wait for ssh2 to send
EOF. */
ssh_packet_wrapper_send_encode(signer->wrapper, SSH_AUTH_HOSTBASED_ERROR,
SSH_FORMAT_END);
/* Init a 5 second timeout. If ssh2 hasn't disconnected at
that time, close stream.*/
ssh_register_timeout(5L, 0L, signer_destroy_timeout, signer);
return;
}
/*
* Parses url given in format
* [<scheme>:][//[<user>[:<password>]@]<host>[:<port>]]/[<path>]
* Returns true if the url is syntactically valid, false otherwise.
* If the incorrect url format "www.ssh.fi" is given then returns FALSE and
* sets host to contain whole url. If some piece of url is not given it is
* set to NULL. If some of the pieces are not needed they can be NULL and
* those pieces will be skipped.
*/
Boolean ssh_url_parse(const char *url, char **scheme, char **host,
char **port, char **username, char **password,
char **path)
{
const char *p, *q, *start;
p = url;
if (scheme)
*scheme = NULL;
if (host)
*host = NULL;
if (port)
*port = NULL;
if (username)
*username = NULL;
if (password)
*password = NULL;
if (path)
*path = NULL;
while (isspace(*p))
p++;
if (!*p)
{
return FALSE;
}
start = p;
while (isalpha(*p) || isdigit(*p) || *p == '+' || *p == '-' || *p == '.')
p++;
/* Check for scheme */
if (*p == ':')
{
if (scheme != NULL)
*scheme = ssh_xmemdup(start, p - start);
p++;
start = p;
}
p = start;
/* Do we have host name part */
if (p[0] == '/' && p[1] == '/')
{
start += 2;
p = start;
/* Check for username and password */
while (*p && *p != '@' && *p != '/')
p++;
if (*p == '@')
{
/* User name (and possible password found) */
q = p;
while (q > start && *q != ':')
q--;
if (*q == ':')
{
/* Password found */
if (username != NULL)
*username = ssh_xmemdup(start, q - start);
if (password != NULL)
*password = ssh_xmemdup(q + 1, p - (q + 1));
}
else
{
/* Only username found */
if (username != NULL)
*username = ssh_xmemdup(start, p - start);
}
p++;
start = p;
}
p = start;
/* Check for host name */
while (*p && *p != ':' && *p != '/')
p++;
if (host != NULL)
*host = ssh_xmemdup(start, p - start);
start = p;
if (*p == ':')
{
start = ++p;
while (isdigit(*p))
p++;
if (port != NULL)
*port = ssh_xmemdup(start, p - start);
start = p;
}
}
if (!*p)
{
return TRUE;
}
if (*p != '/')
{
if (host != NULL && *host == NULL)
*host = ssh_xstrdup(p);
else
if (path != NULL)
*path = ssh_xstrdup(p);
return FALSE;
}
else
{
if (path != NULL)
*path = ssh_xstrdup(p + 1);
return TRUE;
}
}
int main(int argc, char **argv)
{
SshStream stdio_stream;
SshSigner signer;
char config_filename[512];
char *temp_name;
#ifdef SLEEP_AFTER_STARTUP
sleep(30);
#endif /* SLEEP_AFTER_STARTUP */
/* Get program name (without path). */
if ((temp_name = strrchr(argv[0], '/')) != NULL)
progname = ssh_xstrdup(temp_name + 1);
else
progname = ssh_xstrdup(argv[0]);
/* XXX there should be a way to give command-line parameters to this
program, but, they should only be used if the uid is the same as
euid. */
ssh_event_loop_initialize();
signer = ssh_xcalloc(1, sizeof(*signer));
#ifdef SIGNER_QUIET
signer->quiet = TRUE;
#else /* SIGNER_QUIET */
signer->quiet = FALSE;
#endif /* SIGNER_QUIET */
ssh_debug_register_callbacks(signer_ssh_fatal, signer_ssh_warning,
signer_ssh_debug, (void *)signer);
#ifdef SIGNER_DEBUG
ssh_debug_set_global_level(5);
#endif /* SIGNER_DEBUG */
/* Act as server. */
signer->config = ssh_server_create_config();
SSH_TRACE(2, ("public key file: %s", signer->config->public_host_key_file));
SSH_TRACE(2, ("private key file: %s", signer->config->host_key_file));
SSH_TRACE(2, ("randomseed file: %s", signer->config->random_seed_file));
/* Initialize user context with euid. This is used to dig up the
hostkey and such. */
signer->effective_user_data = ssh_user_initialize_with_uid(geteuid(), FALSE);
signer->random_state = ssh_randseed_open(signer->effective_user_data,
signer->config);
/* XXX what about alternative config files? This should be possible
to configure somehow. An option for configure is probably a good
idea. */
snprintf(config_filename, sizeof(config_filename), "%s/%s",
SSH_SERVER_DIR, SSH_SERVER_CONFIG_FILE);
if (!ssh_config_read_file(signer->effective_user_data, signer->config,
NULL, config_filename, NULL))
ssh_warning("%s: Failed to read config file %s", argv[0],
config_filename);
stdio_stream = ssh_stream_fd_wrap2(fileno(stdin), fileno(stdout),
TRUE);
signer->wrapper = ssh_packet_wrap(stdio_stream,
signer_received_packet,
signer_received_eof,
signer_can_send,
signer);
ssh_event_loop_run();
return 0;
}
int main(int argc, char **argv)
{
int c;
SshCryptoStatus cs;
SshCipher cipher;
Boolean all_ciphers = FALSE, speed_test = FALSE, quiet = FALSE;
unsigned char *iv = NULL, *key = NULL;
size_t iv_len = 0, key_len = 0;
char *cipher_name = NULL, *cipher_names, *hlp, *passphrase = NULL;
Boolean encrypt_mode = TRUE;
char *input_file = NULL, *output_file = NULL;
FILE *fin, *fout;
Boolean r = TRUE;
if (strchr(argv[0], '/'))
av0 = strrchr(argv[0], '/') + 1;
else
av0 = argv[0];
if (strcasecmp(av0, "ssh-encrypt") == 0)
encrypt_mode = TRUE;
else if (strcasecmp(av0, "ssh-decrypt") == 0)
encrypt_mode = FALSE;
if (ssh_crypto_library_initialize() != SSH_CRYPTO_OK)
{
fprintf(stderr, "Can't initialize the cryptographic provider.\n");
exit(1);
}
while ((c = ssh_getopt(argc, argv, "thd:ac:i:k:EDp:", NULL)) != -1)
{
switch (c)
{
case 'd':
ssh_debug_set_level_string(ssh_optarg);
break;
case 't':
speed_test = TRUE;
break;
case 'a':
all_ciphers = TRUE;
break;
case 'c':
cipher_name = ssh_xstrdup(ssh_optarg);
break;
case 'q':
quiet = TRUE;
break;
case 'i':
if (iv)
{
fprintf(stderr,
"%s: No multiple initialization vectors allowed.\n",
av0);
usage();
exit(-1);
}
if (! hex_string_to_data(ssh_optarg, &iv, &iv_len))
{
fprintf(stderr, "%s: Bad IV string.\n", av0);
exit(-1);
}
break;
case 'k':
if (key)
{
fprintf(stderr, "%s: No multiple keys allowed.\n", av0);
usage();
exit(-1);
}
if (! hex_string_to_data(ssh_optarg, &key, &key_len))
{
fprintf(stderr, "%s: Bad KEY string.\n", av0);
exit(-1);
}
break;
case 'p':
if (passphrase)
{
fprintf(stderr, "%s: No multiple passphrases allowed.\n", av0);
usage();
exit(-1);
}
passphrase = ssh_optarg;
break;
case 'E':
encrypt_mode = TRUE;
break;
case 'D':
encrypt_mode = FALSE;
break;
case 'h':
help_info();
usage();
exit(0);
/*NOTREACHED*/
default:
usage();
exit(-1);
/*NOTREACHED*/
}
}
argc -= ssh_optind;
argv += ssh_optind;
if (speed_test && (argc > 0))
{
fprintf(stderr, "%s: Extra parameters.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if (argc > 2)
{
fprintf(stderr, "%s: Extra parameters.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if (argc > 1)
output_file = ssh_xstrdup(argv[1]);
if (argc > 0)
input_file = ssh_xstrdup(argv[0]);
if ((cipher_name != NULL) && all_ciphers)
{
fprintf(stderr, "%s: -c and -a can't be used together.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if (all_ciphers && !speed_test)
{
fprintf(stderr, "%s: -a can only be used with -t.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if ((cipher_name != NULL) && strchr(cipher_name, ',') && !speed_test)
{
fprintf(stderr, "%s: Multiple ciphers only be used with -t.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if (cipher_name == NULL)
{
if (speed_test)
{
all_ciphers = TRUE; /* Assume `all' if test mode with no ciphers. */
}
else
{
fprintf(stderr, "Missing -c flag.\n");
usage();
exit(-1);
/*NOTREACHED*/
}
}
if (passphrase && key)
{
fprintf(stderr, "%s: Can't use both passphrase and hex key.\n", av0);
usage();
exit(-1);
/*NOTREACHED*/
}
if (!key && !passphrase && !speed_test)
{
ssh_warning("%s: No key! Empty passphrase assumed.", av0);
passphrase = "";
/*NOTREACHED*/
}
if (speed_test)
{
fprintf(stderr, "Performing speed tests\n");
if (all_ciphers)
{
cipher_names = ssh_cipher_get_supported();
}
else
{
/* Steal allocated cipher_name */
cipher_names = cipher_name;
cipher_name = NULL;
}
hlp = cipher_names;
while ((cipher_name = ssh_name_list_get_name(hlp)) != NULL)
{
hlp += strlen(cipher_name);
if (*hlp == ',')
hlp++;
cipher_speed_test(cipher_name,
passphrase,
key, key_len,
iv, iv_len,
encrypt_mode);
ssh_xfree(cipher_name);
if (strlen(hlp) == 0)
break;
}
ssh_xfree(cipher_names);
}
else
{
if (passphrase)
cs = ssh_cipher_allocate_with_passphrase(cipher_name,
passphrase,
encrypt_mode,
&cipher);
else
cs = ssh_cipher_allocate(cipher_name,
key,
key_len,
encrypt_mode,
&cipher);
if (cs != SSH_CRYPTO_OK)
{
switch (cs)
{
case SSH_CRYPTO_UNSUPPORTED:
fprintf(stderr, "%s: Unsupported cipher \"%s\".\n", av0,
cipher_name);
usage();
exit(-1);
case SSH_CRYPTO_KEY_TOO_SHORT:
fprintf(stderr, "%s: Key too short for \"%s\".\n", av0,
cipher_name);
usage();
exit(-1);
default:
fprintf(stderr, "%s: Cipher allocate failed.\n", av0);
exit(-1);
}
/*NOTREACHED*/
}
if (iv != NULL)
{
if (ssh_cipher_get_iv_length(ssh_cipher_name(cipher)) == iv_len)
ssh_cipher_set_iv(cipher, iv);
else
{
fprintf(stderr, "%s: Weird IV length.\n", av0);
exit(-1);
}
}
if (input_file != NULL)
{
fin = fopen(input_file, "r");
if (fin == NULL)
{
fprintf(stderr, "%s: Cannot open input file \"%s\".\n",
av0, input_file);
exit(-1);
}
}
else
{
fin = stdin;
}
if (output_file != NULL)
{
struct stat st;
if (stat(output_file, &st) >= 0)
{
fprintf(stderr, "%s: Output file \"%s\" exists.\n", av0,
output_file);
exit(-1);
}
fout = fopen(output_file, "w");
if (fout == NULL)
{
fprintf(stderr, "%s: Cannot open output file \"%s\".\n",
av0, output_file);
exit(-1);
}
}
else
{
fout = stdout;
}
if (encrypt_mode)
r = cipher_encrypt(cipher, fin, fout);
else
r = cipher_decrypt(cipher, fin, fout);
if (input_file)
fclose(fin);
if (output_file)
{
fclose(fout);
if (! r)
(void)unlink(output_file);
}
ssh_cipher_free(cipher);
ssh_xfree(cipher_name);
}
ssh_xfree(input_file);
ssh_xfree(output_file);
ssh_xfree(key);
ssh_xfree(iv);
ssh_crypto_library_uninitialize();
ssh_util_uninit();
return((r == TRUE) ? 0 : -1);
}
