Mercurial > pidgin
view libpurple/ntlm.c @ 32796:5ae7e1f36b43
Fix a possible XMPP remote crash
A series of specially crafted file transfer requests can cause clients
to reference invalid memory. The user must have accepted one of the
file transfer requests.
The fix is to correctly cancel and free a SOCKS5 connection attempt so
that it does not trigger an attempt to access invalid memory later.
This was reported to us by Jos«± Valent«żn Guti«±rrez and this patch is
written by Paul Aurich.
author | Mark Doliner <mark@kingant.net> |
---|---|
date | Mon, 07 May 2012 03:16:31 +0000 |
parents | a13744df700c |
children |
line wrap: on
line source
/** * @file ntlm.c */ /* purple * * Copyright (C) 2005 Thomas Butter <butter@uni-mannheim.de> * * hashing done according to description of NTLM on * http://www.innovation.ch/java/ntlm.html * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ #include "internal.h" #include "util.h" #include "ntlm.h" #include "cipher.h" #include "debug.h" #include <string.h> #define NTLM_NEGOTIATE_NTLM2_KEY 0x00080000 struct type1_message { guint8 protocol[8]; /* 'N', 'T', 'L', 'M', 'S', 'S', 'P', '\0' */ guint32 type; /* 0x00000001 */ guint32 flags; /* 0x0000b203 */ guint16 dom_len1; /* domain string length */ guint16 dom_len2; /* domain string length */ guint32 dom_off; /* domain string offset */ guint16 host_len1; /* host string length */ guint16 host_len2; /* host string length */ guint32 host_off; /* host string offset (always 0x00000020) */ #if 0 guint8 host[*]; /* host string (ASCII) */ guint8 dom[*]; /* domain string (ASCII) */ #endif }; struct type2_message { guint8 protocol[8]; /* 'N', 'T', 'L', 'M', 'S', 'S', 'P', '\0'*/ guint32 type; /* 0x00000002 */ guint32 zero; guint16 msg_len1; /* target name length */ guint16 msg_len2; /* target name length */ guint32 flags; /* 0x00008201 */ guint8 nonce[8]; /* nonce */ guint8 context[8]; }; struct type3_message { guint8 protocol[8]; /* 'N', 'T', 'L', 'M', 'S', 'S', 'P', '\0'*/ guint32 type; /* 0x00000003 */ guint16 lm_resp_len1; /* LanManager response length (always 0x18)*/ guint16 lm_resp_len2; /* LanManager response length (always 0x18)*/ guint32 lm_resp_off; /* LanManager response offset */ guint16 nt_resp_len1; /* NT response length (always 0x18) */ guint16 nt_resp_len2; /* NT response length (always 0x18) */ guint32 nt_resp_off; /* NT response offset */ guint16 dom_len1; /* domain string length */ guint16 dom_len2; /* domain string length */ guint32 dom_off; /* domain string offset (always 0x00000040) */ guint16 user_len1; /* username string length */ guint16 user_len2; /* username string length */ guint32 user_off; /* username string offset */ guint16 host_len1; /* host string length */ guint16 host_len2; /* host string length */ guint32 host_off; /* host string offset */ guint16 sess_len1; guint16 sess_len2; guint32 sess_off; /* message length */ guint32 flags; /* 0x00008201 */ /* guint32 flags2; */ /* unknown, used in windows messenger */ /* guint32 flags3; */ #if 0 guint8 dom[*]; /* domain string (unicode UTF-16LE) */ guint8 user[*]; /* username string (unicode UTF-16LE) */ guint8 host[*]; /* host string (unicode UTF-16LE) */ guint8 lm_resp[*]; /* LanManager response */ guint8 nt_resp[*]; /* NT response */ #endif }; gchar * purple_ntlm_gen_type1(const gchar *hostname, const gchar *domain) { int hostnamelen,host_off; int domainlen,dom_off; unsigned char *msg; struct type1_message *tmsg; gchar *tmp; hostnamelen = strlen(hostname); domainlen = strlen(domain); host_off = sizeof(struct type1_message); dom_off = sizeof(struct type1_message) + hostnamelen; msg = g_malloc0(sizeof(struct type1_message) + hostnamelen + domainlen); tmsg = (struct type1_message*)msg; tmsg->protocol[0] = 'N'; tmsg->protocol[1] = 'T'; tmsg->protocol[2] = 'L'; tmsg->protocol[3] = 'M'; tmsg->protocol[4] = 'S'; tmsg->protocol[5] = 'S'; tmsg->protocol[6] = 'P'; tmsg->protocol[7] = '\0'; tmsg->type = GUINT32_TO_LE(0x00000001); tmsg->flags = GUINT32_TO_LE(0x0000b203); tmsg->dom_len1 = tmsg->dom_len2 = GUINT16_TO_LE(domainlen); tmsg->dom_off = GUINT32_TO_LE(dom_off); tmsg->host_len1 = tmsg->host_len2 = GUINT16_TO_LE(hostnamelen); tmsg->host_off = GUINT32_TO_LE(host_off); memcpy(msg + host_off, hostname, hostnamelen); memcpy(msg + dom_off, domain, domainlen); tmp = purple_base64_encode(msg, sizeof(struct type1_message) + hostnamelen + domainlen); g_free(msg); return tmp; } guint8 * purple_ntlm_parse_type2(const gchar *type2, guint32 *flags) { gsize retlen; struct type2_message *tmsg; static guint8 nonce[8]; tmsg = (struct type2_message*)purple_base64_decode(type2, &retlen); if (tmsg != NULL && retlen >= (sizeof(struct type2_message) - 1)) { memcpy(nonce, tmsg->nonce, 8); if (flags != NULL) *flags = GUINT16_FROM_LE(tmsg->flags); } else { purple_debug_error("ntlm", "Unable to parse type2 message - returning empty nonce.\n"); memset(nonce, 0, 8); } g_free(tmsg); return nonce; } /** * Create a 64bit DES key by taking a 56bit key and adding * a parity bit after every 7th bit. */ static void setup_des_key(const guint8 key_56[], guint8 *key) { key[0] = key_56[0]; key[1] = ((key_56[0] << 7) & 0xFF) | (key_56[1] >> 1); key[2] = ((key_56[1] << 6) & 0xFF) | (key_56[2] >> 2); key[3] = ((key_56[2] << 5) & 0xFF) | (key_56[3] >> 3); key[4] = ((key_56[3] << 4) & 0xFF) | (key_56[4] >> 4); key[5] = ((key_56[4] << 3) & 0xFF) | (key_56[5] >> 5); key[6] = ((key_56[5] << 2) & 0xFF) | (key_56[6] >> 6); key[7] = (key_56[6] << 1) & 0xFF; } /* * helper function for purple cipher.c */ static void des_ecb_encrypt(const guint8 *plaintext, guint8 *result, const guint8 *key) { PurpleCipher *cipher; PurpleCipherContext *context; size_t outlen; cipher = purple_ciphers_find_cipher("des"); context = purple_cipher_context_new(cipher, NULL); purple_cipher_context_set_key(context, key); purple_cipher_context_encrypt(context, plaintext, 8, result, &outlen); purple_cipher_context_destroy(context); } /* * takes a 21 byte array and treats it as 3 56-bit DES keys. The * 8 byte plaintext is encrypted with each key and the resulting 24 * bytes are stored in the results array. */ static void calc_resp(guint8 *keys, const guint8 *plaintext, unsigned char *results) { guint8 key[8]; setup_des_key(keys, key); des_ecb_encrypt(plaintext, results, key); setup_des_key(keys + 7, key); des_ecb_encrypt(plaintext, results + 8, key); setup_des_key(keys + 14, key); des_ecb_encrypt(plaintext, results + 16, key); } static void gensesskey(char *buffer, const char *oldkey) { int i = 0; if(oldkey == NULL) { for(i=0; i<16; i++) { buffer[i] = (char)(rand() & 0xff); } } else { memcpy(buffer, oldkey, 16); } } gchar * purple_ntlm_gen_type3(const gchar *username, const gchar *passw, const gchar *hostname, const gchar *domain, const guint8 *nonce, guint32 *flags) { char lm_pw[14]; unsigned char lm_hpw[21]; char sesskey[16]; guint8 key[8]; int domainlen; int usernamelen; int hostnamelen; int msglen; struct type3_message *tmsg; int passwlen, lennt; unsigned char lm_resp[24], nt_resp[24]; unsigned char magic[] = { 0x4B, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25 }; unsigned char nt_hpw[21]; char nt_pw[128]; PurpleCipher *cipher; PurpleCipherContext *context; char *tmp; int idx; gchar *ucs2le; domainlen = strlen(domain) * 2; usernamelen = strlen(username) * 2; hostnamelen = strlen(hostname) * 2; msglen = sizeof(struct type3_message) + domainlen + usernamelen + hostnamelen + 0x18 + 0x18 + ((flags) ? 0x10 : 0); tmsg = g_malloc0(msglen); passwlen = strlen(passw); /* type3 message initialization */ tmsg->protocol[0] = 'N'; tmsg->protocol[1] = 'T'; tmsg->protocol[2] = 'L'; tmsg->protocol[3] = 'M'; tmsg->protocol[4] = 'S'; tmsg->protocol[5] = 'S'; tmsg->protocol[6] = 'P'; tmsg->type = GUINT32_TO_LE(0x00000003); tmsg->lm_resp_len1 = tmsg->lm_resp_len2 = GUINT16_TO_LE(0x18); tmsg->lm_resp_off = GUINT32_TO_LE(sizeof(struct type3_message) + domainlen + usernamelen + hostnamelen); tmsg->nt_resp_len1 = tmsg->nt_resp_len2 = GUINT16_TO_LE(0x18); tmsg->nt_resp_off = GUINT32_TO_LE(sizeof(struct type3_message) + domainlen + usernamelen + hostnamelen + 0x18); tmsg->dom_len1 = tmsg->dom_len2 = GUINT16_TO_LE(domainlen); tmsg->dom_off = GUINT32_TO_LE(sizeof(struct type3_message)); tmsg->user_len1 = tmsg->user_len2 = GUINT16_TO_LE(usernamelen); tmsg->user_off = GUINT32_TO_LE(sizeof(struct type3_message) + domainlen); tmsg->host_len1 = tmsg->host_len2 = GUINT16_TO_LE(hostnamelen); tmsg->host_off = GUINT32_TO_LE(sizeof(struct type3_message) + domainlen + usernamelen); if(flags) { tmsg->sess_off = GUINT32_TO_LE(sizeof(struct type3_message) + domainlen + usernamelen + hostnamelen + 0x18 + 0x18); tmsg->sess_len1 = tmsg->sess_len2 = GUINT16_TO_LE(0x0010); } tmsg->flags = GUINT32_TO_LE(0x00008201); tmp = (char *)tmsg + sizeof(struct type3_message); ucs2le = g_convert(domain, -1, "UTF-16LE", "UTF-8", NULL, NULL, NULL); if (ucs2le != NULL) { memcpy(tmp, ucs2le, domainlen); g_free(ucs2le); tmp += domainlen; } else { purple_debug_info("ntlm", "Unable to encode domain in UTF-16LE.\n"); } ucs2le = g_convert(username, -1, "UTF-16LE", "UTF-8", NULL, NULL, NULL); if (ucs2le != NULL) { memcpy(tmp, ucs2le, usernamelen); g_free(ucs2le); tmp += usernamelen; } else { purple_debug_info("ntlm", "Unable to encode username in UTF-16LE.\n"); } ucs2le = g_convert(hostname, -1, "UTF-16LE", "UTF-8", NULL, NULL, NULL); if (ucs2le != NULL) { memcpy(tmp, ucs2le, hostnamelen); g_free(ucs2le); tmp += hostnamelen; } else { purple_debug_info("ntlm", "Unable to encode hostname in UTF-16LE.\n"); } /* LM */ if (passwlen > 14) passwlen = 14; for (idx = 0; idx < passwlen; idx++) lm_pw[idx] = g_ascii_toupper(passw[idx]); for (; idx < 14; idx++) lm_pw[idx] = 0; setup_des_key((unsigned char*)lm_pw, key); des_ecb_encrypt(magic, lm_hpw, key); setup_des_key((unsigned char*)(lm_pw + 7), key); des_ecb_encrypt(magic, lm_hpw + 8, key); memset(lm_hpw + 16, 0, 5); calc_resp(lm_hpw, nonce, lm_resp); memcpy(tmp, lm_resp, 0x18); tmp += 0x18; /* NTLM */ /* Convert the password to UTF-16LE */ lennt = strlen(passw); for (idx = 0; idx < lennt; idx++) { nt_pw[2 * idx] = passw[idx]; nt_pw[2 * idx + 1] = 0; } cipher = purple_ciphers_find_cipher("md4"); context = purple_cipher_context_new(cipher, NULL); purple_cipher_context_append(context, (guint8 *)nt_pw, 2 * lennt); purple_cipher_context_digest(context, 21, nt_hpw, NULL); purple_cipher_context_destroy(context); memset(nt_hpw + 16, 0, 5); calc_resp(nt_hpw, nonce, nt_resp); memcpy(tmp, nt_resp, 0x18); tmp += 0x18; /* LCS Stuff */ if (flags) { tmsg->flags = GUINT32_TO_LE(0x409082d4); gensesskey(sesskey, NULL); memcpy(tmp, sesskey, 0x10); } /*tmsg->flags2 = 0x0a280105; tmsg->flags3 = 0x0f000000;*/ tmp = purple_base64_encode((guchar *)tmsg, msglen); g_free(tmsg); return tmp; }