Vigenère cipher: Difference between revisions

{{trans|C++}}

 

V out = ‘’

V j = 0

print(original)

print(‘Encrypted: ’encrypted)

 

{{out}}

 

=={{header|Action!}}==

INT i

CHAR c

 

Test("Crypto is short for cryptography.","ABCDABCDABCDABCDABCDABCDABCD")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Vigen%C3%A8re_cipher.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

 

USE Ada.Text_IO, Ada.Characters.Handling;

 

END Main;

 

 

{{out}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d].}}

 

PROC vigenere cipher = (REF STRING key)VOID:

print(("Encrypted: ", encrypted, new line));

print(("Decrypted: ", decrypted, new line))

{{out}}

<pre>

Lines <code>340,350,430,440</code> could probably been put into some DEF FN, but it would probably have made it harder to read. The maximum length for a string in AppleSoft BASIC is 255 characters.

I have not used the DEF FN MOD(A) function in line <code>450</code> on purpose, as I still would have had to correct for a possible negative value.

100 :

110 REM VIGENERE CIPHER

470 K = K + 1: IF K > LEN (K$) THEN K = 1

480 NEXT I

{{out}}

KEY: LEMON

=={{header|Arturo}}==

 

encrypt: function [msg, key][

pos: 0

print text

print encr

 

{{out}}

 

=={{header|AutoHotkey}}==

Text= Beware the Jabberwock, my son! The jaws that bite, the claws that catch!

 

decoderKey .= Chr(26-(Asc(A_LoopField)-65)+65)

return VigenereCipher(Text, decoderKey)

{{out}}

<pre>Input =Beware the Jabberwock, my son! The jaws that bite, the claws that catch!

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

function Filtrar(cadorigen)

filtrado = ""

print "Descifrado: "; DesEncriptar(cadcifrada, llave)

end

{{out}}

<pre>

 

=={{header|BBC BASIC}}==

plaintext$ = "ATTACK AT DAWN"

ciphertext$ = FNencrypt(plaintext$, key$)

IF C% >= 97 IF C% <= 122 MID$(A$,A%,1) = CHR$(C%-32)

NEXT

{{out}}

<pre>

The text to encrypt is read from stdin. The key is the string literal at the start of the program.

 

>>!#:0#-0#1g#,*#<+:v:-1$_^#!:\+1g00p<

\"{"\v>9+2*%"A"+^>$>~>:48*\`#@_::"`"`

 

{{out}}

The decrypter is essentially identical, except for a change of sign on the last line.

 

>>!#:0#-0#1g#,*#<+:v:-1$_^#!:\+1g00p<

\"{"\v>9+2*%"A"+^>$>~>:48*\`#@_::"`"`

 

{{out}}

=={{header|C}}==

This program skips non-alphabetical characters, preserves case, and when run with the <code>-d</code> command line flag, decrypts the message rather than encrypting.

#include <stdlib.h>

#include <string.h>

 

return buf;

 

{{out}}

 

=={{header|C sharp|C#}}==

using System;

 

}

}

{{out}}

<pre>

 

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

#include <string>

using namespace std;

cout << "Encrypted: " << encrypted << endl;

cout << "Decrypted: " << decrypted << endl;

 

{{out}}

 

=={{header|Ceylon}}==

function normalize(String text) => text.uppercased.filter(Character.letter);

print(encrypted);

print(decrypted);

 

=={{header|Clojure}}==

Requires Clojure 1.2.

(:require [clojure.string :as string]))

 

; decipher a text

 

Demonstration code:

(:require [org.rosettacode.clojure.vigenere :as vigenere]))

 

(doall (map (fn [[k v]] (printf "%9s: %s\n" k v))

[ ["Original" plaintext] ["Key" key] ["Encrypted" ciphertext] ["Decrypted" recovered] ])))

 

{{out}}

=={{header|CoffeeScript}}==

{{trans|D}}

code = (char) -> char.charCodeAt()

 

console.log "Original : #{original}"

console.log "Encrypted : #{encrypted}"

<pre>Original : Beware the Jabberwock, my son! The jaws that bite, the claws that catch!

Encrypted : WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY

====Main version====

This doesn't assume anything about character codes other than A-Z being a contiguous block (but still, we could be using EBCDIC. Who knows.)

(remove-if-not

(lambda (c) (char<= #\A c #\Z))

(enc (vigenère msg key))

(dec (vigenère enc key :decipher t)))

{{out}}

<pre>msg: Beware the Jabberwock... The jaws that... the claws that catch!

1. Program

 

 

(defun strip (s)

(setf i (mod (1+ i) (length key)))

(char +a+ (mod (+ (position c +a+) (* p (position (elt key i) +a+))) 26)))

 

2. Execution

 

=={{header|D}}==

 

string encrypt(in string txt, in string key) pure @safe

immutable encoded = original.encrypt(key);

writeln(encoded, "\n", encoded.decrypt(key));

{{out}}

<pre>WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY

===Alternative Version===

{{trans|Raku}}

std.conv;

 

immutable encoded = original.encrypt(key);

writeln(encoded, "\n", encoded.decrypt(key));

The output is the same.

 

=={{header|Elena}}==

{{trans|C#}}

import system'math;

import system'routines;

class VCipher

{

}

var pw := "VIGENERECIPHER";

var s1 := v.encrypt(s0, pw, 1);

console.printLine("Encrypted:",s1);

console.printLine("Press any key to continue..");

console.readChar()

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Ruby}}

@base ?A

@size ?Z - @base + 1

IO.puts "Original: #{plaintext}"

IO.puts "Encrypted: #{ciphertext}"

 

{{out}}

=={{header|Erlang}}==

Erlang is not ideal for string manipulation, but with some utility function definitions it can express this fairly elegantly:

-module(vigenere).

-export([encrypt/2, decrypt/2]).

 

encrypt(Text, Key) -> crypt(Text, Key, fun encipher/2).

 

Demonstration code:

-import(vigenere,[encrypt/2, decrypt/2]).

main(_) ->

CipherText = encrypt("Beware the Jabberwock, my son! The jaws that bite, the claws that catch!", Key),

RecoveredText = decrypt(CipherText, Key),

 

{{out}}

 

=={{header|F_Sharp|F#}}==

module vigenere =

let keyschedule (key:string) =

let plain = vigenere.decrypt passwd cipher

printfn "%s\n%s" cipher plain

 

<pre>C:\src\fsharp>fsi vigenere.fsx

 

=={{header|Factor}}==

math.order sequences ;

IN: rosetta-code.vigenere-cipher

vigenere-decrypt "Decrypted: %s\n" printf ;

 

{{out}}

<pre>

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

end do

end subroutine

{{out}}

<pre> Beware the Jabberwock, my son! The jaws that bite, the claws that catch!

=={{header|FreeBASIC}}==

{{trans|Liberty BASIC}}

Function Filtrar(cadorigen As String) As String

Dim As String letra

Print "Descifrado: "; DesEncriptar(cadcifrada, llave)

Sleep

{{out}}

<pre>

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println("Deciphered:", dt)

{{out}}

<pre>

 

=={{header|Haskell}}==

import Text.Printf

 

decr = decrypt key encr

printf " Input: %s\n Key: %s\nEncrypted: %s\nDecrypted: %s\n"

{{out}}

<pre>

 

=={{header|Icon}} and {{header|Unicon}}==

ptext := "Beware the Jabberwock, my son! The jaws that bite, the claws that catch!"

write("Key = ",ekey := "VIGENERECIPHER")

}

return ctext

 

The following helper procedures will be of general use with classical cryptography tasks.

link strings

 

text ? (s := "", until pos(0) do s ||:= " " || move(5)|tab(0))

return s[2:0]

 

{{libheader|Icon Programming Library}}

=={{header|J}}==

'''Solution:'''<br>

preprocess=: (#~ e.&ALPHA)@toupper NB. force uppercase and discard non-alpha chars

vigEncryptRC=: 0 vig ALPHA preprocess

'''Example Use:'''

WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY

'VIGENERECIPHER' vigDecryptRC 'WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY'

 

=={{header|Java}}==

{{trans|D}}

public static void main(String[] args) {

String key = "VIGENERECIPHER";

return res;

}

 

<pre>WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY

BEWARETHEJABBERWOCKMYSONTHEJAWSTHATBITETHECLAWSTHATCATCH</pre>

===Alternative Version===

import com.google.common.collect.Streams;

import java.util.function.Supplier;

 

}

 

=={{header|JavaScript}}==

// helper

function ordA(a) {

 

console.log(enc);

 

=={{header|jq}}==

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

# retain alphabetic characters only

def n:

| (., example("VIGENERECIPHER")),

"",

{{out}}

<pre>

=={{header|Jsish}}==

From Javascript entry.

"use strict";

 

vigenere(enc, key, true) ==> THEQUICKBROWNFOXJUMPEDOVERTHELAZYDOGTHELAZYDOGLAZYDOGDOG

=!EXPECTEND!=

 

{{out}}

=={{header|Julia}}==

{{works with|Julia|1.5}}

→(a::Char, b::Char, ± = +) = 'A'+((a-'A')±(b-'A')+26)%26

←(a::Char, b::Char) = →(a,b,-)

println(cyphertext)

println(cyphertext ← "Gimme!")

 

{{out}}

 

=={{header|Kotlin}}==

 

fun vigenere(text: String, key: String, encrypt: Boolean = true): String {

val decoded = vigenere(encoded, key, false)

println(decoded)

 

{{out}}

=={{header|Lambdatalk}}==

Only texts in uppercases [A-Z] and spaces.

{def vigenere

{def vigenere.map

-> ATTACKATDAWN

 

 

=={{header|Liberty BASIC}}==

ori$ = "Beware the Jabberwock, my son! The jaws that bite, the claws that catch!"

key$ = filter$("vigenerecipher")

next

end function

Beware the Jabberwock, my son! The jaws that bite, the claws that catch!

 

=={{header|Lua}}==

local msg = { _msg:upper():byte( 1, -1 ) }

local key = { _key:upper():byte( 1, -1 ) }

 

print( encrypted )

<pre>WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY

BEWARETHEJABBERWOCKMYSONTHEJAWSTHATBITETHECLAWSTHATCATCH</pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Module[{textCode, keyCode},

textCode =

keyCode[[;; Length@textCode]],

PadRight[keyCode, Length@textCode, keyCode]];

 

<pre>key = "Vigenere Cipher";

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

return melancholy_dane

 

{{out}}

 

=={{header|Nim}}==

 

proc encrypt(msg, key: string): string =

echo text

echo encr

 

{{out}}

=={{header|Objeck}}==

{{trans|D}}

bundle Default {

class VigenereCipher {

}

}

<pre>

encrypt: WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY

{{trans|C}}

 

let str = String.uppercase src in

let key = String.uppercase key in

Printf.printf "Code: %s\n" cod;

Printf.printf "Back: %s\n" dec;

 

Run:

 

This is a custom, more functional version of the existing solution, due to

 

{{works with|OCaml|4.05 or above}}

(* Task : Vigenère_cipher *)

 

(* This is a custom, more functional version of an existing solution,

due to OCaml 4.05's unsafe-string compatibility mode:

*)

 

Printf.printf "Back: %s\n" pt

;;

{{out}}

<pre>

{{trans|NetRexx}}

A reworking of the [[#NetRexx|NetRexx]] version using Open Object Rexx but shouldn't take much to translate to Classic Rexx.

Do

alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

End

Exit

 

{{out}}

 

=={{header|Pascal}}==

// The Vigenere cipher in reasonably standard Pascal

// <no library functions: all conversions hand-coded>

END.

 

 

{{out}}

 

=={{header|Perl}}==

printHelp();

}

}

return $cipher;

 

Demonstration:

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">ENCRYPT</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Original: %s\nEncrypted: %s\nDecrypted: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">,</span><span style="color: #000000;">d</span><span style="color: #0000FF;">})</span>

{{Out}}

<pre>

=={{header|PHP}}==

{{trans|C}}

 

$str = "Beware the Jabberwock, my son! The jaws that bite, the claws that catch!";

 

?>

{{out}}

<pre>Text: Beware the Jabberwock, my son! The jaws that bite, the claws that catch!

 

=={{header|PicoLisp}}==

(extract

'((C)

(char (+ 65 (% (+ 26 (- C K)) 26))) )

(vigenereKey Str)

Test:

<pre>: (vigenereEncrypt

 

=={{header|PL/I}}==

cypher: procedure options (main); /* 21 September 2012 */

declare t(26) character (26);

end;

end cypher;

{{out}}

<pre>

 

=={{header|PowerShell}}==

function Get-VigenereCipher

{

$OutText = $null

}

Usage examples:

<pre>

 

=={{header|PureBasic}}==

;convert characters to an ordinal (0-25) and remove non-alphabetic characters,

;returns dimension size of result array letters()

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre> Plain text = "The quick brown fox jumped over the lazy dogs."

{{Works with|Python|3}}

{{trans|Haskell}}

 

from itertools import starmap, cycle

if __name__ == '__main__':

main()

{{out}}

<pre>Beware the Jabberwock, my son! The jaws that bite, the claws that catch!

=={{header|Quackery}}==

 

[ upper

dup char A char Z 1+ within

say "Encrypted: " $ "Kahlil Gibran" encrypt dup echo$ cr

 

{{out}}

 

=={{header|R}}==

# mod1(1:20, 6) => 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2

((v - 1) %% n) + 1

# WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY

message(vigen("WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY", "vigenerecipher", decrypt = T))

 

=={{header|Racket}}==

#lang racket

(define chr integer->char)

"VIGENERECIPHER")

"VIGENERECIPHER")

{{out}}

"BEWARETHEJABBERWOCKMYSONTHEJAWSTHATBITETHECLAWSTHATCATCH"

 

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|rakudo|2015-11-14}}

sub v2s (@v) { (@v »%» 26 »+» 65)».chr.join }

 

say $red;

say my $black = blacken($red, $key);

{{out}}

<pre>Beware the Jabberwock, my son! The jaws that bite, the claws that catch!

to add some more features to make it actually "useful" :-) So not only can u encrypt any character (because the crypted message will be base 64 encoded), but it also includes a Gui.

the Gui window has buttons to access the clipboard too - so u can get the original text from clipboard and put the crypted message back again. To execute it,simply download the latest red.exe (about 1,1 MB size! ) from red-lang.org. This program can also be compiled to an .exe (+ red runtime.dll ) by simply execute <pre>red.exe -c vign1.red</pre> or <pre>red.exe -r vign1.red</pre> which creates a single .exe file whithout the need for any .dll . should be working on windows , linux ( under wine ) and mac OS.

 

CRLF: copy "^M^/" ;; constant for 0D 0A line feed

pad 270x1 button "Quit " [quit]

]

{{output}}

the message <pre>Beware the Jabberwock, my son! The jaws that bite, the claws that catch!</pre> with key "VIGENERECIPHER" translates to <pre>i6y8r7e3ZbextWiPs7irrLfFtLWwb2m9wWXFxbdo

=={{header|REXX}}==

===uppercase text only===

@.1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

L=length(@.1)

dMsg=dMsg || substr(@.1, pos( substr(x, i, 1), @.j), 1 )

end /*j*/

{{out|output|text=&nbsp; when using the default internal fields:}}

<pre>

Additional characters can be added by simply appending them to the &nbsp; <big>'''@.1'''</big> &nbsp; variable.

@abc= 'abcdefghijklmnopqrstuvwxyz'; @abcU=@abc; upper @abcU

@.1 = @abcU || @abc'0123456789~`!@#$%^&*()_-+={}|[]\:;<>?,./" '''

dMsg=dMsg || substr(@.1, pos( substr(x, i, 1), @.j), 1 )

end /*j*/

{{out|output|text=&nbsp; when using the default internal fields:}}

<pre>

 

=={{header|Ring}}==

# Project : Vigenère cipher

 

next

return a

Output:

<pre>

ciphertext = LXFOPVEFRNHR

decrypted = ATTACKATDAWN

</pre>

 

=={{header|Ruby}}==

BASE = 'A'.ord

end

 

Demonstration:

 

 

plaintext = 'Beware the Jabberwock, my son! The jaws that bite, the claws that catch!'

puts "Original: #{plaintext}"

puts "Encrypted: #{ciphertext}"

 

{{out}}

 

=={{header|Rust}}==

 

static A: u8 = 'A' as u8;

let decoded = vigenere(key, &encoded, false);

println!("Back: {}", decoded);

 

=={{header|Scala}}==

Valid characters for messages: A through Z, zero, 1 to 9, and full-stop (.)

object Vigenere {

def encrypt(msg: String, key: String) : String = {

println("Encrypt text ABC => " + Vigenere.encrypt("ABC", "KEY"))

println("Decrypt text KFA => " + Vigenere.decrypt("KFA", "KEY"))

 

{{out}}

 

=={{header|Seed7}}==

 

const func string: vigenereCipher (in string: source, in var string: keyword) is func

decrypted := vigenereDecipher(encrypted, keyword);

writeln("Decrypted: " <& decrypted);

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

func v2s(v) { v »%» 26 »+» 65 -> map{.chr}.join }

 

say red

say (var black = blacken(red, key))

{{out}}

<pre>

in the following code, the cypher should consist of upper-case characters only. If that is not guaranteed, apply prep to it before passing it to encrypt/decrypt..

{{works with|Smalltalk/X}}

prep := [:s | s select:[:ch | ch isLetter] thenCollect:[:ch | ch asUppercase]].

encrypt := [:s :cypher | (prep value:s) keysAndValuesCollect:[:i :ch | ch rot:((cypher at:((i-1)\\key size+1))-$A) ]].

decrypt := [:s :cypher | (prep value:s) keysAndValuesCollect:[:i :ch | ch rot:26-((cypher at:((i-1)\\key size+1))-$A) ]].

Test:

plain := 'Beware the Jabberwock, my son! The jaws that bite, the claws that catch!'.

cypher := 'VIGENERECIPHER'.

crypted -> 'WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY'

plain2 -> 'BEWARETHEJABBERWOCKMYSONTHEJAWSTHATBITETHECLAWSTHATCATCH'

 

=={{header|Swift}}==

Can support a larger range of characters, if desired

 

str: String,

minChar: UInt32,

let decoded2 = cipher2.decrypt(encoded2)!

 

 

{{out}}

=={{header|Tcl}}==

{{trans|C++}}

 

oo::class create Vigenere {

return $out

}

Demonstrating:

set original "Beware the Jabberwock, my son! The jaws that bite, the claws that catch!"

set encrypted [$cypher encrypt $original]

puts $original

puts "Encrypted: $encrypted"

{{out}}

<pre>

=={{header|TXR}}==

 

@(do

(defun vig-op (plus-or-minus)

dec: @decoded

check: @check

 

Here, the TXR pattern language is used to scan letters out of two arguments,

 

=={{header|TypeScript}}==

 

key: string

 

})()

 

=={{header|VBA}}==

 

Sub test()

Private Function CharToAscii(s As String) As Byte()

CharToAscii = StrConv(s, vbFromUnicode)

 

{{Out}}

=={{header|VBScript}}==

{{trans|Liberty BASIC}}

Function Encrypt(text,key)

text = OnlyCaps(text)

WScript.StdOut.WriteLine "Encrypted: " & Encrypt(orig_text,orig_key)

WScript.StdOut.WriteLine "Decrypted: " & Decrypt(Encrypt(orig_text,orig_key),orig_key)

 

{{Out}}

 

An alternate implementation using RegExp to filter the input

'vigenere cypher

option explicit

wscript.echo decrypt(encoded,key)

 

 

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

starting from cursor location.

The user enters the keyword (upper or lower case).

Reg_Copy_Block(11, Cur_Pos, EOL_Pos) // @11 = copy of original text

EOL Ins_Newline

}

Num_Pop(6,9)

 

{{out}}

Encrypted: WMCEEIKLGRPIFVMEUGXQPWQVIOIAVEYXUEKFKBTALVXTGAFXYEVKPAGY

Decrypted: BEWARETHEJABBERWOCKMYSONTHEJAWSTHATBITETHECLAWSTHATCATCH

</pre>

 

{{trans|Kotlin}}

{{libheader|Wren-str}}

 

var vigenere = Fn.new { |text, key, encrypt|

System.print(encoded)

var decoded = vigenere.call(encoded, key, false)

 

{{out}}

Usage: vigenere KEYWORD <infile.txt >outfile.xxx

 

int Neg, C, Len, I, Key;

char KeyWord(80);

until C=$1A; \EOF

ChOut(0, $1A); \encrypted file must end with EOF otherwise the decode will hang

 

{{out}}

outfile = PACKMYBOXWITHFIVEDOZENLIQUORJUGS

</pre>

 

=={{header|zkl}}==

{{trans|C}}

upperCase:=["A".."Z"].pump(String);

src=src.toUpper().inCommon(upperCase); // only uppercase

else c - key[i] + 26 ) % 26).toChar()

});

"the claws that catch!";

key := "Vigenere Cipher";

cod := encipher(str, key, True); println("Code: ", cod);

{{out}}

<pre>