Ergebnis 1 bis 5 von 5
  1. #1
    Code Sorceress Avatar von andi9x17
    Registriert seit
    21.05.2011
    Ort
    Dark Net
    Beiträge
    3.135
    Gamer IDs

    Gamertag: andi9x17 PSN ID: andi9x17

    Frage AD Zugriff mit VBS

    Hi Leute,

    ich habe hier ein gewaltiges Problem. Mein Praktikum ist so gut wie zu Ende, aber ich habe immer noch keine Lösung für das AD Problem, die sie hier haben, gefunden.

    Aufgabe:
    Zunächst muss ich sagen, dass ich in der IT Abteilung eine Landesamt für Umwelt bin. Heißt so viel wie, hier wird wissenschaftlich gearbeitet. Ich soll ein Programm schreiben, dass auf den Hessenweiten AD zugreifen kann. Es soll alle Mitglieder des Amtes, sowie ihre Gruppenzugehörigkeit auslesen.

    Ich habe das Programm soweit auch fast fertiggeschríeben.

    Problem:
    Aber jetzt kommt das Problem! Ich checke nicht so ganz, wie man den Pfad programmiert! Und im inet gibt es herzlich wenig drüber!
    Standardmäßig habe ich LDAP:\\*****\**** eingegeben. Also die Sterne habe ich selbstverständlich durch die Domännamen sowie Gruppe ersetzt.
    Ich habe hierzu vom Auftraggeber selber auch kaum Informationen über den Server bekommen. Ich habe nur Gruppennamen zur Verfügung.

    außerdem ist es ja normaleweise so, dass ich mit dem windowsbefehl: gpedit.msc herausfinden kann, ob ich überhaupt die rechte habe.
    Laut dem zuständigen Administrator hat jede User Leserechte. Bei mir kommt immer Zugriff verweigert auch wenn ich mit dem lokalen admin versuche. Im Rechteverzeichnis steht bei mir aber alles auf grün???

    Gibt es vielleicht noch weitere Möglichkeiten den Pfad zum AD heraus zu finden?


    VG,

    andi9x17

  2. #2
    The Cleric Avatar von Don Kan Onji
    Registriert seit
    16.11.2009
    Ort
    Moon Palace
    Beiträge
    32.240
    Gamer IDs

    Gamertag: Lord Raven24 PSN ID: LordRaven27

    Standard

    Was ist AD? Was ist VBS?

    Ich würde vorschlagen, dass du dich mit diesem Problem auch an Valkum wenden kannst. Wer, wenn nicht er, kennt eine Lösung besser


  3. #3
    Notorischer Nörgler Avatar von RAT:
    Registriert seit
    04.08.2011
    Ort
    Rhoihesse
    Beiträge
    1.234

    Standard

    Ich habe mal etwas ähnliches unter C#.net gebastelt. Das Programm soll im gesamten AD nach Servern suchen und danach, ob auf einem Server ein TFS (Team Foundation Server) läuft. Vielleicht bringt es Dich weiter.

    Spoiler:
    Code:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.DirectoryServices;
    using System.DirectoryServices.ActiveDirectory;
    using System.Collections.ObjectModel;
    using Microsoft.TeamFoundation.Framework.Common;
    using Microsoft.TeamFoundation.Client;
    using Microsoft.TeamFoundation.Framework.Client;
    using Microsoft.TeamFoundation.VersionControl.Client;
    using System.Runtime.Remoting.Messaging;
    using System.Threading;
    using System.ComponentModel;
    using System.IO;
    
    namespace TFS_Show
    {
        /// <summary>
        /// Stellt Verbindungen und Objekte aus der AD-Domäne und des TFS zur Verfügung
        /// </summary>
        static class Network
        {
            #region member
            internal static bool _initialized = false;
            internal static string _type = "LDAP:";
    //        internal static string _type = "WinNT:";
            internal static string _authUser;
            internal static DirectoryEntry _root;
            internal static DirectorySearcher _searcher;
            internal static string _domain;
            internal static TfsConfigurationServer _tfs;
            internal static VersionControlServer _vcs;
            internal static ReadOnlyCollection<CatalogNode> _cNodes;
            internal static CatalogNode _cNode;
            internal static List<Changeset> _changes;
            internal static SearchResultCollection _allPC;
            delegate object WorkDelegate(string server);
            #endregion member
    
            #region Initialize()
            /// <summary>
            /// Holt den Verzeichniseintrag für root aus dem Active Directory
            /// </summary>
            internal static void Initialize()
            {
                string aktDom = string.Concat(_type, "//", "RootDSE");
                _root = new DirectoryEntry(aktDom);
    
                if (_root == null) // || _root.Container == null)
                    throw new ApplicationException("Fehler bei Instantiierung auf " + aktDom);
    
                _domain = GetRootDSE();
    
                if (string.IsNullOrEmpty(_domain))
                    throw new ApplicationException("Fehler bei Ermittlung der root-Domäne");
    
                _initialized = true;
            }
            #endregion Initialize()
    
            #region GetRootDSE()
            /// <summary>
            /// Holt den Einstiegspunkt ins Active Directory
            /// </summary>
            /// <returns>root-Domäne, bei uns: de.***.corp</returns>
            internal static string GetRootDSE()
            {
                string rootDSE = _root.Properties["defaultNamingContext"].Value.ToString();
    
                if (rootDSE.Contains(","))
                {
                    string[] arrSubStrings = rootDSE.Split(',');
                    rootDSE = string.Empty;
                    foreach (string item in arrSubStrings)
                    {
                        string[] arrParts = item.Split('=');
                        if (string.IsNullOrEmpty(rootDSE))
                        {
                            rootDSE = arrParts[1];
                        }
                        else
                        {
                            rootDSE = string.Concat(rootDSE, ".", arrParts[1]);
                        }
                    }
                }
                return rootDSE;
            }
            #endregion GetRootDSE()
    
            #region GetAllChilds()
            /// <summary>
            /// Füllt als Hintergrundjob eine Collection mit allen PCs der Domäne
            /// </summary>
            internal static DirectorySearcher GetAllChilds(BackgroundWorker worker, DoWorkEventArgs e)
            {
                if (!_initialized)
                    throw new ApplicationException("Klasse ist nicht initialisiert.");
    
                if (worker.CancellationPending)
                {
                    e.Cancel = true;
                }
                else
                {
                    DirectoryEntry root = new DirectoryEntry(string.Concat(_type, "//", _domain));
                    _searcher = new DirectorySearcher(root);
    
                    // Filter zur Suche angeben, in diesem Fall: alle PCs
                    _searcher.Filter = "(objectCategory=computer)";
                    return _searcher;
                }
    
                return null;
            }
            #endregion GetAllChilds()
    
            #region IsComputerValid()
            /// <summary>
            /// Prüft, ob es einen bestimmten PC in der Domäne gibt
            /// </summary>
            /// <param name="Computername"></param>
            /// <returns>true oder false</returns>
            internal static bool IsComputerValid(string computerName)
            {
                if (!_initialized)
                    throw new ApplicationException("Klasse ist nicht initialisiert.");
    
                if (string.IsNullOrEmpty(computerName))
                    return false;
    
                if (_allPC != null)
                {
                    foreach (SearchResult pc in _allPC)
                    {
                        string domPC = (pc.GetDirectoryEntry().Name.Substring(0, 3) == "CN=") ? pc.GetDirectoryEntry().Name.Substring(3) : pc.GetDirectoryEntry().Name;
    
                        if (computerName.CompareTo(domPC) == 0)
                            return true;
                    }
                }
                return false;
            }
            #endregion IsComputerValid()
    
            #region GetComputerData()
            /// <summary>
            /// Liefert Daten zu einem Computer
            /// </summary>
            /// <param name="computerName"></param>
            /// <returns>Eintrag als AD</returns>
            internal static DirectoryEntry GetComputerData(string computerName)
            {
                foreach (SearchResult pc in _allPC)
                {
                    string domPC = (pc.GetDirectoryEntry().Name.Substring(0, 3) == "CN=") ? pc.GetDirectoryEntry().Name.Substring(3) : pc.GetDirectoryEntry().Name;
    
                    if (computerName.CompareTo(domPC) == 0)
                        return pc.GetDirectoryEntry();
                }
                return new DirectoryEntry();
            }
            #endregion GetComputerData()
    
            #region CheckTFStatus()
            /// <summary>
            /// Prüft den Status des übergebenen Computernamens
            /// </summary>
            /// <param name="server">Computername</param>
            /// <returns>Ergebnismeldung</returns>
            internal static string CheckTFStatus(string server)
            {
                try
                {
                    DoWork(server);
                }
                catch (ApplicationException tfs)
                {
                    return tfs.Message;
                }
    
                if (!_tfs.HasAuthenticated)
                    return string.Format("Authentifizierung für {0} fehlgeschlagen!", server);
    
                try
                {
                    ConnectOptions con = new ConnectOptions();
                    con = ConnectOptions.None;
    
                    _tfs.Connect(con);
                    _cNode = _tfs.CatalogNode;
                }
                catch (ApplicationException ctn)
                {
                    return ctn.Message;
                }
    
                if (_tfs.CatalogNode == null)
                    return string.Format("Der Server {0} meldet {1}", server, _tfs.Name);
    
                return string.Format("{0}: Verbindung hergestellt zu {1}", server, _cNode.Resource.DisplayName);
            }
            #endregion CheckTFStatus()
    
            #region GetProjectCollections()
            /// <summary>
            /// Gibt die aktuellen Projektsammlungen zurück
            /// </summary>
            /// <param name="server">TFS</param>
            /// <param name="project">Projektname</param>
            /// <returns>Projektsammlung</returns>
            internal static List<RegisteredProjectCollection> GetProjectCollections(string server, string project)
            {
                Uri tfsUri = new Uri(string.Concat("http://", server, "/", string.IsNullOrEmpty(project) ? string.Empty : project));
    
                TfsConfigurationServer configurationServer =
                    TfsConfigurationServerFactory.GetConfigurationServer(tfsUri);
                Guid guid = new Guid();
                TfsTeamProjectCollection tpc = configurationServer.GetTeamProjectCollection(guid);
                //ReadOnlyCollection<CatalogNode> collectionNodes = configurationServer.CatalogNode.QueryChildren(
                //    new[] { CatalogResourceTypes.ProjectCollection },
                //    false, CatalogQueryOptions.None);
    
                return new List<RegisteredProjectCollection>
                {
                    RegisteredTfsConnections.GetProjectCollection(string.Concat(server, "\\", null ))
                };
            }
            #endregion GetProjectCollections()
    
            #region GetLastChangeSet()
            /// <summary>
            /// Holt die ID des letzten Changesets
            /// </summary>
            /// <returns>ChangeSet-ID</returns>
            internal static int GetLastChangeSet()
            {
                var lastID = _vcs.QueryHistory(
                    "$/",
                    VersionSpec.Latest,
                    0,
                    RecursionType.Full,
                    string.Empty,
                    VersionSpec.Latest,
                    VersionSpec.Latest,
                    1,
                    false,
                    true).Cast<Changeset>().Single().ChangesetId;
    
                return lastID;
            }
            #endregion GetLastChangeSet()
    
            #region GetAllChanges()
            /// <summary>
            /// Holt alle Changesets zu einem Teamprojekt
            /// </summary>
            internal static void GetAllChanges()
            {
                _changes = new List<Changeset>();
    
                int last = GetLastChangeSet();
                try
                {
                    for (int i = 1; i <= last; i++)
                    {
                        var change = _vcs.GetChangeset(i, true, true, true);
                        _changes.Add(change);
                    }
                }
                catch (Exception)
                {
                    // Dreckig. Aber so bricht er ab, wenns keine Changesets mehr gibt
                }
            }
    
            /// <summary>
            /// Gibt eine Liste aller Änderungen des betreffenden Nutzers zurück
            /// </summary>
            /// <param name="tree"></param>
            /// <returns>Changesets</returns>
            internal static List<Changeset> GetAllChanges(Telerik.WinControls.UI.RadTreeView tree)
            {
                List<Changeset> retVal = new List<Changeset>();
                string tmp = string.Empty;
    
                if (string.IsNullOrEmpty(_authUser))
                    _authUser = _vcs.AuthorizedUser;
    
                GetAllChanges();
    
                foreach (Telerik.WinControls.UI.RadTreeNode node in tree.CheckedNodes)
                {
                    if (node.Tag.GetType() == typeof(ReadOnlyCollection<CatalogNode>))
                    {
                        // Root-Node
                        retVal.AddRange(_changes.Where(item => item.Committer == _authUser));
                    }
                    else if (node.Tag.GetType() == typeof(CatalogNode))
                    {
                        retVal.AddRange(_changes.Where(x => x.Committer == _authUser && x.Changes.Where(y => y.Item.ServerItem.Contains((node.Tag as CatalogNode).Resource.DisplayName)).Count() > 0));
    
                        tmp = string.Empty;
    										// Unkenntlich wg. Firma
                        if ((node.Tag as CatalogNode).Resource.DisplayName.Contains("Projectname"))
                            tmp = (node.Tag as CatalogNode).Resource.DisplayName.Replace("Projectname", "Projectname");
                            else if ((node.Tag as CatalogNode).Resource.DisplayName.Contains("Projectname"))
                                tmp = (node.Tag as CatalogNode).Resource.DisplayName.Replace("Projectname", "Projectname");
                            else if ((node.Tag as CatalogNode).Resource.DisplayName.Contains("Projectname"))
                                tmp = (node.Tag as CatalogNode).Resource.DisplayName.Replace("Projectname", "Projectname");
    
                        if (!string.IsNullOrEmpty(tmp))
                            retVal.AddRange(_changes.Where(x => x.Committer == _authUser && x.Changes.Where(y => y.Item.ServerItem.Contains(tmp)).Count() > 0));
                    }
                }
                return retVal;
            }
            #endregion GetAllChanges()
    
            #region DoWork()
            /// <summary>
            /// Startet timeout-Handler um ggf. einen Abbruch zu erzwingen
            /// Geklaut bei: http://www.developerfusion.com/code/4497/i-need-a-timeout/
            /// </summary>
            /// <param name="server">Zu prüfender Computername</param>
            /// <returns></returns>
            internal static object DoWork(string server)
            {
                WorkDelegate d = new WorkDelegate(DoWorkHandler);
                IAsyncResult res = d.BeginInvoke(server, null, null);
                if (res.IsCompleted == false)
                {
                    res.AsyncWaitHandle.WaitOne(10000, false);
                    if (res.IsCompleted == false)
                        throw new ApplicationException(string.Format("Timeout bei Verbindungsversuch zu {0}", server));
                }
                return d.EndInvoke((AsyncResult)res);
            }
            #endregion DoWork()
    
            #region DoWorkHandler()
            /// <summary>
            /// Erledigt die eigentliche Arbeit als Thread
            /// </summary>
            /// <param name="server">Zu prüfender Computername</param>
            /// <returns></returns>
            private static object DoWorkHandler(string server)
            {
                Uri tfsUri = new Uri(string.Concat("http://", server, ":8080/tfs"));
                _tfs = null;
                _cNode = null;
    
                _tfs = TfsConfigurationServerFactory.GetConfigurationServer(tfsUri);
                TeamFoundationIdentity id = _tfs.AuthorizedIdentity;
                _tfs.Authenticate();
    
                return true;
            }
            #endregion DoWorkHandler()
    
            #region FillddnComputer()
            /// <summary>
            /// Füllt die DropDownListe der Computer
            /// </summary>
            /// <param name="radDropDownList">Dropdown-Liste</param>
            /// <returns>Gefüllte DropDown-Liste</returns>
            internal static Telerik.WinControls.UI.RadDropDownList FillddnComputer(Telerik.WinControls.UI.RadDropDownList radDropDownList)
            {
                Telerik.WinControls.UI.RadDropDownList retVal = radDropDownList;
    
                _allPC = _searcher.FindAll();
                foreach (SearchResult pc in _allPC)
                {
                    Telerik.WinControls.UI.RadListDataItem comp = new Telerik.WinControls.UI.RadListDataItem();
                    comp.Text = pc.GetDirectoryEntry().Name;
    
                    // Ausgabe ist normalerweise: "CN=Computername"
                    comp.Text = (comp.Text.Substring(0, 3) == "CN=") ? comp.Text.Substring(3) : comp.Text;
                    comp.Value = comp.Text;
                    retVal.Items.Add(comp);
                }
                return retVal;
            }
            #endregion FillddnComputer()
    
            #region FillddnProject()
            /// <summary>
            /// Füllt die DropDown-Liste der Projekte
            /// </summary>
            /// <param name="radDropDownList">DropDown-Liste der Projekte</param>
            /// <returns>Gefüllte DropDown-Liste der Projekte</returns>
            internal static Telerik.WinControls.UI.RadDropDownList FillddnProject(Telerik.WinControls.UI.RadDropDownList radDropDownList)
            {
                Telerik.WinControls.UI.RadDropDownList retVal = radDropDownList;
    
                if (_cNode == null)
                    return retVal;
    
                _cNodes = _cNode.QueryChildren(
                    new[] { CatalogResourceTypes.ProjectCollection },
                    true, CatalogQueryOptions.None);
    
                foreach (CatalogNode cNode in _cNodes)
                {
                    Telerik.WinControls.UI.RadListDataItem proj = new Telerik.WinControls.UI.RadListDataItem();
    
                    // Use the InstanceId property to get the team project collection
                    Guid cID = new Guid(cNode.Resource.Properties["InstanceId"]);
                    TfsTeamProjectCollection tPC = _tfs.GetTeamProjectCollection(cID);
                    _vcs = (VersionControlServer)tPC.GetService(typeof(VersionControlServer));
    
                    proj.Value = tPC;
                    proj.Text = tPC.Name;
                    retVal.Items.Add(proj);
                }
                return retVal;
            }
            #endregion FillddnProject()
    
            #region FilltreParts()
            /// <summary>
            /// Füllt die Teamprojekte in den TreeViewer
            /// </summary>
            /// <param name="tfsColl">root vom TFS</param>
            /// <param name="treeView">TreeView-Control aus MainForm</param>
            internal static void FilltreParts(TfsTeamProjectCollection tfsColl, ref Telerik.WinControls.UI.RadTreeView treeView)
            {
                treeView.Nodes.Clear();
    
                if (treeView == null || tfsColl == null || tfsColl.GetType() != typeof(TfsTeamProjectCollection))
                    return;
    
                // Alle Team-Projekte abholen
                ReadOnlyCollection<CatalogNode> pNodes = tfsColl.CatalogNode.QueryChildren(
                    new[] { CatalogResourceTypes.TeamProject },
                    false, CatalogQueryOptions.None);
    
                int i = 0;
                Telerik.WinControls.UI.RadTreeNode node1 = new Telerik.WinControls.UI.RadTreeNode();
                node1.Name = "Root";
                node1.Tag = pNodes;
                node1.CheckType = Telerik.WinControls.UI.CheckType.CheckBox;
                node1.Enabled = true;
                node1.BackColor = System.Drawing.SystemColors.Control;
                node1.ForeColor = System.Drawing.SystemColors.WindowText;
                node1.Text = tfsColl.Name;
                Telerik.WinControls.UI.RadTreeNode[] nodes = new Telerik.WinControls.UI.RadTreeNode[pNodes.Count];
    
                // List the team projects in the collection
                foreach (CatalogNode pNode in pNodes)
                {
                    nodes[i] = new Telerik.WinControls.UI.RadTreeNode();
                    nodes[i].Name = string.Format("Node{0:###}", i.ToString());
                    nodes[i].Tag = pNode;
                    nodes[i].CheckType = Telerik.WinControls.UI.CheckType.CheckBox;
                    nodes[i].Enabled = true;
                    nodes[i].Text = pNode.Resource.DisplayName;
    
                    i++;
                }
    
                for (int j = 0; j <= i-1; j++)
                {
                    node1.Nodes.Add(nodes[j]);
                }
                treeView.Nodes.Add(node1);
                treeView.ExpandAll();
            }
            #endregion FilltreParts()
    
            internal static void ExportChangeSets(List<Changeset> changes)
            {
                string msg;
    
                if (changes.Count < 1)
                    msg = "Keine Changesets ermittelt!";
                else
                {
                    try
                    {
                        StreamWriter outFile = new StreamWriter(@"C:\TFSout.txt", false, Encoding.Default);
                        foreach (Changeset cs in changes)
                        {
                            outFile.WriteLine(string.Format("{0}\t{1}\t{2}\t{3}",
                                cs.ChangesetId,
                                cs.CreationDate,
                                cs.Committer,
                                cs.Comment));
    
                            foreach (Change ch in cs.Changes)
                            {
                                outFile.WriteLine(string.Format("\t\tDatei:\t{0}", ch.Item.ServerItem.Replace("Projectname", "")));
                            }
                        }
                        outFile.Close();
                        msg = string.Format("Es wurden {0} Changesets nach {1} exportiert.", changes.Count, @"C:\TFSout.txt");
                        System.Diagnostics.Process excel = new System.Diagnostics.Process();
                        excel.StartInfo.FileName = "Excel.exe";
                        excel.StartInfo.Arguments = @"C:\TFSout.txt";
    
                        excel.Start();
                    }
                    catch (Exception ioex)
                    {
                        System.Windows.Forms.MessageBox.Show(ioex.Message);
                    }
                }
            }
        }
    }


    Hoffe, es kann Dir Anregungen geben. Einige für die Funktionalität irrelevante Stellen habe ich aus Datenschutzgründen maskiert.

    €: Der ganze untere Teil ist vermutlich für Dich uninteressant. Er kümmert sich lediglich um die Ausgabe (in einem Telerik Treeview-Control) und die Ausgabe als Tab-getrennte Textdatei mit Öffnung in Excel.
    Geändert von RAT: (09.04.2013 um 08:47 Uhr)
    Zitat Zitat von Auslieferator Beitrag anzeigen
    Fazit:
    Ein PC muss her!
    PC only!

  4. #4
    Notorischer Nörgler Avatar von RAT:
    Registriert seit
    04.08.2011
    Ort
    Rhoihesse
    Beiträge
    1.234

    Standard

    Nur mal so spaßeshalber ... konnte Dir das helfen?
    Zitat Zitat von Auslieferator Beitrag anzeigen
    Fazit:
    Ein PC muss her!
    PC only!

  5. #5
    Code Sorceress Avatar von andi9x17
    Registriert seit
    21.05.2011
    Ort
    Dark Net
    Beiträge
    3.135
    Gamer IDs

    Gamertag: andi9x17 PSN ID: andi9x17

    Standard

    Zitat Zitat von RAT: Beitrag anzeigen
    Nur mal so spaßeshalber ... konnte Dir das helfen?
    ja, vielen Dank! Bin zwar kein super VBS Genie, konnte aber anhand deine Programmierung einige Passagen für mich rausfiltern. konnte dir aber nicht früher antworten, weil ich zwischendurch Urlaub hatte.

    Ich selbst bevorzuge natürlich C#, C++ und Java. Aber ich bin ja nur ein kleiner Fisch im großen Behördenbecken.

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •