luxferre/dracondi
1
0
Fork 0
Code Actions Activity

initial upload

Browse Source
This commit is contained in:
Luxferre
2025-03-24 10:21:44 +02:00
commit 2d05e868aa
3 changed files with 291 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+130
View File
@@ -0,0 +1,130 @@
The DRACONDI cipher
===================
DRACONDI (short for "Dual-key Rotating Alphabet CONDI") is a symmetrical, pen
and paper, dual-key cipher based upon the ACA's CONDI ("CONsecutive DIgraph")
cipher. It combines the ease of manual and software implementations with a
lot of security enhancements compared to the original CONDI design.
Design rationale
----------------
The original CONDI cipher as
[described by ACA](https://cryptogram.org/downloads/aca.info/ciphers/Condi.pdf),
while being very simple to implement and use, poses multiple problems when it
comes to security, such as:
- the initial offset only influences the first ciphertext letter;
- repeated plaintext digraphs are encrypted into the same ciphertext digraphs;
- the keyspace size is too small for modern use (about 88 bits);
- the keying scheme doesn't consider repeated keyphrase letters;
- the original CONDI preserves word division which eases the cryptanalysis.
By ditching the word division and altering the CONDI's offset calculation step
to account for the letter position in the message and the ciphertext letter
position in the second keyed alphabet, DRACONDI achieves the following
improvements:
- the initial offset is now affecting the rest of the ciphertext;
- the keyspace size has been increased to about 225 bits;
- repeated plaintext digraphs no longer encrypt into the same ciphertext;
- repeated letters in the keyphrase now affect the keyed alphabet;
- the ciphertext is (optionally) divided into the groups of 5 that no longer
convey any additional information about the plaintext nature.
These improvements come at a cost of slightly longer offset calculation using
the second keyed alphabet, but otherwise the overall simplicity of the original
CONDI cipher is fully retained in DRACONDI.
The DRACONDI algorithm
----------------------
The entire DRACONDI cipher can be described in three sections: key preparation,
encryption and decryption. Additionally, all key and message material which is
alphabetical must first undergo the sanitization part (i.e. lowercasing it and
removing all non-alphabetical characters not belonging to the `[a-z]` range).
### Key preparation
Unless both parties have agreed on using two completely randomized alphabets
(which is the most preferred way of setting up the key material for DRACONDI
and can be achieved in different ways, e.g. sharing a shuffled 52-card deck),
the key preparation process takes two keyphrases and outputs two mixed
alphabets, KA1 and KA2. The algorithm is identical for both keyphrases.
Follow these steps to create a mixed alphabet from a keyphrase of length `N`
(without any spaces or non-alphabetical characters):
1. Start writing down the (sanitized) keyphrase "as is". For every letter,
replace it with the **previous** letter in the alphabet if it already
occurred in the keyphrase. Repeat this process if necessary until a new
letter is found.
2. Write the rest of the alphabet in the natural order.
3. Count `N` letters forward from the beginning and write down the resulting
alphabet, wrapping around at the end. If `N` is over 25, count `N mod 26`
letters instead.
You should be left with a mixed and shifted alphabet of 26 unique letters.
Write the indices from 0 to 25 above it for more convenient usage.
Example: with the key phrase `sivispacemparabellum` (20 letters long), the
unshifted alphabet will look like `sivhrpacemozqybdlkujfgntwx`. Then, since
our shift is 20, we read it from the 20th position (starting at 0) wrapping
around at the end: `fgntwxsivhrpacemozqybdlkuj`. This is our final keyed
alphabet. Now, we need to repeat the process with a different keyphrase to
get the second keyed alphabet.
### Encryption
The encryption process takes an initial plaintext message in the sanitized
form and two keyed alphabets, KA1 and KA2. Follow these steps to encrypt a
message with DRACONDI.
1. Randomly choose the initial offset from 0 to 25. Write its corresponding
letter in the KA1 alphabet as the first ciphertext letter.
2. For every plaintext letter, do the following:
2.1. Locate the plaintext letter position in the KA1 alphabet. Locate the
ciphertext position by moving (offset) letters to the right, wrapping
around the alphabet if necessary.
2.2. Write down the ciphertext letter according to the KA1 alphabet.
2.3. Get the position of the ciphertext letter in the KA2 alphabet. Calculate
the next offset as the sum of that position and the amount of letters
already encrypted in the message (modulo 26).
As an optional step, you can split the ciphertext into 5-letter groups. This
grouping needs to be removed at the sanitization step before decrypting the
message on the receiving end. All reference implementations of DRACONDI in
software are required to implement this step.
### Decryption
The decryption process takes a ciphertext message in the sanitized form and
two keyed alphabets, KA1 and KA2. Follow these steps to decrypt a message
with DRACONDI.
1. Derive the initial offset from the first ciphertext letter in the KA1
alphabet. Discard the first ciphertext letter afterwards.
2. For every remaining ciphertext letter, do the following:
2.1. Locate the ciphertext letter position in the KA1 alphabet. Locate the
plaintext position by moving (offset) letters to the left, wrapping around
the alphabet if necessary.
2.2. Write down the plaintext letter according to the KA1 alphabet.
2.3. Get the position of the ciphertext letter in the KA2 alphabet. Calculate
the next offset as the sum of that position and the amount of letters
already decrypted in the message (modulo 26).
Implementation requirements
---------------------------
When implementing DRACONDI in software, the following rules are in place for an
implementation to be considered correct:
1. The software shall support three modes: keyed alphabets generation (from the
keyphrase pair), encryption and decryption.
2. The keyed alphabets generation part shall be able to accept already permuted
alphabets and output them completely unaltered, making no changes to them.
3. The encryption part shall sanitize the message and output the ciphertext in
5-letter groups separated by a whitespace.
4. The decryption part shall sanitize the ciphertext before processing,
removing any whitespace and non-letter characters from the input.
Credits
-------
Created by Luxferre in 2025, released into the public domain with no warranties.
The original CONDI cipher was created by Wilfred Higginson in 2011.
dracondi.awk
+96
View File
@@ -0,0 +1,96 @@
#!/usr/bin/env awk -f
function prepmsg(s) {
s = tolower(s)
gsub(/[^a-z]/, "", s)
return s
}
function group5(s, l, i) {
l = length(s)
if((l % 5) > 0) {
for(i=l%5;i<5;i++)
s = s CHR[ORD_A + int(rand()*26)]
}
gsub(/.{5}/, "& ", s)
return s
}
function dracondi_key(kp, l, l2, i, r, c, s) {
kp = prepmsg(kp)
l = length(kp)
r = ""
for(i=0;i<l;i++) {
c = substr(kp, i+1, 1)
while(index(r, c) > 0 && length(r) < 26)
c = CHR[ORD_A + ((25 + ORD[c] - ORD_A) % 26)]
r = r c
}
r = r "abcdefghijklmnopqrstuvwxyz"
l2 = length(r)
s = ""
for(i=0;i<l2;i++) {
c = substr(r, i+1, 1)
if(index(s, c) == 0)
s = s c
}
return (substr(s, l+1) substr(s, 0, l))
}
function dracondi_enc(msg, ka1, ka2, offs, l, i, r, c, rc) {
offs = int(rand() * 26)
r = substr(ka1, offs+1, 1)
msg = prepmsg(msg)
l = length(msg)
for(i=0;i<l;i++) {
c = substr(msg, i+1, 1)
rc = substr(ka1, ((index(ka1, c) - 1 + offs) % 26) + 1, 1)
r = r rc
offs = (index(ka2, rc) + i) % 26 # +1 already implied by index
}
return group5(r)
}
function dracondi_dec(msg, ka1, ka2, offs, l, i, r, c, rc) {
msg = prepmsg(msg)
offs = index(ka1, substr(msg,1,1)) - 1
msg = substr(msg, 2)
r = ""
l = length(msg)
for(i=0;i<l;i++) {
c = substr(msg, i+1, 1)
rc = substr(ka1, ((index(ka1, c) + 25 - offs) % 26) + 1, 1)
r = r rc
offs = (index(ka2, c) + i) % 26 # +1 already implied by index
}
return r
}
BEGIN {
srand()
split("", CHR)
split("", ORD)
for(i=0;i<256;i++) {
c = sprintf("%c", i)
CHR[i] = c
ORD[c] = i
}
ORD_A = ORD["a"]
mode = ARGV[ARGC - 3]
ka1 = dracondi_key(ARGV[ARGC - 2])
ka2 = dracondi_key(ARGV[ARGC - 1])
if(mode == "k") {
print "Keyed alphabet 1:", ka1
print "Keyed alphabet 2:", ka2
} else if(mode == "e") {
while(getline msg)
if(length(msg) > 0)
print dracondi_enc(msg, ka1, ka2)
else break
} else if(mode == "d") {
while(getline msg)
if(length(msg) > 0)
print dracondi_dec(msg, ka1, ka2)
else break
} else print "Invalid mode"
}
dracondi.py
Executable
+65
View File
@@ -0,0 +1,65 @@
#!/usr/bin/env python3
# DRACONDI: Dual-key Rotating Alphabet CONDI
import sys, re
from collections import OrderedDict
from random import randint, choice
from string import ascii_lowercase
def prepmsg(s:str):
return re.sub(r'[^a-z]', '', s.lower())
def dracondi_key(keyphrase:str):
prekey = ''
oa = ord('a')
for c in prepmsg(keyphrase):
while prekey.find(c) != -1 and len(prekey) < 26:
c = chr(oa + ((25 + ord(c) - oa) % 26))
prekey += c
offs = len(prekey) % 26
alpha = prekey + ''.join(ascii_lowercase)
unshifted = ''.join(list(OrderedDict.fromkeys(alpha).keys()))
return (unshifted + unshifted)[offs:offs+26]
def dracondi_enc(msg:str, ka1:str, ka2:str):
offs = randint(0, 25)
res = ka1[offs]
for i,c in enumerate(prepmsg(msg)):
rc = ka1[(ka1.index(c) + offs) % 26]
res += rc
offs = (ka2.index(rc) + i + 1) % 26
l = len(res) % 5
if l > 0:
res += ''.join([choice(ascii_lowercase) for i in range(0, 5 - l)])
return ' '.join([res[i:i+5] for i in range(0, len(res), 5)])
def dracondi_dec(msg:str, ka1:str, ka2:str):
res = ''
msg = prepmsg(msg)
offs = ka1.index(msg[0])
for i,c in enumerate(msg[1:]):
res += ka1[(26 + ka1.index(c) - offs) % 26]
offs = (ka2.index(c) + i + 1) % 26
return res
# entrypoint parameters: [mode] [key1] [key2]
# modes: e - encrypt, d - decrypt, k - print out keyed alphabets
def main():
mode = sys.argv[1].lower()
kp1 = sys.argv[2]
kp2 = sys.argv[3]
ka1 = dracondi_key(kp1)
ka2 = dracondi_key(kp2)
if mode.startswith('e'):
msg = sys.stdin.read()
print(dracondi_enc(msg, ka1, ka2))
elif mode.startswith('k'):
print('Keyed alphabet 1:', ka1)
print('Keyed alphabet 2:', ka2)
else:
msg = sys.stdin.read()
print(dracondi_dec(msg, ka1, ka2))
if __name__ == '__main__':
main()