Merge branch 'devel' of github.com:NeutrinoLabs/xrdp into devel

ulab-next-nosound
Laxmikant Rashinkar 10 years ago
commit 56e43c4a38

2
.gitmodules vendored

@ -1,3 +1,3 @@
[submodule "librfxcodec"]
path = librfxcodec
url = git://github.com/neutrinolabs/librfxcodec.git
url = git://github.com/neutrinolabs/librfxcodec

@ -39,7 +39,8 @@ libcommon_la_SOURCES = \
os_calls.c \
ssl_calls.c \
thread_calls.c \
trans.c
trans.c \
xrdp_tls.c
libcommon_la_LIBADD = \
-lcrypto \

@ -19,7 +19,7 @@
*/
#include "fifo.h"
#include "common/os_calls.h"
#include "os_calls.h"
/**
* Create new fifo data struct
@ -27,7 +27,8 @@
* @return pointer to new FIFO or NULL if system out of memory
*****************************************************************************/
FIFO *fifo_create()
FIFO * APP_CC
fifo_create(void)
{
return (FIFO *) g_malloc(sizeof(FIFO), 1);
}
@ -36,7 +37,8 @@ FIFO *fifo_create()
* Delete specified FIFO
*****************************************************************************/
void fifo_delete(FIFO *self)
void APP_CC
fifo_delete(FIFO *self)
{
USER_DATA *udp;
@ -85,7 +87,8 @@ void fifo_delete(FIFO *self)
* @return 0 on success, -1 on error
*****************************************************************************/
int fifo_add_item(FIFO *self, void *item)
int APP_CC
fifo_add_item(FIFO *self, void *item)
{
USER_DATA *udp;
@ -121,7 +124,8 @@ int fifo_add_item(FIFO *self, void *item)
* @return top item from FIFO or NULL if FIFO is empty
*****************************************************************************/
void *fifo_remove_item(FIFO *self)
void * APP_CC
fifo_remove_item(FIFO *self)
{
void *item;
USER_DATA *udp;
@ -155,7 +159,8 @@ void *fifo_remove_item(FIFO *self)
* @return true if FIFO is empty, false otherwise
*****************************************************************************/
int fifo_is_empty(FIFO *self)
int APP_CC
fifo_is_empty(FIFO *self)
{
if (!self)
return 1;

@ -21,6 +21,8 @@
#ifndef _FIFO_H
#define _FIFO_H
#include "arch.h"
typedef struct user_data USER_DATA;
struct user_data
@ -36,10 +38,10 @@ typedef struct fifo
int auto_free;
} FIFO;
FIFO *fifo_create();
void fifo_delete(FIFO *self);
int fifo_add_item(FIFO *self, void *item);
void *fifo_remove_item(FIFO *self);
int fifo_is_empty();
FIFO * APP_CC fifo_create(void);
void APP_CC fifo_delete(FIFO *self);
int APP_CC fifo_add_item(FIFO *self, void *item);
void * APP_CC fifo_remove_item(FIFO *self);
int APP_CC fifo_is_empty(FIFO *self);
#endif

@ -41,4 +41,8 @@
#define XRDP_LIB_PATH "/usr/local/lib/xrdp"
#endif
#if !defined(XRDP_LOG_PATH)
#define XRDP_LOG_PATH "/var/log"
#endif
#endif

@ -26,7 +26,7 @@
/* list */
struct list
{
tbus* items;
tintptr* items;
int count;
int alloc_size;
int grow_by;
@ -38,17 +38,17 @@ list_create(void);
void APP_CC
list_delete(struct list* self);
void APP_CC
list_add_item(struct list* self, tbus item);
tbus APP_CC
list_add_item(struct list* self, tintptr item);
tintptr APP_CC
list_get_item(struct list* self, int index);
void APP_CC
list_clear(struct list* self);
int APP_CC
list_index_of(struct list* self, tbus item);
list_index_of(struct list* self, tintptr item);
void APP_CC
list_remove_item(struct list* self, int index);
void APP_CC
list_insert_item(struct list* self, int index, tbus item);
list_insert_item(struct list* self, int index, tintptr item);
void APP_CC
list_append_list_strdup(struct list* self, struct list* dest, int start_index);
void APP_CC

@ -36,7 +36,7 @@
#include "log.h"
/* Here we store the current state and configuration of the log */
static struct log_config *staticLogConfig = NULL;
static struct log_config *g_staticLogConfig = NULL;
/* This file first start with all private functions.
In the end of the file the public functions is defined */
@ -297,7 +297,7 @@ internalReadConfiguration(const char *inFilename, const char *applicationName)
param_v->auto_free = 1;
/* read logging config */
ret = internal_config_read_logging(fd, staticLogConfig, param_n,
ret = internal_config_read_logging(fd, g_staticLogConfig, param_n,
param_v, applicationName);
if (ret != LOG_STARTUP_OK)
@ -394,12 +394,12 @@ enum logReturns DEFAULT_CC
internalInitAndAllocStruct(void)
{
enum logReturns ret = LOG_GENERAL_ERROR;
staticLogConfig = g_malloc(sizeof(struct log_config), 1);
g_staticLogConfig = g_malloc(sizeof(struct log_config), 1);
if (staticLogConfig != NULL)
if (g_staticLogConfig != NULL)
{
staticLogConfig->fd = -1;
staticLogConfig->enable_syslog = 0;
g_staticLogConfig->fd = -1;
g_staticLogConfig->enable_syslog = 0;
ret = LOG_STARTUP_OK;
}
else
@ -420,7 +420,7 @@ log_start_from_param(const struct log_config *iniParams)
{
enum logReturns ret = LOG_GENERAL_ERROR;
if (staticLogConfig != NULL)
if (g_staticLogConfig != NULL)
{
log_message(LOG_LEVEL_ALWAYS, "Log already initialized");
return ret;
@ -442,24 +442,24 @@ log_start_from_param(const struct log_config *iniParams)
return ret;
}
staticLogConfig->enable_syslog = iniParams->enable_syslog;
staticLogConfig->fd = iniParams->fd;
staticLogConfig->log_file = g_strdup(iniParams->log_file);
staticLogConfig->log_level = iniParams->log_level;
staticLogConfig->log_lock = iniParams->log_lock;
staticLogConfig->log_lock_attr = iniParams->log_lock_attr;
staticLogConfig->program_name = g_strdup(iniParams->program_name);
staticLogConfig->syslog_level = iniParams->syslog_level;
ret = internal_log_start(staticLogConfig);
g_staticLogConfig->enable_syslog = iniParams->enable_syslog;
g_staticLogConfig->fd = iniParams->fd;
g_staticLogConfig->log_file = g_strdup(iniParams->log_file);
g_staticLogConfig->log_level = iniParams->log_level;
g_staticLogConfig->log_lock = iniParams->log_lock;
g_staticLogConfig->log_lock_attr = iniParams->log_lock_attr;
g_staticLogConfig->program_name = g_strdup(iniParams->program_name);
g_staticLogConfig->syslog_level = iniParams->syslog_level;
ret = internal_log_start(g_staticLogConfig);
if (ret != LOG_STARTUP_OK)
{
g_writeln("Could not start log");
if (staticLogConfig != NULL)
if (g_staticLogConfig != NULL)
{
g_free(staticLogConfig);
staticLogConfig = NULL;
g_free(g_staticLogConfig);
g_staticLogConfig = NULL;
}
}
}
@ -489,16 +489,16 @@ log_start(const char *iniFile, const char *applicationName)
if (ret == LOG_STARTUP_OK)
{
ret = internal_log_start(staticLogConfig);
ret = internal_log_start(g_staticLogConfig);
if (ret != LOG_STARTUP_OK)
{
g_writeln("Could not start log");
if (staticLogConfig != NULL)
if (g_staticLogConfig != NULL)
{
g_free(staticLogConfig);
staticLogConfig = NULL;
g_free(g_staticLogConfig);
g_staticLogConfig = NULL;
}
}
}
@ -519,12 +519,12 @@ enum logReturns DEFAULT_CC
log_end(void)
{
enum logReturns ret = LOG_GENERAL_ERROR;
ret = internal_log_end(staticLogConfig);
ret = internal_log_end(g_staticLogConfig);
if (staticLogConfig != NULL)
if (g_staticLogConfig != NULL)
{
g_free(staticLogConfig);
staticLogConfig = NULL;
g_free(g_staticLogConfig);
g_staticLogConfig = NULL;
}
return ret;
@ -541,13 +541,13 @@ log_message(const enum logLevels lvl, const char *msg, ...)
time_t now_t;
struct tm *now;
if (staticLogConfig == NULL)
if (g_staticLogConfig == NULL)
{
g_writeln("The log reference is NULL - log not initialized properly");
return LOG_ERROR_NO_CFG;
}
if (0 > staticLogConfig->fd && staticLogConfig->enable_syslog == 0)
if (0 > g_staticLogConfig->fd && g_staticLogConfig->enable_syslog == 0)
{
return LOG_ERROR_FILE_NOT_OPEN;
}
@ -586,7 +586,7 @@ log_message(const enum logLevels lvl, const char *msg, ...)
#endif
#endif
if (staticLogConfig->enable_syslog && (lvl <= staticLogConfig->syslog_level))
if (g_staticLogConfig->enable_syslog && (lvl <= g_staticLogConfig->syslog_level))
{
/* log to syslog*/
/* %s fix compiler warning 'not a string literal' */
@ -594,19 +594,19 @@ log_message(const enum logLevels lvl, const char *msg, ...)
tc_get_threadid(), buff + 20);
}
if (lvl <= staticLogConfig->log_level)
if (lvl <= g_staticLogConfig->log_level)
{
/* log to console */
g_printf("%s", buff);
/* log to application logfile */
#ifdef LOG_ENABLE_THREAD
pthread_mutex_lock(&(staticLogConfig->log_lock));
pthread_mutex_lock(&(g_staticLogConfig->log_lock));
#endif
if (staticLogConfig->fd > 0)
if (g_staticLogConfig->fd > 0)
{
writereply = g_file_write(staticLogConfig->fd, buff, g_strlen(buff));
writereply = g_file_write(g_staticLogConfig->fd, buff, g_strlen(buff));
if (writereply <= 0)
{
@ -615,7 +615,7 @@ log_message(const enum logLevels lvl, const char *msg, ...)
}
#ifdef LOG_ENABLE_THREAD
pthread_mutex_unlock(&(staticLogConfig->log_lock));
pthread_mutex_unlock(&(g_staticLogConfig->log_lock));
#endif
}
@ -629,11 +629,11 @@ log_message(const enum logLevels lvl, const char *msg, ...)
char *DEFAULT_CC
getLogFile(char *replybuf, int bufsize)
{
if (staticLogConfig)
if (g_staticLogConfig)
{
if (staticLogConfig->log_file)
if (g_staticLogConfig->log_file)
{
g_strncpy(replybuf, staticLogConfig->log_file, bufsize);
g_strncpy(replybuf, g_staticLogConfig->log_file, bufsize);
}
else
{

@ -65,8 +65,8 @@ enum logReturns
struct log_config
{
char* program_name;
char* log_file;
char *program_name;
char *log_file;
int fd;
unsigned int log_level;
int enable_syslog;
@ -86,7 +86,7 @@ struct log_config
*
*/
enum logReturns DEFAULT_CC
internal_log_start(struct log_config* l_cfg);
internal_log_start(struct log_config *l_cfg);
/**
*
@ -95,7 +95,7 @@ internal_log_start(struct log_config* l_cfg);
*
*/
enum logReturns DEFAULT_CC
internal_log_end(struct log_config* l_cfg);
internal_log_end(struct log_config *l_cfg);
/**
* Converts a log level to a string
@ -103,7 +103,7 @@ internal_log_end(struct log_config* l_cfg);
* @param str pointer where the string will be stored.
*/
void DEFAULT_CC
internal_log_lvl2str(const enum logLevels lvl, char* str);
internal_log_lvl2str(const enum logLevels lvl, char *str);
/**
*
@ -113,7 +113,7 @@ internal_log_lvl2str(const enum logLevels lvl, char* str);
*
*/
enum logLevels DEFAULT_CC
internal_log_text2level(char* s);
internal_log_text2level(char *s);
/**
* A function that init our struct that holds all state and
@ -133,9 +133,9 @@ internalInitAndAllocStruct(void);
* @return
*/
enum logReturns DEFAULT_CC
internal_config_read_logging(int file, struct log_config* lc,
struct list* param_n,
struct list* param_v,
internal_config_read_logging(int file, struct log_config *lc,
struct list *param_n,
struct list *param_v,
const char *applicationName);
/*End of internal functions*/
#endif
@ -147,7 +147,7 @@ internal_config_read_logging(int file, struct log_config* lc,
* @return LOG_STARTUP_OK on success
*/
enum logReturns DEFAULT_CC
log_start(const char* iniFile, const char* applicationName);
log_start(const char *iniFile, const char *applicationName);
/**
* An alternative log_start where the caller gives the params directly.
@ -171,7 +171,7 @@ log_end(void);
* @return
*/
enum logReturns DEFAULT_CC
log_message(const enum logLevels lvl, const char* msg, ...);
log_message(const enum logLevels lvl, const char *msg, ...);
/**
*
@ -181,7 +181,7 @@ log_message(const enum logLevels lvl, const char* msg, ...);
* @return 0 on success, 1 on failure
*
*/
int APP_CC text2bool(char* s);
int APP_CC text2bool(char *s);
/**
* This function returns the configured file name for the logfile

@ -36,17 +36,17 @@
/* parser state */
struct stream
{
char* p;
char* end;
char* data;
char *p;
char *end;
char *data;
int size;
/* offsets of various headers */
char* iso_hdr;
char* mcs_hdr;
char* sec_hdr;
char* rdp_hdr;
char* channel_hdr;
char* next_packet;
char *iso_hdr;
char *mcs_hdr;
char *sec_hdr;
char *rdp_hdr;
char *channel_hdr;
char *next_packet;
};
/******************************************************************************/

@ -24,12 +24,13 @@
#include "parse.h"
/*****************************************************************************/
struct trans *APP_CC
struct trans *
APP_CC
trans_create(int mode, int in_size, int out_size)
{
struct trans *self = (struct trans *)NULL;
struct trans *self = (struct trans *) NULL;
self = (struct trans *)g_malloc(sizeof(struct trans), 1);
self = (struct trans *) g_malloc(sizeof(struct trans), 1);
if (self != NULL)
{
@ -38,6 +39,10 @@ trans_create(int mode, int in_size, int out_size)
make_stream(self->out_s);
init_stream(self->out_s, out_size);
self->mode = mode;
self->tls = 0;
/* assign tcp functions */
self->trans_read_call = trans_tcp_force_read_s;
self->trans_write_call = trans_tcp_force_write_s;
}
return self;
@ -68,6 +73,11 @@ trans_delete(struct trans *self)
g_free(self->listen_filename);
}
if (self->tls != 0)
{
xrdp_tls_delete(self->tls);
}
g_free(self);
}
@ -92,8 +102,7 @@ trans_get_wait_objs(struct trans *self, tbus *objs, int *count)
/*****************************************************************************/
int APP_CC
trans_get_wait_objs_rw(struct trans *self,
tbus *robjs, int *rcount,
trans_get_wait_objs_rw(struct trans *self, tbus *robjs, int *rcount,
tbus *wobjs, int *wcount)
{
if (self == 0)
@ -174,8 +183,8 @@ send_waiting(struct trans *self, int block)
int APP_CC
trans_check_wait_objs(struct trans *self)
{
tbus in_sck = (tbus)0;
struct trans *in_trans = (struct trans *)NULL;
tbus in_sck = (tbus) 0;
struct trans *in_trans = (struct trans *) NULL;
int read_bytes = 0;
int to_read = 0;
int read_so_far = 0;
@ -224,8 +233,10 @@ trans_check_wait_objs(struct trans *self)
in_trans->type1 = TRANS_TYPE_SERVER;
in_trans->status = TRANS_STATUS_UP;
in_trans->is_term = self->is_term;
g_strncpy(in_trans->addr, self->addr, sizeof(self->addr) - 1);
g_strncpy(in_trans->port, self->port, sizeof(self->port) - 1);
g_strncpy(in_trans->addr, self->addr,
sizeof(self->addr) - 1);
g_strncpy(in_trans->port, self->port,
sizeof(self->port) - 1);
if (self->trans_conn_in(self, in_trans) != 0)
{
@ -243,7 +254,7 @@ trans_check_wait_objs(struct trans *self)
{
if (g_tcp_can_recv(self->sck, 0))
{
read_so_far = (int)(self->in_s->end - self->in_s->data);
read_so_far = (int) (self->in_s->end - self->in_s->data);
to_read = self->header_size - read_so_far;
if (to_read > 0)
@ -275,7 +286,7 @@ trans_check_wait_objs(struct trans *self)
}
}
read_so_far = (int)(self->in_s->end - self->in_s->data);
read_so_far = (int) (self->in_s->end - self->in_s->data);
if (read_so_far == self->header_size)
{
@ -299,10 +310,15 @@ trans_check_wait_objs(struct trans *self)
return rv;
}
/*****************************************************************************/
int APP_CC
trans_force_read_s(struct trans *self, struct stream *in_s, int size)
{
return self->trans_read_call(self, in_s, size);
}
/*****************************************************************************/
int APP_CC
trans_tcp_force_read_s(struct trans *self, struct stream *in_s, int size)
{
int rcvd;
@ -318,7 +334,9 @@ trans_force_read_s(struct trans *self, struct stream *in_s, int size)
{
return 1;
}
rcvd = g_tcp_recv(self->sck, in_s->end, size, 0);
if (rcvd == -1)
{
if (g_tcp_last_error_would_block(self->sck))
@ -370,6 +388,12 @@ trans_force_read(struct trans *self, int size)
/*****************************************************************************/
int APP_CC
trans_force_write_s(struct trans *self, struct stream *out_s)
{
return self->trans_write_call(self, out_s);
}
/*****************************************************************************/
int APP_CC
trans_tcp_force_write_s(struct trans *self, struct stream *out_s)
{
int size;
int total;
@ -380,7 +404,7 @@ trans_force_write_s(struct trans *self, struct stream *out_s)
return 1;
}
size = (int)(out_s->end - out_s->data);
size = (int) (out_s->end - out_s->data);
total = 0;
if (send_waiting(self, 1) != 0)
@ -455,7 +479,7 @@ trans_write_copy(struct trans *self)
}
out_s = self->out_s;
size = (int)(out_s->end - out_s->data);
size = (int) (out_s->end - out_s->data);
make_stream(wait_s);
init_stream(wait_s, size);
out_uint8a(wait_s, out_s->data, size);
@ -610,14 +634,15 @@ trans_listen(struct trans *self, char *port)
}
/*****************************************************************************/
struct stream *APP_CC
struct stream *
APP_CC
trans_get_in_s(struct trans *self)
{
struct stream *rv = (struct stream *)NULL;
struct stream *rv = (struct stream *) NULL;
if (self == NULL)
{
rv = (struct stream *)NULL;
rv = (struct stream *) NULL;
}
else
{
@ -628,14 +653,15 @@ trans_get_in_s(struct trans *self)
}
/*****************************************************************************/
struct stream *APP_CC
struct stream *
APP_CC
trans_get_out_s(struct trans *self, int size)
{
struct stream *rv = (struct stream *)NULL;
struct stream *rv = (struct stream *) NULL;
if (self == NULL)
{
rv = (struct stream *)NULL;
rv = (struct stream *) NULL;
}
else
{
@ -645,3 +671,43 @@ trans_get_out_s(struct trans *self, int size)
return rv;
}
/*****************************************************************************/
/* returns error */
int APP_CC
trans_set_tls_mode(struct trans *self, const char *key, const char *cert)
{
self->tls = xrdp_tls_create(self, key, cert);
if (self->tls == NULL)
{
g_writeln("trans_set_tls_mode: xrdp_tls_create malloc error");
return 1;
}
if (xrdp_tls_accept(self->tls) != 0)
{
g_writeln("trans_set_tls_mode: xrdp_tls_accept failed");
return 1;
}
/* assign tls functions */
self->trans_read_call = xrdp_tls_force_read_s;
self->trans_write_call = xrdp_tls_force_write_s;
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
trans_shutdown_tls_mode(struct trans *self)
{
if (self->tls != NULL)
{
return xrdp_tls_disconnect(self->tls);
}
/* set callback back to tcp
self->trans_read_call = trans_tcp_force_read_s;
self->trans_write_call = trans_tcp_force_write_s;
*/
return 0;
}

@ -23,6 +23,7 @@
#include "arch.h"
#include "parse.h"
#include <openssl/ssl.h>
#define TRANS_MODE_TCP 1
#define TRANS_MODE_UNIX 2
@ -35,11 +36,14 @@
#define TRANS_STATUS_UP 1
struct trans; /* forward declaration */
struct xrdp_tls;
typedef int (DEFAULT_CC *ttrans_data_in)(struct trans* self);
typedef int (DEFAULT_CC *ttrans_conn_in)(struct trans* self,
struct trans* new_self);
typedef int (DEFAULT_CC *tis_term)(void);
typedef int (APP_CC *trans_read_call) (struct trans *self, struct stream *in_s, int size);
typedef int (APP_CC *trans_write_call) (struct trans *self, struct stream *out_s);
struct trans
{
@ -60,8 +64,35 @@ struct trans
char port[256];
int no_stream_init_on_data_in;
int extra_flags; /* user defined */
struct xrdp_tls *tls;
trans_read_call trans_read_call;
trans_write_call trans_write_call;
};
/* xrdp_tls */
struct xrdp_tls
{
SSL *ssl;
SSL_CTX *ctx;
char *cert;
char *key;
struct trans *trans;
};
/* xrdp_tls.c */
struct xrdp_tls *APP_CC
xrdp_tls_create(struct trans *trans, const char *key, const char *cert);
int APP_CC
xrdp_tls_accept(struct xrdp_tls *self);
int APP_CC
xrdp_tls_disconnect(struct xrdp_tls *self);
void APP_CC
xrdp_tls_delete(struct xrdp_tls *self);
int APP_CC
xrdp_tls_force_read_s(struct trans *self, struct stream *in_s, int size);
int APP_CC
xrdp_tls_force_write_s(struct trans *self, struct stream *out_s);
struct trans* APP_CC
trans_create(int mode, int in_size, int out_size);
void APP_CC
@ -95,5 +126,13 @@ struct stream* APP_CC
trans_get_in_s(struct trans* self);
struct stream* APP_CC
trans_get_out_s(struct trans* self, int size);
int APP_CC
trans_set_tls_mode(struct trans *self, const char *key, const char *cert);
int APP_CC
trans_shutdown_tls_mode(struct trans *self);
int APP_CC
trans_tcp_force_read_s(struct trans *self, struct stream *in_s, int size);
int APP_CC
trans_tcp_force_write_s(struct trans *self, struct stream *out_s);
#endif

@ -125,6 +125,9 @@ struct xrdp_client_info
int capture_code;
int capture_format;
char certificate[1024];
char key_file[1024];
};
#endif

@ -78,9 +78,9 @@ struct rail_icon_info
int cmap_bytes;
int mask_bytes;
int data_bytes;
char* mask;
char* cmap;
char* data;
char *mask;
char *cmap;
char *data;
};
struct rail_window_rect
@ -95,8 +95,8 @@ struct rail_notify_icon_infotip
{
int timeout;
int flags;
char* text;
char* title;
char *text;
char *title;
};
struct rail_window_state_order
@ -105,7 +105,7 @@ struct rail_window_state_order
int style;
int extended_style;
int show_state;
char* title_info;
char *title_info;
int client_offset_x;
int client_offset_y;
int client_area_width;
@ -119,17 +119,17 @@ struct rail_window_state_order
int window_width;
int window_height;
int num_window_rects;
struct rail_window_rect* window_rects;
struct rail_window_rect *window_rects;
int visible_offset_x;
int visible_offset_y;
int num_visibility_rects;
struct rail_window_rect* visibility_rects;
struct rail_window_rect *visibility_rects;
};
struct rail_notify_state_order
{
int version;
char* tool_tip;
char *tool_tip;
struct rail_notify_icon_infotip infotip;
int state;
int icon_cache_entry;
@ -141,7 +141,7 @@ struct rail_monitored_desktop_order
{
int active_window_id;
int num_window_ids;
int* window_ids;
int *window_ids;
};
#endif

@ -0,0 +1,435 @@
/**
* xrdp: A Remote Desktop Protocol server.
*
* Copyright (C) Idan Freiberg 2013-2014
*
* 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.
*
* transport layer security
*/
#include "trans.h"
#include "ssl_calls.h"
/*****************************************************************************/
struct xrdp_tls *
APP_CC
xrdp_tls_create(struct trans *trans, const char *key, const char *cert)
{
struct xrdp_tls *self;
self = (struct xrdp_tls *) g_malloc(sizeof(struct xrdp_tls), 1);
if (self != NULL)
{
self->trans = trans;
self->cert = (char *) cert;
self->key = (char *) key;
}
return self;
}
/*****************************************************************************/
int APP_CC
xrdp_tls_accept(struct xrdp_tls *self)
{
int connection_status;
long options = 0;
/**
* SSL_OP_NO_SSLv2:
*
* We only want SSLv3 and TLSv1, so disable SSLv2.
* SSLv3 is used by, eg. Microsoft RDC for Mac OS X.
*/
options |= SSL_OP_NO_SSLv2;
/**
* SSL_OP_NO_COMPRESSION:
*
* The Microsoft RDP server does not advertise support
* for TLS compression, but alternative servers may support it.
* This was observed between early versions of the FreeRDP server
* and the FreeRDP client, and caused major performance issues,
* which is why we're disabling it.
*/
options |= SSL_OP_NO_COMPRESSION;
/**
* SSL_OP_TLS_BLOCK_PADDING_BUG:
*
* The Microsoft RDP server does *not* support TLS padding.
* It absolutely needs to be disabled otherwise it won't work.
*/
options |= SSL_OP_TLS_BLOCK_PADDING_BUG;
/**
* SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS:
*
* Just like TLS padding, the Microsoft RDP server does not
* support empty fragments. This needs to be disabled.
*/
options |= SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS;
self->ctx = SSL_CTX_new(SSLv23_server_method());
/* set context options */
SSL_CTX_set_mode(self->ctx,
SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER |
SSL_MODE_ENABLE_PARTIAL_WRITE);
SSL_CTX_set_options(self->ctx, options);
SSL_CTX_set_read_ahead(self->ctx, 1);
if (self->ctx == NULL)
{
g_writeln("xrdp_tls_accept: SSL_CTX_new failed");
return 1;
}
if (SSL_CTX_use_RSAPrivateKey_file(self->ctx, self->key, SSL_FILETYPE_PEM)
<= 0)
{
g_writeln("xrdp_tls_accept: SSL_CTX_use_RSAPrivateKey_file failed");
return 1;
}
self->ssl = SSL_new(self->ctx);
if (self->ssl == NULL)
{
g_writeln("xrdp_tls_accept: SSL_new failed");
return 1;
}
if (SSL_use_certificate_file(self->ssl, self->cert, SSL_FILETYPE_PEM) <= 0)
{
g_writeln("xrdp_tls_accept: SSL_use_certificate_file failed");
return 1;
}
if (SSL_set_fd(self->ssl, self->trans->sck) < 1)
{
g_writeln("xrdp_tls_accept: SSL_set_fd failed");
return 1;
}
connection_status = SSL_accept(self->ssl);
if (connection_status <= 0)
{
if (xrdp_tls_print_error("SSL_accept", self->ssl, connection_status))
{
return 1;
}
}
g_writeln("xrdp_tls_accept: TLS connection accepted");
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_tls_print_error(char *func, SSL *connection, int value)
{
switch (SSL_get_error(connection, value))
{
case SSL_ERROR_ZERO_RETURN:
g_writeln("xrdp_tls_print_error: %s: Server closed TLS connection",
func);
return 1;
case SSL_ERROR_WANT_READ:
g_writeln("xrdp_tls_print_error: SSL_ERROR_WANT_READ");
return 0;
case SSL_ERROR_WANT_WRITE:
g_writeln("xrdp_tls_print_error: SSL_ERROR_WANT_WRITE");
return 0;
case SSL_ERROR_SYSCALL:
g_writeln("xrdp_tls_print_error: %s: I/O error", func);
return 1;
case SSL_ERROR_SSL:
g_writeln(
"xrdp_tls_print_error: %s: Failure in SSL library (protocol error?)",
func);
return 1;
default:
g_writeln("xrdp_tls_print_error: %s: Unknown error", func);
return 1;
}
}
/*****************************************************************************/
int APP_CC
xrdp_tls_disconnect(struct xrdp_tls *self)
{
int status = SSL_shutdown(self->ssl);
while (status != 1)
{
status = SSL_shutdown(self->ssl);
if (status <= 0)
{
if (xrdp_tls_print_error("SSL_shutdown", self->ssl, status))
{
return 1;
}
}
}
return 0;
}
/*****************************************************************************/
void APP_CC
xrdp_tls_delete(struct xrdp_tls *self)
{
if (self != NULL)
{
if (self->ssl)
SSL_free(self->ssl);
if (self->ctx)
SSL_CTX_free(self->ctx);
g_free(self);
}
}
/*****************************************************************************/
int APP_CC
xrdp_tls_read(struct xrdp_tls *tls, unsigned char *data, int length)
{
int status;
status = SSL_read(tls->ssl, data, length);
switch (SSL_get_error(tls->ssl, status))
{
case SSL_ERROR_NONE:
break;
case SSL_ERROR_WANT_READ:
case SSL_ERROR_WANT_WRITE:
status = 0;
break;
default:
xrdp_tls_print_error("SSL_read", tls->ssl, status);
status = -1;
break;
}
return status;
}
/*****************************************************************************/
int APP_CC
xrdp_tls_write(struct xrdp_tls *tls, unsigned char *data, int length)
{
int status;
status = SSL_write(tls->ssl, data, length);
switch (SSL_get_error(tls->ssl, status))
{
case SSL_ERROR_NONE:
break;
case SSL_ERROR_WANT_READ:
case SSL_ERROR_WANT_WRITE:
status = 0;
break;
default:
xrdp_tls_print_error("SSL_write", tls->ssl, status);
status = -1;
break;
}
return status;
}
/*****************************************************************************/
int APP_CC
xrdp_tls_force_read_s(struct trans *self, struct stream *in_s, int size)
{
int rcvd;
if (self->status != TRANS_STATUS_UP)
{
return 1;
}
while (size > 0)
{
/* make sure stream has room */
if ((in_s->end + size) > (in_s->data + in_s->size))
{
return 1;
}
rcvd = xrdp_tls_read(self->tls, in_s->end, size);
if (rcvd == -1)
{
if (g_tcp_last_error_would_block(self->sck))
{
if (!g_tcp_can_recv(self->sck, 100))
{
/* check for term here */
if (self->is_term != 0)
{
if (self->is_term())
{
/* term */
self->status = TRANS_STATUS_DOWN;
return 1;
}
}
}
}
else
{
/* error */
self->status = TRANS_STATUS_DOWN;
return 1;
}
}
else if (rcvd == 0)
{
/* error */
self->status = TRANS_STATUS_DOWN;
return 1;
}
else
{
in_s->end += rcvd;
size -= rcvd;
}
}
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_tls_force_write_s(struct trans *self, struct stream *out_s)
{
int size;
int total;
int sent;
if (self->status != TRANS_STATUS_UP)
{
return 1;
}
size = (int) (out_s->end - out_s->data);
total = 0;
if (xrdp_tls_send_waiting(self, 1) != 0)
{
self->status = TRANS_STATUS_DOWN;
return 1;
}
while (total < size)
{
sent = xrdp_tls_write(self->tls, out_s->data + total, size - total);
if (sent == -1)
{
if (g_tcp_last_error_would_block(self->sck))
{
if (!g_tcp_can_send(self->sck, 100))
{
/* check for term here */
if (self->is_term != 0)
{
if (self->is_term())
{
/* term */
self->status = TRANS_STATUS_DOWN;
return 1;
}
}
}
}
else
{
/* error */
self->status = TRANS_STATUS_DOWN;
return 1;
}
}
else if (sent == 0)
{
/* error */
self->status = TRANS_STATUS_DOWN;
return 1;
}
else
{
total = total + sent;
}
}
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_tls_send_waiting(struct trans *self, int block)
{
struct stream *temp_s;
int bytes;
int sent;
int timeout;
int cont;
timeout = block ? 100 : 0;
cont = 1;
while (cont)
{
if (self->wait_s != 0)
{
temp_s = self->wait_s;
if (g_tcp_can_send(self->sck, timeout))
{
bytes = (int) (temp_s->end - temp_s->p);
sent = xrdp_tls_write(self->tls, temp_s->p, bytes);
if (sent > 0)
{
temp_s->p += sent;
if (temp_s->p >= temp_s->end)
{
self->wait_s = (struct stream *) (temp_s->next_packet);
free_stream(temp_s);
}
}
else if (sent == 0)
{
return 1;
}
else
{
if (!g_tcp_last_error_would_block(self->sck))
{
return 1;
}
}
}
}
else
{
break;
}
cont = block;
}
return 0;
}

@ -141,6 +141,7 @@ libxrdp_force_read(struct trans* trans)
s = trans->in_s;
init_stream(s, 32 * 1024);
if (trans_force_read(trans, 4) != 0)
{
g_writeln("libxrdp_force_read: error");
@ -157,6 +158,7 @@ libxrdp_force_read(struct trans* trans)
g_writeln("libxrdp_force_read: error");
return 0;
}
if (trans_force_read(trans, bytes - 4) != 0)
{
g_writeln("libxrdp_force_read: error");

@ -122,9 +122,7 @@ struct xrdp_sec
char pub_mod[256];
char pub_sig[64];
char pri_exp[256];
int rsa_key_bytes; /* 64 or 256 */
int channel_code;
int multimon;
int rsa_key_bytes; /* 64 or 256 , 0 = no rdp security */
char fips_encrypt_key[24];
char fips_decrypt_key[24];
char fips_sign_key[20];
@ -290,6 +288,7 @@ struct xrdp_mppc_enc
tui16 *hash_table;
};
int APP_CC
compress_rdp(struct xrdp_mppc_enc *enc, tui8 *srcData, int len);
struct xrdp_mppc_enc * APP_CC
@ -344,9 +343,8 @@ int APP_CC
xrdp_mcs_disconnect(struct xrdp_mcs *self);
/* xrdp_sec.c */
struct xrdp_sec * APP_CC
xrdp_sec_create(struct xrdp_rdp *owner, struct trans *trans, int crypt_level,
int channel_code, int multimon);
struct xrdp_sec *APP_CC
xrdp_sec_create(struct xrdp_rdp *owner, struct trans *trans);
void APP_CC
xrdp_sec_delete(struct xrdp_sec *self);
int APP_CC
@ -366,8 +364,6 @@ xrdp_sec_send(struct xrdp_sec *self, struct stream *s, int chan);
int APP_CC
xrdp_sec_process_mcs_data(struct xrdp_sec *self);
int APP_CC
xrdp_sec_out_mcs_data(struct xrdp_sec *self);
int APP_CC
xrdp_sec_incoming(struct xrdp_sec *self);
int APP_CC
xrdp_sec_disconnect(struct xrdp_sec *self);

@ -56,8 +56,6 @@ xrdp_iso_process_rdpNegReq(struct xrdp_iso *self, struct stream *s)
int flags;
int len;
DEBUG((" in xrdp_iso_process_neg_req"));
in_uint8(s, flags);
if (flags != 0x0 && flags != 0x8 && flags != 0x1)
{
@ -80,7 +78,6 @@ xrdp_iso_process_rdpNegReq(struct xrdp_iso *self, struct stream *s)
return 1;
}
DEBUG((" out xrdp_iso_process_rdpNegReq"));
return 0;
}
/*****************************************************************************/
@ -279,8 +276,7 @@ xrdp_iso_incoming(struct xrdp_iso *self)
self->rdpNegData = 1;
if (xrdp_iso_process_rdpNegReq(self, s) != 0)
{
g_writeln(
"xrdp_iso_incoming: xrdp_iso_process_rdpNegReq returned non zero");
g_writeln("xrdp_iso_incoming: xrdp_iso_process_rdpNegReq returned non zero");
return 1;
}
break;
@ -306,12 +302,10 @@ xrdp_iso_incoming(struct xrdp_iso *self)
}
}
int serverSecurityLayer = self->mcs_layer->sec_layer->rdp_layer->client_info.security_layer;
/* security layer negotiation */
if (self->rdpNegData)
{
int
serverSecurityLayer =
self->mcs_layer->sec_layer->rdp_layer->client_info.security_layer;
self->selectedProtocol = PROTOCOL_RDP; /* set default security layer */
switch (serverSecurityLayer)
@ -372,6 +366,11 @@ xrdp_iso_incoming(struct xrdp_iso *self)
self->failureCode = INCONSISTENT_FLAGS; //TODO: ?
}
}
else if (self->requestedProtocol != serverSecurityLayer)
{
/* enforce server security */
return 1;
}
/* set things for tls connection */

@ -706,7 +706,163 @@ xrdp_mcs_out_domain_params(struct xrdp_mcs *self, struct stream *s,
xrdp_mcs_ber_out_int8(self, s, 2);
return 0;
}
/*****************************************************************************/
/* prepare server gcc data to send in mcs response msg */
int APP_CC
xrdp_mcs_out_gcc_data(struct xrdp_sec *self)
{
struct stream *s;
int num_channels_even;
int num_channels;
int index;
int channel;
int gcc_size;
char* gcc_size_ptr;
char* ud_ptr;
num_channels = self->mcs_layer->channel_list->count;
num_channels_even = num_channels + (num_channels & 1);
s = &(self->server_mcs_data);
init_stream(s, 8192);
out_uint16_be(s, 5); /* AsnBerObjectIdentifier */
out_uint16_be(s, 0x14);
out_uint8(s, 0x7c);
out_uint16_be(s, 1); /* -- */
out_uint8(s, 0x2a); /* ConnectPDULen */
out_uint8(s, 0x14);
out_uint8(s, 0x76);
out_uint8(s, 0x0a);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 0);
out_uint16_le(s, 0xc001);
out_uint8(s, 0);
out_uint8(s, 0x4d); /* M */
out_uint8(s, 0x63); /* c */
out_uint8(s, 0x44); /* D */
out_uint8(s, 0x6e); /* n */
/* GCC Response Total Length - 2 bytes , set later */
gcc_size_ptr = s->p; /* RDPGCCUserDataResponseLength */
out_uint8s(s, 2);
ud_ptr = s->p; /* User Data */
out_uint16_le(s, SEC_TAG_SRV_INFO);
if (self->mcs_layer->iso_layer->rdpNegData)
{
out_uint16_le(s, 12); /* len */
}
else
{
out_uint16_le(s, 8); /* len */
}
out_uint8(s, 4); /* 4 = rdp5 1 = rdp4 */
out_uint8(s, 0);
out_uint8(s, 8);
out_uint8(s, 0);
if (self->mcs_layer->iso_layer->rdpNegData)
{
/* ReqeustedProtocol */
out_uint32_le(s, self->mcs_layer->iso_layer->requestedProtocol);
}
out_uint16_le(s, SEC_TAG_SRV_CHANNELS);
out_uint16_le(s, 8 + (num_channels_even * 2)); /* len */
out_uint16_le(s, MCS_GLOBAL_CHANNEL); /* 1003, 0x03eb main channel */
out_uint16_le(s, num_channels); /* number of other channels */
for (index = 0; index < num_channels_even; index++)
{
if (index < num_channels)
{
channel = MCS_GLOBAL_CHANNEL + (index + 1);
out_uint16_le(s, channel);
}
else
{
out_uint16_le(s, 0);
}
}
if (self->rsa_key_bytes == 64)
{
g_writeln("xrdp_sec_out_mcs_data: using 512 bit RSA key");
out_uint16_le(s, SEC_TAG_SRV_CRYPT);
out_uint16_le(s, 0x00ec); /* len is 236 */
out_uint32_le(s, self->crypt_method);
out_uint32_le(s, self->crypt_level);
out_uint32_le(s, 32); /* 32 bytes random len */
out_uint32_le(s, 0xb8); /* 184 bytes rsa info(certificate) len */
out_uint8a(s, self->server_random, 32);
/* here to end is certificate */
/* HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ */
/* TermService\Parameters\Certificate */
out_uint32_le(s, 1);
out_uint32_le(s, 1);
out_uint32_le(s, 1);
out_uint16_le(s, SEC_TAG_PUBKEY); /* 0x0006 */
out_uint16_le(s, 0x005c); /* 92 bytes length of SEC_TAG_PUBKEY */
out_uint32_le(s, SEC_RSA_MAGIC); /* 0x31415352 'RSA1' */
out_uint32_le(s, 0x0048); /* 72 bytes modulus len */
out_uint32_be(s, 0x00020000); /* bit len */
out_uint32_be(s, 0x3f000000); /* data len */
out_uint8a(s, self->pub_exp, 4); /* pub exp */
out_uint8a(s, self->pub_mod, 64); /* pub mod */
out_uint8s(s, 8); /* pad */
out_uint16_le(s, SEC_TAG_KEYSIG); /* 0x0008 */
out_uint16_le(s, 72); /* len */
out_uint8a(s, self->pub_sig, 64); /* pub sig */
out_uint8s(s, 8); /* pad */
}
else if (self->rsa_key_bytes == 256)
{
g_writeln("xrdp_sec_out_mcs_data: using 2048 bit RSA key");
out_uint16_le(s, SEC_TAG_SRV_CRYPT);
out_uint16_le(s, 0x01ac); /* len is 428 */
out_uint32_le(s, self->crypt_method);
out_uint32_le(s, self->crypt_level);
out_uint32_le(s, 32); /* 32 bytes random len */
out_uint32_le(s, 0x178); /* 376 bytes rsa info(certificate) len */
out_uint8a(s, self->server_random, 32);
/* here to end is certificate */
/* HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ */
/* TermService\Parameters\Certificate */
out_uint32_le(s, 1);
out_uint32_le(s, 1);
out_uint32_le(s, 1);
out_uint16_le(s, SEC_TAG_PUBKEY); /* 0x0006 */
out_uint16_le(s, 0x011c); /* 284 bytes length of SEC_TAG_PUBKEY */
out_uint32_le(s, SEC_RSA_MAGIC); /* 0x31415352 'RSA1' */
out_uint32_le(s, 0x0108); /* 264 bytes modulus len */
out_uint32_be(s, 0x00080000); /* bit len */
out_uint32_be(s, 0xff000000); /* data len */
out_uint8a(s, self->pub_exp, 4); /* pub exp */
out_uint8a(s, self->pub_mod, 256); /* pub mod */
out_uint8s(s, 8); /* pad */
out_uint16_le(s, SEC_TAG_KEYSIG); /* 0x0008 */
out_uint16_le(s, 72); /* len */
out_uint8a(s, self->pub_sig, 64); /* pub sig */
out_uint8s(s, 8); /* pad */
}
else if (self->rsa_key_bytes == 0) /* no security */
{
g_writeln("xrdp_sec_out_mcs_data: using no security");
out_uint16_le(s, SEC_TAG_SRV_CRYPT);
out_uint16_le(s, 12); /* len is 12 */
out_uint32_le(s, self->crypt_method);
out_uint32_le(s, self->crypt_level);
}
else
{
g_writeln("xrdp_sec_out_mcs_data: error");
}
/* end certificate */
s_mark_end(s);
gcc_size = (int)(s->end - ud_ptr) | 0x8000;
gcc_size_ptr[0] = gcc_size >> 8;
gcc_size_ptr[1] = gcc_size;
return 0;
}
/*****************************************************************************/
/* returns error */
static int APP_CC
@ -720,7 +876,9 @@ xrdp_mcs_send_connect_response(struct xrdp_mcs *self)
init_stream(s, 8192);
data_len = (int) (self->server_mcs_data->end - self->server_mcs_data->data);
xrdp_iso_init(self->iso_layer, s);
xrdp_mcs_ber_out_header(self, s, MCS_CONNECT_RESPONSE, data_len + 38);
//TODO: we should calculate the whole length include MCS_CONNECT_RESPONSE
xrdp_mcs_ber_out_header(self, s, MCS_CONNECT_RESPONSE,
data_len > 0x80 ? data_len + 38 : data_len + 36);
xrdp_mcs_ber_out_header(self, s, BER_TAG_RESULT, 1);
out_uint8(s, 0);
xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 1);
@ -748,13 +906,9 @@ xrdp_mcs_send_connect_response(struct xrdp_mcs *self)
int APP_CC
xrdp_mcs_incoming(struct xrdp_mcs *self)
{
int i;
DEBUG((" in xrdp_mcs_incoming"));
if (xrdp_iso_incoming(self->iso_layer) != 0)
{
return 1;
}
if (xrdp_mcs_recv_connect_initial(self) != 0)
{
return 1;
@ -766,8 +920,7 @@ xrdp_mcs_incoming(struct xrdp_mcs *self)
return 1;
}
/* in xrdp_sec.c */
if (xrdp_sec_out_mcs_data(self->sec_layer) != 0)
if (xrdp_mcs_out_gcc_data(self->sec_layer) != 0)
{
return 1;
}
@ -792,25 +945,18 @@ xrdp_mcs_incoming(struct xrdp_mcs *self)
return 1;
}
for (i = 0 ; i < self->channel_list->count + 2 ; i++)
{
if (xrdp_mcs_recv_cjrq(self) != 0)
{
return 1;
}
if (xrdp_mcs_send_cjcf(self, self->userid,
self->userid + MCS_USERCHANNEL_BASE) != 0)
self->userid + MCS_USERCHANNEL_BASE + i) != 0)
{
return 1;
}
if (xrdp_mcs_recv_cjrq(self) != 0)
{
return 1;
}
if (xrdp_mcs_send_cjcf(self, self->userid, MCS_GLOBAL_CHANNEL) != 0)
{
return 1;
}
DEBUG((" out xrdp_mcs_incoming"));
@ -939,6 +1085,7 @@ close_rdp_socket(struct xrdp_mcs *self)
{
if (self->iso_layer->trans != 0)
{
trans_shutdown_tls_mode(self->iso_layer->trans);
g_tcp_close(self->iso_layer->trans->sck);
self->iso_layer->trans->sck = 0 ;
g_writeln("xrdp_mcs_disconnect - socket closed");

@ -177,6 +177,38 @@ xrdp_rdp_read_config(struct xrdp_client_info *client_info)
client_info->security_layer = PROTOCOL_SSL | PROTOCOL_HYBRID | PROTOCOL_HYBRID_EX;
}
}
else if (g_strcasecmp(item, "certificate") == 0)
{
g_memset(client_info->certificate, 0, sizeof(char) * 1024);
if (value[0] != '/')
{
/* default certificate path */
g_snprintf(client_info->certificate, 1023, "%s/cert.pem", XRDP_CFG_PATH);
log_message(LOG_LEVEL_ALWAYS,"WARNING: Invalid x.509 certificate path defined, "
"default path will be used: %s", client_info->certificate);
}
else
{
/* use user defined certificate */
g_strncpy(client_info->certificate, value, 1023);
}
}
else if (g_strcasecmp(item, "key_file") == 0)
{
g_memset(client_info->key_file, 0, sizeof(char) * 1024);
if (value[0] != '/')
{
/* default key_file path */
g_snprintf(client_info->key_file, 1023, "%s/key.pem", XRDP_CFG_PATH);
log_message(LOG_LEVEL_ALWAYS,"WARNING: Invalid x.509 certificate path defined, "
"default path will be used: %s", client_info->key_file);
}
else
{
/* use user defined key_file */
g_strncpy(client_info->key_file, value, 1023);
}
}
}
@ -253,10 +285,7 @@ xrdp_rdp_create(struct xrdp_session *session, struct trans *trans)
/* read ini settings */
xrdp_rdp_read_config(&self->client_info);
/* create sec layer */
self->sec_layer = xrdp_sec_create(self, trans,
self->client_info.crypt_level,
self->client_info.channel_code,
self->client_info.multimon);
self->sec_layer = xrdp_sec_create(self, trans);
/* default 8 bit v1 color bitmap cache entries and size */
self->client_info.cache1_entries = 600;
self->client_info.cache1_size = 256;
@ -352,6 +381,15 @@ xrdp_rdp_recv(struct xrdp_rdp *self, struct stream *s, int *code)
chan = 0;
error = xrdp_sec_recv(self->sec_layer, s, &chan);
if (error == 3)
{
/* unencrypted confirm active msg arrived */
s->next_packet = 0;
*code = 3;
DEBUG(("out (0) xrdp_rdp_recv"));
return 0;
}
if (error == -1) /* special code for send demand active */
{
s->next_packet = 0;

@ -222,70 +222,29 @@ hex_str_to_bin(char *in, char *out, int out_len)
/*****************************************************************************/
struct xrdp_sec *APP_CC
xrdp_sec_create(struct xrdp_rdp *owner, struct trans *trans, int crypt_level,
int channel_code, int multimon)
xrdp_sec_create(struct xrdp_rdp *owner, struct trans *trans)
{
struct xrdp_sec *self;
DEBUG((" in xrdp_sec_create"));
self = (struct xrdp_sec *)g_malloc(sizeof(struct xrdp_sec), 1);
self = (struct xrdp_sec *) g_malloc(sizeof(struct xrdp_sec), 1);
self->rdp_layer = owner;
self->crypt_method = CRYPT_METHOD_NONE;
self->crypt_method = CRYPT_METHOD_NONE; /* set later */
self->crypt_level = CRYPT_LEVEL_NONE;
switch (crypt_level)
{
case 1: /* low */
self->crypt_method = CRYPT_METHOD_40BIT;
self->crypt_level = CRYPT_LEVEL_LOW;
break;
case 2: /* medium */
self->crypt_method = CRYPT_METHOD_40BIT;
self->crypt_level = CRYPT_LEVEL_CLIENT_COMPATIBLE;
break;
case 3: /* high */
self->crypt_method = CRYPT_METHOD_128BIT;
self->crypt_level = CRYPT_LEVEL_HIGH;
break;
case 4: /* fips */
self->crypt_method = CRYPT_METHOD_FIPS;
self->crypt_level = CRYPT_LEVEL_FIPS;
break;
default:
g_writeln("Fatal : Illegal crypt_level");
break ;
}
self->channel_code = channel_code;
self->multimon = multimon;
if (self->decrypt_rc4_info != NULL)
{
g_writeln("xrdp_sec_create - decrypt_rc4_info already created !!!");
}
self->decrypt_rc4_info = ssl_rc4_info_create();
if (self->encrypt_rc4_info != NULL)
{
g_writeln("xrdp_sec_create - encrypt_rc4_info already created !!!");
}
self->encrypt_rc4_info = ssl_rc4_info_create();
self->mcs_layer = xrdp_mcs_create(self, trans,
&(self->client_mcs_data),
self->mcs_layer = xrdp_mcs_create(self, trans, &(self->client_mcs_data),
&(self->server_mcs_data));
self->fastpath_layer = xrdp_fastpath_create(self, trans);
self->chan_layer = xrdp_channel_create(self, self->mcs_layer);
DEBUG((" out xrdp_sec_create"));
return self;
}
/*****************************************************************************/
void APP_CC
xrdp_sec_delete(struct xrdp_sec *self)
{
if (self == 0)
{
xrdp_sec_delete(struct xrdp_sec *self) {
if (self == 0) {
g_writeln("xrdp_sec_delete: indata is null");
return;
}
@ -325,7 +284,7 @@ xrdp_sec_init(struct xrdp_sec *self, struct stream *s)
}
else
{
s_push_layer(s, sec_hdr, 4);
// s_push_layer(s, sec_hdr, 4);
}
return 0;
@ -1042,6 +1001,21 @@ xrdp_sec_recv(struct xrdp_sec *self, struct stream *s, int *chan)
{
return 1;
}
/* TODO: HACK, we should recognize packets without security header
However, client info packet and license packet always have security header. */
if (s->data[17] == 0x13) /* confirm active pdu */
{
g_writeln("CONFIRM ACTIVE ARRIVED");
return 0;
}
if (s->data[17] == 0x17 || s->data[16] == 0x17) /* rdp data pdu */
{
g_writeln("RDP DATA ARRIVED");
return 0;
}
in_uint32_le(s, flags);
DEBUG((" in xrdp_sec_recv flags $%x", flags));
@ -1066,7 +1040,7 @@ xrdp_sec_recv(struct xrdp_sec *self, struct stream *s, int *chan)
xrdp_sec_fips_decrypt(self, s->p, (int)(s->end - s->p));
s->end -= pad;
}
else
else if (self->crypt_level > CRYPT_LEVEL_NONE)
{
if (!s_check_rem(s, 8))
{
@ -1253,7 +1227,7 @@ xrdp_sec_send(struct xrdp_sec *self, struct stream *s, int chan)
}
else
{
out_uint32_le(s, 0);
// out_uint32_le(s, 0);
}
if (xrdp_mcs_send(self->mcs_layer, s, chan) != 0)
@ -1616,11 +1590,16 @@ xrdp_sec_process_mcs_data_channels(struct xrdp_sec *self, struct stream *s)
{
int num_channels;
int index;
struct mcs_channel_item *channel_item;
struct xrdp_client_info *client_info = (struct xrdp_client_info *)NULL;
client_info = &(self->rdp_layer->client_info);
DEBUG(("processing channels, channel_code is %d", self->channel_code));
DEBUG(("processing channels, channel_code is %d", client_info->channel_code));
/* this is an option set in xrdp.ini */
if (self->channel_code != 1) /* are channels on? */
if (client_info->channel_code != 1) /* are channels on? */
{
g_writeln("Processing channel data from client - The channel is off");
return 0;
@ -1672,9 +1651,9 @@ xrdp_sec_process_mcs_data_monitors(struct xrdp_sec *self, struct stream *s)
client_info = &(self->rdp_layer->client_info);
DEBUG(("processing monitors data, allow_multimon is %d", self->multimon));
DEBUG(("processing monitors data, allow_multimon is %d", client_info->multimon));
/* this is an option set in xrdp.ini */
if (self->multimon != 1) /* are multi-monitors allowed ? */
if (client_info->multimon != 1) /* are multi-monitors allowed ? */
{
DEBUG(("[INFO] xrdp_sec_process_mcs_data_monitors: multimon is not "
"allowed, skipping"));
@ -1815,156 +1794,6 @@ xrdp_sec_process_mcs_data(struct xrdp_sec *self)
return 0;
}
/*****************************************************************************/
/* prepare server mcs data to send in mcs layer */
int APP_CC
xrdp_sec_out_mcs_data(struct xrdp_sec *self)
{
struct stream *s;
int num_channels_even;
int num_channels;
int index;
int channel;
int gcc_size;
char* gcc_size_ptr;
char* ud_ptr;
num_channels = self->mcs_layer->channel_list->count;
num_channels_even = num_channels + (num_channels & 1);
s = &(self->server_mcs_data);
init_stream(s, 8192);
out_uint16_be(s, 5);
out_uint16_be(s, 0x14);
out_uint8(s, 0x7c);
out_uint16_be(s, 1);
out_uint8(s, 0x2a);
out_uint8(s, 0x14);
out_uint8(s, 0x76);
out_uint8(s, 0x0a);
out_uint8(s, 1);
out_uint8(s, 1);
out_uint8(s, 0);
out_uint16_le(s, 0xc001);
out_uint8(s, 0);
out_uint8(s, 0x4d); /* M */
out_uint8(s, 0x63); /* c */
out_uint8(s, 0x44); /* D */
out_uint8(s, 0x6e); /* n */
/* GCC Response Total Length - 2 bytes , set later */
gcc_size_ptr = s->p; /* RDPGCCUserDataResponseLength */
out_uint8s(s, 2);
ud_ptr = s->p; /* User Data */
out_uint16_le(s, SEC_TAG_SRV_INFO);
if (self->mcs_layer->iso_layer->selectedProtocol != -1)
{
out_uint16_le(s, 12); /* len */
}
else
{
out_uint16_le(s, 8); /* len */
}
out_uint8(s, 4); /* 4 = rdp5 1 = rdp4 */
out_uint8(s, 0);
out_uint8(s, 8);
out_uint8(s, 0);
if (self->mcs_layer->iso_layer->selectedProtocol != -1)
{
/* ReqeustedProtocol */
out_uint32_le(s, self->mcs_layer->iso_layer->selectedProtocol);
}
out_uint16_le(s, SEC_TAG_SRV_CHANNELS);
out_uint16_le(s, 8 + (num_channels_even * 2)); /* len */
out_uint16_le(s, MCS_GLOBAL_CHANNEL); /* 1003, 0x03eb main channel */
out_uint16_le(s, num_channels); /* number of other channels */
for (index = 0; index < num_channels_even; index++)
{
if (index < num_channels)
{
channel = MCS_GLOBAL_CHANNEL + (index + 1);
out_uint16_le(s, channel);
}
else
{
out_uint16_le(s, 0);
}
}
if (self->rsa_key_bytes == 64)
{
g_writeln("xrdp_sec_out_mcs_data: using 512 bit RSA key");
out_uint16_le(s, SEC_TAG_SRV_CRYPT);
out_uint16_le(s, 0x00ec); /* len is 236 */
out_uint32_le(s, self->crypt_method);
out_uint32_le(s, self->crypt_level);
out_uint32_le(s, 32); /* 32 bytes random len */
out_uint32_le(s, 0xb8); /* 184 bytes rsa info(certificate) len */
out_uint8a(s, self->server_random, 32);
/* here to end is certificate */
/* HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ */
/* TermService\Parameters\Certificate */
out_uint32_le(s, 1);
out_uint32_le(s, 1);
out_uint32_le(s, 1);
out_uint16_le(s, SEC_TAG_PUBKEY); /* 0x0006 */
out_uint16_le(s, 0x005c); /* 92 bytes length of SEC_TAG_PUBKEY */
out_uint32_le(s, SEC_RSA_MAGIC); /* 0x31415352 'RSA1' */
out_uint32_le(s, 0x0048); /* 72 bytes modulus len */
out_uint32_be(s, 0x00020000); /* bit len */
out_uint32_be(s, 0x3f000000); /* data len */
out_uint8a(s, self->pub_exp, 4); /* pub exp */
out_uint8a(s, self->pub_mod, 64); /* pub mod */
out_uint8s(s, 8); /* pad */
out_uint16_le(s, SEC_TAG_KEYSIG); /* 0x0008 */
out_uint16_le(s, 72); /* len */
out_uint8a(s, self->pub_sig, 64); /* pub sig */
out_uint8s(s, 8); /* pad */
}
else if (self->rsa_key_bytes == 256)
{
g_writeln("xrdp_sec_out_mcs_data: using 2048 bit RSA key");
out_uint16_le(s, SEC_TAG_SRV_CRYPT);
out_uint16_le(s, 0x01ac); /* len is 428 */
out_uint32_le(s, self->crypt_method);
out_uint32_le(s, self->crypt_level);
out_uint32_le(s, 32); /* 32 bytes random len */
out_uint32_le(s, 0x178); /* 376 bytes rsa info(certificate) len */
out_uint8a(s, self->server_random, 32);
/* here to end is certificate */
/* HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ */
/* TermService\Parameters\Certificate */
out_uint32_le(s, 1);
out_uint32_le(s, 1);
out_uint32_le(s, 1);
out_uint16_le(s, SEC_TAG_PUBKEY); /* 0x0006 */
out_uint16_le(s, 0x011c); /* 284 bytes length of SEC_TAG_PUBKEY */
out_uint32_le(s, SEC_RSA_MAGIC); /* 0x31415352 'RSA1' */
out_uint32_le(s, 0x0108); /* 264 bytes modulus len */
out_uint32_be(s, 0x00080000); /* bit len */
out_uint32_be(s, 0xff000000); /* data len */
out_uint8a(s, self->pub_exp, 4); /* pub exp */
out_uint8a(s, self->pub_mod, 256); /* pub mod */
out_uint8s(s, 8); /* pad */
out_uint16_le(s, SEC_TAG_KEYSIG); /* 0x0008 */
out_uint16_le(s, 72); /* len */
out_uint8a(s, self->pub_sig, 64); /* pub sig */
out_uint8s(s, 8); /* pad */
}
else
{
LLOGLN(0, ("xrdp_sec_out_mcs_data: error"));
}
/* end certificate */
s_mark_end(s);
gcc_size = (int)(s->end - ud_ptr) | 0x8000;
gcc_size_ptr[0] = gcc_size >> 8;
gcc_size_ptr[1] = gcc_size;
return 0;
}
/*****************************************************************************/
/* process the mcs client data we received from the mcs layer */
static int APP_CC
@ -2028,19 +1857,106 @@ xrdp_sec_in_mcs_data(struct xrdp_sec *self)
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
xrdp_sec_init_rdp_security(struct xrdp_sec *self)
{
switch (self->rdp_layer->client_info.crypt_level)
{
case 1: /* low */
self->crypt_method = CRYPT_METHOD_40BIT;
self->crypt_level = CRYPT_LEVEL_LOW;
break;
case 2: /* medium */
self->crypt_method = CRYPT_METHOD_40BIT;
self->crypt_level = CRYPT_LEVEL_CLIENT_COMPATIBLE;
break;
case 3: /* high */
self->crypt_method = CRYPT_METHOD_128BIT;
self->crypt_level = CRYPT_LEVEL_HIGH;
break;
case 4: /* fips */
self->crypt_method = CRYPT_METHOD_FIPS;
self->crypt_level = CRYPT_LEVEL_FIPS;
break;
default:
g_writeln("Fatal : Illegal crypt_level");
break ;
}
if (self->decrypt_rc4_info != NULL)
{
g_writeln("xrdp_sec_init_rdp_security: decrypt_rc4_info already created !!!");
}
else
{
self->decrypt_rc4_info = ssl_rc4_info_create();
}
if (self->encrypt_rc4_info != NULL)
{
g_writeln("xrdp_sec_init_rdp_security: encrypt_rc4_info already created !!!");
}
else
{
self->encrypt_rc4_info = ssl_rc4_info_create();
}
return 0;
}
/*****************************************************************************/
int APP_CC
xrdp_sec_incoming(struct xrdp_sec *self)
{
struct list *items = NULL;
struct list *values = NULL;
struct xrdp_iso *iso;
int index = 0;
char *item = NULL;
char *value = NULL;
char key_file[256];
DEBUG((" in xrdp_sec_incoming:"));
iso = self->mcs_layer->iso_layer;
/* negotiate security layer */
if (xrdp_iso_incoming(iso) != 0)
{
DEBUG(("xrdp_sec_incoming: xrdp_iso_incoming failed"));
return 1;
}
/* initialize selected security layer */
if (iso->requestedProtocol > PROTOCOL_RDP)
{
/* init tls security */
DEBUG((" in xrdp_sec_incoming: init tls security"));
if (trans_set_tls_mode(self->mcs_layer->iso_layer->trans,
self->rdp_layer->client_info.key_file,
self->rdp_layer->client_info.certificate) != 0)
{
g_writeln("xrdp_sec_incoming: trans_set_tls_mode failed");
return 1;
}
self->crypt_level = CRYPT_LEVEL_NONE;
self->crypt_method = CRYPT_METHOD_NONE;
self->rsa_key_bytes = 0;
}
else
{
/* init rdp security */
DEBUG((" in xrdp_sec_incoming: init rdp security"));
if (xrdp_sec_init_rdp_security(self) != 0)
{
DEBUG(("xrdp_sec_incoming: xrdp_sec_init_rdp_security failed"));
return 1;
}
g_memset(key_file, 0, sizeof(char) * 256);
DEBUG((" in xrdp_sec_incoming"));
g_random(self->server_random, 32);
items = list_create();
items->auto_free = 1;
@ -2087,7 +2003,9 @@ xrdp_sec_incoming(struct xrdp_sec *self)
list_delete(items);
list_delete(values);
}
/* negotiate mcs layer */
if (xrdp_mcs_incoming(self->mcs_layer) != 0)
{
return 1;
@ -2106,6 +2024,7 @@ xrdp_sec_incoming(struct xrdp_sec *self)
{
return 1;
}
LLOGLN(10, ("xrdp_sec_incoming: out"));
return 0;
}

@ -5,11 +5,17 @@ ini_version=1
bitmap_cache=yes
bitmap_compression=yes
port=3389
crypt_level=high
security_layer=rdp
allow_channels=true
max_bpp=32
fork=yes
crypt_level=high
# security layer can be 'tls', 'rdp' or 'negotiate'
# for client compatible layer
security_layer=rdp
# X.509 certificate and private key
# openssl req -x509 -newkey rsa:2048 -nodes -keyout key.pem -out cert.pem -days 365
certificate=
key_file=
# regulate if the listening socket use socket option tcp_nodelay
# no buffering will be performed in the TCP stack

@ -171,7 +171,6 @@ xrdp_process_data_in(struct trans *self)
pro->server_trans->extra_flags = 1;
break;
}
return 0;
}

Loading…
Cancel
Save