kleines Verschlüsselungsprogramm

#22
@Boar

Ich habe auch Caesar in Java programmiert, ohne GUI nur als Konsole.
Ich habe ne Methode codieren geschrieben

Code:
public String codieren(String plainT, char key) {
  String cipher = "";
  int len = plainT.length();
  char plainCh;
  char ciphCh = ' ';
  for (int i = 0; i < len; i++) {
    plainCh = plainT.charAt(i);
    if ((plainCh >= 'A') && (plainCh <= 'Z')) {
      ciphCh = (char)(plainCh - 'A' + key)
      if(ciphCh > 'Z') {
        ciphCh = (char)(ciphCh - 'Z' - 1 + 'A');
      }
      cipher = cipher + ciphCh;
    }
  }
  return cipher;
}
Anstatt "char key" kannst du auch "int key" nehmen als Parameter
In der Methode werden nur die Großbuchstaben codiert. Zahlen, Leerzeichen und andere werden nicht codiert und weggelassen.
vor dem Aufruf der Methode den String in Großbuchtaben umformen mit toUpperCase
 
#23
so hab das ganze in php doch noch hingekriegt:

PHP:
<?php

function plain2caesar($input, $diff)
        {	
            $tmp = strtoupper($input);
            $signs = array("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");
            $anzahl = count($signs);

            for ($x = 0; $x < $anzahl ; $x++)
            {
                
                if ( ($x-$anzahl+$diff) >= 0 )
                {
                    $signs2[$signs{$x}] = $signs[$x-$anzahl+$diff];
                }
                else
                {
                    $signs2[$signs{$x}] = $signs[$x+$diff];
                }
            }
            
            print_r($signs2);
            
            $strRet = "";
            
            for($i = 0; $i < strlen($tmp); $i++)
            {
				if (in_array($tmp{$i}, $signs2))
				{
          			$strRet .= $signs2[$tmp{$i}];
				}
				else
				{
					$strRet .= $tmp{$i};
				}
            }
            
            return $strRet;
        }
?>
mfg
 
#24
Meine Version ist in C++ geschrieben und kann Files in Caesar ver- und enschlüsseln :]

edit: Hab noch eine Analyse-Funktion eingebaut, mit der man den Schlüssel einer Datei bestimmen kann

Code:
#include <iostream>
#include <string>
#include <fstream>

using namespace std;

int erkennen(string pfad){
    
    ifstream in;
    
    int out;
    int e_text;
    int temp=0;
    int zaehler=0;
    int e_deutsch=4;
    int text[26]={0};
    
    char zeichen;
    
    in.open(pfad.c_str(), ios_base::in);
        
    while(in.get(zeichen)){
                                
                                if(zeichen>96&&zeichen<123){
                                                            
                                                            text[zeichen-97]++;
                                                            zaehler++;
                                                                  
                                }else if(zeichen>64&&zeichen<91){
                                      
                                      text[zeichen-64]++;
                                      zaehler++;
                                            
                                }else{
                                      
                                }
                                
    }
          
    for(int i=0; i<=25; i++){
            
            if(temp<text[i]){
                             
                             temp=text[i];
                             e_text=i;
                             
            }
                  
    }
          
    if(e_text>=e_deutsch){
                          
                          out=e_text-e_deutsch;
                          
    }else{
          
          out=26-(e_deutsch-e_text);
             
    }
    
    in.close();
    
    return out;
    
}

int verschieben(char input, int inkey){
    
    int output;
    
    if(input>64&&input<91){
                           
                           if(input+inkey>90){
                                                     
                                                     output=(input+inkey)-26;
                                                     
                           }else{
                                 
                                 output=input+inkey;
                                                                   
                           }
                                                             
    }else if(input>96&&input<123){
          
          if(input+inkey>122){
                                       
                                       output=(input+inkey)-26;
                                                                   
          }else{
                
                output=input+inkey;
                                            
          }
                                      
    }else{
          
          output=input;
                                      
    }
    
    return output;
    
}

int main(){
    
    ifstream dat_ein;
    ofstream dat_aus; 
    
    string pfad;
    string crypt;
    string prefix;
    
    char key;
    char zeichen;
    char zeichen_crypt;
    
    int verschiebung;
    int modus;
    
    bool add;
    bool autom;

    cout << endl;
    cout << "--------------------------------" << endl;
    cout << "Ceasar-Verschl\x81 \bsselung by xsheep" << endl;
    cout << "--------------------------------" << endl;
    cout << "Wollen sie verschl\x81 \bsseln (1) oder entschl\x81 \bsseln (2) ? ";
    cin >> modus;
    
    if(modus==2){
                 
                 prefix="ent";
                 add=true;
                 
    }else{
          
          prefix="ver";
          add=false;
          
    }
    
    cout << "Bitte geben sie den Pfad des zu " << prefix << "schl\x81 \bsselnden Files ein : ";
    cin >> pfad;
    
    if(add){
            
            cout << "Wollen sie den Schl\x81 \bssel manuell eingeben (1) " << endl << "oder wollen Sie den Schl\x81 \bssel automatisch bestimmen lassen (2) ?" << endl;
            cin >> modus;
            
            if(modus==2){
                         
                         verschiebung=erkennen(pfad.c_str());
                         key=verschiebung+64;
                         verschiebung=26-verschiebung;
                         cout << "Ermittelter Schl\x81 \bssel : " << key << endl;
                         autom=true;
                         
            }else{
                  
                  autom=false;
                  
            }
            
            if(!autom){
                       
                       cout << "Bitte geben sie den Schl\x81 \bssel ein (A-X) : ";
                       cin >> key;
                       
            }
            
    }else{
          
    cout << "Bitte geben sie den Schl\x81 \bssel ein (A-X) : ";
    cin >> key;
    
    }
    
    if(add&&!autom){
            
            if(key>96&&key<123){
                                
                                verschiebung=26-(key-96);
                                
            }else if(key>64&&key<91){
                  
                  verschiebung=26-(key-64);
                  
            }else{
                  
                  verschiebung=1;
                  
            }
            
    }else if(!add){
          
          if(key>96&&key<123){
                              
                              verschiebung=key-96;
                              
          }else if(key>64&&key<91){
                
                verschiebung=key-64;
                
          }else{
                
                verschiebung=1;
                  
          }
          
    }
    
    dat_ein.open(pfad.c_str(), ios_base::in);
    dat_aus.open(pfad.c_str(), ios_base::in);
    
    if(!dat_ein||!dat_aus){
                     
                 cout << "File '" << pfad << "' konnte nicht ge\x94 \bffnet werden. Programm wird abgebrochen." << endl;
                 return -1;
                 
    }else{
          
          cout << "File wird gelesen und " << prefix << "schl\x81 \bsselt ..." << endl;
          
          while(dat_ein.get(zeichen)){
                                      
                                      zeichen_crypt=verschieben(zeichen,verschiebung);
                                      dat_aus << zeichen_crypt;
                                              
          }
          
          cout << "File erfolgreich " << prefix << "schl\x81 \bsselt. Programm wird beendet." << endl;
          cout << "--------------------------------";
          
    }

    dat_ein.close();
    dat_aus.close();
    
    return 0;
    
}
 
#25
hier in VB für Caesar Ver- und Entschlüsselung

Code:
Option Explizit

----------------------------
Private Sub cmdEntschlüsseln_Click()
 Dim UnverText As String, VerText, temp As String
 Dim Schlüssel, i As Integer
 Dim Länge, temp2 As Long
  
VerText = txtVerschlüsselt
 
 Schlüssel = txtSchlüssel
 
Länge = Len(VerText)

For i = 1 To Länge
    temp = Mid(VerText, i, 1)
    temp2 = Asc(temp)
    temp2 = temp2 - Schlüssel
        If temp2 < 32 Then
           temp2 = 255 - Schlüssel
        End If
    temp = Chr(temp2)
    UnverText = UnverText & temp
Next i

 txtUnverschlüsselt = UnverText
 txtVerschlüsselt = ""
 
End Sub

----------------------------
Private Sub cmdVerschlüsseln_Click()
 Dim UnverText As String, VerText, temp As String
 Dim Schlüssel, i As Integer
 Dim Länge, temp2 As Long
  
UnverText = txtUnverschlüsselt
 
 Schlüssel = txtSchlüssel
 
Länge = Len(UnverText)

For i = 1 To Länge
    temp = Mid(UnverText, i, 1)
    temp2 = Asc(temp)
    temp2 = temp2 + Schlüssel
        If temp2 > 255 Then
           temp2 = 32 + Schlüssel
        End If
    temp = Chr(temp2)
    VerText = VerText & temp
Next i

 txtVerschlüsselt = VerText
 txtUnverschlüsselt = ""
 
End Sub
 
#26
ich hab hier ein vigenere-code-decode programm geschrieben :
mit Haskell :


Code:
-- /etc/shadow --
-- Standardfunktionen importieren
import Char  (toUpper, toLower)
import Maybe (fromMaybe)
import List  (sortBy)
import IO

-- ------------------------ helper functions
-- alle Berechnung auf dem folgenden Alphabet
alphabet = ['A'..'Z'] :: String

-- relative Buchstabenhäufigkeit im Deutschen (bei Wikipedia gefunden)
deutsch = [('E', 0.1740),
           ('N', 0.0978),
           ('I', 0.0755),
           ('S', 0.0727),
           ('R', 0.0700),
           ('A', 0.0651),
           ('T', 0.0615),
           ('D', 0.0508),
           ('H', 0.0476),
           ('U', 0.0435),
           ('L', 0.0344),
           ('C', 0.0306),
           ('G', 0.0301),
           ('M', 0.0253),
           ('O', 0.0251),
           ('B', 0.0189),
           ('W', 0.0189),
           ('F', 0.0166),
           ('K', 0.0121),
           ('Z', 0.0113),
           ('P', 0.0079),
           ('V', 0.0067),
           ('J', 0.0027),
           ('Y', 0.0004),
           ('X', 0.0003),
           ('Q', 0.0002)] :: [(Char, Double)]

-- angepasste Version von isAlpha, die testet, ob ein Buchstabe in unserem Alphabet vorhanden ist
-- klein geschriebene Buchstaben sind auch akzeptabel
isAlpha' = flip elem $ alphabet ++ (map toLower alphabet)

-- entfernt alle komischen Zeichen aus einem String und wandelt den Rest in Grossbuchstaben um
prune = map toUpper . filter isAlpha'

-- sortiert eine Liste aufsteigend entsprechend der Funktionswerte von Funktion f
fsort  f = List.sortBy (\x y -> compare (f x) (f y))
-- macht das gleiche wie fsort, nur in absteigender Reihenfolge
fsort' f = reverse . fsort f

-- summiert die Funktionswerte von der Funktion f auf
fsum f = sum . (map f)

-- dividiert zwei Ganzzahlen
divide x y = fromIntegral x / fromIntegral y

-- ------------------------ text analysis
count :: String -> [(Char, Int)]
-- zählt, wie oft die Buchstaben in einem String vorkommen
count s = zip alphabet $ map (\x -> length $ filter (==x) s) alphabet

normalize :: [(Char, Int)] -> [(Char, Double)]
-- wandelt eine von count erstellte Liste in relative Werte um
normalize s = map (flip normalize' counter) s
                    where counter = fsum snd s

normalize' :: (Char, Int) -> Int -> (Char, Double)
-- normalisiert einen einzelnen Eintrag aus einer von count erstellten Liste
normalize' (s,i) n = (s, divide i n)

-- ------------------------ caesar
caesarEncode :: Char -> String -> String
-- verschlüsselt einen Text nach der Caesar-Methode
caesarEncode x y = substitute (prune y) (getCaesar x)
-- weil man es immer wieder mal braucht: mit verdrehten Argumenten
caesarEncode' = flip caesarEncode

substitute :: String -> [(Char, Char)] -> String
-- hat eine Liste von Ersetungen und führt sie auf einem String aus
substitute x y = map (\x -> fromMaybe x (lookup x y))  x

getCaesar :: Char -> [(Char, Char)]
-- erstellt die Liste der Caesar-Ersetzungen für eine gegebene Verschiebung
getCaesar x = zip alphabet $ dropWhile (/=x) $ cycle alphabet

-- ------------------------ vigenere
vigenere :: String -> String -> String
-- verschlüsselt einen Text nach der Vigenere-Methode. k wie key und d wie data...
vigenere k = zipWith (\k d -> head $ substitute [d] (getCaesar k)) (cycle k)

-- sichere Version von vigenere
vigenereEncode k d = vigenere (prune k) (prune d)
-- und auch hier nochmal geflipt
vigenereEncode'    = flip vigenereEncode

-- entschlüsseln eines mit vigenere verschlüsselten Text bei bekannter Passphrase
vigenereDecode k = vigenereEncode $ invertKey $ prune k
-- und wieder geflipt
vigenereDecode'  = flip vigenereDecode

-- Vigenere-Schlüssel invertieren
invertKey :: String -> String
invertKey = map (\x -> fromMaybe x $ lookup x $ zip y $ reverse y)
            where y = alphabet ++ [head alphabet]

-- ------------------------ übungsblatt
korrelationsfunktion :: String -> String -> Integer
-- Korrelation berechnen. an wievielen Stellen sind beide Strings gleich.
-- nein, das kann man nicht anders machen ;)
korrelationsfunktion = curry $ foldl (\s (x,y) -> if x == y then succ s else s) 0 . uncurry zip

zyklischeverschiebungen :: String -> [String]
-- alle zyklischen Verschiebungen eines Textes
-- die Mengenschreibweise ist zwar normal nicht mein Fall, aber hier ist sie sehr schnell (Ausführungsgeschwindigkeit)
zyklischeverschiebungen s = [(drop n s) ++ (take n s) | n <- [0..pred $ length s]] -- (so ähnlich im Forum gefunden ;))

autokorrelation :: String -> [(Integer, Integer)]
-- Autokorrelation eines Textes mit sich selbst. einfach gegen alle zyklischen Verschiebungen testen
autokorrelation x = zip [0..] $ map (korrelationsfunktion x) (zyklischeverschiebungen x)

-- ------------------------ entschlüsseln
passphraselength :: String -> [(Integer, Integer)]
-- Passphrase-Länge knacken. erst einmal die 25 Verschiebungen mit der besten Korrelation finden
passphraselength = fsort fst . take 25 . fsort' snd . autokorrelation

divCount :: [Integer] -> Integer -> Integer
-- Anzahl der Zahlen aus der Liste, die sich durch die Zahl teilen lassen
divCount x y = foldl (\s x -> if mod x y == 0 then succ s else s) 0 x 

goodDivisors :: [Integer] -> [Integer] -> [Integer]
-- die drei Zahlen aus der zweiten Liste, die die meisten Zahlen aus der ersten Liste teilen
goodDivisors x y = map fst $ take 3 $ fsort' snd $ zip y $ map (divCount x) y

-- above: PW length; below: PW text

split :: [a] -> Int -> [[a]]
-- in unserem Fall: die Buchstaben, die mit dem gleichen Caesar-Schlüssel verschlüsselt wurden zusammenpacken
-- kann man aber bestimmt auch noch andere tolle Dinge mit machen
split x n = foldl (\x (a,b) -> insert a b x) (replicate n []) indexed
            where indexed = zip x $ cycle [0..(n-1)]

insert :: a -> Int -> [[a]] -> [[a]]
-- für die split/insert-Aktion fiel mir nichts einfaches mit Higher-Level-Funktionen ein.
-- jedes Element wird in die vorgesehen Liste einsortiert
insert x 0 (a:b) = (x:a) : b
insert x n (a:b) = a : (insert x (n-1) b)

rateDecrypts :: String -> [(Char, Double)]
-- für einen String bewerten, wie "deutsch" eine Verschiebung ist
-- niedrieger Wert bedeutet, dass die Caesar-Verschlüsselung mit dieser Verschiebung einen besonders deutschen Text liefert
rateDecrypts str = zip (invertKey alphabet) (map undeutschness decs)
                   where decs = map (caesarEncode' str) alphabet

undeutschness :: String -> Double
-- checken, wie undeutsch ein Text ist
undeutschness = (unlikelihood deutsch) . normalize . count                   
   
unlikelihood :: [(Char, Double)] -> [(Char, Double)]  -> Double
-- checken, wie unterschiedlich zwei Buchstabenverteilungen sind
-- sehr ähnliche Verteilungen erzeugen KLEINE werte
unlikelihood d = fsum (\x -> (snd x - find (fst x) d) ^ 4 * 10000)

find :: Char -> [(Char, Double)] -> Double
-- relative Häufigkeit eines Buchstabens aus einer Verteilung heraussuchen
find = curry $ fromMaybe 0 . uncurry lookup

suggestKey :: [[(Char, Double)]] -> String
-- einen genauen Schlüssel vorschlagen (einfach immer den Buchstaben nehmen, der die niedrigste undeutschness hat)
suggestKey = map $ fst . head
-- ------------------------ program
-- Zahl einlesen (irgendwo im Netz gefunden)
readNumber = do line <- getLine
                readIO line

-- Hauptfunktion: erstmal einen Dateinamen erfragen und dann versuchen, sie zu knacken
main = do putStr "Please enter File to analyze:\n"
          filename <- getLine
          catch (
                 do inHandle <- openFile filename ReadMode
                    content' <- hGetContents inHandle
                   
                    let content = prune content' -- Datei einlesen und den String ggf. aufräumen
                    let len = passphraselength content -- die Passphrase-Länge errechen
                   
                    putStr "Processing... ... ... (may take a while, seriously doing sth now)\n"
                    putStr $ show len
                    putStr "\nPassphrase Length Cruncher thus suggests a Passphrase Length of:\n"
                    putStr $ show $ goodDivisors (drop 1 $ map fst len) [2..25]
                    putStr "\nPlease enter Passphrase Length:\n"
                    a <- readNumber
                   
                    let ana = map (take 5 . fsort snd . rateDecrypts) $ split content a -- Caesar-Brute-Force-Entschlüssöung auf die Sache ansetzen
                   
                    putStr "Processing... ... ... (may take a while, seriously doing sth now)\n"
                    putStr $ unlines $ map show ana
                    putStr "\nPassphrase Cruncher thus suggests a Passphrase of:\n"
                    putStr $ suggestKey ana
                    putStr "\nPlease enter Passphrase:\n"
                    key <- getLine
                    putStr $ vigenereDecode key content -- und zum Schluss noch einmal entschlüsseln
                    putStr "\nPress enter to exit:"
                    wait <- getLine
                   
                    hClose inHandle
                )
                (\_ -> putStr "ERROR: does not compute!" ) -- Fehler: bla
          putStr "\n"
 
#27
Ich hab das ganze jetzt in zwei Programme gepackt. Die Werte werden über die Bash mitgegeben (nur unter Linux getestet)

Code:
#include <iostream>

using namespace std;

int main(int argc, char* argv[]) {
    if(argc != 5) {
        cerr << "Usage: " << argv[0] << " [e|d] [r|a] key text" << endl << endl
             << "e(ncrypt), d(ecrypt)" << endl
             << "mode: Wenn der zu verschlüsselnde Wert länger ist als der Key..." << endl
             << "  r(epeat): wird der Key wiederholt" << endl
             << "  a(utokey): wird der Wert selbst an den Key angehängt (sicherer)" << endl
             << "example: " << argv[0] << " e a AKEY HALLO (returns HKPJV)" << endl;
        return -1;
    }

    int key_len = strlen(argv[3]);
    int txt_len = strlen(argv[4]);

    //string letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ";
    //int letters_len = 63;
    string letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    int letters_len = 26;
    int false_keys = 0;

    string out, out_key;

    for(int i=0; i<txt_len; i++)
    {
        char key;
        if(key_len > i) {
            key = argv[3][i-false_keys];
        }
        else if(argv[2][0] == 'r') {
             key = argv[3][i % key_len - false_keys];
        }
        else {
            key = argv[4][i-key_len-false_keys];
        }

        int cur_key = letters.find(toupper(key), 0);
        if(cur_key > letters_len) {
            false_keys++;
            continue;
        }

        int cur_letter = letters.find(toupper(argv[4][i]), 0);
        if(cur_letter > letters_len) continue;

        // Wenn encrypted werden soll, key addieren, sonst subtrahieren
        if(argv[1][0] == 'e') {
            cur_letter += cur_key;
            while(cur_letter > letters_len)
                cur_letter -= letters_len;
        }
        else {
            cur_letter -= cur_key;
            while(cur_letter < 0)
                cur_letter += letters_len;
        }

        out += letters[cur_letter];
        out_key += letters[cur_key];
    }
    cout << out << endl;
    cout << "KEY: " << out_key << endl;
}

Code:
#include <iostream>

using namespace std;

int main(int argc, char* argv[]) {
    if(argc < 3) {
        cerr << "Usage: " << argv[0] << " key text [sys]" << endl
                << "\texample: " << argv[0] << " 1 Hallo (returns Ibmmp)" << endl;
        return -1;
    }

    int key = atoi(argv[1]);
    int txt_len = strlen(argv[2]);

    string letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    int letters_len = 63;

    string out;

    for(int i=0; i<txt_len; i++)  {
        int cur_letter = letters.find(argv[2][i]);
        if(cur_letter > letters_len) continue;

        cur_letter += key;
        while(cur_letter > letters_len)
            cur_letter -= letters_len;

        out += letters[cur_letter];
    }
    cout << out << endl;
}
Beim Cäsar-Programm muss man einen negativen Wert angeben, um zu entschlüsseln.

EDIT:
Das ganze in JavaScript, allerdings nur die Vigenere-Lösung, da Vigenere ja eigentlich schon die Caesar-Verschlüsselung beherrscht:
Code:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <style language="text/css">
    body {
      font: 16px sans-serif;
      background-color: #eee;
    }

    #container {
      background-color: #fff;
      width: 700px;
      position: absolute;
      left: 50%;
      margin: 50px 0 50px -370px;
      padding: 20px;
    }

    h1 {
      font: 50px serif;
      text-align: center;
    }

    textarea, [type="text"] {
      border: 1px dashed #aaa;
      font-size: 16px;
    }

    textarea {
      width: 100%;
      height: 100px;
    }

    textarea:focus, [type="text"]:focus {
      background-color: #eef;
      border: 1px solid #aaa;
    }
    </style>

    <script language="JavaScript">
    function vigenere_en(uncrypted, key) {
        var crypted = "";
        uncrypted = onlyUpper(uncrypted);
        var myKey = onlyUpper(key);

        if(document.vigenere.selfKey.checked) {
            // Self-Key
            myKey += uncrypted;
        } else {
            // Repeat key
            var repeatKey = Math.floor(uncrypted.length / myKey.length);

            while(repeatKey > 0) {
                myKey += myKey;
                repeatKey--;
            }
        }

        var keyPos = 0;

        for(var i=0; i<uncrypted.length; i++) {
            var charCode = uncrypted.charCodeAt(i);
            var keyCode  = myKey.charCodeAt(keyPos);

            if(charCode >= 65 && charCode <= 91) {
                charCode += myKey.charCodeAt(keyPos)-65;
                while(charCode < 65) charCode += 26;
                while(charCode >= 91) charCode -= 26;
                crypted += String.fromCharCode(charCode);
                keyPos++;
            }
        }
        document.vigenere.fullKey.value = myKey;
        return crypted;
    }

    function vigenere_de(crypted, key) {
        var uncrypted = "";
        var myKey = onlyUpper(key);
        var keyPos = 0;
        crypted = onlyUpper(crypted);

        if(!(document.vigenere.selfKey.checked)) {
            // Repeat key
            var repeatKey = Math.floor(crypted.length / myKey.length);

            while(repeatKey > 0) {
                myKey += myKey;
                repeatKey--;
            }
        }

        for(var i=0; i<crypted.length; i++) {
            var charCode = crypted.charCodeAt(i);
            var keyCode  = myKey.charCodeAt(keyPos);

            charCode -= myKey.charCodeAt(keyPos)-65;

            while(charCode <= 65) charCode += 26;
            while(charCode >= 91) charCode -= 26;

            // Add char to solution string
            uncrypted += String.fromCharCode(charCode);

            // If selfkey method is used: add char also to key string
            if(document.vigenere.selfKey.checked) {
                myKey += String.fromCharCode(charCode);
            }

            keyPos++;
        }
        document.vigenere.fullKey.value = myKey;
        return uncrypted;
    }

    function onlyUpper(myText) {
        myText = myText.toUpperCase();
        var ret = "";

        for(var i=0; i<myText.length; i++) {
            var charCode = myText.charCodeAt(i);

            if(charCode >= 65 && charCode <= 91) {
                ret += String.fromCharCode(charCode);
            }
        }

        return ret;
    }

    function encode() {
        var uncrypted = document.vigenere.uncrypted.value;
        var key       = document.vigenere.key.value;
        var crypted   = vigenere_en(uncrypted, key);
        document.vigenere.crypted.value = crypted;
    }

    function decode() {
        var uncrypted = document.vigenere.uncrypted.value;
        var key       = document.vigenere.key.value;
        var crypted   = vigenere_de(uncrypted, key);
        document.vigenere.crypted.value = crypted;
    }

    function swap() {
        var tmp = document.vigenere.uncrypted.value;
        document.vigenere.uncrypted.value = document.vigenere.crypted.value;
        document.vigenere.crypted.value = tmp;
    }

    function clear_all() {
        if(confirm("Do you really want to clear the boxes?")) {
            document.vigenere.uncrypted.value = "";
            document.vigenere.crypted.value = "";
            document.vigenere.key.value = "";
            document.vigenere.fullKey.value = "";
        }
    }
    </script>

    <title>
      Vigenere Cipher
    </title>
  </head>
  <body>
    <div id="container">
      <h1>
        Vigenere Cipher
      </h1>
      <noscript>You have to enable JavaScript to use this tool</noscript>
      <form onsubmit="return false;" name="vigenere">
        <p>
          Input:<br />
          <textarea name="uncrypted" id="uncrypted">YOURTEXT</textarea>
        </p>
        <p>
          Key: <input type="text" id="key" value="ANYKEY" />
          <input type="checkbox" name="selfKey" checked="checked" />Self-Key
          <input type="button" value="encode" onmousedown="encode()" />
          <input type="button" value="decode" onmousedown="decode()" />
          <input type="button" value="swap" onmousedown="swap()" />
          <input type="button" value="clear" onmousedown="clear_all()" />
        </p>
        <p>
          Full key (only for debug purposes; don't enter any text):
          <input type="text" id="fullKey" value="" onkeydown="return false;" />
        </p>
        <p>
          Output:<br />
          <textarea name="crypted" id="crypted"></textarea>
        </p>
      </form>
    </div>
  </body>
</html>
 
#28
Hi Hackers, hier ist meine Lösung für Caesar und Vigenere, powered by Groovy :)

Code:
// ***** Caesar *****

String encodeCaesar(String text)
{
    return caesar(text, "A", "Z", { it.next() })    
}

String decodeCaesar(String text)
{
    return caesar(text, "Z", "A", { it.previous() })    
}

String caesar(String text, String START, String END, Closure move)
{
    return text.replaceAll("[A-Z]") { c -> 
        3.times {
            c = (c != END) ? move(c) : START
        }
        return c 
    }
}

println encodeCaesar("ABCZ")     // "DEFC"
println decodeCaesar("DEFC")     // "ABCZ"

// ***** Vigenere *****

charRange = "A".."Z"

String encodeVigenere(String text, String key)
{
    return vigenere(text, key, "A", "Z", { it.next() })
}

String decodeVigenere(String text, String key)
{
    return vigenere(text, key, "Z", "A", { it.previous() })
}

String vigenere(String text, String key, String START, String END, Closure move)
{
    char[] result = new char[text.size()]
    keySize = key.size()
    text.eachWithIndex { c, i ->
        keyChar = key[i % keySize]
        shift = charRange.indexOf(keyChar)
        shift.times {
            c = (c != END) ? move(c) : START
        }
        result[i] = c
    }
    return new String(result)
}

println encodeVigenere("GEHEIMNIS", "AKEY")  // "GOLCIWRGS"
println decodeVigenere("GOLCIWRGS", "AKEY")  // "GEHEIMNIS"
 
#30
Moin!

Hab das ganze nochmal in PHP geschrieben (ich bin gerade erst angefangen mit PHP, also nicht lachen;) )...

[HIDE]
PHP:
<html>
<body bgcolor="black" text= "white">

<font color="red">
<h1>
<u><b>Caesar De- and Encryption</b></u>
</h1>
</font>
<br>
<br>
<br>
<br>

<form method="GET">

	<font size=5>
		<p><u>Encryption</u></p>
	</font>

	<table>
	<tr>
		<td>
			String:
		</td>
		<td>
			<input type="text" name="string">
		</td>
	</tr>
	<tr>
		<td>
			Encryption-Key:
		</td>
		<td>
			<input type"text" name="key">
		</td>
	</tr>
	<tr>
		<td>
		</td>
		<td>
			<input type="submit" value="Encrypt!">
		</td>
	</tr>
</table>

</form>
				
<?PHP

$string = htmlentities(strtolower(trim($_GET['string'])));
$key = trim($_GET['key']);

$abc = array("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");

$zahl = array("a"=>0, "b"=>1, "c"=>2,"d"=>3,"e"=>4, "f"=>5, "g"=>6, "h"=>7, "i"=>8, "j"=>9,   "k"=>10, "l"=>11, "m"=>12, "n"=>13, "o"=>14, "p"=>15, "q"=>16, "r"=>17, "s"=>18, "t"=>19, "u"=>20, "v"=>21, "w"=>22, "x"=>23, "y"=>24, "z"=>25);


$length = strlen($string);

if( !is_numeric($key) || $key < 0 || $key > 26)
{
	echo "Bitte einen Schlüssel zwischen 0 und 26 eingeben!";
}

else
{
	for($i= 0; $i<$length; $i++)
	{
		$tmp = substr($string, $i, 1);
		$letter = $zahl[$tmp];
		$index = $letter + $key;
		if($index > 25 || $index < -25)
		{
			$index-=26;
		}
		$endString .= $abc[$index];

	}
	if($endString != "")
	{
		echo "Encrypted String:   <b>$endString</b>";
	}
}

?>





<form method="GET">

	<font size=5>
		<p><u>Decryption</u></p>
	</font>

	<table>
	<tr>
		<td>
			String:
		</td>
		<td>
			<input type="text" name="string1">
		</td>
	</tr>
	<tr>
		<td>
			Decryption-Key:
		</td>
		<td>
			<input type"text" name="key1">
		</td>
	</tr>
	<tr>
		<td>
		</td>
		<td>
			<input type="submit" value="Decrypt!">
		</td>
	</tr>
</table>

</form>
	
	<?PHP

$string = htmlentities(strtolower(trim($_GET['string1'])));
$key = trim($_GET['key1']);

$abc = array("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");

$zahl = array("a"=>0, "b"=>1, "c"=>2,"d"=>3,"e"=>4, "f"=>5, "g"=>6, "h"=>7, "i"=>8, "j"=>9,   "k"=>10, "l"=>11, "m"=>12, "n"=>13, "o"=>14, "p"=>15, "q"=>16, "r"=>17, "s"=>18, "t"=>19, "u"=>20, "v"=>21, "w"=>22, "x"=>23, "y"=>24, "z"=>25);


$length = strlen($string);

if(!is_numeric($key) ||$key < 0 || $key > 26)
{
	echo "Bitte einen Schlüssel zwischen 0 und 26 eingeben!";
}

else
{
	for($i= 0; $i<$length; $i++)
	{
		$tmp = substr($string, $i, 1);
		$letter = $zahl[$tmp];
		$index = $letter - $key;
		if($index > 25 || $index < -25)
		{
			$index-=26;
		}
		$endString1 .= $abc[$index];

	}
	if($endString1 != "")
	{
		echo "Decrypted String:   <b>$endString1</b>";
	}
}
?>
	


</body>
</html>
[/HIDE]




http://ad90.ad.funpic.de/Caesar-Code/Caesar.php
 
#31
frag mich nicht warum, hab mir den quellcode auch noch nicht angeschaut ^^ aber er lässt, wenn ich "wertwert" eingeb (Schlüssel 4) beim decodieren von "aivxaivx" das w einfach weg... beide male :(
 
#32
Also erstmal Hi @ All
bin Neu hier und das ist mein erster Post :D

Ich hab mal die Caesar in C++ geschrieben ich hab jetzt erst angefangen deswegen gehts wahrscheinlich
auch viel einfacher aber es funktioniert :D


Edit: Ich seh gerade das es manchmal abstürzt :(
 
#33
Hi, ich hab das ganze noma in c++ geschrieben, man kann die Datein und den Schluessel auch als argumente über die bash / cmd mit auf den weg geben weil ich im mom noch eine grafische "Oberfläche" dazu schreib und ich habe statt dem verschieben modulo genommen aber wenn man die ^ durch + / - ersätzt leufts aufs gleiche raus.
Einziges Problem ist das keine größeren datein gehen weil der long int der die datei größe "zählt" sonst platzt das muss ich noch umschreiben.
//auf win getestet sollte aber uebertragbar sein
Code:
#include <iostream>
#include <fstream>
#include <string>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

void replace(string& text,const string& fnd,const string& rep) 
{ 
  size_t pos = text.find(fnd); 
  while(pos!=string::npos) 
  { 
    text.replace(pos,pos+fnd.length(),rep); 
    pos = text.find(fnd,pos); 
  } 
}

unsigned long int lof(ifstream &f){     //Length Of File
unsigned long int d; 
f.seekg(0,ios::end);    //Zeiger ans Ende der Datei setzen 
d=f.tellg();            //Position des Zeigers auslesen  
f.seekg(0,ios::beg);    //Zeiger zum Anfang der Datei setzen  
return(d);
}



void fencrypt(std::ifstream& srcfile,std::ofstream& dstfile,char *key,bool log, const char *datei)
{
//cout<<"void";
int keypos = 0, strpos = 0,i,f;
char buf, str[lof(srcfile)+1000000];
cout<<"while";
while(!srcfile.eof())
{
str[strpos] = srcfile.get();
strpos++;
//cout<<"sa";
}
cout<<strpos;
cout<<" bytes zu verschluesseln\n";
f=strpos;
str[strpos] = '\0'; strpos = 0;
srcfile.close();
//cout<<str[strpos+1];
i=0;
while(i<f)
{
//cout<<"while";
if(key[keypos] == '\0') keypos = 0;
buf = key[keypos];
if(log){std::cout << "Verschluessel  \"" << str[strpos] << "\" mit  \"" << buf <<"\": ";}
//+
str[strpos] ^= (int)buf;
if(log){std::cout << str[strpos] <<std::endl;}
dstfile.put(str[strpos]);
strpos++; keypos++;i++; 
}
}














void fcrypt(std::ifstream& srcfile,std::ofstream& dstfile,char *key,bool log, const char *datei)
{
//cout<<"void";
int keypos = 0, strpos = 0,i,f;
char buf, str[lof(srcfile)+1000000];
//cout<<"while";
while(!srcfile.eof())
{
str[strpos] = srcfile.get();
strpos++;
//cout<<"sa";
}
cout<<strpos;
f=strpos;
str[strpos] = '\0'; strpos = 0;
cout<<" bytes zu verschluesseln\n";
srcfile.close();
cout<<str[strpos+1];
i=0;
while(i<f)
{
//cout<<"while";
if(key[keypos] == '\0') keypos = 0;
buf = key[keypos];
if(log){std::cout << "Entschluessel  \"" << str[strpos] << "\" mit \"" << buf <<"\": ";}
//-
str[strpos] ^= (int)buf;
if(log){std::cout << str[strpos] <<std::endl;}
dstfile.put(str[strpos]);
strpos++; keypos++;i++; 
}
}











int a, b, c, d, e, falsch, u;
ifstream dat_ein;
ofstream dat_aus;
string zeile, zneu, key, dat;
//char *datei;
char datei[110], adatei[110];
char ki[10000];
string ss, sc, sh;

int main (int argc, char *argv[]){
	u=0;
	//cout<<argc;
	if(argc==4){
		u=1;
		strcpy (datei, argv[1]);
		strcpy (adatei, argv[2]);
		key=argv[3];
	}
	if(argc>1&&argc<4){
		cout<<"Der Funktionsaufruf lautet: [datei], [ausgabedatei], [schluessel]\n";
	}
	if(u==0){
	cout<<"Bls Datei Verschluesselung version 2.0\nc by Moritz Hpkt alle Rechte vorbehalten \n";
	}
	e=1;
	while(e==1){
	falsch=0;	
	if(u==0){
	cout<<"1: Verschluesseln \n2: Entschluesseln\n";
	cin>>a;
	cout<<"datei:\n";
	cin>>datei;
	cout<<"ausgabe Datei (ein und ausgabe Datei dürfen nicht indentisch sein) :\n";
	cin>>adatei;
	}
	if(strcmp(datei, adatei) == 0){
		falsch=1;
	}
	if(falsch==0){
	dat_ein.open(datei, ios::binary);
	dat_aus.open(adatei, ios::binary);
	if(u==0){
	cout<<"key: \n";
	cin>>key;
	}
	strcpy (ki, key.c_str());
	//cout<<"char";
	if(a==1){
		fencrypt(dat_ein,dat_aus,ki, false, datei);
	}
	else
	{
		fcrypt(dat_ein,dat_aus,ki, false, datei);
	}

cout<<"Vorgang erfolgreich ausgabe datei:\n";
cout<<adatei;
	}
	else
	{
		cout<<"Der Vorgang wurde abgebrochen, ein und ausgabe Datei stimmten ueber ein";
	}
if(u==0){
cout<<"\n1: Weitere Dateien ver/entschluesseln\n0: beenden\n";	
cin>>e;	
}
else
{
	e=0;
}
	}
return 0;
}
 
Zuletzt bearbeitet:
#34
Nochmal C++^^

Code:
#include <iostream>
#include <string>
#include <fstream>

using namespace std;

int main()
{

    string Klartext;
    string Geheimtext;
    int Verschieben; 
    int Auswahl;
    int Laenge;
   
    ofstream Ausgabe;
    ifstream Einlesen;
    
    string Pfad_Einlesen;
    string Pfad_Ausgabe;
    
    string Text;
    

  cout <<"1. Verschlüßeln" << endl;
  cout <<"2. Entschlüßeln" << endl;
  cin >> Auswahl;
  
  switch(Auswahl)
  {
  case 1:
  
  cout <<"Geben sie den Pfad der Datei ein, die sie Verschlüßeln wollen";
  cout <<"\n(z.B. E:\\Hallo.txt):\t";
  cin >> Pfad_Einlesen;
  
  Einlesen.open(Pfad_Einlesen.c_str());

  
  while ( !Einlesen.eof() )
  { //Solange nicht das Ende der Datei(EOF) erreicht ist 
  Klartext.push_back( Einlesen.get() ); //Hänge an der string klartext den Buchstaben, den get() liefert an
  } 
  
  cout <<"\nUnd jetzt den Pfad der Datein, wo die Verschlüßelung stehen soll: \n";
  cin >> Pfad_Ausgabe;
  
  Ausgabe.open(Pfad_Ausgabe.c_str());
  
  cout <<"\nUm wie viele Stellen wollen sie die Buchstaben Verschieben?\n";
  cin >>  Verschieben;
  
  Laenge = Klartext.length();
    
    for(int i = 0; i <= Laenge - 1 ; i++)
    {
          if(i == Laenge - 1) break;
          
          Geheimtext[i] = Klartext[i];
          Geheimtext[i] += Verschieben;
    }
    
    cout <<"Jetzt kommt die Verschlüßelung: \n\n";
    
    for(int i = 0; i <= Laenge - 1; i++)     
    {
            cout << Geheimtext[i];
            Ausgabe << Geheimtext[i] ;
    }
    
    cout << Geheimtext;
    
    Ausgabe.close();
    Einlesen.close();
    break;
    
    case 2:
         
  cout <<"Geben sie den Pfad der Datei ein, die sie Entschlüßeln wollen";
  cout <<"\n(z.B. E:\\Hallo.txt):\t";
  cin >> Pfad_Einlesen;
  
  Einlesen.open(Pfad_Einlesen.c_str());

  
  while ( !Einlesen.eof() )
  { //Solange nicht das Ende der Datei(EOF) erreicht ist 
  Klartext.push_back( Einlesen.get() ); //Hänge an der string klartext den Buchstaben, den get() liefert an
  } 
  
  cout <<"\nUnd jetzt den Pfad der Datein, wo die Verschlüßelung stehen soll: \n";
  cin >> Pfad_Ausgabe;
  
  Ausgabe.open(Pfad_Ausgabe.c_str());
  
  cout <<"\nUm wie viele Stellen wollen sie die Buchstaben zurückschieben?\n";
  cin >>  Verschieben;
  
    Laenge = Klartext.length();
    
    for(int i = 0; i <= Laenge - 1 ; i++)
    {
          if(i == Laenge - 1) break;
          
          Geheimtext[i] = Klartext[i];
          Geheimtext[i] -= Verschieben;
    }
    
    cout <<"Jetzt kommt die Verschlüßelung: \n\n";
    
    for(int i = 0; i <= Laenge - 1; i++)     
    {
            cout << Geheimtext[i];
            Ausgabe << Geheimtext[i] ;
    }
    
    cout << Geheimtext;
    
    Ausgabe.close();
    Einlesen.close();
    break;
    
   case 3:
        
  cout <<"\n(z.B. E:\\Hallo.txt):\t";
  cin >> Pfad_Einlesen;
  
  Einlesen.open(Pfad_Einlesen.c_str());

  
  while ( !Einlesen.eof() )
  { //Solange nicht das Ende der Datei(EOF) erreicht ist 
  Klartext.push_back( Einlesen.get() ); //Hänge an der string klartext den Buchstaben, den get() liefert an
  } 
  
  cout <<"\nUnd jetzt den Pfad der Datein, wo die Verschlüßelung stehen soll: \n";
  cin >> Pfad_Ausgabe;
  
  Ausgabe.open(Pfad_Ausgabe.c_str());
   
  Verschieben = 0;
  
    Laenge = Klartext.length();
    
    for(int i = 0; i <= Laenge - 1 ; i++)
    {
          
          if(i == Laenge - 1) break;
          
          Geheimtext[i] = Klartext[i];
          Geheimtext[i] -= Verschieben;
    
    }
    
    cout <<"Jetzt kommt die Verschlüßelung: \n\n";
    
    for(int i = 0; i <= Laenge - 1; i++)     
    {
            cout << Geheimtext[i];
            Ausgabe << Geheimtext[i] ;
    }
    
    cout << Geheimtext;
    
    Ausgabe.close();
    Einlesen.close();
    break;
  
   }
   
   
          
    
int ENDE;
cin >> ENDE;
return 0;
}
 
#35
Code:
$ perl -ne 'BEGIN{map{$R{++$j}=$_;$H{$_}=$j if$j<28}(a..z)x2}chomp;for(split//){$_=$R{$H{lc()}+13};print}'
Newlines und Leerzeichen werden ignoriert. (Respektive eigentlich werden nur Newlines ignoriert, Leerzeichen werden zu "m". (13. Buchstabe des Alphabets.))
Da sag noch mal einer prel wäre linenoise!
PREL!!!1
 
#36
Ich hab' die Cäsar-Verschlüsselung mal vor 'ner Zeit zur Übung als Klasse in C++ geschrieben. Bei 'ner Verschlüsselung ohne Schlüsselangabe wird einfach die Länge des Strings als Schlüssel genommen.
Damit hab' ich mir damals Überladung von Funktionen beigebracht :)

Code:
#include <string>

using std::string;

///Klasse um ein einzelnes Wort mit dem Caesarchiffre zu verschluesseln

/**
* Einer Instanz dieser Klasse kann ein string uebergeben werden, welcher
* danach mithilfe der Methoden 'encode()' und 'decode()' ver- und entschluesselt
* werden kann. Nach der Instanzierung ist der String leer.
*/
class cesar
{

private:
        /// Variable, die den aktuellen string haelt.
        /**
        * Die Variable 'phrase' hält den aktuellen string, egal ob
        * verschluesselt oder unverschluesselt. In welchem Zustand sich der
        * String befindet wird in der Variable 'code_status' festgehalten
        */
        string phrase;
        /// Enthaelt die Länge der Variable 'phrase'
        int length;
        /// Unterscheidet zwischen ver- und entschluesseltem String
        /**
        * Wenn code_status den Wert 1 hat, dann ist 'string' verschluesselt
        * Wenn code_status den Wert 0 hat, dann ist 'string' entschluesselt
        */
        bool code_status;
        /// Konstanten für 'code_status'
        static const bool ENCODED = true;
        static const bool DECODED = false;

public:
       /// Setzt einen neuen Wert als string
       /**
       * Mithilfe dieser Methode kann entweder ein neuer zu verschluesselnder 
       * String angegeben werden oder aber ein zu entschluesselnder String
       */
       void setphrase(string newphrase)
       {
            phrase = newphrase;
            length = (int)phrase.length();
            code_status = DECODED;
       }

       /// Gibt den aktuellen String zurueck
       /**
       * Gibt den aktuell gespeicherten String zurueck. Ob dieser ver- oder
       * entschluesselt ist, kann mithilfe der Methode isencoded() abgefragt
       * werden.
       */
       string getphrase()
       {
              return phrase;
       }

       /// Liefert den Status des Strings zurueck
       /**
       * Gibt den aktuellen Kodierungsstatus des Strings zurueck,
       * der mithilfe der Methode getphrase() abgefragt werden kann.
       */
       bool isencoded()
       {
        return code_status;
       }

       /// Verschluesselt den aktuellen String
       /**
       * Wird kein Schluesselwert in Form
       * eines Integers uebergeben, so wird die Laenge des Strings als
       * Schluesselwert benutzt. Ausserdem wird ueberprueft, ob der String
       * bereits als verschluesselter Text vorliegt. Ist dies der Fall, so
       * bleibt dieser unveraendert. Somit kann keine doppelte Verschluesse-
       * lung realisiert werden.
       */
       void encode()
       {
        if(code_status==DECODED)
        {
          int ASCII[255];
          int newASCII;
          
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Array mit ASCII-Werten der Zeichen fuellen
              ASCII[recentLetter-1]=(int)phrase[recentLetter-1];
          }
          
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Wenn es sich um einen Buchstaben handelt, wird er verschluesselt
              if((ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123)
                 ||(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91))
              newASCII = ASCII[recentLetter-1]+length;
              // Ansonsten wird nichts veraendert
              else newASCII = ASCII[recentLetter-1];
              // Fängt ASCII-Werte groesser als Z/z ab und beginnt
              // wieder bei A/a
              // Wenn es sich um Kleinbuchstaben handelt, ist 122 der Grenzwert
              if(ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123
                 &&newASCII>122)
                               newASCII=newASCII-26;
              // Wenn es sich um Kleinbuchstaben handelt, ist 90 der Grenzwert
              if(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91
                 &&newASCII>90)
                               newASCII=newASCII-26;
              // ASCII-Wert wird wieder in Char umgewandelt
              phrase[recentLetter-1]=(char)newASCII;
          }
          code_status = ENCODED;
        }
       }

       /// Entschluesselt den aktuellen String
       /**
       * Wird kein Schluesselwert in Form
       * eines Integers uebergeben, so wird die Laenge des Strings als
       * Schluesselwert benutzt. Ausserdem wird ueberprueft, ob der String
       * bereits als entschluesselter Text vorliegt. Ist dies der Fall, so
       * bleibt dieser unveraendert. Somit kann keine doppelte Entschluesse-
       * lung realisiert werden.
       */
       void decode()
       {
        if(code_status==ENCODED)
        {
          int ASCII[255];
          int newASCII;
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Array mit ASCII-Werten der Zeichen füllen
              ASCII[recentLetter-1]=(int)phrase[recentLetter-1];
          }
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Wenn es sich um einen Buchstaben handelt, wird er verschluesselt
              if((ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123)
                 ||(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91))
              newASCII = ASCII[recentLetter-1]-length;
              // Ansonsten wird nichts veraendert
              else newASCII = ASCII[recentLetter-1];
              // Fängt ASCII-Werte kleiner als A/a ab und beginnt
              // wieder bei Z/z
              // Wenn es sich um Kleinbuchstaben handelt, ist 96 der Grenzwert
              if(ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123
                 &&newASCII<96)
                               newASCII=newASCII+26;
              // Wenn es sich um Kleinbuchstaben handelt, ist 64 der Grenzwert
              if(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91
                 &&newASCII<64)
                               newASCII=newASCII+26;
              // ASCII-Wert wird wieder in Char umgewandelt
              phrase[recentLetter-1]=(char)newASCII;
          }
          code_status = DECODED;
        }
       }
       
       /// Verschluesselt den aktuellen String
       /**
       * Der Parameter 'key' gibt den
       * Schluesselwert an. Ausserdem wird ueberprueft, ob der String
       * bereits als verschluesselter Text vorliegt. Ist dies der Fall, so
       * bleibt dieser unveraendert. Somit kann keine doppelte Verschluesse-
       * lung realisiert werden.
       */
       void encode(int key)
       {
        if(code_status==DECODED)
        {
          int ASCII[255];
          int newASCII;

          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Array mit ASCII-Werten der Zeichen fuellen
              ASCII[recentLetter-1]=(int)phrase[recentLetter-1];
          }

          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Wenn es sich um einen Buchstaben handelt, wird er verschluesselt
              if((ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123)
                 ||(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91))
              newASCII = ASCII[recentLetter-1]+key;
              // Ansonsten wird nichts veraendert
              else newASCII = ASCII[recentLetter-1];
              // Fängt ASCII-Werte groesser als Z/z ab und beginnt
              // wieder bei A/a
              // Wenn es sich um Kleinbuchstaben handelt, ist 122 der Grenzwert
              if(ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123
                 &&newASCII>122)
                               newASCII=newASCII-26;
              // Wenn es sich um Kleinbuchstaben handelt, ist 90 der Grenzwert
              if(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91
                 &&newASCII>90)
                               newASCII=newASCII-26;
              // ASCII-Wert wird wieder in Char umgewandelt
              phrase[recentLetter-1]=(char)newASCII;
          }
          code_status = ENCODED;
        }
       }

       /// Entschluesselt den aktuellen String
       /**
       * Der Parameter 'key' gibt den
       * Schluesselwert an. Ausserdem wird ueberprueft, ob der String
       * bereits als entschluesselter Text vorliegt. Ist dies der Fall, so
       * bleibt dieser unveraendert. Somit kann keine doppelte Entschluesse-
       * lung realisiert werden.
       */
       void decode(int key)
       {
        if(code_status==ENCODED)
        {
          int ASCII[255];
          int newASCII;
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Array mit ASCII-Werten der Zeichen füllen
              ASCII[recentLetter-1]=(int)phrase[recentLetter-1];
          }
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Wenn es sich um einen Buchstaben handelt, wird er verschluesselt
              if((ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123)
                 ||(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91))
              newASCII = ASCII[recentLetter-1]-key;
              // Ansonsten wird nichts veraendert
              else newASCII = ASCII[recentLetter-1];
              // Fängt ASCII-Werte kleiner als A/a ab und beginnt
              // wieder bei Z/z
              // Wenn es sich um Kleinbuchstaben handelt, ist 96 der Grenzwert
              if(ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123
                 &&newASCII<96)
                               newASCII=newASCII+26;
              // Wenn es sich um Kleinbuchstaben handelt, ist 64 der Grenzwert
              if(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91
                 &&newASCII<64)
                               newASCII=newASCII+26;
              // ASCII-Wert wird wieder in Char umgewandelt
              phrase[recentLetter-1]=(char)newASCII;
          }
          code_status = DECODED;
        }
       }
};
 
#37
Zwar schon älter hier aber ich habe auch mal ein kleine, zwar nicht sehr professionelle oder umfangreiche lösung für mich gefunden (C++):

Code:
#include <cstdlib>
#include <iostream>

using namespace std;

void caesar(char cha[], int schlussel);                 // Mache caesar bekannt

int main()
{
 char ch[50] = {'\0'};                                   // 50x leer
 int key = 0;
 
 cout << "*******************************\n";
 cout << "* Caesar Schiffre by Cr4ckEye *\n";           // Ausgaben
 cout << "*******************************\n\n" << endl;
 cout << "Bitte geben Sie einen Text ein: ";
 cin.getline(ch, 50);                                  // Max 50 Zeichen mit Whitespace
 do
 {
 cout << "Bitte geben Sie den Schluessel ein: ";       
 cin >> key;
 } while(key<=0 && key>=26);                           // Key nicht größer als 25
 cout << "\nVerschluesselt: ";
 caesar(ch, key);                                      // Ver und Entschlüsseln
 cin.get();                                            // Halte Fenster offen
 cin.get();
}

void caesar(char cha[], int schlussel)
{
     for(int i=0; i<50; ++i)                          // Verschlüsselung
     {
     if(cha[i] == '\0') break;                        // 0 Terminator -> Ende
      while(cha[i] == 32)                             // Whitespace ausgeben
      { cout << " "; ++i; }                           
      cha[i] = toupper(cha[i])+schlussel;    // Zu Großbuchstabe und Berechnung
      cout << cha[i];                                 // Ausgabe
     }
     
     cout << "\n\nEntschluesselt: ";                  // Entschlüsselung
     
     for(int j=0; j<50; ++j)                          
     {
     if(cha[j] == '\0') break;                        // 0 Terminator -> Ende
      while(cha[j] == 32)                             // Whitespace ausgeben
      { cout << " "; ++j; }
      cha[j] = cha[j]-(schlussel*2);                  // Konvertrierung und Berechnung (schlussel*2), 
                                                      // da er vorher ja nocheinmal um den selben Schlüssel verschoben wurde.
      cout << cha[j];                                 // Ausgabe
     }
}
 
#38
So hab das ganze mal als Handy-Application(JAVA ME)
13 ist der Standardkey damit kann man En- und decrypten mit nur einer Methode.

Code:
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;

public class CryptIt extends MIDlet implements CommandListener 
{
	private Display display;
	private Form form = new Form("Crypt IT");
	private Command crypt = new Command("Crypt", Command.SCREEN, 1);
	private Command exit = new Command("Exit", Command.EXIT, 1);
	private TextField textfield = new TextField("Standardkey 13:", "", 50, TextField.ANY);

	public static String cryptit( String s )
	{
    	StringBuffer ergebnis = new StringBuffer();
		int key=13;
		
   	 	for( int i = 0; i < s.length(); i++ )
    	{
      		int c = s.charAt( i );

      		if ( (c >= 'A') && (c <= 'z') ) 
      		{
        		c += key;
        		if( c > 'z' )
          		c = 'a' + c % 'z' -1;
        		if( (c > 'Z') && (c < 'a') ) 
          		c = 'A' + c % 'Z' - 1;
      		}
      		ergebnis.append( (char) c );
    	}
    
    	return ergebnis.toString();
  	} 
  
	public CryptIt() 
	{
    	display = Display.getDisplay(this);
    	form.addCommand(exit);
    	form.addCommand(crypt);
    	form.append(textfield);
    	form.setCommandListener(this);
  	}

	public void startApp() 
	{
    	display.setCurrent(form);
 	}

  	public void pauseApp() 
  	{
 	}

	public void destroyApp(boolean unconditional) 
	{
 	}

	public void commandAction(Command command, Displayable displayable) 
	{
    	if (command == crypt) 
    	{
      		String textin = textfield.getString();
      		String encrypt = cryptit(textin);
      
      		textfield.setString(encrypt);
    	} else if (command == exit) 
    	{
      		destroyApp(false);
      		notifyDestroyed();
    	}
  	}
}
 
#39
So ich habe nun auch mal aus Übungszwecken ein Caesar Verschlüsselungsprogramm in Java geschrieben :>
Man muss eine Quell und eine Zieldatei angeben und dann wird es ja nach Wahl ver- oder entschlüsselt.
Es ist noch in der Testphase daher ein wenig verbuggt , es werden manche Zeichen bei der entschlüsselung falsch interpretiert.
Leider ist es auf Konsoleneben aber wenn der Code soweit in Ordnung ist werde ich mich mal an eine GUI wagen :)
So ein kleines "Projekt" ist echt super zum üben.

Sind ein paar mehr Dateien, daher Caesar.rar
 
#40
Caesar & Vigenere in Python:

Code:
chars = [ chr(n) for n in range(65,91) ]

# Caesar
def caesar(text, shift, dec=1):
    return "".join([ chars[(ord(c)-65+(dec*shift))%26] for c in text ])

# Vigenere
def encodeVigenere(text, key, dec=1, idx=0, result=""):
    for c in text:
        result += chars[ (ord(c)-65+(dec*chars.index(key[idx])))%26 ]
        idx = (idx + 1) % len(key)
    return result

if __name__ == '__main__':
    print caesar("FELIX", 3)
    print caesar("IHOLA", 3, -1)
    
    print encodeVigenere("GEHEIMNIS", "AKEY")
    print encodeVigenere("GOLCIWRGS", "AKEY", -1)
Gruß
Felix
 
Oben