Initial commit

Author: Super-brawl-team

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

Cryptography/RC4Encrypter.py

@@ -0,0 +1,61 @@
+import io
+import random
+
+class RC4Encrypter:
+    def __init__(self, key):
+        if not isinstance(key, bytes):
+            key = key.encode()
+        self._box = list(range(256))
+        j = 0
+        for i in range(256):
+            j = (j + self._box[i] + key[i % len(key)]) % 256
+            self._box[i], self._box[j] = self._box[j], self._box[i]
+        self._i = 0
+        self._j = 0
+
+    def update(self, msg):
+        if not isinstance(msg, bytes):
+            msg = msg.encode()
+        box = self._box
+        i = self._i
+        j = self._j
+        out = bytearray(len(msg))
+        for k in range(len(msg)):
+            i = (i + 1) % 256
+            j = (j + box[i]) % 256
+            box[i], box[j] = box[j], box[i]
+            out[k] = msg[k] ^ box[(box[i] + box[j]) % 256]
+        self._i = i
+        self._j = j
+        return out
+
+    def skip(self, n):
+        box = self._box
+        i = self._i
+        j = self._j
+        for _ in range(n):
+            i = (i + 1) % 256
+            j = (j + box[i]) % 256
+            box[i], box[j] = box[j], box[i]
+        self._i = i
+        self._j = j
+
+class RC4Transform(io.BufferedIOBase):
+    def __init__(self, key):
+        self._rc4 = RC4Encrypter(key)
+
+    def _transform(self, data):
+        if data:
+            return self._rc4.update(data)
+        return b''
+
+    def read(self, size=-1):
+        return self._transform(super().read(size))
+
+    def write(self, b):
+        return len(self._transform(b))
+
+    def skip(self, n):
+        self._rc4.skip(n)
+
+RC4Encrypter.Transform = RC4Transform

Cryptography/__pycache__/RC4Encrypter.cpython-313.pyc

@@ -0,0 +1,18 @@
+import json
+from Cryptography.RC4Encrypter import RC4Encrypter as RC4
+
+class CryptoRc4:
+    def __init__(self, key):
+        print(key)
+        self.key = key.encode('utf-8')
+        self.nonce = b'nonce'
+        self.RC4_Stream = RC4(self.key + self.nonce)
+        self.RC4_Stream.update(self.key + self.nonce)
+        self.RC4_Stream2 = RC4(self.key + self.nonce)
+        self.RC4_Stream2.update(self.key + self.nonce)
+
+    def decrypt(self, data):
+        return self.RC4_Stream.update(data)
+
+    def encrypt(self, data):
+        return self.RC4_Stream2.update(data)

Cryptography/__pycache__/rc4.cpython-313.pyc

@@ -0,0 +1,64 @@
+import random
+import string
+import struct
+from Cryptography.rc4 import CryptoRc4
+
+key = input("Set the key string here (press return to generate a random one) >> ").strip()
+if not key:
+    key = ''.join(random.choices(string.ascii_letters + string.digits, k=40))
+    print("The randomly generated key is :" + key + " , make sure to keep it")
+
+request = input("Encrypt or decrypt (e/d) >> ").strip().lower()
+file = input("File name >> ").strip()
+
+crypto = CryptoRc4(key)
+
+def encrypt():
+    with open(file, "rb") as original:
+        file_data = original.read()
+    
+    file_ext = file.split('.')[-1]
+    file_ext_bytes = file_ext.encode('utf-8') 
+    ext_length = len(file_ext_bytes)  # avoiding using bs bytestream :skull:
+
+    header = b"SUCCESS" + struct.pack("I", ext_length) + file_ext_bytes
+
+    encrypted_data = crypto.encrypt(header + file_data)
+
+    output_file = file.replace("." + file_ext, "") + ".cws"
+
+    with open(output_file, "wb") as encrypted_file:
+    
+        encrypted_file.write(encrypted_data)
+
+    print(f"Encrypted file saved as: {output_file}")
+
+def decrypt():
+    with open(file, "rb") as encrypted_file:
+        file_data = encrypted_file.read()
+    decrypted_data = crypto.decrypt(file_data)
+    if not decrypted_data.startswith(b"SUCCESS"):
+        print("[ERROR] Incorrect decryption password!")
+        return
+    
+    decrypted_data = decrypted_data[7:]
+    ext_length = struct.unpack("I", decrypted_data[:4])[0]
+    decrypted_data = decrypted_data[4:]
+
+    file_ext = decrypted_data[:ext_length].decode('utf-8')
+    decrypted_data = decrypted_data[ext_length:] # Do NOT critizise i broke my head to make that :sob:
+
+    
+
+    output_file = file.replace(".cws", f".{file_ext}")
+    with open(output_file, "wb") as decrypted_file:
+        decrypted_file.write(decrypted_data)
+
+    print(f"Decrypted file saved as: {output_file}")
+
+if request == "e":
+    encrypt()
+elif request == "d":
+    decrypt()
+else:
+    print("Invalid choice! Please enter 'e' to encrypt or 'd' to decrypt.")

Cryptography/rc4.py

@@ -0,0 +1 @@
+��G���`�3���O

Screenshot_2025-02-08-02-29-18-756.jpeg

@@ -0,0 +1 @@
+salut