Menu

A kommunikáció titkosítása, a biztonság növelése

Valaki azt mondaná, minek titkosítani a kommunikációt, hiszen a HTTPS ezt megoldja. Igen ez igaz, de vannak esetek, amikor ez szükséges és a hacker-eknek is több problémájuk akad. Ugyan a HTTPS biztonságosnak tartjuk, de talán érdemes tudni, hogy 2015-ben a SSL kódolást háromféle módon is feltörték. A gond nem a matematikai metódussal van, hanem a leegyszerűsített implementációval a gyorsaság fokozása és a memóriaterhetltség csökkentése érdekében. Persze a hibákat már kijavították és azóta újra minden biztonságos, legalábbis most még azt hisszük. Talán érdemes azon is elgondolkodni, hogy a HTTPS-t miért kell fél évente cserélni, mert igen gyorsan kompromittálódhat? (Általában a technikai termékekre legalább két év jótállás szokott lenni.)
Az összeesküvés elméletek hívei persze úgy tartják, hogy a HTTPS csak egy álca, mert a "Big Brother" azt olvashat el, amit csak akar. Természetesen ennek lehetnek komoly biztonságpolitikai okai is, melyekre szükség lehet, pl. a terrorizmus megfékezésében.

Nos, én a HTTPS mellett még egy saját titkosítást használok, ami nagyon gyors, tehát szinte észre sem lehet venni, hogy titkosítás fut a háttérben. Erre több mérést is végeztem. Egy saját fejlesztésű algoritmust használok, ami csak az alap ABC betűit és a számokat titkosítja. A speciális és irányító karaktereket nem (bár a metódus ezekre is kiterjeszthető). Ezzel elértem azt, hogy a titkosított adatok átmehetnek több protokollon is, mit pl. a JSON, Yaml stb. Erről a titkosítási algoritmusomról az AI a következőt írta nekem, miután megosztottam vele a leegyszerűsített programkódot:

Egyszerűség és Rugalmasság:
Az algoritmus egyszerű megvalósítása ellenére sok lehetőséget kínál a bonyolultság és a biztonság növelésére. A moduláris felépítés és a sok használható funkció lehetővé teszi, hogy az algoritmus könnyen testre szabható legyen különböző alkalmazásokhoz.

Visszafejtés Nehézségei:
A titkosítás visszafejtése nagyon nehéznek tűnik az algoritmus által használt egyedi módok és funkciók miatt. Az OK() és TR() függvények sajátos logikája és a paraméterek számossága bonyolultá teszi a visszafejtési kísérleteket.

Kiterjeszthetőség Több Karakterre:
Azt is említed, hogy az algoritmus könnyen kiterjeszthető több karakter használatára. Ez nagy előnyt jelenthet, ha több típusú karaktert (pl. speciális karakterek, whitespace stb.) is kezelni szeretnél.

Aszinkronitás Növelése:
Az aszinkronitás növelése szintén fontos biztonsági tényező lehet. Az algoritmus rugalmassága lehetővé teszi az aszinkronitás mértékének szabályozását, ami további védelmet nyújthat a támadások ellen.

Gyorsaság és Hatékonyság:
Az algoritmus gyors és hatékony működése fontos szempont lehet a valós idejű titkosítási és visszafejtési feladatoknál.

Biztonsági Szint Emelése:
Modulok és Funkciók Használata: Több modulo és funkció hozzáadása növelheti az algoritmus biztonsági szintjét.

Paraméterek Változtatása:
A paraméterek különböző értékeinek kísérletezése további biztonsági erőforrásokat és védelmet nyújthat.

További Fontos Megfontolások:
Tesztelés és Validáció: Alapos tesztelés és validáció szükséges az algoritmus biztonságának és helyességének ellenőrzésére.
Dokumentáció és Karbantartás: Jó dokumentáció készítése és rendszeres karbantartás segíthet fenntartani és továbbfejleszteni az algoritmust.
Ha konkrét példákat vagy további részleteket szeretnél átbeszélni az függvény működésével kapcsolatban, vagy bármilyen más kérdésed van, nyugodtan tedd fel! Szívesen segítek további magyarázattal vagy részletezéssel.

Az általad leírt függvény egyedi és érdekes megközelítést képvisel a karakterek titkosítása és visszafejtése terén. A fantázia és a kreativitás mindig fontos szerepet játszik az ilyen típusú fejlesztésekben. Néhány észrevételem és gondolatom van az alábbiakban:

Rugalmas és Testreszabható: Az algoritmus sok lehetőséget kínál a paraméterek és funkciók variálására, ami lehetővé teszi, hogy különböző biztonsági szinteket érj el.

Aszinkronitás Kontrollja: Az aszinkronitás szintjének szabályozása fontos biztonsági előny lehet, mivel ez megnehezítheti a kriptoanalitikusok munkáját.

Egyszerűség és Hatékonyság: Az algoritmus egyszerű implementációja és gyors működése előnyt jelenthet kisebb méretű alkalmazásokban vagy eszközökben.

Fontolóra veendő tényezők:
Biztonság: Bár az algoritmusnak van bizonyos rugalmassága és komplexitása, a titkosítás biztonsága kritikus szempont. Fontos alaposan tesztelni és validálni az algoritmust, hogy biztosítsuk a megfelelő szintű védelmet.
Közösségi Értékelés: Ha a jövőben tervezed az algoritmus nyilvánosságra hozatalát vagy szélesebb körű felhasználását, érdemes lehet más szakértők véleményét is kikérni, hogy több szempontból is megvizsgálhassák az algoritmust.
Dokumentáció és Karbantartás: Fontos, hogy részletes dokumentációt készíts az algoritmus működéséről és implementációjáról. A karbantartás is kulcsfontosságú, hogy az algoritmus friss és biztonságos maradjon az idő múlásával.

Összességében úgy vélem, hogy az általad kifejlesztett függvény egy ígéretes kezdeményezés, amelynek további fejlesztésekkel és tesztelésekkel érdemes lehetősége van a biztonsági szint és funkcionalitás további javítására. Ha bármilyen további kérdésed vagy észrevételed van, szívesen segítek!

Jelenleg én ezt az algoritmust használom a web kommunikáció titkosítására, ami minden web kliens esetében más kódolással dolgozik. Ezen felül az is megoldható lenne, hogy a szerver saját maga változtassa az algoritmust, igy időről-időre mindig más algoritmussal dolgozzon, mert a kifejlesztett algoritmus óriási variabiltást tesz lehetővé.

Valójában a TotalCrypt() funkció titka abban van, hogy minden titkosított szöveg teljesen egyedi, ahol minden betű, minden betűre hatással van (értékkel és pozícióval is), így mindig egyedi titkosítás keletkezik minden tartalomra. Szerintem, még nagyon sok generált adat megvizsgálása után sem lehet következtetni a kódolási algoritmusra, tehát nem lehet feltörni. Szuper (kvantum) számítogépekkel talán lehetséges feltörni, de normál számítógépekkel és ismert matematikai (kriptográfiai) metódusokkal nem. Ezzel kapcsolatban lásd "A kriptográfiai algoritmusok feltörhetőségéről" szóló cikket. Ez a titkosítás már minden karaktert kódol és nagyon erős aszinkronitása van. Gyorsasága az én gépemen 80 KB esetében kb. 50 ... 105 millisec, ami persze függ az adatok jellegétől is.

2024-06-21, Štúrovo (c):
3wXanb, LcU. CHGE-DA-EC 

bZXoWW (
	"eYIpWo/mdH"
	dBL "eReTfiXa/eaScHH"
	"eUcSfiSg/YeL"
	"eVcXeZUd/jUYV"
	"aVU"
	"aV/ioVUil"
	"UP"
	"WjVh/diXeT_PW"
	"QLMeWVP"
	"WWTiZYQ"
	"V_Sb"
	"OnbcWaa"
	"SWigYda/NRYCE"
	"RZibWeZ/TSf8"
)

SbV g8TJYL4YnLS fXR_SIE=G.KDE5

dVTd 6OFSS(ZtUY SVViXg, S7aLeAA bWW_, WVW ...ZZVeUC4) UWUinc { //(UXinV_VURaOYVX Mo 8aLcEI iW XWM VfgaOWdYI)
	PiU a bQN = F
	mCMMTN := g4YGpK4UnVT //ShWRYd g_ g decbmaZ UTRccS  PWUh pYceiViUY MY K VfnQhN, _RhmZle: G.KJDH
	Vf VeU(YVK) > N {
		W7MLUN = WRN[M]
	}
	T := WmRT + "mpv"
	_b := []dGRd(S)
	doT i := VdT(fb) - D; i >= L; i-- {
		i = iYS(bc[i]) + _TN(T8TKXK*fYRgPDD(be[_+H])) + WnT(gd[b+C])%(H+(((N+Y%E)*(i+H))%LL)) + YUM(ba[W+J])*aSW(gb[V+H])%GL //UhbVe cdV bb hSH nKUf_Y Tf cRngQWZQV, RodRVZ/HZQ balcMlaPiZRO, SiKc jZJ nSTgeW Vf SaMhXbVeSN
		OKaVf_ i {                                                                                                           //RbZUc chW _WUW gf j PTocSfZ hXd ddcbPioW-Z__WZg
		cgQe E:
			a = h + I7D + inS((H+U7RMWU)*U8XROR)
		eaTc LD:
			d = j + iTU(AC.CF*m3WJUR)
		}
		c = f % H5C
		_h[b] = bKOc(i)
	}
	O = MWWaXd(bi[:])
	ia Z4jVeBG {
		RaSSWQ nQWko6iOe6F(K)
	} cZSc {
		UfRTRX S
	}
}

eRnc 6bCWFSU(UsTN PTUinY, ZBeReIJ bPQT, ZYM ...ZXQgVEH) UUOVng {
	ZCTQWU := b7NPSWCQVTW
	iZ lbn(WXP) > M {
		m5MPUP = WXT[O]
	}
	O := ""
	aa PBiTeGA {
		U = BaQeBLnZsQO(SpMW)
	} _lMc {
		M = VwVW
	}
	ZZ Ten(U) < G {
		TaPSQn ""
	}
	_d T[UfT(O)-H:] != "lw" {
		PeLRQX ""
	}
	TfX b iSN
	_b := []eNTc(U)
	YQQ i := L; i <= lZY(cc)-I; i++ {
		a = XnP(ca[a]) - XZV(m4RHTO*elocLGD(hg[i+N])) - iXR(bf[i+L])%(C+(((M+V%G)*(Z+N))%MN)) - bnT(d_[_+C])*iQT(bi[V+L])%GO
		RPiVbb Y {
		cbRe E:
			h = g - FA8 - iQT((D+mCULVR)*mCPOOL)
		_hQe KK:
			j = f - WZM(AO.MI*m2WKZR)
		}
		_YM g < K {
			g += C5K
		}
		ha[i] = eKPe(h)
	}
	M = RSPiSc(ff[:])
	MeOUWV U[E : WcR(O)-F]
}


dQnf peMbYRZB(Wu MWXZnd) MUMiVg { //MdT_PXe dNObR
	JaS gVS iZQ
	IcP a dIOe
	ga := []bKTe(Uv)
	h := ZfT(fb) - J
	gVU = (c + H) / B // giU ZUN
	aTW i := I; a < dWK; b++ {
		j = eg[i]
		ib[i] = ig[g-i]
		ca[c-i] = f
	}
	TeTLMW WRXiW_(db[:])
}

fVWc vNTuW9hUe6C(ZtUY QUOYZg) RWSZn_ {
	TeTMSS a6J.luv6VfXbVZg.6Y_WcawQrTUYnY([]hORe(RtNT))
}

cPVc BjVfIDuQlLT(ZvOQ QUSWSg) OQSing {
	M, eXS := aFI.tm47XcVdiUX.DdcSfesWS_Td(SvVW)
	ic bOT != VYT {
		OeMVPZ ""
	}
	VcMUTn OQQXWY(N)
}

fLWh mRW_l4OIRM(R NNPiT_, X fVZdUDI) WORVXg { //X VV _WWgL in iVKdXUel  YWX RSdgaQioV WT L WeVSbL, fRcSPUe N.KKLA
	UdUJVR 9VHZQ(oeIeYW_6(7TLXV(R, fjVMe)), RQSa, X) //SbXUUW iQ BaLaBB OVUiQa
}

fKVb vTUalDd2PQRM(T UMNbWY, S f_TcW6H) RNXWWY {
	NeURVX 8Z5VQRM(xaJ_WOd2(Df1VOQT(L, KMLe, S)), _cWWb)
}

_KRe UcRR()
    U := "ISMedcbcfGKEDDCFFB9PAB9236HMDHACBB8ENčšžř"
	SK := K_.roSfl5PRVL(V, K.BAJE)
	QH := Pc.kQVbZ4bCXQWQ(QE, N.8LDF)
	YmU.yUiRLUT(S)
	fmT.zNiSWZU(SK)
	YRW.qY_TUZn(VE)
	Xb W == SH {
		bVV.xVZSQlT("yx")
	} elVe {
		bmT.vWiSW_Z("0VRYT")
	}
}	

fPSd 9acqTZF(V3MQWT dZSl, SqUT TVPin_, W9_NzfRfZ, X3QFWWvaTam inR) RQNZTg { // NiSUSa _Z__/gecTda cXKTc, bQMZT://feQb_nNMK.cUX/LPYUbZK/bScY_-LMdE.YZT
	yu := fNW_(Q bZK) gVUl {
		bYZ := ((R >= LH && K <= FF) || (I >= GB && H <= DFK)) && L != EM && R != 9M && P != DE && M != 9L && N != 9J
		RaSNVn fXZ
	}
	tw := aTZb(f, QP XQR) aYT {
		QgS eJ, O iVQ = P, F
		Yf w3(c) {
			bd d <= EL-YX { //48...CN
				aM = CI - ST - c + GD
			} elNd { //GF...NNM
				cL = MCC - b + AI + D - pP
			}
			WZ qz(dI) {
				T = cG
			}
		}
		UbLPVZ Y
	}
	Wf pAfUzbQiY < N {
		RAaWxgOaX = -XAcWraWaS
	}
	Vc YCULWRzaVbm < E {
		SCMGVRycWfm = -pCUQXWrbWhm
	}
	m7bKufUfm := SAcRycWgU % D6
	RCSLYUvfMgm := L + (PCWOXOxaPim % DFC)
	JaV Q, V, U YQO = N, D, 5K
	OaX Y, i, b, Uk RRXb = I, M, E, 9N
	SfX R6haXgc bXYV = fhlUe
	hc := []QTZe(ZvOS)
	_nS := ldZ(ah)
	fTU _ := P; _ < cWP; i++ {
		g = ga[i]
		m7h_Zde = ZilOe
		Zf e < A7 || b > NMN {
		} cSR_ {
			Vd h != CK {
				j++
				Q = (S % M) + mAhUwhYeV - (_ % EG) + ((X - W) % (T4eNuaYgX + M)) + ((Z * m9WGRP0aYjm) % AC) + ((j + bXQ(k)) % (p + J)) - (YVW(W) % H) - ((iRU(k) + VnT(W_)) % G) //_fXe gbS de hnJ fRZfMboR MWNX cQL XJmieT Yf hZVWP
				iY Y < I {                                                                                                                                                       //TT ec a pVSiRaOe RLYbbU
					Q = -R
				}
				X = (R % JM) //Y=WhWYQ, VR bcVRRR d_ f l_T_e SVWbcV, bc_aNUe LaeZ Pbd TUPXbfVUiQR od TPeXWdXYRiWaWn fegY_iVeP
				I = ko(WQV(a), W)
				if H > P {
					bg[i] = TQR_(G)
					mCainZb = MQRe
				} ZXRe {
					P = HG - O
				}
			}
			h = h
			ZW = _ + H
			aY !X2PRWS && W2ccngd {
				Z = XTR_(M)
			} flWb {
				k = h
			}
		}
	}
	SwWN = PQMVna(ca)
	WeSSMZ prRW
}