पैटर्न विश्लेषण द्वारा डिक्रिप्शन

Question

आपको एक एन्क्रिप्टेड स्ट्रिंग दिया जाता है, एक बहुत ही सरल प्रतिस्थापन सिफर का उपयोग करके एन्क्रिप्ट किया गया है।

मुसीबत

आपको पता नहीं है कि सिफर क्या है, लेकिन आप जानते हैं कि सिफरटेक्स्ट अंग्रेजी है और उस क्रम में अंग्रेजी में सबसे लगातार अक्षर etaoinshrdlucmfwypvbgkkjjxz हैं । केवल स्वीकृत वर्ण अपरकेस अक्षर और स्थान हैं। आप बुनियादी विश्लेषण कर सकते हैं - एकल अक्षरों से शुरू, लेकिन आप अधिक जटिल मल्टी-लेटर विश्लेषण पर माइग्रेट कर सकते हैं - उदाहरण के लिए, यू लगभग हमेशा क्यू का अनुसरण करता है, और केवल कुछ अक्षर लगातार दो बार आ सकते हैं।

उदाहरण

clear : SUBMARINE TO ATTACK THE DOVER WAREHOUSE AND PORT ON TUESDAY SUNRISE
cipher: ZOQ DUPAEYSRYDSSDXVYSHEYNRBEUYLDUEHROZEYDANYKRUSYRAYSOEZNDMYZOAUPZE

clear : THE QUICK BROWN FOX BEING QUITE FAST JUMPED OVER THE LAZY DOG QUITE NICELY
cipher: TNAEPDHIGEMZQJLEVQBEMAHL EPDHTAEVXWTEODYUASEQKAZETNAERXFCESQ EPDHTAELHIARC

clear : BUFFALO BUFFALO BUFFALO BUFFALO BUFFALO BUFFALO BUFFALO
cipher: HV  WRPDHV  WRPDHV  WRPDHV  WRPDHV  WRPDHV  WRPDHV  WRP

चुनौतियां

देखें कि क्या आप इनमें से प्रत्येक सिफर में पाठ को डिक्रिप्ट कर सकते हैं:

• SVNXIFCXYCFSXKVVZXIHXHERDXEIYRAKXZCOFSWHCZXHERDXBNRHCXZR RONQHXORWECFHCUH
• SOFPTGFIFBOKJPHLBFPKHZUGLSOJPLIPKBPKHZUGLSOJPMOLEOPWFSFGJLBFIPMOLEOPXULBSIPLBP KBPBPWLIJFBILUBKHPGKISFG
• TMBWFYAQFAZYCUOYJOBOHATMCYNIAOQW Q JAXOYCOCYCHAACOCYCAHGOVYLAOEGOTMBWFYAOBFF ACOBHOKBZYKOYCHAUWBHAXOQW XITHJOV WOXWYLYCU
• FTRMKRGVRFMHSZVRWHRSFMFLMBNGKMGTHGBRSMKROKLSHSZMHKMMMMMRVVLVMPRKKOZRMFVDSGOFRW

मेरे पास प्रत्येक के लिए प्रतिस्थापन मेट्रिक्स और क्लीयरटेक्स्ट है, लेकिन मैं उन्हें केवल तभी प्रकट करूंगा जब यह बहुत मुश्किल हो जाएगा या कोई इसे समझ नहीं पाएगा।

जो समाधान सबसे संदेशों को सफलतापूर्वक डिक्रिप्ट कर सकता है, वह विजेता है। यदि दो समाधान समान रूप से अच्छे हैं, तो वे वोट गणना द्वारा तय किए जाएंगे।

Comments

क्या परिभाषित करता है »सबसे सुरुचिपूर्ण«? मुझे लगता है कि क्रिस ने 99 बोतलों पर पहले ही आपत्ति जताई थी। यह एक व्यक्तिपरक मानदंड है जो न्याय करने में काफी कठिन है।

— जॉय

@ जॉय सबसे ऊपर? समुदाय को तय करने दें।

— थॉमस ओ

पुन: "सबसे अधिक उत्थान": मैं इसे देखने के लिए दुखी हूँ एक लोकप्रियता प्रतियोगिता पद बन गया है, कम से कम नहीं क्योंकि पद अन्यथा उत्कृष्ट है; पूरे मामले पर मेरे विचारों के लिए meta.codegolf.stackexchange.com/questions/110/… देखें ।

— क्रिस जस्टर-यंग

यहाँ "सुरुचिपूर्ण" का क्या अर्थ है? सर्वश्रेष्ठ बिग-ओ प्रदर्शन?

— gnibbler

@ बैस 5098, नप। यह सिर्फ एक कठिन सिफरटेक्स्ट है जिसे आवृत्ति विश्लेषण के लिए अधिक लचीला बनाने के लिए दागी गई है।

— थॉमस ओ

Answer 1

अजगर

मैंने सभी गुप्त वाक्यांशों का पता लगा लिया है, लेकिन मैं उन्हें यहाँ पोस्ट नहीं करूँगा। अगर आपको परवाह है तो कोड चलाएं।

कोड एक स्पेस कैरेक्टर चुनकर, प्रत्येक शब्द के लिए सभी संभावित प्रतिस्थापनों की गणना करता है, फिर संगत प्रतिस्थापन की खोज करता है। यह क्लियरटेक्स्ट में गलत वर्तनी से निपटने के लिए कुछ आउट-ऑफ-लेक्सिकॉन शब्दों की भी अनुमति देता है :)

मैंने http://wordlist.sourceforge.net/ से एक बड़े लेक्सिकॉन (~ 500K शब्द) का उपयोग किया ।

import sys,re

# get input
message = sys.argv[1]

# read in lexicon of words
# download scowl version 7.1
# mk-list english 95 > wordlist
lexicon = set()
roman_only = re.compile('^[A-Z]*$')
for word in open('wordlist').read().upper().split():
  word=word.replace("'",'')
  if roman_only.match(word): lexicon.add(word)

histogram={}
for c in message: histogram[c]=0
for c in message: histogram[c]+=1
frequency_order = map(lambda x:x[1], sorted([(f,c) for c,f in histogram.items()])[::-1])

# returns true if the two maps are compatible.
# they are compatible if the mappings agree wherever they are defined,
# and no two different args map to the same value.
def mergeable_maps(map1, map2):
  agreements = 0
  for c in map1:
    if c in map2:
      if map1[c] != map2[c]: return False
      agreements += 1
  return len(set(map1.values() + map2.values())) == len(map1) + len(map2) - agreements

def merge_maps(map1, map2):
  m = {}
  for (c,d) in map1.items(): m[c]=d
  for (c,d) in map2.items(): m[c]=d
  return m

def search(map, word_maps, outside_lexicon_allowance, words_outside_lexicon):
  cleartext = ''.join(map[x] if x in map else '?' for x in message)
  #print 'trying', cleartext

  # pick a word to try next
  best_word = None
  best_score = 1e9
  for (word,subs) in word_maps.items():
    if word in words_outside_lexicon: continue
    compatible_subs=0
    for sub in subs:
      if mergeable_maps(map, sub): compatible_subs += 1
    unassigned_chars = 0
    for c in word:
      if c not in map: unassigned_chars += 1  #TODO: duplicates?
    if compatible_subs == 0: score = 0
    elif unassigned_chars == 0: score = 1e9
    else: score = 1.0 * compatible_subs / unassigned_chars   # TODO: tweak?
    if score < best_score:
      best_score = score
      best_word = word
  if not best_word:  # no words with unset characters, except possibly the outside lexicon ones
    print cleartext,[''.join(map[x] if x in map else '?' for x in word) for word in words_outside_lexicon]
    return True

  # use all compatible maps for the chosen word
  r = False
  for sub in word_maps[best_word]:
    if not mergeable_maps(map, sub): continue
    r |= search(merge_maps(map, sub), word_maps, outside_lexicon_allowance, words_outside_lexicon)

  # maybe this word is outside our lexicon
  if outside_lexicon_allowance > 0:
    r |= search(map, word_maps, outside_lexicon_allowance - 1, words_outside_lexicon + [best_word])
  return r

for outside_lexicon_allowance in xrange(3):
  # assign the space character first
  for space in frequency_order:
    words = [w for w in message.split(space) if w != '']
    if reduce(lambda x,y:x|y, [len(w)>20 for w in words]): continue  # obviously bad spaces

    # find all valid substitution maps for each word
    word_maps={}
    for word in words:
      n = len(word)
      maps = []
      for c in lexicon:
        if len(c) != n: continue
        m = {}
        ok = 1
        for i in xrange(n):
          if word[i] in m:                      # repeat letter
            if m[word[i]] != c[i]: ok=0; break  # repeat letters map to same thing
          elif c[i] in m.values(): ok=0; break  # different letters map to different things
          else: m[word[i]]=c[i]
        if ok: maps.append(m);
      word_maps[word]=maps

    # look for a solution
    if search({space:' '}, word_maps, outside_lexicon_allowance, []): sys.exit(0)

print 'I give up.'

Answer 2

PHP (अपूर्ण)

यह एक अधूरा PHP सॉल्यूशन है जो प्रश्न में अक्षर आवृत्ति की जानकारी का उपयोग करके काम करता है, साथ ही दिए गए शब्द में सबसे विश्वसनीय अक्षरों के आधार पर नियमित अभिव्यक्तियों के साथ मेल खाने वाले शब्दों का एक शब्दकोश है।

वर्तमान में शब्दकोश काफी छोटा है, लेकिन उपयुक्त विस्तार के साथ मुझे अनुमान है कि परिणाम बेहतर होंगे। मैंने आंशिक मैचों की संभावना पर विचार किया है लेकिन वर्तमान शब्दकोश के साथ परिणामों में सुधार के बजाय गिरावट में यह परिणाम है।

यहां तक ​​कि वर्तमान के साथ, छोटा शब्दकोश मुझे लगता है कि मैं काफी सुरक्षित रूप से कह सकता हूं कि चौथा संदेश क्या कहता है।

#!/usr/bin/php
<?php

    if($argv[1]) {

        $cipher = $argv[1];

        // Dictionary
        $words = explode("/", "the/to/on/and/in/is/secret/message");
        $guess = explode("/", "..e/t./o./a../i./.s/.e..et/.ess..e");

        $az = str_split("_etaoinshrdlucmfwypvbgkqjxz");

        // Build table
        for($i=0; $i<strlen($cipher); $i++) {
            $table[$cipher{$i}]++;
        }
        arsort($table);

        // Do default guesses
        $result = str_replace("_", " ", str_replace(array_keys($table), $az, $cipher));

        // Apply dictionary
        $cw = count($words);
        for($i=0; $i<$cw*2; $i++) {
            $tokens = explode(" ", $result);
            foreach($tokens as $t) {
                if(preg_match("/^" . $guess[$i%$cw] . "$/", $t)) {
                    $result = deenc($words[$i%$cw], $t, $result);
                    echo $t . ' -> ' . $words[$i%$cw] . "\n";
                    break;
                }
            }
        }

        // Show best guess
        echo $result . "\n";

    } else {

        echo "Usage: " . $argv[0] . " [cipher text]\n";

    }

    // Quick (non-destructive) replace tool
    function deenc($word, $enc, $string) {
        $string = str_replace(str_split($enc), str_split(strtoupper($word)), $string);
        $string = str_replace(str_split($word), str_split($enc), $string);
        return strtolower($string);
    }

?>

Comments

यदि आपके पास ऐसा सिस्टम है तो आप usr / usr / share / dict / words का उपयोग करके देखें।

— कीथ रान्डेल