openpgp 0.0.1 → 0.0.2

data/AUTHORS

@@ -0,0 +1,2 @@
+* Arto Bendiken <arto.bendiken@gmail.com> (Lead developer)
+* Kévin Lacointe <kevinlacointe@gmail.com> (Some GnuPG patches)

data/README

@@ -1,9 +1,12 @@
-= OpenPGP.rb
+OpenPGP.rb: OpenPGP for Ruby
+============================
 
 This is a pure-Ruby implementation of the OpenPGP Message Format (RFC 4880).
 
+* <http://openpgp.rubyforge.org/>
+* <http://github.com/bendiken/openpgp>
 
-=== About 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
@@ -11,82 +14,86 @@ 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
+* <http://tools.ietf.org/html/rfc4880>
+* <http://www.openpgp.org/>
 
-
-== Features
+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
+--------
 
-== Examples
-
-  require 'openpgp'
-
-
-=== Decoding an ASCII-armored message
-
-  require 'open-uri'
-  text = open('http://ar.to/pgp.txt').read
+    require 'openpgp'
 
-  msg = OpenPGP::Message.parse(OpenPGP.dearmor(text))
+### Decoding an ASCII-armored message
 
+    require 'open-uri'
+    text = open('http://ar.to/pgp.txt').read
 
-=== Generating a new keypair
+    msg = OpenPGP::Message.parse(OpenPGP.dearmor(text))
 
-  gpg = OpenPGP::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',
-  })
+### 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
+Documentation
+-------------
 
-* http://openpgp.rubyforge.org
+* <http://openpgp.rubyforge.org/>
 
-
-== Download
+Download
+--------
 
 To get a local working copy of the development repository, do:
 
-  % git clone git://github.com/bendiken/openpgp.git
+    % 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
-
+    % wget http://github.com/bendiken/openpgp/tarball/master
 
-== Installation
+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:
+official release from Gemcutter, do:
 
-  % [sudo] gem install bendiken-openpgp -s http://gems.github.com
+    % [sudo] gem install openpgp
 
+Resources
+---------
 
-== Authors
+* <http://openpgp.rubyforge.org/>
+* <http://github.com/bendiken/openpgp>
+* <http://gemcutter.org/gems/crm114>
+* <http://rubyforge.org/projects/openpgp>
+* <http://raa.ruby-lang.org/project/openpgp/>
+* <http://www.ohloh.net/p/openpgp>
 
-* Arto Bendiken (mailto:arto.bendiken@gmail.com) - http://ar.to
+Authors
+-------
 
+* [Arto Bendiken](mailto:arto.bendiken@gmail.com) - <http://ar.to/>
+* [Kévin Lacointe](mailto:kevinlacointe@gmail.com)
 
-== License
+License
+-------
 
-All source code is available under the terms of the MIT license. For more
-information, see the accompanying LICENSE file.
+OpenPGP.rb is free and unencumbered public domain software. For more
+information, see <http://unlicense.org/> or the accompanying UNLICENSE file.

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/openpgp.rb

@@ -1,6 +1,17 @@
 require 'openpgp/version'
-require 'openpgp/armor'
-require 'openpgp/message'
-require 'openpgp/packet'
-require 'openpgp/algorithm'
-require 'openpgp/gnupg'
+require 'openpgp/util'
+
+module OpenPGP
+  autoload :Algorithm, 'openpgp/algorithm'
+  autoload :Armor,     'openpgp/armor'
+  autoload :Buffer,    'openpgp/buffer'
+  autoload :Cipher,    'openpgp/cipher'
+  autoload :Engine,    'openpgp/engine'
+  autoload :Digest,    'openpgp/digest'
+  autoload :Message,   'openpgp/message'
+  autoload :Packet,    'openpgp/packet'
+  autoload :Random,    'openpgp/random'
+  autoload :S2K,       'openpgp/s2k'
+end
+
+OpenPGP::Engine::OpenSSL.install!

data/lib/openpgp/algorithm.rb

@@ -44,7 +44,7 @@ module OpenPGP
     # OpenPGP hash algorithms.
     #
     # @see http://tools.ietf.org/html/rfc4880#section-9.4
-    module Hash
+    module Digest
       MD5         = 1
       SHA1        = 2
       RIPEMD160   = 3

data/lib/openpgp/armor.rb

@@ -1,16 +1,4 @@
 module OpenPGP
-  ##
-  # Alias for OpenPGP::Armor.encode().
-  def self.enarmor(data, marker = 'MESSAGE', headers = {})
-    Armor.encode(data, marker, headers)
-  end
-
-  ##
-  # Alias for OpenPGP::Armor.decode().
-  def self.dearmor(text, marker = nil)
-    Armor.decode(text, marker)
-  end
-
   ##
   # OpenPGP ASCII Armor utilities.
   #
@@ -23,91 +11,109 @@ module OpenPGP
       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.to_s.upcase}-----"
+      "-----BEGIN PGP #{marker(marker)}-----"
     end
 
     ##
     # @see http://tools.ietf.org/html/rfc4880#section-6.2
     def self.footer(marker)
-      "-----END PGP #{marker.to_s.upcase}-----"
+      "-----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', headers = {})
-      require 'stringio'
-      require 'base64'
-
-      text = StringIO.new
-      text << self.header(marker)     << "\n"
-      headers.each { |key, value| text << "#{key}: #{value}\n" }
-      text << "\n" << Base64.encode64(data)
-      text << "="  << Base64.encode64([self.crc24(data)].pack('N')[1, 3])
-      text << self.footer(marker)     << "\n"
-      text.string
+    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)
-      require 'stringio'
-      require 'base64'
+    def self.decode(text, marker = nil, options = {})
+      data, crc, state = Buffer.new, nil, :begin
 
-      data, crc, state = StringIO.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.to_s.upcase == $1
+                state = :head if marker.nil? || marker(marker) == $1
             end
           when :head
             state = :body if line =~ /^\s*$/
           when :body
             case line
               when /^=(....)$/
-                crc = ("\0" << Base64.decode64($1)).unpack('N').first
+                crc = ("\0" << decode64($1)).unpack('N').first
                 state = :end
               when /^-----END PGP ([^-]+)-----$/
                 state = :end
               else
-                data << Base64.decode64(line)
+                data << decode64(line)
             end
           when :end
             break
         end
       end
-      data.string
+
+      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
 
-    ##
-    # @see http://tools.ietf.org/html/rfc4880#section-6.1
-    CRC24_INIT = 0x00b704ce
-    CRC24_POLY = 0x01864cfb
+    class CRCError < IOError; end
 
-    ##
-    # @see http://tools.ietf.org/html/rfc4880#section-6
-    # @see http://tools.ietf.org/html/rfc4880#section-6.1
-    def self.crc24(data)
-      crc = CRC24_INIT
-      data.each_byte do |octet|
-        crc ^= octet << 16
-        8.times do
-          crc <<= 1
-          crc ^= CRC24_POLY if (crc & 0x01000000).nonzero?
+    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
-      crc &= 0x00ffffff
-    end
+
+      ##
+      # Returns the Base64-decoded version of +input+.
+      def self.decode64(input)
+        input.unpack('m').first
+      end
   end
 
   include Armor::Markers

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