rsa-g 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 463d0dbc0338873b4d2aa01faab3eef89da7c99b
+  data.tar.gz: 2858960e94ac616e97bdd85763add76e7bc86b35
+SHA512:
+  metadata.gz: e35f2fb15ea89dd07979a5a01ee665e51631e496952e640672ecbf700066a10541abca47a25dac1cacf26e9d77893e799bb1d3188c5aad8c989ecb31cc9cfb19
+  data.tar.gz: f1e482f1acabe397329ab2440e50d8ade9b20377c9ae5e26984400bf79257b9a5a0f8bb0310a4ba5de89bb46a599832c5c262eaf7225178d2cdd9c0a07c08e85

data/AUTHORS

@@ -0,0 +1 @@
+Gabriel Vian

data/README

@@ -0,0 +1 @@
+README.md

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 @@
+1.0.0

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,241 @@
+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
+
+    ##
+    # Returns a hash table representation of this key pair.
+    #
+    # @example
+    #   key_pair.to_hash  #=> {:n => ..., :d => ..., :e => ...}
+    #
+    # @return [Hash]
+    def to_hash
+      {:n => modulus, :d => private_key ? private_key.exponent : nil, :e => public_key ? public_key.exponent : nil}
+    end
+
+    ##
+    # Encrypts the given `plaintext` using the public key from this key
+    # pair.
+    #
+    # @overload encrypt(plaintext, options = {})
+    #   @param  [Integer]                 plaintext
+    #   @param  [Hash{Symbol => Object}]  options
+    #   @return [Integer]
+    #
+    # @overload encrypt(plaintext, options = {})
+    #   @param  [String, IO, StringIO]    plaintext
+    #   @param  [Hash{Symbol => Object}]  options
+    #   @return [String]
+    #
+    # @param  [Object]                  plaintext
+    # @param  [Hash{Symbol => Object}]  options
+    # @option options [Symbol, #to_sym] :padding (nil)
+    def encrypt(plaintext, options = {})
+      case plaintext
+        when Integer      then encrypt_integer(plaintext, options)
+        when String       then PKCS1.i2osp(encrypt_integer(PKCS1.os2ip(plaintext), options))
+        when StringIO, IO then PKCS1.i2osp(encrypt_integer(PKCS1.os2ip(plaintext.read), options))
+        else raise ArgumentError, plaintext.inspect # FIXME
+      end
+    end
+
+    ##
+    # Decrypts the given `ciphertext` using the private key from this key
+    # pair.
+    #
+    # @overload decrypt(ciphertext, options = {})
+    #   @param  [Integer]                 ciphertext
+    #   @param  [Hash{Symbol => Object}]  options
+    #   @return [Integer]
+    #
+    # @overload decrypt(ciphertext, options = {})
+    #   @param  [String, IO, StringIO]    ciphertext
+    #   @param  [Hash{Symbol => Object}]  options
+    #   @return [String]
+    #
+    # @param  [Object]                  ciphertext
+    # @param  [Hash{Symbol => Object}]  options
+    # @option options [Symbol, #to_sym] :padding (nil)
+    def decrypt(ciphertext, options = {})
+      case ciphertext
+        when Integer      then decrypt_integer(ciphertext, options)
+        when String       then PKCS1.i2osp(decrypt_integer(PKCS1.os2ip(ciphertext), options))
+        when StringIO, IO then PKCS1.i2osp(decrypt_integer(PKCS1.os2ip(ciphertext.read), options))
+        else raise ArgumentError, ciphertext.inspect # FIXME
+      end
+    end
+
+    ##
+    # Signs the given `plaintext` using the private key from this key pair.
+    #
+    # @overload sign(plaintext, options = {})
+    #   @param  [Integer]                 plaintext
+    #   @param  [Hash{Symbol => Object}]  options
+    #   @return [Integer]
+    #
+    # @overload sign(plaintext, options = {})
+    #   @param  [String, IO, StringIO]    plaintext
+    #   @param  [Hash{Symbol => Object}]  options
+    #   @return [String]
+    #
+    # @param  [Object]                  plaintext
+    # @param  [Hash{Symbol => Object}]  options
+    # @option options [Symbol, #to_sym] :padding (nil)
+    def sign(plaintext, options = {})
+      case plaintext
+        when Integer      then sign_integer(plaintext, options)
+        when String       then PKCS1.i2osp(sign_integer(PKCS1.os2ip(plaintext), options))
+        when StringIO, IO then PKCS1.i2osp(sign_integer(PKCS1.os2ip(plaintext.read), options))
+        else raise ArgumentError, plaintext.inspect # FIXME
+      end
+    end
+
+    ##
+    # Verifies the given `signature` using the public key from this key
+    # pair.
+    #
+    # @overload verify(signature, plaintext, options = {})
+    #   @param  [Integer]                 signature
+    #   @param  [Integer]                 plaintext
+    #   @param  [Hash{Symbol => Object}]  options
+    #   @return [Boolean]
+    #
+    # @overload verify(signature, plaintext, options = {})
+    #   @param  [String, IO, StringIO]    signature
+    #   @param  [String, IO, StringIO]    plaintext
+    #   @param  [Hash{Symbol => Object}]  options
+    #   @return [Boolean]
+    #
+    # @param  [Object]                  signature
+    # @param  [Object]                  plaintext
+    # @param  [Hash{Symbol => Object}]  options
+    # @option options [Symbol, #to_sym] :padding (nil)
+    # @return [Boolean]
+    def verify(signature, plaintext, options = {})
+      signature = case signature
+        when Integer      then signature
+        when String       then PKCS1.os2ip(signature)
+        when StringIO, IO then PKCS1.os2ip(signature.read)
+        else raise ArgumentError, signature.inspect # FIXME
+      end
+      plaintext = case plaintext
+        when Integer      then plaintext
+        when String       then PKCS1.os2ip(plaintext)
+        when StringIO, IO then PKCS1.os2ip(plaintext.read)
+        else raise ArgumentError, plaintext.inspect # FIXME
+      end
+      verify_integer(signature, plaintext, options)
+    end
+
+  protected
+
+    ##
+    # @private
+    def encrypt_integer(plaintext, options = {})
+      PKCS1.rsaep(public_key, plaintext)
+    end
+
+    ##
+    # @private
+    def decrypt_integer(ciphertext, options = {})
+      PKCS1.rsadp(private_key, ciphertext)
+    end
+
+    ##
+    # @private
+    def sign_integer(plaintext, options = {})
+      PKCS1.rsasp1(private_key, plaintext)
+    end
+
+    ##
+    # @private
+    def verify_integer(signature, plaintext, options = {})
+      PKCS1.rsavp1(public_key, signature).eql?(plaintext)
+    end
+  end # class KeyPair
+end # module RSA

data/lib/rsa/math.rb

@@ -0,0 +1,277 @@
+module RSA
+  ##
+  # Mathematical helper functions for RSA.
+  module Math
+    extend ::Math
+
+    class ArithmeticError < ArgumentError; end
+
+    ##
+    # Yields an infinite pseudo-prime number sequence.
+    #
+    # This is a pseudo-prime generator that simply yields the initial values
+    # 2 and 3, followed by all positive integers that are not divisible by 2
+    # or 3.
+    #
+    # It works identically to `Prime::Generator23`, the Ruby 1.9 standard
+    # library's default pseudo-prime generator implementation.
+    #
+    # @example
+    #   RSA::Math.primes.take(5)                       #=> [2, 3, 5, 7, 11]
+    #
+    # @yield  [p] each pseudo-prime number
+    # @yieldparam [Integer] p a pseudo-prime number
+    # @return [Enumerator] yielding pseudo-primes
+    # @see    http://ruby-doc.org/core-1.9/classes/Prime.html
+    def self.primes(&block)
+      if block_given?
+        yield 2; yield 3; yield 5
+        prime, step = 5, 4
+        loop { yield prime += (step = 6 - step) }
+      end
+      enum_for(:primes)
+    end
+
+    ##
+    # Yields the prime factorization of the nonzero integer `n`.
+    #
+    # @example
+    #   RSA::Math.factorize(12).to_a                   #=> [[2, 2], [3, 1]]
+    #
+    # @param  [Integer] n a nonzero integer
+    # @yield  [p, e] each prime factor
+    # @yieldparam [Integer] p the prime factor base
+    # @yieldparam [Integer] e the prime factor exponent
+    # @return [Enumerator]
+    # @raise  [ZeroDivisionError] if `n` is zero
+    # @see    http://ruby-doc.org/core-1.9/classes/Prime.html
+    def self.factorize(n, &block)
+      raise ZeroDivisionError if n.zero?
+      if block_given?
+        n = n.abs if n < 0
+        primes.find do |p|
+          e = 0
+          while (q, r = n.divmod(p); r.zero?)
+            n, e = q, e + 1
+          end
+          yield p, e unless e.zero?
+          n <= p
+        end
+        yield n, 1 if n > 1
+      end
+      enum_for(:factorize, n)
+    end
+
+    ##
+    # 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 an integer
+    # @return [Boolean] `true` if `n` is a prime number, `false` otherwise
+    # @see    http://en.wikipedia.org/wiki/Primality_test
+    # @see    http://ruby-doc.org/core-1.9/classes/Prime.html
+    def self.prime?(n)
+      case
+        when n < 0 then prime?(n.abs)
+        when n < 2 then false
+        else primes do |p|
+          q, r = n.divmod(p)
+          return true  if q < p
+          return false if r.zero?
+        end
+      end
+    end
+
+    ##
+    # Returns `true` if the integer `a` is coprime (relatively prime) to
+    # integer `b`.
+    #
+    # @example
+    #   RSA::Math.coprime?(6, 35)                      #=> true
+    #   RSA::Math.coprime?(6, 27)                      #=> false
+    #
+    # @param  [Integer] a an integer
+    # @param  [Integer] b an integer
+    # @return [Boolean] `true` if `a` and `b` are coprime, `false` otherwise
+    # @see    http://en.wikipedia.org/wiki/Coprime
+    # @see    http://mathworld.wolfram.com/RelativelyPrime.html
+    def self.coprime?(a, b)
+      egcd = self.egcd(a, b)
+      (a*egcd[0] + b*egcd[1]).eql?(1)
+    end
+
+    ##
+    # Returns the greatest common divisor (GCD) of the two integers `a` and
+    # `b`. The GCD is the largest positive integer that divides both numbers
+    # without a remainder.
+    #
+    # @example
+    #   RSA::Math.gcd(3, 5)                            #=> 1
+    #   RSA::Math.gcd(8, 12)                           #=> 4
+    #   RSA::Math.gcd(12, 60)                          #=> 12
+    #   RSA::Math.gcd(90, 12)                          #=> 6
+    #
+    # @param  [Integer] a an integer
+    # @param  [Integer] b an integer
+    # @return [Integer] the greatest common divisor of `a` and `b`
+    # @see    http://en.wikipedia.org/wiki/Greatest_common_divisor
+    # @see    http://mathworld.wolfram.com/GreatestCommonDivisor.html
+    def self.gcd(a, b)
+      a.gcd(b)
+    end
+
+    ##
+    # Returns the Bezout coefficients of the two nonzero integers `a` and
+    # `b` using the extended Euclidean algorithm.
+    #
+    # @example
+    #   RSA::Math.egcd(120, 23)                        #=> [-9, 47]
+    #   RSA::Math.egcd(421, 111)                       #=> [-29, 110]
+    #   RSA::Math.egcd(93, 219)                        #=> [33, -14]
+    #   RSA::Math.egcd(4864, 3458)                     #=> [32, -45]
+    #
+    # @param  [Integer] a a nonzero integer
+    # @param  [Integer] b a nonzero integer
+    # @return [Array(Integer, Integer)] the Bezout coefficients `x` and `y`
+    # @raise  [ZeroDivisionError] if `a` or `b` is zero
+    # @see    http://en.wikipedia.org/wiki/B%C3%A9zout's_identity
+    # @see    http://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
+    # @see    http://mathworld.wolfram.com/ExtendedGreatestCommonDivisor.html
+    def self.egcd(a, b)
+      if a.modulo(b).zero?
+        [0, 1]
+      else
+        x, y = egcd(b, a.modulo(b))
+        [y, x - y * a.div(b)]
+      end
+    end
+
+    ##
+    # Returns the modular multiplicative inverse of the integer `b` modulo
+    # `m`, where `b <= m`.
+    #
+    # The running time of the used algorithm, the extended Euclidean
+    # algorithm, is on the order of O(log2 _m_).
+    #
+    # @example
+    #   RSA::Math.modinv(3, 11)                        #=> 4
+    #   RSA::Math.modinv(6, 35)                        #=> 6
+    #   RSA::Math.modinv(-6, 35)                       #=> 29
+    #   RSA::Math.modinv(6, 36)                        #=> ArithmeticError
+    #
+    # @param  [Integer] b
+    # @param  [Integer] m the modulus
+    # @return [Integer] the modular multiplicative inverse
+    # @raise  [ArithmeticError] if `m` <= 0, or if `b` not coprime to `m`
+    # @see    http://en.wikipedia.org/wiki/Modular_multiplicative_inverse
+    # @see    http://mathworld.wolfram.com/ModularInverse.html
+    def self.modinv(b, m)
+      if m > 0 && coprime?(b, m)
+        egcd(b, m).first.modulo(m)
+      else
+        raise ArithmeticError, "modulus #{m} is not positive" if m <= 0
+        raise ArithmeticError, "#{b} is not coprime to #{m}"
+      end
+    end
+
+    ##
+    # Performs modular exponentiation in a memory-efficient manner.
+    #
+    # This is equivalent to `base**exponent % modulus` but much faster for
+    # large exponents.
+    #
+    # The running time of the used algorithm, the right-to-left binary
+    # method, is on the order of O(log _exponent_).
+    #
+    # @example
+    #   RSA::Math.modpow(5, 3, 13)                     #=> 8
+    #   RSA::Math.modpow(4, 13, 497)                   #=> 445
+    #
+    # @param  [Integer] base the base
+    # @param  [Integer] exponent the exponent
+    # @param  [Integer] modulus the modulus
+    # @return [Integer] the result
+    # @see    http://en.wikipedia.org/wiki/Modular_exponentiation
+    def self.modpow(base, exponent, modulus)
+      result = 1
+      while exponent > 0
+        result   = (base * result) % modulus unless (exponent & 1).zero?
+        base     = (base * base)   % modulus
+        exponent >>= 1
+      end
+      result
+    end
+
+    ONE = BigDecimal('1')
+
+    ##
+    # Returns the Euler totient for the positive integer `n`.
+    #
+    # @example
+    #   (1..5).map { |n| RSA::Math.phi(n) }            #=> [1, 1, 2, 2, 4]
+    #
+    # @param  [Integer] n a positive integer, or zero
+    # @return [Integer] the Euler totient of `n`
+    # @raise  [ArgumentError] if `n` < 0
+    # @see    http://en.wikipedia.org/wiki/Euler's_totient_function
+    # @see    http://mathworld.wolfram.com/TotientFunction.html
+    def self.phi(n)
+      case
+        when n < 0     then raise ArgumentError, "expected a positive integer, but got #{n}"
+        when n < 2     then 1 # by convention
+        when prime?(n) then n - 1
+        else factorize(n).inject(n) { |product, (p, e)| product * (ONE - (ONE / BigDecimal(p.to_s))) }.round.to_i
+      end
+    end
+
+    ##
+    # Returns the binary logarithm of `n`.
+    #
+    # @example
+    #   RSA::Math.log2(16)                             #=> 4.0
+    #   RSA::Math.log2(1024)                           #=> 10.0
+    #
+    # @param  [Integer] n a positive integer
+    # @return [Float] the logarithm
+    # @raise  [Errno::EDOM] if `n` < 1
+    # @see    http://en.wikipedia.org/wiki/Binary_logarithm
+    def self.log2(n)
+      ::Math.log2(n)
+    end
+
+    ##
+    # Returns the base-256 logarithm of `n`.
+    #
+    # @example
+    #   RSA::Math.log256(16)                           #=> 0.5
+    #   RSA::Math.log256(1024)                         #=> 1.25
+    #
+    # @param  [Integer] n a positive integer
+    # @return [Float] the logarithm
+    # @raise  [Errno::EDOM] if `n` < 1
+    # @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.
+    #
+    # @example
+    #   RSA::Math.log(16, 2)                           #=> 4.0
+    #   RSA::Math.log(16, 256)                         #=> 0.5
+    #
+    # @param  [Integer] n a positive integer
+    # @param  [Integer] b a positive integer >= 2, or `nil`
+    # @return [Float] the logarithm
+    # @raise  [Errno::EDOM] if `n` < 1, or if `b` < 2
+    # @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,130 @@
+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 = nil)
+      raise ArgumentError, "integer too large" if len && x >= 256**len
+
+      StringIO.open do |buffer|
+        while x > 0
+          b = (x & 0xFF).chr
+          x >>= 8
+          buffer << b
+        end
+        s = buffer.string
+        s.force_encoding(Encoding::BINARY) if s.respond_to?(:force_encoding)
+        s.reverse!
+        s = len ? s.rjust(len, "\0") : 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  = 4
+    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

data/lib/rsa.rb

@@ -0,0 +1,27 @@
+require 'bigdecimal' unless defined?(BigDecimal)
+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

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: rsa-g
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Gabriel Vian
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+description: RSA.rb is a pure-Ruby implementation of the RSA encryption algorithm
+  and the PKCS#1 cryptography standard.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AUTHORS
+- CREDITS
+- README
+- UNLICENSE
+- VERSION
+- lib/rsa.rb
+- 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
+homepage: 
+licenses:
+- Unlicense
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rsa
+rubygems_version: 2.6.14.1
+signing_key: 
+specification_version: 4
+summary: RSA encryption for Ruby.
+test_files: []