openpgp 0.0.1 → 0.0.2

data/lib/openpgp/random.rb

@@ -0,0 +1,31 @@
+module OpenPGP
+  module Random
+    ##
+    # Generates a random number.
+    def self.number(bits = 32, options = {})
+      octets = bytes((bits / 8.0).ceil).unpack('C*')
+      number = octets.inject { |number, octet| number = (number << 8) | octet }
+      number & ((1 << bits) - 1)
+    end
+
+    ##
+    # Generates a pseudo-random prime number of the specified bit length.
+    #
+    # @see http://openssl.org/docs/crypto/BN_generate_prime.html
+    # @see http://openssl.org/docs/apps/genrsa.html
+    def self.prime(bits, options = {})
+      raise NotImplementedError # TODO
+    end
+
+    ##
+    # Generates a random byte.
+    def self.byte() bytes(1) end
+
+    ##
+    # Generates a string of random bytes.
+    def self.bytes(count, &block)
+      octets = File.open('/dev/urandom', 'r') {|f| f.read(count) } # FIXME
+      block_given? ? octets.each_byte(&block) : octets
+    end
+  end
+end

data/lib/openpgp/s2k.rb

@@ -0,0 +1,186 @@
+module OpenPGP
+  ##
+  # OpenPGP string-to-key (S2K) specifiers.
+  #
+  # @see http://tools.ietf.org/html/rfc4880#section-3.7
+  class S2K
+    attr_accessor :passphrase
+    attr_accessor :algorithm
+
+    def self.parse(input)
+      case mode = input.read_byte
+        when 0        then S2K::Simple.parse(input)       # Simple S2K
+        when 1        then S2K::Salted.parse(input)       # Salted S2K
+        when 3        then S2K::Iterated.parse(input)     # Iterated and Salted S2K
+        when 100..110 then S2K.new(:data => input.read)   # Private/Experimental S2K
+        else # TODO
+      end
+    end
+
+    def self.identifier
+      const_get(:IDENTIFIER)
+    end
+
+    def initialize(passphrase = nil, options = {}, &block)
+      @passphrase = passphrase.to_s
+      options.each { |k, v| instance_variable_set("@#{k}", v) }
+
+      block.call(self) if block_given?
+    end
+
+    def write(buffer)
+      buffer.write_byte(identifier)
+      buffer.write_byte(digest.to_i)
+    end
+
+    def identifier
+      @identifier || self.class.identifier
+    end
+
+    def to_hash
+      {:mode => identifier, :algorithm => digest.to_i}
+    end
+
+    def to_s
+      Buffer.write { |buffer| write(buffer) }
+    end
+
+    def to_key(key_size = 16)
+      key = if digest.size >= key_size
+        digest.digest(digest_input)
+      else
+        Buffer.write do |buffer|
+          (key_size / digest.size.to_f).ceil.times do |i|
+            buffer << digest.digest(digest_input_with_preload(i))
+          end
+        end
+      end
+      key[0, key_size]
+    end
+
+    def digest
+      @digest ||= case algorithm
+        when nil    then Digest::DEFAULT
+        when Digest then algorithm
+        when Symbol then Digest.for(algorithm)
+        when String then Digest.for(algorithm)
+        else Digest.for(algorithm.to_i)
+      end
+    end
+
+    def digest_input_with_preload(length = 0)
+      ("\0" * length) << digest_input
+    end
+
+    def digest_input
+      raise NotImplementedError
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-3.7.1.1
+    class Simple < S2K
+      IDENTIFIER = 0x00
+
+      def self.parse(input)
+        self.new(nil, :algorithm => input.read_byte)
+      end
+
+      def digest_input
+        passphrase
+      end
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-3.7.1.2
+    class Salted < S2K
+      IDENTIFIER = 0x01
+
+      def self.parse(input)
+        self.new(nil, :algorithm => input.read_byte, :salt => input.read_bytes(8))
+      end
+
+      attr_accessor :salt
+
+      def initialize(passphrase = nil, options = {}, &block)
+        super(passphrase, options, &block)
+
+        @salt = Random.bytes(8) unless @salt
+      end
+
+      def write(buffer)
+        super(buffer)
+        buffer.write_bytes(salt)
+      end
+
+      def to_hash
+        super.merge({:salt => salt})
+      end
+
+      def digest_input
+        salt.to_s[0, 8] << passphrase
+      end
+    end
+
+    ##
+    # @see http://tools.ietf.org/html/rfc4880#section-3.7.1.3
+    class Iterated < Salted
+      IDENTIFIER = 0x03
+
+      def self.parse(input)
+        self.new(nil, :algorithm => input.read_byte, :salt => input.read_bytes(8)) do |s2k|
+          s2k.count = s2k.decode_count(input.read_byte)
+        end
+      end
+
+      attr_reader :count
+
+      def initialize(passphrase = nil, options = {}, &block)
+        super(passphrase, options, &block)
+
+        @count = 65536 unless @count
+      end
+
+      def write(buffer)
+        super(buffer)
+        buffer.write_byte(encode_count(count))
+      end
+
+      def to_hash
+        super.merge(:count => count)
+      end
+
+      def digest_input
+        buffer = Buffer.write do |buffer|
+          iterations = count
+          while iterations > 0
+            buffer << (digest_input = super())
+            iterations -= digest_input.size
+          end
+        end
+      end
+
+      protected
+
+        EXPBIAS = 6
+
+        def decode_count(count)
+          (16 + (count & 15)) << ((count >> 4) + EXPBIAS)
+        end
+
+        def encode_count(iterations)
+          case iterations
+            when 0..1024           then 0
+            when 65011712..(1.0/0) then 255
+            else
+              count1 = iterations >> 6
+              count2 = (count2 || 0) + 1 while count1 >= 32 && count1 >>= 1
+              result = (count2 << 4) | (count1 - 16)
+              result += 1 if decode_count(result) < iterations
+              result
+          end
+        end
+    end
+
+    DEFAULT = Iterated
+  end
+end

data/lib/openpgp/util.rb

@@ -0,0 +1,65 @@
+module OpenPGP
+  ##
+  # Alias for OpenPGP::Armor.encode().
+  def self.enarmor(data, marker = :message, options = {})
+    Armor.encode(data, marker, options)
+  end
+
+  ##
+  # Alias for OpenPGP::Armor.decode().
+  def self.dearmor(text, marker = nil, options = {})
+    Armor.decode(text, marker, options)
+  end
+
+  ##
+  # Alias for OpenPGP::Message.encrypt().
+  def self.encrypt(data, options = {})
+    (msg = Message.encrypt(data, options)) ? msg.to_s : nil
+  end
+
+  ##
+  # Alias for OpenPGP::Message.decrypt().
+  def self.decrypt(data, options = {})
+    raise NotImplementedError # TODO
+  end
+
+  ##
+  # Alias for OpenPGP::Message.sign().
+  def self.sign
+    raise NotImplementedError # TODO
+  end
+
+  ##
+  # Alias for OpenPGP::Message.verify().
+  def self.verify
+    raise NotImplementedError # TODO
+  end
+
+  ##
+  # @see http://tools.ietf.org/html/rfc4880#section-6.1
+  CRC24_INIT = 0x00b704ce
+  CRC24_POLY = 0x01864cfb
+
+  ##
+  # @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?
+      end
+    end
+    crc &= 0x00ffffff
+  end
+
+  ##
+  # Returns the bit length of a multiprecision integer (MPI).
+  #
+  # @see http://tools.ietf.org/html/rfc4880#section-3.2
+  def self.bitlength(data)
+    data.empty? ? 0 : (data.size - 1) * 8 + (Math.log(data[0]) / Math.log(2)).floor + 1
+  end
+end

data/lib/openpgp/version.rb

@@ -1,11 +1,14 @@
 module OpenPGP
-  module Version
+  module VERSION
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY].join('.')
     STRING << "-#{EXTRA}" if EXTRA
+
+    def self.to_s()   STRING end
+    def self.to_str() STRING end
   end
 end

metadata

@@ -1,19 +1,30 @@
 --- !ruby/object:Gem::Specification 
 name: openpgp
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Arto Bendiken
+- "K\xC3\xA9vin Lacointe"
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-04-18 00:00:00 +02:00
+date: 2009-12-20 00:00:00 +01:00
 default_executable: openpgp
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rakefile
+  name: open4
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: bendiken-rakefile
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
@@ -22,7 +33,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-description: "    OpenPGP.rb is a pure-Ruby implementation of the OpenPGP Message Format (RFC 4880).\n"
+description: "    OpenPGP.rb is a pure-Ruby implementation of the OpenPGP Message Format\n    (RFC 4880), the most widely-used e-mail encryption standard in the world.\n"
 email: arto.bendiken@gmail.com
 executables: 
 - openpgp
@@ -31,22 +42,42 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- LICENSE
+- AUTHORS
 - README
 - Rakefile
+- UNLICENSE
 - VERSION
 - bin/openpgp
-- lib/openpgp.rb
 - lib/openpgp/algorithm.rb
 - lib/openpgp/armor.rb
-- lib/openpgp/gnupg.rb
+- lib/openpgp/buffer.rb
+- lib/openpgp/cipher/3des.rb
+- lib/openpgp/cipher/aes.rb
+- lib/openpgp/cipher/blowfish.rb
+- lib/openpgp/cipher/cast5.rb
+- lib/openpgp/cipher/idea.rb
+- lib/openpgp/cipher/twofish.rb
+- lib/openpgp/cipher.rb
+- lib/openpgp/client/gnupg.rb
+- lib/openpgp/digest/md5.rb
+- lib/openpgp/digest/rmd160.rb
+- lib/openpgp/digest/sha1.rb
+- lib/openpgp/digest/sha2.rb
+- lib/openpgp/digest.rb
+- lib/openpgp/engine/gnupg.rb
+- lib/openpgp/engine/openssl.rb
+- lib/openpgp/engine.rb
 - lib/openpgp/message.rb
 - lib/openpgp/packet.rb
+- lib/openpgp/random.rb
+- lib/openpgp/s2k.rb
+- lib/openpgp/util.rb
 - lib/openpgp/version.rb
+- lib/openpgp.rb
 has_rdoc: false
 homepage: http://github.com/bendiken/openpgp
 licenses: 
-- MIT
+- Public Domain
 post_install_message: 
 rdoc_options: []
 
@@ -67,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: 
 - GnuPG >= 1.4.7 (not required, but enables extra functionality)
 rubyforge_project: openpgp
-rubygems_version: 1.3.2
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: A pure-Ruby implementation of the OpenPGP Message Format (RFC 4880).

data/LICENSE

@@ -1,19 +0,0 @@
-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.