/* $Id$
   Single file NTLM system to create and parse authentication messages.

   http://www.reversing.org
   ilo-- ilo@reversing.org  

   I did copy&paste&modify several files to leave independent NTLM code 
   that compile in cygwin/linux environment. Most of the code was ripped 
   from Samba implementation so I left the Copying statement. Samba core
   code was left unmodified from 1.9 version.

   Also libntlm was ripped but rewrote, due to fixed and useless interface.
   Library oriented code was removed. (c) goes to: Simon Josefsson.

   Information about interface to this ntlm-system is in ntlm.h file.

   Unix SMB/Netbios implementation.
   Version 1.9.
   SMB parameters and setup
   Copyright (C) Andrew Tridgell 1992-1998
   Modified by Jeremy Allison 1995.
   
   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.

   */

#ifdef WIN32
#else
#include <unistd.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <assert.h>
#include <string.h>
#include "ntlm.h"


/* Byte order macros */
#ifndef _BYTEORDER_H
#define _BYTEORDER_H

/*
   This file implements macros for machine independent short and 
   int32_t manipulation

Here is a description of this file that I emailed to the samba list once:

> I am confused about the way that byteorder.h works in Samba. I have
> looked at it, and I would have thought that you might make a distinction
> between LE and BE machines, but you only seem to distinguish between 386
> and all other architectures.
> 
> Can you give me a clue?

sure.

The distinction between 386 and other architectures is only there as
an optimisation. You can take it out completely and it will make no
difference. The routines (macros) in byteorder.h are totally byteorder
independent. The 386 optimsation just takes advantage of the fact that
the x86 processors don't care about alignment, so we don't have to
align ints on int32_t boundaries etc. If there are other processors out
there that aren't alignment sensitive then you could also define
CAREFUL_ALIGNMENT=0 on those processors as well.

Ok, now to the macros themselves. I'll take a simple example, say we
want to extract a 2 byte integer from a SMB packet and put it into a
type called uint16 that is in the local machines byte order, and you
want to do it with only the assumption that uint16 is _at_least_ 16
bits long (this last condition is very important for architectures
that don't have any int32_t types that are 2 bytes long)

You do this:

#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
#define PVAL(buf,pos) ((unsigned)CVAL(buf,pos))
#define SVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+1)<<8)

then to extract a uint16 value at offset 25 in a buffer you do this:

char *buffer = foo_bar();
uint16 xx = SVAL(buffer,25);

We are using the byteoder independence of the ANSI C bitshifts to do
the work. A good optimising compiler should turn this into efficient
code, especially if it happens to have the right byteorder :-)

I know these macros can be made a bit tidier by removing some of the
casts, but you need to look at byteorder.h as a whole to see the
reasoning behind them. byteorder.h defines the following macros:

SVAL(buf,pos) - extract a 2 byte SMB value
IVAL(buf,pos) - extract a 4 byte SMB value
SVALS(buf,pos) signed version of SVAL()
IVALS(buf,pos) signed version of IVAL()

SSVAL(buf,pos,val) - put a 2 byte SMB value into a buffer
SIVAL(buf,pos,val) - put a 4 byte SMB value into a buffer
SSVALS(buf,pos,val) - signed version of SSVAL()
SIVALS(buf,pos,val) - signed version of SIVAL()

RSVAL(buf,pos) - like SVAL() but for NMB byte ordering
RSVALS(buf,pos) - like SVALS() but for NMB byte ordering
RIVAL(buf,pos) - like IVAL() but for NMB byte ordering
RIVALS(buf,pos) - like IVALS() but for NMB byte ordering
RSSVAL(buf,pos,val) - like SSVAL() but for NMB ordering
RSIVAL(buf,pos,val) - like SIVAL() but for NMB ordering
RSIVALS(buf,pos,val) - like SIVALS() but for NMB ordering

it also defines lots of intermediate macros, just ignore those :-)

*/

/* some switch macros that do both store and read to and from SMB buffers */

#define RW_PCVAL(read,inbuf,outbuf,len) \
	{ if (read) { PCVAL (inbuf,0,outbuf,len); } \
	else      { PSCVAL(inbuf,0,outbuf,len); } }

#define RW_PIVAL(read,big_endian,inbuf,outbuf,len) \
	{ if (read) { if (big_endian) { RPIVAL(inbuf,0,outbuf,len); } else { PIVAL(inbuf,0,outbuf,len); } } \
	else      { if (big_endian) { RPSIVAL(inbuf,0,outbuf,len); } else { PSIVAL(inbuf,0,outbuf,len); } } }

#define RW_PSVAL(read,big_endian,inbuf,outbuf,len) \
	{ if (read) { if (big_endian) { RPSVAL(inbuf,0,outbuf,len); } else { PSVAL(inbuf,0,outbuf,len); } } \
	else      { if (big_endian) { RPSSVAL(inbuf,0,outbuf,len); } else { PSSVAL(inbuf,0,outbuf,len); } } }

#define RW_CVAL(read, inbuf, outbuf, offset) \
	{ if (read) { (outbuf) = CVAL (inbuf,offset); } \
	else      { SCVAL(inbuf,offset,outbuf); } }

#define RW_IVAL(read, big_endian, inbuf, outbuf, offset) \
	{ if (read) { (outbuf) = ((big_endian) ? RIVAL(inbuf,offset) : IVAL (inbuf,offset)); } \
	else      { if (big_endian) { RSIVAL(inbuf,offset,outbuf); } else { SIVAL(inbuf,offset,outbuf); } } }

#define RW_SVAL(read, big_endian, inbuf, outbuf, offset) \
	{ if (read) { (outbuf) = ((big_endian) ? RSVAL(inbuf,offset) : SVAL (inbuf,offset)); } \
	else      { if (big_endian) { RSSVAL(inbuf,offset,outbuf); } else { SSVAL(inbuf,offset,outbuf); } } }

#undef CAREFUL_ALIGNMENT

/* we know that the 386 can handle misalignment and has the "right" 
   byteorder */
#ifdef __i386__
#define CAREFUL_ALIGNMENT 0
#endif

#ifndef CAREFUL_ALIGNMENT
#define CAREFUL_ALIGNMENT 1
#endif

#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
#define PVAL(buf,pos) ((unsigned)CVAL(buf,pos))
#define SCVAL(buf,pos,val) (CVAL(buf,pos) = (val))


#if CAREFUL_ALIGNMENT

#define SVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+1)<<8)
#define IVAL(buf,pos) (SVAL(buf,pos)|SVAL(buf,(pos)+2)<<16)
#define SSVALX(buf,pos,val) (CVAL(buf,pos)=(val)&0xFF,CVAL(buf,pos+1)=(val)>>8)
#define SIVALX(buf,pos,val) (SSVALX(buf,pos,val&0xFFFF),SSVALX(buf,pos+2,val>>16))
#define SVALS(buf,pos) ((int16)SVAL(buf,pos))
#define IVALS(buf,pos) ((int32)IVAL(buf,pos))
#define SSVAL(buf,pos,val) SSVALX((buf),(pos),((uint16)(val)))
#define SIVAL(buf,pos,val) SIVALX((buf),(pos),((uint32)(val)))
#define SSVALS(buf,pos,val) SSVALX((buf),(pos),((int16)(val)))
#define SIVALS(buf,pos,val) SIVALX((buf),(pos),((int32)(val)))

#else /* CAREFUL_ALIGNMENT */

/* this handles things for architectures like the 386 that can handle
   alignment errors */

/*
   WARNING: This section is dependent on the length of int16 and int32
   being correct 
*/

/* get single value from an SMB buffer */
#define SVAL(buf,pos) (*(uint16 *)((char *)(buf) + (pos)))
#define IVAL(buf,pos) (*(uint32 *)((char *)(buf) + (pos)))
#define SVALS(buf,pos) (*(int16 *)((char *)(buf) + (pos)))
#define IVALS(buf,pos) (*(int32 *)((char *)(buf) + (pos)))

/* store single value in an SMB buffer */
#define SSVAL(buf,pos,val) SVAL(buf,pos)=((uint16)(val))
#define SIVAL(buf,pos,val) IVAL(buf,pos)=((uint32)(val))
#define SSVALS(buf,pos,val) SVALS(buf,pos)=((int16)(val))
#define SIVALS(buf,pos,val) IVALS(buf,pos)=((int32)(val))

#endif /* CAREFUL_ALIGNMENT */

/* macros for reading / writing arrays */

#define SMBMACRO(macro,buf,pos,val,len,size) \
{ int32_t l; for (l = 0; l < (len); l++) (val)[l] = macro((buf), (pos) + (size)*l); }

#define SSMBMACRO(macro,buf,pos,val,len,size) \
{ int32_t l; for (l = 0; l < (len); l++) macro((buf), (pos) + (size)*l, (val)[l]); }

/* reads multiple data from an SMB buffer */
#define PCVAL(buf,pos,val,len) SMBMACRO(CVAL,buf,pos,val,len,1)
#define PSVAL(buf,pos,val,len) SMBMACRO(SVAL,buf,pos,val,len,2)
#define PIVAL(buf,pos,val,len) SMBMACRO(IVAL,buf,pos,val,len,4)
#define PCVALS(buf,pos,val,len) SMBMACRO(CVALS,buf,pos,val,len,1)
#define PSVALS(buf,pos,val,len) SMBMACRO(SVALS,buf,pos,val,len,2)
#define PIVALS(buf,pos,val,len) SMBMACRO(IVALS,buf,pos,val,len,4)

/* stores multiple data in an SMB buffer */
#define PSCVAL(buf,pos,val,len) SSMBMACRO(SCVAL,buf,pos,val,len,1)
#define PSSVAL(buf,pos,val,len) SSMBMACRO(SSVAL,buf,pos,val,len,2)
#define PSIVAL(buf,pos,val,len) SSMBMACRO(SIVAL,buf,pos,val,len,4)
#define PSCVALS(buf,pos,val,len) SSMBMACRO(SCVALS,buf,pos,val,len,1)
#define PSSVALS(buf,pos,val,len) SSMBMACRO(SSVALS,buf,pos,val,len,2)
#define PSIVALS(buf,pos,val,len) SSMBMACRO(SIVALS,buf,pos,val,len,4)


/* now the reverse routines - these are used in nmb packets (mostly) */
#define SREV(x) ((((x)&0xFF)<<8) | (((x)>>8)&0xFF))
#define IREV(x) ((SREV(x)<<16) | (SREV((x)>>16)))

#define RSVAL(buf,pos) SREV(SVAL(buf,pos))
#define RSVALS(buf,pos) SREV(SVALS(buf,pos))
#define RIVAL(buf,pos) IREV(IVAL(buf,pos))
#define RIVALS(buf,pos) IREV(IVALS(buf,pos))
#define RSSVAL(buf,pos,val) SSVAL(buf,pos,SREV(val))
#define RSSVALS(buf,pos,val) SSVALS(buf,pos,SREV(val))
#define RSIVAL(buf,pos,val) SIVAL(buf,pos,IREV(val))
#define RSIVALS(buf,pos,val) SIVALS(buf,pos,IREV(val))

/* reads multiple data from an SMB buffer (big-endian) */
#define RPSVAL(buf,pos,val,len) SMBMACRO(RSVAL,buf,pos,val,len,2)
#define RPIVAL(buf,pos,val,len) SMBMACRO(RIVAL,buf,pos,val,len,4)
#define RPSVALS(buf,pos,val,len) SMBMACRO(RSVALS,buf,pos,val,len,2)
#define RPIVALS(buf,pos,val,len) SMBMACRO(RIVALS,buf,pos,val,len,4)

/* stores multiple data in an SMB buffer (big-endian) */
#define RPSSVAL(buf,pos,val,len) SSMBMACRO(RSSVAL,buf,pos,val,len,2)
#define RPSIVAL(buf,pos,val,len) SSMBMACRO(RSIVAL,buf,pos,val,len,4)
#define RPSSVALS(buf,pos,val,len) SSMBMACRO(RSSVALS,buf,pos,val,len,2)
#define RPSIVALS(buf,pos,val,len) SSMBMACRO(RSIVALS,buf,pos,val,len,4)

#define DBG_RW_PCVAL(charmode,string,depth,base,read,inbuf,outbuf,len) \
	{ RW_PCVAL(read,inbuf,outbuf,len) \
	DEBUG(5,("%s%04x %s: ", \
             tab_depth(depth), base,string)); \
    if (charmode) print_asc(5, (unsigned char*)(outbuf), (len)); else \
	{ int32_t idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%02x ", (outbuf)[idx])); } } \
	DEBUG(5,("\n")); }

#define DBG_RW_PSVAL(charmode,string,depth,base,read,big_endian,inbuf,outbuf,len) \
	{ RW_PSVAL(read,big_endian,inbuf,outbuf,len) \
	DEBUG(5,("%s%04x %s: ", \
             tab_depth(depth), base,string)); \
    if (charmode) print_asc(5, (unsigned char*)(outbuf), 2*(len)); else \
	{ int32_t idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%04x ", (outbuf)[idx])); } } \
	DEBUG(5,("\n")); }

#define DBG_RW_PIVAL(charmode,string,depth,base,read,big_endian,inbuf,outbuf,len) \
	{ RW_PIVAL(read,big_endian,inbuf,outbuf,len) \
	DEBUG(5,("%s%04x %s: ", \
             tab_depth(depth), base,string)); \
    if (charmode) print_asc(5, (unsigned char*)(outbuf), 4*(len)); else \
	{ int32_t idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%08x ", (outbuf)[idx])); } } \
	DEBUG(5,("\n")); }

#define DBG_RW_CVAL(string,depth,base,read,inbuf,outbuf) \
	{ RW_CVAL(read,inbuf,outbuf,0) \
	DEBUG(5,("%s%04x %s: %02x\n", \
             tab_depth(depth), base, string, outbuf)); }

#define DBG_RW_SVAL(string,depth,base,read,big_endian,inbuf,outbuf) \
	{ RW_SVAL(read,big_endian,inbuf,outbuf,0) \
	DEBUG(5,("%s%04x %s: %04x\n", \
             tab_depth(depth), base, string, outbuf)); }

#define DBG_RW_IVAL(string,depth,base,read,big_endian,inbuf,outbuf) \
	{ RW_IVAL(read,big_endian,inbuf,outbuf,0) \
	DEBUG(5,("%s%04x %s: %08x\n", \
             tab_depth(depth), base, string, outbuf)); }

#endif /* _BYTEORDER_H */


/* Samba MD4 implementation */

/* NOTE: This code makes no attempt to be fast! 

   It assumes that a int32_t 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, int32_t s) {
  x &= 0xFFFFFFFF;
  return ((x << s) & 0xFFFFFFFF) | (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) {
  int32_t 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) {
  int32_t 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 */
void mdfour(unsigned char *out, unsigned char *in, int32_t n) {
  unsigned char buf[128];
  uint32 M[16];
  uint32 b = n * 8;
  int32_t 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;
}

/* Samba DES implementation */
#define uchar unsigned char
#define int16 signed short

static uchar perm1[56] = { 57, 49, 41, 33, 25, 17, 9,
  1, 58, 50, 42, 34, 26, 18,
  10, 2, 59, 51, 43, 35, 27,
  19, 11, 3, 60, 52, 44, 36,
  63, 55, 47, 39, 31, 23, 15,
  7, 62, 54, 46, 38, 30, 22,
  14, 6, 61, 53, 45, 37, 29,
  21, 13, 5, 28, 20, 12, 4
};

static uchar perm2[48] = { 14, 17, 11, 24, 1, 5,
  3, 28, 15, 6, 21, 10,
  23, 19, 12, 4, 26, 8,
  16, 7, 27, 20, 13, 2,
  41, 52, 31, 37, 47, 55,
  30, 40, 51, 45, 33, 48,
  44, 49, 39, 56, 34, 53,
  46, 42, 50, 36, 29, 32
};

static uchar perm3[64] = { 58, 50, 42, 34, 26, 18, 10, 2,
  60, 52, 44, 36, 28, 20, 12, 4,
  62, 54, 46, 38, 30, 22, 14, 6,
  64, 56, 48, 40, 32, 24, 16, 8,
  57, 49, 41, 33, 25, 17, 9, 1,
  59, 51, 43, 35, 27, 19, 11, 3,
  61, 53, 45, 37, 29, 21, 13, 5,
  63, 55, 47, 39, 31, 23, 15, 7
};

static uchar perm4[48] = { 32, 1, 2, 3, 4, 5,
  4, 5, 6, 7, 8, 9,
  8, 9, 10, 11, 12, 13,
  12, 13, 14, 15, 16, 17,
  16, 17, 18, 19, 20, 21,
  20, 21, 22, 23, 24, 25,
  24, 25, 26, 27, 28, 29,
  28, 29, 30, 31, 32, 1
};

static uchar perm5[32] = { 16, 7, 20, 21,
  29, 12, 28, 17,
  1, 15, 23, 26,
  5, 18, 31, 10,
  2, 8, 24, 14,
  32, 27, 3, 9,
  19, 13, 30, 6,
  22, 11, 4, 25
};


static uchar perm6[64] = { 40, 8, 48, 16, 56, 24, 64, 32,
  39, 7, 47, 15, 55, 23, 63, 31,
  38, 6, 46, 14, 54, 22, 62, 30,
  37, 5, 45, 13, 53, 21, 61, 29,
  36, 4, 44, 12, 52, 20, 60, 28,
  35, 3, 43, 11, 51, 19, 59, 27,
  34, 2, 42, 10, 50, 18, 58, 26,
  33, 1, 41, 9, 49, 17, 57, 25
};


static uchar sc[16] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };

static uchar sbox[8][4][16] = {
  {{14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7},
   {0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8},
   {4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0},
   {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13}},

  {{15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10},
   {3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5},
   {0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15},
   {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9}},

  {{10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8},
   {13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1},
   {13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7},
   {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12}},

  {{7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15},
   {13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9},
   {10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4},
   {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14}},

  {{2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9},
   {14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6},
   {4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14},
   {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3}},

  {{12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
   {10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
   {9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
   {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}},

  {{4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
   {13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
   {1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
   {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}},

  {{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
   {1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
   {7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
   {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}}
};

static void permute(char *out, char *in, uchar * p, int32_t n) {
  int32_t i;

  for (i = 0; i < n; i++)
    out[i] = in[p[i] - 1];
}

static void l_shift(char *d, int32_t count, int32_t n) {
  char out[64];
  int32_t i;

  for (i = 0; i < n; i++)
    out[i] = d[(i + count) % n];
  for (i = 0; i < n; i++)
    d[i] = out[i];
}

static void concat(char *out, char *in1, char *in2, int32_t l1, int32_t l2) {
  while (l1--)
    *out++ = *in1++;
  while (l2--)
    *out++ = *in2++;
}

void xor(char *out, char *in1, char *in2, int32_t n) {
  int32_t i;

  for (i = 0; i < n; i++)
    out[i] = in1[i] ^ in2[i];
}

static void dohash(char *out, char *in, char *key, int32_t forw) {
  int32_t i, j, k;
  char pk1[56];
  char c[28];
  char d[28];
  char cd[56];
  char ki[16][48];
  char pd1[64];
  char l[32], r[32];
  char rl[64];

  permute(pk1, key, perm1, 56);

  for (i = 0; i < 28; i++)
    c[i] = pk1[i];
  for (i = 0; i < 28; i++)
    d[i] = pk1[i + 28];

  for (i = 0; i < 16; i++) {
    l_shift(c, sc[i], 28);
    l_shift(d, sc[i], 28);

    concat(cd, c, d, 28, 28);
    permute(ki[i], cd, perm2, 48);
  }

  permute(pd1, in, perm3, 64);

  for (j = 0; j < 32; j++) {
    l[j] = pd1[j];
    r[j] = pd1[j + 32];
  }

  for (i = 0; i < 16; i++) {
    char er[48];
    char erk[48];
    char b[8][6];
    char cb[32];
    char pcb[32];
    char r2[32];

    permute(er, r, perm4, 48);

    xor(erk, er, ki[forw ? i : 15 - i], 48);

    for (j = 0; j < 8; j++)
      for (k = 0; k < 6; k++)
        b[j][k] = erk[j * 6 + k];

    for (j = 0; j < 8; j++) {
      int32_t m, n;

      m = (b[j][0] << 1) | b[j][5];

      n = (b[j][1] << 3) | (b[j][2] << 2) | (b[j][3] << 1) | b[j][4];

      for (k = 0; k < 4; k++)
        b[j][k] = (sbox[j][m][n] & (1 << (3 - k))) ? 1 : 0;
    }

    for (j = 0; j < 8; j++)
      for (k = 0; k < 4; k++)
        cb[j * 4 + k] = b[j][k];
    permute(pcb, cb, perm5, 32);

    xor(r2, l, pcb, 32);

    for (j = 0; j < 32; j++)
      l[j] = r[j];

    for (j = 0; j < 32; j++)
      r[j] = r2[j];
  }

  concat(rl, r, l, 32, 32);

  permute(out, rl, perm6, 64);
}

static void str_to_key(unsigned char *str, unsigned char *key) {
  int32_t i;

  key[0] = str[0] >> 1;
  key[1] = ((str[0] & 0x01) << 6) | (str[1] >> 2);
  key[2] = ((str[1] & 0x03) << 5) | (str[2] >> 3);
  key[3] = ((str[2] & 0x07) << 4) | (str[3] >> 4);
  key[4] = ((str[3] & 0x0F) << 3) | (str[4] >> 5);
  key[5] = ((str[4] & 0x1F) << 2) | (str[5] >> 6);
  key[6] = ((str[5] & 0x3F) << 1) | (str[6] >> 7);
  key[7] = str[6] & 0x7F;
  for (i = 0; i < 8; i++) {
    key[i] = (key[i] << 1);
  }
}


static void smbhash(unsigned char *out, unsigned char *in, unsigned char *key, int32_t forw) {
  int32_t i;
  char outb[64];
  char inb[64];
  char keyb[64];
  unsigned char key2[8];

  str_to_key(key, key2);

  for (i = 0; i < 64; i++) {
    inb[i] = (in[i / 8] & (1 << (7 - (i % 8)))) ? 1 : 0;
    keyb[i] = (key2[i / 8] & (1 << (7 - (i % 8)))) ? 1 : 0;
    outb[i] = 0;
  }

  dohash(outb, inb, keyb, forw);

  for (i = 0; i < 8; i++) {
    out[i] = 0;
  }

  for (i = 0; i < 64; i++) {
    if (outb[i])
      out[i / 8] |= (1 << (7 - (i % 8)));
  }
}

void E_P16(unsigned char *p14, unsigned char *p16) {
  unsigned char sp8[8] = { 0x4b, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25 };
  smbhash(p16, sp8, p14, 1);
  smbhash(p16 + 8, sp8, p14 + 7, 1);
}

void E_P24(unsigned char *p21, unsigned char *c8, unsigned char *p24) {
  smbhash(p24, c8, p21, 1);
  smbhash(p24 + 8, c8, p21 + 7, 1);
  smbhash(p24 + 16, c8, p21 + 14, 1);
}

void D_P16(unsigned char *p14, unsigned char *in, unsigned char *out) {
  smbhash(out, in, p14, 0);
  smbhash(out + 8, in + 8, p14 + 7, 0);
}

void E_old_pw_hash(unsigned char *p14, unsigned char *in, unsigned char *out) {
  smbhash(out, in, p14, 1);
  smbhash(out + 8, in + 8, p14 + 7, 1);
}

void cred_hash1(unsigned char *out, unsigned char *in, unsigned char *key) {
  unsigned char buf[8];

  smbhash(buf, in, key, 1);
  smbhash(out, buf, key + 9, 1);
}

void cred_hash2(unsigned char *out, unsigned char *in, unsigned char *key) {
  unsigned char buf[8];
  static unsigned char key2[8];

  smbhash(buf, in, key, 1);
  key2[0] = key[7];
  smbhash(out, buf, key2, 1);
}

void cred_hash3(unsigned char *out, unsigned char *in, unsigned char *key, int32_t forw) {
  static unsigned char key2[8];

  smbhash(out, in, key, forw);
  key2[0] = key[7];
  smbhash(out + 8, in + 8, key2, forw);
}

void SamOEMhash(unsigned char *data, unsigned char *key, int32_t val) {
  unsigned char s_box[256];
  unsigned char index_i = 0;
  unsigned char index_j = 0;
  unsigned char j = 0;
  int32_t ind;

  for (ind = 0; ind < 256; ind++) {
    s_box[ind] = (unsigned char) ind;
  }

  for (ind = 0; ind < 256; ind++) {
    unsigned char tc;

    j += (s_box[ind] + key[ind % 16]);

    tc = s_box[ind];
    s_box[ind] = s_box[j];
    s_box[j] = tc;
  }
  for (ind = 0; ind < (val ? 516 : 16); ind++) {
    unsigned char tc;
    unsigned char t;

    index_i++;
    index_j += s_box[index_i];

    tc = s_box[index_i];
    s_box[index_i] = s_box[index_j];
    s_box[index_j] = tc;

    t = s_box[index_i] + s_box[index_j];
    data[ind] = data[ind] ^ s_box[t];
  }
}

/* Samba encryption implementation*/


/****************************************************************************
 Like strncpy but always null terminates. Make sure there is room!
 The variable n should always be one less than the available size.
****************************************************************************/

char *StrnCpy(char *dest, const char *src, size_t n) {
  char *d = dest;

  if (!dest)
    return (NULL);
  if (!src) {
    *dest = 0;
    return (dest);
  }
  while (n-- && (*d++ = *src++));
  *d = 0;
  return (dest);
}

size_t skip_multibyte_char(char c) {
  return 0;
}


/*******************************************************************
safe string copy into a known length string. maxlength does not
include the terminating zero.
********************************************************************/
#define DEBUG(a,b) ;
char *safe_strcpy(char *dest, const char *src, size_t maxlength) {
  size_t len;

  if (!dest) {
    DEBUG(0, ("Error: NULL dest in safe_strcpy\n"));
    return NULL;
  }

  if (!src) {
    *dest = 0;
    return dest;
  }

  len = strlen(src);

  if (len > maxlength) {
    DEBUG(0, ("Error: string overflow by %d in safe_strcpy [%.50s]\n", (int32_t) (len - maxlength), src));
    len = maxlength;
  }

  memcpy(dest, src, len);
  dest[len] = 0;
  return dest;
}


void strupper(char *s) {
  while (*s) {
    {
      size_t skip = skip_multibyte_char(*s);

      if (skip != 0)
        s += skip;
      else {
        if (islower((int32_t) *s))
          *s = toupper((int32_t) *s);
        s++;
      }
    }
  }
}

extern void SMBOWFencrypt(uchar passwd[16], uchar * c8, uchar p24[24]);

/*
 This implements the X/Open SMB password encryption
 It takes a password, a 8 byte "crypt key" and puts 24 bytes of 
 encrypted password into p24 
 */

void SMBencrypt(uchar * passwd, uchar * c8, uchar * p24) {
  uchar p14[15], p21[21];

  memset(p21, '\0', 21);
  memset(p14, '\0', 14);
  StrnCpy((char *) p14, (char *) passwd, 14);

  strupper((char *) p14);
  E_P16(p14, p21);

  SMBOWFencrypt(p21, c8, p24);

#ifdef DEBUG_PASSWORD
  DEBUG(100, ("SMBencrypt: lm#, challenge, response\n"));
  dump_data(100, (char *) p21, 16);
  dump_data(100, (char *) c8, 8);
  dump_data(100, (char *) p24, 24);
#endif
}

/* Routines for Windows NT MD4 Hash functions. */
static int32_t _my_wcslen(int16 * str) {
  int32_t len = 0;

  while (*str++ != 0)
    len++;
  return len;
}

/*
 * Convert a string into an NT UNICODE string.
 * Note that regardless of processor type 
 * this must be in intel (little-endian)
 * format.
 */

static int32_t _my_mbstowcs(int16 * dst, uchar * src, int32_t len) {
  int32_t i;
  int16 val;

  for (i = 0; i < len; i++) {
    val = *src;
    SSVAL(dst, 0, val);
    dst++;
    src++;
    if (val == 0)
      break;
  }
  return i;
}

/* 
 * Creates the MD4 Hash of the users password in NT UNICODE.
 */

void E_md4hash(uchar * passwd, uchar * p16) {
  int32_t len;
  int16 wpwd[129];

  /* Password cannot be longer than 128 characters */
  len = strlen((char *) passwd);
  if (len > 128)
    len = 128;
  /* Password must be converted to NT unicode */
  _my_mbstowcs(wpwd, passwd, len);
  wpwd[len] = 0;                /* Ensure string is null terminated */
  /* Calculate length in bytes */
  len = _my_wcslen(wpwd) * sizeof(int16);

  mdfour(p16, (unsigned char *) wpwd, len);
}

/* Does both the NT and LM owfs of a user's password */
void nt_lm_owf_gen(char *pwd, uchar nt_p16[16], uchar p16[16]) {
  char passwd[130];

  memset(passwd, '\0', 130);
  safe_strcpy(passwd, pwd, sizeof(passwd) - 1);

  /* Calculate the MD4 hash (NT compatible) of the password */
  memset(nt_p16, '\0', 16);
  E_md4hash((uchar *) passwd, nt_p16);

#ifdef DEBUG_PASSWORD
  DEBUG(100, ("nt_lm_owf_gen: pwd, nt#\n"));
  dump_data(120, passwd, strlen(passwd));
  dump_data(100, (char *) nt_p16, 16);
#endif

  /* Mangle the passwords into Lanman format */
  passwd[14] = '\0';
  strupper(passwd);

  /* Calculate the SMB (lanman) hash functions of the password */

  memset(p16, '\0', 16);
  E_P16((uchar *) passwd, (uchar *) p16);

#ifdef DEBUG_PASSWORD
  DEBUG(100, ("nt_lm_owf_gen: pwd, lm#\n"));
  dump_data(120, passwd, strlen(passwd));
  dump_data(100, (char *) p16, 16);
#endif
  /* clear out local copy of user's password (just being paranoid). */
  memset(passwd, '\0', sizeof(passwd));
}

/* Does the des encryption from the NT or LM MD4 hash. */
void SMBOWFencrypt(uchar passwd[16], uchar * c8, uchar p24[24]) {
  uchar p21[21];

  memset(p21, '\0', 21);

  memcpy(p21, passwd, 16);
  E_P24(p21, c8, p24);
}

/* Does the des encryption from the FIRST 8 BYTES of the NT or LM MD4 hash. */
void NTLMSSPOWFencrypt(uchar passwd[8], uchar * ntlmchalresp, uchar p24[24]) {
  uchar p21[21];

  memset(p21, '\0', 21);
  memcpy(p21, passwd, 8);
  memset(p21 + 8, 0xbd, 8);

  E_P24(p21, ntlmchalresp, p24);
#ifdef DEBUG_PASSWORD
  DEBUG(100, ("NTLMSSPOWFencrypt: p21, c8, p24\n"));
  dump_data(100, (char *) p21, 21);
  dump_data(100, (char *) ntlmchalresp, 8);
  dump_data(100, (char *) p24, 24);
#endif
}


/* Does the NT MD4 hash then des encryption. */

void SMBNTencrypt(uchar * passwd, uchar * c8, uchar * p24) {
  uchar p21[21];

  memset(p21, '\0', 21);

  E_md4hash(passwd, p21);
  SMBOWFencrypt(p21, c8, p24);

#ifdef DEBUG_PASSWORD
  DEBUG(100, ("SMBNTencrypt: nt#, challenge, response\n"));
  dump_data(100, (char *) p21, 16);
  dump_data(100, (char *) c8, 8);
  dump_data(100, (char *) p24, 24);
#endif
}

#if 0

BOOL make_oem_passwd_hash(char data[516], const char *passwd, uchar old_pw_hash[16], BOOL unicode) {
  int32_t new_pw_len = strlen(passwd) * (unicode ? 2 : 1);

  if (new_pw_len > 512) {
    DEBUG(0, ("make_oem_passwd_hash: new password is too long.\n"));
    return False;
  }

  /*
   * Now setup the data area.
   * We need to generate a random fill
   * for this area to make it harder to
   * decrypt. JRA.
   */
  generate_random_buffer((unsigned char *) data, 516, False);
  if (unicode) {
    struni2(&data[512 - new_pw_len], passwd);
  } else {
    fstrcpy(&data[512 - new_pw_len], passwd);
  }
  SIVAL(data, 512, new_pw_len);

#ifdef DEBUG_PASSWORD
  DEBUG(100, ("make_oem_passwd_hash\n"));
  dump_data(100, data, 516);
#endif
  SamOEMhash((unsigned char *) data, (unsigned char *) old_pw_hash, True);

  return True;
}

#endif

/* libtnlm copyrigth was left here, anyway the interface was slightly modified */

/* included libntlm-3.2.9 (c) even if this code is based in 2.1 version*/

/*
Libntlm AUTHORS -- information about the authors
Copyright (C) 2002, 2003, 2004 Simon Josefsson
See the end for copying conditions.

Grant Edwards <grante@visi.com>
Original author of libntlm

Andrew Tridgell
Wrote functions borrowed from SMB.

Simon Josefsson <simon@josefsson.org>
Build environment, maintainer.

Frediano Ziglio
Contributed LGPL versions of some of the GPL'd Samba files.
*/

/* The [IS]VAL macros are to take care of byte order for non-Intel
 * Machines -- I think this file is OK, but it hasn't been tested.
 * The other files (the ones stolen from Samba) should be OK.
 * I am not crazy about these macros -- they seem to have gotten
 * a bit complex.  A new scheme for handling string/buffer fields
 * in the structures probably needs to be designed
 */

#define AddBytes(ptr, header, buf, count) \
{ \
if (buf != NULL && count != 0) \
  { \
  SSVAL(&ptr->header.len,0,count); \
  SSVAL(&ptr->header.maxlen,0,count); \
  SIVAL(&ptr->header.offset,0,((ptr->buffer - ((uint8*)ptr)) + ptr->bufIndex)); \
  memcpy(ptr->buffer+ptr->bufIndex, buf, count); \
  ptr->bufIndex += count; \
  } \
else \
  { \
  ptr->header.len = \
  ptr->header.maxlen = 0; \
  SIVAL(&ptr->header.offset,0,ptr->bufIndex); \
  } \
}

#define AddString(ptr, header, string) \
{ \
char *p = string; \
int32_t len = 0; \
if (p) len = strlen(p); \
AddBytes(ptr, header, ((unsigned char*)p), len); \
}

#define AddUnicodeString(ptr, header, string) \
{ \
char *p = string; \
unsigned char *b = NULL; \
int32_t len = 0; \
if (p) \
  { \
  len = strlen(p); \
  b = strToUnicode(p); \
  } \
AddBytes(ptr, header, b, len*2); \
}


#define GetUnicodeString(structPtr, header) \
unicodeToString(((char*)structPtr) + IVAL(&structPtr->header.offset,0) , SVAL(&structPtr->header.len,0)/2)
#define GetString(structPtr, header) \
toString((((char *)structPtr) + IVAL(&structPtr->header.offset,0)), SVAL(&structPtr->header.len,0))
#define DumpBuffer(fp, structPtr, header) \
dumpRaw(fp,((unsigned char*)structPtr)+IVAL(&structPtr->header.offset,0),SVAL(&structPtr->header.len,0))


static void dumpRaw(FILE * fp, unsigned char *buf, size_t len) {
  int32_t i;

  for (i = 0; i < (int32_t) len; ++i)
    fprintf(fp, "%02x ", buf[i]);

  fprintf(fp, "\n");
}

static char *unicodeToString(char *p, size_t len) {
  int32_t i;
  static char buf[4096];

  assert(len + 1 < sizeof buf);

  for (i = 0; i < (int32_t) len; ++i) {
    buf[i] = *p & 0x7f;
    p += 2;
  }

  buf[i] = '\0';
  return buf;
}

static unsigned char *strToUnicode(char *p) {
  static unsigned char buf[4096];
  size_t l = strlen(p);
  int32_t i = 0;

  assert(l * 2 < sizeof buf);

  while (l--) {
    buf[i++] = *p++;
    buf[i++] = 0;
  }

  return buf;
}

static unsigned char *toString(char *p, size_t len) {
  static unsigned char buf[4096];

  assert(len + 1 < sizeof buf);

  memcpy(buf, p, len);
  buf[len] = 0;
  return buf;
}


void buildAuthRequest(tSmbNtlmAuthRequest * request, long flags, char *host, char *domain) {
  char *h = NULL;               //strdup(host);
  char *p = NULL;               //strchr(h,'@');

//TODO: review default flags

  if (host == NULL)
    host = "";
  if (domain == NULL)
    domain = "";

  h = strdup(host);
  p = strchr(h, '@');
  if (p) {
    if (!domain)
      domain = p + 1;
    *p = '\0';
  }
  if (flags == 0)
    flags = 0x0000b207;         /* Lowest security options to avoid negotiation */
  request->bufIndex = 0;
  memcpy(request->ident, "NTLMSSP\0\0\0", 8);
  SIVAL(&request->msgType, 0, 1);
  SIVAL(&request->flags, 0, flags);

  assert(strlen(host) < 128);
  AddString(request, host, h);
  assert(strlen(domain) < 128);
  AddString(request, domain, domain);
  free(h);
}

void buildAuthResponse(tSmbNtlmAuthChallenge *challenge, tSmbNtlmAuthResponse * response, long flags, char *user, char *password, char *domainname, char *host) {
  uint8 lmRespData[24];
  uint8 ntRespData[24];
  char *u = strdup(user);
  char *p = strchr(u, '@');
  char *w = NULL;
  char *d = strdup(GetUnicodeString(challenge, uDomain));
  char *domain = d;

  if (domainname != NULL)
    domain = domainname;

  if (host == NULL)
    host = "";
  w = strdup(host);

  if (p) {
    domain = p + 1;
    *p = '\0';
  }

  SMBencrypt((unsigned char *) password, challenge->challengeData, lmRespData);
  SMBNTencrypt((unsigned char *) password, challenge->challengeData, ntRespData);

  response->bufIndex = 0;
  memcpy(response->ident, "NTLMSSP\0\0\0", 8);
  SIVAL(&response->msgType, 0, 3);

  AddBytes(response, lmResponse, lmRespData, 24);
  AddBytes(response, ntResponse, ntRespData, 24);

  assert(strlen(domain) < 128);
  AddUnicodeString(response, uDomain, domain);
  assert(strlen(u) < 128);
  AddUnicodeString(response, uUser, u);
  assert(strlen(w) < 128);
  AddUnicodeString(response, uWks, w);

  AddString(response, sessionKey, NULL);

  if (flags != 0)
    challenge->flags = flags;   /* Overide flags! */
  response->flags = challenge->flags;

  if (w)
    free(w);
  if (d)
    free(d);
  if (u)
    free(u);
}





// info functions
void dumpAuthRequest(FILE * fp, tSmbNtlmAuthRequest * request);
void dumpAuthChallenge(FILE * fp, tSmbNtlmAuthChallenge * challenge);
void dumpAuthResponse(FILE * fp, tSmbNtlmAuthResponse * response);

void dumpAuthRequest(FILE * fp, tSmbNtlmAuthRequest * request) {
  fprintf(fp, "NTLM Request:\n");
  fprintf(fp, "      Ident = %s\n", request->ident);
  fprintf(fp, "      mType = %u\n", IVAL(&request->msgType, 0));
  fprintf(fp, "      Flags = %08x\n", IVAL(&request->flags, 0));
  fprintf(fp, "       Host = %s\n", GetString(request, host));
  fprintf(fp, "     Domain = %s\n", GetString(request, domain));
}

void dumpAuthChallenge(FILE * fp, tSmbNtlmAuthChallenge * challenge) {
  fprintf(fp, "NTLM Challenge:\n");
  fprintf(fp, "      Ident = %s\n", challenge->ident);
  fprintf(fp, "      mType = %u\n", IVAL(&challenge->msgType, 0));
  fprintf(fp, "     Domain = %s\n", GetUnicodeString(challenge, uDomain));
  fprintf(fp, "      Flags = %08x\n", IVAL(&challenge->flags, 0));
  fprintf(fp, "  Challenge = ");
  dumpRaw(fp, challenge->challengeData, 8);
  fprintf(fp, "  Incomplete!! parse optional parameters\n");
}

void dumpAuthResponse(FILE * fp, tSmbNtlmAuthResponse * response) {
  fprintf(fp, "NTLM Response:\n");
  fprintf(fp, "      Ident = %s\n", response->ident);
  fprintf(fp, "      mType = %u\n", IVAL(&response->msgType, 0));
  fprintf(fp, "     LmResp = ");
  DumpBuffer(fp, response, lmResponse);
  fprintf(fp, "     NTResp = ");
  DumpBuffer(fp, response, ntResponse);
  fprintf(fp, "     Domain = %s\n", GetUnicodeString(response, uDomain));
  fprintf(fp, "       User = %s\n", GetUnicodeString(response, uUser));
  fprintf(fp, "        Wks = %s\n", GetUnicodeString(response, uWks));
  fprintf(fp, "       sKey = ");
  DumpBuffer(fp, response, sessionKey);
  fprintf(fp, "      Flags = %08x\n", IVAL(&response->flags, 0));
}







/*
 * base64.c -- base-64 conversion routines.
 *
 * For license terms, see the file COPYING in this directory.
 *
 * This base 64 encoding is defined in RFC2045 section 6.8,
 * "Base64 Content-Transfer-Encoding", but lines must not be broken in the
 * scheme used here.
 */

/*
 * This code borrowed from fetchmail sources
 */


static const char base64digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

#define BAD	-1
static const char base64val[] = {
  BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD,
  BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD,
  BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, BAD, 62, BAD, BAD, BAD, 63,
  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, BAD, BAD, BAD, BAD, BAD, BAD,
  BAD, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, BAD, BAD, BAD, BAD, BAD,
  BAD, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
  41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, BAD, BAD, BAD, BAD, BAD
};

#define DECODE64(c)  (isascii(c) ? base64val[c] : BAD)

void to64frombits(unsigned char *out, const unsigned char *in, int32_t inlen)

/* raw bytes in quasi-big-endian order to base 64 string (NUL-terminated) */
{
  for (; inlen >= 3; inlen -= 3) {
    *out++ = base64digits[in[0] >> 2];
    *out++ = base64digits[((in[0] << 4) & 0x30) | (in[1] >> 4)];
    *out++ = base64digits[((in[1] << 2) & 0x3c) | (in[2] >> 6)];
    *out++ = base64digits[in[2] & 0x3f];
    in += 3;
  }
  if (inlen > 0) {
    unsigned char fragment;

    *out++ = base64digits[in[0] >> 2];
    fragment = (in[0] << 4) & 0x30;
    if (inlen > 1)
      fragment |= in[1] >> 4;
    *out++ = base64digits[fragment];
    *out++ = (inlen < 2) ? '=' : base64digits[(in[1] << 2) & 0x3c];
    *out++ = '=';
  }
  *out = '\0';
}

int32_t from64tobits(char *out, const char *in)

/* base 64 to raw bytes in quasi-big-endian order, returning count of bytes */
{
  int32_t len = 0;
  register unsigned char digit1, digit2, digit3, digit4;

  if (in[0] == '+' && in[1] == ' ')
    in += 2;
  if (*in == '\r')
    return (0);

  do {
    digit1 = in[0];
    if (DECODE64(digit1) == BAD)
      return (-1);
    digit2 = in[1];
    if (DECODE64(digit2) == BAD)
      return (-1);
    digit3 = in[2];
    if (digit3 != '=' && DECODE64(digit3) == BAD)
      return (-1);
    digit4 = in[3];
    if (digit4 != '=' && DECODE64(digit4) == BAD)
      return (-1);
    in += 4;
    *out++ = (DECODE64(digit1) << 2) | (DECODE64(digit2) >> 4);
    ++len;
    if (digit3 != '=') {
      *out++ = ((DECODE64(digit2) << 4) & 0xf0) | (DECODE64(digit3) >> 2);
      ++len;
      if (digit4 != '=') {
        *out++ = ((DECODE64(digit3) << 6) & 0xc0) | DECODE64(digit4);
        ++len;
      }
    }
  } while (*in && *in != '\r' && digit4 != '=');

  return (len);
}

/* base64.c ends here */
