util.c File Reference

#include "precomp.h"
#include <wine/debug.h>

Include dependency graph for util.c:

Go to the source code of this file.

Classes
struct	MD4_CTX
struct	MD5_CTX

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ntlm)
VOID WINAPI	MD4Init (MD4_CTX *ctx)
VOID WINAPI	MD4Update (MD4_CTX *ctx, const unsigned char *buf, unsigned int len)
VOID WINAPI	MD4Final (MD4_CTX *ctx)
VOID WINAPI	MD5Init (MD5_CTX *ctx)
VOID WINAPI	MD5Update (MD5_CTX *ctx, const unsigned char *buf, unsigned int len)
VOID WINAPI	MD5Final (MD5_CTX *ctx)
ULONG	ComputeCrc32 (const BYTE *pData, INT iLen, ULONG initial_crc)
SECURITY_STATUS	SECUR32_CreateNTLM1SessionKey (PBYTE password, int len, PBYTE session_key)
static void	SECUR32_CalcNTLM2Subkey (const BYTE *session_key, const char *magic, PBYTE subkey)
SECURITY_STATUS	SECUR32_CreateNTLM2SubKeys (PNegoHelper helper)
arc4_info *	SECUR32_arc4Alloc (void)
void	SECUR32_arc4Init (arc4_info *a4i, const BYTE *key, unsigned int keyLen)
void	SECUR32_arc4Process (arc4_info *a4i, BYTE *inoutString, unsigned int length)
void	SECUR32_arc4Cleanup (arc4_info *a4i)

Variables
static const ULONG	CRC_table [256]
static const char	client_to_server_sign_constant [] = "session key to client-to-server signing key magic constant"
static const char	client_to_server_seal_constant [] = "session key to client-to-server sealing key magic constant"
static const char	server_to_client_sign_constant [] = "session key to server-to-client signing key magic constant"
static const char	server_to_client_seal_constant [] = "session key to server-to-client sealing key magic constant"

Function Documentation

ComputeCrc32()

ULONG ComputeCrc32	(	const BYTE *	pData,
		INT	iLen,
		ULONG	initial_crc
	)

Definition at line 109 of file util.c.

{
  ULONG crc = ~initial_crc;
 
  while (iLen > 0)
  {
    crc = CRC_table[(crc ^ *pData) & 0xff] ^ (crc >> 8);
    pData++;
    iLen--;
  }
  return ~crc;
}

Referenced by ntlm_CreateSignature().

MD4Final()

VOID WINAPI MD4Final

(

MD4_CTX *

ctx

)

Definition at line 113 of file md4.c.

{
    unsigned int count;
    unsigned char *p;
 
    /* Compute number of bytes mod 64 */
    count = (ctx->i[0] >> 3) & 0x3F;
 
    /* Set the first char of padding to 0x80.  This is safe since there is
       always at least one byte free */
    p = ctx->in + count;
    *p++ = 0x80;
 
    /* Bytes of padding needed to make 64 bytes */
    count = 64 - 1 - count;
 
    /* Pad out to 56 mod 64 */
    if (count < 8)
    {
        /* Two lots of padding:  Pad the first block to 64 bytes */
        memset( p, 0, count );
        byteReverse( ctx->in, 16 );
        MD4Transform( ctx->buf, (unsigned int *)ctx->in );
 
        /* Now fill the next block with 56 bytes */
        memset( ctx->in, 0, 56 );
    }
    else
    {
        /* Pad block to 56 bytes */
        memset( p, 0, count - 8 );
    }
 
    byteReverse( ctx->in, 14 );
 
    /* Append length in bits and transform */
    ((unsigned int *)ctx->in)[14] = ctx->i[0];
    ((unsigned int *)ctx->in)[15] = ctx->i[1];
 
    MD4Transform( ctx->buf, (unsigned int *)ctx->in );
    byteReverse( (unsigned char *)ctx->buf, 4 );
    memcpy( ctx->digest, ctx->buf, 16 );
    memset(ctx->in, 0, sizeof(ctx->in));
}

Referenced by SECUR32_CreateNTLM1SessionKey().

MD4Init()

VOID WINAPI MD4Init

(

MD4_CTX *

ctx

)

Definition at line 45 of file md4.c.

{
    ctx->buf[0] = 0x67452301;
    ctx->buf[1] = 0xefcdab89;
    ctx->buf[2] = 0x98badcfe;
    ctx->buf[3] = 0x10325476;
 
    ctx->i[0] = ctx->i[1] = 0;
}

Referenced by SECUR32_CreateNTLM1SessionKey().

MD4Update()

VOID WINAPI MD4Update	(	MD4_CTX *	ctx,
		const unsigned char *	buf,
		unsigned int	len
	)

Definition at line 59 of file md4.c.

{
    register unsigned int t;
 
    /* Update bitcount */
    t = ctx->i[0];
 
    if ((ctx->i[0] = t + (len << 3)) < t)
        ctx->i[1]++;        /* Carry from low to high */
 
    ctx->i[1] += len >> 29;
    t = (t >> 3) & 0x3f;
 
    /* Handle any leading odd-sized chunks */
    if (t)
    {
        unsigned char *p = (unsigned char *)ctx->in + t;
        t = 64 - t;
 
        if (len < t)
        {
            memcpy( p, buf, len );
            return;
        }
 
        memcpy( p, buf, t );
        byteReverse( ctx->in, 16 );
 
        MD4Transform( ctx->buf, (unsigned int *)ctx->in );
 
        buf += t;
        len -= t;
    }
 
    /* Process data in 64-byte chunks */
    while (len >= 64)
    {
        memcpy( ctx->in, buf, 64 );
        byteReverse( ctx->in, 16 );
 
        MD4Transform( ctx->buf, (unsigned int *)ctx->in );
 
        buf += 64;
        len -= 64;
    }
 
    /* Handle any remaining bytes of data. */
    memcpy( ctx->in, buf, len );
}

Referenced by SECUR32_CreateNTLM1SessionKey().

MD5Final()

VOID WINAPI MD5Final

(

MD5_CTX *

ctx

)

Definition at line 113 of file md5.c.

{
    unsigned int count;
    unsigned char *p;
 
    /* Compute number of bytes mod 64 */
    count = (ctx->i[0] >> 3) & 0x3F;
 
    /* Set the first char of padding to 0x80.  This is safe since there is
       always at least one byte free */
    p = ctx->in + count;
    *p++ = 0x80;
 
    /* Bytes of padding needed to make 64 bytes */
    count = 64 - 1 - count;
 
    /* Pad out to 56 mod 64 */
    if (count < 8)
    {
        /* Two lots of padding:  Pad the first block to 64 bytes */
        memset( p, 0, count );
        byteReverse( ctx->in, 16 );
        MD5Transform( ctx->buf, (unsigned int *)ctx->in );
 
        /* Now fill the next block with 56 bytes */
        memset( ctx->in, 0, 56 );
    }
    else
    {
        /* Pad block to 56 bytes */
        memset( p, 0, count - 8 );
    }
 
    byteReverse( ctx->in, 14 );
 
    /* Append length in bits and transform */
    ((unsigned int *)ctx->in)[14] = ctx->i[0];
    ((unsigned int *)ctx->in)[15] = ctx->i[1];
 
    MD5Transform( ctx->buf, (unsigned int *)ctx->in );
    byteReverse( (unsigned char *)ctx->buf, 4 );
    memcpy( ctx->digest, ctx->buf, 16 );
    memset(ctx->in, 0, sizeof(ctx->in));
}

Referenced by SECUR32_CalcNTLM2Subkey().

MD5Init()

VOID WINAPI MD5Init

(

MD5_CTX *

ctx

)

Definition at line 45 of file md5.c.

{
    ctx->buf[0] = 0x67452301;
    ctx->buf[1] = 0xefcdab89;
    ctx->buf[2] = 0x98badcfe;
    ctx->buf[3] = 0x10325476;
 
    ctx->i[0] = ctx->i[1] = 0;
}

Referenced by SECUR32_CalcNTLM2Subkey().

MD5Update()

VOID WINAPI MD5Update	(	MD5_CTX *	ctx,
		const unsigned char *	buf,
		unsigned int	len
	)

Definition at line 59 of file md5.c.

{
    register unsigned int t;
 
    /* Update bitcount */
    t = ctx->i[0];
 
    if ((ctx->i[0] = t + (len << 3)) < t)
        ctx->i[1]++;        /* Carry from low to high */
 
    ctx->i[1] += len >> 29;
    t = (t >> 3) & 0x3f;
 
    /* Handle any leading odd-sized chunks */
    if (t)
    {
        unsigned char *p = (unsigned char *)ctx->in + t;
        t = 64 - t;
 
        if (len < t)
        {
            memcpy( p, buf, len );
            return;
        }
 
        memcpy( p, buf, t );
        byteReverse( ctx->in, 16 );
 
        MD5Transform( ctx->buf, (unsigned int *)ctx->in );
 
        buf += t;
        len -= t;
    }
 
    /* Process data in 64-byte chunks */
    while (len >= 64)
    {
        memcpy( ctx->in, buf, 64 );
        byteReverse( ctx->in, 16 );
 
        MD5Transform( ctx->buf, (unsigned int *)ctx->in );
 
        buf += 64;
        len -= 64;
    }
 
    /* Handle any remaining bytes of data. */
    memcpy( ctx->in, buf, len );
}

Referenced by SECUR32_CalcNTLM2Subkey().

SECUR32_arc4Alloc()

arc4_info * SECUR32_arc4Alloc

(

void

)

Definition at line 189 of file util.c.

{
    arc4_info *a4i = HeapAlloc(GetProcessHeap(), 0, sizeof(arc4_info));
    return a4i;
}

Referenced by ntlm_AcceptSecurityContext(), and ntlm_InitializeSecurityContextW().

SECUR32_arc4Cleanup()

void SECUR32_arc4Cleanup

(

arc4_info *

a4i

)

Definition at line 246 of file util.c.

{
    HeapFree(GetProcessHeap(), 0, a4i);
}

Referenced by ntlm_DeleteSecurityContext().

SECUR32_arc4Init()

void SECUR32_arc4Init	(	arc4_info *	a4i,
		const BYTE *	key,
		unsigned int	keyLen
	)

Definition at line 199 of file util.c.

{
    unsigned int keyIndex = 0, stateIndex = 0;
    unsigned int i, a;
 
    TRACE("(%p, %p, %d)\n", a4i, key, keyLen);
 
        a4i->x = a4i->y = 0;
 
    for (i=0; i<256; i++)
        a4i->state[i] = i;
 
    for (i=0; i<256; i++)
    {
        a = a4i->state[i];
        stateIndex += key[keyIndex] + a;
        stateIndex &= 0xff;
        a4i->state[i] = a4i->state[stateIndex];
        a4i->state[stateIndex] = a;
        if (++keyIndex >= keyLen)
            keyIndex = 0;
    }
 
}

Referenced by ntlm_AcceptSecurityContext(), and ntlm_InitializeSecurityContextW().

SECUR32_arc4Process()

void SECUR32_arc4Process	(	arc4_info *	a4i,
		BYTE *	inoutString,
		unsigned int	length
	)

Definition at line 224 of file util.c.

{
    BYTE *const s=a4i->state;
    unsigned int x = a4i->x;
    unsigned int y = a4i->y;
    unsigned int a, b;
 
    while(length--)
    {
        x = (x+1) & 0xff;
        a = s[x];
        y = (y+a) & 0xff;
        b = s[y];
        s[x] = b;
        s[y] = a;
        *inoutString++ ^= s[(a+b) & 0xff];
    }
 
    a4i->x = x;
    a4i->y = y;
}

Referenced by ntlm_CreateSignature(), ntlm_DecryptMessage(), and ntlm_EncryptMessage().

SECUR32_CalcNTLM2Subkey()

static void SECUR32_CalcNTLM2Subkey ( const BYTE *  session_key, const char *  magic, PBYTE  subkey  )

static

Definition at line 144 of file util.c.

{
    MD5_CTX ctx;
 
    MD5Init(&ctx);
    MD5Update(&ctx, session_key, 16);
    MD5Update(&ctx, (const unsigned char*)magic, lstrlenA(magic)+1);
    MD5Final(&ctx);
    memcpy(subkey, ctx.digest, 16);
}

Referenced by SECUR32_CreateNTLM2SubKeys().

SECUR32_CreateNTLM1SessionKey()

SECURITY_STATUS SECUR32_CreateNTLM1SessionKey	(	PBYTE	password,
		int	len,
		PBYTE	session_key
	)

Definition at line 122 of file util.c.

{
    MD4_CTX ctx;
    BYTE ntlm_hash[16];
 
    TRACE("(%p, %p)\n", password, session_key);
 
    MD4Init(&ctx);
    MD4Update(&ctx, password, len);
    MD4Final(&ctx);
 
    memcpy(ntlm_hash, ctx.digest, 0x10);
 
    MD4Init(&ctx);
    MD4Update(&ctx, ntlm_hash, 0x10u);
    MD4Final(&ctx);
 
    memcpy(session_key, ctx.digest, 0x10);
 
    return SEC_E_OK;
}

Referenced by ntlm_InitializeSecurityContextW().

SECUR32_CreateNTLM2SubKeys()

SECURITY_STATUS SECUR32_CreateNTLM2SubKeys

(

PNegoHelper

helper

)

Definition at line 156 of file util.c.

{
    helper->crypt.ntlm2.send_sign_key = HeapAlloc(GetProcessHeap(), 0, 16);
    helper->crypt.ntlm2.send_seal_key = HeapAlloc(GetProcessHeap(), 0, 16);
    helper->crypt.ntlm2.recv_sign_key = HeapAlloc(GetProcessHeap(), 0, 16);
    helper->crypt.ntlm2.recv_seal_key = HeapAlloc(GetProcessHeap(), 0, 16);
 
    if(helper->mode == NTLM_CLIENT)
    {
        SECUR32_CalcNTLM2Subkey(helper->session_key, client_to_server_sign_constant,
                helper->crypt.ntlm2.send_sign_key);
        SECUR32_CalcNTLM2Subkey(helper->session_key, client_to_server_seal_constant,
                helper->crypt.ntlm2.send_seal_key);
        SECUR32_CalcNTLM2Subkey(helper->session_key, server_to_client_sign_constant,
                helper->crypt.ntlm2.recv_sign_key);
        SECUR32_CalcNTLM2Subkey(helper->session_key, server_to_client_seal_constant,
                helper->crypt.ntlm2.recv_seal_key);
    }
    else
    {
        SECUR32_CalcNTLM2Subkey(helper->session_key, server_to_client_sign_constant,
                helper->crypt.ntlm2.send_sign_key);
        SECUR32_CalcNTLM2Subkey(helper->session_key, server_to_client_seal_constant,
                helper->crypt.ntlm2.send_seal_key);
        SECUR32_CalcNTLM2Subkey(helper->session_key, client_to_server_sign_constant,
                helper->crypt.ntlm2.recv_sign_key);
        SECUR32_CalcNTLM2Subkey(helper->session_key, client_to_server_seal_constant,
                helper->crypt.ntlm2.recv_seal_key);
    }
 
    return SEC_E_OK;
}

Referenced by ntlm_InitializeSecurityContextW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ntlm

)

Variable Documentation

client_to_server_seal_constant

const char client_to_server_seal_constant[] = "session key to client-to-server sealing key magic constant"

static

Definition at line 77 of file util.c.

Referenced by SECUR32_CreateNTLM2SubKeys().

client_to_server_sign_constant

const char client_to_server_sign_constant[] = "session key to client-to-server signing key magic constant"

static

Definition at line 76 of file util.c.

Referenced by SECUR32_CreateNTLM2SubKeys().

CRC_table

const ULONG CRC_table[256]

static

Definition at line 29 of file util.c.

Referenced by ComputeCrc32().

server_to_client_seal_constant

const char server_to_client_seal_constant[] = "session key to server-to-client sealing key magic constant"

static

Definition at line 79 of file util.c.

Referenced by SECUR32_CreateNTLM2SubKeys().

server_to_client_sign_constant

const char server_to_client_sign_constant[] = "session key to server-to-client signing key magic constant"

static

Definition at line 78 of file util.c.

Referenced by SECUR32_CreateNTLM2SubKeys().