rsa 0.1.1 → 0.1.2

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/lib/rsa/key_pair.rb

@@ -87,6 +87,17 @@ module RSA
     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.

data/lib/rsa/math.rb

@@ -4,6 +4,8 @@ module RSA
   module Math
     extend ::Math
 
+    class ArithmeticError < ArgumentError; end
+
     ##
     # Performs a primality test on the integer `n`, returning `true` if it
     # is a prime.
@@ -12,7 +14,7 @@ module RSA
     #   1.upto(10).select { |n| RSA::Math.prime?(n) }  #=> [2, 3, 5, 7]
     #
     # @param  [Integer] n
-    # @return [Boolean]
+    # @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)
@@ -24,6 +26,97 @@ module RSA
       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)
+      gcd(a, b).equal?(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.
     #
@@ -31,7 +124,7 @@ module RSA
     # large exponents.
     #
     # The running time of the used algorithm, the right-to-left binary
-    # method, is O(log _exponent_).
+    # method, is on the order of O(log _exponent_).
     #
     # @example
     #   RSA::Math.modpow(5, 3, 13)                     #=> 8
@@ -66,7 +159,7 @@ module RSA
     # @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) }
+      1 + (2...n).count { |i| coprime?(n, i) }
     end
 
     ##

data/lib/rsa/version.rb

@@ -2,7 +2,7 @@ module RSA
   module VERSION
     MAJOR = 0
     MINOR = 1
-    TINY  = 1
+    TINY  = 2
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Arto Bendiken
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-06 00:00:00 +02:00
+date: 2010-09-07 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency