rsa 0.1.0

data/AUTHORS

@@ -0,0 +1 @@
+* Arto Bendiken <arto.bendiken@gmail.com>

data/README

@@ -0,0 +1,88 @@
+RSA.rb: RSA Encryption for Ruby
+===============================
+
+RSA.rb is a [Ruby][] library that implements the [RSA][] encryption
+algorithm and the [PKCS#1][] cryptography standard.
+
+* <http://github.com/bendiken/rsa>
+
+Features
+--------
+
+* 100% free and unencumbered [public domain](http://unlicense.org/) software.
+* Implements the PKCS#1 data conversion primitives (I2OSP and OS2IP).
+* Implements the PKCS#1 encryption/decryption primitives (RSAEP and RSADP).
+* Implements the PKCS#1 signature primitives (RSASP1 and RSAVP1).
+* Implements RSA key pair generation using Ruby's OpenSSL standard library.
+* Compatible with Ruby 1.9.1+ and JRuby 1.5.0+.
+* Compatible with older Ruby versions with the help of the [Backports][] gem.
+
+Documentation
+-------------
+
+* <http://rsa.rubyforge.org/>
+
+Dependencies
+------------
+
+* [Ruby](http://ruby-lang.org/) (>= 1.9.1) or (>= 1.8.1 with [Backports][])
+
+Installation
+------------
+
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest official release of RSA.rb, do:
+
+    % [sudo] gem install rsa             # Ruby 1.9.1+
+    % [sudo] gem install backports rsa   # Ruby 1.8.x
+
+Download
+--------
+
+To get a local working copy of the development repository, do:
+
+    % git clone git://github.com/bendiken/rsa.git
+
+Alternatively, you can download the latest development version as a tarball
+as follows:
+
+    % wget http://github.com/bendiken/rsa/tarball/master
+
+Author
+------
+
+* [Arto Bendiken](mailto:arto.bendiken@gmail.com) - <http://ar.to/>
+
+Contributors
+------------
+
+Refer to the accompanying {file:CREDITS} file.
+
+Contributing
+------------
+
+* Do your best to adhere to the existing coding conventions and idioms.
+* Don't use hard tabs, and don't leave trailing whitespace on any line.
+* Do document every method you add using [YARD][] annotations. Read the
+  [tutorial][YARD-GS] or just look at the existing code for examples.
+* Don't touch the `.gemspec`, `VERSION` or `AUTHORS` files. If you need to
+  change them, do so on your private branch only.
+* Do feel free to add yourself to the `CREDITS` file and the corresponding
+  list in the the `README`. Alphabetical order applies.
+* Do note that in order for us to merge any non-trivial changes (as a rule
+  of thumb, additions larger than about 15 lines of code), we need an
+  explicit [public domain dedication][PDD] on record from you.
+
+License
+-------
+
+This is free and unencumbered public domain software. For more information,
+see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+
+[Ruby]:      http://ruby-lang.org/
+[RSA]:       http://en.wikipedia.org/wiki/RSA
+[PKCS#1]:    http://en.wikipedia.org/wiki/PKCS1
+[YARD]:      http://yardoc.org/
+[YARD-GS]:   http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]:       http://unlicense.org/#unlicensing-contributions
+[Backports]: http://rubygems.org/gems/backports

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

@@ -0,0 +1 @@
+0.1.0

data/lib/rsa.rb

@@ -0,0 +1,26 @@
+require 'stringio' unless defined?(StringIO)
+
+if RUBY_VERSION < '1.9.1'
+  # @see http://rubygems.org/gems/backports
+  begin
+    require 'backports/1.9.1'
+  rescue LoadError
+    abort "RSA.rb requires Ruby 1.9.1 or the Backports gem (hint: `gem install backports')."
+  end
+end
+
+module RSA
+  autoload :Math,    'rsa/math'
+  autoload :PKCS1,   'rsa/pkcs1'
+  autoload :Key,     'rsa/key'
+  autoload :KeyPair, 'rsa/key_pair'
+  autoload :OpenSSL, 'rsa/openssl'
+  autoload :VERSION, 'rsa/version'
+end
+
+begin
+  require 'openssl'
+  require 'rsa/openssl'
+rescue LoadError
+  # OpenSSL acceleration disabled.
+end

data/lib/rsa/key.rb

@@ -0,0 +1,54 @@
+module RSA
+  ##
+  # An RSA public or private key.
+  #
+  # Refer to PKCS #1 v2.1, section 3, pp. 6-8.
+  #
+  # @see http://www.rsa.com/rsalabs/node.asp?id=2125
+  # @see http://en.wikipedia.org/wiki/Public-key_cryptography
+  class Key
+    ##
+    # The RSA modulus, a positive integer.
+    #
+    # @return [Integer]
+    attr_reader  :modulus
+    alias_method :n, :modulus
+
+    ##
+    # The RSA public or private exponent, a positive integer.
+    #
+    # @return [Integer]
+    attr_reader  :exponent
+    alias_method :e, :exponent
+    alias_method :d, :exponent
+
+    ##
+    # Initializes a new key.
+    #
+    # @param  [Integer, #to_i]         modulus
+    # @param  [Integer, #to_i]         exponent
+    # @param  [Hash{Symbol => Object}] options
+    def initialize(modulus, exponent, options = {})
+      @modulus  = modulus.to_i
+      @exponent = exponent.to_i
+      @options  = options.dup
+    end
+
+    ##
+    # Returns `true` if this is a valid RSA key according to {RSA::PKCS1
+    # PKCS #1}.
+    #
+    # @return [Boolean]
+    def valid?
+      true # TODO: PKCS #1 v2.1, sections 3.1 and 3.2, pp. 6-7.
+    end
+
+    ##
+    # Returns a two-element array containing the modulus and exponent.
+    #
+    # @return [Array]
+    def to_a
+      [modulus, exponent]
+    end
+  end # class Key
+end # module RSA

data/lib/rsa/key_pair.rb

@@ -0,0 +1,155 @@
+module RSA
+  ##
+  # An RSA key pair.
+  #
+  # Refer to PKCS #1 v2.1, section 3, pp. 6-8.
+  #
+  # @see http://www.rsa.com/rsalabs/node.asp?id=2125
+  # @see http://en.wikipedia.org/wiki/Public-key_cryptography
+  class KeyPair
+    ##
+    # The RSA private key.
+    #
+    # @return [Key]
+    attr_reader  :private_key
+    alias_method :private, :private_key
+
+    ##
+    # The RSA public key.
+    #
+    # @return [Key]
+    attr_reader  :public_key
+    alias_method :public, :public_key
+
+    ##
+    # Initializes a new key pair.
+    #
+    # @param  [Key]                    private_key
+    # @param  [Key]                    public_key
+    # @param  [Hash{Symbol => Object}] options
+    def initialize(private_key, public_key, options = {})
+      @private_key = private_key
+      @public_key  = public_key
+      @options     = options.dup
+    end
+
+    ##
+    # Returns `true` if this key pair contains a private key.
+    #
+    # @return [Boolean]
+    def private_key?
+      !!private_key
+    end
+    alias_method :private?, :private_key? # for OpenSSL compatibility
+
+    ##
+    # Returns `true` if this key pair contains a public key.
+    #
+    # @return [Boolean]
+    def public_key?
+      !!public_key
+    end
+    alias_method :public?, :public_key?   # for OpenSSL compatibility
+
+    ##
+    # Returns `true` if this is a valid RSA key pair according to
+    # {RSA::PKCS1 PKCS #1}.
+    #
+    # @return [Boolean]
+    # @see    Key#valid?
+    def valid?
+      private_key.valid? && public_key.valid?
+    end
+
+    ##
+    # Returns the byte size of this key pair.
+    #
+    # @return [Integer]
+    def bytesize
+      Math.log256(modulus).ceil
+    end
+
+    ##
+    # Returns the bit size of this key pair.
+    #
+    # @return [Integer]
+    def bitsize
+      Math.log2(modulus).ceil
+    end
+    alias_method :size, :bitsize
+
+    ##
+    # Returns the RSA modulus for this key pair.
+    #
+    # @return [Integer]
+    def modulus
+      private_key ? private_key.modulus : public_key.modulus
+    end
+    alias_method :n, :modulus
+
+    ##
+    # Encrypts the given `plaintext` using the public key from this key
+    # pair.
+    #
+    # @param  [Integer, String, IO]     plaintext
+    # @param  [Hash{Symbol => Object}]  options
+    # @option options [Symbol, #to_sym] :padding (nil)
+    # @return [Integer]
+    def encrypt(plaintext, options = {})
+      PKCS1.rsaep(public_key, convert_to_integer(plaintext))
+    end
+
+    ##
+    # Decrypts the given `ciphertext` using the private key from this key
+    # pair.
+    #
+    # @param  [Integer, String, IO]     ciphertext
+    # @param  [Hash{Symbol => Object}]  options
+    # @option options [Symbol, #to_sym] :padding (nil)
+    # @return [Integer]
+    def decrypt(ciphertext, options = {})
+      PKCS1.rsadp(private_key, convert_to_integer(ciphertext))
+    end
+
+    ##
+    # Signs the given `plaintext` using the private key from this key pair.
+    #
+    # @param  [Integer, String, IO]     plaintext
+    # @param  [Hash{Symbol => Object}]  options
+    # @option options [Symbol, #to_sym] :padding (nil)
+    # @return [Integer]
+    def sign(plaintext, options = {})
+      PKCS1.rsasp1(private_key, convert_to_integer(plaintext))
+    end
+
+    ##
+    # Verifies the given `signature` using the public key from this key
+    # pair.
+    #
+    # @param  [Integer, String, IO]     signature
+    # @param  [Integer, String, IO]     plaintext
+    # @param  [Hash{Symbol => Object}]  options
+    # @option options [Symbol, #to_sym] :padding (nil)
+    # @return [Boolean]
+    def verify(signature, plaintext, options = {})
+      PKCS1.rsavp1(public_key, convert_to_integer(signature)).eql?(convert_to_integer(plaintext))
+    end
+
+  protected
+
+    ##
+    # Converts the given `input` to an integer suitable for use with RSA
+    # primitives.
+    #
+    # @param  [Integer, String, IO] input
+    # @return [Integer]
+    def convert_to_integer(input)
+      case input
+        when Integer      then input
+        when String       then PKCS1.os2ip(input)
+        when IO, StringIO then PKCS1.os2ip(input.read)
+        else raise ArgumentError, input.inspect # FIXME
+      end
+    end
+  end # class KeyPair
+end # module RSA

data/lib/rsa/math.rb

@@ -0,0 +1,100 @@
+module RSA
+  ##
+  # Mathematical helper functions for RSA.
+  module Math
+    extend ::Math
+
+    ##
+    # Performs a primality test on the integer `n`, returning `true` if it
+    # is a prime.
+    #
+    # @example
+    #   1.upto(10).select { |n| RSA::Math.prime?(n) }  #=> [2, 3, 5, 7]
+    #
+    # @param  [Integer] n
+    # @return [Boolean]
+    # @see    http://en.wikipedia.org/wiki/Primality_test
+    # @see    http://ruby-doc.org/core-1.9/classes/Prime.html
+    def self.prime?(n)
+      if n.respond_to?(:prime?)
+        n.prime?
+      else
+        require 'prime' unless defined?(Prime) # Ruby 1.9+ only
+        Prime.prime?(n)
+      end
+    end
+
+    ##
+    # Performs modular exponentiation in a memory-efficient manner.
+    #
+    # This is equivalent to `base**exponent % modulus` but much faster for
+    # large exponents.
+    #
+    # This is presently a semi-naive implementation. Don't rely on it for
+    # very large exponents.
+    #
+    # @example
+    #   RSA::Math.modpow(5, 3, 13)                     #=> 8
+    #   RSA::Math.modpow(4, 13, 497)                   #=> 445
+    #
+    # @param  [Integer] base
+    # @param  [Integer] exponent
+    # @param  [Integer] modulus
+    # @return [Integer]
+    # @see    http://en.wikipedia.org/wiki/Modular_exponentiation
+    def self.modpow(base, exponent, modulus)
+      1.upto(exponent).inject(1) do |c, e|
+        (c * base) % modulus
+      end
+    end
+
+    ##
+    # Returns the Euler totient for the positive integer `n`.
+    #
+    # This is presently a very naive implementation. Don't rely on it for
+    # anything but very small values of `n`.
+    #
+    # @example
+    #   (1..5).map { |n| RSA::Math.phi(n) }            #=> [1, 1, 2, 2, 4]
+    #
+    # @param  [Integer] n
+    # @return [Integer]
+    # @see    http://en.wikipedia.org/wiki/Euler's_totient_function
+    # @see    http://mathworld.wolfram.com/TotientFunction.html
+    def self.phi(n)
+      1 + (2...n).count { |i| i.gcd(n).eql?(1) }
+    end
+
+    ##
+    # Returns the binary logarithm of `n`.
+    #
+    # @param  [Integer] n
+    # @return [Float]
+    # @see    http://en.wikipedia.org/wiki/Binary_logarithm
+    def self.log2(n)
+      ::Math.log2(n)
+    end
+
+    ##
+    # Returns the base-256 logarithm of `n`.
+    #
+    # @param  [Integer] n
+    # @return [Float]
+    # @see    http://en.wikipedia.org/wiki/Logarithm
+    def self.log256(n)
+      ::Math.log(n, 256)
+    end
+
+    ##
+    # Returns the natural logarithm of `n`. If the optional argument `b` is
+    # given, it will be used as the base of the logarithm.
+    #
+    # @param  [Integer] n
+    # @param  [Integer] b
+    # @return [Float]
+    # @see    http://en.wikipedia.org/wiki/Natural_logarithm
+    def self.log(n, b = nil)
+      b ? ::Math.log(n, b) : ::Math.log(n)
+    end
+  end
+end

data/lib/rsa/openssl.rb

@@ -0,0 +1,37 @@
+module RSA
+  module OpenSSL
+    # TODO
+  end # module OpenSSL
+
+  class KeyPair
+    ##
+    # Generates a new RSA key pair of length `bits`.
+    #
+    # By default, the public exponent will be 65537 (0x10001) as recommended
+    # by {RSA::PKCS1 PKCS #1}.
+    #
+    # @param  [Integer, #to_i] bits
+    # @param  [Integer, #to_i] exponent
+    # @return [KeyPair]
+    def self.generate(bits, exponent = 65537)
+      pkey = ::OpenSSL::PKey::RSA.generate(bits.to_i, exponent.to_i)
+      n, d, e = pkey.n.to_i, pkey.d.to_i, pkey.e.to_i
+      self.new(Key.new(n, d), Key.new(n, e))
+    end
+
+    ##
+    # Returns this key pair as an `OpenSSL::PKey::RSA` instance.
+    #
+    # @return [OpenSSL::PKey::RSA]
+    def to_openssl
+      @openssl_pkey ||= begin
+        pkey   = ::OpenSSL::PKey::RSA.new
+        pkey.n = private_key.modulus  if private_key?
+        pkey.e = private_key.exponent if private_key?
+        pkey.n ||= public_key.modulus if public_key?
+        pkey.d = public_key.exponent  if public_key?
+        pkey
+      end
+    end
+  end # class KeyPair
+end # module RSA

data/lib/rsa/pkcs1.rb

@@ -0,0 +1,124 @@
+module RSA
+  ##
+  # Support for the PKCS #1 (aka RFC 3447) padding schemes.
+  #
+  # @see http://en.wikipedia.org/wiki/PKCS1
+  # @see http://tools.ietf.org/html/rfc3447
+  # @see http://www.rsa.com/rsalabs/node.asp?id=2125
+  module PKCS1
+    ##
+    # Converts a nonnegative integer into an octet string of a specified
+    # length.
+    #
+    # This is the PKCS #1 I2OSP (Integer-to-Octet-String) primitive.
+    # Refer to PKCS #1 v2.1 pp. 8-9, section 4.1.
+    #
+    # @example
+    #   RSA::PKCS1.i2osp(9_202_000, 2)    #=> ArgumentError: integer too large
+    #   RSA::PKCS1.i2osp(9_202_000, 3)    #=> "\x8C\x69\x50"
+    #   RSA::PKCS1.i2osp(9_202_000, 4)    #=> "\x00\x8C\x69\x50"
+    #
+    # @param  [Integer] x   nonnegative integer to be converted
+    # @param  [Integer] len intended length of the resulting octet string
+    # @return [String] octet string of length `len`
+    # @see    http://tools.ietf.org/html/rfc3447#section-4.1
+    # @raise  [ArgumentError] if `n` is greater than 256^len
+    def self.i2osp(x, len = Math.log256(x).ceil)
+      raise ArgumentError, "integer too large" if x >= 256**len
+
+      len.downto(1).inject(String.new) do |s, i|
+        b = (x & 0xFF).chr
+        x >>= 8
+        s = b + s
+      end
+    end
+
+    ##
+    # Converts an octet string into a nonnegative integer.
+    #
+    # This is the PKCS #1 OS2IP (Octet-String-to-Integer) primitive.
+    # Refer to PKCS #1 v2.1 p. 9, section 4.2.
+    #
+    # @example
+    #   RSA::PKCS1.os2ip("\x8C\x69\x50")  #=> 9_202_000
+    #
+    # @param  [String] x octet string to be converted
+    # @return [Integer] nonnegative integer
+    # @see    http://tools.ietf.org/html/rfc3447#section-4.2
+    def self.os2ip(x)
+      x.bytes.inject(0) { |n, b| (n << 8) + b }
+    end
+
+    ##
+    # Produces a ciphertext representative from a message representative
+    # under the control of a public key.
+    #
+    # This is the PKCS #1 RSAEP encryption primitive.
+    # Refer to PKCS #1 v2.1 p. 10, section 5.1.1.
+    #
+    # @param  [Key, #to_a] k RSA public key (`n`, `e`)
+    # @param  [Integer] m message representative, an integer between 0 and `n` - 1
+    # @return [Integer] ciphertext representative, an integer between 0 and `n` - 1
+    # @raise  [ArgumentError] if `m` is out of range
+    # @see    http://tools.ietf.org/html/rfc3447#section-5.1.1
+    def self.rsaep(k, m)
+      n, e = k.to_a
+      raise ArgumentError, "message representative out of range" unless m >= 0 && m < n
+      c = Math.modpow(m, e, n)
+    end
+
+    ##
+    # Recovers the message representative from a ciphertext representative
+    # under the control of a private key.
+    #
+    # This is the PKCS #1 RSADP decryption primitive.
+    # Refer to PKCS #1 v2.1 pp. 10-11, section 5.1.2.
+    #
+    # @param  [Key, #to_a] k RSA private key (`n`, `d`)
+    # @param  [Integer] c ciphertext representative, an integer between 0 and `n` - 1
+    # @return [Integer] message representative, an integer between 0 and `n` - 1
+    # @raise  [ArgumentError] if `c` is out of range
+    # @see    http://tools.ietf.org/html/rfc3447#section-5.1.2
+    def self.rsadp(k, c)
+      n, d = k.to_a
+      raise ArgumentError, "ciphertext representative out of range" unless c >= 0 && c < n
+      m = Math.modpow(c, d, n)
+    end
+
+    ##
+    # Produces a signature representative from a message representative
+    # under the control of a private key.
+    #
+    # This is the PKCS #1 RSASP1 signature primitive.
+    # Refer to PKCS #1 v2.1 pp. 12-13, section 5.2.1.
+    #
+    # @param  [Key, #to_a] k RSA private key (`n`, `d`)
+    # @param  [Integer] m message representative, an integer between 0 and `n` - 1
+    # @return [Integer] signature representative, an integer between 0 and `n` - 1
+    # @raise  [ArgumentError] if `m` is out of range
+    # @see    http://tools.ietf.org/html/rfc3447#section-5.2.1
+    def self.rsasp1(k, m)
+      n, d = k.to_a
+      raise ArgumentError, "message representative out of range" unless m >= 0 && m < n
+      s = Math.modpow(m, d, n)
+    end
+
+    ##
+    # Recovers the message representative from a signature representative
+    # under the control of a public key.
+    #
+    # This is the PKCS #1 RSAVP1 verification primitive.
+    # Refer to PKCS #1 v2.1 p. 13, section 5.2.2.
+    #
+    # @param  [Key, #to_a] k RSA public key (`n`, `e`)
+    # @param  [Integer] s signature representative, an integer between 0 and `n` - 1
+    # @return [Integer] message representative, an integer between 0 and `n` - 1
+    # @raise  [ArgumentError] if `s` is out of range
+    # @see    http://tools.ietf.org/html/rfc3447#section-5.2.2
+    def self.rsavp1(k, s)
+      n, e = k.to_a
+      raise ArgumentError, "signature representative out of range" unless s >= 0 && s < n
+      m = Math.modpow(s, e, n)
+    end
+  end # module PKCS1
+end # module RSA

data/lib/rsa/version.rb

@@ -0,0 +1,22 @@
+module RSA
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    EXTRA = nil
+
+    STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+    ##
+    # @return [String]
+    def self.to_s() STRING end
+
+    ##
+    # @return [String]
+    def self.to_str() STRING end
+
+    ##
+    # @return [Array(Integer, Integer, Integer)]
+    def self.to_a() [MAJOR, MINOR, TINY] end
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: rsa
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Arto Bendiken
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-06 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id002
+description: RSA.rb is a pure-Ruby implementation of the RSA encryption algorithm and the PKCS#1 cryptography standard.
+email: arto.bendiken@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- AUTHORS
+- CREDITS
+- README
+- UNLICENSE
+- VERSION
+- lib/rsa/key.rb
+- lib/rsa/key_pair.rb
+- lib/rsa/math.rb
+- lib/rsa/openssl.rb
+- lib/rsa/pkcs1.rb
+- lib/rsa/version.rb
+- lib/rsa.rb
+has_rdoc: false
+homepage: http://rsa.rubyforge.org/
+licenses: 
+- Public Domain
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 1
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rsa
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: RSA encryption for Ruby.
+test_files: []
+