dekryptos 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 593f93ec638be132440da71be3eb1374943a24c3
+  data.tar.gz: 7ed51ee4afe57848bb12b4ec27ddcd3e5fe30ffe
+SHA512:
+  metadata.gz: 333bc3c6fc65dc198f060c30e5f5c0dc69cd315c8d6f8880a2a79ed6fbd3572fa2ab748c9e5ebec56807c2405431a4e388abaec7b95b57db532f2d3bbd7b3477
+  data.tar.gz: 16b3b9da8896ba425ed72a51e841b89df3411218d858bfb205b33dc164d50c5865cc46a4c250af2e84f224b5001dbbed3a2388950cd4306093691491d2ad84a2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 - 2014 Eric Weinstein
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+D E K Я Y P T O S
+===================
+
+## About
+These are little bits o' Ruby magic I've been using to mess around with decrypting parts of the [Kryptos sculpture](http://en.wikipedia.org/wiki/Kryptos).
+
+## Dependencies
+* Ruby (2.0+).
+
+## Installation
+```bash
+$ gem install dekryptos
+```
+
+## Examples
+```bash
+$ dekrypt -t EMUFPHZLRFAXYUSDJKZLDKRNSHGNFIVJYQTQUXQBQVYUVLLTREVJYQTMKYRDMFD -k KRYPTOS,PALIMPSEST -c vigenere
+BETWEENSUBTLESHADINGANDTHEABSENCEOFLIGHTLIESTHENUANCEOFIQLUSION
+
+$ dekrypt -t VFPJUDEEHZWETZYVGWHKKQETGFQJNCEGGWHKK?DQMCPFQZDQMMIAGPFXHQRLGTIMVMZJANQLVKQEDAGDVFRPJUNGEUNAQZGZLECGYUXUEENJTBJLBQCRTBJDFHRRYIZETKZEMVDUFKSJHKFWHKUWQLSZFTIHHDDDUVH?DWKBFUFPWNTDFIYCUQZEREEVLDKFEZMOQQJLTTUGSYQPFEUNLAVIDXFLGGTEZ?FKZBSFDQVGOGIPUFXHHDRKFFHQNTGPUAECNUVPDJMQCLQUMUNEDFQELZZVRRGKFFVOEEXBDMVPNFQXEZLGREDNQFMPNZGLFLPMRJQYALMGNUVPDXVKPDQUMEBEDMHDAFMJGZNUPLGESWJLLAETG -k KRYPTOS,ABSCISSA -c vigenere
+
+ITWASTOTALLYINVISIBLEHOWSTHATPOSSIBLETHEYUSEDTHEEARTHSMAGNETICFIELDXTHEINFORMATIONWASGATHEREDANDTRANSMITTEDUNDERGRUUNDTOANUNKNOWNLOCATIONXDOESLANGLEYKNOWABOUTTHISTHEYSHOULDITSBURIEDOUTTHERESOMEWHEREXWHOKNOWSTHEEXACTLOCATIONONLYWWTHISWASHISLASTMESSAGEXTHIRTYEIGHTDEGREESFIFTYSEVENMINUTESSIXPOINTFIVESECONDSNORTHSEVENTYSEVENDEGREESEIGHTMINUTESFORTYFOURSECONDSWESTXLAYERTWO
+
+$ dekrypt -t ENDYAHROHNLSRHEOCPTEOIBIDYSHNAIACHTNREYULDSLLSLLNOHSNOSMRWXMNETPRNGATIHNRARPESLNNELEBLPIIACAEWMTWNDITEENRAHCTENEUDRETNHAEOETFOLSEDTIWENHAEIOYTEYQHEENCTAYCREIFTBRSPAMHHEWENATAMATEGYEERLBTEEFOASFIOTUETUAEOTOARMAEERTNRTIBSEDDNIAAHTTMSTEWPIEROAGRIEWFEBAECTDDHILCEIHSITEGOEAOSDDRYDLORITRKLMLEHAGTDHARDPNEOHMGFMFEUHEECDMRIPFEIMEHNLSSTTRTVDOHW -k 4 -c transposition
+
+YOSOEIHANULLSMMPANPNEIATINCEEATSIHOYEAEBAEAAYLESTUTMRTEITTIAEBTIITEDDILHDDOFUCIINTVWDRLETBSITYSLHSXTGHRLLPCMDEHNRHELTNIEETRTPHNMGREAOTORERSNHSPOIECHEIOSYRKETREGEEREHSTHNHNHPIYAHEDSOOWENIASELAWNEAEDNOODEETHCCFSHEAEETOIEEAENBDAMWRRFEDCSGORORLGANMFEMFESROEAHRCODNCRLLNNRNRTRENBIEWTRTUTEFEWAYQNYIRMWTTEBFFUAOATIDATEEGWADLHEADLTMAHPHMHDPMLTD
+
+$ dekrypt -t YOSOEIHANULLSMMPANPNEIATINCEEATSIHOYEAEBAEAAYLESTUTMRTEITTIAEBTIITEDDILHDDOFUCIINTVWDRLETBSITYSLHSXTGHRLLPCMDEHNRHELTNIEETRTPHNMGREAOTORERSNHSPOIECHEIOSYRKETREGEEREHSTHNHNHPIYAHEDSOOWENIASELAWNEAEDNOODEETHCCFSHEAEETOIEEAENBDAMWRRFEDCSGORORLGANMFEMFESROEAHRCODNCRLLNNRNRTRENBIEWTRTUTEFEWAYQNYIRMWTTEBFFUAOATIDATEEGWADLHEADLTMAHPHMHDPMLTD -k 48 -c transposition
+
+SLOWLYDESPARATLYSLOWLYTHEREMAINSOFPASSAGEDEBRISTHATENCUMBEREDTHELOWERPARTOFTHEDOORWAYWASREMOVEDWITHTREMBLINGHANDSIMADEATINYBREACHINTHEUPPERLEFTHANDCORNERANDTHENWIDENINGTHEHOLEALITTLEIINSERTEDTHECANDLEANDPEEREDINTHEHOTAIRESCAPINGFROMTHECHAMBERCAUSEDTHEFLAMETOFLICKERBUTPRESENTLYDETAILSOFTHEROOMWITHINEMERGEDFROMTHEMISTXCANYOUSEEANYTHINGQ
+```
+
+## Ciphers
+There are currently files for Autokey, Monoalphabetic (simple ROT-13), Playfair, Transposition, and Vigenere ciphers.
+
+## Contributing
+1. Branch (`git checkout -b fancy-new-feature`)
+2. Commit (`git commit -m "Fanciness!"`)
+3. Lint (`bundle exec rake rubocop`)
+4. Test (`bundle exec rake spec`)
+5. Generate documentation (`bundle exec rake rdoc`)
+6. Push (`git push origin fancy-new-feature`)
+7. Ye Olde Pulle Request

data/Rakefile

@@ -0,0 +1,36 @@
+#!/usr/bin/env rake
+# encoding: UTF-8
+
+require 'rdoc/task'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+task default: :help
+
+desc 'Display help menu'
+task :help do
+  puts <<-eos
+  Available Rake tasks:
+
+  rake rdoc     # Generate documentation
+  rake rubocop  # Lint
+  rake spec     # Test
+  eos
+end
+
+desc 'Generate documentation'
+RDoc::Task.new do |rdoc|
+  rdoc.main = 'README.rdoc'
+  rdoc.rdoc_files.include('README.md', 'lib/**/*.rb')
+end
+
+desc 'Lint'
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.patterns = %w(lib/**/*.rb)
+end
+
+desc 'Test'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ['--color --format d']
+  t.pattern    = './spec/**/*_spec.rb'
+end

data/bin/dekrypt

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+
+# Author:: Eric Weinstein
+# Copyright:: (c) 2014 Eric Weinstein
+# License:: MIT (see LICENSE)
+
+require 'optparse'
+require 'ostruct'
+require_relative '../lib/dekryptos'
+
+class Dekrypt
+  def self.parse(args)
+    options = OpenStruct.new
+
+    opt_parser = OptionParser.new do |opts|
+      opts.banner = 'Usage: dekrypt -t TEXT -k KEYS -c CIPHER'
+      opts.separator ''
+      opts.separator 'Running dekryptos with the dekrypt command:'
+      opts.separator '  TEXT is a block of text (without spaces or punctuation)'
+      opts.separator '  that you would like to decrypt.'
+      opts.separator ''
+      opts.separator '  KEYS is a list of comma-delimited words to be used'
+      opts.separator '  as keys in your deciphering.'
+      opts.separator ''
+      opts.separator '  CIPHER is the name of the cipher you would like to use.'
+      opts.separator '  Supported ciphers: autokey, monoalphabetic, playfair,'
+      opts.separator '  transposition, vigenere.'
+      opts.separator ''
+
+      opts.on('-h', '--help', 'Display this screen') do
+        puts opt_parser
+        exit
+      end
+
+      opts.on('-t t', '--text t', String, 'Enter ciphertext') do |text|
+        options.text = text
+      end
+
+      opts.on('-k a,b,c', '--keys a,b,c', Array, 'Enter key(s)') do |key|
+        options.keys = key
+      end
+
+      opts.on('-c c', '--cipher c', String, 'Enter cipher name') do |cipher|
+        options.cipher = cipher
+      end
+    end
+
+    begin opt_parser.parse!(args)
+      cipher = options.cipher.capitalize
+      self.class.send(:include, Object.const_get(cipher))
+
+      case cipher
+      when 'Autokey'
+        puts decrypt(options.text, build_tabula_recta, options.keys.first)
+      when 'Monoalphabetic'
+        puts rot_13(options.text)
+      when 'Playfair'
+        puts decrypt(options.text, build_table(options.keys.first))
+      when 'Transposition'
+        puts decrypt(options.text, options.keys.first.to_i)
+      when 'Vigenere'
+        key_one = options.keys.first
+        key_two = options.keys.last
+        puts decrypt(options.text, build_table(key_one, key_two), key_two)
+      else
+        fail "[!] Unknown cipher: #{options.cipher}"
+      end
+    rescue => e
+      msg = "[!] An error occurred: #{e.message}\n"
+      msg << "#{e.backtrace.join("\n")}\n\n"
+      msg << "Run dekrypt -h for help."
+      abort(msg)
+    end
+    options
+  end
+end
+
+Dekrypt.parse(ARGV)

data/lib/dekryptos/analysis.rb

@@ -0,0 +1,132 @@
+# encoding: UTF-8
+
+# Author:: Eric Weinstein
+# Copyright:: (c) 2014 Eric Weinstein
+# License:: MIT (see LICENSE)
+
+##
+# Tools for analyzing suggested Kryptos solutions.
+module Analysis
+  # Public: Provides all factors of a given number.
+  #
+  # === Parameter(s)
+  # +n+ - +Integer+: The number to factor.
+  #
+  # === Return Value
+  # +Array<Integer>+: A list of factors.
+  def factor(n)
+    factors = []
+    (1..n).each do |x|
+      factors << x if n % x == 0
+    end
+
+    factors
+  end
+
+  # Public: Provides all anagrams for a given word.
+  #
+  # === Parameter(s)
+  # +text+ - +String+: The text to anagram.
+  #
+  # === Return Value
+  # +Array<String>+: A list of anagrams.
+  # rubocop: disable MethodLength, UnderscorePrefixedVariableName
+  def anagram(text)
+    head, tail = [], text.split('')
+    stack = [[head, tail]]
+    result = []
+
+    while stack.size > 0
+      head, tail = stack.pop
+      if tail.size.zero?
+        result << head
+      else
+        tail.each_with_index do |_, i|
+          _tail = tail.dup
+          curr  = _tail.delete_at(i)
+          _head = head.dup
+          _head << curr
+          stack << [_head, _tail]
+        end
+      end
+    end
+
+    result.map! { |p| p.join('') }
+    result.uniq!
+    result
+  end
+  # rubocop: enable MethodLength, UnderscorePrefixedVariableName
+
+  # Public: Checks whether one word or phrase is
+  # an anagram of another.
+  #
+  # === Parameter(s)
+  # +phrase_one+ - +String+: A word or phrase.
+  # +phrase_two+ - +String+: A word or phrase that
+  # may be an anagram of +phrase_one+.
+  #
+  # === Return Value
+  # +Boolean+: True if one phrase is an anagram
+  # of the other, false otherwise.
+  def anagram?(phrase_one, phrase_two)
+    phrase_one.split('').sort == phrase_two.split('').sort
+  end
+
+  # Public: Performs frequency analysis on the provided
+  # text.
+  #
+  # === Parameter(s)
+  # +text+ - +String+: The text to analyze.
+  #
+  # === Return Value
+  # +Hash<String, Integer>+: A hash representing the
+  # letter frequencies.
+  def frequency(text)
+    text  = text.downcase.gsub(/\s*/, '')
+    chars = text.split('')
+    freqs = Hash[('a'..'z').to_a.zip([0] * 26)]
+
+    chars.each do |c|
+      freqs[c] += 1
+    end
+
+    freqs
+  end
+
+  # Public: Calculates the index of coincidence for
+  # the given text (see http://en.wikipedia.org/wiki/
+  # Index_of_coincidence).
+  #
+  # === Parameter(s)
+  # +text+ - +String+: The text to analyze.
+  #
+  # === Return Value
+  # +Float+: The index of coincidence for the text.
+  def ioc(text)
+    c     = 26.0
+    freqs = frequency(text)
+    n     = text.length
+
+    f = freqs.values.reduce(0) { |a, e| a + (e * (e - 1)) }
+    f / ((n * (n - 1)) / c)
+  end
+
+  # Public: Calculates the percentage of text composed
+  # of vowels. (Y is not included as a vowel.)
+  #
+  # === Parameter(s)
+  # +text+ - +String+: The text to analyze.
+  #
+  # === Return Value
+  # +Float+: The percentage comprising vowels.
+  def vowels(text)
+    vowels = %w(A E I O U)
+    chars = text.upcase.split('')
+    vowel_count = 0
+    chars.each do |c|
+      vowel_count += 1 if vowels.include? c
+    end
+
+    vowel_count.to_f / text.length
+  end
+end

data/lib/dekryptos/autokey.rb

@@ -0,0 +1,118 @@
+# encoding: UTF-8
+
+# Author:: Eric Weinstein
+# Copyright:: (c) 2014 Eric Weinstein
+# License:: MIT (see LICENSE)
+
+##
+# Encryption/decryption using autokey ciphers
+# (http://en.wikipedia.org/wiki/Autokey_cipher)
+module Autokey
+  # Public: encrypts plaintext via autokey cipher.
+  #
+  # We generate our key by prepending the keyword to
+  # the plaintext. Then, for each pair formed by the
+  # i-th index of the key and the plaintext, we look
+  # up that (row, column) coordinate in the tabula
+  # recta and add it to the ciphertext.
+  #
+  # === Parameter(s)
+  # +plaintext+ - +String+: the text to be encrypted.
+  # +table+ - +Array+: the table generated by +build_tabula_recta+.
+  # +keyword+ - +String+: the keyword to be prepended to the plaintext
+  # to form the key.
+  #
+  # === Return Value
+  # +String+: the encrypted text.
+  #
+  # === Example
+  #
+  # +encrypt('ATTACKATDAWN', build_tabula_recta, 'KRYPTOS')+
+  # +=> "KKRPVYSTWTWP"+
+  def encrypt(plaintext, table, keyword)
+    ciphertext = ''
+    plaintext.upcase!
+    keyword.upcase!
+
+    key = (keyword + plaintext).split('')
+
+    plaintext.tr('?', '').split('').each_with_index do |letter, index|
+      ciphertext << table[table[0].index(letter)][table[0].index(key[index])]
+    end
+
+    ciphertext
+  end
+
+  # Public: decrypts ciphertext via autokey cipher.
+  #
+  # For each pair formed by the i-th index of the key and
+  # ciphertext, we look up the ciphertext letter in the key
+  # letter row and add the corresponding letter from the top
+  # row to the plaintext. Because the text is enciphered with
+  # itself, we continuously append the deciphered text to the
+  # key as we go along.
+  #
+  # === Parameter(s)
+  # +ciphertext+ - +String+: the text to be decrypted.
+  # +table+ - +Array+: the table generated by +build_tabula_recta+.
+  # +keyword+ - +String+: the keyword used to encrypt the text.
+  #
+  # === Return Value
+  # +String+: the decrypted text.
+  #
+  # === Example
+  #
+  # +decrypt('KKRPVYSTWTWP', build_tabula_recta, 'KRYPTOS')+
+  # +=> "ATTACKATDAWN"+
+  def decrypt(ciphertext, table, keyword)
+    plaintext = ''
+    ciphertext.upcase!
+    keyword.upcase!
+
+    key = (keyword).split('')
+
+    ciphertext.tr('?', '').split('').each_with_index do |letter, index|
+      plaintext << table[0][table[table[0].index(key[index])].index(letter)]
+      key << table[0][table[table[0].index(key[index])].index(letter)]
+    end
+
+    plaintext
+  end
+
+  # Public: generates the tabula recta needed to encrypt
+  # text via autokey cipher.
+  #
+  # === Parameter(s)
+  # None.
+  #
+  # === Return Value
+  # +Array+: a two-dimensional array of characters (26 x 26).
+  #
+  # === Example
+  # +build_tabula_recta+
+  #
+  # (See http://en.wikipedia.org/wiki/Tabula_recta for an example.)
+  def build_tabula_recta
+    table = []
+    row = alphabet
+
+    alphabet.each do |letter|
+      table << row.rotate(row.index(letter))
+    end
+
+    table
+  end
+
+  private
+
+  # Private: generates an alphabet.
+  #
+  # === Parameter(s)
+  # None.
+  #
+  # === Return Value
+  # +Array+: an array comprising the letters of the alphabet.
+  def alphabet
+    ('A'..'Z').to_a
+  end
+end

data/lib/dekryptos/kryptos.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+
+# Author:: Eric Weinstein
+# Copyright:: (c) 2014 Eric Weinstein
+# License:: MIT (see LICENSE)
+
+##
+# == K1, K2, K3, K4
+#
+# These are the four parts of the Kryptos sculpture
+# (http://en.wikipedia.org/wiki/Kryptos).
+module Kryptos
+  # This is the first section of the ciphertext.
+  K1 = 'EMUFPHZLRFAXYUSDJKZLDKRNSHGNFIVJYQTQUXQ'\
+  'BQVYUVLLTREVJYQTMKYRDMFD'
+
+  # I've added an extra 'S' eight characters before the
+  # end of K2 in order to correct Jim's error (the final
+  # words should be "X LAYER TWO" and not "ID BY ROWS").
+  K2 = 'VFPJUDEEHZWETZYVGWHKKQETGFQJNCEGGWHKK?D'\
+  'QMCPFQZDQMMIAGPFXHQRLGTIMVMZJANQLVKQEDAGDVFRPJUNGEU'\
+  'NAQZGZLECGYUXUEENJTBJLBQCRTBJDFHRRYIZETKZEMVDUFKSJH'\
+  'KFWHKUWQLSZFTIHHDDDUVH?DWKBFUFPWNTDFIYCUQZEREEVLDKF'\
+  'EZMOQQJLTTUGSYQPFEUNLAVIDXFLGGTEZ?FKZBSFDQVGOGIPUFX'\
+  'HHDRKFFHQNTGPUAECNUVPDJMQCLQUMUNEDFQELZZVRRGKFFVOEE'\
+  'XBDMVPNFQXEZLGREDNQFMPNZGLFLPMRJQYALMGNUVPDXVKPDQUM'\
+  'EBEDMHDAFMJGZNUPLGESWJLLAETG'
+
+  # I've omitted the final '?' from K3 in order to
+  # facilitate correct transposition.
+  K3 = 'ENDYAHROHNLSRHEOCPTEOIBIDYSHNAIACHTNR'\
+  'EYULDSLLSLLNOHSNOSMRWXMNETPRNGATIHNRARPESLNNELEBLPI'\
+  'IACAEWMTWNDITEENRAHCTENEUDRETNHAEOETFOLSEDTIWENHAEI'\
+  'OYTEYQHEENCTAYCREIFTBRSPAMHHEWENATAMATEGYEERLBTEEFO'\
+  'ASFIOTUETUAEOTOARMAEERTNRTIBSEDDNIAAHTTMSTEWPIEROAG'\
+  'RIEWFEBAECTDDHILCEIHSITEGOEAOSDDRYDLORITRKLMLEHAGTD'\
+  'HARDPNEOHMGFMFEUHEECDMRIPFEIMEHNLSSTTRTVDOHW'
+
+  # This is the final (and as-yet untranslated)
+  # section of the ciphertext. According to Jim,
+  # NYPVTT deciphers to BERLIN.
+  K4 = 'OBKRUOXOGHULBSOLIFBBWFLRVQQPRNGKSSOTWT'\
+  'QSJQSSEKZZWATJKLUDIAWINFBNYPVTTMZFPKWGDKZXTJCDIGKUH'\
+  'UAUEKCAR'
+
+  # === Example Tables
+  #
+  # This is an example of a Vigenere cipher table.
+  EXAMPLE_VIGENERE_TABLE = [
+    %w(K R Y P T O S A B C D E F G H I J L M N Q U V W X Z),
+    %w(P T O S A B C D E F G H I J L M N Q U V W X Z K R Y),
+    %w(A B C D E F G H I J L M N Q U V W X Z K R Y P T O S),
+    %w(L M N Q U V W X Z K R Y P T O S A B C D E F G H I J),
+    %w(I J L M N Q U V W X Z K R Y P T O S A B C D E F G H),
+    %w(M N Q U V W X Z K R Y P T O S A B C D E F G H I J L),
+    %w(P T O S A B C D E F G H I J L M N Q U V W X Z K R Y),
+    %w(S A B C D E F G H I J L M N Q U V W X Z K R Y P T O),
+    %w(E F G H I J L M N Q U V W X Z K R Y P T O S A B C D),
+    %w(S A B C D E F G H I J L M N Q U V W X Z K R Y P T O),
+    %w(T O S A B C D E F G H I J L M N Q U V W X Z K R Y P)
+  ]
+
+  # This is an example of a Playfair cipher table.
+  EXAMPLE_PLAYFAIR_TABLE = [
+    %w(K R Y P T),
+    %w(O S A B C),
+    %w(D E F G H),
+    %w(I J L M N),
+    %w(U V W X Z)
+  ]
+end

data/lib/dekryptos/monoalphabetic.rb

@@ -0,0 +1,72 @@
+# encoding: UTF-8
+
+# Author:: Eric Weinstein
+# Copyright:: (c) 2014 Eric Weinstein
+# License:: MIT (see LICENSE)
+
+##
+# Assorted tools for encrypting/decrypting monoalphabetic substitution ciphers
+# (https://en.wikipedia.org/wiki/Substitution_cipher)
+module Monoalphabetic
+  # An error raised when a non-alphabetic character is passed to an encryption/
+  # decryption method.
+  class CharacterError < Exception; end
+
+  # Public: encrypts and decrypts text via ROT13
+  # (https://en.wikipedia.org/wiki/ROT13).
+  #
+  # * Each letter is shifted by 13 places in the alphabet, _e.g._ A -> N.
+  # * Because encryption/decryption are symmetric, the same method is used to
+  #   both encrypt and decrypt text.
+  #
+  # === Parameter(s)
+  # +plaintext+ - +String+: the text to be encrypted or decrypted.
+  #
+  # === Return Value
+  # +String+: the encrypted/decrypted text.
+  #
+  # === Example
+  #
+  # +rot_13('HELLO')+
+  # +=> "URYYB"+
+  #--
+  # rubocop:disable Style/MethodLength
+  #++
+  def rot_13(plaintext)
+    fail CharacterError,
+         'Plaintext must be a string' unless plaintext.respond_to? :upcase
+    letters = plaintext.upcase.split('')
+
+    ciphertext = []
+
+    letters.each do |letter|
+      fail CharacterError,
+           'Plaintext must be letters only' unless alphabet.include? letter
+
+      idx_to_check = alphabet.index(letter)
+      if idx_to_check < 13
+        ciphertext << alphabet[idx_to_check + 13]
+      else
+        ciphertext << alphabet[idx_to_check - 13]
+      end
+    end
+
+    ciphertext.join('')
+  end
+  #--
+  # rubocop:enable Style/MethodLength
+  #++
+
+  private
+
+  # Private: generates an alphabet.
+  #
+  # === Parameter(s)
+  # None.
+  #
+  # === Return Value
+  # +Array+: an array comprising the letters of the alphabet.
+  def alphabet
+    ('A'..'Z').to_a
+  end
+end

data/lib/dekryptos/playfair.rb

@@ -0,0 +1,197 @@
+# encoding: UTF-8
+
+# Author:: Eric Weinstein
+# Copyright:: (c) 2014 Eric Weinstein
+# License:: MIT (see LICENSE)
+
+##
+# Encryption/decryption using Playfair ciphers
+# (http://en.wikipedia.org/wiki/Playfair_cipher)
+module Playfair
+  # Public: builds the 5 x 5 grid for our Playfair cipher.
+  #
+  # === Parameter(s)
+  # +key+ - +String+: the key forms the first +key.length+ letters of
+  # the 5 x 5 grid from left to right (after repeats are omitted),
+  # followed by the remaining letters of the alphabet in order. In this
+  # algorithm, the letter 'Q' is removed from the table entirely to make
+  # it 5 x 5.
+  #
+  # === Return Value
+  # +Array+: a two-dimensional array of characters (5 x 5).
+  #
+  # === Example
+  # +build_table('KRYPTOS')+
+  #
+  # (See +EXAMPLE_PLAYFAIR_TABLE+ in +kryptos.rb+ for the result.)
+  #--
+  # rubocop:disable Style/MethodLength, Style/Next, Style/CyclomaticComplexity
+  #++
+  def build_table(key)
+    key = key.upcase.split('').uniq
+    grid = [[], [], [], [], []]
+
+    grid_letters = key
+    rest_of_grid = ('A'..'Z').to_a
+    rest_of_grid.each do |letter|
+      grid_letters << letter unless key.include? letter
+    end
+
+    grid_letters.delete('Q')
+
+    grid.each_with_index do |_, index|
+      grid[index] = grid_letters[index * 5, 5]
+    end
+  end
+
+  # Public: encrypts plaintext using a Playfair cipher.
+  #
+  # * If both elements of the pair are in the same row, we add the element
+  #   to the right to the ciphertext.
+  # * If the elements of the pair are in _different_ rows, we store the
+  #   location as a (row, index) tuple in +matches+ for evaluation as follows:
+  #   * Comparing two +matches+ at a time, if they share an index value, they
+  #     must be in the same column. We then push the values in the ensuing rows
+  #     to the ciphertext string.
+  #   * If the two +matches+ do _not_ share an index value, they must form
+  #     nonconsecutive vertices (opposing corners) of a rectangle. We then push
+  #     their complements to the ciphertext string, which is equivalent to
+  #     simply swapping their indices.
+  #   * After comparing each set of two +matches+, we shift them off the
+  #     +matches+ array and continue.
+  #
+  # === Parameter(s)
+  # +plaintext+ - +String+: the text to be encrypted.
+  # +grid+ - +Array+: the grid generated by +build_table+.
+  #
+  # === Return Value
+  # +String+: the encrypted text.
+  #
+  # === Example
+  # +encrypt('ATTACKATDAWN', EXAMPLE_PLAYFAIR_TABLE)+
+  # +=> "CYYCOTCYFOZL"+
+  def encrypt(plaintext, grid)
+    ciphertext = []
+    pairs = bigramify(plaintext)
+    matches = []
+
+    pairs.each do |pair|
+      grid.each_with_index do |row, index|
+        if row.include?(pair[0]) && row.include?(pair[1])
+          ciphertext << row[(row.index(pair[0]) + 1) % 5]
+          ciphertext << row[(row.index(pair[1]) + 1) % 5]
+        else
+          matches[0] = [index, row.index(pair[0])] if row.include?(pair[0])
+          matches[1] = [index, row.index(pair[1])] if row.include?(pair[1])
+        end
+      end
+      unless matches.empty?
+        if matches[0][1] == matches[1][1]
+          ciphertext << grid[(matches[0][0] + 1) % 5][matches[0][1]]
+          ciphertext << grid[(matches[1][0] + 1) % 5][matches[1][1]]
+          2.times { matches.shift }
+        else
+          ciphertext << grid[matches[0][0]][matches[1][1]]
+          ciphertext << grid[matches[1][0]][matches[0][1]]
+          2.times { matches.shift }
+        end
+      end
+    end
+
+    ciphertext.join('')
+  end
+
+  # Public: decrypts ciphertext using a Playfair cipher.
+  #
+  # * If both elements of the pair are in the same row, we add the element to
+  #   the left to the ciphertext.
+  # * If the elements of the pair are in _different_ rows, we store the location
+  #   as a (row, index) tuple in +matches+ for evaluation as follows:
+  #   * Comparing two +matches+ at a time, if they share an index value, they
+  #     must be in the same column. We then push the values in the preceding
+  #     rows to the ciphertext string.
+  #   * If the two +matches+ do _not_ share an index value, they must form
+  #     nonconsecutive vertices (opposing corners) of a rectangle. We then push
+  #     their complements to the ciphertext string, which is equivalent to
+  #     simply swapping their indices.
+  #   * After comparing each set of two +matches+, we shift them off the
+  #     +matches+ array and continue.
+  #
+  # === Parameter(s)
+  # +ciphertext+ - +String+: the text to be decrypted.
+  # +grid+ - +Array+: the grid generated by +build_table+.
+  #
+  # === Return Value
+  # +String+: the decrypted text.
+  #
+  # === Example
+  # +encrypt('CYYCOTCYFOZL', EXAMPLE_PLAYFAIR_TABLE)+
+  # +=> "ATTACKATDAWN"+
+  def decrypt(ciphertext, grid)
+    plaintext = []
+    pairs = bigramify(ciphertext)
+    matches = []
+
+    pairs.each do |pair|
+      grid.each_with_index do |row, index|
+        if row.include?(pair[0]) && row.include?(pair[1])
+          plaintext << row[(row.index(pair[0]) + 9) % 5]
+          plaintext << row[(row.index(pair[1]) + 9) % 5]
+        else
+          matches[0] = [index, row.index(pair[0])] if row.include?(pair[0])
+          matches[1] = [index, row.index(pair[1])] if row.include?(pair[1])
+        end
+      end
+      unless matches.empty?
+        if matches[0][1] == matches[1][1]
+          plaintext << grid[(matches[0][0] + 9) % 5][matches[0][1]]
+          plaintext << grid[(matches[1][0] + 9) % 5][matches[1][1]]
+          2.times { matches.shift }
+        else
+          plaintext << grid[matches[0][0]][matches[1][1]]
+          plaintext << grid[matches[1][0]][matches[0][1]]
+          2.times { matches.shift }
+        end
+      end
+    end
+
+    plaintext.join('')
+  end
+
+  private
+
+  # Private: converts text to bigrams for processing by our
+  # encryption/decryption methods.
+  #
+  # * If we encounter a double-letter bigram, we break it up with an X.
+  # * If we end up with an odd number of letters, we pad with a final X.
+  # * We replace any Qs with Xs (since +build_table+ omits Qs).
+  #
+  # === Parameter(s)
+  # +text+ - +String+: the text to convert to bigrams.
+  #
+  # === Return Value
+  # +Array+: an array of two-character strings (bigrams).
+  def bigramify(text)
+    text_array = text.upcase.split('')
+
+    text_array.each_with_index do |char, index|
+      if index.even?
+        if char == text_array[index + 1]
+          text_array.insert(index + 1, 'X')
+          text = text_array.join('')
+          bigramify(text)
+        end
+      end
+    end
+
+    text_array << 'X' if text_array.length.odd?
+    text = text_array.join('')
+    text.gsub!('Q', 'X')
+
+    text.split(/(.{2})/).reject { |pair| pair if pair.empty? }
+  end
+  #--
+  # rubocop:enable Style/MethodLength, Style/Next, Style/CyclomaticComplexity
+  #++
+end

data/lib/dekryptos/transposition.rb

@@ -0,0 +1,67 @@
+# encoding: UTF-8
+
+# Author:: Eric Weinstein
+# Copyright:: (c) 2014 Eric Weinstein
+# License:: MIT (see LICENSE)
+
+##
+# Encryption/decryption using keyed columnar transposition
+# (http://en.wikipedia.org/wiki/Transposition_cipher)
+module Transposition
+  # Public: encrypts text via keyed columnar transposition.
+  #
+  # The encryption method converts the plaintext to an array,
+  # each row within which comprises +width+ characters. The
+  # array is then transposed and each row is reversed, after
+  # which the array is converted back to a string.
+  #
+  # === Parameter(s)
+  # +plaintext+ - +String+: the text to be encrypted.
+  # +width+ - +Integer+: the width of each row in the intermediary
+  # table required for transposition.
+  #
+  # === Return Value
+  # +String+: the encrypted text.
+  #
+  # === Example
+  # Assuming +pt+ is the plaintext version of K3:
+  # +encrypt(encrypt(pt, 7), 84)+
+  # +=> # Results in K3+
+  def encrypt(plaintext, width)
+    matrix = plaintext.chars.each_slice(width).map(&:join)
+    matrix.each_with_index do |_, index|
+      matrix[index] = matrix[index].split('')
+    end
+
+    matrix.transpose.map(&:reverse).join('')
+  end
+
+  # Public: decrypts text via keyed columnar transposition.
+  #
+  # The decryption method converts the ciphertext to an array,
+  # each row within which comprises +width+ characters. Each
+  # row in the array is reversed and the entire array is
+  # transposed, after which the array is converted back to a
+  # string.
+  #
+  # === Parameter(s)
+  # +ciphertext+ - +String+: the text to be decrypted.
+  # +width+ - +Integer+: the width of each row in the intermediary
+  # table required for transposition.
+  #
+  # === Return Value
+  # +String+: the decrypted text.
+  #
+  # === Example
+  # Assuming +K3+ is part 3 of the Kryptos sculpture:
+  # +decrypt(decrypt(K3, 4), 48)+
+  # +=> # Results in the plaintext+
+  def decrypt(ciphertext, width)
+    matrix = ciphertext.chars.each_slice(width).map(&:join)
+    matrix.each_with_index do |_, index|
+      matrix[index] = matrix[index].split('')
+    end
+
+    matrix.map(&:reverse).transpose.join('')
+  end
+end

data/lib/dekryptos/vigenere.rb

@@ -0,0 +1,137 @@
+# encoding: UTF-8
+
+# Author:: Eric Weinstein
+# Copyright:: (c) 2014 Eric Weinstein
+# License:: MIT (see LICENSE)
+
+##
+# Encryption/decryption using Vigenere ciphers
+# (http://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher)
+module Vigenere
+  # Public: builds the tableau needed for encryption/decryption.
+  #
+  # === Parameter(s)
+  # +key1+ - +String+: the key found in each row. Optional; the default is a
+  # standard A-to-Z alphabet.
+  # +key2+ - +String+: the key that forms an acrostic down the left-hand side
+  # of the tableau.
+  #
+  # === Return Value
+  # +Array+: a two-dimensional array of characters comprising the tableau.
+  #
+  # === Example
+  #
+  # +build_table('KRYPTOS', 'PALIMPSEST')+
+  #
+  # (See +EXAMPLE_VIGENERE_TABLE+ in +krpytos.rb+ for the result.)
+  def build_table(key1 = alphabet.join(''), key2)
+    table = []
+
+    key1.upcase!
+    key2.upcase!
+
+    table[0] = key1.split('')
+    table[0] = populate_row(table[0], key1)
+    row = table[0]
+
+    key2.split('').each do |letter|
+      table << row.rotate(row.index(letter))
+    end
+
+    table
+  end
+
+  # Public: encrypts plaintext using a Vigenere cipher.
+  #
+  # For each letter in the plaintext, we loop through the first row of
+  # the tableau and add the corresponding character from the row we're
+  # currently on to the ciphertext string.
+  #
+  # === Parameter(s)
+  # +plaintext+ - +String+: the text to be encrypted.
+  # +table+ - +Array+: the table generated by +build_table+.
+  # +key+ - +String+: the alphabet key that forms an acrostic down the
+  # left-hand side of the tableau (+key2+ in +build_table+).
+  #
+  # === Return Value
+  # +String+: the encrypted text.
+  #
+  # === Example
+  #
+  # +encrypt('ATTACKATDAWN', EXAMPLE_VIGENERE_TABLE, 'PALIMPSEST')+
+  # +=> "DEUVRPGIJEKK"+
+  def encrypt(plaintext, table, key)
+    ciphertext = ''
+    key.upcase!
+
+    plaintext.tr('?', '').split('').each_with_index do |char, char_index|
+      table.first.each_with_index do |letter, letter_index|
+        ciphertext <<
+          table[char_index % key.length + 1][letter_index] if letter == char
+      end
+    end
+
+    ciphertext
+  end
+
+  # Public: decrypts plaintext using a Vigenere cipher.
+  #
+  # For each letter in the ciphertext, we loop through the tableau
+  # (starting at row 1) and add the corresponding character from row
+  # 0 to the plaintext string.
+  #
+  # === Parameter(s)
+  # +ciphertext+ - +String+: the text to be decrypted.
+  # +table+ - +Array+: the table generated by +build_table+.
+  # +key+ - +String+: the alphabet key that forms an acrostic down
+  # the left-hand side of the tableau (+key2+ in +build_table+).
+  #
+  # === Return Value
+  # +String+: the decrypted text.
+  #
+  # === Example
+  #
+  # +decrypt('DEUVRPGIJEKK', EXAMPLE_VIGENERE_TABLE, 'PALIMPSEST')+
+  # +=> "ATTACKATDAWN"+
+  def decrypt(ciphertext, table, key)
+    plaintext = ''
+    key.upcase!
+
+    ciphertext.tr('?', '').split('').each_with_index do |char, char_idx|
+      table[char_idx % key.length + 1].each_with_index do |letter, letter_idx|
+        plaintext << table.first[letter_idx] if letter == char
+      end
+    end
+
+    plaintext
+  end
+
+  private
+
+  # Private: builds a row in our Vigenere table.
+  #
+  # === Parameter(s)
+  # +row+ - +Array+: an array to which we add any alphabet letters,
+  # in order, that aren't part of the key (+key1+ in +build_table+).
+  #
+  # === Return Value
+  # +Array+: an array of characters constituting a row in the tableau.
+  def populate_row(row, key)
+    alphabet.each do |letter|
+      row << letter unless key.include? letter
+    end
+
+    row
+  end
+
+  # Private: generates an alphabet.
+  #
+  # === Parameter(s)
+  # None.
+  #
+  # === Return Value
+  # +Array+: an array comprising the letters of the alphabet.
+  def alphabet
+    ('A'..'Z').to_a
+  end
+end

data/lib/dekryptos.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+# Author:: Eric Weinstein
+
+require_relative 'dekryptos/analysis'
+require_relative 'dekryptos/autokey'
+require_relative 'dekryptos/kryptos'
+require_relative 'dekryptos/monoalphabetic'
+require_relative 'dekryptos/playfair'
+require_relative 'dekryptos/transposition'
+require_relative 'dekryptos/vigenere'

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: dekryptos
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Eric Weinstein
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-12 00:00:00.000000000 Z
+dependencies: []
+description: Some tools that might come in handy attempting to decrypt Kryptos.
+email:
+- eric.q.weinstein@gmail.com
+executables:
+- dekrypt
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dekryptos/analysis.rb
+- lib/dekryptos/autokey.rb
+- lib/dekryptos/kryptos.rb
+- lib/dekryptos/monoalphabetic.rb
+- lib/dekryptos/playfair.rb
+- lib/dekryptos/transposition.rb
+- lib/dekryptos/vigenere.rb
+- lib/dekryptos.rb
+- LICENSE
+- README.md
+- Rakefile
+- bin/dekrypt
+homepage: https://github.com/ericqweinstein/dekryptos
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Tools for working on the Kryptos sculpture.
+test_files: []
+has_rdoc: