Sokan szeretnék tudni, hogyan dolgozik egy kém. Ezelőtt 40 évvel amikor még kémkedtem a MOSAD-nak ezt a módszert használtam a titkosításra. A python program rejtélyessége az alábbi technikákból adódik:Lambda függvény: Egy névtelen függvény, amely aláhúzás _ nevet kapott a zavaró hatás érdekében. Listakifejezés (List comprehension): Egyetlen sorba sűrített ciklus és feltétel. Karakterkódolás: Az ord() és chr() függvényekkel matematikai műveleteket végez a karaktereken ahelyett, hogy közvetlenül kiírná a szót.Rejtett eltolás: Az "IFMMP" karaktereinek ASCII kódjából kivonja a paraméter (ebben az esetben a 3 mint páratlan szám) és a 2 maradékát, így kapja meg a helyes karaktereket. Ezt obszkuritásnak nevezzük.
Program;
-----------------
_ = lambda __: print("".join([chr(ord(char) - (__ % 2)) for char in "IFMMP"]))
_(1)
---------------------
Dekódolva; t+t+12+00
Olvasva; Találkozunk a Templomnál 12 kor!
----------------------
A kriptográfiában az obszkuritás (homályosítás/elrejtés) önmagában nem számít biztonságos titkosításnak, de hasznos eszköz lehet adatok álcázására vagy a visszafejtés nehezítésére. Az alábbiakban egy olyan Python-szkriptet mutatok be, amely a karakterek Unicode értékeinek manipulálásával és Base64 kódolással végzi el a szövegek homályosítását.Ez a módszer arra kiváló, hogy olvashatatlanná tegye az adatokat. Python Kód: Egyszerű homályosító (obszkuráló) program
A program a megadott szöveg minden egyes karakterét eltolja egy meghatározott értékkel (egy egyszerű eltolásos rejtjelezés-szerűséggel), majd a végeredményt Base64 formátumba kódolja, hogy ne tartalmazzon speciális karaktereket.
----------------------
import base64
def obscure_text(text, shift=3):
"""Szöveg homályosítása karakterek eltolásával és Base64 kódolással."""
# 1. lépés: Karakterek eltolása a megadott értékkel
shifted_chars = [chr(ord(char) + shift) for char in text]
shifted_string = "".join(shifted_chars)
# 2. lépés: Base64 kódolás a biztonságos karakterekért
encoded_bytes = shifted_string.encode('utf-8')
obfuscated_bytes = base64.b64encode(encoded_bytes)
return obfuscated_bytes.decode('utf-8')
def reveal_text(obfuscated_text, shift=3):
"""Homályosított szöveg visszafejtése."""
# 1. lépés: Base64 dekódolás
decoded_bytes = base64.b64decode(obfuscated_text.encode('utf-8'))
decoded_string = decoded_bytes.decode('utf-8')
# 2. lépés: Eltolás visszaállítása
original_chars = [chr(ord(char) - shift) for char in decoded_string]
return "".join(original_chars)
# --- Példa a használatra ---
if __name__ == "__main__":
original = "Ez egy titkos uzenet"
shift_value = 5 # Az eltolás mértéke
# Homályosítás
obs = obscure_text(original, shift_value)
print(f"Homályosított szöveg: {obs}")
# Visszafejtés
rev = reveal_text(obs, shift_value)
print(f"Visszafejtett szöveg: {rev}")
------------------
Homályosított szöveg: Sn8lamx+JXlueXB0eCV6f2pzank=
Visszafejtett szöveg: Ez egy titkos uzenet
-------------------
import base64
def obscure_encrypt(clear_text: str, key: str) -> str:
"""
Titkosítja a szöveget XOR művelettel, majd Base64-be kódolja.
"""
encrypted_chars = []
for i in range(len(clear_text)):
# XOR művelet a szöveg karaktere és a kulcs karaktere között
key_char = ord(key[i % len(key)])
text_char = ord(clear_text[i])
encrypted_chars.append(chr(text_char ^ key_char))
# Bájtokká alakítás és Base64 kódolás
encrypted_bytes = "".join(encrypted_chars).encode("latin-1")
return base64.b64encode(encrypted_bytes).decode("utf-8")
def obscure_decrypt(obscure_text: str, key: str) -> str:
"""
Visszafejti az obszkurált szöveget a megadott kulcs segítségével.
"""
try:
# Base64 dekódolás és visszaalakítás
decoded_bytes = base64.b64decode(obscure_text.encode("utf-8"))
decoded_text = decoded_bytes.decode("latin-1")
decrypted_chars = []
for i in range(len(decoded_text)):
key_char = ord(key[i % len(key)])
text_char = ord(decoded_text[i])
decrypted_chars.append(chr(text_char ^ key_char))
return "".join(decrypted_chars)
except Exception:
return "Hiba: Érvénytelen kulcs vagy sérült adatok!"
# --- Példa a használatra ---
if __name__ == "__main__":
titkositand_szoveg = "Ez egy bizalmas szoveg"
jelszo = "titkos_kulcs"
lezsirozott = obscure_encrypt(titkositand_szoveg, jelszo)
visszafejtve = obscure_decrypt(lezsirozott, jelszo)
print(f"Eredeti: {titkositand_szoveg}")
print(f"Obszkurált / Titkosított: {lezsirozott}")
print(f"Visszafejtve: {visszafejtve}")
------------------------
Kódolás
-------------------------
import base64
def kodol(szoveg: str) -> str:
# Egyszerű példa: Base64 kódolás
return base64.b64encode(szoveg.encode("utf-8")).decode("utf-8")
eredeti_uzenet = "t+t+12+00"
kodolt = kodol(eredeti_uzenet)
print(kodolt)
---------------------
dCt0KzEyKzAw
-------------------
import base64
def atkodolo_program(kodolt_szoveg):
# 1. Dekódolás: Feltételezzük, hogy a bemenet Base64 kódolású
try:
# A szöveget először bájtokká (bytes) alakítjuk, majd dekódoljuk
dekodolt_bajt = base64.b64decode(kodolt_szoveg.encode('utf-8'))
eredeti_szoveg = dekodolt_bajt.decode('utf-8')
except Exception as e:
return f"Hiba a dekódolás során: {e}"
# 2. Újrakódolás: Hexadecimális formátumba
uj_kodolt_ertek = eredeti_szoveg.encode('utf-8').hex()
print(f"Eredeti kódolt szöveg: {kodolt_szoveg}")
print(f"Visszafejtett (dekódolt) szöveg: {eredeti_szoveg}")
print(f"Újrakódolt (Hex) szöveg: {uj_kodolt_ertek}")
return uj_kodolt_ertek
# Példa használat
minta_kodolt_szoveg = "VHJhbnN6Zm9ybSZhY3Rpb24=" # "Transzform&action" Base64-ben
atkodolo_program(minta_kodolt_szoveg)
------------------
Eredeti kódolt szöveg: VHJhbnN6Zm9ybSZhY3Rpb24=
Visszafejtett (dekódolt) szöveg: Transzform&action
Újrakódolt (Hex) szöveg: 5472616e737a666f726d26616374696f6e
-----------------------
Fernet szimmetrikus titkosítási eljárás (amely az iparági szabvány AES-128 algoritmust használja.
--------------------------
import base64
import hashlib
def xor_titkosit(szoveg, kulcs):
szoveg_bytes = szoveg.encode("utf-8")
kulcs_bytes = hashlib.sha256(kulcs.encode("utf-8")).digest()
titkos = bytes(b ^ kulcs_bytes[i % len(kulcs_bytes)] for i, b in enumerate(szoveg_bytes))
return base64.b64encode(titkos).decode("utf-8")
def xor_visszafejt(token, kulcs):
titkos_bytes = base64.b64decode(token.encode("utf-8"))
kulcs_bytes = hashlib.sha256(kulcs.encode("utf-8")).digest()
eredeti = bytes(b ^ kulcs_bytes[i % len(kulcs_bytes)] for i, b in enumerate(titkos_bytes))
return eredeti.decode("utf-8")
def szoveg_titkositasa():
kulcs = "alapertelmezett_kulcs"
eredeti_szoveg = "Ez egy nagyon titkos szöveg."
titkos_token = xor_titkosit(eredeti_szoveg, kulcs)
visszafejtett_szoveg = xor_visszafejt(titkos_token, kulcs)
print(f"Eredeti szöveg: {eredeti_szoveg}")
print(f"Titkosított token: {titkos_token}")
print(f"Visszafejtve: {visszafejtett_szoveg}")
if __name__ == "__main__":
szoveg_titkositasa()
--------------------
Eredeti szöveg: Ez egy nagyon titkos szöveg.
Titkosított token: +qls6ByNaqzWnVTdH9uOguN2nkHK59A+ty+f0cg=
Visszafejtve: Ez egy nagyon titkos szöveg.
Nincsenek megjegyzések:
Megjegyzés küldése