943 lines
37 KiB
C#
943 lines
37 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.IO;
|
|
using System.Security.AccessControl;
|
|
using System.Text.RegularExpressions;
|
|
using System.DirectoryServices;
|
|
using System.Threading;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Deployment;
|
|
using System.Reflection;
|
|
//using Excel = Microsoft.Office.Interop.Excel;
|
|
|
|
namespace Permissions
|
|
{
|
|
public partial class Form1 : Form
|
|
{
|
|
// CONFIGURATION
|
|
int optionsToggleMove = 28;
|
|
int debugPanelMove = 333;
|
|
string LDAPDirEnt = "LDAP://DC=domain,DC=local"; // TODO: Obsolete?
|
|
string getUserInfo = "sAMAccountName"; // TODO: Make configurable through UI
|
|
string ignoreGroupNameBegin = "BUILTIN,LOCAL,NT AUTHORITY,SYSTEM,S-"; // TODO: Make configurable through UI
|
|
public static string startFolder = @""; // TODO: Obsolete, remove all references
|
|
int maxDirDepth = 1;
|
|
// END CONFIGURATION
|
|
|
|
string groupNameStripBegin = Environment.UserDomainName + @"\";
|
|
|
|
string permInfo = "";
|
|
int resultCount = 0;
|
|
Dictionary<string, string> groupHist = new Dictionary<string,string>();
|
|
ArrayList groupNames = new ArrayList();
|
|
Dictionary<string, string> groupsAndMembers = new Dictionary<string, string>();
|
|
public static ArrayList folderList = new ArrayList();
|
|
public static ArrayList folderListTemp = new ArrayList();
|
|
public static ArrayList debugInfo = new ArrayList();
|
|
|
|
|
|
// GUI
|
|
public Form1()
|
|
{
|
|
InitializeComponent();
|
|
|
|
string currentVersion = Application.ProductVersion.ToString();
|
|
version_lbl.Text = "v" + currentVersion;
|
|
updateDebugInfo("Function InitializeComponent() called");
|
|
this.KeyPreview = true;
|
|
this.Height = this.Height - optionsToggleMove;
|
|
result_panel.Location = new Point(result_panel.Location.X, result_panel.Location.Y - optionsToggleMove);
|
|
this.Width = this.Width - debugPanelMove;
|
|
label3.Text = "";
|
|
saveAs_bttn.Enabled = false;
|
|
clear_bttn.Enabled = false;
|
|
startTime_label.Text = "";
|
|
endTime_label.Text = "";
|
|
Folder_textbox.Text = "";
|
|
results_textbox.Text = resultCount.ToString();
|
|
tabControl1.TabPages.Remove(homeDir);
|
|
updateDebugInfo("Program started");
|
|
updateDebugInfo("Version: " + currentVersion);
|
|
}
|
|
|
|
public void UnhandledThreadExceptionHandler(object sender, ThreadExceptionEventArgs e)
|
|
{
|
|
this.HandleUnhandledException(e.Exception);
|
|
}
|
|
|
|
public void HandleUnhandledException(Exception e, bool ShowMessageBox = false)
|
|
{
|
|
// do what you want here.
|
|
updateDebugInfo("---------------------------");
|
|
updateDebugInfo("Unhandeled exeption:");
|
|
updateDebugInfo(e.Message);
|
|
updateDebugInfo("---------------------------");
|
|
if (ShowMessageBox == true)
|
|
{
|
|
if (MessageBox.Show("An unexpected error has occurred. Continue?",
|
|
"My application", MessageBoxButtons.YesNo, MessageBoxIcon.Stop,
|
|
MessageBoxDefaultButton.Button2) == DialogResult.No)
|
|
{
|
|
Application.Exit();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void controlsEnabled(bool enabled)
|
|
{
|
|
updateDebugInfo("Function controlsEnabled(bool " + enabled + ") called");
|
|
saveAs_bttn.Enabled = enabled;
|
|
clear_bttn.Enabled = enabled;
|
|
getPermissions_bttn.Enabled = enabled;
|
|
getPermissions_bttn.Visible = enabled;
|
|
skipDoubleGroup_chkBox.Enabled = enabled;
|
|
ignorePassGroups_chkBox.Enabled = enabled;
|
|
onlyLeesGebr_chkBox.Enabled = enabled;
|
|
recusive_chkBox.Enabled = enabled;
|
|
getOwnerGroup_chkBox.Enabled = enabled;
|
|
multiPath_bttn.Enabled = enabled;
|
|
maxLvl_numud.Enabled = enabled;
|
|
|
|
if (folderListTemp.Count < 2)
|
|
{
|
|
path_panel.Enabled = enabled;
|
|
}
|
|
}
|
|
|
|
public void startScan()
|
|
{
|
|
updateDebugInfo("Function startScan() called");
|
|
updateDebugInfo("Scan options:");
|
|
updateDebugInfo("Recursive: " + recusive_chkBox.Checked);
|
|
updateDebugInfo("Recursive levels: " + maxLvl_numud.Value);
|
|
updateDebugInfo("Ignore __pass groups: " + ignorePassGroups_chkBox.Checked);
|
|
updateDebugInfo("Skip double groups: " + skipDoubleGroup_chkBox.Checked);
|
|
updateDebugInfo("Only __lees && __gebr groups: " + onlyLeesGebr_chkBox.Checked);
|
|
updateDebugInfo("Get __eign group members: " + getOwnerGroup_chkBox.Checked);
|
|
if (upDateDebugLog.IsBusy) { upDateDebugLog.CancelAsync(); pauseDebug_bttn.Text = "Scan running"; pauseDebug_bttn.Enabled = false; updateDebugInfo("Pausing debug background worker to prevent conflicts between worker threads"); };
|
|
loading_pic_visible(true);
|
|
cancel_bttn.Visible = true;
|
|
cancel_bttn.Enabled = true;
|
|
folderListTemp.Clear();
|
|
controlsEnabled(false);
|
|
mainProgressBar.Visible = true;
|
|
startTime_label.Text = DateTime.Now.Hour.ToString() + ":" + DateTime.Now.Minute.ToString() + ":" + DateTime.Now.Second.ToString();
|
|
}
|
|
|
|
public void endScan()
|
|
{
|
|
updateDebugInfo("Function endScan() called");
|
|
loading_pic_visible(false);
|
|
cancel_bttn.Visible = false;
|
|
cancel_bttn.Enabled = false;
|
|
mainProgressBar.Visible = false;
|
|
controlsEnabled(true);
|
|
groupHist.Clear();
|
|
label3.Text = "";
|
|
endTime_label.Text = DateTime.Now.Hour.ToString() + ":" + DateTime.Now.Minute.ToString() + ":" + DateTime.Now.Second.ToString();
|
|
if (pauseDebug_bttn.Enabled == false && pauseDebug_bttn.Text == "Scan running") { upDateDebugLog.RunWorkerAsync(); pauseDebug_bttn.Text = "Pause debugger"; pauseDebug_bttn.Enabled = true; };
|
|
}
|
|
|
|
private void updateResults(int resultCount)
|
|
{
|
|
results_textbox.Text = resultCount.ToString();
|
|
}
|
|
|
|
public delegate void updateResultsCallback(int resultCount);
|
|
|
|
private void updateRichTextBox1(string txt)
|
|
{
|
|
richTextBox1.Text = txt;
|
|
}
|
|
|
|
public delegate void updateRichTextBox1Callback(string txt);
|
|
|
|
private void updateDebug_rtextbox(string txt)
|
|
{
|
|
if (txt != debug_rtextbox.Text)
|
|
{
|
|
debug_rtextbox.Text = txt;
|
|
}
|
|
}
|
|
|
|
public delegate void updateDebug_rtextboxCallback(string txt);
|
|
|
|
private void updateDataGridView1(string dataGridInfo)
|
|
{
|
|
string[] dataGridInfo2 = dataGridInfo.Split('|');
|
|
|
|
dataGridView1.Rows.Add(dataGridInfo2[0], dataGridInfo2[1], dataGridInfo2[2]);
|
|
}
|
|
|
|
public delegate void updateDataGridView1Callback(string dataGridInfo);
|
|
|
|
private void updateLabel3(string txt)
|
|
{
|
|
label3.Text = txt;
|
|
}
|
|
|
|
public delegate void updateLabel3Callback(string text);
|
|
|
|
private void loading_pic_visible(bool visible)
|
|
{
|
|
loading_pic.Visible = visible;
|
|
}
|
|
|
|
public delegate void loading_pic_visibleCallback(bool visible);
|
|
|
|
private void mainProgressBar_update(int Current, bool visible)
|
|
{
|
|
mainProgressBar.Value = Current;
|
|
mainProgressBar.Visible = visible;
|
|
}
|
|
|
|
public delegate void mainProgressBar_updateCallback(int Current, bool visible);
|
|
|
|
private void mainProgressBar_setMax(int Max)
|
|
{
|
|
mainProgressBar.Maximum = Max;
|
|
}
|
|
|
|
public delegate void mainProgressBar_setMaxCallback(int Max);
|
|
|
|
private void updateMemUsage_lbl(string txt)
|
|
{
|
|
memUsage_lbl.Text = txt;
|
|
}
|
|
|
|
public delegate void updateMemUsage_lblCallback(string text);
|
|
|
|
public void toggleDebugPanelVisible()
|
|
{
|
|
if (debug_panel.Visible == false)
|
|
{
|
|
this.Width = this.Width + debugPanelMove;
|
|
debug_panel.Visible = true;
|
|
updateDebugInfo("Debug panel opened");
|
|
upDateDebugLog.RunWorkerAsync();
|
|
updateDebugInfo("Debug background worker started");
|
|
tabControl1.TabPages.Add(homeDir);
|
|
}
|
|
else if (debug_panel.Visible == true)
|
|
{
|
|
this.Width = this.Width - debugPanelMove;
|
|
debug_panel.Visible = false;
|
|
updateDebugInfo("Debug panel closed");
|
|
if (upDateDebugLog.IsBusy) { upDateDebugLog.CancelAsync(); };
|
|
updateDebugInfo("Debug background worker stopped");
|
|
tabControl1.TabPages.Remove(homeDir);
|
|
}
|
|
}
|
|
|
|
public void toggleCSVvisible()
|
|
{
|
|
if (dataGridView1.Visible == true) { dataGridView1.Visible = false; }
|
|
else { dataGridView1.Visible = true; }
|
|
}
|
|
|
|
|
|
// GUI controls
|
|
private void cancel_bttn_Click(object sender, EventArgs e)
|
|
{
|
|
updateDebugInfo("cancel_bttn was clicked");
|
|
label3.Text = "Cancelling...";
|
|
if (getPermissionsRecursive.IsBusy) { getPermissionsRecursive.CancelAsync(); };
|
|
|
|
cancel_bttn.Enabled = false;
|
|
}
|
|
|
|
private void options_link_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
|
|
{
|
|
updateDebugInfo("options_Link was clicked");
|
|
if (options_panel.Visible)
|
|
{
|
|
updateDebugInfo("Disabling options panel");
|
|
options_panel.Visible = false;
|
|
options_link.Text = "-------------- Show options --------------";
|
|
//this.Height = this.Height - optionsToggleMove;
|
|
result_panel.Height = result_panel.Height + optionsToggleMove;
|
|
dataGridView1.Height = dataGridView1.Height + optionsToggleMove;
|
|
richTextBox1.Height = richTextBox1.Height + optionsToggleMove;
|
|
result_panel.Location = new Point(result_panel.Location.X, result_panel.Location.Y - optionsToggleMove);
|
|
}
|
|
else
|
|
{
|
|
updateDebugInfo("Enabling options panel");
|
|
options_panel.Visible = true;
|
|
options_link.Text = "-------------- Hide options ---------------";
|
|
//this.Height = this.Height + optionsToggleMove;
|
|
result_panel.Height = result_panel.Height - optionsToggleMove;
|
|
dataGridView1.Height = dataGridView1.Height - optionsToggleMove;
|
|
richTextBox1.Height = richTextBox1.Height - optionsToggleMove;
|
|
result_panel.Location = new Point(result_panel.Location.X, result_panel.Location.Y + optionsToggleMove);
|
|
};
|
|
}
|
|
|
|
private void saveAs_bttn_Click(object sender, EventArgs e)
|
|
{
|
|
updateDebugInfo("saveAs_bttn was clicked");
|
|
if (results_textbox.Text != "0" && results_textbox.Text != "")
|
|
{
|
|
|
|
string savedFile = "";
|
|
|
|
saveFD.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
|
|
saveFD.Title = "Save as...";
|
|
saveFD.FileName = "permissions";
|
|
|
|
saveFD.Filter = "Excel Files|*.xls|CSV Files|*.csv|TXT Files|*.txt";
|
|
|
|
if (saveFD.ShowDialog() != DialogResult.Cancel)
|
|
{
|
|
savedFile = saveFD.FileName;
|
|
|
|
controlsEnabled(false);
|
|
|
|
label3.Invoke(new updateLabel3Callback(this.updateLabel3), new object[] { "Saving file..." });
|
|
loading_pic.Invoke(new loading_pic_visibleCallback(this.loading_pic_visible), new object[] { true });
|
|
|
|
if (File.Exists(savedFile)) { File.Delete(savedFile); }
|
|
|
|
//TODO: Make full use of the background worker for saving to file
|
|
if (savedFile.EndsWith(".xls"))
|
|
{
|
|
updateDebugInfo("Saving file als .xls in " + savedFile);
|
|
saveAs.RunWorkerAsync(savedFile);
|
|
}
|
|
else if (Path.GetExtension(savedFile).ToLower() == ".csv" || Path.GetExtension(savedFile).ToLower() == ".txt")
|
|
{
|
|
updateDebugInfo("Saving file als .csv in " + savedFile);
|
|
saveCSV(savedFile);
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Unsupported file format...");
|
|
updateDebugInfo("Unsupported file format...");
|
|
}
|
|
}
|
|
}
|
|
else { MessageBox.Show("No results"); updateDebugInfo("No results"); }
|
|
}
|
|
|
|
private void getPermissions_bttn_Click(object sender, EventArgs e)
|
|
{
|
|
updateDebugInfo("getPermissions_bttn was clicked");
|
|
scanPermissions();
|
|
}
|
|
|
|
private void Folder_textbox_KeyPress(object sender, KeyPressEventArgs e)
|
|
{
|
|
if (e.KeyChar == (char)13)
|
|
{
|
|
scanPermissions();
|
|
}
|
|
}
|
|
|
|
private void clear_bttn_Click(object sender, EventArgs e)
|
|
{
|
|
updateDebugInfo("clear_bttn was clicked");
|
|
richTextBox1.Text = "";
|
|
permInfo = "";
|
|
resultCount = 0;
|
|
results_textbox.Text = resultCount.ToString();
|
|
dataGridView1.Rows.Clear();
|
|
groupHist.Clear();
|
|
groupsAndMembers.Clear();
|
|
startTime_label.Text = "";
|
|
endTime_label.Text = "";
|
|
saveAs_bttn.Enabled = false;
|
|
clear_bttn.Enabled = false;
|
|
updateDebugInfo("All results cleared");
|
|
}
|
|
|
|
private void multiPath_bttn_Click(object sender, EventArgs e)
|
|
{
|
|
updateDebugInfo("multiPath_bttn was clicked");
|
|
multiPath multiPathForm = new multiPath();
|
|
controlsEnabled(false);
|
|
if(multiPathForm.ShowDialog() == DialogResult.OK)
|
|
{
|
|
controlsEnabled(true);
|
|
}
|
|
else
|
|
{
|
|
controlsEnabled(true);
|
|
}
|
|
|
|
updateDebugInfo("The multipath dialogue was used");
|
|
|
|
if (folderList.Count > 0)
|
|
{
|
|
path_panel.Enabled = false;
|
|
Folder_textbox.Text = "[Multiple Folders]";
|
|
updateDebugInfo("Multipath folder count = " + folderList.Count + "");
|
|
|
|
if (folderList.Count == 1)
|
|
{
|
|
path_panel.Enabled = true;
|
|
Folder_textbox.Text = folderList[0].ToString().Replace(startFolder, "");
|
|
updateDebugInfo("Found only 1 value in multipath array");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
path_panel.Enabled = true;
|
|
Folder_textbox.Text = "";
|
|
updateDebugInfo("The multipath dialogue was cancelled");
|
|
}
|
|
}
|
|
|
|
private void Form1_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if (e.Control && e.KeyCode == Keys.D)
|
|
{
|
|
updateDebugInfo("CTRL + D was pressed");
|
|
toggleDebugPanelVisible();
|
|
}
|
|
}
|
|
|
|
private void viewCSV_bttn_Click(object sender, EventArgs e)
|
|
{
|
|
toggleCSVvisible();
|
|
}
|
|
|
|
private void pauseDebug_bttn_Click(object sender, EventArgs e)
|
|
{
|
|
if (upDateDebugLog.IsBusy) { upDateDebugLog.CancelAsync(); pauseDebug_bttn.Text = "Resume debugger"; updateDebugInfo("Debug background worker stopped"); };
|
|
|
|
if (!upDateDebugLog.IsBusy) { pauseDebug_bttn.Text = "Pause debugger"; upDateDebugLog.RunWorkerAsync(); updateDebugInfo("Debug background worker started"); };
|
|
}
|
|
|
|
private void tabControl1_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
updateDebugInfo("Selected TAB changed to: "+tabControl1.SelectedTab.ToString());
|
|
}
|
|
|
|
private void recusive_chkBox_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if (recusive_chkBox.Checked)
|
|
{
|
|
maxLvl_numud.Visible = true;
|
|
label7.Visible = true;
|
|
}
|
|
else
|
|
{
|
|
maxLvl_numud.Visible = false;
|
|
label7.Visible = false;
|
|
}
|
|
}
|
|
|
|
|
|
// Functions
|
|
private void scanPermissions()
|
|
{
|
|
updateDebugInfo("Function scanPermissions() called");
|
|
updateDebugInfo("Folder_textbox.text = " + Folder_textbox.Text + "");
|
|
if (folderList.Count == 0)
|
|
{
|
|
updateDebugInfo("folderList count = 0");
|
|
folderList.Add(Folder_textbox.Text);
|
|
updateDebugInfo("folderList add " + Folder_textbox.Text + "");
|
|
}
|
|
|
|
bool dirExists = true;
|
|
|
|
foreach (string f in folderList)
|
|
{
|
|
if (!Directory.Exists(f))
|
|
{
|
|
dirExists = false;
|
|
}
|
|
}
|
|
|
|
if (dirExists)
|
|
{
|
|
updateDebugInfo("Folders in folderList exist");
|
|
startScan();
|
|
|
|
updateDebugInfo("Scanning folders:");
|
|
foreach (string f in folderList)
|
|
{
|
|
folderListTemp.Add(f);
|
|
updateDebugInfo(" " + f + "");
|
|
}
|
|
|
|
getPermissionsRecursive.RunWorkerAsync(folderListTemp);
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Path incorrect");
|
|
updateDebugInfo("Path incorrect!");
|
|
if (Folder_textbox.Enabled)
|
|
{
|
|
updateDebugInfo("Cleared folderList");
|
|
folderList.Clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool ignoreGroupNamesBegin(string ignoreGroups, string ignoredGroupNameBegin)
|
|
{
|
|
updateDebugInfo("Function ignoreGroupNamesBegin(string " + ignoreGroups + ", string " + ignoredGroupNameBegin + ") called");
|
|
string[] ignoredGroups = ignoreGroups.Split(',');
|
|
|
|
bool result = false;
|
|
|
|
if (!result)
|
|
{
|
|
foreach (string ignoregroup in ignoredGroups)
|
|
{
|
|
if (!result)
|
|
{
|
|
if (ignoredGroupNameBegin.StartsWith(ignoregroup))
|
|
{
|
|
result = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public ArrayList splitGroupMembers(Dictionary<string, string> GroupsAndMembers, string groupName)
|
|
{
|
|
ArrayList splitGroupMembers = new ArrayList();
|
|
|
|
if (GroupsAndMembers.ContainsKey(groupName))
|
|
{
|
|
string[] s = GroupsAndMembers[groupName].Split('|');
|
|
|
|
foreach (string gm in s)
|
|
{
|
|
if (gm != "")
|
|
{ splitGroupMembers.Add(gm); }
|
|
}
|
|
}
|
|
|
|
return splitGroupMembers;
|
|
}
|
|
|
|
public Dictionary<string, string> GetGroupMembers(string strGroup)
|
|
{
|
|
string groupMembers = "";
|
|
|
|
updateDebugInfo("Getting group members for " + strGroup);
|
|
|
|
if (!groupsAndMembers.ContainsKey(strGroup))
|
|
{
|
|
updateDebugInfo("Group was not in cache, doing LDAP queries");
|
|
try
|
|
{
|
|
DirectoryEntry ent = new DirectoryEntry(LDAPDirEnt);
|
|
DirectorySearcher srch = new DirectorySearcher("(CN=" + strGroup + ")");
|
|
SearchResultCollection coll = srch.FindAll();
|
|
foreach (SearchResult rs in coll)
|
|
{
|
|
ResultPropertyCollection resultPropColl = rs.Properties;
|
|
foreach (Object memberColl in resultPropColl["member"])
|
|
{
|
|
DirectoryEntry gpMemberEntry = new DirectoryEntry("LDAP://" + memberColl);
|
|
System.DirectoryServices.PropertyCollection userProps = gpMemberEntry.Properties;
|
|
object obVal = userProps[getUserInfo].Value;
|
|
if (null != obVal)
|
|
{
|
|
groupMembers = groupMembers + "|" + obVal.ToString();
|
|
}
|
|
}
|
|
}
|
|
if (groupMembers != "")
|
|
{
|
|
groupsAndMembers.Add(strGroup, groupMembers);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
HandleUnhandledException(ex);
|
|
}
|
|
}
|
|
return groupsAndMembers;
|
|
}
|
|
|
|
public static string StringCollectionToString(StringCollection stringCollection)
|
|
{
|
|
string outputString = "";
|
|
|
|
if (stringCollection != null && stringCollection.Count > 0)
|
|
{
|
|
|
|
foreach (string inputString in stringCollection)
|
|
|
|
outputString += inputString + ",";
|
|
|
|
outputString = outputString.Substring(0, outputString.Length - 1);
|
|
|
|
}
|
|
|
|
return outputString;
|
|
|
|
}
|
|
|
|
public ArrayList DirSearch(string sDir)
|
|
{
|
|
ArrayList directories = new ArrayList();
|
|
updateDebugInfo("Function DirSearch(string " + sDir + ") was called");
|
|
directories.Add(sDir);
|
|
|
|
foreach (string d in Directory.GetDirectories(sDir))
|
|
{
|
|
if (getPermissionsRecursive.CancellationPending) { break; };
|
|
|
|
string[] dirCount = sDir.Split('\\');
|
|
|
|
directories.Add(d);
|
|
|
|
if (dirCount.Length < maxDirDepth)
|
|
{
|
|
foreach (string f in Directory.GetDirectories(d))
|
|
{
|
|
if (getPermissionsRecursive.CancellationPending) { break; };
|
|
directories.Add(f);
|
|
}
|
|
DirSearch(d);
|
|
}
|
|
}
|
|
return directories;
|
|
}
|
|
|
|
private void releaseObject(object obj)
|
|
{
|
|
try
|
|
{
|
|
System.Runtime.InteropServices.Marshal.ReleaseComObject(obj);
|
|
obj = null;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
obj = null;
|
|
HandleUnhandledException(ex);
|
|
}
|
|
finally
|
|
{
|
|
GC.Collect();
|
|
}
|
|
}
|
|
|
|
/*
|
|
private void saveXLS(string savedFile)
|
|
{
|
|
CultureInfo oldCI = Thread.CurrentThread.CurrentCulture;
|
|
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
|
|
|
|
Excel.Application xlApp;
|
|
Excel.Workbook xlWorkBook;
|
|
Excel.Worksheet xlWorkSheet;
|
|
object misValue = System.Reflection.Missing.Value;
|
|
|
|
xlApp = new Excel.ApplicationClass();
|
|
xlWorkBook = xlApp.Workbooks.Add(misValue);
|
|
xlWorkSheet = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(1);
|
|
int i = 0;
|
|
int j = 0;
|
|
|
|
for (i = 0; i <= dataGridView1.RowCount - 1; i++)
|
|
{
|
|
for (j = 0; j <= dataGridView1.ColumnCount - 1; j++)
|
|
{
|
|
DataGridViewCell cell = dataGridView1[j, i];
|
|
xlWorkSheet.Cells[i + 1, j + 1] = cell.Value;
|
|
}
|
|
}
|
|
|
|
xlWorkBook.SaveAs(savedFile, Excel.XlFileFormat.xlWorkbookNormal, misValue, misValue, misValue, misValue, Excel.XlSaveAsAccessMode.xlExclusive, misValue, misValue, misValue, misValue, misValue);
|
|
xlWorkBook.Close(true, misValue, misValue);
|
|
xlApp.Quit();
|
|
|
|
releaseObject(xlWorkSheet);
|
|
releaseObject(xlWorkBook);
|
|
releaseObject(xlApp);
|
|
|
|
MessageBox.Show("File saved as: " + savedFile);
|
|
updateDebugInfo("File saved as: " + savedFile);
|
|
|
|
if (oldCI != null)
|
|
{ Thread.CurrentThread.CurrentCulture = oldCI; }
|
|
}
|
|
*/
|
|
|
|
private void saveCSV(string savedFile)
|
|
{
|
|
richTextBox1.SaveFile(savedFile, RichTextBoxStreamType.PlainText);
|
|
MessageBox.Show("File saved as: " + savedFile);
|
|
updateDebugInfo("File saved as: " + savedFile);
|
|
|
|
label3.Invoke(new updateLabel3Callback(this.updateLabel3), new object[] { "" });
|
|
loading_pic.Invoke(new loading_pic_visibleCallback(this.loading_pic_visible), new object[] { false });
|
|
controlsEnabled(true);
|
|
}
|
|
|
|
public string currentTimeString()
|
|
{
|
|
string currentTimeString = DateTime.Now.Hour.ToString() + ":" + DateTime.Now.Minute.ToString() + ":" + DateTime.Now.Second.ToString();
|
|
return currentTimeString;
|
|
}
|
|
|
|
public void updateDebugInfo(string info)
|
|
{
|
|
try { debugInfo.Add(currentTimeString() + "|" + info); }
|
|
catch (Exception eDebugInfoAdd) { HandleUnhandledException(eDebugInfoAdd); };
|
|
}
|
|
|
|
|
|
// Background workers
|
|
private void getPermissionsRecursive_DoWork(object sender, DoWorkEventArgs e)
|
|
{
|
|
int maxDirDept_plus = 0;
|
|
|
|
if (Int32.TryParse(maxLvl_numud.Value.ToString(), out maxDirDept_plus) && recusive_chkBox.Checked)
|
|
{ maxDirDept_plus = Int32.Parse(maxLvl_numud.Value.ToString()); }
|
|
else
|
|
{ maxDirDept_plus = 1; }
|
|
|
|
|
|
maxDirDepth = maxDirDept_plus;
|
|
|
|
updateDebugInfo("Max dir depth set to:" + maxDirDepth);
|
|
|
|
|
|
updateDebugInfo("Background worker getPermissionsRecurisve started");
|
|
ArrayList subPath = new ArrayList();
|
|
|
|
foreach (string f in folderListTemp)
|
|
{
|
|
if (recusive_chkBox.Checked)
|
|
{
|
|
label3.Invoke(new updateLabel3Callback(this.updateLabel3), new object[] { "Scanning for folders(" + f + ")..." });
|
|
updateDebugInfo("Scanning folders...");
|
|
foreach (string subPath2 in DirSearch(f))
|
|
{
|
|
if (getPermissionsRecursive.CancellationPending)
|
|
{
|
|
e.Cancel = true;
|
|
label3.Invoke(new updateLabel3Callback(this.updateLabel3), new object[] { "Cancelled..." });
|
|
Thread.Sleep(2);
|
|
break;
|
|
}
|
|
subPath.Add(subPath2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
subPath.Add(f);
|
|
}
|
|
}
|
|
|
|
subPath.Sort();
|
|
|
|
int currentProgress = 0;
|
|
|
|
updateDebugInfo("Found " + subPath.Count + " Folders to check ACL");
|
|
|
|
foreach (string subDir in subPath)
|
|
{
|
|
currentProgress = currentProgress + 1;
|
|
mainProgressBar.Invoke(new mainProgressBar_setMaxCallback(this.mainProgressBar_setMax), new object[] { subPath.Count });
|
|
mainProgressBar.Invoke(new mainProgressBar_updateCallback(this.mainProgressBar_update), new object[] { currentProgress, true });
|
|
|
|
if (getPermissionsRecursive.CancellationPending)
|
|
{
|
|
e.Cancel = true;
|
|
break;
|
|
}
|
|
|
|
label3.Invoke(new updateLabel3Callback(this.updateLabel3), new object[] { "Scanning ACL (" + subDir + ")..." });
|
|
updateDebugInfo("Scanning ACL (" + subDir + ")...");
|
|
|
|
// Load directory information
|
|
DirectorySecurity myDirectorySecurity = Directory.GetAccessControl(subDir);
|
|
// Obtain the access control list (ACL)
|
|
AuthorizationRuleCollection ACL = myDirectorySecurity.GetAccessRules(true, false, typeof(System.Security.Principal.NTAccount));
|
|
// Go thru each access control entry (ACE) in the ACL
|
|
foreach (AuthorizationRule ACE in ACL)
|
|
{
|
|
System.Threading.Thread.Sleep(50);
|
|
if (getPermissionsRecursive.CancellationPending)
|
|
{
|
|
e.Cancel = true;
|
|
label3.Invoke(new updateLabel3Callback(this.updateLabel3), new object[] { "Cancelled..." });
|
|
updateDebugInfo("Cancelled backgroundworker");
|
|
Thread.Sleep(2);
|
|
break;
|
|
}
|
|
|
|
string groupName = ACE.IdentityReference.ToString();
|
|
groupName = groupName.Replace(groupNameStripBegin, "");
|
|
|
|
if (getOwnerGroup_chkBox.Checked)
|
|
{
|
|
|
|
if (groupName.Contains("__gebr") || groupName.Contains("__lees"))
|
|
{
|
|
string groupNameOwner = "";
|
|
groupNameOwner = groupName.Replace("__gebr", "__eign");
|
|
groupNameOwner = groupName.Replace("__lees", "__eign");
|
|
|
|
if (!groupHist.ContainsKey(groupNameOwner) || !groupHist.ContainsValue(subDir))
|
|
{
|
|
if (skipDoubleGroup_chkBox.Checked)
|
|
{ groupHist[groupNameOwner] = subDir; }
|
|
|
|
if (!ignoreGroupNamesBegin(ignoreGroupNameBegin, groupNameOwner))
|
|
{
|
|
bool getMembers = true;
|
|
|
|
if (groupNameOwner.StartsWith(ignoreGroupNameBegin)) { getMembers = false; }
|
|
|
|
if (getMembers)
|
|
{
|
|
label3.Invoke(new updateLabel3Callback(this.updateLabel3), new object[] { "Getting members for " + groupNameOwner + "..." });
|
|
|
|
Dictionary<string, string> groupMembers = GetGroupMembers(groupNameOwner);
|
|
|
|
ArrayList membersOfGroup = splitGroupMembers(groupMembers, groupNameOwner);
|
|
|
|
foreach (string gm in membersOfGroup)
|
|
{
|
|
string dataGridInfo = subDir + "|" + groupNameOwner + "|" + gm;
|
|
permInfo = permInfo + subDir + "," + groupNameOwner + "," + gm + "\n";
|
|
dataGridView1.Invoke(new updateDataGridView1Callback(this.updateDataGridView1), new object[] { dataGridInfo });
|
|
richTextBox1.Invoke(new updateRichTextBox1Callback(this.updateRichTextBox1), new object[] { permInfo });
|
|
|
|
resultCount = dataGridView1.RowCount;
|
|
results_textbox.Invoke(new updateResultsCallback(this.updateResults), new object[] { resultCount });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!groupHist.ContainsKey(groupName) || !groupHist.ContainsValue(subDir))
|
|
{
|
|
if (skipDoubleGroup_chkBox.Checked)
|
|
{ groupHist[groupName] = subDir; }
|
|
|
|
if (!ignoreGroupNamesBegin(ignoreGroupNameBegin, groupName))
|
|
{
|
|
bool getMembers = true;
|
|
if (ignorePassGroups_chkBox.Checked && groupName.EndsWith("__pass")) { getMembers = false; }
|
|
else if (onlyLeesGebr_chkBox.Checked && groupName.EndsWith("__gebr") == false && groupName.EndsWith("__lees") == false) { getMembers = false; }
|
|
else if (groupName.StartsWith(ignoreGroupNameBegin)) { getMembers = false; }
|
|
|
|
if (getMembers)
|
|
{
|
|
label3.Invoke(new updateLabel3Callback(this.updateLabel3), new object[] { "Getting members for " + groupName + "..." });
|
|
|
|
Dictionary<string, string> groupMembers = GetGroupMembers(groupName);
|
|
|
|
ArrayList membersOfGroup = splitGroupMembers(groupMembers, groupName);
|
|
|
|
foreach (string gm in membersOfGroup)
|
|
{
|
|
string dataGridInfo = subDir + "|" + groupName + "|" + gm;
|
|
permInfo = permInfo + subDir + "," + groupName + "," + gm + "\n";
|
|
dataGridView1.Invoke(new updateDataGridView1Callback(this.updateDataGridView1), new object[] { dataGridInfo });
|
|
richTextBox1.Invoke(new updateRichTextBox1Callback(this.updateRichTextBox1), new object[] { permInfo });
|
|
|
|
resultCount = dataGridView1.RowCount;
|
|
results_textbox.Invoke(new updateResultsCallback(this.updateResults), new object[] { resultCount });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
e.Result = permInfo;
|
|
}
|
|
|
|
private void getPermissionsRecursive_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
|
|
{
|
|
endScan();
|
|
updateDebugInfo("Background worker getPermissionsRecurisve stopped");
|
|
mainProgressBar.Invoke(new mainProgressBar_setMaxCallback(this.mainProgressBar_setMax), new object[] { 0 });
|
|
mainProgressBar.Invoke(new mainProgressBar_updateCallback(this.mainProgressBar_update), new object[] { 0, false });
|
|
|
|
}
|
|
|
|
private void saveAs_DoWork(object sender, DoWorkEventArgs e)
|
|
{
|
|
updateDebugInfo("Background worker saveAs started");
|
|
string savedFile = (string)e.Argument;
|
|
|
|
if (savedFile.EndsWith(".xls"))
|
|
{
|
|
updateDebugInfo("Saving as .xls file");
|
|
//saveXLS(savedFile);
|
|
}
|
|
else if (Path.GetExtension(savedFile).ToLower() == ".csv" || Path.GetExtension(savedFile).ToLower() == ".txt")
|
|
{
|
|
updateDebugInfo("Saving as .csv or .txt file");
|
|
saveCSV(savedFile);
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Unsupported file format...");
|
|
updateDebugInfo("Unsupported file format...");
|
|
}
|
|
}
|
|
|
|
private void saveAs_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
|
|
{
|
|
label3.Invoke(new updateLabel3Callback(this.updateLabel3), new object[] { "" });
|
|
loading_pic.Invoke(new loading_pic_visibleCallback(this.loading_pic_visible), new object[] { false });
|
|
controlsEnabled(true);
|
|
updateDebugInfo("Background worker saveAs stopped");
|
|
}
|
|
|
|
private void updateDebugLog_DoWork(object sender, DoWorkEventArgs e)
|
|
{
|
|
updateDebugInfo("Starting debug background worker");
|
|
while (true)
|
|
{
|
|
string debugInfoTemp = "";
|
|
try
|
|
{
|
|
foreach (string d in debugInfo)
|
|
{
|
|
debugInfoTemp = debugInfoTemp + d + "\n";
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{ HandleUnhandledException(ex); }
|
|
|
|
PerformanceCounter performanceCounter = new PerformanceCounter();
|
|
performanceCounter.CategoryName = "Process";
|
|
performanceCounter.CounterName = "Working Set";
|
|
performanceCounter.InstanceName = Process.GetCurrentProcess().ProcessName;
|
|
memUsage_lbl.Invoke(new updateMemUsage_lblCallback(this.updateMemUsage_lbl), new object[] { ((uint)performanceCounter.NextValue() / 1024).ToString("N0") + " MB" });
|
|
|
|
|
|
Thread.Sleep(500);
|
|
if (upDateDebugLog.CancellationPending)
|
|
{
|
|
e.Cancel = true;
|
|
updateDebugInfo("Cancelling debug background worker");
|
|
break;
|
|
}
|
|
try { debug_rtextbox.Invoke(new updateDebug_rtextboxCallback(this.updateDebug_rtextbox), new object[] { debugInfoTemp }); }
|
|
catch (Exception eUpdateDebugInfo) { HandleUnhandledException(eUpdateDebugInfo); };
|
|
}
|
|
updateDebugInfo("Stopping debug background worker");
|
|
}
|
|
|
|
|
|
}
|
|
} |