sixword 0.1.0 → 0.2.0

data/bin/sixword

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require_relative '../lib/sixword'
+
+BaseName = File.basename($0)
+
+def puts_err(message)
+  $stderr.puts(BaseName + ': ' + message)
+end
+
+def parse_args
+  options = {pad: true}
+  optparse = OptionParser.new do |opts|
+    opts.banner = <<-EOM
+usage: #{BaseName} [OPTION]... [FILE]
+
+Six-word encode or decode FILE, or standard input, to standard output.
+
+The data are encoded using the 2048 word dictionary created for S/Key (tm) and
+standardized by RFC 2289, RFC 1760, and RFC 1751. It also supports an optional
+custom padding scheme to allow for messages that are not a multiple of 8 bytes.
+
+With no FILE, or when FILE is -, read standard input.
+
+#{BaseName} understands a few different styles of hexadecimal input and output.
+When encoding, the input will first be decoded to binary data before being
+encoded to words. When decoding, the output will be encoded in hex.
+
+
+Hex styles:
+
+  lower/lowercase:
+    Accept a variety of inputs, but don't include whitespace in output.
+
+    Encoding:
+      '48:69:20:77:6f:72:6c:64' => 'Hi world' => 'ACRE ADEN INN SLID MAD PAP'
+    Decoding:
+      'ACRE ADEN INN SLID MAD PAP' => 'Hi world' => '486920776f726c64'
+
+  finger/fingerprint:
+    Accept a variety of inputs, and include whitespace in output.
+    This is intended to look something like GPG fingerprints.
+
+    Encoding:
+      '4869 2077 6F72 6C64' => 'Hi world' => 'ACRE ADEN INN SLID MAP PAP'
+    Decoding:
+      'ACRE ADEN INN SLID MAP PAP' => 'Hi world' => '4869 2077 6F72 6C64'
+
+
+Options:
+    EOM
+
+    opts.on('-h', '--help', 'Display this message', ' ') do
+      $stderr.puts opts, ''
+      exit 0
+    end
+
+    #
+
+    opts.on('-d', '--decode', 'Decode data') do
+      options[:mode] = :decode
+    end
+
+    opts.on('-p', '--no-pad', "Don't use custom padding scheme", ' ') do
+      options[:pad] = false
+    end
+
+    #
+
+    opts.on('-S', '--hex-style STYLE',
+            'Treat input (when encoding) or print',
+            'output (when decoding) as hex') do |style|
+      options[:hex_style] = style
+    end
+
+    opts.on('-H', '--hex', 'Short for --hex-style lowercase') do
+      options[:hex_style] = 'lowercase'
+    end
+
+    opts.on('-f', '--fingerprint', 'Short for --hex-style fingerprint') do
+      options[:hex_style] = 'fingerprint'
+    end
+  end
+
+  optparse.parse!
+
+  case ARGV.length
+  when 0
+    filename = '-'
+  when 1
+    filename = ARGV.fetch(0)
+  else
+    $stderr.puts optparse, ''
+    puts_err "extra operand #{ARGV.fetch(1).inspect}"
+    exit 1
+  end
+
+  begin
+    runner = Sixword::CLI.new(filename, options)
+    runner.run!
+  rescue Sixword::CLI::CLIError => err
+    puts_err err.message
+    exit 2
+  rescue Sixword::InvalidParity => err
+    puts_err err.message
+    exit 3
+  rescue Sixword::UnknownWord => err
+    puts_err err.message
+    exit 4
+  rescue Sixword::InvalidWord => err
+    puts_err err.message
+    exit 5
+  rescue Sixword::InputError => err
+    puts_err err.message
+    exit 10
+  rescue Interrupt
+    $stderr.puts
+    exit 130 # not actually the same as signalled exit, but oh well
+  end
+end
+
+parse_args

data/lib/sixword.rb

@@ -1,3 +1,5 @@
+require_relative 'sixword/cli'
+require_relative 'sixword/hex'
 require_relative 'sixword/lib'
 require_relative 'sixword/version'
 require_relative 'sixword/words'
@@ -44,6 +46,10 @@ module Sixword
     words_per_slice = options.fetch(:words_per_slice)
     pad = options.fetch(:pad)
 
+    unless byte_string
+      raise ArgumentError.new("byte_string is falsy")
+    end
+
     unless block_given?
       return Enumerator.new(self, :encode_iter, byte_string, options)
     end
@@ -107,14 +113,4 @@ module Sixword
   def self.pad_decode(string_or_words)
     decode(string_or_words, padding_ok: true)
   end
-
-  def self.hex_string_to_byte_string(hex_string)
-    # strip whitespace, make sure it's valid hex
-    hex_string = hex_string.gsub(/\s+/, '')
-    if hex_string =~ /[^a-fA-F0-9]/
-      raise ArgumentError.new("Invalid value for hex: #{hex_string.inspect}")
-    end
-
-    [hex_string].pack('H*')
-  end
 end

data/lib/sixword/cli.rb

@@ -0,0 +1,202 @@
+module Sixword
+  class CLI
+    class CLIError < StandardError; end
+
+    attr_reader :filename, :options, :stream, :mode
+
+    def initialize(filename, options)
+      @filename = filename
+      @options = {mode: :encode, pad: false}.merge(options)
+
+      if filename == '-'
+        # dup stdin and put it into binary mode
+        @stream = $stdin.dup
+        @stream.binmode
+      else
+        # read in binary mode even on unix so ruby yields binary encoding
+        @stream = File.open(filename, 'rb')
+      end
+
+
+      @mode = @options.fetch(:mode)
+      unless [:encode, :decode].include?(mode)
+        raise ArgumentError.new("Invalid mode: #{mode.inspect}")
+      end
+    end
+
+    def pad?
+      options.fetch(:pad)
+    end
+
+    def encoding?
+      mode == :encode
+    end
+
+    def hex_style
+      options[:hex_style]
+    end
+
+    def print_hex(data, chunk_index, cols=80)
+      case hex_style
+      when 'lower', 'lowercase'
+        # encode to lowercase hex with no newlines
+        print Sixword::Hex.encode(data)
+      when 'finger', 'fingerprint'
+        # encode to GPG fingerprint like hex with newlines
+        newlines_every = cols / 5
+        if chunk_index != 0
+          if chunk_index % newlines_every == 0
+            print "\n"
+          else
+            print ' '
+          end
+        end
+        print Sixword::Hex.encode_fingerprint(data)
+      when 'colon', 'colons'
+        # encode to SSL/SSH fingerprint like hex with colons
+        print ':' unless chunk_index == 0
+        print Sixword::Hex.encode_colons(data)
+      end
+    end
+
+    def run!
+      if encoding?
+        do_encode! do |encoded|
+          puts encoded
+        end
+      else
+        chunk_index = 0
+        do_decode! do |decoded|
+          if hex_style
+            print_hex(decoded, chunk_index)
+            chunk_index += 1
+          else
+            print decoded
+          end
+        end
+
+        # add trailing newline for hex output
+        puts if hex_style
+      end
+    end
+
+    private
+
+    def do_decode!
+      unless block_given?
+        raise ArgumentError.new("block is required")
+      end
+
+      arr = []
+      read_input_by_6_words do |arr|
+        yield Sixword.decode(arr, padding_ok: pad?)
+      end
+    end
+
+    def do_encode!
+      process_encode_input do |chunk|
+        Sixword.encode_iter(chunk, words_per_slice:6, pad:pad?) do |encoded|
+          yield encoded
+        end
+      end
+    end
+
+    def process_encode_input
+      unless block_given?
+        raise ArgumentError.new("block is required")
+      end
+
+      if hex_style
+        # yield data in chunks from accumulate_hex_input until EOF
+        accumulate_hex_input do |hex|
+          begin
+            data = Sixword::Hex.decode(hex)
+          rescue ArgumentError => err
+            # expose hex decoding failures to user
+            raise CLIError.new(err.message)
+          else
+            yield data
+          end
+        end
+      else
+        # yield data 8 bytes at a time until EOF
+        while true
+          buf = stream.read(8)
+          if buf
+            yield buf
+          else
+            # EOF
+            break
+          end
+        end
+      end
+    end
+
+    # Yield data 6 words at a time until EOF
+    def read_input_by_6_words
+      block_size = 2048
+      word_arr = []
+
+      while true
+        buf = stream.read(block_size)
+        if buf.nil?
+          break #EOF
+        end
+
+        buf.scan(/\S+/) do |word|
+          word_arr << word
+
+          # return the array if we have accumulated 6 words
+          if word_arr.length == 6
+            yield word_arr
+            word_arr.clear
+          end
+        end
+      end
+
+      # yield whatever we have left, if anything
+      if !word_arr.empty?
+        yield word_arr
+      end
+    end
+
+    def accumulate_hex_input
+      unless block_given?
+        raise ArgumentError.new("must pass block")
+      end
+
+      # these are actually treated the same at the moment
+      case hex_style
+      when 'lower', 'lowercase'
+      when 'finger', 'fingerprint'
+      else
+        raise CLIError.new("unknown hex style: #{hex_style.inspect}")
+      end
+
+      while true
+        buf = ''
+
+        # try to accumulate 8 bytes (16 chars) before yielding the hex
+        while buf.length < 16
+          char = stream.getc
+          if char.nil?
+            # EOF, so yield whatever we have if it's non-empty
+            yield buf unless buf.empty?
+            return
+          end
+
+          if Sixword::Hex.valid_hex?(char)
+            buf << char
+            next
+          elsif Sixword::Hex.strip_char?(char)
+            next
+          end
+
+          raise CLIError.new("invalid hex character: #{char.inspect}")
+        end
+
+        yield buf
+      end
+    end
+  end
+end

data/lib/sixword/hex.rb

@@ -0,0 +1,49 @@
+module Sixword
+  module Hex
+    HexValid = /\A[a-fA-F0-9]+\z/
+    HexStrip = /[\s:.-]+/
+
+    def self.valid_hex?(string)
+      !!(string =~ HexValid)
+    end
+
+    def self.strip_char?(char)
+      unless char.length == 1
+        raise ArgumentError.new("Must pass single character string")
+      end
+      !!(char =~ HexStrip)
+    end
+
+    def self.encode(bytes)
+      bytes.unpack('H*').fetch(0)
+    end
+
+    def self.encode_slice(bytes, slice, delimiter)
+      encode(bytes).each_char.each_slice(slice).map(&:join).join(delimiter)
+    end
+
+    def self.encode_fingerprint(bytes)
+      encode_slice(bytes, 4, ' ').upcase
+    end
+
+    def self.encode_colons(bytes)
+      encode_slice(bytes, 2, ':')
+    end
+
+    def self.decode(hex_string, strip_chars=true)
+      if strip_chars
+        hex_string = hex_string.gsub(HexStrip, '')
+      end
+
+      unless valid_hex?(hex_string)
+        raise ArgumentError.new("Invalid value for hex: #{hex_string.inspect}")
+      end
+
+      unless hex_string.length % 2 == 0
+        raise ArgumentError.new("Odd length hex: #{hex_string.inspect}")
+      end
+
+      [hex_string].pack('H*')
+    end
+  end
+end

data/lib/sixword/version.rb

@@ -1,3 +1,3 @@
 module Sixword
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/sixword/hex_spec.rb

@@ -0,0 +1,124 @@
+require_relative '../rspec_helper'
+
+describe Sixword::Hex do
+  TestCases = {
+    "\x73\xe2\x16\xb5\x36\x3f\x23\x77" => [
+      "73e216b5363f2377",
+      "73E2 16B5 363F 2377",
+      "73:e2:16:b5:36:3f:23:77",
+    ],
+    "\xfe\xfb\x90\x3d\x12\x59\x36\xee" => [
+      "fefb903d125936ee",
+      "FEFB 903D 1259 36EE",
+      "fe:fb:90:3d:12:59:36:ee",
+    ],
+    "\x41\x2e\xb9\x92\xe8\x34\xe9\x90" => [
+      "412eb992e834e990",
+      "412E B992 E834 E990",
+      "41:2e:b9:92:e8:34:e9:90",
+    ],
+    "\x76\x55\x69\x21\x5c\x74\x1b\xda" => [
+      "765569215c741bda",
+      "7655 6921 5C74 1BDA",
+      "76:55:69:21:5c:74:1b:da",
+    ],
+    "\x62\xec\x83\xdf\x92\x2f\x8a\x7d" => [
+      "62ec83df922f8a7d",
+      "62EC 83DF 922F 8A7D",
+      "62:ec:83:df:92:2f:8a:7d",
+    ],
+    "\xe2\x65\x2a\x67\xe8\x32\x41\x19" => [
+      "e2652a67e8324119",
+      "E265 2A67 E832 4119",
+      "e2:65:2a:67:e8:32:41:19",
+    ],
+    "\xd2\x6b\x73\x44\x17\xad\x7f\x93" => [
+      "d26b734417ad7f93",
+      "D26B 7344 17AD 7F93",
+      "d2:6b:73:44:17:ad:7f:93",
+    ],
+    "\xc5\x3c\xab\x0e\x0c\xf5\x2a\xe8" => [
+      "c53cab0e0cf52ae8",
+      "C53C AB0E 0CF5 2AE8",
+      "c5:3c:ab:0e:0c:f5:2a:e8",
+    ],
+
+    "\x34\x59\xa1\x13\x01\x94\xc3\xf6\xe8\xa9\xec\xf6\x44\xb5\xba\x41" => [
+      "3459a1130194c3f6e8a9ecf644b5ba41",
+      "3459 A113 0194 C3F6 E8A9 ECF6 44B5 BA41",
+      "34:59:a1:13:01:94:c3:f6:e8:a9:ec:f6:44:b5:ba:41",
+    ],
+    "\x8e\x93\x05\x97\xec\x03\x41\x9d\x13\x1c\x05\x7a\x6a\xa9\xc5\x73" => [
+      "8e930597ec03419d131c057a6aa9c573",
+      "8E93 0597 EC03 419D 131C 057A 6AA9 C573",
+      "8e:93:05:97:ec:03:41:9d:13:1c:05:7a:6a:a9:c5:73",
+    ],
+    "\xc6\xb4\x10\xe9\x26\x71\x1a\x7c\x4f\x67\x98\xf9\x92\x0e\xdf\x4c" => [
+      "c6b410e926711a7c4f6798f9920edf4c",
+      "C6B4 10E9 2671 1A7C 4F67 98F9 920E DF4C",
+      "c6:b4:10:e9:26:71:1a:7c:4f:67:98:f9:92:0e:df:4c",
+    ],
+    "\x83\x6a\x14\xd4\x0b\xf0\xc6\xed\xb5\xa8\x1f\xb7\xc0\xcc\xc5\x22" => [
+      "836a14d40bf0c6edb5a81fb7c0ccc522",
+      "836A 14D4 0BF0 C6ED B5A8 1FB7 C0CC C522",
+      "83:6a:14:d4:0b:f0:c6:ed:b5:a8:1f:b7:c0:cc:c5:22",
+    ],
+    "\x26\xb8\xdf\xd0\x00\x35\x98\xff\xec\x95\xc3\xa1\x1e\x64\x97\x08" => [
+      "26b8dfd0003598ffec95c3a11e649708",
+      "26B8 DFD0 0035 98FF EC95 C3A1 1E64 9708",
+      "26:b8:df:d0:00:35:98:ff:ec:95:c3:a1:1e:64:97:08",
+    ],
+    "\xd9\xff\xcb\x22\xe5\x2e\x92\x0c\xfd\x45\xcb\x0c\x18\x18\x08\x10" => [
+      "d9ffcb22e52e920cfd45cb0c18180810",
+      "D9FF CB22 E52E 920C FD45 CB0C 1818 0810",
+      "d9:ff:cb:22:e5:2e:92:0c:fd:45:cb:0c:18:18:08:10",
+    ],
+    "\x73\x13\xc0\x90\x96\xd1\x5b\xbd\x10\x04\x69\x34\xf0\xbe\xf9\x60" => [
+      "7313c09096d15bbd10046934f0bef960",
+      "7313 C090 96D1 5BBD 1004 6934 F0BE F960",
+      "73:13:c0:90:96:d1:5b:bd:10:04:69:34:f0:be:f9:60",
+    ],
+    "\x18\x3b\xa9\x75\x54\x57\xf9\x5d\x00\x13\x5e\x3c\x87\x9f\x1c\x17" => [
+      "183ba9755457f95d00135e3c879f1c17",
+      "183B A975 5457 F95D 0013 5E3C 879F 1C17",
+      "18:3b:a9:75:54:57:f9:5d:00:13:5e:3c:87:9f:1c:17",
+    ],
+  }
+
+  it 'should decode and encode random hex strings correctly' do
+    TestCases.each do |binary, hexes|
+      lower, finger, colons = hexes
+      Sixword::Hex.encode(binary).should == lower
+      Sixword::Hex.decode(lower).should == binary
+    end
+  end
+
+  it 'should decode and encode random hex fingerprints correctly' do
+    TestCases.each do |binary, hexes|
+      lower, finger, colons = hexes
+      Sixword::Hex.encode_fingerprint(binary).should == finger
+      Sixword::Hex.decode(finger).should == binary
+    end
+  end
+
+  it 'should decode and encode random colon hexes correctly' do
+    TestCases.each do |binary, hexes|
+      lower, finger, colons = hexes
+      Sixword::Hex.encode_colons(binary).should == colons
+      Sixword::Hex.decode(colons).should == binary
+    end
+  end
+
+  it 'should accept all valid hex characters' do
+    Sixword::Hex.valid_hex?('abcdefABCDEF0123456789').should == true
+  end
+
+  it 'should reject invalid hex characters' do
+    ('g'..'z').each do |c|
+      Sixword::Hex.valid_hex?(c).should == false
+    end
+    ('G'..'Z').each do |c|
+      Sixword::Hex.valid_hex?(c).should == false
+    end
+  end
+end

data/spec/sixword_spec.rb

@@ -5,7 +5,7 @@ describe Sixword do
     Sixword::TestVectors::HexTests.each do |section, tests|
       tests.each do |hex, sentence|
         words = sentence.split
-        byte_string = Sixword.hex_string_to_byte_string(hex)
+        byte_string = Sixword::Hex.decode(hex)
         debug_puts "Encode 0x#{hex} => #{words.inspect}"
         Sixword.encode(byte_string).should == words
       end
@@ -16,7 +16,7 @@ describe Sixword do
     Sixword::TestVectors::HexTests.each do |section, tests|
       tests.each do |hex, sentence|
         words = sentence.split
-        byte_string = Sixword.hex_string_to_byte_string(hex)
+        byte_string = Sixword::Hex.decode(hex)
         debug_puts "Decode #{words.inspect} => 0x#{hex}"
         Sixword.decode(words).should == byte_string
       end
@@ -49,7 +49,7 @@ describe Sixword do
     Sixword::TestVectors::HexTests.fetch('rfc 1751').each do |hex, sentence|
       # group into 6-word sentences
       sentences = sentence.split.each_slice(6).map {|s| s.join(' ')}
-      byte_string = Sixword.hex_string_to_byte_string(hex)
+      byte_string = Sixword::Hex.decode(hex)
       debug_puts "Encoding #{hex.inspect} to sentences"
       debug_puts " => #{sentences.inspect}"
       Sixword.encode_to_sentences(byte_string).should == sentences
@@ -71,7 +71,7 @@ describe Sixword do
        "6C617A7920646F672E" =>
        "The quick brown fox jumps over the lazy dog.",
     }.each do |hex_string, byte_string|
-      Sixword.hex_string_to_byte_string(hex_string).should == byte_string
+      Sixword::Hex.decode(hex_string).should == byte_string
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sixword
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-26 00:00:00.000000000 Z
+date: 2013-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,7 +68,8 @@ description: ! "    Sixword implements the 6-word binary encoding created for S/
   Word List, Diceware, Base64, Base32\n"
 email:
 - abrody@abrody.com
-executables: []
+executables:
+- sixword
 extensions: []
 extra_rdoc_files: []
 files:
@@ -77,12 +78,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/sixword
 - lib/sixword.rb
+- lib/sixword/cli.rb
+- lib/sixword/hex.rb
 - lib/sixword/lib.rb
 - lib/sixword/version.rb
 - lib/sixword/words.rb
 - sixword.gemspec
 - spec/rspec_helper.rb
+- spec/sixword/hex_spec.rb
 - spec/sixword/lib_spec.rb
 - spec/sixword_spec.rb
 - spec/test_vectors.rb
@@ -101,7 +106,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2348163145907655780
+      hash: -1062992431278592122
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -110,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2348163145907655780
+      hash: -1062992431278592122
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -119,6 +124,7 @@ specification_version: 3
 summary: Implementation of RFC 2289 compatible 6-word encoding
 test_files:
 - spec/rspec_helper.rb
+- spec/sixword/hex_spec.rb
 - spec/sixword/lib_spec.rb
 - spec/sixword_spec.rb
 - spec/test_vectors.rb