utils/ntlm.c

 
#include <winpr/config.h>
 
#include <winpr/ntlm.h>
#include <winpr/assert.h>
 
#include <winpr/crt.h>
#include <winpr/crypto.h>
 
BOOL NTOWFv1W(LPCWSTR Password, UINT32 PasswordLengthInBytes, BYTE* NtHash)
{
  if (!Password || !NtHash)
    return FALSE;
 
  if (!winpr_Digest(WINPR_MD_MD4, Password, PasswordLengthInBytes, NtHash,
                    WINPR_MD4_DIGEST_LENGTH))
    return FALSE;
 
  return TRUE;
}
 
BOOL NTOWFv1A(LPCSTR Password, UINT32 PasswordLengthInBytes, BYTE* NtHash)
{
  LPWSTR PasswordW = nullptr;
  BOOL result = FALSE;
  size_t pwdCharLength = 0;
 
  if (!NtHash)
    return FALSE;
 
  if (!Password && (PasswordLengthInBytes > 0))
    return FALSE;
 
  if (Password)
  {
    PasswordW = ConvertUtf8NToWCharAlloc(Password, PasswordLengthInBytes, &pwdCharLength);
    if (!PasswordW)
      return FALSE;
  }
 
  if (!NTOWFv1W(PasswordW, WINPR_ASSERTING_INT_CAST(UINT32, pwdCharLength * sizeof(WCHAR)),
                NtHash))
    goto out_fail;
 
  result = TRUE;
out_fail:
  free(PasswordW);
  return result;
}
 
BOOL NTOWFv2W(LPCWSTR Password, UINT32 PasswordLengthInBytes, LPCWSTR User,
              UINT32 UserLengthInBytes, LPCWSTR Domain, UINT32 DomainLengthInBytes, BYTE* NtHash)
{
  BYTE NtHashV1[WINPR_MD5_DIGEST_LENGTH];
 
  if (!Domain && (DomainLengthInBytes > 0))
    return FALSE;
  if (!User || !Password || !NtHash)
    return FALSE;
 
  if (!NTOWFv1W(Password, PasswordLengthInBytes, NtHashV1))
    return FALSE;
 
  return NTOWFv2FromHashW(NtHashV1, User, UserLengthInBytes, Domain, DomainLengthInBytes, NtHash);
}
 
BOOL NTOWFv2A(LPCSTR Password, UINT32 PasswordLengthInBytes, LPCSTR User, UINT32 UserLengthInBytes,
              LPCSTR Domain, UINT32 DomainLengthInBytes, BYTE* NtHash)
{
  LPWSTR UserW = nullptr;
  LPWSTR DomainW = nullptr;
  LPWSTR PasswordW = nullptr;
  BOOL result = FALSE;
  size_t userCharLength = 0;
  size_t domainCharLength = 0;
  size_t pwdCharLength = 0;
 
  if (!NtHash)
    return FALSE;
 
  if (!User && (UserLengthInBytes > 0))
    return FALSE;
  if (!Password && (PasswordLengthInBytes > 0))
    return FALSE;
  if (!Domain && (DomainLengthInBytes > 0))
    return FALSE;
 
  if (User)
  {
    UserW = ConvertUtf8NToWCharAlloc(User, UserLengthInBytes, &userCharLength);
    if (!UserW)
      goto out_fail;
  }
  if (Domain)
  {
    DomainW = ConvertUtf8NToWCharAlloc(Domain, DomainLengthInBytes, &domainCharLength);
    if (!DomainW)
      goto out_fail;
  }
  if (Password)
  {
    PasswordW = ConvertUtf8NToWCharAlloc(Password, PasswordLengthInBytes, &pwdCharLength);
    if (!PasswordW)
      goto out_fail;
  }
 
  if (!NTOWFv2W(PasswordW, (UINT32)pwdCharLength * sizeof(WCHAR), UserW,
                (UINT32)userCharLength * sizeof(WCHAR), DomainW,
                (UINT32)domainCharLength * sizeof(WCHAR), NtHash))
    goto out_fail;
 
  result = TRUE;
out_fail:
  free(UserW);
  free(DomainW);
  free(PasswordW);
  return result;
}
 
BOOL NTOWFv2FromHashW(const BYTE* NtHashV1, LPCWSTR User, UINT32 UserLengthInBytes, LPCWSTR Domain,
                      UINT32 DomainLengthInBytes, BYTE* NtHash)
{
  BYTE result = FALSE;
 
  if (!NtHash || !NtHashV1)
    return FALSE;
 
  if (!User && (UserLengthInBytes > 0))
    return FALSE;
  if (!Domain && (DomainLengthInBytes > 0))
    return FALSE;
 
  if (!User)
    return FALSE;
 
  BYTE* buffer = (BYTE*)malloc(UserLengthInBytes + DomainLengthInBytes);
  if (!buffer)
    return FALSE;
 
  /* Concatenate(UpperCase(User), Domain) */
  CopyMemory(buffer, User, UserLengthInBytes);
  CharUpperBuffW((LPWSTR)buffer, UserLengthInBytes / 2);
 
  if (DomainLengthInBytes > 0)
  {
    CopyMemory(&buffer[UserLengthInBytes], Domain, DomainLengthInBytes);
  }
 
  /* Compute the HMAC-MD5 hash of the above value using the NTLMv1 hash as the key, the result is
   * the NTLMv2 hash */
  if (!winpr_HMAC(WINPR_MD_MD5, NtHashV1, 16, buffer, UserLengthInBytes + DomainLengthInBytes,
                  NtHash, WINPR_MD5_DIGEST_LENGTH))
    goto out_fail;
 
  result = TRUE;
out_fail:
  free(buffer);
  return result;
}
 
BOOL NTOWFv2FromHashA(const BYTE* NtHashV1, LPCSTR User, UINT32 UserLengthInBytes, LPCSTR Domain,
                      UINT32 DomainLengthInBytes, BYTE* NtHash)
{
  LPWSTR UserW = nullptr;
  LPWSTR DomainW = nullptr;
  BOOL result = FALSE;
  size_t userCharLength = 0;
  size_t domainCharLength = 0;
 
  if (!NtHash || !NtHashV1)
    return FALSE;
 
  if (!User && (UserLengthInBytes > 0))
    return FALSE;
  if (!Domain && (DomainLengthInBytes > 0))
    return FALSE;
 
  if (User)
  {
    UserW = ConvertUtf8NToWCharAlloc(User, UserLengthInBytes, &userCharLength);
    if (!UserW)
      goto out_fail;
  }
 
  if (Domain)
  {
    DomainW = ConvertUtf8NToWCharAlloc(Domain, DomainLengthInBytes, &domainCharLength);
    if (!DomainW)
      goto out_fail;
  }
 
  if (!NTOWFv2FromHashW(NtHashV1, UserW, (UINT32)userCharLength * sizeof(WCHAR), DomainW,
                        (UINT32)domainCharLength * sizeof(WCHAR), NtHash))
    goto out_fail;
 
  result = TRUE;
out_fail:
  free(UserW);
  free(DomainW);
  return result;
}