/* * Does NTLM hashes, and encodes them for transmission to qi server. * Mostly stolen from Samba 2.0.6. */ static char rcsid[] = "$Id: ntlm.c,v 2.0 2000/07/08 03:26:40 dgc Exp $"; /* proto */ static void mdfour(unsigned char *out, unsigned char *in, int n); /* * This is for base-16 encoding hash data so it can be used with the * qi encrypto stuff. */ static char * base16(unsigned char *b256) { static unsigned char b16[33]; static unsigned char chars[] = "0123456789ABCDEF"; unsigned int i; for (i = 0; i < 16; ++i) { b16[i*2] = chars[b256[i] >> 4]; b16[(i*2)+1] = chars[b256[i] & 0x0f]; } b16[32] = '\0'; return b16; } /* * Since the whole point of this exercise in terror is to make samba use * qi (and thus depend on qi), I'm plagiarizing from samba's * libsmb/smbencrypt.c. This will avoid an ugly cross-dependency. * Besides, the samba people don't have things to the point that it's * easy to make an smb library of your own. */ /* algorithm stolen from samba:libsmb/smbencrypt.c:_my_mbstowcs() */ static void ascii2nt(unsigned short *dst, unsigned char *src, int len) { int i; for (i = 0; i < len; ++i) { *dst = *src << 8; if (*src == 0) break; ++dst; ++src; } } /* algorithm stolen from samba:libsmb/smbencrypt.c:E_md4hash() */ static void mk_nthash(char *pw, char *nthash) { unsigned short work[130]; int x; memset(work, '\0', sizeof(work)); x = strlen(pw); if (x > 128) x = 128; ascii2nt(work, pw, x); mdfour(nthash, (char *)work, x * sizeof(unsigned short) / sizeof(char)); } int NTHashOK(b16) char *string; { unsigned char decrypted[MAXSTR]; char *pw = PasswordOf(User); unsigned char nthash[16]; unsigned char *ntb16; if (!*pw) return (0); /* From samba:libsmb/smbencrypt.c */ mk_nthash(pw, nthash); ntb16 = base16(nthash); #ifdef PRE_ENCRYPT crypt_start(crypt(ntb16,ntb16)); #else crypt_start(ntb16); #endif (void) decrypt(decrypted, string); return (!strcmp(decrypted, Challenge)); } typedef unsigned int uint32; /* * The remainder is almost verbatim from Andrew Tridgell's md4 implementation. * Code copied from samba:lib/md4.c; the only changes are to remove his * "includes.h" header inclusion and to make mdfour() a static function. */ /* Unix SMB/Netbios implementation. Version 1.9. a implementation of MD4 designed for use in the SMB authentication protocol Copyright (C) Andrew Tridgell 1997-1998. 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* dgc removed for qick // #include "includes.h" */ /* NOTE: This code makes no attempt to be fast! It assumes that a int is at least 32 bits long */ static uint32 A, B, C, D; static uint32 F(uint32 X, uint32 Y, uint32 Z) { return (X&Y) | ((~X)&Z); } static uint32 G(uint32 X, uint32 Y, uint32 Z) { return (X&Y) | (X&Z) | (Y&Z); } static uint32 H(uint32 X, uint32 Y, uint32 Z) { return X^Y^Z; } static uint32 lshift(uint32 x, int s) { x &= 0xFFFFFFFF; return ((x<>(32-s)); } #define ROUND1(a,b,c,d,k,s) a = lshift(a + F(b,c,d) + X[k], s) #define ROUND2(a,b,c,d,k,s) a = lshift(a + G(b,c,d) + X[k] + (uint32)0x5A827999,s) #define ROUND3(a,b,c,d,k,s) a = lshift(a + H(b,c,d) + X[k] + (uint32)0x6ED9EBA1,s) /* this applies md4 to 64 byte chunks */ static void mdfour64(uint32 *M) { int j; uint32 AA, BB, CC, DD; uint32 X[16]; for (j=0;j<16;j++) X[j] = M[j]; AA = A; BB = B; CC = C; DD = D; ROUND1(A,B,C,D, 0, 3); ROUND1(D,A,B,C, 1, 7); ROUND1(C,D,A,B, 2, 11); ROUND1(B,C,D,A, 3, 19); ROUND1(A,B,C,D, 4, 3); ROUND1(D,A,B,C, 5, 7); ROUND1(C,D,A,B, 6, 11); ROUND1(B,C,D,A, 7, 19); ROUND1(A,B,C,D, 8, 3); ROUND1(D,A,B,C, 9, 7); ROUND1(C,D,A,B, 10, 11); ROUND1(B,C,D,A, 11, 19); ROUND1(A,B,C,D, 12, 3); ROUND1(D,A,B,C, 13, 7); ROUND1(C,D,A,B, 14, 11); ROUND1(B,C,D,A, 15, 19); ROUND2(A,B,C,D, 0, 3); ROUND2(D,A,B,C, 4, 5); ROUND2(C,D,A,B, 8, 9); ROUND2(B,C,D,A, 12, 13); ROUND2(A,B,C,D, 1, 3); ROUND2(D,A,B,C, 5, 5); ROUND2(C,D,A,B, 9, 9); ROUND2(B,C,D,A, 13, 13); ROUND2(A,B,C,D, 2, 3); ROUND2(D,A,B,C, 6, 5); ROUND2(C,D,A,B, 10, 9); ROUND2(B,C,D,A, 14, 13); ROUND2(A,B,C,D, 3, 3); ROUND2(D,A,B,C, 7, 5); ROUND2(C,D,A,B, 11, 9); ROUND2(B,C,D,A, 15, 13); ROUND3(A,B,C,D, 0, 3); ROUND3(D,A,B,C, 8, 9); ROUND3(C,D,A,B, 4, 11); ROUND3(B,C,D,A, 12, 15); ROUND3(A,B,C,D, 2, 3); ROUND3(D,A,B,C, 10, 9); ROUND3(C,D,A,B, 6, 11); ROUND3(B,C,D,A, 14, 15); ROUND3(A,B,C,D, 1, 3); ROUND3(D,A,B,C, 9, 9); ROUND3(C,D,A,B, 5, 11); ROUND3(B,C,D,A, 13, 15); ROUND3(A,B,C,D, 3, 3); ROUND3(D,A,B,C, 11, 9); ROUND3(C,D,A,B, 7, 11); ROUND3(B,C,D,A, 15, 15); A += AA; B += BB; C += CC; D += DD; A &= 0xFFFFFFFF; B &= 0xFFFFFFFF; C &= 0xFFFFFFFF; D &= 0xFFFFFFFF; for (j=0;j<16;j++) X[j] = 0; } static void copy64(uint32 *M, unsigned char *in) { int i; for (i=0;i<16;i++) M[i] = (in[i*4+3]<<24) | (in[i*4+2]<<16) | (in[i*4+1]<<8) | (in[i*4+0]<<0); } static void copy4(unsigned char *out,uint32 x) { out[0] = x&0xFF; out[1] = (x>>8)&0xFF; out[2] = (x>>16)&0xFF; out[3] = (x>>24)&0xFF; } /* produce a md4 message digest from data of length n bytes */ static void mdfour(unsigned char *out, unsigned char *in, int n) { unsigned char buf[128]; uint32 M[16]; uint32 b = n * 8; int i; A = 0x67452301; B = 0xefcdab89; C = 0x98badcfe; D = 0x10325476; while (n > 64) { copy64(M, in); mdfour64(M); in += 64; n -= 64; } for (i=0;i<128;i++) buf[i] = 0; memcpy(buf, in, n); buf[n] = 0x80; if (n <= 55) { copy4(buf+56, b); copy64(M, buf); mdfour64(M); } else { copy4(buf+120, b); copy64(M, buf); mdfour64(M); copy64(M, buf+64); mdfour64(M); } for (i=0;i<128;i++) buf[i] = 0; copy64(M, buf); copy4(out, A); copy4(out+4, B); copy4(out+8, C); copy4(out+12, D); A = B = C = D = 0; }