Bacon cipher: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
| (30 intermediate revisions by 13 users not shown) | |||
Line 1:
[[Category:Encryption]]
{{draft task}}
[[wp: Bacon's cipher| Bacon's cipher]] is a method of steganography created by Francis Bacon.
Line 18:
# Show an example plaintext message encoded and then decoded here on this page.
<br><br>
=={{header|11l}}==
{{trans|Nim}}
<syntaxhighlight lang="11l">V codes = [‘a’ = ‘AAAAA’, ‘b’ = ‘AAAAB’, ‘c’ = ‘AAABA’, ‘d’ = ‘AAABB’, ‘e’ = ‘AABAA’,
‘f’ = ‘AABAB’, ‘g’ = ‘AABBA’, ‘h’ = ‘AABBB’, ‘i’ = ‘ABAAA’, ‘j’ = ‘ABAAB’,
‘k’ = ‘ABABA’, ‘l’ = ‘ABABB’, ‘m’ = ‘ABBAA’, ‘n’ = ‘ABBAB’, ‘o’ = ‘ABBBA’,
‘p’ = ‘ABBBB’, ‘q’ = ‘BAAAA’, ‘r’ = ‘BAAAB’, ‘s’ = ‘BAABA’, ‘t’ = ‘BAABB’,
‘u’ = ‘BABAA’, ‘v’ = ‘BABAB’, ‘w’ = ‘BABBA’, ‘x’ = ‘BABBB’, ‘y’ = ‘BBAAA’,
‘z’ = ‘BBAAB’, ‘ ’ = ‘BBBAA’]
V rev_codes = Dict(codes.items(), (k, v) -> (v, k))
F encode(plaintext, message)
V et = ‘’
L(c) plaintext.lowercase()
et ‘’= I c C ‘a’..‘z’ {:codes[c]} E :codes[Char(‘ ’)]
V result = ‘’
V count = 0
L(c) message.lowercase()
I c C ‘a’..‘z’
result ‘’= I et[count] == ‘A’ {c} E c.uppercase()
count++
I count == et.len
L.break
E
result ‘’= c
R result
F decode(message)
V result = ‘’
V et = ‘’
L(c) message
I c C (‘A’..‘Z’, ‘a’..‘z’)
et ‘’= I c.is_lowercase() {‘A’} E ‘B’
L(i) (0 .< et.len - 4).step(5)
result ‘’= :rev_codes[et[i .< i + 5]]
R result
V plaintext = ‘the quick brown fox jumps over the lazy dog’
V message = ‘bacon's cipher is a method of steganography created by francis bacon.’""
‘this task is to implement a program for encryption and decryption of ’""
‘plaintext using the simple alphabet of the baconian cipher or some ’""
‘other kind of representation of this alphabet (make anything signify anything). ’""
‘the baconian alphabet may optionally be extended to encode all lower ’""
‘case characters individually and/or adding a few punctuation characters ’""
‘such as the space.’
V ciphertext = encode(plaintext, message)
print(‘Cipher text →’)
print(ciphertext)
V decodedtext = decode(ciphertext)
print("\nHidden text →")
print(decodedtext)</syntaxhighlight>
{{out}}
<pre>
Cipher text →
BacON's cIPHer Is a METhoD of stEgAnogRaphy crEatEd By FRAncis baCOn.thIs TASk Is TO imPLeMENT a proGrAm FOR eNcRYPTIOn anD deCRyPtioN Of plAINTExt UsING the SIMpLe AlPhaBet Of thE BAConIan CIphER Or sOme OTHer kInD Of reprESenTATion OF This alPHaBET (makE An
Hidden text →
the quick brown fox jumps over the lazy dog
</pre>
=={{header|Ada}}==
{{trans|Kotlin}}
<
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
Line 170 ⟶ 234:
Put_Line (decode (ciphertext));
end;
end Main;</
{{output}}
<pre>
Line 183 ⟶ 247:
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
Line 273 ⟶ 337:
print( "-----------------------------------------------------" );
print( if baconDecoded <> plainText then "UNSUCESSFUL" else "sucessful" fi, " decode" )
epocs</
{{out}}
<pre>
Line 289 ⟶ 353:
=={{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"
Line 376 ⟶ 440:
print( ( bacon decoded, newline ) );
print( ( "-----------------------------------------------------", newline ) );
print( ( IF bacon decoded /= plain text THEN "UNSUCESSFUL" ELSE "sucessful" FI, " decode", newline ) )</
{{out}}
<pre>
Line 393 ⟶ 457:
=={{header|Arturo}}==
<
a: "AAAAA" b: "AAAAB" c: "AAABA" d: "AAABB" e: "AABAA"
f: "AABAB" g: "AABBA" h: "AABBB" i: "ABAAA" j: "ABAAB"
Line 458 ⟶ 522:
print ""
print "Message:"
print decodeBacon cipherText</
{{out}}
Line 468 ⟶ 532:
the quick brown fox jumps over the lazy dog</pre>
=={{header|
<syntaxhighlight lang="autohotkey">Bacon_Cipher(message, plaintext:=""){
codes := {"a":"AAAAA", "b":"AAAAB", "c":"AAABA", "d":"AAABB", "e":"AABAA"
, "f":"AABAB", "g":"AABBA", "h":"AABBB", "i":"ABAAA", "j":"ABAAB"
, "k":"ABABA", "l":"ABABB", "m":"ABBAA", "n":"ABBAB", "o":"ABBBA"
, "p":"ABBBB", "q":"BAAAA", "r":"BAAAB", "s":"BAABA", "t":"BAABB"
, "u":"BABAA", "v":"BABAB", "w":"BABBA", "x":"BABBB", "y":"BBAAA"
, "z":"BBAAB", " ":"BBBAA"}
if (plaintext<>"") {
for i, letter in StrSplit(plaintext)
code .= codes[letter]
x := StrSplit(code)
for i, letter in StrSplit(message)
if (Asc(letter) >= 97 and Asc(letter) <= 122)
if !(l := x.RemoveAt(1))
break
else if (l = "A")
cipher .= letter
else
cipher .= Chr(Asc(letter) - 32)
else
cipher .= letter
return cipher
} else {
Keys := []
for l, c in codes
Keys[c] := l
for i, letter in StrSplit(message)
if (Asc(letter) >= 97 and Asc(letter) <= 122)
pattern .= "A"
else if (Asc(letter) >= 65 and Asc(letter) <= 90)
pattern .= "B"
while StrLen(pattern)
str .= Keys[SubStr(pattern, 1, 5)]
, pattern := SubStr(pattern, 6)
return str
}
}</syntaxhighlight>
Examples:<syntaxhighlight lang="autohotkey">Message:= "
(join
bacon's cipher is a method of steganography created by francis bacon.
this task is to implement a program for encryption and decryption of
plaintext using the simple alphabet of the baconian cipher or some
other kind of representation of this alphabet (make anything signify anything).
the baconian alphabet may optionally be extended to encode all lower
case characters individually and/or adding a few punctuation characters
such as the space.
)"
plaintext := "the quick brown fox jumps over the lazy dog"
MsgBox, 262144, ,% "plain text = " plaintext
. "`n`nencoded = `n" (cipher := Bacon_Cipher(message, plaintext))
. "`n`ndecoded = " recoveredText := Bacon_Cipher(cipher)</syntaxhighlight>
{{out}}
<pre>plain text = the quick brown fox jumps over the lazy dog
encoded =
BacON's cIPHer Is a METhoD of stEgAnogRaphy crEatEd By FRAncis baCOn.thIs TASk Is TO imPLeMENT a proGrAm FOR eNcRYPTIOn anD deCRyPtioN OfplAINTExt UsING the SIMpLe AlPhaBet Of thE BAConIan CIphER Or sOmeOTHer kInD Of reprESenTATion OF This alPHaBET (makE An
decoded = the quick brown fox jumps over the lazy dog
</pre>
=={{header|BASIC}}==
==={{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." \
Line 519 ⟶ 651:
NEXT
PRINT "Decoded:", NL$, result$</
{{out}}
<pre>Encoded:
BacON's cIPHer Is a METhoD of stEgAnogRaphy crEatEd By FRAncis baCOn.thIs TASk Is TO imPLeMENT a proGrAm FOR eNcRYPTIOn anD deCRyPtioN Of plAINTExt UsING the SIMpLe AlPhaBet Of thE BAConIan CIphER Or sOme OTHer kInD Of reprESenTATion OF This alPHaBET (makE An
Decoded:
the quick brown fox jumps over the lazy dog</pre>
==={{header|Visual Basic .NET}}===
{{trans|C#}}
<syntaxhighlight lang="vbnet">Imports System.Text
Module Module1
ReadOnly CODES As New Dictionary(Of Char, String) From {
{"a", "AAAAA"}, {"b", "AAAAB"}, {"c", "AAABA"}, {"d", "AAABB"}, {"e", "AABAA"},
{"f", "AABAB"}, {"g", "AABBA"}, {"h", "AABBB"}, {"i", "ABAAA"}, {"j", "ABAAB"},
{"k", "ABABA"}, {"l", "ABABB"}, {"m", "ABBAA"}, {"n", "ABBAB"}, {"o", "ABBBA"},
{"p", "ABBBB"}, {"q", "BAAAA"}, {"r", "BAAAB"}, {"s", "BAABA"}, {"t", "BAABB"},
{"u", "BABAA"}, {"v", "BABAB"}, {"w", "BABBA"}, {"x", "BABBB"}, {"y", "BBAAA"},
{"z", "BBAAB"}, {" ", "BBBAA"} ' use " " To denote any non-letter
}
Function Encode(plainText As String, message As String) As String
Dim pt = plainText.ToLower()
Dim sb As New StringBuilder()
For Each c In pt
If "a" <= c AndAlso c <= "z" Then
sb.Append(CODES(c))
Else
sb.Append(CODES(" "))
End If
Next
Dim et = sb.ToString()
Dim mg = message.ToLower() '"A"s to be in lower case, "B"s in upper case
sb.Length = 0
Dim count = 0
For Each c In mg
If "a" <= c AndAlso c <= "z" Then
If et(count) = "A" Then
sb.Append(c)
Else
sb.Append(Chr(Asc(c) - 32)) ' upper case equivalent
End If
count += 1
If count = et.Length Then
Exit For
End If
Else
sb.Append(c)
End If
Next
Return sb.ToString()
End Function
Function Decode(message As String) As String
Dim sb As New StringBuilder
For Each c In message
If "a" <= c AndAlso c <= "z" Then
sb.Append("A")
ElseIf "A" <= c AndAlso c <= "Z" Then
sb.Append("B")
End If
Next
Dim et = sb.ToString()
sb.Length = 0
For index = 0 To et.Length - 1 Step 5
Dim quintet = et.Substring(index, 5)
Dim key = CODES.Where(Function(a) a.Value = quintet).First().Key
sb.Append(key)
Next
Return sb.ToString()
End Function
Sub Main()
Dim plainText = "the quick brown fox jumps over the lazy dog"
Dim message =
"bacon's cipher is a method of steganography created by francis bacon. " +
"this task is to implement a program for encryption and decryption of " +
"plaintext using the simple alphabet of the baconian cipher or some " +
"other kind of representation of this alphabet (make anything signify anything). " +
"the baconian alphabet may optionally be extended to encode all lower " +
"case characters individually and/or adding a few punctuation characters " +
"such as the space."
Dim cipherText = Encode(plainText, message)
Console.WriteLine("Cipher text ->" & Environment.NewLine & "{0}", cipherText)
Dim decodedText = Decode(cipherText)
Console.WriteLine(Environment.NewLine & "Hidden text ->" & Environment.NewLine & "{0}", decodedText)
End Sub
End Module</syntaxhighlight>
{{out}}
<pre>Cipher text ->
BacON's cIPHer Is a METhoD of stEgAnogRaphy crEatEd By FRAncis baCOn. thIs TASk Is TO imPLeMENT a proGrAm FOR eNcRYPTIOn anD deCRyPtioN Of plAINTExt UsING the SIMpLe AlPhaBet Of thE BAConIan CIphER Or sOme OTHer kInD Of reprESenTATion OF This alPHaBET (makE An
Hidden text ->
the quick brown fox jumps over the lazy dog</pre>
=={{header|C}}==
{{trans|Kotlin}}
<
#include <string.h>
#include <stdlib.h>
Line 637 ⟶ 867:
free(hidden_text);
return 0;
}</
{{output}}
Line 652 ⟶ 882:
=={{header|C sharp|C#}}==
{{trans|Java}}
<
using System.Collections.Generic;
using System.Linq;
Line 724 ⟶ 954:
}
}
}</
{{out}}
<pre>Cipher text ->
Line 735 ⟶ 965:
Bacon cipher implementation
<
#include <iostream>
#include <algorithm>
Line 783 ⟶ 1,013:
std::vector<std::string> bAlphabet;
};
</syntaxhighlight>
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:
Line 859 ⟶ 1,089:
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
Line 873 ⟶ 1,103:
LETSHAUESOMEFUNWITHBACONCIPHER
</pre>
=={{header|Common Lisp}}==
====Association lists====
1. Note
Codes are stored in association lists.
<pre>#\x -> assoc -> code -> rassoc -> #\x</pre>
For instance.
<pre>(cdr (assoc #\a +codes+)) = (a a a a a) (car (rassoc '(a a a a a) +codes+) = #\a </pre>
2. Program
<syntaxhighlight lang="lisp">;; 22.06.16
(defconstant +codes+
'((#\a . (a a a a a)) (#\b . (a a a a b)) (#\c . (a a a b a))
(#\d . (a a a b b)) (#\e . (a a b a a)) (#\f . (a a b a b))
(#\g . (a a b b a)) (#\h . (a a b b b)) (#\i . (a b a a a))
(#\j . (a b a a b)) (#\k . (a b a b a)) (#\l . (a b a b b))
(#\m . (a b b a a)) (#\n . (a b b a b)) (#\o . (a b b b a))
(#\p . (a b b b b)) (#\q . (b a a a a)) (#\r . (b a a a b))
(#\s . (b a a b a)) (#\t . (b a a b b)) (#\u . (b a b a a))
(#\v . (b a b a b)) (#\w . (b a b b a)) (#\x . (b a b b b))
(#\y . (b b a a a)) (#\z . (b b a a b)) (#\space . (b b b a a))))
(defun encode (text message)
(let (cipher key code)
(loop for c across message do
(setf code (cdr (assoc (char-downcase c) +codes+)))
(setf key (append key code)))
(loop for c across text always key do
(when (alpha-char-p c)
(if (eq (car key) 'B)
(setf c (char-upcase c))
(setf c (char-downcase c)))
(setf key (cdr key)))
(setf cipher (append cipher (list c))))
(coerce cipher 'string)))
(defun decode (message)
(let (key code letter)
(loop for c across message when (alpha-char-p c) do
(if (lower-case-p c)
(setf code (append code '(A)))
(setf code (append code '(B))))
(when (= (length code) 5)
(setf letter (car (rassoc code +codes+ :test #'equal)))
(setf key (append key (list letter)))
(setf code nil)))
(coerce key 'string)))</syntaxhighlight>
3. Example
<syntaxhighlight lang="lisp">(defconstant +monologue+ (concatenate 'string
"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 "
"for the Plutition Camps with sweat in my eyes watching stars fight on the sh"
"oulder of Orion... I’ve felt wind in my hair, riding test boats off the blac"
"k galaxies and seen an attack fleet burn like a match and disappear. I've se"
"en it, felt it..."))
(defconstant +key+ "« tears in rain »")</syntaxhighlight>
4. Execution
{{out}}
<pre>(encode +monologue+ +key+)
"I'VE knOwn ADveNtures, seEn plACes YoU PEoplE will NEvER SEe, i'Ve beEn offwoRl
d anD BaCK... FRon"
(decode (encode +monologue+ +key+))
" tears in rain "</pre>
That's All Folks !
''cyril nocton (cyril.nocton@gmail.com)''
=={{header|D}}==
<
import std.stdio;
import std.uni;
Line 964 ⟶ 1,274:
writeln("Hidden text ->");
writeln(decodedText);
}</
{{out}}
<pre>Cipher text ->
Line 974 ⟶ 1,284:
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Bacon%27s_cipher}}
'''Solution'''
'''Program for encoding.''' It uses the extended version of the alphabeth, which can be calculated programatically, with no table.
[[File:Fōrmulæ - Bacon's cipher 01.png]]
'''Test case for encoding'''
[[File:Fōrmulæ - Bacon's cipher 02.png]]
[[File:Fōrmulæ - Bacon's cipher 03.png]]
'''Program for decoding'''
[[File:Fōrmulæ - Bacon's cipher 04.png]]
'''Test case for decoding'''
[[File:Fōrmulæ - Bacon's cipher 05.png]]
[[File:Fōrmulæ - Bacon's cipher 06.png]]
=={{header|Go}}==
{{trans|Kotlin}}
<
import(
Line 1,064 ⟶ 1,392:
decodedText := baconDecode(cipherText)
fmt.Printf("\nHidden text ->\n\n%s\n", decodedText)
}</
{{out}}
Line 1,079 ⟶ 1,407:
=={{header|Groovy}}==
{{trans|Java}}
<
private static final Map<Character, String> codes
Line 1,166 ⟶ 1,494:
System.out.printf("\nHidden text ->\n\n%s\n", decodedText)
}
}</
{{out}}
<pre>Cipher text ->
Line 1,178 ⟶ 1,506:
=={{header|Haskell}}==
<
import Data.List (elemIndex, unfoldr)
import Data.Bool (bool)
Line 1,250 ⟶ 1,578:
, encode text "something wrong @ in the message"
, encode "abc" message
]</
{{Out}}
<pre>BAcoN's CIPher is A metHod Of StegaNogrApHy creAted By franCiS
Line 1,269 ⟶ 1,597:
Implementation:
<
beta=: 26{.(}.~i.&'A')a.
norm=: ([ -. -.)&alfa@(rplc&('JIVU'))@toupper
Line 1,276 ⟶ 1,604:
encrypt=: gena@enca@norm
decrypt=: alfa {~ _5 #.\ 90 < a.&i.</
We use random letters as the basis for our steganography and we use case to represent "font".
Line 1,282 ⟶ 1,610:
Example use:
<
nWVkJAPkamEuUJIeTGKnUsTVRfAWWuNBIIHdEIcOAPuTBeXKQduQAdU
encrypt 'this is a test'
sFLkBQKqqaQsGGXzAXQsKlZFBcILRlUIRAQaEQoNUBcHIhFTWbeRAlM
decrypt encrypt 'this is a test'
THISISATEST</
=={{header|Java}}==
{{trans|Kotlin}}
{{works with|Java|9}}
<
import java.util.Map;
import java.util.Objects;
Line 1,367 ⟶ 1,695:
System.out.printf("\nHidden text ->\n\n%s\n", decodedText);
}
}</
{{out}}
<pre>Cipher text ->
Line 1,377 ⟶ 1,705:
the quick brown fox jumps over the lazy dog
</pre>
=={{header|jq}}==
{{trans|Wren}}
{{works with|jq}}
'''Works with gojq, the Go implementation of jq''' (*)
'''Preliminaries'''
<syntaxhighlight lang="jq">def is_upper: . >= "A" and . <= "Z";
def is_lower: . >= "a" and . <= "z";
# Output: a stream
def chars: explode[] | [.] | implode;
# (*) Change to `keys` for gojq
def key($s): first( keys_unsorted[] as $k | if .[$k] == $s then $k else empty end) // "?";
</syntaxhighlight>
'''Bacon Cipher'''
<syntaxhighlight lang="jq">def Bacon:
{
"a" : "AAAAA", "b" : "AAAAB", "c" : "AAABA", "d" : "AAABB", "e" : "AABAA",
"f" : "AABAB", "g" : "AABBA", "h" : "AABBB", "i" : "ABAAA", "j" : "ABAAB",
"k" : "ABABA", "l" : "ABABB", "m" : "ABBAA", "n" : "ABBAB", "o" : "ABBBA",
"p" : "ABBBB", "q" : "BAAAA", "r" : "BAAAB", "s" : "BAABA", "t" : "BAABB",
"u" : "BABAA", "v" : "BABAB", "w" : "BABBA", "x" : "BABBB", "y" : "BBAAA",
"z" : "BBAAB", " " : "BBBAA" # use " " to denote any non-letter
};
def encode($plaintext; $message):
(reduce ($plaintext|ascii_downcase|chars) as $c ("";
if $c|ascii_downcase == . then . + Bacon[$c] else . + Bacon[" "] end)) as $et
# "A"s to be in lower case, "B"s in upper case
| label $out
| foreach ($message|ascii_downcase|chars) as $c ( {sb: "", count: 0};
if ($c | is_lower)
then .sb = if $et[.count: .count+1] == "A" then .sb + $c else .sb + ($c|ascii_upcase) end
| .count += 1
| if .count == ($et|length) then .emit = .sb, break $out else . end
else .sb += $c
end;
select(.emit).emit ) ;
def decode($message):
Bacon as $Bacon
| (reduce ($message|chars) as $c ("";
if ($c|is_lower) then . + "A"
elif ($c|is_upper) then . + "B"
else .
end)) as $et
| reduce range(0; $et|length; 5) as $i ("";
$et[$i : $i+5] as $quintet
| . + ($Bacon | key($quintet)) ) ;
{ plainText: "the quick brown fox jumps over the lazy dog",
message: (
"bacon's cipher is a method of steganography created by francis bacon." +
"this task is to implement a program for encryption and decryption of " +
"plaintext using the simple alphabet of the baconian cipher or some " +
"other kind of representation of this alphabet (make anything signify anything). " +
"the baconian alphabet may optionally be extended to encode all lower " +
"case characters individually and/or adding a few punctuation characters " +
"such as the space.") }
| .cipherText = encode(.plainText; .message)
| .decodedText = decode(.cipherText)
| "Cipher text ->\n\n\(.cipherText)",
"\nHidden text ->\n\n\(.decodedText)"</syntaxhighlight>
{{out}}
<pre>
Cipher text ->
BacON's cIPHer Is a METhoD of stEgAnogRaphy crEatEd By FRAncis baCOn.thIs TASk Is TO imPLeMENT a proGrAm FOR eNcRYPTIOn anD deCRyPtioN Of plAINTExt UsING the SIMpLe AlPhaBet Of thE BAConIan CIphER Or sOme OTHer kInD Of reprESenTATion OF This alPHaBET (makE An
Hidden text ->
the quick brown fox jumps over the lazy dog
</pre>
=={{header|Julia}}==
Line 1,383 ⟶ 1,789:
'''Module''':
<
using Formatting, IterTools.chain
Line 1,448 ⟶ 1,854:
end
end # module BaconCipher</
'''Main''':
<
enc = BaconCipher.encrypt(msg)
dec = BaconCipher.decrypt(enc)
Line 1,457 ⟶ 1,863:
println(" -> Encrypted:\n", enc)
println(" -> Decrypted:\n", dec)
end</
{{out}}
Line 1,479 ⟶ 1,885:
=={{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",
Line 1,540 ⟶ 1,946:
val decodedText = Bacon.decode(cipherText)
println("\nHidden text ->\n\n$decodedText")
}</
{{out}}
Line 1,555 ⟶ 1,961:
=={{header|Lua}}==
Based on C++ version
<syntaxhighlight lang="lua">
function Bacon( txt, secret, e )
local alpha = {}
Line 1,665 ⟶ 2,071:
print( a )
print( Bacon( "", a, 0 ) )
</syntaxhighlight>
{{out}}
<pre>
Line 1,674 ⟶ 2,080:
=={{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";
Line 1,737 ⟶ 2,143:
codedMsg = encode("the quick brown fox jumps over the lazy dog")
print codedMsg
print decode(codedMsg)</
{{out}}
Line 1,745 ⟶ 2,151:
=={{header|Nim}}==
{{trans|Kotlin}}
<
const Codes = {'a': "AAAAA", 'b': "AAAAB", 'c': "AAABA", 'd': "AAABB", 'e': "AABAA",
Line 1,792 ⟶ 2,198:
echo "Cipher text →\n", cipherText
let decodedText = cipherText.decode()
echo "\nHidden text →\n", decodedText</
{{out}}
Line 1,803 ⟶ 2,209:
=={{header|Perl}}==
{{trans|Raku}}
<
use warnings;
use utf8;
Line 1,867 ⟶ 2,273:
print "$steganography\n"
print "$decoded\n"</
{{out}}
<pre style="height:35ex">Steganograpic message hidden in text:
Line 1,906 ⟶ 2,312:
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>
Line 1,975 ⟶ 2,381:
<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}}
Line 1,991 ⟶ 2,397:
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
Line 2,057 ⟶ 2,463:
decrypted = decrypt(encrypted)
print('DECRYPTED = \n%s\n' % decrypted)
assert phrase == decrypted, 'Round-tripping error'</
{{out}}
Line 2,077 ⟶ 2,483:
DECRYPTED =
rosetta code bacon cipher example secret phrase to encode in the capitalisation of peter pan</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ dup upper swap lower != ] is ischar ( c --> b )
[ char a char z 1+ clamp
char a -
[ table
$ "AAAAA" $ "AAAAB" $ "AAABA" ( abc )
$ "AAABB" $ "AABAA" $ "AABAB" ( def )
$ "AABBA" $ "AABBB" $ "ABAAA" ( ghi )
$ "ABAAB" $ "ABABA" $ "ABABB" ( jkl )
$ "ABBAA" $ "ABBAB" $ "ABBBA" ( mno )
$ "ABBBB" $ "BAAAA" $ "BAAAB" ( pqr )
$ "BAABA" $ "BAABB" $ "BABAA" ( stu )
$ "BABAB" $ "BABBA" $ "BABBB" ( vwx )
$ "BBAAA" $ "BBAAB" ( y z ) ] do ] is baconian ( c --> $ )
[ $ "abcdefghijklmnopqrstuvwxyz"
0 rot witheach
[ char A = swap 1 << + ]
0 25 clamp peek ] is debacon ( $ --> c )
[ [] swap
witheach
[ dup ischar iff
[ lower baconian join ]
else drop ] ] is ->bacon$ ( $ --> $ )
[ [] [] rot
dup size 5 / times
[ 5 split
dip [ nested join ] ]
drop
witheach [ debacon join ] ] is debacon$ ( $ --> $ )
[ [] unrot ->bacon$ swap
witheach
[ over size if
[ dup ischar if
[ swap behead
dip swap
char A = iff
lower else upper ] ]
swap dip join ] drop ] is baconise ( $ $ --> $ )
[ [] swap
witheach
[ dup ischar iff
[ char A char Z 1+ within iff
[ char A ] else [ char B ]
join ]
else drop ]
debacon$ ] is debaconise ( $ --> $ )
$ "If it looks like a duck, and quacks like a duck, "
$ "we have at least to consider the possibility that "
$ "we have a small aquatic bird of the family anatidae "
$ " on our hands. "
$ "(This is a quote from the noted author Douglas Adams)"
4 times join
$ "Dirk Gently's Holistic Detective Agency"
baconise
dup nest$ 60 wrap$ cr cr
debaconise echo$
</syntaxhighlight>
{{out}}
<pre>if iT LoOks lIke a DuCk, And qUAcks Like A DuCK, we HAvE aT
LEAst tO coNsidER ThE POssIbILiTy thAt wE hAve A SmAll
aquaTic biRD of The FamILy aNatidaE oN ouR HaNds. (tHiS iS a
qUote from thE NoteD autHOr DougLaS Adams)
dirkgentlysholisticdetectiveagency</pre>
=={{header|Racket}}==
<
(require xml)
Line 2,126 ⟶ 2,607:
)
(displayln (bacon-encode->html plain-text false-text values (λ (s) `(i ,s)))))</
{{out}}
Line 2,144 ⟶ 2,625:
=={{header|Raku}}==
(formerly Perl 6)
=== alternative steganography algorithm ===
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}}
<syntaxhighlight lang="raku"
This task is to implement a program for encryption and decryption
of plaintext using the simple alphabet of the Baconian cipher or
Line 2,199 ⟶ 2,681:
say "Hidden message revealed:";
say reveal $steganography;</
{{out}}
Line 2,227 ⟶ 2,709:
=== Bacon cipher solution ===
<syntaxhighlight lang="raku"
my @symb = ' ', |@abc; # modified Baconian charset - space and full alphabet
# TODO original one with I=J U=V, nice for Latin
Line 2,235 ⟶ 2,717:
sub bacon ($s, $msg) {
my
my
for $msg.lc.comb Z
for @a.kv -> $i, $c-str {
(my $x := @a[$i]) = $x.uc if %bacon{$c-msg}.comb[
} }
}
Line 2,261 ⟶ 2,742:
my $baconed = bacon $str, $msg;
$baconed
# FIXME
say "text:\n$baconed\n";
my $unbaconed = unbacon($baconed).trim.uc;
say "hidden message:\n$unbaconed";</
{{out}}
Line 2,290 ⟶ 2,771:
All alphabetic letters are handled as if they were in uppercase (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."
Line 2,314 ⟶ 2,795:
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
return $</
'''output''' when using the default input:
<pre>
Line 2,326 ⟶ 2,807:
:::* the ''bottom tee'' <big><big>┴</big></big> (sometimes known as the ''bottom junction'')
:::* the ''top tee'' <big><big>┬</big></big> (sometimes known as the ''top junction'')
<
parse arg plain /*obtain optional arguments from the CL*/
if plain='' then plain = "The quick brown fox jumped over the lazy dog."
Line 2,350 ⟶ 2,831:
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
return $</
'''output''' when using the default input:
<pre>
Line 2,359 ⟶ 2,840:
===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."
Line 2,383 ⟶ 2,864:
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
return $</
'''output''' when using the default input:
<pre>
Line 2,393 ⟶ 2,874:
=={{header|Ruby}}==
{{trans|C#}}
<
'a' => "AAAAA", 'b' => "AAAAB", 'c' => "AAABA", 'd' => "AAABB", 'e' => "AABAA",
'f' => "AABAB", 'g' => "AABBA", 'h' => "AABBB", 'i' => "ABAAA", 'j' => "ABAAB",
Line 2,480 ⟶ 2,961:
end
main()</
{{out}}
<pre>Cipher text ->
Line 2,490 ⟶ 2,971:
=={{header|Scala}}==
{{trans|Java}}
<
object BaconCipher {
Line 2,578 ⟶ 3,059:
println(s"Hidden text ->\n\n$decodedText")
}
}</
{{out}}
<pre>Cipher text ->
Line 2,587 ⟶ 3,068:
the quick brown fox jumps over the lazy dog</pre>
=={{header|
{{trans|
<syntaxhighlight lang="v (vlang)">const codes = {
`a` : "AAAAA", `b` : "AAAAB", `c` : "AAABA", `d` : "AAABB", `e` : "AABAA",
`f` : "AABAB", `g` : "AABBA", `h` : "AABBB", `i` : "ABAAA", `j` : "ABAAB",
`k` : "ABABA", `l` : "ABABB", `m` : "ABBAA", `n` : "ABBAB", `o` : "ABBBA",
`p` : "ABBBB", `q` : "BAAAA", `r` : "BAAAB", `s` : "BAABA", `t` : "BAABB",
`u` : "BABAA", `v` : "BABAB", `w` : "BABBA", `x` : "BABBB", `y` : "BBAAA",
`z` : "BBAAB", ` ` : "BBBAA"
}
fn bacon_encode(plain_text string, message string) string {
pt := plain_text.to_lower()
mut sb := []u8{}
for c in pt.runes() {
if c >= `a` && c <= `z` {
sb << codes[c].bytes()
} else {
sb << codes[` `].bytes()
}
}
et := sb.bytestr()
mg := message.to_lower() // 'A's to be in lower case, 'B's in upper case
sb = [] // clear the byte slice
mut count := 0
for c in mg {
if c >= u8(`a`) && c <= u8(`z`) {
if et[count] == `A` {
sb << c
} else {
sb << c - 32 // upper case equivalent
}
count++
if count == et.len { break }
} else {
sb << c
}
}
return sb.bytestr()
}
fn bacon_decode(message string) string {
mut sb := []u8{}
for c in message {
if c >= u8(`a`) && c <= u8(`z`) {
sb << `A`
} else if c >= u8(`A`) && c <= u8(`Z`) {
sb << `B`
}
}
et := sb.bytestr()
sb = [] // clear the byte slice
for i := 0; i < et.len; i += 5 {
quintet := et[i .. i + 5]
for k, v in codes {
if v == quintet {
sb << u8(k)
break
}
}
}
return sb.bytestr()
}
fn main() {
plain_text := "the quick brown fox jumps over the lazy dog"
message := "bacon's cipher is a method of steganography created by francis bacon." +
"this task is to implement a program for encryption and decryption of " +
"plaintext using the simple alphabet of the baconian cipher or some " +
"other kind of representation of this alphabet (make anything signify anything). " +
"the baconian alphabet may optionally be extended to encode all lower " +
"case characters individually and/or adding a few punctuation characters " +
"such as the space."
cipher_text := bacon_encode(plain_text, message)
println("Cipher text ->\n\n$cipher_text")
decoded_text := bacon_decode(cipher_text)
println("\nHidden text ->\n\n$decoded_text")
}</syntaxhighlight>
{{out}}
<pre>
Cipher text ->
BacON's cIPHer Is a METhoD of stEgAnogRaphy crEatEd By FRAncis baCOn.thIs TASk Is TO imPLeMENT a proGrAm FOR eNcRYPTIOn anD deCRyPtioN Of plAINTExt UsING the SIMpLe AlPhaBet Of thE BAConIan CIphER Or sOme OTHer kInD Of reprESenTATion OF This alPHaBET (makE An
Hidden text ->
the quick brown fox jumps over the lazy dog</pre>
Line 2,688 ⟶ 3,159:
{{trans|Kotlin}}
{{libheader|Wren-str}}
{{libheader|Wren-
<
import "./
class Bacon {
Line 2,757 ⟶ 3,228:
System.print("Cipher text ->\n\n%(cipherText)")
var decodedText = Bacon.decode(cipherText)
System.print("\nHidden text ->\n\n%(decodedText)")</
{{out}}
<pre>
Cipher text ->
BacON's cIPHer Is a METhoD of stEgAnogRaphy crEatEd By FRAncis baCOn.thIs TASk Is TO imPLeMENT a proGrAm FOR eNcRYPTIOn anD deCRyPtioN Of plAINTExt UsING the SIMpLe AlPhaBet Of thE BAConIan CIphER Or sOme OTHer kInD Of reprESenTATion OF This alPHaBET (makE An
Hidden text ->
the quick brown fox jumps over the lazy dog
</pre>
=={{header|XPL0}}==
{{trans|C}}
Works on Raspberry Pi. (MAlloc works differently in other versions.)
<syntaxhighlight lang "XPL0">include xpllib; \for StrCmp, StrLen, Print, ToLower, StrNCopy
int Codes;
func GetCode(C);
char C;
[if C >= 97 and C <= 122 then return Codes(C-97);
return Codes(26);
];
func GetChar(Code);
char Code;
int I;
[if StrCmp(Codes(26), Code) = 0 then return ^ ;
for I:= 0 to 26-1 do
if StrCmp(Codes(I), Code) = 0 then return 97+I;
Print("\nCode ^"%s^" is invalid\n", Code);
exit(1);
];
proc StrToLower(S);
char S;
int I;
for I:= 0 to StrLen(S)-1 do S(I):= ToLower(S(I));
func BaconEncode(PlainText, Message);
char PlainText, Message;
int I, Count;
int PLen, MLen, ELen;
char C, P, Et, Mt;
[PLen:= StrLen(PlainText);
MLen:= StrLen(Message);
ELen:= 5 * PLen;
Et:= MAlloc(ELen+1);
StrToLower(PlainText);
P:= Et;
for I:= 0 to PLen-1 do
[C:= PlainText(I);
StrNCopy(P, GetCode(C), 5);
P:= P+5;
];
P:= P+1; P(0):= 0;
\'A's to be in lowercase, 'B's in uppercase
StrToLower(Message);
Mt:= MAlloc(MLen+1);
Count:= 0;
for I:= 0 to MLen-1 do
[C:= Message(I);
if C >= ^a and C <= ^z then
[if Et(Count) = ^A then Mt(I):= C
else Mt(I):= C-32; \uppercase equivalent
Count:= Count+1;
if Count = ELen then I:= MLen;
]
else Mt(I):= C;
];
Release(Et);
return Mt;
];
func BaconDecode(CipherText);
char CipherText;
int I, Count, CLen, PLen;
char P, Ct, Pt, C, Quintet(6);
[CLen:= StrLen(CipherText);
Ct:= MAlloc(CLen+1);
Count:= 0;
for I:= 0 to CLen-1 do
[C:= CipherText(I);
if C >= ^a and C <= ^z then
[Ct(Count):= ^A; Count:= Count+1]
else if C >= ^A and C <= ^Z then
[Ct(Count):= ^B; Count:= Count+1];
];
PLen:= StrLen(Ct) / 5;
Pt:= MAlloc(PLen+1);
P:= Ct;
for I:= 0 to PLen-1 do
[StrNCopy(Quintet, P, 5);
Quintet(5):= 0;
Pt(I):= GetChar(Quintet);
P:= P+5;
];
Pt(PLen):= 0;
Release(Ct);
return Pt;
];
char PlainText, Message, CipherText, HiddenText;
[\Maps successively from 'a' to 'z' plus ' ' to denote any non-letter
Codes:= ["AAAAA", "AAAAB", "AAABA", "AAABB", "AABAA",
"AABAB", "AABBA", "AABBB", "ABAAA", "ABAAB",
"ABABA", "ABABB", "ABBAA", "ABBAB", "ABBBA",
"ABBBB", "BAAAA", "BAAAB", "BAABA", "BAABB",
"BABAA", "BABAB", "BABBA", "BABBB", "BBAAA",
"BBAAB", "BBBAA"];
PlainText:= "the quick brown fox jumps over the lazy dog";
Message:= "bacon's cipher is a method of steganography created by francis bacon.
this task is to implement a program for encryption and decryption of
plaintext using the simple alphabet of the baconian cipher or some
other kind of representation of this alphabet (make anything signify anything).
the baconian alphabet may optionally be extended to encode all lower
case characters individually and/or adding a few punctuation characters
such as the space.";
CipherText:= BaconEncode(PlainText, Message);
Print("Cipher text ->\n\n%s\n", CipherText);
HiddenText:= BaconDecode(CipherText);
Print("\nHidden text ->\n\n%s\n", HiddenText);
Release(CipherText);
Release(HiddenText);
]</syntaxhighlight>
{{out}}
<pre>
Line 2,772 ⟶ 3,371:
=={{header|zkl}}==
{{trans|Python}}
<
fcn init(_keyText){
var [const] keyText=_keyText.toLower(),
Line 2,801 ⟶ 3,400:
fcn{ vm.arglist.pump(String,upperLetters.holds,"toInt") : bin2lc[_] });
}
}</
<
#<<<
0'|All children, except one, grow up. They soon know that they will grow
Line 2,829 ⟶ 3,428:
println("ENCRYPTED = \n%s".fmt(encrypted));
println("DECRYPTED = \n%s".fmt(decrypted));
if(phrase.toLower()!=decrypted) throw(Exception.AssertionError("Round-tripping error"));</
{{out}}
<pre>
| |||