licence.c File Reference

#include "precomp.h"

Include dependency graph for licence.c:

Go to the source code of this file.

Functions
void *	rdssl_rc4_info_create (void)
void	rdssl_rc4_info_delete (void *rc4_info)
void	rdssl_rc4_set_key (void *rc4_info, char *key, int len)
void	rdssl_rc4_crypt (void *rc4_info, char *in_data, char *out_data, int len)
int	rdssl_mod_exp (char *out, int out_len, char *in, int in_len, char *mod, int mod_len, char *exp, int exp_len)
static void	licence_generate_keys (uint8 *client_random, uint8 *server_random, uint8 *pre_master_secret)
static void	licence_generate_hwid (uint8 *hwid)
static void	licence_info (uint8 *client_random, uint8 *rsa_data, uint8 *licence_data, int licence_size, uint8 *hwid, uint8 *signature)
static void	licence_send_new_licence_request (uint8 *client_random, uint8 *rsa_data, char *user, char *host)
static void	licence_process_request (STREAM s)
static void	licence_send_platform_challenge_response (uint8 *token, uint8 *crypt_hwid, uint8 *signature)
static RD_BOOL	licence_parse_platform_challenge (STREAM s, uint8 **token, uint8 **signature)
static void	licence_process_platform_challenge (STREAM s)
static void	licence_process_new_license (STREAM s)
void	licence_process_error_alert (STREAM s)
void	licence_process (STREAM s)

Variables
char	g_username [256]
char	g_hostname [256]
RDP_VERSION	g_rdp_version
static uint8	g_licence_key [16]
static uint8	g_licence_sign_key [16]
RD_BOOL	g_licence_issued = False
RD_BOOL	g_licence_error_result = False

Function Documentation

licence_generate_hwid()

static void licence_generate_hwid ( uint8 *  hwid )

static

Definition at line 66 of file licence.c.

Referenced by licence_process_platform_challenge(), and licence_process_request().

{
    buf_out_uint32(hwid, 2);
    strncpy((char *) (hwid + 4), g_hostname, LICENCE_HWID_SIZE - 4);
}

licence_generate_keys()

static void licence_generate_keys ( uint8 *  client_random, uint8 *  server_random, uint8 *  pre_master_secret  )

static

Definition at line 49 of file licence.c.

Referenced by licence_process_request().

{
    uint8 master_secret[48];
    uint8 key_block[48];

    /* Generate master secret and then key material */
    sec_hash_48(master_secret, pre_master_secret, client_random, server_random, 'A');
    sec_hash_48(key_block, master_secret, server_random, client_random, 'A');

    /* Store first 16 bytes of session key as MAC secret */
    memcpy(g_licence_sign_key, key_block, 16);

    /* Generate RC4 key from next 16 bytes */
    sec_hash_16(g_licence_key, &key_block[16], client_random, server_random);
}

licence_info()

static void licence_info ( uint8 *  client_random, uint8 *  rsa_data, uint8 *  licence_data, int  licence_size, uint8 *  hwid, uint8 *  signature  )

static

Definition at line 74 of file licence.c.

Referenced by licence_process_request().

{
    uint32 sec_flags = SEC_LICENSE_PKT;
    uint16 length =
        24 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE +
        licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;
    STREAM s;

    s = sec_init(sec_flags, length + 2);

    out_uint8(s, LICENCE_TAG_LICENCE_INFO);
    out_uint8(s, ((g_rdp_version >= RDP_V5) ? 3 : 2));  /* version */
    out_uint16_le(s, length);

    out_uint32_le(s, 1);
    out_uint16(s, 0);
    out_uint16_le(s, 0x0201);

    out_uint8p(s, client_random, SEC_RANDOM_SIZE);
    out_uint16_le(s, 2);
    out_uint16_le(s, (SEC_MODULUS_SIZE + SEC_PADDING_SIZE));
    out_uint8p(s, rsa_data, SEC_MODULUS_SIZE);
    out_uint8s(s, SEC_PADDING_SIZE);

    out_uint16_le(s, 1);
    out_uint16_le(s, licence_size);
    out_uint8p(s, licence_data, licence_size);

    out_uint16_le(s, 1);
    out_uint16_le(s, LICENCE_HWID_SIZE);
    out_uint8p(s, hwid, LICENCE_HWID_SIZE);

    out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);

    s_mark_end(s);
    sec_send(s, sec_flags);
}

licence_parse_platform_challenge()

static RD_BOOL licence_parse_platform_challenge ( STREAM  s, uint8 **  token, uint8 **  signature  )

static

Definition at line 232 of file licence.c.

Referenced by licence_process_platform_challenge().

{
    uint16 tokenlen;

    in_uint8s(s, 6);    /* unknown: f8 3d 15 00 04 f6 */

    in_uint16_le(s, tokenlen);
    if (tokenlen != LICENCE_TOKEN_SIZE)
    {
        error("token len %d\n", tokenlen);
        return False;
    }

    in_uint8p(s, *token, tokenlen);
    in_uint8p(s, *signature, LICENCE_SIGNATURE_SIZE);

    return s_check_end(s);
}

licence_process()

void licence_process

(

STREAM

s

)

Definition at line 378 of file licence.c.

Referenced by sec_recv().

{
    uint8 tag;

    in_uint8(s, tag);
    in_uint8s(s, 3);    /* version, length */

#if WITH_DEBUG
    DEBUG(("Received licensing PDU (message type 0x%02x)\n", tag));
#endif

    switch (tag)
    {
        case LICENCE_TAG_REQUEST:
            licence_process_request(s);
            break;

        case LICENCE_TAG_PLATFORM_CHALLANGE:
            licence_process_platform_challenge(s);
            break;

        case LICENCE_TAG_NEW_LICENCE:
        case LICENCE_TAG_UPGRADE_LICENCE:
            /* we can handle new and upgrades of licences the same way. */
            licence_process_new_license(s);
            break;

        case LICENCE_TAG_ERROR_ALERT:
            licence_process_error_alert(s);
            break;

        default:
            unimpl("licence tag 0x%02x\n", tag);
    }
}

licence_process_error_alert()

void licence_process_error_alert

(

STREAM

s

)

Definition at line 324 of file licence.c.

Referenced by licence_process().

{
    uint32 error_code;
    uint32 state_transition;
    uint32 error_info;
    in_uint32(s, error_code);
    in_uint32(s, state_transition);
    in_uint32(s, error_info);

    /* There is a special case in the error alert handling, when licensing is all good
       and the server is not sending a license to client, a "Server License Error PDU -
       Valid Client" packet is sent which means, every thing is ok.

       Therefor we should flag that everything is ok with license here.
     */
    if (error_code == 0x07)
    {
        g_licence_issued = True;
        return;
    }

    /* handle error codes, for now, just report them */
    switch (error_code)
    {
        case 0x6:   // ERR_NO_LICENSE_SERVER
            warning("License error alert from server: No license server\n");
            break;

        case 0x8:   // ERR_INVALID_CLIENT
            warning("License error alert from server: Invalid client\n");
            break;

        case 0x4:   // ERR_INVALID_SCOPE
        case 0xb:   // ERR_INVALID_PRODUCTID
        case 0xc:   // ERR_INVALID_MESSAGE_LENGTH
        default:
            warning("License error alert from server: code %u, state transition %u\n",
                error_code, state_transition);
            break;
    }

    /* handle error codes, for now, just report them */
    switch (error_info)
    {
        default:
            break;
    }

    g_licence_error_result = True;
}

licence_process_new_license()

static void licence_process_new_license ( STREAM  s )

static

Definition at line 288 of file licence.c.

Referenced by licence_process().

{
    void * crypt_key;
    uint32 length;
    int i;

    in_uint8s(s, 2);    // Skip license binary blob type
    in_uint16_le(s, length);
    if (!s_check_rem(s, length))
        return;

    crypt_key = rdssl_rc4_info_create();
    rdssl_rc4_set_key(crypt_key, (char *)g_licence_key, 16);
    rdssl_rc4_crypt(crypt_key, (char *)s->p, (char *)s->p, length);
    rdssl_rc4_info_delete(crypt_key);

    /* Parse NEW_LICENSE_INFO block */
    in_uint8s(s, 4);    // skip dwVersion

    /* Skip strings, Scope, CompanyName and ProductId to get
       to the LicenseInfo which we store in license blob. */
    length = 0;
    for (i = 0; i < 4; i++)
    {
        in_uint8s(s, length);
        in_uint32_le(s, length);
        if (!s_check_rem(s, length))
            return;
    }

    g_licence_issued = True;
    save_licence(s->p, length);
}

licence_process_platform_challenge()

static void licence_process_platform_challenge ( STREAM  s )

static

Definition at line 253 of file licence.c.

Referenced by licence_process().

{
    uint8 *in_token = NULL, *in_sig;
    uint8 out_token[LICENCE_TOKEN_SIZE], decrypt_token[LICENCE_TOKEN_SIZE];
    uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];
    uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];
    uint8 out_sig[LICENCE_SIGNATURE_SIZE];
    void * crypt_key;

    /* Parse incoming packet and save the encrypted token */
    licence_parse_platform_challenge(s, &in_token, &in_sig);
    memcpy(out_token, in_token, LICENCE_TOKEN_SIZE);

    /* Decrypt the token. It should read TEST in Unicode. */
    crypt_key = rdssl_rc4_info_create();
    rdssl_rc4_set_key(crypt_key, (char *)g_licence_key, 16);
    rdssl_rc4_crypt(crypt_key, (char *)in_token, (char *)decrypt_token, LICENCE_TOKEN_SIZE);
    rdssl_rc4_info_delete(crypt_key);
    
    /* Generate a signature for a buffer of token and HWID */
    licence_generate_hwid(hwid);
    memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);
    memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);
    sec_sign(out_sig, 16, g_licence_sign_key, 16, sealed_buffer, sizeof(sealed_buffer));

    /* Now encrypt the HWID */
    crypt_key = rdssl_rc4_info_create();
    rdssl_rc4_set_key(crypt_key, (char *)g_licence_key, 16);
    rdssl_rc4_crypt(crypt_key, (char *)hwid, (char *)crypt_hwid, LICENCE_HWID_SIZE);

    licence_send_platform_challenge_response(out_token, crypt_hwid, out_sig);
}

licence_process_request()

static void licence_process_request ( STREAM  s )

static

Definition at line 156 of file licence.c.

Referenced by licence_process().

{
    uint8 null_data[SEC_MODULUS_SIZE];
    uint8 *server_random;
    uint8 signature[LICENCE_SIGNATURE_SIZE];
    uint8 hwid[LICENCE_HWID_SIZE];
    uint8 *licence_data;
    int licence_size;
    void * crypt_key;

    /* Retrieve the server random from the incoming packet */
    in_uint8p(s, server_random, SEC_RANDOM_SIZE);

    /* We currently use null client keys. This is a bit naughty but, hey,
       the security of licence negotiation isn't exactly paramount. */
    memset(null_data, 0, sizeof(null_data));
    licence_generate_keys(null_data, server_random, null_data);

    licence_size = load_licence(&licence_data);
    if (licence_size > 0)
    {
        /* Generate a signature for the HWID buffer */
        licence_generate_hwid(hwid);
        sec_sign(signature, 16, g_licence_sign_key, 16, hwid, sizeof(hwid));

        /* Now encrypt the HWID */
        crypt_key = rdssl_rc4_info_create();
        rdssl_rc4_set_key(crypt_key, (char *)g_licence_key, 16);
        rdssl_rc4_crypt(crypt_key, (char *)hwid, (char *)hwid, sizeof(hwid));
        rdssl_rc4_info_delete(crypt_key);

#if WITH_DEBUG
        DEBUG(("Sending licensing PDU (message type 0x%02x)\n", LICENCE_TAG_LICENCE_INFO));
#endif
        licence_info(null_data, null_data, licence_data, licence_size, hwid, signature);

        xfree(licence_data);
        return;
    }

#if WITH_DEBUG
    DEBUG(("Sending licensing PDU (message type 0x%02x)\n", LICENCE_TAG_NEW_LICENCE_REQUEST));
#endif
    licence_send_new_licence_request(null_data, null_data, g_username, g_hostname);
}

licence_send_new_licence_request()

static void licence_send_new_licence_request ( uint8 *  client_random, uint8 *  rsa_data, char *  user, char *  host  )

static

Definition at line 115 of file licence.c.

Referenced by licence_process_request().

{
    uint32 sec_flags = SEC_LICENSE_PKT;
    uint16 userlen = strlen(user) + 1;
    uint16 hostlen = strlen(host) + 1;
    uint16 length =
        24 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE + userlen + hostlen;
    STREAM s;

    s = sec_init(sec_flags, length + 2);

    out_uint8(s, LICENCE_TAG_NEW_LICENCE_REQUEST);
    out_uint8(s, ((g_rdp_version >= RDP_V5) ? 3 : 2));  /* version */
    out_uint16_le(s, length);

    out_uint32_le(s, 1);    // KEY_EXCHANGE_ALG_RSA
    out_uint16(s, 0);
    out_uint16_le(s, 0xff01);

    out_uint8p(s, client_random, SEC_RANDOM_SIZE);
    out_uint16_le(s, 2);
    out_uint16_le(s, (SEC_MODULUS_SIZE + SEC_PADDING_SIZE));
    out_uint8p(s, rsa_data, SEC_MODULUS_SIZE);
    out_uint8s(s, SEC_PADDING_SIZE);

    /* Username LICENSE_BINARY_BLOB */
    out_uint16_le(s, BB_CLIENT_USER_NAME_BLOB);
    out_uint16_le(s, userlen);
    out_uint8p(s, user, userlen);

    /* Machinename LICENSE_BINARY_BLOB */
    out_uint16_le(s, BB_CLIENT_MACHINE_NAME_BLOB);
    out_uint16_le(s, hostlen);
    out_uint8p(s, host, hostlen);

    s_mark_end(s);
    sec_send(s, sec_flags);
}

licence_send_platform_challenge_response()

static void licence_send_platform_challenge_response ( uint8 *  token, uint8 *  crypt_hwid, uint8 *  signature  )

static

Definition at line 204 of file licence.c.

Referenced by licence_process_platform_challenge().

{
    uint32 sec_flags = SEC_LICENSE_PKT;
    uint16 length = 58;
    STREAM s;

    s = sec_init(sec_flags, length + 2);

    out_uint8(s, LICENCE_TAG_PLATFORM_CHALLANGE_RESPONSE);
    out_uint8(s, ((g_rdp_version >= RDP_V5) ? 3 : 2));  /* version */
    out_uint16_le(s, length);

    out_uint16_le(s, 1);
    out_uint16_le(s, LICENCE_TOKEN_SIZE);
    out_uint8p(s, token, LICENCE_TOKEN_SIZE);

    out_uint16_le(s, 1);
    out_uint16_le(s, LICENCE_HWID_SIZE);
    out_uint8p(s, crypt_hwid, LICENCE_HWID_SIZE);

    out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);

    s_mark_end(s);
    sec_send(s, sec_flags);
}

rdssl_mod_exp()

int rdssl_mod_exp	(	char *	out,
		int	out_len,
		char *	in,
		int	in_len,
		char *	mod,
		int	mod_len,
		char *	exp,
		int	exp_len
	)

Definition at line 1485 of file ssl_calls.c.

{
  /* Computes y = x ^ e mod m */
  /* Binary left-to-right method */
  DIGIT_T mask;
  DIGIT_T* e;
  DIGIT_T* x;
  DIGIT_T* y;
  DIGIT_T* m;
  unsigned int n;
  int max_size;
  char* l_out;
  char* l_in;
  char* l_mod;
  char* l_exp;

  if (in_len > out_len || in_len == 0 ||
      out_len == 0 || mod_len == 0 || exp_len == 0)
  {
    return 0;
  }
  max_size = out_len;
  if (in_len > max_size)
  {
    max_size = in_len;
  }
  if (mod_len > max_size)
  {
    max_size = mod_len;
  }
  if (exp_len > max_size)
  {
    max_size = exp_len;
  }
  l_out = (char*)g_malloc(max_size, 1);
  l_in = (char*)g_malloc(max_size, 1);
  l_mod = (char*)g_malloc(max_size, 1);
  l_exp = (char*)g_malloc(max_size, 1);
  memcpy(l_in, in, in_len);
  memcpy(l_mod, mod, mod_len);
  memcpy(l_exp, exp, exp_len);
  e = (DIGIT_T*)l_exp;
  x = (DIGIT_T*)l_in;
  y = (DIGIT_T*)l_out;
  m = (DIGIT_T*)l_mod;
  /* Find second-most significant bit in e */
  n = mpSizeof(e, max_size / 4);
  for (mask = HIBITMASK; mask > 0; mask >>= 1)
  {
    if (e[n - 1] & mask)
    {
      break;
    }
  }
  mpNEXTBITMASK(mask, n);
  /* Set y = x */
  mpSetEqual(y, x, max_size / 4);
  /* For bit j = k - 2 downto 0 step -1 */
  while (n)
  {
    mpModMult(y, y, y, m, max_size / 4); /* Square */
    if (e[n - 1] & mask)
    {
      mpModMult(y, y, x, m, max_size / 4); /* Multiply */
    }
    /* Move to next bit */
    mpNEXTBITMASK(mask, n);
  }
  memcpy(out, l_out, out_len);
  g_free(l_out);
  g_free(l_in);
  g_free(l_mod);
  g_free(l_exp);
  return out_len;
}

rdssl_rc4_crypt()

void rdssl_rc4_crypt	(	void *	rc4_info,
		char *	in_data,
		char *	out_data,
		int	len
	)

Definition at line 173 of file ssl_calls.c.

Referenced by licence_process_new_license(), licence_process_platform_challenge(), and licence_process_request().

{
    struct rc4_state *info = rc4_info;
    BOOL ret;
    DWORD dwErr;
    BYTE * intermediate_data;
    DWORD dwLen = len;
    if (!rc4_info || !in_data || !out_data || !len || !info->hKey)
    {
        error("rdssl_rc4_crypt %p %p %p %d\n", rc4_info, in_data, out_data, len);
        return;
    }
    intermediate_data = g_malloc(len, 0);
    if (!intermediate_data)
    {
        error("rdssl_rc4_set_key no memory\n");
        return;
    }
    memcpy(intermediate_data, in_data, len);
    ret = CryptEncrypt(info->hKey,
                       0,
                       FALSE,
                       0,
                       intermediate_data,
                       &dwLen,
                       dwLen);
    if (!ret)
    {
        dwErr = GetLastError();
        g_free(intermediate_data);
        error("CryptEncrypt failed with %lx\n", dwErr);
        return;
    }
    memcpy(out_data, intermediate_data, len);
    g_free(intermediate_data);
}

rdssl_rc4_info_create()

void* rdssl_rc4_info_create

(

void

)

Definition at line 51 of file ssl_calls.c.

Referenced by licence_process_new_license(), licence_process_platform_challenge(), and licence_process_request().

{
    struct rc4_state *info = g_malloc(sizeof(struct rc4_state), 1);
    BOOL ret;
    DWORD dwErr;
    if (!info)
    {
        error("rdssl_rc4_info_create no memory\n");
        return NULL;
    }
    ret = CryptAcquireContext(&info->hCryptProv,
                              L"MSTSC",
                              MS_ENHANCED_PROV,
                              PROV_RSA_FULL,
                              0);
    if (!ret)
    {
        dwErr = GetLastError();
        if (dwErr == NTE_BAD_KEYSET)
        {
            ret = CryptAcquireContext(&info->hCryptProv,
                                      L"MSTSC",
                                      MS_ENHANCED_PROV,
                                      PROV_RSA_FULL,
                                      CRYPT_NEWKEYSET);
        }
    }
    if (!ret)
    {
        dwErr = GetLastError();
        error("CryptAcquireContext failed with %lx\n", dwErr);
        g_free(info);
        return NULL;
    }
    return info;
}

rdssl_rc4_info_delete()

void rdssl_rc4_info_delete

(

void *

rc4_info

)

Definition at line 90 of file ssl_calls.c.

Referenced by licence_process_new_license(), licence_process_platform_challenge(), and licence_process_request().

{
    struct rc4_state *info = rc4_info;
    BOOL ret = TRUE;
    DWORD dwErr;
    if (!info)
    {
        //error("rdssl_rc4_info_delete rc4_info is null\n");
        return;
    }
    if (info->hKey)
    {
        ret = CryptDestroyKey(info->hKey);
        if (!ret)
        {
            dwErr = GetLastError();
            error("CryptDestroyKey failed with %lx\n", dwErr);
        }
    }
    if (info->hCryptProv)
    {
        ret = CryptReleaseContext(info->hCryptProv, 0);
        if (!ret)
        {
            dwErr = GetLastError();
            error("CryptReleaseContext failed with %lx\n", dwErr);
        }
    }
    g_free(rc4_info);
}

rdssl_rc4_set_key()

void rdssl_rc4_set_key	(	void *	rc4_info,
		char *	key,
		int	len
	)

Definition at line 123 of file ssl_calls.c.

Referenced by licence_process_new_license(), licence_process_platform_challenge(), and licence_process_request().

{
    struct rc4_state *info = rc4_info;
    BOOL ret;
    DWORD dwErr;
    BYTE * blob;
    PUBLICKEYSTRUC *desc;
    DWORD * keySize;
    BYTE * keyBuf;
    if (!rc4_info || !key || !len || !info->hCryptProv)
    {
        error("rdssl_rc4_set_key %p %p %d\n", rc4_info, key, len);
        return;
    }
    blob = g_malloc(sizeof(PUBLICKEYSTRUC) + sizeof(DWORD) + len, 0);
    if (!blob)
    {
        error("rdssl_rc4_set_key no memory\n");
        return;
    }
    desc = (PUBLICKEYSTRUC *)blob;
    keySize = (DWORD *)(blob + sizeof(PUBLICKEYSTRUC));
    keyBuf = blob + sizeof(PUBLICKEYSTRUC) + sizeof(DWORD);
    desc->aiKeyAlg = CALG_RC4;
    desc->bType = PLAINTEXTKEYBLOB;
    desc->bVersion = CUR_BLOB_VERSION;
    desc->reserved = 0;
    *keySize = len;
    memcpy(keyBuf, key, len);
    if (info->hKey)
    {
        CryptDestroyKey(info->hKey);
        info->hKey = 0;
    }
    ret = CryptImportKey(info->hCryptProv,
                         blob,
                         sizeof(PUBLICKEYSTRUC) + sizeof(DWORD) + len,
                         0,
                         CRYPT_EXPORTABLE,
                         &info->hKey);
    g_free(blob);
    if (!ret)
    {
        dwErr = GetLastError();
        error("CryptImportKey failed with %lx\n", dwErr);
    }
}

Variable Documentation

g_hostname

char g_hostname[256]

Definition at line 26 of file uimain.c.

Referenced by licence_generate_hwid(), and licence_process_request().

g_licence_error_result

RD_BOOL g_licence_error_result = False

Definition at line 45 of file licence.c.

Referenced by licence_process_error_alert(), sec_init(), sec_recv(), sec_reset_state(), and sec_send_to_channel().

g_licence_issued

RD_BOOL g_licence_issued = False

Definition at line 44 of file licence.c.

Referenced by licence_process_error_alert(), licence_process_new_license(), sec_init(), sec_recv(), sec_reset_state(), and sec_send_to_channel().

g_licence_key

uint8 g_licence_key[16]

static

Definition at line 41 of file licence.c.

Referenced by licence_generate_keys(), licence_process_new_license(), licence_process_platform_challenge(), and licence_process_request().

g_licence_sign_key

uint8 g_licence_sign_key[16]

static

Definition at line 42 of file licence.c.

Referenced by licence_generate_keys(), licence_process_platform_challenge(), and licence_process_request().

g_rdp_version

RDP_VERSION g_rdp_version

Definition at line 74 of file uimain.c.

Referenced by licence_info(), licence_send_new_licence_request(), and licence_send_platform_challenge_response().

g_username

char g_username[256]

Definition at line 25 of file uimain.c.

Referenced by licence_process_request().