mirror of
https://github.com/jellyfin/jellyfin.git
synced 2024-09-07 20:08:59 +02:00
807 lines
22 KiB
C#
807 lines
22 KiB
C#
// This code is derived from jcifs smb client library <jcifs at samba dot org>
|
|
// Ported by J. Arturo <webmaster at komodosoft dot net>
|
|
//
|
|
// This library is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public
|
|
// License as published by the Free Software Foundation; either
|
|
// version 2.1 of the License, or (at your option) any later version.
|
|
//
|
|
// This library 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
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
using System;
|
|
using SharpCifs.Util;
|
|
using SharpCifs.Util.Sharpen;
|
|
|
|
namespace SharpCifs.Smb
|
|
{
|
|
/// <summary>This class stores and encrypts NTLM user credentials.</summary>
|
|
/// <remarks>
|
|
/// This class stores and encrypts NTLM user credentials. The default
|
|
/// credentials are retrieved from the <tt>jcifs.smb.client.domain</tt>,
|
|
/// <tt>jcifs.smb.client.username</tt>, and <tt>jcifs.smb.client.password</tt>
|
|
/// properties.
|
|
/// <p>
|
|
/// Read <a href="../../../authhandler.html">jCIFS Exceptions and
|
|
/// NtlmAuthenticator</a> for related information.
|
|
/// </remarks>
|
|
|
|
public sealed class NtlmPasswordAuthentication : Principal
|
|
{
|
|
private static readonly int LmCompatibility = Config.GetInt("jcifs.smb.lmCompatibility"
|
|
, 3);
|
|
|
|
private static readonly Random Random = new Random();
|
|
|
|
private static LogStream _log = LogStream.GetInstance();
|
|
|
|
private static readonly byte[] S8 = { unchecked(unchecked(0x4b)), unchecked(unchecked(0x47)), unchecked(unchecked(0x53)), unchecked(unchecked(0x21)), unchecked(unchecked(0x40)), unchecked(unchecked(0x23)), unchecked(unchecked(0x24)), unchecked(unchecked(0x25)) };
|
|
|
|
// KGS!@#$%
|
|
private static void E(byte[] key, byte[] data, byte[] e)
|
|
{
|
|
byte[] key7 = new byte[7];
|
|
byte[] e8 = new byte[8];
|
|
for (int i = 0; i < key.Length / 7; i++)
|
|
{
|
|
Array.Copy(key, i * 7, key7, 0, 7);
|
|
DES des = new DES(key7);
|
|
des.Encrypt(data, e8);
|
|
Array.Copy(e8, 0, e, i * 8, 8);
|
|
}
|
|
}
|
|
|
|
internal static string DefaultDomain;
|
|
|
|
internal static string DefaultUsername;
|
|
|
|
internal static string DefaultPassword;
|
|
|
|
internal static readonly string Blank = string.Empty;
|
|
|
|
public static readonly NtlmPasswordAuthentication Anonymous = new NtlmPasswordAuthentication
|
|
(string.Empty, string.Empty, string.Empty);
|
|
|
|
internal static void InitDefaults()
|
|
{
|
|
if (DefaultDomain != null)
|
|
{
|
|
return;
|
|
}
|
|
DefaultDomain = Config.GetProperty("jcifs.smb.client.domain", "?");
|
|
DefaultUsername = Config.GetProperty("jcifs.smb.client.username", "GUEST");
|
|
DefaultPassword = Config.GetProperty("jcifs.smb.client.password", Blank);
|
|
}
|
|
|
|
/// <summary>Generate the ANSI DES hash for the password associated with these credentials.
|
|
/// </summary>
|
|
/// <remarks>Generate the ANSI DES hash for the password associated with these credentials.
|
|
/// </remarks>
|
|
public static byte[] GetPreNtlmResponse(string password, byte[] challenge)
|
|
{
|
|
byte[] p14 = new byte[14];
|
|
byte[] p21 = new byte[21];
|
|
byte[] p24 = new byte[24];
|
|
byte[] passwordBytes;
|
|
try
|
|
{
|
|
passwordBytes = Runtime.GetBytesForString(password.ToUpper(), SmbConstants.OemEncoding);
|
|
}
|
|
catch (UnsupportedEncodingException uee)
|
|
{
|
|
throw new RuntimeException("Try setting jcifs.encoding=US-ASCII", uee);
|
|
}
|
|
int passwordLength = passwordBytes.Length;
|
|
// Only encrypt the first 14 bytes of the password for Pre 0.12 NT LM
|
|
if (passwordLength > 14)
|
|
{
|
|
passwordLength = 14;
|
|
}
|
|
Array.Copy(passwordBytes, 0, p14, 0, passwordLength);
|
|
E(p14, S8, p21);
|
|
E(p21, challenge, p24);
|
|
return p24;
|
|
}
|
|
|
|
/// <summary>Generate the Unicode MD4 hash for the password associated with these credentials.
|
|
/// </summary>
|
|
/// <remarks>Generate the Unicode MD4 hash for the password associated with these credentials.
|
|
/// </remarks>
|
|
public static byte[] GetNtlmResponse(string password, byte[] challenge)
|
|
{
|
|
byte[] uni = null;
|
|
byte[] p21 = new byte[21];
|
|
byte[] p24 = new byte[24];
|
|
try
|
|
{
|
|
uni = Runtime.GetBytesForString(password, SmbConstants.UniEncoding);
|
|
}
|
|
catch (UnsupportedEncodingException uee)
|
|
{
|
|
if (_log.Level > 0)
|
|
{
|
|
Runtime.PrintStackTrace(uee, _log);
|
|
}
|
|
}
|
|
Md4 md4 = new Md4();
|
|
md4.Update(uni);
|
|
try
|
|
{
|
|
md4.Digest(p21, 0, 16);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_log.Level > 0)
|
|
{
|
|
Runtime.PrintStackTrace(ex, _log);
|
|
}
|
|
}
|
|
E(p21, challenge, p24);
|
|
return p24;
|
|
}
|
|
|
|
/// <summary>Creates the LMv2 response for the supplied information.</summary>
|
|
/// <remarks>Creates the LMv2 response for the supplied information.</remarks>
|
|
/// <param name="domain">The domain in which the username exists.</param>
|
|
/// <param name="user">The username.</param>
|
|
/// <param name="password">The user's password.</param>
|
|
/// <param name="challenge">The server challenge.</param>
|
|
/// <param name="clientChallenge">The client challenge (nonce).</param>
|
|
public static byte[] GetLMv2Response(string domain, string user, string password,
|
|
byte[] challenge, byte[] clientChallenge)
|
|
{
|
|
try
|
|
{
|
|
byte[] hash = new byte[16];
|
|
byte[] response = new byte[24];
|
|
// The next 2-1/2 lines of this should be placed with nTOWFv1 in place of password
|
|
Md4 md4 = new Md4();
|
|
md4.Update(Runtime.GetBytesForString(password, SmbConstants.UniEncoding)
|
|
);
|
|
Hmact64 hmac = new Hmact64(md4.Digest());
|
|
hmac.Update(Runtime.GetBytesForString(user.ToUpper(), SmbConstants.UniEncoding
|
|
));
|
|
hmac.Update(Runtime.GetBytesForString(domain.ToUpper(), SmbConstants.UniEncoding
|
|
));
|
|
hmac = new Hmact64(hmac.Digest());
|
|
hmac.Update(challenge);
|
|
hmac.Update(clientChallenge);
|
|
hmac.Digest(response, 0, 16);
|
|
Array.Copy(clientChallenge, 0, response, 16, 8);
|
|
return response;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_log.Level > 0)
|
|
{
|
|
Runtime.PrintStackTrace(ex, _log);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static byte[] GetNtlm2Response(byte[] nTowFv1, byte[] serverChallenge, byte
|
|
[] clientChallenge)
|
|
{
|
|
byte[] sessionHash = new byte[8];
|
|
try
|
|
{
|
|
MessageDigest md5;
|
|
md5 = MessageDigest.GetInstance("MD5");
|
|
md5.Update(serverChallenge);
|
|
md5.Update(clientChallenge, 0, 8);
|
|
Array.Copy(md5.Digest(), 0, sessionHash, 0, 8);
|
|
}
|
|
catch (Exception gse)
|
|
{
|
|
if (_log.Level > 0)
|
|
{
|
|
Runtime.PrintStackTrace(gse, _log);
|
|
}
|
|
throw new RuntimeException("MD5", gse);
|
|
}
|
|
byte[] key = new byte[21];
|
|
Array.Copy(nTowFv1, 0, key, 0, 16);
|
|
byte[] ntResponse = new byte[24];
|
|
E(key, sessionHash, ntResponse);
|
|
return ntResponse;
|
|
}
|
|
|
|
public static byte[] NtowFv1(string password)
|
|
{
|
|
if (password == null)
|
|
{
|
|
throw new RuntimeException("Password parameter is required");
|
|
}
|
|
try
|
|
{
|
|
Md4 md4 = new Md4();
|
|
md4.Update(Runtime.GetBytesForString(password, SmbConstants.UniEncoding)
|
|
);
|
|
return md4.Digest();
|
|
}
|
|
catch (UnsupportedEncodingException uee)
|
|
{
|
|
throw new RuntimeException(uee.Message);
|
|
}
|
|
}
|
|
|
|
public static byte[] NtowFv2(string domain, string username, string password)
|
|
{
|
|
try
|
|
{
|
|
Md4 md4 = new Md4();
|
|
md4.Update(Runtime.GetBytesForString(password, SmbConstants.UniEncoding)
|
|
);
|
|
Hmact64 hmac = new Hmact64(md4.Digest());
|
|
hmac.Update(Runtime.GetBytesForString(username.ToUpper(), SmbConstants.UniEncoding
|
|
));
|
|
hmac.Update(Runtime.GetBytesForString(domain, SmbConstants.UniEncoding));
|
|
return hmac.Digest();
|
|
}
|
|
catch (UnsupportedEncodingException uee)
|
|
{
|
|
throw new RuntimeException(uee.Message);
|
|
}
|
|
}
|
|
|
|
internal static byte[] ComputeResponse(byte[] responseKey, byte[] serverChallenge
|
|
, byte[] clientData, int offset, int length)
|
|
{
|
|
Hmact64 hmac = new Hmact64(responseKey);
|
|
hmac.Update(serverChallenge);
|
|
hmac.Update(clientData, offset, length);
|
|
byte[] mac = hmac.Digest();
|
|
byte[] ret = new byte[mac.Length + clientData.Length];
|
|
Array.Copy(mac, 0, ret, 0, mac.Length);
|
|
Array.Copy(clientData, 0, ret, mac.Length, clientData.Length);
|
|
return ret;
|
|
}
|
|
|
|
public static byte[] GetLMv2Response(byte[] responseKeyLm, byte[] serverChallenge
|
|
, byte[] clientChallenge)
|
|
{
|
|
return ComputeResponse(responseKeyLm, serverChallenge
|
|
, clientChallenge, 0, clientChallenge.Length);
|
|
}
|
|
|
|
public static byte[] GetNtlMv2Response(byte[] responseKeyNt, byte[] serverChallenge
|
|
, byte[] clientChallenge, long nanos1601, byte[] targetInfo)
|
|
{
|
|
int targetInfoLength = targetInfo != null ? targetInfo.Length : 0;
|
|
byte[] temp = new byte[28 + targetInfoLength + 4];
|
|
Encdec.Enc_uint32le(unchecked(0x00000101), temp, 0);
|
|
// Header
|
|
Encdec.Enc_uint32le(unchecked(0x00000000), temp, 4);
|
|
// Reserved
|
|
Encdec.Enc_uint64le(nanos1601, temp, 8);
|
|
Array.Copy(clientChallenge, 0, temp, 16, 8);
|
|
Encdec.Enc_uint32le(unchecked(0x00000000), temp, 24);
|
|
// Unknown
|
|
if (targetInfo != null)
|
|
{
|
|
Array.Copy(targetInfo, 0, temp, 28, targetInfoLength);
|
|
}
|
|
Encdec.Enc_uint32le(unchecked(0x00000000), temp, 28 + targetInfoLength);
|
|
// mystery bytes!
|
|
return ComputeResponse(responseKeyNt, serverChallenge
|
|
, temp, 0, temp.Length);
|
|
}
|
|
|
|
internal static readonly NtlmPasswordAuthentication Null = new NtlmPasswordAuthentication
|
|
(string.Empty, string.Empty, string.Empty);
|
|
|
|
internal static readonly NtlmPasswordAuthentication Guest = new NtlmPasswordAuthentication
|
|
("?", "GUEST", string.Empty);
|
|
|
|
internal static readonly NtlmPasswordAuthentication Default = new NtlmPasswordAuthentication
|
|
(null);
|
|
|
|
internal string Domain;
|
|
|
|
internal string Username;
|
|
|
|
internal string Password;
|
|
|
|
internal byte[] AnsiHash;
|
|
|
|
internal byte[] UnicodeHash;
|
|
|
|
internal bool HashesExternal;
|
|
|
|
internal byte[] ClientChallenge;
|
|
|
|
internal byte[] Challenge;
|
|
|
|
/// <summary>
|
|
/// Create an <tt>NtlmPasswordAuthentication</tt> object from the userinfo
|
|
/// component of an SMB URL like "<tt>domain;user:pass</tt>".
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create an <tt>NtlmPasswordAuthentication</tt> object from the userinfo
|
|
/// component of an SMB URL like "<tt>domain;user:pass</tt>". This constructor
|
|
/// is used internally be jCIFS when parsing SMB URLs.
|
|
/// </remarks>
|
|
public NtlmPasswordAuthentication(string userInfo)
|
|
{
|
|
Domain = Username = Password = null;
|
|
if (userInfo != null)
|
|
{
|
|
try
|
|
{
|
|
userInfo = Unescape(userInfo);
|
|
}
|
|
catch (UnsupportedEncodingException)
|
|
{
|
|
}
|
|
int i;
|
|
int u;
|
|
int end;
|
|
char c;
|
|
end = userInfo.Length;
|
|
for (i = 0, u = 0; i < end; i++)
|
|
{
|
|
c = userInfo[i];
|
|
if (c == ';')
|
|
{
|
|
Domain = Runtime.Substring(userInfo, 0, i);
|
|
u = i + 1;
|
|
}
|
|
else
|
|
{
|
|
if (c == ':')
|
|
{
|
|
Password = Runtime.Substring(userInfo, i + 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Username = Runtime.Substring(userInfo, u, i);
|
|
}
|
|
InitDefaults();
|
|
if (Domain == null)
|
|
{
|
|
Domain = DefaultDomain;
|
|
}
|
|
if (Username == null)
|
|
{
|
|
Username = DefaultUsername;
|
|
}
|
|
if (Password == null)
|
|
{
|
|
Password = DefaultPassword;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create an <tt>NtlmPasswordAuthentication</tt> object from a
|
|
/// domain, username, and password.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create an <tt>NtlmPasswordAuthentication</tt> object from a
|
|
/// domain, username, and password. Parameters that are <tt>null</tt>
|
|
/// will be substituted with <tt>jcifs.smb.client.domain</tt>,
|
|
/// <tt>jcifs.smb.client.username</tt>, <tt>jcifs.smb.client.password</tt>
|
|
/// property values.
|
|
/// </remarks>
|
|
public NtlmPasswordAuthentication(string domain, string username, string password
|
|
)
|
|
{
|
|
int ci;
|
|
if (username != null)
|
|
{
|
|
ci = username.IndexOf('@');
|
|
if (ci > 0)
|
|
{
|
|
domain = Runtime.Substring(username, ci + 1);
|
|
username = Runtime.Substring(username, 0, ci);
|
|
}
|
|
else
|
|
{
|
|
ci = username.IndexOf('\\');
|
|
if (ci > 0)
|
|
{
|
|
domain = Runtime.Substring(username, 0, ci);
|
|
username = Runtime.Substring(username, ci + 1);
|
|
}
|
|
}
|
|
}
|
|
this.Domain = domain;
|
|
this.Username = username;
|
|
this.Password = password;
|
|
InitDefaults();
|
|
if (domain == null)
|
|
{
|
|
this.Domain = DefaultDomain;
|
|
}
|
|
if (username == null)
|
|
{
|
|
this.Username = DefaultUsername;
|
|
}
|
|
if (password == null)
|
|
{
|
|
this.Password = DefaultPassword;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create an <tt>NtlmPasswordAuthentication</tt> object with raw password
|
|
/// hashes.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create an <tt>NtlmPasswordAuthentication</tt> object with raw password
|
|
/// hashes. This is used exclusively by the <tt>jcifs.http.NtlmSsp</tt>
|
|
/// class which is in turn used by NTLM HTTP authentication functionality.
|
|
/// </remarks>
|
|
public NtlmPasswordAuthentication(string domain, string username, byte[] challenge
|
|
, byte[] ansiHash, byte[] unicodeHash)
|
|
{
|
|
if (domain == null || username == null || ansiHash == null || unicodeHash == null)
|
|
{
|
|
throw new ArgumentException("External credentials cannot be null");
|
|
}
|
|
this.Domain = domain;
|
|
this.Username = username;
|
|
Password = null;
|
|
this.Challenge = challenge;
|
|
this.AnsiHash = ansiHash;
|
|
this.UnicodeHash = unicodeHash;
|
|
HashesExternal = true;
|
|
}
|
|
|
|
/// <summary>Returns the domain.</summary>
|
|
/// <remarks>Returns the domain.</remarks>
|
|
public string GetDomain()
|
|
{
|
|
return Domain;
|
|
}
|
|
|
|
/// <summary>Returns the username.</summary>
|
|
/// <remarks>Returns the username.</remarks>
|
|
public string GetUsername()
|
|
{
|
|
return Username;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the password in plain text or <tt>null</tt> if the raw password
|
|
/// hashes were used to construct this <tt>NtlmPasswordAuthentication</tt>
|
|
/// object which will be the case when NTLM HTTP Authentication is
|
|
/// used.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns the password in plain text or <tt>null</tt> if the raw password
|
|
/// hashes were used to construct this <tt>NtlmPasswordAuthentication</tt>
|
|
/// object which will be the case when NTLM HTTP Authentication is
|
|
/// used. There is no way to retrieve a users password in plain text unless
|
|
/// it is supplied by the user at runtime.
|
|
/// </remarks>
|
|
public string GetPassword()
|
|
{
|
|
return Password;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the domain and username in the format:
|
|
/// <tt>domain\\username</tt>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Return the domain and username in the format:
|
|
/// <tt>domain\\username</tt>. This is equivalent to <tt>toString()</tt>.
|
|
/// </remarks>
|
|
public new string GetName()
|
|
{
|
|
bool d = Domain.Length > 0 && Domain.Equals("?") == false;
|
|
return d ? Domain + "\\" + Username : Username;
|
|
}
|
|
|
|
/// <summary>Computes the 24 byte ANSI password hash given the 8 byte server challenge.
|
|
/// </summary>
|
|
/// <remarks>Computes the 24 byte ANSI password hash given the 8 byte server challenge.
|
|
/// </remarks>
|
|
public byte[] GetAnsiHash(byte[] challenge)
|
|
{
|
|
if (HashesExternal)
|
|
{
|
|
return AnsiHash;
|
|
}
|
|
switch (LmCompatibility)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
{
|
|
return GetPreNtlmResponse(Password, challenge);
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
return GetNtlmResponse(Password, challenge);
|
|
}
|
|
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
{
|
|
if (ClientChallenge == null)
|
|
{
|
|
ClientChallenge = new byte[8];
|
|
Random.NextBytes(ClientChallenge);
|
|
}
|
|
return GetLMv2Response(Domain, Username, Password, challenge, ClientChallenge);
|
|
}
|
|
|
|
default:
|
|
{
|
|
return GetPreNtlmResponse(Password, challenge);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>Computes the 24 byte Unicode password hash given the 8 byte server challenge.
|
|
/// </summary>
|
|
/// <remarks>Computes the 24 byte Unicode password hash given the 8 byte server challenge.
|
|
/// </remarks>
|
|
public byte[] GetUnicodeHash(byte[] challenge)
|
|
{
|
|
if (HashesExternal)
|
|
{
|
|
return UnicodeHash;
|
|
}
|
|
switch (LmCompatibility)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
{
|
|
return GetNtlmResponse(Password, challenge);
|
|
}
|
|
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
{
|
|
return new byte[0];
|
|
}
|
|
|
|
default:
|
|
{
|
|
return GetNtlmResponse(Password, challenge);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
|
|
public byte[] GetSigningKey(byte[] challenge)
|
|
{
|
|
switch (LmCompatibility)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
{
|
|
byte[] signingKey = new byte[40];
|
|
GetUserSessionKey(challenge, signingKey, 0);
|
|
Array.Copy(GetUnicodeHash(challenge), 0, signingKey, 16, 24);
|
|
return signingKey;
|
|
}
|
|
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
{
|
|
throw new SmbException("NTLMv2 requires extended security (jcifs.smb.client.useExtendedSecurity must be true if jcifs.smb.lmCompatibility >= 3)"
|
|
);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Returns the effective user session key.</summary>
|
|
/// <remarks>Returns the effective user session key.</remarks>
|
|
/// <param name="challenge">The server challenge.</param>
|
|
/// <returns>
|
|
/// A <code>byte[]</code> containing the effective user session key,
|
|
/// used in SMB MAC signing and NTLMSSP signing and sealing.
|
|
/// </returns>
|
|
public byte[] GetUserSessionKey(byte[] challenge)
|
|
{
|
|
if (HashesExternal)
|
|
{
|
|
return null;
|
|
}
|
|
byte[] key = new byte[16];
|
|
try
|
|
{
|
|
GetUserSessionKey(challenge, key, 0);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_log.Level > 0)
|
|
{
|
|
Runtime.PrintStackTrace(ex, _log);
|
|
}
|
|
}
|
|
return key;
|
|
}
|
|
|
|
/// <summary>Calculates the effective user session key.</summary>
|
|
/// <remarks>Calculates the effective user session key.</remarks>
|
|
/// <param name="challenge">The server challenge.</param>
|
|
/// <param name="dest">
|
|
/// The destination array in which the user session key will be
|
|
/// placed.
|
|
/// </param>
|
|
/// <param name="offset">
|
|
/// The offset in the destination array at which the
|
|
/// session key will start.
|
|
/// </param>
|
|
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
|
|
internal void GetUserSessionKey(byte[] challenge, byte[] dest, int offset)
|
|
{
|
|
if (HashesExternal)
|
|
{
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
Md4 md4 = new Md4();
|
|
md4.Update(Runtime.GetBytesForString(Password, SmbConstants.UniEncoding)
|
|
);
|
|
switch (LmCompatibility)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
{
|
|
md4.Update(md4.Digest());
|
|
md4.Digest(dest, offset, 16);
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
{
|
|
if (ClientChallenge == null)
|
|
{
|
|
ClientChallenge = new byte[8];
|
|
Random.NextBytes(ClientChallenge);
|
|
}
|
|
Hmact64 hmac = new Hmact64(md4.Digest());
|
|
hmac.Update(Runtime.GetBytesForString(Username.ToUpper(), SmbConstants.UniEncoding
|
|
));
|
|
hmac.Update(Runtime.GetBytesForString(Domain.ToUpper(), SmbConstants.UniEncoding
|
|
));
|
|
byte[] ntlmv2Hash = hmac.Digest();
|
|
hmac = new Hmact64(ntlmv2Hash);
|
|
hmac.Update(challenge);
|
|
hmac.Update(ClientChallenge);
|
|
Hmact64 userKey = new Hmact64(ntlmv2Hash);
|
|
userKey.Update(hmac.Digest());
|
|
userKey.Digest(dest, offset, 16);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
md4.Update(md4.Digest());
|
|
md4.Digest(dest, offset, 16);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new SmbException(string.Empty, e);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compares two <tt>NtlmPasswordAuthentication</tt> objects for
|
|
/// equality.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Compares two <tt>NtlmPasswordAuthentication</tt> objects for
|
|
/// equality. Two <tt>NtlmPasswordAuthentication</tt> objects are equal if
|
|
/// their caseless domain and username fields are equal and either both hashes are external and they are equal or both internally supplied passwords are equal. If one <tt>NtlmPasswordAuthentication</tt> object has external hashes (meaning negotiated via NTLM HTTP Authentication) and the other does not they will not be equal. This is technically not correct however the server 8 byte challage would be required to compute and compare the password hashes but that it not available with this method.
|
|
/// </remarks>
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (obj is NtlmPasswordAuthentication)
|
|
{
|
|
NtlmPasswordAuthentication ntlm = (NtlmPasswordAuthentication
|
|
)obj;
|
|
if (ntlm.Domain.ToUpper().Equals(Domain.ToUpper()) && ntlm.Username.ToUpper().Equals
|
|
(Username.ToUpper()))
|
|
{
|
|
if (HashesExternal && ntlm.HashesExternal)
|
|
{
|
|
|
|
return Arrays.Equals(AnsiHash, ntlm.AnsiHash) && Arrays.Equals(UnicodeHash, ntlm.
|
|
UnicodeHash);
|
|
}
|
|
if (!HashesExternal && Password.Equals(ntlm.Password))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>Return the upcased username hash code.</summary>
|
|
/// <remarks>Return the upcased username hash code.</remarks>
|
|
public override int GetHashCode()
|
|
{
|
|
return GetName().ToUpper().GetHashCode();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the domain and username in the format:
|
|
/// <tt>domain\\username</tt>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Return the domain and username in the format:
|
|
/// <tt>domain\\username</tt>. This is equivalent to <tt>getName()</tt>.
|
|
/// </remarks>
|
|
public override string ToString()
|
|
{
|
|
return GetName();
|
|
}
|
|
|
|
/// <exception cref="System.FormatException"></exception>
|
|
/// <exception cref="UnsupportedEncodingException"></exception>
|
|
internal static string Unescape(string str)
|
|
{
|
|
char ch;
|
|
int i;
|
|
int j;
|
|
int state;
|
|
int len;
|
|
char[] @out;
|
|
byte[] b = new byte[1];
|
|
if (str == null)
|
|
{
|
|
return null;
|
|
}
|
|
len = str.Length;
|
|
@out = new char[len];
|
|
state = 0;
|
|
for (i = j = 0; i < len; i++)
|
|
{
|
|
switch (state)
|
|
{
|
|
case 0:
|
|
{
|
|
ch = str[i];
|
|
if (ch == '%')
|
|
{
|
|
state = 1;
|
|
}
|
|
else
|
|
{
|
|
@out[j++] = ch;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
b[0] = unchecked((byte)(Convert.ToInt32(Runtime.Substring(str, i,
|
|
i + 2), 16) & unchecked(0xFF)));
|
|
@out[j++] = (Runtime.GetStringForBytes(b, 0, 1, "ASCII"))[0];
|
|
i++;
|
|
state = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return new string(@out, 0, j);
|
|
}
|
|
}
|
|
}
|