Vigenère cipher/Cryptanalysis: Difference between revisions

{{trans|Python}}

F vigenere_decrypt(target_freqs, input)

V (key, decoded) = vigenere_decrypt(english_frequences, encoded)

print(‘Key: ’key)

{{out}}

=={{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;

immutable key_dec = vigenereDecrypt(englishFrequences, encoded);

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

{{out|Output (cut)}}

<pre>Key: THECHESHIRECAT

=={{header|Go}}==

{{trans|Kotlin}}

import (

fmt.Println("\nBest key :", bestKey)

fmt.Printf("\nDecrypted text:\n%s\n", decrypt(enc, bestKey))

{{out}}

=={{header|Haskell}}==

import Data.List(transpose, nub, sort, maximumBy)

import Data.Ord (comparing)

\BXVCB XBAWG LQKCM ICRRX MACUO IKHQU AJEGL OIJHH XPVZW JEWBA\

\FWAML ZZRXJ EKAHV FASMU LVVUT TGK\

{{out}}

<pre style="font-size:80%">

{{trans|C}}

static String encodedMessage =

"MOMUD EKAPV TQEFM OEVHP AJMII CDCTI FGYAG JSPXY ALUYM NSMYH VUXJE LEPXJ FXGCM JHKDZ RYICU HYPUS PGIGM OIYHF WHTCQ KMLRD ITLXZ LJFVQ GHOLW CUHLO MDSOE KTALU VYLNZ RFGBX PHVGA LWQIS FGRPH JOOFW GUBYI LAPLA LCAFA AMKLG CETDW VOELJ IKGJB XPHVG ALWQC SNWBU BYHCU HKOCE XJEYK BQKVY KIIEH GRLGH XEOLW AWFOJ ILOVV RHPKD WIHKN ATUHN VRYAQ DIVHX FHRZV QWMWV LGSHN NLVZS JLAKI FHXUF XJLXM TBLQV RXXHR FZXGV LRAJI EXPRV OSMNP KEPDT LPRWM JAZPK LQUZA ALGZX GVLKL GJTUI ITDSU REZXJ ERXZS HMPST MTEOE PAPJH SMFNB YVQUZ AALGA YDNMP AQOWT UHDBV TSMUE UIMVH QGVRW AEFSP EMPVE PKXZY WLKJA GWALT VYYOB YIXOK IHPDS EVLEV RVSGB JOGYW FHKBL GLXYA MVKIS KIEHY IMAPX UOISK PVAGN MZHPW TTZPV XFCCD TUHJH WLAPF YULTB UXJLN SIJVV YOVDJ SOLXG TGRVO SFRII CTMKO JFCQF KTINQ BWVHG TENLH HOGCS PSFPV GJOKM SIFPR ZPAAS ATPTZ FTPPD PORRF TAXZP KALQA WMIUD BWNCT LEFKO ZQDLX BUXJL ASIMR PNMBF ZCYLV WAPVF QRHZV ZGZEF KBYIO OFXYE VOWGB BXVCB XBAWG LQKCM ICRRX MACUO IKHQU AJEGL OIJHH XPVZW JEWBA FWAML ZZRXJ EKAHV FASMU LVVUT TGK";

}

=={{header|Julia}}==

const ciphertext = filter(isalpha, """

MOMUD EKAPV TQEFM OEVHP AJMII CDCTI FGYAG JSPXY ALUYM NSMYH

gc()

t = @elapsed cryptanalyze(ciphertext)

{{out}}

{{trans|C}}

This is a reasonably faithful translation of the C entry though I've restricted the key lengths examined to 26 to automatically produce the correct key and hence decrypted text. This is because the C entry examines key lengths up to 29 and a value of 28 gives a slightly better fit even though the key produced (THECHESCIRECATTHECHESHIRECAT) and resulting text don't make as much sense and so would be rejected if one were examining the candidate keys manually.

val encoded =

println("Best key : $bestKey")

println("\nDecrypted text:\n${decrypt(enc, bestKey)}")

{{out}}

{{trans|Phix}}

This is a translation of Julia algorithm with some ideas from Phix translation.

const

echo "key: ", key, '\n'

echo dec, '\n'

{{out}}

Uses the Vigenere decrypt function from the Vigenere task solution (not included in the code below).

{{works with|OCaml|above 4.05}}

(* Task : Vigenere cipher/Cryptanalysis *)

Printf.printf "Key: %s\n\nText: %s" key pt

;;

{{out}}

<pre>

=={{header|Perl}}==

use warnings;

use feature 'say';

"Key length " . length($key) . "\n" .

"Plaintext " . substr(mycrypt($text, $key), 0, 80) . "...\n";

{{out}}

=={{header|Phix}}==

{{trans|Julia}}

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Cryptanalysis.exw

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>

{{Out}}

<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|Raku}}==

(formerly Perl 6)

{{trans|Perl}}

constant %English-letter-freq = (

E => 12.70, L => 4.03, Y => 1.97, P => 1.93, T => 9.06, A => 8.17, O => 7.51, I => 6.97, N => 6.75,

"Key length {$key.chars}\n" ~

"Plaintext {substr(mycrypt($cipher-text, $key), 0, 80)}...\n";

{{out}}

<pre>Key THECHESHIRECAT

{{trans|Kotlin}}

Note that the character to/from byte ('''u8''') conversions work here only because the key and cryptogram are composed of ASCII characters only. Indeed, Rust's '''char''' type is a ''Unicode scalar value'', how they are represented is well summarized in the Rust book's [https://doc.rust-lang.org/std/primitive.char.html subchapter on strings].

use std::iter::FromIterator;

println!("\nDecrypted text:\n{}", decrypt(&enc, &best_key));

}

{{out}}

<pre>

=={{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)

=={{header|Vlang}}==

{{trans|Go}}

const encoded =

"MOMUD EKAPV TQEFM OEVHP AJMII CDCTI FGYAG JSPXY ALUYM NSMYH" +

println("\nBest key : $best_key")

println("\nDecrypted text:\n${decrypt(enc, best_key)}")

{{out}}

{{libheader|Wren-str}}

{{libheader|Wren-fmt}}

import "/trait" for Stepped

import "/str" for Char, Str

System.print()

System.print("Best key : %(bestKey)")

{{out}}

=={{header|zkl}}==

{{trans|Python}}

english_frequences=T( // A..Z

0.08167, 0.01492, 0.02782, 0.04253, 0.12702, 0.02228, 0.02015,

}).concat() :

T(key,_);

#<<<

"MOMUD EKAPV TQEFM OEVHP AJMII CDCTI FGYAG JSPXY ALUYM NSMYH

key,decoded:=vigenere_decrypt(english_frequences,encryptedText);

println("Key:", key);

{{out}}

<pre>