Bacon cipher: Difference between revisions

{{trans|Nim}}

 

‘f’ = ‘AABAB’, ‘g’ = ‘AABBA’, ‘h’ = ‘AABBB’, ‘i’ = ‘ABAAA’, ‘j’ = ‘ABAAB’,

‘k’ = ‘ABABA’, ‘l’ = ‘ABABB’, ‘m’ = ‘ABBAA’, ‘n’ = ‘ABBAB’, ‘o’ = ‘ABBBA’,

V decodedtext = decode(ciphertext)

print("\nHidden text →")

 

{{out}}

=={{header|Ada}}==

{{trans|Kotlin}}

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

Put_Line (decode (ciphertext));

end;

{{output}}

<pre>

Tested with Agena 2.9.5 Win32

{{Trans|ALGOL 68}}

 

# Bacon's letter codes but with distinct values for i & j and u & v and an extra for any non-letter

print( "-----------------------------------------------------" );

print( if baconDecoded <> plainText then "UNSUCESSFUL" else "sucessful" fi, " decode" )

{{out}}

<pre>

 

=={{header|ALGOL 68}}==

[]STRING bacon codes = ( #a# "AAAAA", "AAAAB", "AAABA", "AAABB", "AABAA", "AABAB", "AABBA", "AABBB", "ABAAA"

, #j# "ABAAB", "ABABA", "ABABB", "ABBAA", "ABBAB", "ABBBA", "ABBBB", "BAAAA", "BAAAB"

print( ( bacon decoded, newline ) );

print( ( "-----------------------------------------------------", newline ) );

{{out}}

<pre>

=={{header|Arturo}}==

 

a: "AAAAA" b: "AAAAB" c: "AAABA" d: "AAABB" e: "AABAA"

f: "AABAB" g: "AABBA" h: "AABBB" i: "ABAAA" j: "ABAAB"

print ""

print "Message:"

 

{{out}}

 

=={{header|AutoHotkey}}==

codes := {"a":"AAAAA", "b":"AAAAB", "c":"AAABA", "d":"AAABB", "e":"AABAA"

, "f":"AABAB", "g":"AABBA", "h":"AABBB", "i":"ABAAA", "j":"ABAAB"

return str

}

(join

bacon's cipher is a method of steganography created by francis bacon.

MsgBox, 262144, ,% "plain text = " plaintext

. "`n`nencoded = `n" (cipher := Bacon_Cipher(message, plaintext))

{{out}}

<pre>plain text = the quick brown fox jumps over the lazy dog

=={{header|BaCon}}==

A Bacon cipher in [[BaCon]]. Using unique identifiers 'aaaaa'-'bbaab' for a-z and, as other examples on this page, using 'bbbaa' (28) for the space character.

 

txt$ = "Bacon's cipher is a method of steganography created by Francis Bacon." \

NEXT

 

{{out}}

<pre>Encoded:

=={{header|C}}==

{{trans|Kotlin}}

#include <string.h>

#include <stdlib.h>

free(hidden_text);

return 0;

 

{{output}}

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

{{trans|Java}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>Cipher text ->

Bacon cipher implementation

 

#include <iostream>

#include <algorithm>

std::vector<std::string> bAlphabet;

};

 

These next 2 classes use the 0's & 1's generated by the 'Bacon encryption' to create different the outputs.

One could go wild here...

class cipherI {

public:

return 0;

}

{{out}}

<pre>

2. Program

 

 

(defconstant +codes+

(setf key (append key (list letter)))

(setf code nil)))

 

3. Example

 

"I've known adventures, seen places you people will never see, I've been Offw"

"orld and back... frontiers ! I've stood on the back deck of a blinker bound "

"en it, felt it..."))

 

 

4. Execution

 

=={{header|D}}==

import std.stdio;

import std.uni;

writeln("Hidden text ->");

writeln(decodedText);

{{out}}

<pre>Cipher text ->

=={{header|Go}}==

{{trans|Kotlin}}

 

import(

decodedText := baconDecode(cipherText)

fmt.Printf("\nHidden text ->\n\n%s\n", decodedText)

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

private static final Map<Character, String> codes

 

System.out.printf("\nHidden text ->\n\n%s\n", decodedText)

}

{{out}}

<pre>Cipher text ->

=={{header|Haskell}}==

 

import Data.List (elemIndex, unfoldr)

import Data.Bool (bool)

, encode text "something wrong @ in the message"

, encode "abc" message

{{Out}}

<pre>BAcoN's CIPher is A metHod Of StegaNogrApHy creAted By franCiS

Implementation:

 

beta=: 26{.(}.~i.&'A')a.

norm=: ([ -. -.)&alfa@(rplc&('JIVU'))@toupper

 

encrypt=: gena@enca@norm

 

We use random letters as the basis for our steganography and we use case to represent "font".

Example use:

 

nWVkJAPkamEuUJIeTGKnUsTVRfAWWuNBIIHdEIcOAPuTBeXKQduQAdU

encrypt 'this is a test'

sFLkBQKqqaQsGGXzAXQsKlZFBcILRlUIRAQaEQoNUBcHIhFTWbeRAlM

decrypt encrypt 'this is a test'

 

=={{header|Java}}==

{{trans|Kotlin}}

{{works with|Java|9}}

import java.util.Map;

import java.util.Objects;

System.out.printf("\nHidden text ->\n\n%s\n", decodedText);

}

{{out}}

<pre>Cipher text ->

 

'''Preliminaries'''

 

def is_lower: . >= "a" and . <= "z";

# (*) Change to `keys` for gojq

def key($s): first( keys_unsorted[] as $k | if .[$k] == $s then $k else empty end) // "?";

'''Bacon Cipher'''

{

"a" : "AAAAA", "b" : "AAAAB", "c" : "AAABA", "d" : "AAABB", "e" : "AABAA",

| .decodedText = decode(.cipherText)

| "Cipher text ->\n\n\(.cipherText)",

{{out}}

<pre>

 

'''Module''':

 

using Formatting, IterTools.chain

end

 

 

'''Main''':

enc = BaconCipher.encrypt(msg)

dec = BaconCipher.decrypt(enc)

println(" -> Encrypted:\n", enc)

println(" -> Decrypted:\n", dec)

 

{{out}}

=={{header|Kotlin}}==

The 'full' Bacon alphabet, which has separate letters for i, j, u and v, has been used in the following:

private val codes = mapOf(

'a' to "AAAAA", 'b' to "AAAAB", 'c' to "AAABA", 'd' to "AAABB", 'e' to "AABAA",

val decodedText = Bacon.decode(cipherText)

println("\nHidden text ->\n\n$decodedText")

 

{{out}}

=={{header|Lua}}==

Based on C++ version

function Bacon( txt, secret, e )

local alpha = {}

print( a )

print( Bacon( "", a, 0 ) )

{{out}}

<pre>

 

=={{header|MiniScript}}==

c["a"] = "AAAAA"; c["b"] = "AAAAB"; c["c"] = "AAABA"; c["d"] = "AAABB"; c["e"] = "AABAA"; c["f"] = "AABAB";

c["g"] = "AABBA"; c["h"] = "AABBB"; c["i"] = "ABAAA"; c["j"] = "ABAAB"; c["k"] = "ABABA"; c["l"] = "ABABB";

codedMsg = encode("the quick brown fox jumps over the lazy dog")

print codedMsg

 

{{out}}

=={{header|Nim}}==

{{trans|Kotlin}}

 

const Codes = {'a': "AAAAA", 'b': "AAAAB", 'c': "AAABA", 'd': "AAABB", 'e': "AABAA",

echo "Cipher text →\n", cipherText

let decodedText = cipherText.decode()

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use utf8;

 

print "$steganography\n"

{{out}}

<pre style="height:35ex">Steganograpic message hidden in text:

half of/an obviously corrupt image file.

 

<span style="color: #008080;">constant</span> <span style="color: #000000;">bits</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span>

<span style="color: #000000;">mask</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">bits</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Encrypted:\n"</span><span style="color: #0000FF;">&</span><span style="color: #000000;">ant</span><span style="color: #0000FF;">&</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Decrypted:\n"</span><span style="color: #0000FF;">&</span><span style="color: #000000;">dec</span><span style="color: #0000FF;">&</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>

 

{{out}}

This deviates from the Bacon method as it encodes to different capitalisation of text rather than differences in font.

 

 

sometext = """All children, except one, grow up. They soon know that they will grow

decrypted = decrypt(encrypted)

print('DECRYPTED = \n%s\n' % decrypted)

 

{{out}}

=={{header|Quackery}}==

 

 

[ char a char z 1+ clamp

dup nest$ 60 wrap$ cr cr

debaconise echo$

 

{{out}}

=={{header|Racket}}==

 

(require xml)

 

)

 

{{out}}

Not truly a Bacon Cipher as it doesn't encode using font variations. But fits with the spirit if not the exact definition.

{{works with|Rakudo|2015-11-20}}

This task is to implement a program for encryption and decryption

of plaintext using the simple alphabet of the Baconian cipher or

 

say "Hidden message revealed:";

 

{{out}}

 

=== Bacon cipher solution ===

my @symb = ' ', |@abc; # modified Baconian charset - space and full alphabet

# TODO original one with I=J U=V, nice for Latin

say "text:\n$baconed\n";

my $unbaconed = unbacon($baconed).trim.uc;

 

{{out}}

 

All alphabetic letters are handled as if they were in uppercase &nbsp; (i.e., lowercase letters are uppercased).

parse arg plain /*obtain optional arguments from the CL*/

if plain='' then plain = "The quick brown fox jumped over the lazy dog."

do k=0 for 256; _=d2c(k); if @._=='' then iterate; q=@._; !.q=_; end

do j=1 to Lx by 5; y=substr(x,j,5); $=$ || !.y; end

'''output''' &nbsp; when using the default input:

<pre>

:::* &nbsp; the &nbsp; ''bottom tee'' &nbsp; <big><big>┴</big></big> &nbsp; &nbsp; (sometimes known as the &nbsp; ''bottom junction'')

:::* &nbsp; the &nbsp; &nbsp; ''top tee'' &nbsp; &nbsp; &nbsp; <big><big>┬</big></big> &nbsp; &nbsp; (sometimes known as the &nbsp; ''top junction'')

parse arg plain /*obtain optional arguments from the CL*/

if plain='' then plain = "The quick brown fox jumped over the lazy dog."

do k=0 for 256; _=d2c(k); if @._=='' then iterate; q=@._; !.q=_; end

do j=1 to Lx by 5; y=substr(x,j,5); $=$ || !.y; end

'''output''' &nbsp; when using the default input:

<pre>

 

===uses upper/lower case===

parse arg plain /*obtain optional arguments from the CL*/

if plain='' then plain = "The quick brown fox jumped over the lazy dog."

do k=0 for 256; _=d2c(k); if @._=='' then iterate; q=@._; !.q=_; end

do j=1 to Lx by 5; y=substr(x,j,5); $=$ || !.y; end

'''output''' &nbsp; when using the default input:

<pre>

=={{header|Ruby}}==

{{trans|C#}}

'a' => "AAAAA", 'b' => "AAAAB", 'c' => "AAABA", 'd' => "AAABB", 'e' => "AABAA",

'f' => "AABAB", 'g' => "AABBA", 'h' => "AABBB", 'i' => "ABAAA", 'j' => "ABAAB",

end

 

{{out}}

<pre>Cipher text ->

=={{header|Scala}}==

{{trans|Java}}

 

object BaconCipher {

println(s"Hidden text ->\n\n$decodedText")

}

{{out}}

<pre>Cipher text ->

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>Cipher text ->

=={{header|Vlang}}==

{{trans|go}}

`a` : "AAAAA", `b` : "AAAAB", `c` : "AAABA", `d` : "AAABB", `e` : "AABAA",

`f` : "AABAB", `g` : "AABBA", `h` : "AABBB", `i` : "ABAAA", `j` : "ABAAB",

decoded_text := bacon_decode(cipher_text)

println("\nHidden text ->\n\n$decoded_text")

{{out}}

<pre>

{{libheader|Wren-str}}

{{libheader|Wren-trait}}

import "/trait" for Stepped

 

System.print("Cipher text ->\n\n%(cipherText)")

var decodedText = Bacon.decode(cipherText)

 

{{out}}

=={{header|zkl}}==

{{trans|Python}}

fcn init(_keyText){

var [const] keyText=_keyText.toLower(),

fcn{ vm.arglist.pump(String,upperLetters.holds,"toInt") : bin2lc[_] });

}

#<<<

0'|All children, except one, grow up. They soon know that they will grow

println("ENCRYPTED = \n%s".fmt(encrypted));

println("DECRYPTED = \n%s".fmt(decrypted));

{{out}}

<pre>