Paano lumikha ng isang Caesar cipher at decryptor sa C

Kung nagsisimula ka sa C at gusto mo ng praktikal na proyekto, Lumikha ng isang programa para sa pag-encrypt at pag-decrypting gamit ang Caesar cipher. Ito ay isang perpektong opsyon. Ito ay simple, pinipilit ka nitong manipulahin ang mga string, magtrabaho kasama ang mga character, at mag-isip sa mga terminong matematika, ngunit hindi ka nababaliw sa pagiging kumplikado.

Bilang karagdagan sa pagsisilbi bilang isang programming exercise, Ang Caesar cipher ay isang mahusay na entry point sa mundo ng cryptographyMauunawaan mo kung ano ang susi, kung bakit mahina ang ilang system, at kung paano aatakehin ang pag-encrypt nang may malupit na puwersa. Titingnan natin ito nang sunud-sunod, kasama ang teorya, mga halimbawa, at ilang mga diskarte sa pagpapatupad sa C.

Ano ang Caesar cipher at saan ito nanggaling?

Ang tawag Caesar cipherAng shift cipher, o shift cipher, ay isa sa mga pinakalumang cryptographic system na umiiral. Nagmula ang pangalan nito Julius Caesar, na sinasabing dati niyang inuutusan naka-camouflaged na mensahe ng militar sa kanyang mga heneral, upang kung may humarang sa teksto ay hindi nila ito maintindihan sa unang tingin.

Ang ideya ay napaka-simple: Ang bawat titik ng orihinal na mensahe ay pinapalitan ng isa pa na isang nakapirming bilang ng mga posisyon na pasulong o paatras sa alpabeto.Ang bilang ng mga posisyon ay ang susiHalimbawa, sa key 3, ang A ay nagiging D, ang B ay nagiging E, ang C ay nagiging F at iba pa hanggang Z, kung saan ang alpabeto ay "bumaling" at nagsisimula muli sa A.

Ang iskema na ito ay kabilang sa monoalphabetic substitution ciphersSa tuwing lumilitaw ang parehong titik sa plaintext, ito ay binago sa parehong naka-encrypt na titik. Ginagawa nitong napakadaling maunawaan at ipatupad, ngunit napakadaling masira gamit ang kaunting pagsusuri.

Mga pundasyon ng matematika ng Caesar cipher

Sa likod ng klasikong pamamaraang ito ay namamalagi a napaka compact na mathematical formulation. Binilang namin ang bawat titik mula 0 hanggang n-1 (kung saan ang n ay ang laki ng alpabeto), maaari nating ipahayag ang cipher bilang:

C = (P + k) mod n

Saan P ay ang posisyon ng orihinal na titik, C ay ang posisyon ng naka-encrypt na sulat, k ay ang susi sa displacement at n ay ang kabuuang bilang ng mga simbolo ng alpabeto (26 sa alpabetong Ingles na walang ñ). Ang operator mod Tinitiyak nito na, sa pag-abot sa dulo ng alpabeto, magsisimula muli ang bilang mula sa simula.

Para makuha ang mensahe, simple lang baligtarin ang operasyon:

P = (C − k) mod n

Sa pagsasagawa, kapag ipinatupad namin ito sa C hindi kami gumagana sa mga abstract na posisyon, ngunit sa mga numerong code ng character (ASCII o UTF-8 compatible)Ang malalaking letrang A hanggang Z ay sumasakop sa mga halagang 65 hanggang 90, at ang mga maliliit na letrang aa hanggang z ay mula 97 hanggang 122. Kapag sinasamantala ang mga saklaw na ito, maaari nating ibawas ang base code ('A' o 'a'), ilapat ang shift gamit ang modulo 26 at idagdag muli ang base.

Isang pangunahing detalye: Ginagarantiyahan ng modular na operasyon ang "circular effect" ng alpabetoKung ililipat mo ang Z ng tatlong posisyon na may key 3 sa uppercase na hanay, mapupunta ka sa C, dahil ang pagkalkula ay ginagawa sa loob ng hanay na 0-25 at pagkatapos ay i-convert pabalik sa ASCII code.

Mga pangunahing konsepto ng cryptography na kailangan mo

Ang pagtatrabaho sa Caesar cipher ay nagbibigay-daan sa iyo na mag-internalize ng ilan mga klasikong konsepto ng cryptography nang hindi pa nakakapasok sa advanced na matematika o modernong algorithm.

Tinatawag namin ang orihinal na hindi naka-encrypt na mensahe teksto ng eroplanoIto ang gusto mong ipaalam: halimbawa, "Paalam" o isang kumpletong parirala. Ang resulta pagkatapos mag-apply ng encryption ay ang ciphertext o cryptogram, na mukhang isang string ng walang kahulugan na mga titik, tulad ng "Dglrv".

Ang proseso ng pag-convert ng plaintext sa ciphertext ay tinatawag pag-encrypt, habang tinatawag ang inverse operation decryptionSa parehong mga kaso, a susina sa Caesar cipher ay isang integer lamang sa pagitan ng 1 at 26 (o sa pagitan ng 0 at 25, depende sa kung paano mo ito tinukoy sa programa), at ang aplikasyon nito sa mga serbisyo tulad ng Gmail.

Ang isang kawili-wiling punto ay, kahit na ang resulta ay maaaring mukhang ligtas sa isang gumagamit na walang kaalaman, Ang aktwal na seguridad ng Caesar cipher ay halos zero.Mayroon lamang 25 na posibleng mga susi sa karaniwang alpabeto ng Latin, kaya maaaring subukan ng isang umaatake ang lahat ng ito sa mga millisecond gamit ang isang brute-force na programa.

ASCII, ordinal, at conversion sa pagitan ng mga titik at numero

Upang maipatupad ang sistemang ito sa C, kailangan mong maunawaang mabuti kung paano kinakatawan ng mga computer ang mga characterSa kasaysayan, ang ASCII ay pangunahing ginagamit, na nagtatalaga ng integer sa pagitan ng 0 at 127 sa bawat simbolo, bagama't sa pagsasanay ang mga napi-print na hanay mula 32 hanggang 126 ay kadalasang ginagamit.

Tulad ng nagkomento na kami, Ang mga malalaking titik na AZ ay may mga code mula 65 hanggang 90, At ang mga maliliit na titik az mula 97 hanggang 122Ang mga digit na 0-9 ay mula 48 hanggang 57. Sa kasalukuyan, karaniwan nang gumana sa UTF-8, ngunit para sa mga pangunahing character ay pinapanatili nito ang parehong mga halaga tulad ng ASCII, kaya ang aming code ay magiging wasto pa rin.

Ang karaniwang lansihin ay ang i-convert ang isang titik sa numeric code nitomanipulahin ang numerong iyon gamit ang mga pagpapatakbo ng karagdagan, pagbabawas, at modulo, at pagkatapos ay i-convert ito pabalik sa isang character. Sawa Ginagawa ito sa mga function ord() y chr(); sa C sila ay hindi umiiral bilang tulad, ngunit Ang uri ng char mismo ay maaaring ituring bilang isang integer, at ang mga constant ng character gaya ng 'A' o 'a' ay kumikilos bilang mga numeric na halaga.

Halimbawa, para ilipat ang letrang 'A' ng tatlong posisyon pasulong sa C, maaari mong isipin ang ganito: Ang 'A' ay may code 65, magdagdag ka ng 3 at makakakuha ka ng 68, na tumutugma sa 'D'Kapag nagtatrabaho sa malalaking titik, ibawas muna ang 'A' upang gawing normal ang hanay sa 0-25, ilapat ang offset modulo 26, at pagkatapos ay idagdag ang 'A' pabalik upang mabawi ang tamang code.

Pangkalahatang disenyo ng isang C program para sa Caesar cipher

Ang isang C program na nagpapatupad ng Caesar encryption at decryption ay kadalasang sumusunod sa a magkatulad na istrakturakahit na ang mga detalye ay maaaring magbago depende sa istilo ng may-akda:

• Humiling ng text mula sa user: hinihiling ang isang string na magiging mensaheng ie-encrypt o ide-decrypt.
• Binabasa ang numeric key: ang gumagamit ay pumapasok sa offset, karaniwang isang integer sa pagitan ng 1 at 26.
• Pagpili ng mode: i-encrypt, i-decrypt, o kahit na malupit na puwersa kung gusto mong magdagdag ng dagdag na iyon.
• Pangunahing function ng pagsasalin: natatanggap ang mensahe, ang susi at ang mode, binabagtas ang string at bumubuo ng naprosesong resulta.
• Output ng screenAng nakuhang cryptogram o plaintext ay naka-print.

Ang core ng algorithm ay palaging pareho: daanan ang string ng character sa pamamagitan ng character.Suriin kung ang bawat simbolo ay isang titik at, kung gayon, ilapat ang naaangkop na pagbabago, igalang ang malaki at maliit na titik. Lahat ng hindi isang titik (mga puwang, mga bantas, mga numero, atbp.) ay karaniwang iniiwan.

Paggamit ng mga karaniwang C function upang gumana sa mga character

Upang gawing mas malinis at mas matatag ang code, lubos na inirerekomendang umasa sa header. , na nag-aalok ng ilang napakakapaki-pakinabang na function para sa pag-uuri ng mga character.

pangunahing tampok:

Sa partikular, para sa Caesar cipher, magiging interesado ka sa:

• isalpha(c): nagbabalik ng di-zero na halaga kung ang c ay isang titik (malaki o maliit), at zero kung hindi.
• isupper(c): sinusuri kung ang c ay isang malaking titik.
• islower(c): sinusuri kung ang c ay isang maliit na titik.

Con estas funciones puedes madaling i-filter kung aling mga character ang ipoprosesoKung mali ang isalpha(c), kopyahin mo lang ang simbolo sa resulta at magpatuloy sa susunod. Kung ito ay isang liham, magpapasya ka sa naaangkop na hanay (AZ o az) ayon sa isupper o islower at ilapat ang shift nang walang takot na lumabas sa kaukulang alpabeto.

Sa parallel, kakailanganin mo ang header para sa mga function tulad ng strlen()na nagpapahintulot sa iyo na malaman ang haba ng string at gamitin ito sa isang loop para o habang sa pamamagitan ng pag-ulit sa mensahe.

Halimbawa ng pangunahing pagpapatupad ng Caesar cipher sa C

Ang isang napaka-karaniwang bersyon ng C program ay tumutukoy sa isang function, na maaari naming tawagan, halimbawa huminto(), namamahala sa baguhin sa lugar ang natanggap na string o upang makabuo ng naka-encrypt na kopya mula sa isang input buffer.

Karaniwang daloy:

• En main ()Hinihiling sa user na maproseso ang teksto.
• Ang displacement key ay hinihiling at ito ay napatunayan upang matiyak na ito ay nasa loob ng pinapayagang hanay.
• Ang pag-encrypt na function ay tinatawag sa pamamagitan ng pagpasa ng teksto at ang susi.
• Ang resulta ay ipinapakita sa screen.

Panloob na kaayusan:

• Kalkulahin ang haba ng teksto gamit ang strlen() upang itakda ang mga limitasyon ng loop.
• Traverse ang string character sa pamamagitan ng character gamit ang isang integer index.
• Suriin kung ang bawat karakter ay isang malaking titik, isang maliit na titik, o hindi alpabeto.
• Ilapat ang displacement gamit ang naaangkop na formula at ang % operator 26.
• Iwanang hindi nagbabago ang mga hindi alpabetikong character.

Ang gamit ng operator % 26 ay mahalaga para sa resulta manatili sa loob ng alpabetoKaya, kung ililipat mo ang z gamit ang key 3, makakakuha ka ng c sa halip na isang kakaibang simbolo ng ASCII code.

Pagmamanipula ng string sa C: scanf, fgets at buffers

Ang isa sa pinakamahirap na aspeto ng pagsulat ng mga program na ito sa C ay hindi ang mismong pag-encrypt, ngunit ang paraan upang basahin ang string mula sa karaniwang inputBagama't mukhang nakakatukso ang `scanf` na may "%s", mayroon itong ilang problema: pinuputol nito ang pagbabasa sa unang puwang, hindi nito makokontrol nang mabuti ang laki ng buffer, at madaling magdulot ng mga overflow kung hindi ka mag-iingat.

Kaya naman pinipiling gamitin ng maraming modernong halimbawa fgets() para basahin ang buong linya. Ang function na ito ay tumatanggap ng buffer, ang maximum na laki nito, at ang input source (karaniwang stdin) at tinitiyak na ang mga limitasyon ay hindi lalampas. Ang trade-off ay iyon Karaniwan itong umaalis sa line break sa dulo ng stringKaya karaniwang magandang ideya na linisin ito nang manu-mano sa pamamagitan ng pagdaan sa string at pagpapalit ng '\n' ng '\0' kapag lumitaw ito.

Sa anumang kaso, ang algorithm ng pag-encrypt ay independiyente sa kung paano mo nakuha ang string: Maaari mong i-encapsulate ang logic ni Caesar sa isang function na tumatanggap ng pre-prepared char[], at pagkatapos ay magpasya sa pangunahing kung pupunan ang array na iyon ng fgets, scanf o anumang iba pang paraan ayon sa iyong mga pangangailangan.

Istraktura ng isang kumpletong interactive na programa

Higit pa sa pangunahing pag-andar ng pag-encrypt, ang isa ay maaaring bumuo ng isang medyo komprehensibong interactive na programa na nagbibigay-daan sa user na pumili kung ie-encrypt, i-decrypt, o subukan ang lahat ng posibleng key (brute force mode).

Ang isang napakalinaw na organisasyon ay binubuo ng paghihiwalay ng lohika sa ilang mga function:

• getMode(): nagtatanong sa user kung gusto nilang mag-encrypt, mag-decrypt, o gumamit ng brute force at magbabalik ng character o maikling string na kumakatawan sa napiling mode.
• getMessage(): ang may pananagutan sa paghiling ng text na maproseso at ibalik ito.
• getKey(): humihiling ng key mula sa user, pinipilit ang user na magpasok ng value sa pagitan ng 1 at maximum (halimbawa 26) at ibabalik ang integer na iyon.
• getTranslatedMessage(mode, mensahe, key): inilalapat ang lohika ng pag-encrypt o decryption ayon sa mode, ibinabalik ang binagong teksto.

Sa decrypted mode ito ay napaka-maginhawa gumana sa parehong function tulad ng para sa pag-encryptNgunit ang tanda ng susi ay binago. Iyon ay, kung pipiliin ng user na mag-decrypt, ang susi ay i-multiply sa -1 at ang parehong algorithm na ginamit para sa pag-encrypt ay inilalapat. Sa ganitong paraan, maiiwasan mo ang pagdoble ng code.

Ang brute force mode ay nagdaragdag ng isang kapansin-pansing kuryusidad: awtomatiko ang proseso ng pagsubok sa lahat ng posibleng mga susiAng programa ay umiikot mula 1 hanggang sa maximum na laki ng key, na tinatawag ang translation function sa decryption mode sa bawat pag-ulit at ipinapakita ang bawat resulta kasama ang key na ginamit. Kailangan lang ng user na obserbahan kung aling mga linya ang may katuturan sa Spanish upang matukoy kung aling shift ang orihinal na ginamit.

#isama // Para sa printf at scanf #include // For strlen // Function that applies the Caesar cipher void caesar_cipher(char *text, int shift) { for (int i = 0; i < strlen(text); i++) { char c = text[i]; // kasalukuyang character // Kung ito ay malaking titik kung (c >= 'A' && c <= 'Z') { text[i] = ((c - 'A' + shift) % 26) + 'A'; } // Kung ito ay maliit na titik else if (c >= 'a' && c <= 'z') { text[i] = ((c - 'a' + shift) % 26) + 'a'; } // Kung hindi ito isang sulat, iwanan ito bilang } } int main() { char message[100]; // buffer para sa text int shift; // value ng shift printf("Ipasok ang mensahe upang i-encrypt: "); scanf("%99[^\n]", mensahe); // Reads up to 99 characters including spaces printf("Ipasok ang offset (hal., 3): "); scanf("%d", &offset); // Ilapat ang encryption caesar_cipher(mensahe, offset); printf("Naka-encrypt na mensahe: %s\n", mensahe); bumalik 0; }

Pangangasiwa ng malalaking titik, maliliit na titik, at mga espesyal na character

Ang isang bagay na madalas na hindi napapansin sa simula ay ang kahalagahan ng Igalang ang hugis ng mga titik at huwag sirain ang tekstoAng isang mahusay na Caesar cipher program ay dapat tratuhin nang magkahiwalay ang malaki at maliit na titik, at mag-iwan ng mga buo na simbolo na hindi kabilang sa alpabeto.

Karaniwang lohika ay:

• Kung ang simbolo ay hindi pumasa sa tseke isalpha()Direkta itong kinokopya sa resulta nang walang anumang pagbabago.
• Kung ito ay isang malaking titik, ito pinapa-normalize ang halaga sa pamamagitan ng pagbabawas ng 'A'Ang displacement ay inilapat sa modulo 26 at pagkatapos ay idinagdag muli ang 'A'.
• Kung ito ay isang maliit na titik, ang parehong ay tapos na ngunit sa hanay batay sa 'a'.
• Kung kapag idinagdag ang susi ay lumampas ka sa hanay (lampas sa 'Z' o 'z'), ibawas ang 26; kung ibababa mo, magdagdag ka ng 26.

Sa ganitong paraan maaari kang gumawa ng mga text tulad ng "Goodbye" na may key 3 "Dglrv" na may kinalaman sa inisyal na malaking titik at ang natitira sa maliit na titik, at sa pag-decipher ay babalik ka nang eksakto sa orihinal.

Mahalaga rin na magkaroon ng kamalayan na Hindi binabago ng Caesar cipher ang mga puwang o mga bantasNagbibigay-daan ito sa visual na istruktura ng mga pangungusap at talata na mapanatili, ngunit ginagawang nakikita pa rin ng isang umaatake ang haba ng mensahe at kaugnay na posisyon ng mga salita.