mirror of
https://github.com/jellyfin/jellyfin.git
synced 2024-09-07 20:08:59 +02:00
570 lines
15 KiB
C#
570 lines
15 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 System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Net;
|
|
using SharpCifs.Netbios;
|
|
using SharpCifs.Util.Sharpen;
|
|
|
|
namespace SharpCifs.Smb
|
|
{
|
|
public sealed class SmbSession
|
|
{
|
|
private static readonly string LogonShare = Config.GetProperty("jcifs.smb.client.logonShare"
|
|
, null);
|
|
|
|
private static readonly int LookupRespLimit = Config.GetInt("jcifs.netbios.lookupRespLimit"
|
|
, 3);
|
|
|
|
private static readonly string Domain = Config.GetProperty("jcifs.smb.client.domain"
|
|
, null);
|
|
|
|
private static readonly string Username = Config.GetProperty("jcifs.smb.client.username"
|
|
, null);
|
|
|
|
private static readonly int CachePolicy = Config.GetInt("jcifs.netbios.cachePolicy"
|
|
, 60 * 10) * 60;
|
|
|
|
internal static NbtAddress[] DcList;
|
|
|
|
internal static long DcListExpiration;
|
|
|
|
internal static int DcListCounter;
|
|
|
|
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
|
|
private static NtlmChallenge Interrogate(NbtAddress addr)
|
|
{
|
|
UniAddress dc = new UniAddress(addr);
|
|
SmbTransport trans = SmbTransport.GetSmbTransport(dc, 0);
|
|
if (Username == null)
|
|
{
|
|
trans.Connect();
|
|
if (SmbTransport.LogStatic.Level >= 3)
|
|
{
|
|
SmbTransport.LogStatic.WriteLine("Default credentials (jcifs.smb.client.username/password)"
|
|
+ " not specified. SMB signing may not work propertly." + " Skipping DC interrogation."
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SmbSession ssn = trans.GetSmbSession(NtlmPasswordAuthentication.Default
|
|
);
|
|
ssn.GetSmbTree(LogonShare, null).TreeConnect(null, null);
|
|
}
|
|
return new NtlmChallenge(trans.Server.EncryptionKey, dc);
|
|
}
|
|
|
|
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
|
|
/// <exception cref="UnknownHostException"></exception>
|
|
public static NtlmChallenge GetChallengeForDomain()
|
|
{
|
|
if (Domain == null)
|
|
{
|
|
throw new SmbException("A domain was not specified");
|
|
}
|
|
lock (Domain)
|
|
{
|
|
long now = Runtime.CurrentTimeMillis();
|
|
int retry = 1;
|
|
do
|
|
{
|
|
if (DcListExpiration < now)
|
|
{
|
|
NbtAddress[] list = NbtAddress.GetAllByName(Domain, 0x1C, null,
|
|
null);
|
|
DcListExpiration = now + CachePolicy * 1000L;
|
|
if (list != null && list.Length > 0)
|
|
{
|
|
DcList = list;
|
|
}
|
|
else
|
|
{
|
|
DcListExpiration = now + 1000 * 60 * 15;
|
|
if (SmbTransport.LogStatic.Level >= 2)
|
|
{
|
|
SmbTransport.LogStatic.WriteLine("Failed to retrieve DC list from WINS");
|
|
}
|
|
}
|
|
}
|
|
int max = Math.Min(DcList.Length, LookupRespLimit);
|
|
for (int j = 0; j < max; j++)
|
|
{
|
|
int i = DcListCounter++ % max;
|
|
if (DcList[i] != null)
|
|
{
|
|
try
|
|
{
|
|
return Interrogate(DcList[i]);
|
|
}
|
|
catch (SmbException se)
|
|
{
|
|
if (SmbTransport.LogStatic.Level >= 2)
|
|
{
|
|
SmbTransport.LogStatic.WriteLine("Failed validate DC: " + DcList[i]);
|
|
if (SmbTransport.LogStatic.Level > 2)
|
|
{
|
|
Runtime.PrintStackTrace(se, SmbTransport.LogStatic);
|
|
}
|
|
}
|
|
}
|
|
DcList[i] = null;
|
|
}
|
|
}
|
|
DcListExpiration = 0;
|
|
}
|
|
while (retry-- > 0);
|
|
DcListExpiration = now + 1000 * 60 * 15;
|
|
}
|
|
throw new UnknownHostException("Failed to negotiate with a suitable domain controller for "
|
|
+ Domain);
|
|
}
|
|
|
|
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
|
|
/// <exception cref="UnknownHostException"></exception>
|
|
public static byte[] GetChallenge(UniAddress dc)
|
|
{
|
|
return GetChallenge(dc, 0);
|
|
}
|
|
|
|
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
|
|
/// <exception cref="UnknownHostException"></exception>
|
|
public static byte[] GetChallenge(UniAddress dc, int port)
|
|
{
|
|
SmbTransport trans = SmbTransport.GetSmbTransport(dc, port);
|
|
trans.Connect();
|
|
return trans.Server.EncryptionKey;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Authenticate arbitrary credentials represented by the
|
|
/// <tt>NtlmPasswordAuthentication</tt> object against the domain controller
|
|
/// specified by the <tt>UniAddress</tt> parameter.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Authenticate arbitrary credentials represented by the
|
|
/// <tt>NtlmPasswordAuthentication</tt> object against the domain controller
|
|
/// specified by the <tt>UniAddress</tt> parameter. If the credentials are
|
|
/// not accepted, an <tt>SmbAuthException</tt> will be thrown. If an error
|
|
/// occurs an <tt>SmbException</tt> will be thrown. If the credentials are
|
|
/// valid, the method will return without throwing an exception. See the
|
|
/// last <a href="../../../faq.html">FAQ</a> question.
|
|
/// <p>
|
|
/// See also the <tt>jcifs.smb.client.logonShare</tt> property.
|
|
/// </remarks>
|
|
/// <exception cref="SmbException"></exception>
|
|
public static void Logon(UniAddress dc, NtlmPasswordAuthentication auth)
|
|
{
|
|
Logon(dc, -1, auth);
|
|
}
|
|
|
|
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
|
|
public static void Logon(UniAddress dc, int port, NtlmPasswordAuthentication auth
|
|
)
|
|
{
|
|
SmbTree tree = SmbTransport.GetSmbTransport(dc, port).GetSmbSession(auth).GetSmbTree
|
|
(LogonShare, null);
|
|
if (LogonShare == null)
|
|
{
|
|
tree.TreeConnect(null, null);
|
|
}
|
|
else
|
|
{
|
|
Trans2FindFirst2 req = new Trans2FindFirst2("\\", "*", SmbFile.AttrDirectory);
|
|
Trans2FindFirst2Response resp = new Trans2FindFirst2Response();
|
|
tree.Send(req, resp);
|
|
}
|
|
}
|
|
|
|
internal int ConnectionState;
|
|
|
|
internal int Uid;
|
|
|
|
internal List<object> Trees;
|
|
|
|
private UniAddress _address;
|
|
|
|
private int _port;
|
|
|
|
private int _localPort;
|
|
|
|
private IPAddress _localAddr;
|
|
|
|
internal SmbTransport transport;
|
|
|
|
internal NtlmPasswordAuthentication Auth;
|
|
|
|
internal long Expiration;
|
|
|
|
internal string NetbiosName;
|
|
|
|
internal SmbSession(UniAddress address, int port, IPAddress localAddr, int localPort
|
|
, NtlmPasswordAuthentication auth)
|
|
{
|
|
// Transport parameters allows trans to be removed from CONNECTIONS
|
|
this._address = address;
|
|
this._port = port;
|
|
this._localAddr = localAddr;
|
|
this._localPort = localPort;
|
|
this.Auth = auth;
|
|
Trees = new List<object>();
|
|
ConnectionState = 0;
|
|
}
|
|
|
|
internal SmbTree GetSmbTree(string share, string service)
|
|
{
|
|
lock (this)
|
|
{
|
|
SmbTree t;
|
|
if (share == null)
|
|
{
|
|
share = "IPC$";
|
|
}
|
|
/*for (IEnumeration e = trees.GetEnumerator(); e.MoveNext(); )
|
|
{
|
|
t = (SmbTree)e.Current;
|
|
if (t.Matches(share, service))
|
|
{
|
|
return t;
|
|
}
|
|
}*/
|
|
foreach (var e in Trees)
|
|
{
|
|
t = (SmbTree)e;
|
|
if (t.Matches(share, service))
|
|
{
|
|
return t;
|
|
}
|
|
}
|
|
|
|
t = new SmbTree(this, share, service);
|
|
Trees.Add(t);
|
|
return t;
|
|
}
|
|
}
|
|
|
|
internal bool Matches(NtlmPasswordAuthentication auth)
|
|
{
|
|
return this.Auth == auth || this.Auth.Equals(auth);
|
|
}
|
|
|
|
internal SmbTransport Transport()
|
|
{
|
|
lock (this)
|
|
{
|
|
if (transport == null)
|
|
{
|
|
transport = SmbTransport.GetSmbTransport(_address, _port, _localAddr, _localPort, null
|
|
);
|
|
}
|
|
return transport;
|
|
}
|
|
}
|
|
|
|
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
|
|
internal void Send(ServerMessageBlock request, ServerMessageBlock response)
|
|
{
|
|
lock (Transport())
|
|
{
|
|
if (response != null)
|
|
{
|
|
response.Received = false;
|
|
}
|
|
Expiration = Runtime.CurrentTimeMillis() + SmbConstants.SoTimeout;
|
|
SessionSetup(request, response);
|
|
if (response != null && response.Received)
|
|
{
|
|
return;
|
|
}
|
|
if (request is SmbComTreeConnectAndX)
|
|
{
|
|
SmbComTreeConnectAndX tcax = (SmbComTreeConnectAndX)request;
|
|
if (NetbiosName != null && tcax.path.EndsWith("\\IPC$"))
|
|
{
|
|
tcax.path = "\\\\" + NetbiosName + "\\IPC$";
|
|
}
|
|
}
|
|
request.Uid = Uid;
|
|
request.Auth = Auth;
|
|
try
|
|
{
|
|
transport.Send(request, response);
|
|
}
|
|
catch (SmbException se)
|
|
{
|
|
if (request is SmbComTreeConnectAndX)
|
|
{
|
|
Logoff(true);
|
|
}
|
|
request.Digest = null;
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
|
|
internal void SessionSetup(ServerMessageBlock andx, ServerMessageBlock andxResponse
|
|
)
|
|
{
|
|
lock (Transport())
|
|
{
|
|
NtlmContext nctx = null;
|
|
SmbException ex = null;
|
|
SmbComSessionSetupAndX request;
|
|
SmbComSessionSetupAndXResponse response;
|
|
byte[] token = new byte[0];
|
|
int state = 10;
|
|
while (ConnectionState != 0)
|
|
{
|
|
if (ConnectionState == 2 || ConnectionState == 3)
|
|
{
|
|
// connected or disconnecting
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
Runtime.Wait(transport);
|
|
}
|
|
catch (Exception ie)
|
|
{
|
|
throw new SmbException(ie.Message, ie);
|
|
}
|
|
}
|
|
ConnectionState = 1;
|
|
// trying ...
|
|
try
|
|
{
|
|
transport.Connect();
|
|
if (transport.Log.Level >= 4)
|
|
{
|
|
transport.Log.WriteLine("sessionSetup: accountName=" + Auth.Username + ",primaryDomain="
|
|
+ Auth.Domain);
|
|
}
|
|
Uid = 0;
|
|
do
|
|
{
|
|
switch (state)
|
|
{
|
|
case 10:
|
|
{
|
|
if (Auth != NtlmPasswordAuthentication.Anonymous && transport.HasCapability(SmbConstants
|
|
.CapExtendedSecurity))
|
|
{
|
|
state = 20;
|
|
break;
|
|
}
|
|
request = new SmbComSessionSetupAndX(this, andx, Auth);
|
|
response = new SmbComSessionSetupAndXResponse(andxResponse);
|
|
if (transport.IsSignatureSetupRequired(Auth))
|
|
{
|
|
if (Auth.HashesExternal && NtlmPasswordAuthentication.DefaultPassword != NtlmPasswordAuthentication
|
|
.Blank)
|
|
{
|
|
transport.GetSmbSession(NtlmPasswordAuthentication.Default).GetSmbTree(LogonShare
|
|
, null).TreeConnect(null, null);
|
|
}
|
|
else
|
|
{
|
|
byte[] signingKey = Auth.GetSigningKey(transport.Server.EncryptionKey);
|
|
request.Digest = new SigningDigest(signingKey, false);
|
|
}
|
|
}
|
|
request.Auth = Auth;
|
|
try
|
|
{
|
|
transport.Send(request, response);
|
|
}
|
|
catch (SmbAuthException sae)
|
|
{
|
|
throw;
|
|
}
|
|
catch (SmbException se)
|
|
{
|
|
ex = se;
|
|
}
|
|
if (response.IsLoggedInAsGuest && Runtime.EqualsIgnoreCase("GUEST", Auth.
|
|
Username) == false && transport.Server.Security != SmbConstants.SecurityShare &&
|
|
Auth != NtlmPasswordAuthentication.Anonymous)
|
|
{
|
|
throw new SmbAuthException(NtStatus.NtStatusLogonFailure);
|
|
}
|
|
if (ex != null)
|
|
{
|
|
throw ex;
|
|
}
|
|
Uid = response.Uid;
|
|
if (request.Digest != null)
|
|
{
|
|
transport.Digest = request.Digest;
|
|
}
|
|
ConnectionState = 2;
|
|
state = 0;
|
|
break;
|
|
}
|
|
|
|
case 20:
|
|
{
|
|
if (nctx == null)
|
|
{
|
|
bool doSigning = (transport.Flags2 & SmbConstants.Flags2SecuritySignatures
|
|
) != 0;
|
|
nctx = new NtlmContext(Auth, doSigning);
|
|
}
|
|
if (SmbTransport.LogStatic.Level >= 4)
|
|
{
|
|
SmbTransport.LogStatic.WriteLine(nctx);
|
|
}
|
|
if (nctx.IsEstablished())
|
|
{
|
|
NetbiosName = nctx.GetNetbiosName();
|
|
ConnectionState = 2;
|
|
state = 0;
|
|
break;
|
|
}
|
|
try
|
|
{
|
|
token = nctx.InitSecContext(token, 0, token.Length);
|
|
}
|
|
catch (SmbException se)
|
|
{
|
|
try
|
|
{
|
|
transport.Disconnect(true);
|
|
}
|
|
catch (IOException)
|
|
{
|
|
}
|
|
Uid = 0;
|
|
throw;
|
|
}
|
|
if (token != null)
|
|
{
|
|
request = new SmbComSessionSetupAndX(this, null, token);
|
|
response = new SmbComSessionSetupAndXResponse(null);
|
|
if (transport.IsSignatureSetupRequired(Auth))
|
|
{
|
|
byte[] signingKey = nctx.GetSigningKey();
|
|
if (signingKey != null)
|
|
{
|
|
request.Digest = new SigningDigest(signingKey, true);
|
|
}
|
|
}
|
|
request.Uid = Uid;
|
|
Uid = 0;
|
|
try
|
|
{
|
|
transport.Send(request, response);
|
|
}
|
|
catch (SmbAuthException sae)
|
|
{
|
|
throw;
|
|
}
|
|
catch (SmbException se)
|
|
{
|
|
ex = se;
|
|
try
|
|
{
|
|
transport.Disconnect(true);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
if (response.IsLoggedInAsGuest && Runtime.EqualsIgnoreCase("GUEST", Auth.
|
|
Username) == false)
|
|
{
|
|
throw new SmbAuthException(NtStatus.NtStatusLogonFailure);
|
|
}
|
|
if (ex != null)
|
|
{
|
|
throw ex;
|
|
}
|
|
Uid = response.Uid;
|
|
if (request.Digest != null)
|
|
{
|
|
transport.Digest = request.Digest;
|
|
}
|
|
token = response.Blob;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
throw new SmbException("Unexpected session setup state: " + state);
|
|
}
|
|
}
|
|
}
|
|
while (state != 0);
|
|
}
|
|
catch (SmbException se)
|
|
{
|
|
Logoff(true);
|
|
ConnectionState = 0;
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
Runtime.NotifyAll(transport);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void Logoff(bool inError)
|
|
{
|
|
lock (Transport())
|
|
{
|
|
if (ConnectionState != 2)
|
|
{
|
|
// not-connected
|
|
return;
|
|
}
|
|
ConnectionState = 3;
|
|
// disconnecting
|
|
NetbiosName = null;
|
|
|
|
foreach (SmbTree t in Trees)
|
|
{
|
|
t.TreeDisconnect(inError);
|
|
}
|
|
|
|
if (!inError && transport.Server.Security != SmbConstants.SecurityShare)
|
|
{
|
|
SmbComLogoffAndX request = new SmbComLogoffAndX(null);
|
|
request.Uid = Uid;
|
|
try
|
|
{
|
|
transport.Send(request, null);
|
|
}
|
|
catch (SmbException)
|
|
{
|
|
}
|
|
Uid = 0;
|
|
}
|
|
ConnectionState = 0;
|
|
Runtime.NotifyAll(transport);
|
|
}
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return "SmbSession[accountName=" + Auth.Username + ",primaryDomain=" + Auth.Domain
|
|
+ ",uid=" + Uid + ",connectionState=" + ConnectionState + "]";
|
|
}
|
|
}
|
|
}
|