Vigenère cipher/Cryptanalysis: Difference between revisions

* Use that key to decrypt and output the original plaintext. Maintaining the whitespace from the ciphertext is optional.

* The algorithm doesn't have to be perfect (which may not be possible) but it should work when given enough ciphertext. The example above is fairly long, and should be plenty for any algorithm.

=={{header|Ada}}==

The program is not fully auto, but makes a small number of suggestions for the right key and plaintext.

 

procedure Vignere_Cryptanalysis is

end;

end loop;

 

=={{header|C}}==

This finds the right key (I think, I didn't try to decode it after getting the key). The program is not fully auto, but by its output, the result is pretty obvious.

#include <stdlib.h>

#include <string.h>

 

return 0;

 

=={{header|C++}}==

Not guaranteed to give a 100% correct answer, but it works here. Requires C++0x.

 

#include <string>

#include <vector>

cout << "Key: " << output.second << endl << endl;

cout << "Text: " << output.first << endl;

 

=={{header|D}}==

{{trans|C++}}

std.array, std.numeric, std.ascii;

 

 

static double correlation(in string txt, in double[] sTargets)

uint[nAlpha] charCounts = 0;

foreach (immutable c; txt)

}

 

auto freqs = new Tuple!(char,"c", uint,"d")[nAlpha];

foreach (immutable i, immutable c; std.ascii.uppercase)

 

static string[2] decode(in string cleaned, in string key)

string decoded;

foreach (immutable i, immutable c; cleaned)

static size_t findBestLength(in string cleaned,

in double[] sTargets)

size_t bestLength;

double bestCorr = -100.0;

 

static string findKey(in string cleaned, in size_t bestLength,

auto pieces = new string[bestLength];

foreach (immutable i, immutable c; cleaned)

immutable cleaned = input.toUpper.removechars("^A-Z");

 

immutable sortedTargets = targetFreqs.dup.sort().release.idup;

 

immutable key_dec = vigenereDecrypt(englishFrequences, encoded);

writefln("Key: %s\n\nText: %s", key_dec[0], key_dec[1]);

{{out|Output (cut)}}

<pre>Key: THECHESHIRECAT

 

Text: THISWASTHEPOEMTHATALICEREADJABBERWOCKYTWASBRILLIGANDTHESLITHY...</pre>

 

=={{header|Python}}==

{{trans|D}}

from operator import itemgetter

 

print "\nText:", decoded

 

 

=={{header|Racket}}==

This is a simple method that just tries to find a key of any length that minimizes the difference from the expected English character distributions.

 

#lang at-exp racket

 

(display (integer->char (+ first-char (decode-num n))))))

(newline)

 

Output:

This is an attempt at following the [http://en.wikipedia.org/wiki/Index_of_coincidence#Example Wikipedia] description. However, it performs just as well as the simple version. Most likely because I know almost nothing about cryptography...

 

#lang at-exp racket

 

(display (integer->char (+ first-char (decode-num n))))))

(newline)

 

=={{header|Tcl}}==

{{trans|Python}}

 

oo::class create VigenereAnalyzer {

return [my GetKeyFromFreqs $freqs]

}

Demonstration (that assumes that the Tcl solution to [[Vigenère cipher#Tcl|Vigenère cipher]] task is present):

MOMUD EKAPV TQEFM OEVHP AJMII CDCTI FGYAG JSPXY ALUYM NSMYH

VUXJE LEPXJ FXGCM JHKDZ RYICU HYPUS PGIGM OIYHF WHTCQ KMLRD

set decoded [decoder decrypt $encoded]

puts "Key: $key"

 

=={{header|Vedit macro language}}==

If this does not solve some encrypted text, you could increase the number of key combinations to be checked.

 

 

Chdir(PATH_ONLY)

BOL

#37 = Search_Block("|V", Cur_Pos, EOL_Pos, ALL+NOERR)