pathl 2.2.0__tar.gz → 2.2.2__tar.gz

{pathl-2.2.0 → pathl-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathl
-Version: 2.2.0
+Version: 2.2.2
 Summary: General-purpose cybersecurity toolkit
 Author: Alicja
 License-Expression: MIT

{pathl-2.2.0 → pathl-2.2.2}/pathl/cli.py

@@ -51,6 +51,18 @@ def cmd_fastscan(args):
         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",
@@ -96,6 +108,11 @@ def main():
     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()
 

pathl-2.2.2/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.2/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.2.0 → pathl-2.2.2}/pathl/hello/world.py

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

{pathl-2.2.0 → pathl-2.2.2}/pathl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathl
-Version: 2.2.0
+Version: 2.2.2
 Summary: General-purpose cybersecurity toolkit
 Author: Alicja
 License-Expression: MIT

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

@@ -14,6 +14,8 @@ 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-2.2.0 → pathl-2.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pathl"
-version = "2.2.0"
+version = "2.2.2"
 description = "General-purpose cybersecurity toolkit"
 readme = "README.md"
 requires-python = ">=3.8"

{pathl-2.2.0 → pathl-2.2.2}/setup.py

@@ -9,6 +9,10 @@ setup(
         Extension(
             name="pathl.math.math",
             sources=["pathl/math/math.c"]
-        )
+        ),
+        Extension(
+            name="pathl.hash.sha256",
+            sources=["pathl/hash/sha256.c"]
+        ),
     ]
 )