pathl 2.1.7__tar.gz → 2.2.0__tar.gz

pathl-2.2.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: pathl
+Version: 2.2.0
+Summary: General-purpose cybersecurity toolkit
+Author: Alicja
+License-Expression: MIT
+Project-URL: Homepage, https://pip.pathl.pl
+Project-URL: Repository, https://github.com/AlicjaPathl/pathl
+Project-URL: Documentation, https://pip.pathl.pl/docs
+Project-URL: Issues, https://github.com/AlicjaPathl/pathl/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: rsa
+Requires-Dist: pycryptodome
+
+# 📦 pathl 2.1.7
+
+**pathl** to lekki i wydajny toolkit CLI oraz biblioteka programistyczna do zadań z zakresu cyberbezpieczeństwa i kryptografii, napisana w języku Python i C.
+
+---
+
+## 🚀 Szybki start
+
+### Instalacja i kompilacja
+Upewnij się, że masz zainstalowanego Pythona w wersji 3.8 lub nowszej, kompilator GCC oraz nagłówki deweloperskie Pythona (np. `python3-devel` lub `python3-dev`).
+
+1. Zainstaluj bibliotekę wraz z zależnościami:
+```bash
+pip install pathl
+```
+
+2. Skompiluj natywne rozszerzenie C (`fastscan`):
+```bash
+make build-c
+```
+
+### Użycie CLI
+Narzędzie udostępnia prosty interfejs wiersza poleceń:
+
+```bash
+# Szybkie skanowanie portów w C z nieblokującymi gniazdami (np. porty 1-1024 z limitem 1000 połączeń współbieżnych)
+pathl fastscan 192.168.0.1 --start 1 --end 1024 --concurrency 1000 --timeout 0.5
+
+# Skanowanie portów TCP w wybranym przedziale w Pythonie (starsza metoda wielowątkowa)
+pathl scan 192.168.0.1 --start 1 --end 1024 --threads 100
+
+# Zapytanie DNS lookup (zwraca adresy IP domeny)
+pathl dns google.com
+
+# Wyświetlenie powitania
+pathl hello
+```
+
+### Użycie jako biblioteka (Python API)
+```python
+# Test instalacji
+from pathl.hello import World
+World().main()  # Wypisze: "Hello Its My Packeg"
+
+# Zarządzanie kluczami i szyfrowanie z podziałem na moduły
+from pathl.crypto import aes, rsa, utils
+
+# 1. Generowanie i ładowanie kluczy przy użyciu klasy FileOI
+file_io = utils.FileOI(key_file="aes.key", pv_file="rsa.priv", pub_file="rsa.pub")
+rsa_keys = file_io.load_RSA(f=1)  # Wymusza generowanie, jeśli brak kluczy
+aes_key = file_io.load_aes(f=1)
+
+# 2. Szyfrowanie asymetryczne (RSA)
+rsa_cipher = rsa.CryptoIORsa(rsa_keys)
+encrypted_rsa = rsa_cipher.crypt("Tajna wiadomosc")
+decrypted_rsa = rsa_cipher.decrypt(encrypted_rsa)
+
+# 3. Szyfrowanie symetryczne (AES-ECB)
+aes_cipher = aes.CryptoIOAes(aes_key)
+encrypted_aes = aes_cipher.crypt("Tajna wiadomosc")
+decrypted_aes = aes_cipher.decrypt(encrypted_aes)
+```
+
+> [!NOTE]
+> Klasy można również importować bezpośrednio z pakietu głównego:
+> `from pathl.crypto import FileOI, CryptoIORsa, CryptoIOAes`
+
+---
+
+## 📚 Pełna dokumentacja
+
+Szczegółowy opis architektury systemu, modułów API, zagadnień bezpieczeństwa oraz **analizy złożoności czasowej i pamięciowej algorytmów** znajduje się w pliku:
+👉 **[Docs.md](file:///home/neon/pathl/Docs.md)**

pathl-2.2.0/README.md

@@ -0,0 +1,73 @@
+# 📦 pathl 2.1.7
+
+**pathl** to lekki i wydajny toolkit CLI oraz biblioteka programistyczna do zadań z zakresu cyberbezpieczeństwa i kryptografii, napisana w języku Python i C.
+
+---
+
+## 🚀 Szybki start
+
+### Instalacja i kompilacja
+Upewnij się, że masz zainstalowanego Pythona w wersji 3.8 lub nowszej, kompilator GCC oraz nagłówki deweloperskie Pythona (np. `python3-devel` lub `python3-dev`).
+
+1. Zainstaluj bibliotekę wraz z zależnościami:
+```bash
+pip install pathl
+```
+
+2. Skompiluj natywne rozszerzenie C (`fastscan`):
+```bash
+make build-c
+```
+
+### Użycie CLI
+Narzędzie udostępnia prosty interfejs wiersza poleceń:
+
+```bash
+# Szybkie skanowanie portów w C z nieblokującymi gniazdami (np. porty 1-1024 z limitem 1000 połączeń współbieżnych)
+pathl fastscan 192.168.0.1 --start 1 --end 1024 --concurrency 1000 --timeout 0.5
+
+# Skanowanie portów TCP w wybranym przedziale w Pythonie (starsza metoda wielowątkowa)
+pathl scan 192.168.0.1 --start 1 --end 1024 --threads 100
+
+# Zapytanie DNS lookup (zwraca adresy IP domeny)
+pathl dns google.com
+
+# Wyświetlenie powitania
+pathl hello
+```
+
+### Użycie jako biblioteka (Python API)
+```python
+# Test instalacji
+from pathl.hello import World
+World().main()  # Wypisze: "Hello Its My Packeg"
+
+# Zarządzanie kluczami i szyfrowanie z podziałem na moduły
+from pathl.crypto import aes, rsa, utils
+
+# 1. Generowanie i ładowanie kluczy przy użyciu klasy FileOI
+file_io = utils.FileOI(key_file="aes.key", pv_file="rsa.priv", pub_file="rsa.pub")
+rsa_keys = file_io.load_RSA(f=1)  # Wymusza generowanie, jeśli brak kluczy
+aes_key = file_io.load_aes(f=1)
+
+# 2. Szyfrowanie asymetryczne (RSA)
+rsa_cipher = rsa.CryptoIORsa(rsa_keys)
+encrypted_rsa = rsa_cipher.crypt("Tajna wiadomosc")
+decrypted_rsa = rsa_cipher.decrypt(encrypted_rsa)
+
+# 3. Szyfrowanie symetryczne (AES-ECB)
+aes_cipher = aes.CryptoIOAes(aes_key)
+encrypted_aes = aes_cipher.crypt("Tajna wiadomosc")
+decrypted_aes = aes_cipher.decrypt(encrypted_aes)
+```
+
+> [!NOTE]
+> Klasy można również importować bezpośrednio z pakietu głównego:
+> `from pathl.crypto import FileOI, CryptoIORsa, CryptoIOAes`
+
+---
+
+## 📚 Pełna dokumentacja
+
+Szczegółowy opis architektury systemu, modułów API, zagadnień bezpieczeństwa oraz **analizy złożoności czasowej i pamięciowej algorytmów** znajduje się w pliku:
+👉 **[Docs.md](file:///home/neon/pathl/Docs.md)**

pathl-2.2.0/pathl/cli.py

@@ -0,0 +1,110 @@
+import argparse
+from pathl.scaner.scaner import run_scan
+from pathl.dns.dns import run_dns
+
+# reszta kodu bez zmian
+
+def cmd_hello(args):
+    print("Hello from pathl 🔐")
+
+
+def cmd_scan(args):
+    run_scan(
+        target=args.target,
+        start=args.start,
+        end=args.end,
+        threads=args.threads,
+        timeout=args.timeout,
+        output=args.output
+    )
+
+
+def cmd_fastscan(args):
+    import sys
+    try:
+        from pathl.scaner import fastscan
+    except ImportError:
+        print("Error: fastscan C extension is not compiled. Please run 'make build-c' first.")
+        sys.exit(1)
+
+    import socket
+    print(f"[*] Target : {args.target}")
+    print(f"[*] Ports  : {args.start}-{args.end}")
+    print(f"[*] Limit  : {args.concurrency}")
+    print(f"[*] Timeout: {args.timeout}s\n")
+
+    timeout_ms = int(args.timeout * 1000)
+    open_ports = fastscan.scan(args.target, args.start, args.end, args.concurrency, timeout_ms)
+
+    print("\n[*] Scan finished")
+    for port in open_ports:
+        try:
+            service = socket.getservbyport(port)
+        except Exception:
+            service = "unknown"
+        print(f"[OPEN] {port}/tcp ({service})")
+
+    if args.output:
+        with open(args.output, "w") as f:
+            for port in open_ports:
+                f.write(f"{port}\n")
+        print(f"[*] Saved to {args.output}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="pathl",
+        description="General-purpose cybersecurity toolkit"
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+
+    # HELLO
+    parser_hello = subparsers.add_parser("hello")
+    parser_hello.set_defaults(func=cmd_hello)
+
+    #DNS
+    parser_dns = subparsers.add_parser("dns")
+    parser_dns.add_argument("domain")
+    parser_dns.add_argument("-p", action="store_true")
+    parser_dns.set_defaults(func=run_dns)
+
+
+    # SCAN
+    parser_scan = subparsers.add_parser("scan")
+
+    parser_scan.add_argument("target")
+
+    parser_scan.add_argument("--start", type=int, default=1)
+    parser_scan.add_argument("--end", type=int, default=1024)
+
+    parser_scan.add_argument("--threads", type=int, default=100)
+    parser_scan.add_argument("--timeout", type=float, default=0.3)
+
+    parser_scan.add_argument("--output")
+
+    parser_scan.set_defaults(func=cmd_scan)
+
+    # FASTSCAN
+    parser_fastscan = subparsers.add_parser("fastscan")
+    parser_fastscan.add_argument("target")
+    parser_fastscan.add_argument("--start", type=int, default=1)
+    parser_fastscan.add_argument("--end", type=int, default=1024)
+    parser_fastscan.add_argument("--concurrency", type=int, default=1000)
+    parser_fastscan.add_argument("--timeout", type=float, default=0.5)
+    parser_fastscan.add_argument("--output")
+    parser_fastscan.set_defaults(func=cmd_fastscan)
+
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

pathl-2.2.0/pathl/crypto/__init__.py

@@ -0,0 +1,9 @@
+from pathl.crypto import aes
+from pathl.crypto import rsa
+from pathl.crypto import utils
+
+from pathl.crypto.utils import FileOI
+from pathl.crypto.rsa import CryptoIORsa
+from pathl.crypto.aes import CryptoIOAes
+
+__all__ = ["aes", "rsa", "utils", "FileOI", "CryptoIORsa", "CryptoIOAes"]

pathl-2.2.0/pathl/crypto/aes.py

@@ -0,0 +1,18 @@
+import hashlib
+import secrets
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+
+class CryptoIOAes:
+    def __init__(self, key):
+        self.key = key
+        self.cipher = AES.new(self.key, AES.MODE_ECB)
+
+    def crypt(self, msg):
+        return self.cipher.encrypt(pad(msg.encode(), 16))
+
+    def decrypt(self, text):
+        return unpad(self.cipher.decrypt(text), 16)
+
+    def gen_key(self, lengt=256):
+        return hashlib.sha256(secrets.token_bytes(2048)).digest()

pathl-2.2.0/pathl/crypto/rsa.py

@@ -0,0 +1,16 @@
+import rsa
+import hashlib
+import secrets
+
+class CryptoIORsa:
+    def __init__(self, load):
+        self.pv, self.pub = load
+
+    def crypt(self, msg):
+        return rsa.encrypt(msg.encode(), self.pub)
+
+    def decrypt(self, cipher):
+        return rsa.decrypt(cipher, self.pv)
+
+    def gen_challenge(self):
+        return hashlib.sha256(secrets.token_bytes(32)).hexdigest()

pathl-2.2.0/pathl/crypto/utils.py

@@ -0,0 +1,49 @@
+import os
+import secrets
+import hashlib
+import rsa
+
+class FileOI:
+    def __init__(self, key_file="key.key", pv_file="rsa2048", pub_file="rsa2048.pub"):
+        self.pv_file = pv_file
+        self.pub_file = pub_file
+        self.key_file = key_file
+
+    def check_file(self):
+        if not (os.path.exists(self.pv_file) and os.path.exists(self.pub_file)):
+            self.new_gen_rsa()
+
+    def new_gen_rsa(self):
+        pub, pv = rsa.newkeys(2048)
+
+        with open(self.pv_file, "wb") as w:
+            w.write(pv.save_pkcs1())
+        with open(self.pub_file, "wb") as w:
+            w.write(pub.save_pkcs1())
+        print("KEY")
+        del pub, pv
+
+    def load_RSA(self, f=0):
+        if f:
+            self.check_file()
+        with open(self.pv_file, "rb") as r:
+            pv = rsa.PrivateKey.load_pkcs1(r.read())
+        with open(self.pub_file, "rb") as r:
+            pub = rsa.PublicKey.load_pkcs1(r.read())
+        return pv, pub
+
+    def load_aes(self, f=0):
+        if f or not os.path.exists(self.key_file):
+            raw = secrets.token_bytes(32)
+            key = hashlib.sha256(raw).digest()
+
+            with open(self.key_file, "wb") as file:
+                file.write(key)
+
+        with open(self.key_file, "rb") as file:
+            key = file.read()
+
+        if len(key) != 32:
+            raise ValueError(f"Invalid key length: {len(key)}")
+
+        return key

pathl-2.2.0/pathl/math/__init__.py

@@ -0,0 +1,13 @@
+import sys
+
+try:
+    from pathl.math.math import add
+except ImportError:
+    # Uprzejme powiadomienie użytkownika w razie braku kompilacji
+    def add(a, b):
+        raise ImportError(
+            "Moduł pathl.math.math (rozszerzenie C) nie został skompilowany. "
+            "Uruchom 'make build-c' w katalogu głównym projektu."
+        )
+
+__all__ = ["add"]

pathl-2.2.0/pathl/math/math.c

@@ -0,0 +1,35 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+/* Funkcja dodająca dwie liczby zmiennoprzecinkowe */
+static PyObject* py_add(PyObject* self, PyObject* args) {
+    double a, b;
+    
+    /* Parsowanie argumentów z Pythona ("dd" oznacza dwa typy double) */
+    if (!PyArg_ParseTuple(args, "dd", &a, &b)) {
+        return NULL;
+    }
+    
+    /* Zwrócenie wyniku jako obiekt PyFloat */
+    return PyFloat_FromDouble(a + b);
+}
+
+/* Tablica metod dostępnych w module */
+static PyMethodDef MathMethods[] = {
+    {"add", py_add, METH_VARARGS, "Dodaje dwie liczby zmiennoprzecinkowe."},
+    {NULL, NULL, 0, NULL} /* Znacznik końca tablicy */
+};
+
+/* Struktura definiująca moduł */
+static struct PyModuleDef mathmodule = {
+    PyModuleDef_HEAD_INIT,
+    "math", /* Nazwa modułu */
+    "Prosty moduł matematyczny napisany w C.", /* Dokumentacja modułu */
+    -1, /* Moduł nie przechowuje stanu w zmiennych globalnych (-1) */
+    MathMethods
+};
+
+/* Funkcja inicjalizująca moduł - wywoływana automatycznie przy imporcie */
+PyMODINIT_FUNC PyInit_math(void) {
+    return PyModule_Create(&mathmodule);
+}

pathl-2.2.0/pathl/scaner/fastscan.c

@@ -0,0 +1,200 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <netdb.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+typedef struct {
+    int fd;
+    int port;
+    struct timeval start_time;
+    int active;
+} ActiveSocket;
+
+static PyObject* fastscan_scan(PyObject* self, PyObject* args) {
+    char *target;
+    int start_port, end_port, concurrency, timeout_ms;
+
+    if (!PyArg_ParseTuple(args, "siiii", &target, &start_port, &end_port, &concurrency, &timeout_ms)) {
+        return NULL;
+    }
+
+    if (start_port < 1 || end_port > 65535 || start_port > end_port) {
+        PyErr_SetString(PyExc_ValueError, "Invalid port range");
+        return NULL;
+    }
+
+    if (concurrency < 1) {
+        PyErr_SetString(PyExc_ValueError, "Concurrency must be >= 1");
+        return NULL;
+    }
+
+    struct hostent *he = gethostbyname(target);
+    if (!he) {
+        PyErr_SetString(PyExc_ValueError, "Could not resolve hostname");
+        return NULL;
+    }
+    struct in_addr target_ip = *(struct in_addr *)he->h_addr_list[0];
+
+    int total_ports = end_port - start_port + 1;
+    int *open_ports = malloc(sizeof(int) * total_ports);
+    if (!open_ports) {
+        return PyErr_NoMemory();
+    }
+    int open_ports_count = 0;
+
+    ActiveSocket *sockets = calloc(concurrency, sizeof(ActiveSocket));
+    if (!sockets) {
+        free(open_ports);
+        return PyErr_NoMemory();
+    }
+
+    // Release GIL for the duration of the scan
+    Py_BEGIN_ALLOW_THREADS
+
+    int next_port = start_port;
+    int active_count = 0;
+
+    while (next_port <= end_port || active_count > 0) {
+        // Fill active sockets up to concurrency
+        while (active_count < concurrency && next_port <= end_port) {
+            int port = next_port++;
+            int fd = socket(AF_INET, SOCK_STREAM, 0);
+            if (fd < 0) {
+                // Out of file descriptors? Wait for active ones to close
+                next_port--;
+                break;
+            }
+
+            // Non-blocking
+            int flags = fcntl(fd, F_GETFL, 0);
+            fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+
+            struct sockaddr_in addr;
+            memset(&addr, 0, sizeof(addr));
+            addr.sin_family = AF_INET;
+            addr.sin_port = htons(port);
+            addr.sin_addr = target_ip;
+
+            int res = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
+            if (res == 0) {
+                open_ports[open_ports_count++] = port;
+                close(fd);
+            } else if (res < 0 && errno == EINPROGRESS) {
+                // Find empty slot
+                for (int i = 0; i < concurrency; i++) {
+                    if (!sockets[i].active) {
+                        sockets[i].fd = fd;
+                        sockets[i].port = port;
+                        gettimeofday(&sockets[i].start_time, NULL);
+                        sockets[i].active = 1;
+                        active_count++;
+                        break;
+                    }
+                }
+            } else {
+                close(fd);
+            }
+        }
+
+        if (active_count == 0) {
+            continue;
+        }
+
+        fd_set write_fds;
+        FD_ZERO(&write_fds);
+        int max_fd = -1;
+        for (int i = 0; i < concurrency; i++) {
+            if (sockets[i].active) {
+                FD_SET(sockets[i].fd, &write_fds);
+                if (sockets[i].fd > max_fd) {
+                    max_fd = sockets[i].fd;
+                }
+            }
+        }
+
+        struct timeval sel_tv;
+        sel_tv.tv_sec = 0;
+        sel_tv.tv_usec = 10000; // 10ms select timeout
+
+        int sel_res = select(max_fd + 1, NULL, &write_fds, NULL, &sel_tv);
+
+        struct timeval now;
+        gettimeofday(&now, NULL);
+
+        for (int i = 0; i < concurrency; i++) {
+            if (!sockets[i].active) continue;
+
+            int fd = sockets[i].fd;
+            int port = sockets[i].port;
+            int closed = 0;
+
+            if (sel_res > 0 && FD_ISSET(fd, &write_fds)) {
+                int err = 0;
+                socklen_t len = sizeof(err);
+                if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len) == 0) {
+                    if (err == 0) {
+                        open_ports[open_ports_count++] = port;
+                    }
+                }
+                close(fd);
+                sockets[i].active = 0;
+                active_count--;
+                closed = 1;
+            }
+
+            if (!closed) {
+                long elapsed_ms = (now.tv_sec - sockets[i].start_time.tv_sec) * 1000 +
+                                 (now.tv_usec - sockets[i].start_time.tv_usec) / 1000;
+                if (elapsed_ms >= timeout_ms) {
+                    close(fd);
+                    sockets[i].active = 0;
+                    active_count--;
+                }
+            }
+        }
+    }
+
+    free(sockets);
+
+    // Re-acquire GIL
+    Py_END_ALLOW_THREADS
+
+    PyObject *open_ports_list = PyList_New(open_ports_count);
+    if (!open_ports_list) {
+        free(open_ports);
+        return NULL;
+    }
+
+    for (int i = 0; i < open_ports_count; i++) {
+        PyList_SetItem(open_ports_list, i, PyLong_FromLong(open_ports[i]));
+    }
+
+    free(open_ports);
+    return open_ports_list;
+}
+
+static PyMethodDef FastscanMethods[] = {
+    {"scan", fastscan_scan, METH_VARARGS, "Scan ports using non-blocking C sockets."},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef fastscanmodule = {
+    PyModuleDef_HEAD_INIT,
+    "fastscan",
+    "Fast port scanner in C",
+    -1,
+    FastscanMethods
+};
+
+PyMODINIT_FUNC PyInit_fastscan(void) {
+    return PyModule_Create(&fastscanmodule);
+}

pathl-2.2.0/pathl.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: pathl
+Version: 2.2.0
+Summary: General-purpose cybersecurity toolkit
+Author: Alicja
+License-Expression: MIT
+Project-URL: Homepage, https://pip.pathl.pl
+Project-URL: Repository, https://github.com/AlicjaPathl/pathl
+Project-URL: Documentation, https://pip.pathl.pl/docs
+Project-URL: Issues, https://github.com/AlicjaPathl/pathl/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: rsa
+Requires-Dist: pycryptodome
+
+# 📦 pathl 2.1.7
+
+**pathl** to lekki i wydajny toolkit CLI oraz biblioteka programistyczna do zadań z zakresu cyberbezpieczeństwa i kryptografii, napisana w języku Python i C.
+
+---
+
+## 🚀 Szybki start
+
+### Instalacja i kompilacja
+Upewnij się, że masz zainstalowanego Pythona w wersji 3.8 lub nowszej, kompilator GCC oraz nagłówki deweloperskie Pythona (np. `python3-devel` lub `python3-dev`).
+
+1. Zainstaluj bibliotekę wraz z zależnościami:
+```bash
+pip install pathl
+```
+
+2. Skompiluj natywne rozszerzenie C (`fastscan`):
+```bash
+make build-c
+```
+
+### Użycie CLI
+Narzędzie udostępnia prosty interfejs wiersza poleceń:
+
+```bash
+# Szybkie skanowanie portów w C z nieblokującymi gniazdami (np. porty 1-1024 z limitem 1000 połączeń współbieżnych)
+pathl fastscan 192.168.0.1 --start 1 --end 1024 --concurrency 1000 --timeout 0.5
+
+# Skanowanie portów TCP w wybranym przedziale w Pythonie (starsza metoda wielowątkowa)
+pathl scan 192.168.0.1 --start 1 --end 1024 --threads 100
+
+# Zapytanie DNS lookup (zwraca adresy IP domeny)
+pathl dns google.com
+
+# Wyświetlenie powitania
+pathl hello
+```
+
+### Użycie jako biblioteka (Python API)
+```python
+# Test instalacji
+from pathl.hello import World
+World().main()  # Wypisze: "Hello Its My Packeg"
+
+# Zarządzanie kluczami i szyfrowanie z podziałem na moduły
+from pathl.crypto import aes, rsa, utils
+
+# 1. Generowanie i ładowanie kluczy przy użyciu klasy FileOI
+file_io = utils.FileOI(key_file="aes.key", pv_file="rsa.priv", pub_file="rsa.pub")
+rsa_keys = file_io.load_RSA(f=1)  # Wymusza generowanie, jeśli brak kluczy
+aes_key = file_io.load_aes(f=1)
+
+# 2. Szyfrowanie asymetryczne (RSA)
+rsa_cipher = rsa.CryptoIORsa(rsa_keys)
+encrypted_rsa = rsa_cipher.crypt("Tajna wiadomosc")
+decrypted_rsa = rsa_cipher.decrypt(encrypted_rsa)
+
+# 3. Szyfrowanie symetryczne (AES-ECB)
+aes_cipher = aes.CryptoIOAes(aes_key)
+encrypted_aes = aes_cipher.crypt("Tajna wiadomosc")
+decrypted_aes = aes_cipher.decrypt(encrypted_aes)
+```
+
+> [!NOTE]
+> Klasy można również importować bezpośrednio z pakietu głównego:
+> `from pathl.crypto import FileOI, CryptoIORsa, CryptoIOAes`
+
+---
+
+## 📚 Pełna dokumentacja
+
+Szczegółowy opis architektury systemu, modułów API, zagadnień bezpieczeństwa oraz **analizy złożoności czasowej i pamięciowej algorytmów** znajduje się w pliku:
+👉 **[Docs.md](file:///home/neon/pathl/Docs.md)**

{pathl-2.1.7 → pathl-2.2.0}/pathl.egg-info/SOURCES.txt

@@ -1,14 +1,23 @@
 README.md
 pyproject.toml
+setup.py
 pathl/__init__.py
 pathl/cli.py
 pathl.egg-info/PKG-INFO
 pathl.egg-info/SOURCES.txt
 pathl.egg-info/dependency_links.txt
 pathl.egg-info/entry_points.txt
+pathl.egg-info/requires.txt
 pathl.egg-info/top_level.txt
+pathl/crypto/__init__.py
+pathl/crypto/aes.py
+pathl/crypto/rsa.py
+pathl/crypto/utils.py
 pathl/dns/dns.py
 pathl/hello/__init__.py
 pathl/hello/welcome.py
 pathl/hello/world.py
+pathl/math/__init__.py
+pathl/math/math.c
+pathl/scaner/fastscan.c
 pathl/scaner/scaner.py

pathl-2.2.0/pathl.egg-info/requires.txt

@@ -0,0 +1,2 @@
+rsa
+pycryptodome

{pathl-2.1.7 → pathl-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pathl"
-version = "2.1.7"
+version = "2.2.0"
 description = "General-purpose cybersecurity toolkit"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -16,7 +16,7 @@ authors = [
 # POPRAWIONE: licencja jako string, nie tabela
 license = "MIT"
 
-dependencies = []
+dependencies = ["rsa","pycryptodome"]
 
 [project.urls]
 Homepage = "https://pip.pathl.pl"

pathl-2.2.0/setup.py

@@ -0,0 +1,14 @@
+from setuptools import setup, Extension
+
+setup(
+    ext_modules=[
+        Extension(
+            name="pathl.scaner.fastscan",
+            sources=["pathl/scaner/fastscan.c"]
+        ),
+        Extension(
+            name="pathl.math.math",
+            sources=["pathl/math/math.c"]
+        )
+    ]
+)

pathl-2.1.7/PKG-INFO

@@ -1,14 +0,0 @@
-Metadata-Version: 2.4
-Name: pathl
-Version: 2.1.7
-Summary: General-purpose cybersecurity toolkit
-Author: Alicja
-License-Expression: MIT
-Project-URL: Homepage, https://pip.pathl.pl
-Project-URL: Repository, https://github.com/AlicjaPathl/pathl
-Project-URL: Documentation, https://pip.pathl.pl/docs
-Project-URL: Issues, https://github.com/AlicjaPathl/pathl/issues
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
-# pathl

pathl-2.1.7/README.md

@@ -1 +0,0 @@
-# pathl

pathl-2.1.7/pathl/cli.py

@@ -1,68 +0,0 @@
-import argparse
-from pathl.scaner.scaner import run_scan
-from pathl.dns.dns import run_dns
-
-# reszta kodu bez zmian
-
-def cmd_hello(args):
-    print("Hello from pathl 🔐")
-
-
-def cmd_scan(args):
-    run_scan(
-        target=args.target,
-        start=args.start,
-        end=args.end,
-        threads=args.threads,
-        timeout=args.timeout,
-        output=args.output
-    )
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        prog="pathl",
-        description="General-purpose cybersecurity toolkit"
-    )
-
-    subparsers = parser.add_subparsers(dest="command")
-
-
-    # HELLO
-    parser_hello = subparsers.add_parser("hello")
-    parser_hello.set_defaults(func=cmd_hello)
-
-    #DNS
-    parser_dns = subparsers.add_parser("dns")
-    parser_dns.add_argument("domain")
-    parser_dns.add_argument("-p", action="store_true")
-    parser_dns.set_defaults(func=run_dns)
-
-
-    # SCAN
-    parser_scan = subparsers.add_parser("scan")
-
-    parser_scan.add_argument("target")
-
-    parser_scan.add_argument("--start", type=int, default=1)
-    parser_scan.add_argument("--end", type=int, default=1024)
-
-    parser_scan.add_argument("--threads", type=int, default=100)
-    parser_scan.add_argument("--timeout", type=float, default=0.3)
-
-    parser_scan.add_argument("--output")
-
-    parser_scan.set_defaults(func=cmd_scan)
-
-
-    args = parser.parse_args()
-
-    if not args.command:
-        parser.print_help()
-        return
-
-    args.func(args)
-
-
-if __name__ == "__main__":
-    main()

pathl-2.1.7/pathl.egg-info/PKG-INFO

@@ -1,14 +0,0 @@
-Metadata-Version: 2.4
-Name: pathl
-Version: 2.1.7
-Summary: General-purpose cybersecurity toolkit
-Author: Alicja
-License-Expression: MIT
-Project-URL: Homepage, https://pip.pathl.pl
-Project-URL: Repository, https://github.com/AlicjaPathl/pathl
-Project-URL: Documentation, https://pip.pathl.pl/docs
-Project-URL: Issues, https://github.com/AlicjaPathl/pathl/issues
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
-# pathl