Az RSA működik úgy is, ha nem a nyilvános enkódoló, hanem a privát dekódoló kulcsomat választom véletlenszerűen?

"A privát kulcsomat szeretném választani, és a nyilvánost generálni a privátból, a megszokottal ellentétesen."

Még egyszer: az eljárás lényege, hogy generálsz egy kulcspárt. Elvben nincs privát és nyilvános, csak két kulcs. Ezekből bármelyiket választhatod privátnak. Nem kell semmit "ellentétesen" csinálni, csak a végén felcseréled őket.

[link]

[link]

[link]

A nyilvános kódú rejtjelezés szemléltetésére jó példa egy egyirányú utcáktól hemzsegő város. A városban van egy A és B pont. Ha el akarsz jutni A pontból B pontba, akkor lehet adni egy útvonaltervet: fordulj balra, aztán jobbra, aztán megint jobbra, majd megint balra, stb… Így el tudsz jutni A pontból B pontba. Viszont nem tudsz visszajutni B pontból A pontba, mert egyirányú utcákon közlekedtél. Viszont lehet csinálni egy útvonaltervet, ami B pontból juttat el A pontba. Ez nyilván egy egészen más útvonal lesz.

Ha nincs térképed a városról, akkor az odaútból nem lehet megtudni a visszautat, a visszaútból meg nem lehet megtudni az odautat. De itt az oda és vissza viszonyítás kérdése. Ha valakit leteszel az egyik pontba, akkor egy adott útvonaltervvel el tud jutni a másik pontba. Onnan viszont a kiindulópontra csak a másik útvonaltervvel tud eljutni. A→B útvonalterv esetén csak a B→A útvonalterv vezet vissza a kiindulópontra, a B→A útvonalterv esetén meg csak az A→B útvonalterv vezet vissza a kiindulópontra.

A lényeg, hogy neked két kulcsod van, legyen N a nyilvános kulcs, P a privát kulcs. Erre igaz, hogy:

P(N(x)) = N(P(x)) = x

de

P(x) ≠ N(x)

A két kulcs szimmetrikusan működik. Hogy melyiket választod privátnak és melyiket teszed nyilvánossá, az lényegtelen, csak arra kell ügyelni, hogy a privátnak használt kulcsot véletlenül se hozd nyilvánosságra. A nyilvános kulcsot meg szétosztogathatod szórólapon, felfestheted a házad falára, hiszen a nyilvános kulccsal kódolt üzenetet csak a privát kulcsoddal lehet dekódolni, viszont a te privát kulcsoddal titkosított üzenet dekódolásához csak a nyilvános kulcsra van szükség, a te privát üzenetedre nincs. A legegyszerűbb esetben ha te kódolsz egy üzenetet, akkor P(x)-et küldöd el, a fogadó meg N(P(x))-szel visszakapja x-et, azaz az eredeti üzenetet. Ha meg neked akar üzenni valaki, akkor ő N(x)-et küldi el neked, te meg P(N(x))-el visszakapod x-et, azaz az ő eredeti üzenetét.

Persze ezzel az a gond, hogy általad titkosítani akart üzenetet nem csak a célszemély, hanem bárki dekódolni tudja. Illetve hogy te nem lehet biztos abban, hogy a megkapott kódolt üzenetet valóban az küldte, akit te feltételezel. Erre jó, ha kölcsönösen titkosítjátok az üzenetet a saját privát, és a másik nyilvános kulcsával is.

Ha egyeske üzenetet küld kettesnek, akkor kódolja azt ketteske nyilvános és a saját privát kulcsával is:

y := N₂(P₁(x))

ketteske a titkosított üzenetet (y) könnyen dekódolni tudja egyeske nyilvános és a saját privát kulcsával:

N₁(P₂(y)) = N₁(P₂(N₂(P₁(x)))) = N₁(P₁(x)) = x

Az RSA ezt kicsit optimálisabban oldja meg számítási kapacitás szempontjából, de ez már csak részletkérdés. A lényeg, és ez adja a nyilvános kódolás működőképességét, hogy a két kulcs szerepe felcserélhető. Ha valami az egyikkel van kódolva, csak a másikkal fejthető vissza. Ha valami a másikkal van kódolva, csak az egyikkel fejthető vissza. Hogy melyik a két kulcsból a privát és melyik a nyilvános, az már csak egy fej vagy írás kérdése.

> P(N(x)) = N(P(x)) = x

> de

> P(x) ≠ N(x)

Fontosabb kritérium, hogy:

P(P(x)) ≠ x

N(N(x)) ≠ x

Nem a közvetlen kérdésedre fogok válaszolni, mert annak nincs értelme, zavaros, az elnevezéseket keveri, pl. az e-ről úgy beszélsz, mintha egymagában az lenne a nyilvános kulcs, meg egyoldalú véletlenszerűséget emlegetsz, noha az mindkét kulcsnak elengedhetetlen része n révén, stb. De megpróbálom tisztázni a képet.

A két kulcs összesen három számból áll. n, e, d. Az n két nagy, "véletlenszerű" prím (p, q) szorzata, az e és a d két, ennél kisebb szám, amikre teljesül az a bizonyos e*d = 1 (mod lkkt((p-1)(q-1))) feltétel. Innentől annyi a dolgod, hogy úgy válaszd ki e-t és d-t, hogy a d kellően nagy legyen ahhoz, hogy ne lehessen megtippelni. Ugyanis a három szám közül ez lesz az, amit titokban tartasz. Az (n, e) számpár lesz a nyilvános kulcsod, az (n, d) pedig a privát.

e-nek semmi köze a biztonsághoz, se vagy véletlenszerűséghez. Az e egy nagyon is szándékosan választott szám, célszerű tulajdonságokkal (páratlan, kicsi, kevés 1-es bitet tartalmazó) hogy a két kulcs közül legalább a nyilvánossal való kódolás gyors legyen. Ez napjainkban a sztenderd bináris 10000000000000001 = 65537. Azért jó, mert az üzenetet rekurzívan 16-szor négyzetre kell emelni (mod n), és még egyszer hozzászorozni. Máshogy is lehet csinálni, ez most mindegy is.

Az e szám a d-ről nem árul el plusz információt. Minden n=pq-hoz és e=65537-hez tartozik egy, jellemzően bazi nagy, n-nél csak pár bittel rövidebb d, amit csak izomból, próbálgatással lehet megfejteni. Ezen semmit nem változtatna az sem, ha e=65537 helyett saját kezűleg választott e=735982389723 számodat használnád, és ahhoz számolnál d-t. Hiszen ugyanaz lenne a menete a feltörésének: nyers erő.

Megteheted. A kódolás és dekódolás felcserélhető, mindkettő ugyanaz a művelet: üzenet hatványozása mod n, csak a kitevő a különbség. Ha választasz magadnak egy akármilyen, lkkt(p-1, q-1)-vel relatív prím e-t, és ahhoz számolsz d-t, működni fog minden.

Legalábbis amíg a matematika mezejéről vissza nem térsz a való világba... mert hálistennek a közhasználatban levő protokollok nem adnak neked arra lehetőséget, hogy dekódolás szintű erőfeszítésre kényszerítsd szerencsétlen kommunikációs partneredet kódolási oldalon. Egy SSL nyilvános kulcsba nem fogsz belerakni semmilyen nagy számot, mert csak 16 bitet tart fenn a számára, egyes protokollok nem is hajlandóak a 65537-től eltérő e-vel számolni, hanem beléjük van égetve.

A kódolás így fix 17 művelet, a dekódolás már egy 256 bites kulcs esetén is ~256+128 (±20) művelet.

És mégegyszer: a biztonságot tekintve nincs jelentősége a nyilvános kitevő értékének. Azt kell megértened, hogy egy (n, e) számpár ismeretében az ed = 1 (mod fí(n)) megoldása a matematika jelenlegi állása szerint ígyis-úgyis csak izomból lehetséges, e értékétől függetlenül.

"Ha egyeske üzenetet küld kettesnek, akkor kódolja azt ketteske nyilvános és a saját privát kulcsával is"

Lehet, hogy én értem félre, de egyeske biztosan nem használja kettes privát kulcsát, tekintve hogy az privát (titkos).

A metódus a következő:

Ha A üzenetet akar küldeni B-nek, akkor azt B (a címzett) nyilvános kulcsával titkosítja, amit csak B fog tudni elolvasni a saját privát kulcsával. Ha B választ akar küldeni, akkor azt A nyilvános kulcsával titkosítja, így csak A tudja elolvasni a saját privát kulcsával.

A: BN(x) --> B: BP(BN(x))

Egymás privát kulcsait nem használhatják. Esetleg olyat lehet csinálni (lehet, hogy ezt írtad, csak félreértettem), hogy A titkosítja az üzenetét a saját privát és a B publikus kulcsával, amit B dekódolhat a saját privát és A nyilvános és kulcsával.

A: 'BN(AP(x))' --> B: AN(BP( 'BN(AP(x))' ))