Engineering your own voynich

[pf0072]

You need to click solve again on the main window after setting the numbers for the polyphones. (not very intuitive )

I did. It reopens the same "Polyphones" dialog.

Maybe there is something else that needs to be set ?

I would prefer a true polyalphabetic substitution mode with 3 alphabets, polyphones are much more difficult to solve.


For the "Substitution + monoalphabetic groups" the "Solve" button displays:
Error: input dimensions cannot exceed 100 by 100


Note: the big 8-grams file (beijinghouse) was loaded correctly after I re-compressed it with gzip. Thanks for the links.

I know this is old but I was having the same problem. I had to turn my ciphertext into a grid of text, instead of one long string. So the grid of ciphertext has to be less than 100 wide or tall. I don't know why, but it does. And when you hit solve, it'll bring up a grid to put cribs if you want. And then just hit solve again on the main window.

[mja0075]

Finally....

Byatan's key has a lot of overlaps and repeats, which is perhaps why it stunted us for so long. We needed to be solving for polyphones too.
However, @nablator your breakdown was very good, and even got the two four character keys.

Method:

You are not allowed to view links. Register or Login to view.

Same as nablator's cipher. Grab plaintext 3 characters at a time, 3 keys for each position, insert space, repeat.

His Key:

You are not allowed to view links. Register or Login to view.

key = {
    #pos 0
    0: {
        "a": "m",
        "b": "m",
        "c": "m",
        "d": "f",
        "e": "F",
        "f": "k",
        "g": "K",
        "h": "n",
        "i": "T",
        "k": "t",
        "l": "q",
        "m": "b",
        "n": "fi",
        "o": "fa",
        "p": "Fi",
        "r": "Ki",
        "s": "Ka",
        "t": "Ti",
        "u": "TI",
        "v": "TI",
        "w": "na",
        "y": "qii",
    },
    #pos 1
    1: {
        "a": "m",
        "b": "m",
        "c": "m",
        "d": "i",
        "e": "a",
        "f": "o",
        "g": "ii",
        "h": "iii",
        "i": "e",
        "k": "E",
        "l": "v",
        "m": "z",
        "n": "ai",
        "o": "ae",
        "p": "ia",
        "r": "oo",
        "s": "ei",
        "t": "ii",
        "u": "aa",
        "v": "aa",
        "w": "ee",
        "x": "iii",
        "y": "ooi",
        "z": "iiu",
    },
    #pos 2
    2: {
        "a": "z",
        "b": "x",
        "c": "r",
        "d": "l",
        "e": "g",
        "f": "k",
        "g": "K",
        "h": "n",
        "i": "T",
        "k": "t",
        "l": "q",
        "m": "b",
        "n": "aei",
        "o": "iea",
        "p": "ouy",
        "r": "ean",
        "s": "nuy",
        "t": "yun",
        "u": "pen",
        "w": "ben",
        "x": "vinn",
        "y": "uYnh",
        "z": "YNh",
    },
}

The plaintext:

You are not allowed to view links. Register or Login to view.

Need to strip numbers, punctuation and spaces:

Enigma has an electromechanical rotor mechanism that scrambles the 26 letters of the alphabet. In typical use, one person enters text on the Enigma's keyboard and another person writes down which of 26 lights above the keyboard lights up at each key press. If plain text is entered, the lit-up letters are the encoded ciphertext. Entering ciphertext transforms it back into readable plaintext. The rotor mechanism changes the electrical connections between the keys and the lights with each keypress. The security of the system depends on a set of machine settings that were generally changed daily during the war, based on secret key lists distributed in advance, and on other settings that were changed for each message. The receiving station has to know and use the exact settings employed by the transmitting station to successfully decrypt a message.

Source: You are not allowed to view links. Register or Login to view. second paragraph

Reproduction of Byatan's cipher in python:

You are not allowed to view links. Register or Login to view.

Code:

import re key = {     #pos 0     0: {         "a": "m",         "b": "m",         "c": "m",         "d": "f",         "e": "F",         "f": "k",         "g": "K",         "h": "n",         "i": "T",         "k": "t",         "l": "q",         "m": "b",         "n": "fi",         "o": "fa",         "p": "Fi",         "r": "Ki",         "s": "Ka",         "t": "Ti",         "u": "TI",         "v": "TI",         "w": "na",         "y": "qii",     },     #pos 1     1: {         "a": "m",         "b": "m",         "c": "m",         "d": "i",         "e": "a",         "f": "o",         "g": "ii",         "h": "iii",         "i": "e",         "k": "E",         "l": "v",         "m": "z",         "n": "ai",         "o": "ae",         "p": "ia",         "r": "oo",         "s": "ei",         "t": "ii",         "u": "aa",         "v": "aa",         "w": "ee",         "x": "iii",         "y": "ooi",         "z": "iiu",     },     #pos 2     2: {         "a": "z",         "b": "x",         "c": "r",         "d": "l",         "e": "g",         "f": "k",         "g": "K",         "h": "n",         "i": "T",         "k": "t",         "l": "q",         "m": "b",         "n": "aei",         "o": "iea",         "p": "ouy",         "r": "ean",         "s": "nuy",         "t": "yun",         "u": "pen",         "w": "ben",         "x": "vinn",         "y": "uYnh",         "z": "YNh",     }, } ciphertext = [] current_pos = 0 pos = 0 plaintext = ("Enigma has an electromechanical rotor mechanism that scrambles the 26 letters of the alphabet. In typical use, one person enters text on the Enigma's keyboard and another person writes down which of 26 lights above the keyboard lights up at each key press. If plain text is entered, the lit-up letters are the encoded ciphertext. Entering ciphertext transforms it back into readable plaintext. The rotor mechanism changes the electrical connections between the keys and the lights with each keypress. The security of the system depends on a set of machine settings that were generally changed daily during the war, based on secret key lists distributed in advance, and on other settings that were changed for each message. The receiving station has to know and use the exact settings employed by the transmitting station to successfully decrypt a message.") plaintext = plaintext.lower() plaintext = re.sub(r'[^A-Za-z]', '', plaintext) #get rid of non-letters # Encrypt the string character by character for char in plaintext:     ciphertext.append(key[current_pos][char])     # Cycle position: 0 -> 1 -> 2 -> 0 ...     current_pos = (current_pos + 1) % 3     pos = pos + 1     if current_pos == 0:         ciphertext.append(" ") out = "".join(ciphertext) original = "FaiT Kzz nmnuy maig qar Tiooiea bar nmaei Tmz qooiea Tiaeean bar nmaei Teib Tiiiiz Tieir Kimb mvg Kaiin Fvg Tiiig Kieiiea kiin Fmq Fiiiiz mayun Taiyun qiiiaT mmq TIeig faaig Fiaean Kaaeaei Faiyun Foonuy Tiavinn Tiaeaei Tiiiig FaiT Kzz KaEg qiimiea mool mail maiiea Tiiiig Kiiag Kieiiea fieeean Tiig Kaiiea naaiben ner naek qeK niinuy mmiea TIayun nat Fooix famean fvT Kiiiyun Kaaaouy miig mmn tauYnh Fioog KaeiT kiaq meaei Tiavinn Tienuy Faiyun Foog fiin FvT Tiaaouy qayun Tiaean Kamean Fiin Faaei mael Fir Tian Fooyun Fiiiyun Faiyun FooT fiiir Tian Fooyun Fiiiyun Tiooz fieik faoob Kaeyun mmr teaei Tiaeean Fml mmq Fiaq meaei Tiavinn Tiiin Fooiea Tiaeean bar nmaei Teib miiiz fiiig Kaiin Faq Fmyun Kier mvr faaiaei Fmyun Taeaei Kamg Tieeg Faiyun nat Fooinuy mail Tiiiig qeK niinuy naeyun naz miiit Fooiouy Kianuy Kaiin Feig maaean TiiuYnh faoyun nanuy qiieiyun Fzl Fiag fiinuy faaiz Kaayun faob mmn Taig Kaayun Tieaei Keiyun nmyun naaean Fiig fiaean mvq qiimn maiK Fil meq qiiipen Kieaei Kiin Feez Kimz Kaal faainuy Fmean Fiit Fooiq Teiyun KaiT Kaiiean Tmpen Tial Taiz faaz fimg mail faaiiea Tiiiig Kieig TiiiT fiiinuy Tiiiiz Tieeg Kiar nmaei Kal kaeean Fmr nzg Kaeiz Kayun naean Fmg TaaT fiiinuy Timyun Taeaei nmnuy Tiaet fiaeben mail TIeig Tiiiig Fiiiz miinuy Fiiyun TaiK Kaab Fiviea qiial mooiyun nayun Kimaei KazT TiiiT fiiinuy Timyun Taeaei Tiaenuy TImr Feinuy kaaq qooil Fmean qiiiayun mzg Kaeiz Ka" print(out) print ("\nMatch:" + str(out == original))

[oshfdk]

Byatan's key has a lot of overlaps and repeats, which is perhaps why it stunted us for so long. We needed to be solving for polyphones too.
However, @nablator your breakdown was very good, and even got the two four character keys.

Congratulations! How practical is it for reading if used as an actual cipher? Is it always simple to determine the boundaries between the positions?

Could you share some details of how you managed to crack it?

This is also optimistic news for those of us who think they know how the Voynich manuscript was created (be it a specific cipher, exotic language or some other method), but so far can't come up with a solution. Sometimes you just need to keep digging.

[nablator]

Thank you so much! I wasn't expecting a polyphonic cipher, and I wasn't expecting so many ambiguities in the breakdown, even when "iiu" and "YNh" are removed (no need for "z" as it's not in the plaintext):

Code:

f+ii is also fi+i f+iii is also fi+ii f+ia is also fi+a F+ii is also Fi+i F+iii is also Fi+ii F+ia is also Fi+a q+iii is also qii+i na+a is also n+aa na+e is also n+ae na+i is also n+ai Ti+ii is also T+iii Ti+a is also T+ia Ti+i is also T+ii Ka+a is also K+aa Ka+e is also K+ae Ka+i is also K+ai fa+a is also f+aa fa+e is also f+ae fa+i is also f+ai Ki+ii is also K+iii Ki+a is also K+ia Ki+i is also K+ii

[oshfdk]

Thank you so much! I wasn't expecting a polyphonic cipher, and I wasn't expecting so many ambiguities in the breakdown, even when "iiu" and "YNh" are removed (no need for "z" as it's not in the plaintext):

Congrats to you too! I think your effort was also essential for solving this.

So, is this generally just a bad quality cipher that would be a pain to read? Are there many cases when ambiguities both resolve to common plaintext combinations?

[nablator]

So, is this generally just a bad quality cipher that would be a pain to read? Are there many cases when ambiguities both resolve to common plaintext combinations?

The ambiguities are all in the first 2 of the 3 positions:
Ti+a is also T+ia so plaintext "te" = "ip"
Ti+i is also T+ii so plaintext "td" = "ig" = "it"
Ka+a is also K+aa so plaintext "se" = "gu" = "gv"
Ka+e is also K+ae so plaintext "si" = "go"
Ka+i is also K+ai so plaintext "sd" = "gn"
fa+a is also f+aa so plaintext "oe" = "du" = "dv"
fa+e is also f+ae so plaintext "oi" = "do"
fa+i is also f+ai so plaintext "od" = "dn"
Ki+ii is also K+iii so plaintext "rg" = "rt" = "gh" = "gx"
Ki+a is also K+ia so plaintext "re" = "gp"
Ki+i is also K+ii so plaintext "rd" = "gg" ="gt"
... and there are many more, not sure why my program missed them:
T+iii is also Ti+ii so plaintext "ih" = "ix" = "tg" = "tt"
Fi+i is also F+ii so plaintext "pd" = "eg" = "et"
f+ia is also fi+a so plaintext "dp" = "ne"
etc.

Some of these combinations occur in Byatan's ciphertext, so the deciphering process is ambiguous and needs a dictionary to resolve multiple possibilities.

[Koen G]

Nice work! I did not expect this thread to reach such a clean resolution.

The ambiguities seem a bit arbitrary? In the sense that they could probably be avoided with some optimization?

[nablator]

The ambiguities seem a bit arbitrary? In the sense that they could probably be avoided with some optimization?

Yes. I found several possible unambiguous partitions without any empty string in any of the 3 positions (24 - 24 - 23 or 25 - 24 - 22 letters or similar). The ambiguous partitions scored low and were discarded by my program. It didn't work very well actually, I did most of the optimisation manually, using the program for scoring only (i.e. counting the ambiguities and the size of the 3 alphabets that were combined in the score).

[RobGea]

Congratulations and very well done mja0075
Respect to nablator  

[mja0075]

Congratulations! How practical is it for reading if used as an actual cipher? Is it always simple to determine the boundaries between the positions?

By my count there are (including duplicates):
106 groups with 1 possible decoding 
    40 groups with 2 possible decodings 
    62 groups with 3 possible decodings
    13 groups with 4 possible decodings
    6 groups with 6 possible decodings
    6 groups with 9 possible decodings (anything starting with "mm")

Which means, more than half of the "words" in the cipher are not deterministic, and there are 6.98x10^59 different decodes with this key.

However, most of these obviously produce nonsense english, so in reality it's not too bad, but it is slow to try the different word combinations. There's also no spaces encoded.

Could you share some details of how you managed to crack it?

I had been using nablator's cipher as an example case to try and build faster segmentation that could quickly and reliably find keys that successfully decrypted with AZDecrypt. This never got anywhere with Byatan's though, so I had claude pull AZDecrypt's scoring and decryption logic into the loop.

So basically, instead of segmenting the text, and then trying to solve, redoing segmentation with decryption runs in between. 

Some other notes:

You are not allowed to view links. Register or Login to view.

Score stolen from AZDecrypt is:
ngram (sum of ngram log scores)* (entropy) ^ entropy_weight (1)
plus some negative scores around number of symbols and polyphones

6-grams were sufficient.

The code assumed the layout of the cipher matched nablator's 3 column idea.

Eventually saw "enigma" in the output:
"enigmahasanelectrovechaniaalrotorvechanism" 

Googling led to wikipedia, which provided source text.

And then it was just iterating over the key until the outputs matched.
With such an easily identifiable source text, it only took about 5 minutes to iterate over the key.

My code is a mess, I will try and post a cleaned version sometime soon.

Respect to nablator  

Agreed!