How to resolve the algorithm ADFGVX cipher step by step in the Julia programming language
How to resolve the algorithm ADFGVX cipher step by step in the Julia programming language
Table of Contents
Problem Statement
The ADFGVX cipher was a manually applied field cipher used by the German Army during World War I. It was broken in 1918 by the French cryptanalyst Georges Painvin. The workings of the cipher are described in the Wikipedia article, linked to above, and so will not be repeated here. Write routines, functions etc. in your language to:
- Encrypt suitable plaintext and decrypt the resulting cipher text using the ADFGVX cipher algorithm given a Polybius square (see 2. below) and a suitable key. For this purpose suitable means text consisting solely of ASCII upper case letters or digits.
- Create a 6 x 6 Polybius square using a random combination of the letters A to Z and the digits 0 to 9 and then display it.
- Given the number of letters (between 7 and 12 say) to use, create a key by selecting a suitable word at random from unixdict.txt and then display it. The word selected should be such that none of its characters are repeated. Use these routines to create a Polybius square and a 9 letter key. These should then be used to encrypt the plaintext: ATTACKAT1200AM and decrypt the resulting cipher text. Display here the results of both operations. As it's unclear from the Wikipedia article how to handle a final row with fewer elements than the number of characters in the key, either of the methods mentioned in Columnar transposition may be used. In the case of the second method, it is also acceptable to fill any gaps after shuffling by moving elements to the left which makes decipherment harder.
Let's start with the solution:
Step by Step solution about How to resolve the algorithm ADFGVX cipher step by step in the Julia programming language
The ADFGVX cipher is a fractionating transposition cipher developed during World War I by German army intelligence. It is similar to the ADFGX cipher, but with an additional row and column, making it more secure.
The ADFGVX cipher uses a 6x6 Polybius square to represent the alphabet. The square is divided into 36 cells, each containing a different letter. The letters are arranged in a random order, and the key to the cipher is the order of the letters in the square.
To encrypt a message, the sender first converts the message into a series of pairs of letters. The first letter of each pair represents the row of the Polybius square, and the second letter represents the column. The sender then encrypts the message by replacing each pair of letters with the corresponding pair of letters from the Polybius square.
To decrypt a message, the recipient first converts the message into a series of pairs of letters. The recipient then decrypts the message by replacing each pair of letters with the corresponding pair of letters from the Polybius square.
The ADFGVX cipher is a relatively secure cipher, but it is not unbreakable. The cipher can be broken by using a variety of cryptanalytic techniques, including frequency analysis and pattern recognition.
Here is an example of how to use the ADFGVX cipher in Julia:
using ADFGVX
# Create an ADFGVX cipher
cipher = ADFGVX(POLYBIUS, KEY)
# Encrypt a message
encoded_message = encrypt(message, cipher)
# Decrypt a message
decoded_message = decrypt(encoded_message, cipher)The ADFGVX cipher is a powerful tool for encrypting messages. It is easy to use and relatively secure. However, it is important to remember that no cipher is unbreakable.
Source code in the julia programming language
"""
The ADFGVX cipher.
See also eg. https://www.nku.edu/~christensen/092hnr304%20ADFGVX.pdf
"""
using Random
""" The WWI German ADFGVX cipher. """
struct ADFGVX
polybius::Vector{Char}
pdim::Int
key::Vector{Char}
keylen::Int
alphabet::Vector{Char}
encode::Dict{Char, Vector{Char}}
decode::Dict{Vector{Char}, Char}
end
""" ADFGVX constructor, takes 2 strings, option for third string if polybius len != 36 """
function ADFGVX(s, k, alph = "ADFGVX")
poly = collect(uppercase(s))
pdim = isqrt(length(poly))
al = collect(uppercase(alph))
enco::Dict = Dict([(poly[(i - 1) * pdim + j] => [al[i], al[j]])
for i in 1:pdim, j in 1:pdim])
deco = Dict(last(p) => first(p) for p in enco)
@assert pdim^2 == length(poly) && pdim == length(al)
return ADFGVX(poly, pdim, collect(uppercase(k)), length(k), al, enco, deco)
end
""" Encrypt with the ADFGVX cipher. """
function encrypt(s::String, k::ADFGVX)
chars = reduce(vcat, [k.encode[c] for c in
filter(c -> c in k.polybius, collect(uppercase(s)))])
colvecs = [lett => chars[i:k.keylen:length(chars)] for (i, lett) in enumerate(k.key)]
sort!(colvecs, lt = (x, y) -> first(x) < first(y))
return String(mapreduce(p -> last(p), vcat, colvecs))
end
""" Decrypt with the ADFGVX cipher. Does not depend on spacing of encoded text """
function decrypt(s::String, k::ADFGVX)
chars = filter(c -> c in k.alphabet, collect(uppercase(s)))
sortedkey = sort(collect(k.key))
order = [findfirst(c -> c == ch, k.key) for ch in sortedkey]
originalorder = [findfirst(c -> c == ch, sortedkey) for ch in k.key]
a, b = divrem(length(chars), k.keylen)
strides = [a + (b >= i ? 1 : 0) for i in order] # shuffled column lengths
starts = accumulate(+, strides[begin:end-1], init=1) # shuffled starts of columns
pushfirst!(starts, 1) # starting index
ends = [starts[i] + strides[i] - 1 for i in 1:k.keylen] # shuffled ends of columns
cols = [chars[starts[i]:ends[i]] for i in originalorder] # get reordered columns
pairs, nrows = Char[], (length(chars) - 1) ÷ k.keylen + 1 # recover the rows
for i in 1:nrows, j in 1:k.keylen
(i - 1) * k.keylen + j > length(chars) && break
push!(pairs, cols[j][i])
end
return String([k.decode[[pairs[i], pairs[i + 1]]] for i in 1:2:length(pairs)-1])
end
const POLYBIUS = String(shuffle(collect("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")))
const KEY = read("unixdict.txt", String) |>
v -> split(v, r"\s+") |>
v -> filter(w -> (n = length(w); n == 9 && n == length(unique(collect(w)))), v) |>
shuffle |> first |> uppercase
const SECRETS, message = ADFGVX(POLYBIUS, KEY), "ATTACKAT1200AM"
println("Polybius: $POLYBIUS, Key: $KEY")
println("Message: $message")
encoded = encrypt(message, SECRETS)
decoded = decrypt(encoded, SECRETS)
println("Encoded: $encoded")
println("Decoded: $decoded")
You may also check:How to resolve the algorithm Find duplicate files step by step in the Phix programming language
You may also check:How to resolve the algorithm Read a configuration file step by step in the Liberty BASIC programming language
You may also check:How to resolve the algorithm Loops/Downward for step by step in the Nim programming language
You may also check:How to resolve the algorithm Strip a set of characters from a string step by step in the ALGOL 68 programming language
You may also check:How to resolve the algorithm Metallic ratios step by step in the J programming language