Unix SMB/CIFS implementation. More...

#include "md4.h"
#include <stdint.h>
#include <string.h>

Include dependency graph for md4.c:

Macros
#define	uint32 uint32_t

#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)

Functions
static uint32	F (uint32 X, uint32 Y, uint32 Z)

static uint32	G (uint32 X, uint32 Y, uint32 Z)

static uint32	H (uint32 X, uint32 Y, uint32 Z)

static uint32	lshift (uint32 x, int s)

static void	mdfour64_ntlmssp (uint32 *M)

static void	copy64_ntlmssp (uint32 M, const unsigned char in)

static void	copy4_ntlmssp (unsigned char *out, uint32 x)

void	mdfour_ntlmssp (unsigned char out, const unsigned char in, int n)

Variables
static uint32	A

static uint32	B

static uint32	C

static uint32	D

Detailed Description

Unix SMB/CIFS implementation.

A implementation of MD4 designed for use in the SMB authentication protocol

Definition in file md4.c.

Macro Definition Documentation

◆ ROUND1

#define ROUND1	(	a,
		b,
		c,
		d,
		k,
		s
	)	a = lshift (a + F (b, c, d) + X[k], s)

Definition at line 55 of file md4.c.

◆ ROUND2

#define ROUND2	(	a,
		b,
		c,
		d,
		k,
		s
	)	a = lshift (a + G (b, c, d) + X[k] + (uint32) 0x5A827999, s)

Definition at line 56 of file md4.c.

◆ ROUND3

#define ROUND3	(	a,
		b,
		c,
		d,
		k,
		s
	)	a = lshift (a + H (b, c, d) + X[k] + (uint32) 0x6ED9EBA1, s)

Definition at line 58 of file md4.c.

◆ uint32

#define uint32 uint32_t

Definition at line 20 of file md4.c.

Function Documentation

◆ copy4_ntlmssp()

static void copy4_ntlmssp	(	unsigned char *	out,
		uint32	x
	)

static

Definition at line 155 of file md4.c.

{
  out[0] = x & 0xFF;
  out[1] = (x >> 8) & 0xFF;
  out[2] = (x >> 16) & 0xFF;
  out[3] = (x >> 24) & 0xFF;
}

Referenced by mdfour_ntlmssp().

Here is the caller graph for this function:

◆ copy64_ntlmssp()

static void copy64_ntlmssp	(	uint32 *	M,
		const unsigned char *	in
	)

static

Definition at line 145 of file md4.c.

{
  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);
}

Referenced by mdfour_ntlmssp().

Here is the caller graph for this function:

◆ F()

static uint32 F	(	uint32	X,
		uint32	Y,
		uint32	Z
	)

static

Definition at line 31 of file md4.c.

{
  return (X & Y) | ((~X) & Z);
}

◆ G()

static uint32 G	(	uint32	X,
		uint32	Y,
		uint32	Z
	)

static

Definition at line 37 of file md4.c.

{
  return (X & Y) | (X & Z) | (Y & Z);
}

◆ H()

static uint32 H	(	uint32	X,
		uint32	Y,
		uint32	Z
	)

static

Definition at line 43 of file md4.c.

{
  return X ^ Y ^ Z;
}

◆ lshift()

static uint32 lshift	(	uint32	x,
		int	s
	)

static

Definition at line 49 of file md4.c.

{
  x &= 0xFFFFFFFF;
  return ((x << s) & 0xFFFFFFFF) | (x >> (32 - s));
}

◆ mdfour64_ntlmssp()

static void mdfour64_ntlmssp ( uint32 * M )

static

Definition at line 63 of file md4.c.

{
  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 (size_t i = 0; i < 16; i++)
    {
      *(volatile char *) (X + i) = '\0';
    }
}

References A, B, C, D, ROUND1, ROUND2, ROUND3, and uint32.

Referenced by mdfour_ntlmssp().

Here is the caller graph for this function:

◆ mdfour_ntlmssp()

void mdfour_ntlmssp	(	unsigned char *	out,
		const unsigned char *	in,
		int	n
	)

Definition at line 165 of file md4.c.

{
  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_ntlmssp (M, in);
      mdfour64_ntlmssp (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_ntlmssp (buf + 56, b);
      copy64_ntlmssp (M, buf);
      mdfour64_ntlmssp (M);
    }
  else
    {
      copy4_ntlmssp (buf + 120, b);
      copy64_ntlmssp (M, buf);
      mdfour64_ntlmssp (M);
      copy64_ntlmssp (M, buf + 64);
      mdfour64_ntlmssp (M);
    }
 
  for (i = 0; i < 128; i++)
    buf[i] = 0;
  copy64_ntlmssp (M, buf);
 
  copy4_ntlmssp (out, A);
  copy4_ntlmssp (out + 4, B);
  copy4_ntlmssp (out + 8, C);
  copy4_ntlmssp (out + 12, D);
 
  A = B = C = D = 0;
}