klacointe-openpgp 0.0.1.3

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Arto Bendiken <http://ar.to/>
+
+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

@@ -0,0 +1,104 @@
+= OpenPGP.rb
+
+This is a pure-Ruby implementation of the OpenPGP Message Format (RFC 4880).
+
+* http://openpgp.rubyforge.org
+* http://github.com/bendiken/openpgp
+
+
+=== About OpenPGP
+
+OpenPGP is the most widely-used e-mail encryption standard in the world. It
+is defined by the OpenPGP Working Group of the Internet Engineering Task
+Force (IETF) Proposed Standard RFC 4880. The OpenPGP standard was originally
+derived from PGP (Pretty Good Privacy), first created by Phil Zimmermann in
+1991.
+
+* http://tools.ietf.org/html/rfc4880
+* http://www.openpgp.org
+
+
+== Features
+
+* Encodes and decodes ASCII-armored OpenPGP messages.
+* Parses OpenPGP messages into their constituent packets.
+  * Supports both old-format (PGP 2.6.x) and new-format (RFC 4880) packets.
+* Includes a GnuPG wrapper for features that are not natively supported.
+
+
+== Examples
+
+  require 'openpgp'
+
+
+=== Decoding an ASCII-armored message
+
+  require 'open-uri'
+  text = open('http://ar.to/pgp.txt').read
+
+  msg = OpenPGP::Message.parse(OpenPGP.dearmor(text))
+
+
+=== Generating a new keypair
+
+  gpg = OpenPGP::Engine::GnuPG.new(:homedir => '~/.gnupg')
+  key_id = gpg.gen_key({
+    :key_type      => 'DSA',
+    :key_length    => 1024,
+    :subkey_type   => 'ELG-E',
+    :subkey_length => 1024,
+    :name          => 'J. Random Hacker',
+    :comment       => nil,
+    :email         => 'jhacker@example.org',
+    :passphrase    => 'secret passphrase',
+  })
+
+
+== Documentation
+
+* http://openpgp.rubyforge.org
+
+
+== Download
+
+To get a local working copy of the development repository, do:
+
+  % git clone git://github.com/bendiken/openpgp.git
+
+Alternatively, you can download the latest development version as a tarball
+as follows:
+
+  % wget http://github.com/bendiken/openpgp/tarball/master
+
+
+== Installation
+
+The recommended installation method is via RubyGems. To install the latest
+official release from RubyForge, do:
+
+  % [sudo] gem install openpgp
+
+To use the very latest bleeding-edge development version, install the gem
+directly from GitHub as follows:
+
+  % [sudo] gem install bendiken-openpgp -s http://gems.github.com
+
+
+== Resources
+
+* http://openpgp.rubyforge.org
+* http://github.com/bendiken/openpgp
+* http://rubyforge.org/projects/openpgp
+* http://raa.ruby-lang.org/project/openpgp
+* http://www.ohloh.net/p/openpgp
+
+
+== Authors
+
+* Arto Bendiken (mailto:arto.bendiken@gmail.com) - http://ar.to
+
+
+== License
+
+All source code is available under the terms of the MIT license. For more
+information, see the accompanying LICENSE file.

data/Rakefile

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'lib')))
+require 'rubygems'
+require 'rakefile' # http://github.com/bendiken/rakefile
+require 'openpgp'
+
+desc "Generate YARD documentation (with title)"
+task :yardocs => :yardoc do
+  # FIXME: fork YARD and patch it to allow the title to be configured
+  sh "sed -i 's/YARD Documentation/OpenPGP.rb Documentation/' doc/yard/index.html"
+
+  # TODO: investigate why YARD doesn't auto-link URLs like RDoc does
+  html = File.read(file = 'doc/yard/readme.html')
+  html.gsub!(/>(http:\/\/)([\w\d\.\/\-]+)/, '><a href="\1\2" target="_blank">\2</a>')
+  html.gsub!(/(http:\/\/ar\.to\/[\w\d\.\/]+)/, '<a href="\1">\1</a>')
+  html.gsub!(/(http:\/\/ar\.to)([^\/]+)/, '<a href="\1" target="_top">ar.to</a>\2')
+  html.gsub!(/(mailto:[^\)]+)/, '<a href="\1">\1</a>')
+  File.open(file, 'wb') { |f| f.puts html }
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1.2

data/bin/openpgp

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby -rubygems
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'openpgp'

data/lib/openpgp/algorithm.rb

@@ -0,0 +1,57 @@
+module OpenPGP
+  module Algorithm
+    ##
+    # OpenPGP public-key algorithms.
+    #
+    # @see http://tools.ietf.org/html/rfc4880#section-9.1
+    module Asymmetric
+      RSA         = 1
+      RSA_E       = 2
+      RSA_S       = 3
+      ELG_E       = 16
+      DSA         = 17
+    end
+
+    ##
+    # OpenPGP symmetric-key algorithms.
+    #
+    # @see http://tools.ietf.org/html/rfc4880#section-9.2
+    module Symmetric
+      NONE        = 0
+      IDEA        = 1
+      TRIPLEDES   = 2
+      CAST5       = 3
+      BLOWFISH    = 4
+      AES         = 7
+      AES128      = 7
+      AES192      = 8
+      AES256      = 9
+      TWOFISH     = 10
+    end
+
+    ##
+    # OpenPGP compression algorithms.
+    #
+    # @see http://tools.ietf.org/html/rfc4880#section-9.3
+    module Compression
+      NONE        = 0
+      ZIP         = 1
+      ZLIB        = 2
+      BZIP2       = 3
+    end
+
+    ##
+    # OpenPGP hash algorithms.
+    #
+    # @see http://tools.ietf.org/html/rfc4880#section-9.4
+    module Digest
+      MD5         = 1
+      SHA1        = 2
+      RIPEMD160   = 3
+      SHA256      = 8
+      SHA384      = 9
+      SHA512      = 10
+      SHA224      = 11
+    end
+  end
+end

data/lib/openpgp/armor.rb

@@ -0,0 +1,120 @@
+module OpenPGP
+  ##
+  # OpenPGP ASCII Armor utilities.
+  #
+  # @see http://tools.ietf.org/html/rfc4880#section-6.2
+  module Armor
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-6.2
+    module Markers
+      MESSAGE           = 'MESSAGE'
+      PUBLIC_KEY_BLOCK  = 'PUBLIC KEY BLOCK'
+      PRIVATE_KEY_BLOCK = 'PRIVATE KEY BLOCK'
+      SIGNATURE         = 'SIGNATURE'
+      ARMORED_FILE      = 'ARMORED FILE' # a GnuPG extension
+    end
+
+    def self.marker(marker)
+      marker = Markers.const_get(marker.to_s.upcase.to_sym) if marker.is_a?(Symbol)
+      marker.to_s.upcase
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-6.2
+    def self.header(marker)
+      "-----BEGIN PGP #{marker(marker)}-----"
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-6.2
+    def self.footer(marker)
+      "-----END PGP #{marker(marker)}-----"
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-6
+    # @see http://tools.ietf.org/html/rfc4880#section-6.2
+    # @see http://tools.ietf.org/html/rfc2045
+    def self.encode(data, marker = :message, options = {})
+      Buffer.write do |text|
+        text << self.header(marker)     << "\n"
+        text << "Version: #{options[:version]}\n" if options[:version]
+        text << "Comment: #{options[:comment]}\n" if options[:comment]
+        if options[:headers]
+          options[:headers].each { |key, value| text << "#{key}: #{value}\n" }
+        end
+        text << "\n" << encode64(data, options[:line_length])
+        text << "="  << encode64([OpenPGP.crc24(data)].pack('N')[1, 3])
+        text << self.footer(marker)     << "\n"
+      end
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-6
+    # @see http://tools.ietf.org/html/rfc2045
+    def self.decode(text, marker = nil, options = {})
+      data, crc, state = Buffer.new, nil, :begin
+
+      text.each_line do |line|
+        line.chomp!
+        case state
+          when :begin
+            case line
+              when /^-----BEGIN PGP ([^-]+)-----$/
+                state = :head if marker.nil? || marker(marker) == $1
+            end
+          when :head
+            state = :body if line =~ /^\s*$/
+          when :body
+            case line
+              when /^=(....)$/
+                crc = ("\0" << decode64($1)).unpack('N').first
+                state = :end
+              when /^-----END PGP ([^-]+)-----$/
+                state = :end
+              else
+                data << decode64(line)
+            end
+          when :end
+            break
+        end
+      end
+
+      data = data.string
+      if options[:crc] && crc != (crc_data = OpenPGP.crc24(data))
+        raise CRCError.new("ASCII armor says 0x#{crc.to_s(16)}, but data has 0x#{crc_data.to_s(16)}")
+      end
+      data
+    end
+
+    class CRCError < IOError; end
+
+    protected
+
+      ##
+      # Returns the Base64-encoded version of +input+, with a configurable
+      # output line length.
+      def self.encode64(input, line_length = nil)
+        if line_length.nil?
+          [input].pack('m')
+        elsif line_length % 4 == 0
+          [input].pack("m#{(line_length / 4) * 3}")
+        else
+          output = []
+          [input].pack('m').delete("\n").scan(/.{1,#{line_length}}/) do
+            output << $&
+          end
+          output << ''
+          output.join("\n")
+        end
+      end
+
+      ##
+      # Returns the Base64-decoded version of +input+.
+      def self.decode64(input)
+        input.unpack('m').first
+      end
+  end
+
+  include Armor::Markers
+end

data/lib/openpgp/buffer.rb

@@ -0,0 +1,100 @@
+require 'stringio'
+
+module OpenPGP
+  ##
+  class Buffer < StringIO
+    def self.write(*args, &block)
+      buffer = self.new(*args, &block)
+      buffer.string
+    end
+
+    def initialize(*args, &block)
+      super
+      block.call(self) if block_given?
+    end
+
+    ##
+    def read_string
+      read_bytes(length = read_byte)
+    end
+
+    ##
+    def write_string(value)
+      value = value.to_s
+      self << [value.size].pack('C')
+      self << value unless value.empty?
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-3.5
+    def read_timestamp
+      read_unpacked(4, 'N')
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-3.5
+    def write_timestamp(value)
+      self << [value.to_i].pack('N')
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-3.1
+    def read_number(count, base = nil)
+      number, shift = 0, count * 8
+      read_bytes(count).each_byte do |octet|
+        number += octet << (shift -= 8)
+      end
+      !base ? number : number.to_s(base).upcase
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-3.1
+    def write_number
+      # TODO
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-3.2
+    def read_mpi
+      length = read_unpacked(2, 'n')      # length in bits
+      length = ((length + 7) / 8.0).floor # length in bytes
+      read_bytes(length)
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-3.2
+    def write_mpi
+      # TODO
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-3.7
+    def read_s2k()     S2K.parse(self) end
+
+    def write_s2k(s2k) s2k.write(self) end
+
+    def read_unpacked(count, format)
+      read_bytes(count).unpack(format).first
+    end
+
+    def write_unpacked
+      # TODO
+    end
+
+    def read_bytes(count)
+      read(count)
+    end
+
+    def write_bytes(value)
+      self << value
+    end
+
+    def read_byte
+      getc
+    end
+
+    def write_byte(value)
+      self << (value.respond_to?(:chr) ? value : value.to_s[0]).chr
+    end
+  end
+end

data/lib/openpgp/cipher/3des.rb

@@ -0,0 +1,9 @@
+module OpenPGP
+  class Cipher
+    ##
+    class TripleDES < Cipher
+      IDENTIFIER = 2
+      ENGINE     = 'DES-EDE3'
+    end
+  end
+end

data/lib/openpgp/cipher/aes.rb

@@ -0,0 +1,26 @@
+module OpenPGP
+  class Cipher
+    ##
+    class AES < Cipher
+      ENGINE     = 'AES-128-ECB'
+    end
+
+    ##
+    class AES128 < AES
+      IDENTIFIER = 7
+      ENGINE     = 'AES-128-ECB'
+    end
+
+    ##
+    class AES192 < AES
+      IDENTIFIER = 8
+      ENGINE     = 'AES-192-ECB'
+    end
+
+    ##
+    class AES256 < AES
+      IDENTIFIER = 9
+      ENGINE     = 'AES-256-ECB'
+    end
+  end
+end

data/lib/openpgp/cipher/blowfish.rb

@@ -0,0 +1,9 @@
+module OpenPGP
+  class Cipher
+    ##
+    class Blowfish < Cipher
+      IDENTIFIER = 4
+      ENGINE     = 'BF-ECB'
+    end
+  end
+end

data/lib/openpgp/cipher/cast5.rb

@@ -0,0 +1,9 @@
+module OpenPGP
+  class Cipher
+    ##
+    class CAST5 < Cipher
+      IDENTIFIER = 3
+      ENGINE     = 'CAST5-ECB'
+    end
+  end
+end

data/lib/openpgp/cipher/idea.rb

@@ -0,0 +1,9 @@
+module OpenPGP
+  class Cipher
+    ##
+    class IDEA < Cipher
+      IDENTIFIER = 1
+      ENGINE     = 'IDEA-ECB'
+    end
+  end
+end

data/lib/openpgp/cipher/twofish.rb

@@ -0,0 +1,9 @@
+module OpenPGP
+  class Cipher
+    ##
+    class Twofish < Cipher
+      IDENTIFIER = 10
+      ENGINE     = nil # N/A
+    end
+  end
+end

data/lib/openpgp/cipher.rb

@@ -0,0 +1,117 @@
+require 'openssl'
+
+module OpenPGP
+  ##
+  # OpenPGP cipher algorithm.
+  class Cipher
+    autoload :IDEA,      'openpgp/cipher/idea'
+    autoload :TripleDES, 'openpgp/cipher/3des'
+    autoload :CAST5,     'openpgp/cipher/cast5'
+    autoload :Blowfish,  'openpgp/cipher/blowfish'
+    autoload :AES128,    'openpgp/cipher/aes'
+    autoload :AES192,    'openpgp/cipher/aes'
+    autoload :AES256,    'openpgp/cipher/aes'
+    autoload :Twofish,   'openpgp/cipher/twofish'
+
+    DEFAULT = AES128
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-9.2
+    def self.for(identifier)
+      case identifier
+        when Symbol then const_get(identifier.to_s.upcase)
+        when String then const_get(identifier.upcase.to_sym)
+        when 1      then IDEA
+        when 2      then TripleDES
+        when 3      then CAST5
+        when 4      then Blowfish
+        when 7      then AES128
+        when 8      then AES192
+        when 9      then AES256
+        when 10     then Twofish
+      end
+    end
+
+    attr_accessor :key, :options
+    attr_accessor :engine
+
+    def initialize(key, options = {})
+      @key = case key
+        when S2K then key.to_key(key_size)
+        else S2K::Simple.new(key).to_key(key_size)
+      end
+      @options = options
+    end
+
+    def self.to_i() identifier end
+
+    def self.identifier
+      const_get(:IDENTIFIER)
+    end
+
+    def identifier()
+      self.class.identifier
+    end
+
+    def key_size
+      @key_size ||= engine.key_len
+    end
+
+    def block_size
+      @block_size ||= engine.block_size
+    end
+
+    def engine
+      @engine ||= Engine::OpenSSL.use do
+        OpenSSL::Cipher.new(self.class.const_get(:ENGINE))
+      end
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-13.9
+    def encrypt(plaintext)
+      ciphertext = String.new
+
+      engine.reset
+      engine.encrypt
+
+      # IV
+      rblock = Random.bytes(block_size)
+      iblock = encrypt_block("\0" * block_size)
+      block_size.times do |i|
+        ciphertext << (iblock[i] ^= rblock[i]).chr
+      end
+
+      # Checksum
+      iblock = encrypt_block(iblock)
+      ciphertext << (iblock[0] ^ rblock[block_size - 2]).chr
+      ciphertext << (iblock[1] ^ rblock[block_size - 1]).chr
+
+      # Resync
+      iblock = ciphertext[2..-1]
+
+      # Encrypt
+      plaintext.size.times do |n|
+        if (i = n % block_size) == 0
+          iblock = encrypt_block(iblock)
+        end
+        ciphertext << (iblock[i] ^= plaintext[n]).chr
+      end
+
+      ciphertext
+    end
+
+    def decrypt(ciphertext)
+      # TODO
+      engine.reset
+      engine.decrypt
+    end
+
+    def encrypt_block(block)
+      engine.encrypt
+      engine.key = @key
+      engine.iv  = (@iv ||= "\0" * engine.iv_len)
+      engine.update(block) << engine.final
+    end
+  end
+end