679 lines
20 KiB
C
679 lines
20 KiB
C
/**
|
|
* xrdp: A Remote Desktop Protocol server.
|
|
*
|
|
* Copyright (C) Jay Sorg 2004-2015
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/**
|
|
*
|
|
* @file scp.c
|
|
* @brief scp (sesman control protocol) handler function
|
|
* @author Jay Sorg, Simone Fedele
|
|
*
|
|
*/
|
|
|
|
#if defined(HAVE_CONFIG_H)
|
|
#include <config_ac.h>
|
|
#endif
|
|
|
|
#include "trans.h"
|
|
#include "os_calls.h"
|
|
#include "scp.h"
|
|
#include "sesman_config.h"
|
|
|
|
#include "scp_process.h"
|
|
#include "sesman_access.h"
|
|
#include "sesman_auth.h"
|
|
#include "guid.h"
|
|
#include "os_calls.h"
|
|
#include "session_list.h"
|
|
#include "session.h"
|
|
#include "sesman.h"
|
|
#include "string_calls.h"
|
|
|
|
/**************************************************************************//**
|
|
* Logs an authentication failure message
|
|
*
|
|
* @param username Username
|
|
* @param ip_addr IP address, if known
|
|
*
|
|
* The message is intended for use by fail2ban. Make changes with care.
|
|
*/
|
|
static void
|
|
log_authfail_message(const char *username, const char *ip_addr)
|
|
{
|
|
if (ip_addr == NULL || ip_addr[0] == '\0')
|
|
{
|
|
ip_addr = "unknown";
|
|
}
|
|
LOG(LOG_LEVEL_INFO, "AUTHFAIL: user=%s ip=%s time=%d",
|
|
username, ip_addr, g_time1());
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
/**
|
|
* Mode parameter for authenticate_and_authorize_connection()
|
|
*/
|
|
enum login_mode
|
|
{
|
|
AM_SYSTEM,
|
|
AM_UDS
|
|
};
|
|
|
|
/**
|
|
* Authenticate and authorize the connection
|
|
*
|
|
* @param sc Connection to sesman
|
|
* @param login_mode Describes the type of login in use
|
|
* @param uid UID for user
|
|
* @param username Name for user
|
|
* @param password Password (AM_SYSTEM) or NULL.
|
|
* @param ip_addr Remote IP address (AM_SYSTEM) or NULL.
|
|
* @return Status for the operation
|
|
*
|
|
* @pre sc->auth_info, sc->username and sc->ip_addr must be NULL
|
|
*
|
|
* @post If E_SCP_LOGIN_OK is returned, sc->auth_info is non-NULL
|
|
* @post If E_SCP_LOGIN_OK is returned, sc->username is non-NULL
|
|
* @post If E_SCP_LOGIN_OK is returned, sc->ip_addr is non-NULL
|
|
*
|
|
*/
|
|
static enum scp_login_status
|
|
authenticate_and_authorize_connection(struct sesman_con *sc,
|
|
enum login_mode login_mode,
|
|
int uid,
|
|
const char *username,
|
|
const char *password,
|
|
const char *ip_addr)
|
|
{
|
|
enum scp_login_status status = E_SCP_LOGIN_GENERAL_ERROR;
|
|
struct auth_info *auth_info = NULL;
|
|
|
|
/* Check preconditions */
|
|
if (sc->auth_info != NULL || sc->username != NULL || sc->ip_addr != NULL)
|
|
{
|
|
LOG(LOG_LEVEL_ERROR,
|
|
"Internal error - connection already logged in");
|
|
}
|
|
else
|
|
{
|
|
switch (login_mode)
|
|
{
|
|
case AM_SYSTEM:
|
|
auth_info = auth_userpass(username, password, ip_addr, &status);
|
|
break;
|
|
case AM_UDS:
|
|
auth_info = auth_uds(username, &status);
|
|
break;
|
|
default:
|
|
LOG(LOG_LEVEL_ERROR, "%s called with invalid mode %d",
|
|
__func__, (int)login_mode);
|
|
}
|
|
|
|
if (auth_info != NULL)
|
|
{
|
|
if (status != E_SCP_LOGIN_OK)
|
|
{
|
|
/* This shouldn't happen */
|
|
LOG(LOG_LEVEL_ERROR,
|
|
"Unexpected status return %d from auth call",
|
|
(int)status);
|
|
}
|
|
else if (!access_login_allowed(&g_cfg->sec, username))
|
|
{
|
|
status = E_SCP_LOGIN_NOT_AUTHORIZED;
|
|
LOG(LOG_LEVEL_INFO, "Username okay but group problem for "
|
|
"user: %s", username);
|
|
}
|
|
|
|
/* If all is well, put the auth_info in the sesman connection
|
|
* for later use. If not, remove the auth_info */
|
|
if (status == E_SCP_LOGIN_OK)
|
|
{
|
|
char *dup_username = g_strdup(username);
|
|
char *dup_ip_addr =
|
|
(ip_addr == NULL) ? g_strdup("") : g_strdup(ip_addr);
|
|
|
|
if (dup_username == NULL || dup_ip_addr == NULL)
|
|
{
|
|
LOG(LOG_LEVEL_ERROR, "%s : Memory allocation failed",
|
|
__func__);
|
|
g_free(dup_username);
|
|
g_free(dup_ip_addr);
|
|
status = E_SCP_LOGIN_NO_MEMORY;
|
|
}
|
|
else
|
|
{
|
|
LOG(LOG_LEVEL_INFO, "Access permitted for user=%s uid=%d",
|
|
username, uid);
|
|
sc->auth_info = auth_info;
|
|
sc->uid = uid;
|
|
sc->username = dup_username;
|
|
sc->ip_addr = dup_ip_addr;
|
|
}
|
|
}
|
|
|
|
if (status != E_SCP_LOGIN_OK)
|
|
{
|
|
auth_end(auth_info);
|
|
}
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
static int
|
|
process_set_peername_request(struct sesman_con *sc)
|
|
{
|
|
int rv;
|
|
const char *peername;
|
|
|
|
rv = scp_get_set_peername_request(sc->t, &peername);
|
|
if (rv == 0)
|
|
{
|
|
if (sesman_set_connection_peername(sc, peername) != 0)
|
|
{
|
|
LOG(LOG_LEVEL_WARNING,
|
|
"Failed to set connection peername from %s to %s",
|
|
sc->peername, peername);
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
* Allocates a chain item and starts the session
|
|
*/
|
|
static enum scp_screate_status
|
|
allocate_and_start_session(struct auth_info *auth_info,
|
|
const char *username,
|
|
const char *ip_addr,
|
|
const struct session_parameters *params)
|
|
{
|
|
int pid = 0;
|
|
struct session_chain *temp = (struct session_chain *)NULL;
|
|
enum scp_screate_status status;
|
|
|
|
/* check to limit concurrent sessions */
|
|
if (session_list_get_count() >= (unsigned int)g_cfg->sess.max_sessions)
|
|
{
|
|
LOG(LOG_LEVEL_ERROR, "max concurrent session limit "
|
|
"exceeded. login for user %s denied", username);
|
|
return E_SCP_SCREATE_MAX_REACHED;
|
|
}
|
|
|
|
temp = (struct session_chain *)g_malloc(sizeof(struct session_chain), 0);
|
|
|
|
if (temp == 0)
|
|
{
|
|
LOG(LOG_LEVEL_ERROR, "Out of memory error: cannot create new session "
|
|
"chain element - user %s", username);
|
|
return E_SCP_SCREATE_NO_MEMORY;
|
|
}
|
|
|
|
temp->item = (struct session_item *)g_malloc(sizeof(struct session_item), 0);
|
|
|
|
if (temp->item == 0)
|
|
{
|
|
g_free(temp);
|
|
LOG(LOG_LEVEL_ERROR, "Out of memory error: cannot create new session "
|
|
"item - user %s", username);
|
|
return E_SCP_SCREATE_NO_MEMORY;
|
|
}
|
|
|
|
status = session_start(auth_info, params, &pid);
|
|
if (status == E_SCP_SCREATE_OK)
|
|
{
|
|
if (ip_addr[0] != '\0')
|
|
{
|
|
LOG(LOG_LEVEL_INFO, "++ created session: username %s, ip %s",
|
|
username, ip_addr);
|
|
}
|
|
else
|
|
{
|
|
LOG(LOG_LEVEL_INFO, "++ created session: username %s", username);
|
|
}
|
|
|
|
temp->item->pid = pid;
|
|
temp->item->display = params->display;
|
|
temp->item->width = params->width;
|
|
temp->item->height = params->height;
|
|
temp->item->bpp = params->bpp;
|
|
temp->item->auth_info = auth_info;
|
|
g_strncpy(temp->item->start_ip_addr, ip_addr,
|
|
sizeof(temp->item->start_ip_addr) - 1);
|
|
temp->item->uid = params->uid;
|
|
temp->item->guid = params->guid;
|
|
|
|
temp->item->start_time = g_time1();
|
|
|
|
temp->item->type = params->type;
|
|
temp->item->status = SESMAN_SESSION_STATUS_ACTIVE;
|
|
|
|
session_list_add(temp);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
static int
|
|
process_sys_login_request(struct sesman_con *sc)
|
|
{
|
|
int rv;
|
|
const char *supplied_username;
|
|
const char *password;
|
|
const char *ip_addr;
|
|
|
|
rv = scp_get_sys_login_request(sc->t, &supplied_username,
|
|
&password, &ip_addr);
|
|
if (rv == 0)
|
|
{
|
|
enum scp_login_status errorcode;
|
|
int server_closed = 1;
|
|
int uid;
|
|
char *username = NULL;
|
|
|
|
LOG(LOG_LEVEL_INFO,
|
|
"Received system login request from %s for user: %s IP: %s",
|
|
sc->peername, supplied_username, ip_addr);
|
|
|
|
if (sc->auth_info != NULL)
|
|
{
|
|
errorcode = E_SCP_LOGIN_ALREADY_LOGGED_IN;
|
|
LOG(LOG_LEVEL_ERROR, "Connection is already logged in for %s",
|
|
sc->username);
|
|
}
|
|
else if (g_getuser_info_by_name(supplied_username,
|
|
&uid, NULL, NULL, NULL, NULL) != 0)
|
|
{
|
|
/* we can't get a UID for the user */
|
|
errorcode = E_SCP_LOGIN_NOT_AUTHENTICATED;
|
|
LOG(LOG_LEVEL_ERROR, "Can't get UID for user %s",
|
|
supplied_username);
|
|
log_authfail_message(username, ip_addr);
|
|
}
|
|
else if (g_getuser_info_by_uid(uid,
|
|
&username, NULL, NULL, NULL, NULL) != 0)
|
|
{
|
|
errorcode = E_SCP_LOGIN_GENERAL_ERROR;
|
|
LOG(LOG_LEVEL_ERROR, "Can't reverse lookup UID %d", uid);
|
|
}
|
|
else
|
|
{
|
|
if (g_strcmp(supplied_username, username) != 0)
|
|
{
|
|
/*
|
|
* If using a federated naming service (e.g. AD), the
|
|
* username supplied may not match that name mapped to by
|
|
* the UID. We will generate a warning in this instance so
|
|
* the user can see what is being used within sesman
|
|
*/
|
|
LOG(LOG_LEVEL_WARNING,
|
|
"Using username %s for the session (from UID %d)",
|
|
username, uid);
|
|
}
|
|
|
|
errorcode = authenticate_and_authorize_connection(
|
|
sc, AM_SYSTEM,
|
|
uid, username,
|
|
password, ip_addr);
|
|
if (errorcode == E_SCP_LOGIN_OK)
|
|
{
|
|
server_closed = 0;
|
|
}
|
|
else if (errorcode == E_SCP_LOGIN_NOT_AUTHENTICATED)
|
|
{
|
|
log_authfail_message(username, ip_addr);
|
|
if (sc->auth_retry_count > 0)
|
|
{
|
|
/* Password problem? Invite the user to retry */
|
|
server_closed = 0;
|
|
--sc->auth_retry_count;
|
|
}
|
|
}
|
|
|
|
g_free(username);
|
|
}
|
|
|
|
if (server_closed)
|
|
{
|
|
/* Expecting no more client messages. Close the connection
|
|
* after returning from this callback */
|
|
sc->close_requested = 1;
|
|
}
|
|
|
|
rv = scp_send_login_response(sc->t, errorcode, server_closed);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
static int
|
|
process_uds_login_request(struct sesman_con *sc)
|
|
{
|
|
enum scp_login_status errorcode;
|
|
int rv;
|
|
int uid;
|
|
int pid;
|
|
char *username = NULL;
|
|
int server_closed = 1;
|
|
|
|
rv = g_sck_get_peer_cred(sc->t->sck, &pid, &uid, NULL);
|
|
if (rv != 0)
|
|
{
|
|
LOG(LOG_LEVEL_INFO,
|
|
"Unable to get peer credentials for socket %d",
|
|
(int)sc->t->sck);
|
|
errorcode = E_SCP_LOGIN_GENERAL_ERROR;
|
|
}
|
|
else
|
|
{
|
|
LOG(LOG_LEVEL_INFO,
|
|
"Received UDS login request from %s for UID: %d from PID: %d",
|
|
sc->peername, uid, pid);
|
|
|
|
if (sc->auth_info != NULL)
|
|
{
|
|
errorcode = E_SCP_LOGIN_ALREADY_LOGGED_IN;
|
|
LOG(LOG_LEVEL_ERROR, "Connection is already logged in for %s",
|
|
sc->username);
|
|
}
|
|
else if (g_getuser_info_by_uid(uid, &username,
|
|
NULL, NULL, NULL, NULL) != 0)
|
|
{
|
|
errorcode = E_SCP_LOGIN_GENERAL_ERROR;
|
|
LOG(LOG_LEVEL_ERROR, "Can't reverse lookup UID %d", uid);
|
|
}
|
|
else
|
|
{
|
|
errorcode = authenticate_and_authorize_connection(
|
|
sc, AM_UDS,
|
|
uid, username,
|
|
NULL, NULL);
|
|
g_free(username);
|
|
|
|
if (errorcode == E_SCP_LOGIN_OK)
|
|
{
|
|
server_closed = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (server_closed)
|
|
{
|
|
/* Close the connection after returning from this callback */
|
|
sc->close_requested = 1;
|
|
}
|
|
|
|
return scp_send_login_response(sc->t, errorcode, server_closed);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
static int
|
|
process_logout_request(struct sesman_con *sc)
|
|
{
|
|
if (sc->auth_info != NULL)
|
|
{
|
|
LOG(LOG_LEVEL_INFO, "Logging out %s from sesman", sc->username);
|
|
auth_end(sc->auth_info);
|
|
sc->auth_info = NULL;
|
|
sc->uid = -1;
|
|
g_free(sc->username);
|
|
sc->username = NULL;
|
|
g_free(sc->ip_addr);
|
|
sc->ip_addr = NULL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
static int
|
|
process_create_session_request(struct sesman_con *sc)
|
|
{
|
|
int rv;
|
|
// Parameters for a new session (if required). Filled in as
|
|
// we go along.
|
|
struct session_parameters sp = {0};
|
|
const char *shellptr;
|
|
const char *dirptr;
|
|
enum scp_screate_status status = E_SCP_SCREATE_OK;
|
|
|
|
int display = 0;
|
|
struct guid guid;
|
|
|
|
guid_clear(&guid);
|
|
|
|
rv = scp_get_create_session_request(sc->t,
|
|
&sp.type, &sp.width, &sp.height,
|
|
&sp.bpp, &shellptr, &dirptr);
|
|
|
|
if (rv == 0)
|
|
{
|
|
if (sc->auth_info == NULL)
|
|
{
|
|
status = E_SCP_SCREATE_NOT_LOGGED_IN;
|
|
}
|
|
else
|
|
{
|
|
LOG(LOG_LEVEL_INFO,
|
|
"Received request from %s to create a session for user %s"
|
|
" type=%s"
|
|
" geometry=%dx%d, bpp=%d, shell=\"%s\", dir=\"%s\"",
|
|
sc->peername, sc->username,
|
|
SCP_SESSION_TYPE_TO_STR(sp.type),
|
|
sp.width, sp.height, sp.bpp, shellptr, dirptr);
|
|
|
|
struct session_item *s_item =
|
|
session_list_get_bydata(sc->uid, sp.type, sp.width, sp.height,
|
|
sp.bpp, sc->ip_addr);
|
|
if (s_item != 0)
|
|
{
|
|
// Found an existing session
|
|
if (sc->ip_addr[0] != '\0')
|
|
{
|
|
LOG( LOG_LEVEL_INFO, "++ reconnected session: username %s, "
|
|
"display :%d.0, session_pid %d, ip %s",
|
|
sc->username, s_item->display, s_item->pid,
|
|
sc->ip_addr);
|
|
}
|
|
else
|
|
{
|
|
LOG(LOG_LEVEL_INFO, "++ reconnected session: username %s, "
|
|
"display :%d.0, session_pid %d",
|
|
sc->username, s_item->display, s_item->pid);
|
|
}
|
|
|
|
// Get values for response to SCP client
|
|
display = s_item->display;
|
|
guid = s_item->guid;
|
|
|
|
session_reconnect(s_item->display, sc->uid, sc->auth_info);
|
|
}
|
|
else
|
|
{
|
|
// Need to create a new session
|
|
//
|
|
// Get the rest of the parameters for the session
|
|
guid = guid_new();
|
|
display = session_list_get_available_display();
|
|
|
|
sp.display = display;
|
|
sp.uid = sc->uid;
|
|
sp.guid = guid;
|
|
// These need to be copied so they are available
|
|
// when the sub-process closes all the connections
|
|
g_snprintf(sp.shell, sizeof(sp.shell), "%s", shellptr);
|
|
g_snprintf(sp.directory, sizeof(sp.directory), "%s", dirptr);
|
|
|
|
if (display == 0)
|
|
{
|
|
status = E_SCP_SCREATE_NO_DISPLAY;
|
|
}
|
|
else
|
|
{
|
|
// The new session will have a lifetime longer than
|
|
// the sesman connection, and so needs to own
|
|
// the auth_info struct.
|
|
//
|
|
// Copy the auth_info struct out of the connection and pass
|
|
// it to the session
|
|
struct auth_info *auth_info = sc->auth_info;
|
|
sc->auth_info = NULL;
|
|
|
|
status = allocate_and_start_session(auth_info,
|
|
sc->username,
|
|
sc->ip_addr,
|
|
&sp);
|
|
if (status != E_SCP_SCREATE_OK)
|
|
{
|
|
// Close the auth session down as it can't be re-used.
|
|
auth_end(auth_info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Currently a create session request is the last thing on a
|
|
* connection, and results in automatic closure */
|
|
sc->close_requested = 1;
|
|
|
|
rv = scp_send_create_session_response(sc->t, status,
|
|
display, &guid);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
static int
|
|
process_list_sessions_request(struct sesman_con *sc)
|
|
{
|
|
int rv = 0;
|
|
|
|
struct scp_session_info *info = NULL;
|
|
unsigned int cnt = 0;
|
|
unsigned int i;
|
|
|
|
if (sc->auth_info == NULL)
|
|
{
|
|
rv = scp_send_list_sessions_response(sc->t,
|
|
E_SCP_LS_NOT_LOGGED_IN,
|
|
NULL);
|
|
}
|
|
else
|
|
{
|
|
LOG(LOG_LEVEL_INFO,
|
|
"Received request from %s to list sessions for user %s",
|
|
sc->peername, sc->username);
|
|
|
|
info = session_list_get_byuid(sc->uid, &cnt,
|
|
SESMAN_SESSION_STATUS_ALL);
|
|
|
|
for (i = 0; rv == 0 && i < cnt; ++i)
|
|
{
|
|
rv = scp_send_list_sessions_response(sc->t,
|
|
E_SCP_LS_SESSION_INFO,
|
|
&info[i]);
|
|
}
|
|
free_session_info_list(info, cnt);
|
|
|
|
if (rv == 0)
|
|
{
|
|
rv = scp_send_list_sessions_response(sc->t,
|
|
E_SCP_LS_END_OF_LIST,
|
|
NULL);
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
static int
|
|
process_close_connection_request(struct sesman_con *sc)
|
|
{
|
|
int rv = 0;
|
|
|
|
LOG(LOG_LEVEL_INFO, "Received request to close connection from %s",
|
|
sc->peername);
|
|
|
|
/* Expecting no more client messages. Close the connection
|
|
* after returning from this callback */
|
|
sc->close_requested = 1;
|
|
return rv;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
int
|
|
scp_process(struct sesman_con *sc)
|
|
{
|
|
enum scp_msg_code msgno;
|
|
int rv = 0;
|
|
|
|
switch ((msgno = scp_msg_in_get_msgno(sc->t)))
|
|
{
|
|
case E_SCP_SET_PEERNAME_REQUEST:
|
|
rv = process_set_peername_request(sc);
|
|
break;
|
|
|
|
case E_SCP_SYS_LOGIN_REQUEST:
|
|
rv = process_sys_login_request(sc);
|
|
break;
|
|
|
|
case E_SCP_UDS_LOGIN_REQUEST:
|
|
rv = process_uds_login_request(sc);
|
|
break;
|
|
|
|
case E_SCP_LOGOUT_REQUEST:
|
|
rv = process_logout_request(sc);
|
|
break;
|
|
|
|
case E_SCP_CREATE_SESSION_REQUEST:
|
|
rv = process_create_session_request(sc);
|
|
break;
|
|
|
|
case E_SCP_LIST_SESSIONS_REQUEST:
|
|
rv = process_list_sessions_request(sc);
|
|
break;
|
|
|
|
case E_SCP_CLOSE_CONNECTION_REQUEST:
|
|
rv = process_close_connection_request(sc);
|
|
break;
|
|
|
|
default:
|
|
{
|
|
char buff[64];
|
|
scp_msgno_to_str(msgno, buff, sizeof(buff));
|
|
LOG(LOG_LEVEL_ERROR, "Ignored SCP message %s", buff);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|