pathl 2.1.7__tar.gz → 2.2.1b1__tar.gz

pathl-2.2.1b1/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: pathl
+Version: 2.2.1b1
+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.1b1/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.1b1/pathl/cli.py

@@ -0,0 +1,127 @@
+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 cmd_sha256(args):
+    import sys
+    try:
+        from pathl.hash import sha256
+    except ImportError:
+        print("Error: sha256 C extension is not compiled. Run 'make build-c' first.")
+        sys.exit(1)
+
+    result = sha256.hash(args.text)
+    print(result)
+
+
+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)
+
+    # SHA256
+    parser_sha256 = subparsers.add_parser("sha256", help="Haszuj tekst algorytmem SHA-256")
+    parser_sha256.add_argument("text", help="Tekst do zahaszowania")
+    parser_sha256.set_defaults(func=cmd_sha256)
+
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

pathl-2.2.1b1/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.1b1/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.1b1/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.1b1/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.1b1/pathl/hash/__init__.py

@@ -0,0 +1,11 @@
+"""
+pathl.hash — moduły haszujące napisane w C
+
+Użycie:
+    from pathl.hash import sha256
+    print(sha256.hash("hello"))
+    # => 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
+
+    print(sha256.hash_bytes(b"hello"))
+    # => 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
+"""

pathl-2.2.1b1/pathl/hash/sha256.c

@@ -0,0 +1,220 @@
+/*
+ * pathl.hash.sha256 — SHA-256 w czystym C (bez OpenSSL)
+ * Użycie z Pythona:
+ *   from pathl.hash import sha256
+ *   print(sha256.hash("hello"))
+ */
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <stdint.h>
+#include <string.h>
+
+/* ── SHA-256 stałe ───────────────────────────────────────────────────── */
+static const uint32_t K[64] = {
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+};
+
+/* ── makra ────────────────────────────────────────────────────────────── */
+#define ROTR(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
+#define CH(x, y, z) (((x) & (y)) ^ (~(x) & (z)))
+#define MAJ(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
+#define EP0(x) (ROTR(x,2)  ^ ROTR(x,13) ^ ROTR(x,22))
+#define EP1(x) (ROTR(x,6)  ^ ROTR(x,11) ^ ROTR(x,25))
+#define SIG0(x) (ROTR(x,7)  ^ ROTR(x,18) ^ ((x) >> 3))
+#define SIG1(x) (ROTR(x,17) ^ ROTR(x,19) ^ ((x) >> 10))
+
+typedef struct {
+    uint8_t  data[64];
+    uint32_t datalen;
+    uint64_t bitlen;
+    uint32_t state[8];
+} SHA256_CTX;
+
+static void sha256_transform(SHA256_CTX *ctx, const uint8_t *data)
+{
+    uint32_t a, b, c, d, e, f, g, h, i, j, t1, t2, m[64];
+
+    for (i = 0, j = 0; i < 16; i++, j += 4)
+        m[i] = ((uint32_t)data[j]     << 24) |
+               ((uint32_t)data[j + 1] << 16) |
+               ((uint32_t)data[j + 2] <<  8) |
+               ((uint32_t)data[j + 3]);
+    for (; i < 64; i++)
+        m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
+
+    a = ctx->state[0]; b = ctx->state[1];
+    c = ctx->state[2]; d = ctx->state[3];
+    e = ctx->state[4]; f = ctx->state[5];
+    g = ctx->state[6]; h = ctx->state[7];
+
+    for (i = 0; i < 64; i++) {
+        t1 = h + EP1(e) + CH(e, f, g) + K[i] + m[i];
+        t2 = EP0(a) + MAJ(a, b, c);
+        h = g; g = f; f = e; e = d + t1;
+        d = c; c = b; b = a; a = t1 + t2;
+    }
+
+    ctx->state[0] += a; ctx->state[1] += b;
+    ctx->state[2] += c; ctx->state[3] += d;
+    ctx->state[4] += e; ctx->state[5] += f;
+    ctx->state[6] += g; ctx->state[7] += h;
+}
+
+static void sha256_init(SHA256_CTX *ctx)
+{
+    ctx->datalen = 0;
+    ctx->bitlen  = 0;
+    ctx->state[0] = 0x6a09e667;
+    ctx->state[1] = 0xbb67ae85;
+    ctx->state[2] = 0x3c6ef372;
+    ctx->state[3] = 0xa54ff53a;
+    ctx->state[4] = 0x510e527f;
+    ctx->state[5] = 0x9b05688c;
+    ctx->state[6] = 0x1f83d9ab;
+    ctx->state[7] = 0x5be0cd19;
+}
+
+static void sha256_update(SHA256_CTX *ctx, const uint8_t *data, size_t len)
+{
+    for (size_t i = 0; i < len; i++) {
+        ctx->data[ctx->datalen++] = data[i];
+        if (ctx->datalen == 64) {
+            sha256_transform(ctx, ctx->data);
+            ctx->bitlen += 512;
+            ctx->datalen = 0;
+        }
+    }
+}
+
+static void sha256_final(SHA256_CTX *ctx, uint8_t *hash)
+{
+    uint32_t i = ctx->datalen;
+
+    if (ctx->datalen < 56) {
+        ctx->data[i++] = 0x80;
+        while (i < 56) ctx->data[i++] = 0x00;
+    } else {
+        ctx->data[i++] = 0x80;
+        while (i < 64) ctx->data[i++] = 0x00;
+        sha256_transform(ctx, ctx->data);
+        memset(ctx->data, 0, 56);
+    }
+
+    ctx->bitlen += (uint64_t)ctx->datalen * 8;
+    ctx->data[63] = (uint8_t)(ctx->bitlen);
+    ctx->data[62] = (uint8_t)(ctx->bitlen >> 8);
+    ctx->data[61] = (uint8_t)(ctx->bitlen >> 16);
+    ctx->data[60] = (uint8_t)(ctx->bitlen >> 24);
+    ctx->data[59] = (uint8_t)(ctx->bitlen >> 32);
+    ctx->data[58] = (uint8_t)(ctx->bitlen >> 40);
+    ctx->data[57] = (uint8_t)(ctx->bitlen >> 48);
+    ctx->data[56] = (uint8_t)(ctx->bitlen >> 56);
+    sha256_transform(ctx, ctx->data);
+
+    for (i = 0; i < 4; i++) {
+        hash[i]      = (ctx->state[0] >> (24 - i * 8)) & 0xff;
+        hash[i + 4]  = (ctx->state[1] >> (24 - i * 8)) & 0xff;
+        hash[i + 8]  = (ctx->state[2] >> (24 - i * 8)) & 0xff;
+        hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0xff;
+        hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0xff;
+        hash[i + 20] = (ctx->state[5] >> (24 - i * 8)) & 0xff;
+        hash[i + 24] = (ctx->state[6] >> (24 - i * 8)) & 0xff;
+        hash[i + 28] = (ctx->state[7] >> (24 - i * 8)) & 0xff;
+    }
+}
+
+/* ── Python API ───────────────────────────────────────────────────────── */
+
+/*
+ * sha256.hash(text: str) -> str
+ *   Zwraca hex-digest SHA-256 dla podanego tekstu (UTF-8).
+ */
+static PyObject *py_sha256_hash(PyObject *self, PyObject *args)
+{
+    const char *input;
+    Py_ssize_t  input_len;
+
+    if (!PyArg_ParseTuple(args, "s#", &input, &input_len))
+        return NULL;
+
+    SHA256_CTX ctx;
+    uint8_t    digest[32];
+    char       hexbuf[65];
+
+    Py_BEGIN_ALLOW_THREADS
+    sha256_init(&ctx);
+    sha256_update(&ctx, (const uint8_t *)input, (size_t)input_len);
+    sha256_final(&ctx, digest);
+    for (int i = 0; i < 32; i++)
+        snprintf(hexbuf + i * 2, 3, "%02x", digest[i]);
+    hexbuf[64] = '\0';
+    Py_END_ALLOW_THREADS
+
+    return PyUnicode_FromString(hexbuf);
+}
+
+/*
+ * sha256.hash_bytes(data: bytes) -> str
+ *   Zwraca hex-digest SHA-256 dla surowych bajtów.
+ */
+static PyObject *py_sha256_hash_bytes(PyObject *self, PyObject *args)
+{
+    const uint8_t *input;
+    Py_ssize_t     input_len;
+
+    if (!PyArg_ParseTuple(args, "y#", &input, &input_len))
+        return NULL;
+
+    SHA256_CTX ctx;
+    uint8_t    digest[32];
+    char       hexbuf[65];
+
+    Py_BEGIN_ALLOW_THREADS
+    sha256_init(&ctx);
+    sha256_update(&ctx, input, (size_t)input_len);
+    sha256_final(&ctx, digest);
+    for (int i = 0; i < 32; i++)
+        snprintf(hexbuf + i * 2, 3, "%02x", digest[i]);
+    hexbuf[64] = '\0';
+    Py_END_ALLOW_THREADS
+
+    return PyUnicode_FromString(hexbuf);
+}
+
+/* ── Tabela metod ─────────────────────────────────────────────────────── */
+static PyMethodDef Sha256Methods[] = {
+    {"hash",       py_sha256_hash,       METH_VARARGS,
+     "hash(text: str) -> str\n\nZwraca hex SHA-256 dla tekstu UTF-8."},
+    {"hash_bytes", py_sha256_hash_bytes, METH_VARARGS,
+     "hash_bytes(data: bytes) -> str\n\nZwraca hex SHA-256 dla surowych bajtów."},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef sha256module = {
+    PyModuleDef_HEAD_INIT,
+    "sha256",
+    "Moduł SHA-256 napisany w czystym C (bez OpenSSL).",
+    -1,
+    Sha256Methods
+};
+
+PyMODINIT_FUNC PyInit_sha256(void)
+{
+    return PyModule_Create(&sha256module);
+}

{pathl-2.1.7 → pathl-2.2.1b1}/pathl/hello/world.py

@@ -3,3 +3,5 @@ class World:
         self.msg = "Hello Its My Packeg"
     def main(self):
         print(self.msg)
+    def versin(self):
+        print("2.9.9")

pathl-2.2.1b1/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.1b1/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.1b1/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.1b1/pathl.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: pathl
+Version: 2.2.1b1
+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.1b1}/pathl.egg-info/SOURCES.txt

@@ -1,14 +1,25 @@
 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/hash/__init__.py
+pathl/hash/sha256.c
 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.1b1/pathl.egg-info/requires.txt

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

{pathl-2.1.7 → pathl-2.2.1b1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pathl"
-version = "2.1.7"
+version = "2.2.1b1"
 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.1b1/setup.py

@@ -0,0 +1,18 @@
+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"]
+        ),
+        Extension(
+            name="pathl.hash.sha256",
+            sources=["pathl/hash/sha256.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