CAESAR CIPHER I KRYPTOGRAFI

Cæsar-chifferet er en enkel krypteringsteknikk som ble brukt av Julius Cæsar for å sende hemmelige meldinger til sine allierte. Det fungerer ved å flytte bokstavene i klartekstmeldingen med et visst antall posisjoner, kjent som skift eller nøkkel.
Caesar Cipher-teknikken er en av de tidligste og enkleste metodene for krypteringsteknikk. Det er ganske enkelt en type erstatningssiffer, det vil si at hver bokstav i en gitt tekst erstattes av en bokstav med et fast antall posisjoner nedover i alfabetet. For eksempel med et skift på 1, vil A bli erstattet av B, B vil bli C, og så videre. Metoden er tilsynelatende oppkalt etter Julius Caesar, som tilsynelatende brukte den til å kommunisere med sine tjenestemenn.
For å chiffere en gitt tekst trenger vi derfor en heltallsverdi, kjent som et skift som indikerer antall posisjoner hver bokstav i teksten har blitt flyttet ned.
Krypteringen kan representeres ved hjelp av modulær aritmetikk ved først å transformere bokstavene til tall, i henhold til skjemaet, A = 0, B = 1,…, Z = 25. Kryptering av en bokstav ved et skift n kan beskrives matematisk som.
For eksempel, hvis skiftet er 3, vil bokstaven A bli erstattet med bokstaven D, B vil bli E, C vil bli F, og så videre. Alfabetet er viklet rundt slik at det etter Z starter tilbake på A.
Her er et eksempel på hvordan du bruker Cæsar-chifferet for å kryptere meldingen HELLO med et skifte på 3:

Skriv ned klartekstmeldingen: HEI
Velg en skiftverdi. I dette tilfellet vil vi bruke et skift på 3.
Erstatt hver bokstav i klartekstmeldingen med bokstaven som er tre posisjoner til høyre i alfabetet.

H blir K (skift 3 fra H)

E blir H (skift 3 fra E)

L blir O (skift 3 fra L)

O blir R (skift 3 fra O)

4. Den krypterte meldingen er nå KHOOR.

For å dekryptere meldingen trenger du ganske enkelt å flytte hver bokstav tilbake med samme antall posisjoner. I dette tilfellet vil du flytte hver bokstav i KHOOR tilbake med 3 posisjoner for å få den opprinnelige meldingen, HELLO.

E_n(x)=(x+n)mod 26
(Krypteringsfase med skift n)

D_n(x)=(x-n)mod 26
(Dekrypteringsfase med skift n)

Caesar Cipher 3

Eksempler:

 Text : ABCDEFGHIJKLMNOPQRSTUVWXYZ Shift : 23 Cipher : XYZABCDEFGHIJKLMNOPQRSTUVW Text : ATTACKATONCE Shift : 4 Cipher : EXXEGOEXSRGI

Fordeler:

Enkel å implementere og bruke, og gjør det egnet for nybegynnere å lære om kryptering.
Kan implementeres fysisk, for eksempel med et sett med roterende disker eller et sett med kort, kjent som en scytale, som kan være nyttig i visse situasjoner.
Krever bare et lite sett med forhåndsdelt informasjon.
Kan enkelt endres for å lage en sikrere variant, for eksempel ved å bruke flere skiftverdier eller nøkkelord.

Ulemper:

Den er ikke sikker mot moderne dekrypteringsmetoder.
Sårbar for kjente klartekstangrep, der en angriper har tilgang til både den krypterte og ukrypterte versjonen av de samme meldingene.
Det lille antallet mulige nøkler betyr at en angriper enkelt kan prøve alle mulige nøkler til den riktige er funnet, noe som gjør den sårbar for et brute force-angrep.
Det er ikke egnet for lang tekstkryptering, da det ville være lett å knekke.
Den er ikke egnet for sikker kommunikasjon da den lett brytes.
Gir ikke konfidensialitet, integritet og autentisitet i en melding.

Funksjoner av caesar cipher:

Substitusjons-chiffer: Cæsar-chifferet er en type substitusjons-chiffer, der hver bokstav i klarteksten erstattes av en bokstav et eller annet fast antall posisjoner nedover i alfabetet.
Fast nøkkel: Cæsar-chifferet bruker en fast nøkkel, som er antall posisjoner som bokstavene forskyves med. Denne nøkkelen er kjent for både avsender og mottaker.
Symmetrisk kryptering: Cæsar-chifferet er en symmetrisk krypteringsteknikk, noe som betyr at den samme nøkkelen brukes til både kryptering og dekryptering.
Begrenset tasterom: Cæsar-chifferet har et svært begrenset nøkkelrom på kun 26 mulige nøkler, da det kun er 26 bokstaver i det engelske alfabetet.
Sårbar for brute force-angrep: Cæsar-chifferet er sårbart for brute force-angrep, siden det bare er 26 mulige nøkler å prøve.
Enkel å implementere: Caesar-chifferet er veldig enkelt å implementere og krever bare enkle aritmetiske operasjoner, noe som gjør det til et populært valg for enkle krypteringsoppgaver.

Regler for Caesar Cipher:

Velg et tall mellom 1 og 25. Dette vil være din skiftverdi.
Skriv ned bokstavene i alfabetet i rekkefølge, fra A til Å.
Skift hver bokstav i alfabetet med skiftverdien. For eksempel, hvis skiftverdien er 3, vil A bli D, B blir E, C vil bli F, og så videre.
Krypter meldingen din ved å erstatte hver bokstav med den tilsvarende flyttede bokstaven. For eksempel, hvis skiftverdien er 3, vil ordet hei bli khoor.
For å dekryptere meldingen, reverser du prosessen ved å flytte hver bokstav tilbake med samme beløp. For eksempel, hvis skiftverdien er 3, vil den krypterte meldingen khoor bli hei.

Algoritme for Caesar Cipher:
Inndata:

Velg en skiftverdi mellom 1 og 25.
Skriv ned alfabetet i rekkefølge fra A til Å.
Opprett et nytt alfabet ved å flytte hver bokstav i det opprinnelige alfabetet med skifteverdien. For eksempel, hvis skiftverdien er 3, vil det nye alfabetet være:
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
D E F G H I J K L M N O P Q R S T U V W X Y Z A B C
Erstatt hver bokstav i meldingen med den tilsvarende bokstaven fra det nye alfabetet. For eksempel, hvis skiftverdien er 3, vil ordet hei bli khoor.
For å dekryptere meldingen, flytt hver bokstav tilbake med samme beløp. For eksempel, hvis skiftverdien er 3, vil den krypterte meldingen khoor bli hei.

Fremgangsmåte:

Gå gjennom den gitte teksten ett tegn om gangen.
For hvert tegn, transformer det gitte tegnet i henhold til regelen, avhengig av om vi krypterer eller dekrypterer teksten.
Returner den nye genererte strengen.

Et program som mottar en tekst (streng) og Shift-verdi (heltall) og returnerer den krypterte teksten.

C++

// A C++ program to illustrate Caesar Cipher Technique> #include> using> namespace> std;> // This function receives text and shift and> // returns the encrypted text> string encrypt(string text,> int> s)> {> > string result => ''> ;> > // traverse text> > for> (> int>

i = 0; i   // apply transformation to each character  // Encrypt Uppercase letters  if (isupper(text[i]))  result += char(int(text[i] + s - 65) % 26 + 65);  // Encrypt Lowercase letters  else  result += char(int(text[i] + s - 97) % 26 + 97);  }  // Return the resulting string  return result; } // Driver program to test the above function int main() {  string text = 'ATTACKATONCE';  int s = 4;  cout  < < 'Text : '  < < text;  cout  < < '
Shift: '  < < s;  cout  < < '
Cipher: '  < < encrypt(text, s);  return 0; }>

Java

//A Java Program to illustrate Caesar Cipher Technique> class> CaesarCipher> {> > // Encrypts text using a shift of s> > public> static> StringBuffer encrypt(String text,> int> s)> > {> > StringBuffer result=> new> StringBuffer();> > for> (> int> i=> 0>

; i  {  if (Character.isUpperCase(text.charAt(i)))  {  char ch = (char)(((int)text.charAt(i) +  s - 65) % 26 + 65);  result.append(ch);  }  else  {  char ch = (char)(((int)text.charAt(i) +  s - 97) % 26 + 97);  result.append(ch);  }  }  return result;  }  // Driver code  public static void main(String[] args)  {  String text = 'ATTACKATONCE';  int s = 4;  System.out.println('Text : ' + text);  System.out.println('Shift : ' + s);  System.out.println('Cipher: ' + encrypt(text, s));  } }>

Python3

#A python program to illustrate Caesar Cipher Technique> def> encrypt(text,s):> > result> => ''> > # traverse text> > for> i> in> range> (> len> (text)):> > char> => text[i]> > # Encrypt uppercase characters> > if> (char.isupper()):> > result> +> => chr> ((> ord> (char)> +> s> -> 65> )> %> 26> +> 65> )> > # Encrypt lowercase characters> > else> :> > result> +> => chr> ((> ord> (char)> +> s> -> 97> )> %> 26> +> 97> )> > return> result> #check the above function> text> => 'ATTACKATONCE'> s> => 4> print> (> 'Text : '> +> text)> print> (> 'Shift : '> +> str> (s))> print> (> 'Cipher: '> +> encrypt(text,s))>

C#

// A C# Program to illustrate Caesar Cipher Technique> using> System;> using> System.Text;> public> class> CaesarCipher> {> > // Encrypts text using a shift on s> > public> static> StringBuilder encrypt(String text,> int> s)> > {> > StringBuilder result=> new> StringBuilder();> > for> (> int>

i=0; i  {  if (char.IsUpper(text[i]))  {  char ch = (char)(((int)text[i] +  s - 65) % 26 + 65);  result.Append(ch);  }  else  {  char ch = (char)(((int)text[i] +  s - 97) % 26 + 97);  result.Append(ch);  }  }  return result;  }  // Driver code  public static void Main(String[] args)  {  String text = 'ATTACKATONCE';  int s = 4;  Console.WriteLine('Text : ' + text);  Console.WriteLine('Shift : ' + s);  Console.WriteLine('Cipher: ' + encrypt(text, s));  } } /* This code contributed by PrinciRaj1992 */>

PHP

 // A PHP program to illustrate Caesar // Cipher Technique // This function receives text and shift  // and returns the encrypted text function encrypt($text, $s) {  $result = '';  // traverse text  for ($i = 0; $i  >

Javascript

> //A Javascript Program to illustrate Caesar Cipher Technique> > > // Encrypts text using a shift on s> > function> encrypt(text, s)> > {> > let result=> ''> > for>

(let i = 0; i   {  let char = text[i];  if (char.toUpperCase(text[i]))  {  let ch = String.fromCharCode((char.charCodeAt(0) + s-65) % 26 + 65);  result += ch;  }  else  {  let ch = String.fromCharCode((char.charCodeAt(0) + s-97) % 26 + 97);  result += ch;  }  }  return result;  }    // Driver code  let text = 'ATTACKATONCE';  let s = 4;  document.write('Text : ' + text + ' ');  document.write('Shift : ' + s + ' ');  document.write('Cipher: ' + encrypt(text, s) + ' ');    // This code is contributed by avanitrachhadiya2155>

Produksjon

Text : ATTACKATONCE Shift: 4 Cipher: EXXEGOEXSRGI

Tidskompleksitet: O(N) hvor N er lengden på den gitte teksten
Ekstra plass: PÅ)

Hvordan dekryptere?
Vi kan enten skrive en annen funksjon som ligner på kryptering, som vil bruke det gitte skiftet i motsatt retning for å dekryptere den opprinnelige teksten. Imidlertid kan vi bruke den sykliske egenskapen til chifferen under modulo, derfor kan vi ganske enkelt observere

Cipher(n) = De-cipher(26-n)

Derfor kan vi bruke den samme funksjonen til å dekryptere, i stedet vil vi modifisere skiftverdien slik at skift = 26-skift (se dette for en prøvekjøring i C++).