Zugreifen auf eine freigegebene Datei (UNC) von einer nicht vertrauenswürdigen Remote-Domäne mit Anmeldeinformationen

Wir haben in eine interessante situation, die Bedürfnisse zu lösen, und meine Recherchen haben aufgedeckt nill. Ich rufe deshalb die öffentlichkeit um Hilfe.

Das Problem ist dieses: wir müssen den programmgesteuerten Zugriff auf eine freigegebene Datei, die nicht in unserer Domäne und nicht in einer vertrauenswürdigen externen Domäne über remote-file-sharing /UNC. Natürlich, wir müssen Anmeldeinformationen eingeben, um die remote-Maschine.

Normalerweise löst man dieses problem in einer von zwei Möglichkeiten:

Anzeigen der Datei-Freigabe als Laufwerk und die Anmeldeinformationen an, die Zeit. Dies erfolgt in der Regel die NET USE Befehl oder die Win32-Funktionen, die doppelte NET USE.
Auf die Datei mit einem UNC-Pfad, als ob der remote-computer auf die Domäne und sicherzustellen, dass das Konto, unter dem das Programm ausgeführt wird, wird verdoppelt (inklusive Passwort) auf dem remote-Rechner als lokale Benutzer. Im Grunde nutzen die Tatsache, dass Windows automatisch die Versorgung der Anmeldeinformationen des aktuellen Benutzers, wenn der Benutzer versucht, Zugriff auf eine freigegebene Datei.
Don ' T verwenden remote-file-sharing. Verwenden Sie FTP (oder irgendeinem anderen Wege) zu übertragen Sie die Datei, arbeiten Sie vor Ort und übertragen Sie Sie anschließend wieder.

Für verschiedene und verschiedene Gründe, unsere security /Netzwerk Architekten abgelehnt haben die beiden ersten Ansätzen. Der zweite Ansatz ist offensichtlich ein Sicherheitsproblem; wenn der remote-computer kompromittiert wird, kann der lokale computer ist nun in Gefahr. Der erste Ansatz ist unbefriedigend, weil die neu eingehängten Laufwerk ist eine gemeinsame Ressource zur Verfügung, um andere Programme auf dem lokalen computer während der file-Zugriff durch das Programm. Obwohl es durchaus möglich ist, stellen Sie diese temporär, es ist immer noch ein Loch in Ihrer Meinung.

Sind Sie offen für die Dritte option, aber die remote-Netzwerk-admins bestehen auf SFTP statt FTPS und FtpWebRequest nur FTPS unterstützt. SFTP ist die mehr firewall-freundliche option und es gibt ein paar Bibliotheken, die ich benutzen könnte für diesen Ansatz, aber ich würde es vorziehen, zu reduzieren, meine Abhängigkeiten, wenn ich kann.

Habe ich gesucht, MSDN, entweder für eine verwaltete oder eine win32-Nutzung von remote-file-sharing, aber ich konnte nicht kommen mit etwas sinnvolles.

Und so Frage ich: gibt es einen anderen Weg? Habe ich einmal eine super-geheime win32-Funktion, die tut, was ich will? Oder muss ich verfolgen eine Variante von option 3?

InformationsquelleAutor der Frage Randolpho | 2009-03-18

c#file-sharing unc windows

153

Den Weg, um Ihr problem zu lösen, ist die Verwendung eines Win32-API aufgerufen WNetUseConnection.

Verwenden Sie diese Funktion, um eine Verbindung zu einer UNC-Pfad mit Authentifizierung, NICHT um ein Laufwerk zuzuordnen.

Wird diese ermöglichen es Ihnen, eine Verbindung zu einem remote-Computer, auch wenn es nicht auf der gleichen domain, und selbst wenn er ein anderen Benutzernamen und Passwort.

Sobald Sie verwendet werden, WNetUseConnection Sie werden in der Lage sein, um den Zugriff auf die Datei über einen UNC-Pfad als ob Sie waren auf der gleichen domain. Der beste Weg ist wohl über die administrative gebaut in Aktien.

Beispiel: \\computername\c$\program files\Folder\file.txt

Hier einige Beispiel für C# - code, der verwendet WNetUseConnection.

Beachten Sie, für die NetResource, sollten Sie übergeben Sie null für die lpLocalName und lpProvider. Der dwType sollte RESOURCETYPE_DISK. Die lpRemoteName sollte \\ComputerName.

InformationsquelleAutor der Antwort Brian R. Bondy

101

Für Menschen auf der Suche nach einer schnellen Lösung, die Sie verwenden können, die NetworkShareAccesser ich vor kurzem geschrieben (basierend auf diese Antwort (vielen Dank!)):

Verwendung:

using (NetworkShareAccesser.Access(REMOTE_COMPUTER_NAME, DOMAIN, USER_NAME, PASSWORD))
{
    File.Copy(@"C:\Some\File\To\copy.txt", @"\\REMOTE-COMPUTER\My\Shared\Target\file.txt");
}

WARNUNG: Bitte stellen Sie absolut sicher, dass Dispose des NetworkShareAccesser genannt wird (auch wenn Sie die app stürzt ab!), ansonsten eine offene Verbindung bleibt auf Windows. Können Sie alle offenen verbindungen, die durch die öffnung der cmd Eingabeaufforderung, und geben Sie net use.

Code:

///<summary>
///Provides access to a network share.
///</summary>
public class NetworkShareAccesser : IDisposable
{
    private string _remoteUncName;
    private string _remoteComputerName;

    public string RemoteComputerName
    {
        get
        {
            return this._remoteComputerName;
        }
        set
        {
            this._remoteComputerName = value;
            this._remoteUncName = @"\\" + this._remoteComputerName;
        }
    }

    public string UserName
    {
        get;
        set;
    }
    public string Password
    {
        get;
        set;
    }

    #region Consts

    private const int RESOURCE_CONNECTED = 0x00000001;
    private const int RESOURCE_GLOBALNET = 0x00000002;
    private const int RESOURCE_REMEMBERED = 0x00000003;

    private const int RESOURCETYPE_ANY = 0x00000000;
    private const int RESOURCETYPE_DISK = 0x00000001;
    private const int RESOURCETYPE_PRINT = 0x00000002;

    private const int RESOURCEDISPLAYTYPE_GENERIC = 0x00000000;
    private const int RESOURCEDISPLAYTYPE_DOMAIN = 0x00000001;
    private const int RESOURCEDISPLAYTYPE_SERVER = 0x00000002;
    private const int RESOURCEDISPLAYTYPE_SHARE = 0x00000003;
    private const int RESOURCEDISPLAYTYPE_FILE = 0x00000004;
    private const int RESOURCEDISPLAYTYPE_GROUP = 0x00000005;

    private const int RESOURCEUSAGE_CONNECTABLE = 0x00000001;
    private const int RESOURCEUSAGE_CONTAINER = 0x00000002;


    private const int CONNECT_INTERACTIVE = 0x00000008;
    private const int CONNECT_PROMPT = 0x00000010;
    private const int CONNECT_REDIRECT = 0x00000080;
    private const int CONNECT_UPDATE_PROFILE = 0x00000001;
    private const int CONNECT_COMMANDLINE = 0x00000800;
    private const int CONNECT_CMD_SAVECRED = 0x00001000;

    private const int CONNECT_LOCALDRIVE = 0x00000100;

    #endregion

    #region Errors

    private const int NO_ERROR = 0;

    private const int ERROR_ACCESS_DENIED = 5;
    private const int ERROR_ALREADY_ASSIGNED = 85;
    private const int ERROR_BAD_DEVICE = 1200;
    private const int ERROR_BAD_NET_NAME = 67;
    private const int ERROR_BAD_PROVIDER = 1204;
    private const int ERROR_CANCELLED = 1223;
    private const int ERROR_EXTENDED_ERROR = 1208;
    private const int ERROR_INVALID_ADDRESS = 487;
    private const int ERROR_INVALID_PARAMETER = 87;
    private const int ERROR_INVALID_PASSWORD = 1216;
    private const int ERROR_MORE_DATA = 234;
    private const int ERROR_NO_MORE_ITEMS = 259;
    private const int ERROR_NO_NET_OR_BAD_PATH = 1203;
    private const int ERROR_NO_NETWORK = 1222;

    private const int ERROR_BAD_PROFILE = 1206;
    private const int ERROR_CANNOT_OPEN_PROFILE = 1205;
    private const int ERROR_DEVICE_IN_USE = 2404;
    private const int ERROR_NOT_CONNECTED = 2250;
    private const int ERROR_OPEN_FILES = 2401;

    #endregion

    #region PInvoke Signatures

    [DllImport("Mpr.dll")]
    private static extern int WNetUseConnection(
        IntPtr hwndOwner,
        NETRESOURCE lpNetResource,
        string lpPassword,
        string lpUserID,
        int dwFlags,
        string lpAccessName,
        string lpBufferSize,
        string lpResult
        );

    [DllImport("Mpr.dll")]
    private static extern int WNetCancelConnection2(
        string lpName,
        int dwFlags,
        bool fForce
        );

    [StructLayout(LayoutKind.Sequential)]
    private class NETRESOURCE
    {
        public int dwScope = 0;
        public int dwType = 0;
        public int dwDisplayType = 0;
        public int dwUsage = 0;
        public string lpLocalName = "";
        public string lpRemoteName = "";
        public string lpComment = "";
        public string lpProvider = "";
    }

    #endregion

    ///<summary>
    ///Creates a NetworkShareAccesser for the given computer name. The user will be promted to enter credentials
    ///</summary>
    ///<param name="remoteComputerName"></param>
    ///<returns></returns>
    public static NetworkShareAccesser Access(string remoteComputerName)
    {
        return new NetworkShareAccesser(remoteComputerName);
    }

    ///<summary>
    ///Creates a NetworkShareAccesser for the given computer name using the given domain/computer name, username and password
    ///</summary>
    ///<param name="remoteComputerName"></param>
    ///<param name="domainOrComuterName"></param>
    ///<param name="userName"></param>
    ///<param name="password"></param>
    public static NetworkShareAccesser Access(string remoteComputerName, string domainOrComuterName, string userName, string password)
    {
        return new NetworkShareAccesser(remoteComputerName,
                                        domainOrComuterName + @"\" + userName,
                                        password);
    }

    ///<summary>
    ///Creates a NetworkShareAccesser for the given computer name using the given username (format: domainOrComputername\Username) and password
    ///</summary>
    ///<param name="remoteComputerName"></param>
    ///<param name="userName"></param>
    ///<param name="password"></param>
    public static NetworkShareAccesser Access(string remoteComputerName, string userName, string password)
    {
        return new NetworkShareAccesser(remoteComputerName, 
                                        userName,
                                        password);
    }

    private NetworkShareAccesser(string remoteComputerName)
    {
        RemoteComputerName = remoteComputerName;               

        this.ConnectToShare(this._remoteUncName, null, null, true);
    }

    private NetworkShareAccesser(string remoteComputerName, string userName, string password)
    {
        RemoteComputerName = remoteComputerName;
        UserName = userName;
        Password = password;

        this.ConnectToShare(this._remoteUncName, this.UserName, this.Password, false);
    }

    private void ConnectToShare(string remoteUnc, string username, string password, bool promptUser)
    {
        NETRESOURCE nr = new NETRESOURCE
        {
            dwType = RESOURCETYPE_DISK,
            lpRemoteName = remoteUnc
        };

        int result;
        if (promptUser)
        {
            result = WNetUseConnection(IntPtr.Zero, nr, "", "", CONNECT_INTERACTIVE | CONNECT_PROMPT, null, null, null);
        }
        else
        {
            result = WNetUseConnection(IntPtr.Zero, nr, password, username, 0, null, null, null);
        }

        if (result != NO_ERROR)
        {
            throw new Win32Exception(result);
        }
    }

    private void DisconnectFromShare(string remoteUnc)
    {
        int result = WNetCancelConnection2(remoteUnc, CONNECT_UPDATE_PROFILE, false);
        if (result != NO_ERROR)
        {
            throw new Win32Exception(result);
        }
    }

    ///<summary>
    ///Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
    ///</summary>
    ///<filterpriority>2</filterpriority>
    public void Dispose()
    {
        this.DisconnectFromShare(this._remoteUncName);
    }
}

InformationsquelleAutor der Antwort GameScripting

15

Ist, soweit ich weiß, brauchen Sie nicht zu Karte Sie den UNC-Pfad einen Laufwerkbuchstaben, um die Anmeldeinformationen für einen server. Ich benutzte regelmäßig batch-Skripte wie:
```
net use \\myserver /user:username password

:: do something with \\myserver\the\file\i\want.xml

net use /delete \\my.server.com
```
Jedoch jedes Programm läuft auf dem gleichen Konto wie das Programm können Sie immer noch Zugriff auf alles, was username:password Zugriff hat. Eine mögliche Lösung könnte sein, isolieren Sie Ihr Programm in seinen eigenen lokalen Benutzer-account (den UNC-Zugriff lokal auf dem Konto, genannt NET USE).

Hinweis: Mithilfe von SMB-auf-domains ist nicht ganz eine gute Nutzung der Technologie, IMO. Wenn Sicherheit wichtig ist, ist die Tatsache, dass die SMB-Verschlüsselung fehlt ist ein bisschen ein Dämpfer, ganz von selbst.

InformationsquelleAutor der Antwort Jacob
4

Während ich nicht mich kennen, würde ich sicherlich hoffen, dass #2 ist falsch...ich würde gerne glauben, dass Windows nicht AUTOMATISCH geben meine login-Daten (schon gar nicht mein Passwort!) auf jedem Rechner, geschweige denn eine, die nicht Teil der mein Vertrauen.

Unabhängig, Sie haben, erkundet Sie die Identitätswechsel-Architektur? Ihr code wird in etwa so Aussehen:
```
using (System.Security.Principal.WindowsImpersonationContext context = System.Security.Principal.WindowsIdentity.Impersonate(token))
{
    //Do network operations here

    context.Undo();
}
```
In diesem Fall, die token variable IntPtr. Um einen Wert für diese variable, Sie müssen rufen Sie die nicht verwaltete Windows-API-Funktion LogonUser. Eine schnelle Reise zu pinvoke.net gibt uns die folgende Signatur:
```
[System.Runtime.InteropServices.DllImport("advapi32.dll", SetLastError = true)]
public static extern bool LogonUser(
    string lpszUsername,
    string lpszDomain,
    string lpszPassword,
    int dwLogonType,
    int dwLogonProvider,
    out IntPtr phToken
);
```
Benutzernamen, die Domäne und das Kennwort sollte scheinen ziemlich offensichtlich. Haben Sie einen Blick auf die verschiedenen Werte, die übergeben werden kann, um dwLogonType und dwLogonProvider, um zu bestimmen, die, die am besten zu Ihren Bedürfnissen passt.

Dieser code ist nicht getestet worden, weil ich nicht haben eine zweite Domäne hier, wo ich überprüfen kann, dies sollte sich aber hoffentlich legen Sie auf die richtige Spur.

InformationsquelleAutor der Antwort Adam Robinson
3

Eher als WNetUseConnection, würde ich empfehlen,NetUseAdd. WNetUseConnection ist eine legacy-Funktion wurde abgelöst durch WNetUseConnection2 und WNetUseConnection3, aber alle diese Funktionen erstellen Sie ein Netzwerk-Gerät, das sichtbar in Windows Explorer. NetUseAdd ist das äquivalent zum Aufruf von net use in einer DOS-Eingabeaufforderung zur Authentifizierung auf einem remote-computer.

Wenn Sie rufen Sie NetUseAdd dann die nachfolgenden versuche auf das Verzeichnis zuzugreifen, das sollte gelingen.

InformationsquelleAutor der Antwort Adam Robinson
2

Meisten SFTP-Server-Unterstützung SCP als auch die viel leichter zu finden-Bibliotheken für. Man könnte auch einfach anrufen, einen bestehenden Kunden aus dem code wie pscp enthalten PuTTY.

Wenn der Dateityp mit dem Sie arbeiten, ist so etwas einfaches wie eine text-oder XML-Datei, man könnte sogar so weit gehen und schreiben Sie Ihre eigene client/server-Implementierung die Datei Bearbeiten, mit so etwas wie wird .NET Remoting oder web-services.

InformationsquelleAutor der Antwort Ryan Bolger
1

Ich gesehen habe option 3 implementiert, mit JScape tools in eine ziemlich direkte Art und Weise. Sie könnten es versuchen. Es ist nicht kostenlos, aber es macht seinen job.

InformationsquelleAutor der Antwort DreamSonic

Hier einen minimalen POC-Klasse w/alle Reste entfernt

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

public class UncShareWithCredentials : IDisposable
{
    private string _uncShare;

    public UncShareWithCredentials(string uncShare, string userName, string password)
    {
        var nr = new Native.NETRESOURCE
        {
            dwType = Native.RESOURCETYPE_DISK,
            lpRemoteName = uncShare
        };

        int result = Native.WNetUseConnection(IntPtr.Zero, nr, password, userName, 0, null, null, null);
        if (result != Native.NO_ERROR)
        {
            throw new Win32Exception(result);
        }
        _uncShare = uncShare;
    }

    public void Dispose()
    {
        if (!string.IsNullOrEmpty(_uncShare))
        {
            Native.WNetCancelConnection2(_uncShare, Native.CONNECT_UPDATE_PROFILE, false);
            _uncShare = null;
        }
    }

    private class Native
    {
        public const int RESOURCETYPE_DISK = 0x00000001;
        public const int CONNECT_UPDATE_PROFILE = 0x00000001;
        public const int NO_ERROR = 0;

        [DllImport("mpr.dll")]
        public static extern int WNetUseConnection(IntPtr hwndOwner, NETRESOURCE lpNetResource, string lpPassword, string lpUserID,
            int dwFlags, string lpAccessName, string lpBufferSize, string lpResult);

        [DllImport("mpr.dll")]
        public static extern int WNetCancelConnection2(string lpName, int dwFlags, bool fForce);

        [StructLayout(LayoutKind.Sequential)]
        public class NETRESOURCE
        {
            public int dwScope;
            public int dwType;
            public int dwDisplayType;
            public int dwUsage;
            public string lpLocalName;
            public string lpRemoteName;
            public string lpComment;
            public string lpProvider;
        }
    }
}

Können Sie direkt \\server\share\folder w/WNetUseConnectionkeine Notwendigkeit, entfernen Sie es, um \\server Teil nur vorher.

InformationsquelleAutor der Antwort wqw

-2

Sah ich zu MS, die Antworten zu finden. Die erste Lösung setzt Voraus das Benutzerkonto ausführen der Anwendung Prozess hat Zugriff auf den freigegebenen Ordner oder das Laufwerk (Gleiche domain). Stellen Sie sicher, dass Ihre DNS aufgelöst wird oder verwenden Sie eine IP-Adresse. Tun Sie einfach Folgendes:

 DirectoryInfo di = new DirectoryInfo(PATH);
 var files = di.EnumerateFiles("*.*", SearchOption.AllDirectories);

Wenn Sie möchten, über verschiedene Domänen hinweg .NET 2.0 mit Zugangsdaten Folgen diesem Modell:

WebRequest req = FileWebRequest.Create(new Uri(@"\\<server Name>\Dir\test.txt"));

        req.Credentials = new NetworkCredential(@"<Domain>\<User>", "<Password>");
        req.PreAuthenticate = true;

        WebResponse d = req.GetResponse();
        FileStream fs = File.Create("test.txt");

        //here you can check that the cast was successful if you want. 
        fs = d.GetResponseStream() as FileStream;
        fs.Close();

InformationsquelleAutor der Antwort Kentonbmax

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.