bitster 0.0.1c

data/examples/bitster.rb

@@ -0,0 +1,58 @@
+$dev = true # flip this if running against an actually installed gem
+
+if !$dev
+  require 'bitster'
+else
+  require_relative '../lib/bitster/version'
+  require_relative '../lib/bitster/crypto_math'
+  require_relative '../lib/bitster/var_helpers'
+  require_relative '../lib/bitster/rsa_key_pair'
+  require_relative '../lib/bitster/rsa_pub_key'
+  require_relative '../lib/bitster/rsa_private_key'
+  require_relative '../lib/bitster/rsa_machine'
+end
+
+ciphertext = Array.new
+result = Array.new
+
+begin
+  plaintext = File.read(ARGV[0]).split("")
+rescue
+  if $stdin.tty?
+    plaintext = ("C"*32).split("")
+  else
+    plaintext = ARGF.read.split("")
+  end
+end
+
+key_len = 1024
+print "[*] Generating a new RSA key-pair with modulus #{key_len}..."
+t0 = Time.now.to_i
+pair = Bitster::RSAKeyPair.new(key_len)
+t1 = Time.now.to_i
+puts " done; time elapsed: #{t1 - t0}s."
+
+machine = Bitster::RSAMachine.new(:keypair => pair)
+
+print "[*] Encrypting..."
+t0 = Time.now.to_i
+plaintext.each do |c|
+  ciphertext << machine.encrypt(c.ord)
+end
+t1 = Time.now.to_i
+puts " done; time elapsed: #{t1 - t0}s."
+
+
+print "[*] Decrypting..."
+t0 = Time.now.to_i
+ciphertext.each do |c|
+  result << machine.decrypt(c).chr
+end
+t1 = Time.now.to_i
+puts " done; time elapsed: #{t1 - t0}s."
+
+puts "[*] Result:"
+puts "-"*80
+puts result.join
+puts "-"*80
+puts "[*] -END-"

data/examples/bitster.txt

@@ -0,0 +1,9 @@
+RSA is one of the first practical public-key cryptosystems and is widely used
+for secure data transmission. In such a cryptosystem, the encryption key is
+public and differs from the decryption key which is kept secret. In RSA, this
+asymmetry is based on the practical difficulty of factoring the product of two
+large prime numbers, the factoring problem. RSA is made of the initial letters
+of the surnames of Ron Rivest, Adi Shamir, and Leonard Adleman, who first
+publicly described the algorithm in 1977. Clifford Cocks, an English mathe-
+matician working for the UK intelligence agency GCHQ, had developed an equi-
+valent system in 1973, but it was not declassified until 1997.

data/examples/bitster_simple.rb

@@ -0,0 +1,27 @@
+$dev = true # flip this if running against an actually installed gem
+
+if !$dev
+  require 'bitster'
+else
+  require_relative '../lib/bitster/version'
+  require_relative '../lib/bitster/crypto_math'
+  require_relative '../lib/bitster/var_helpers'
+  require_relative '../lib/bitster/rsa_key_pair'
+  require_relative '../lib/bitster/rsa_pub_key'
+  require_relative '../lib/bitster/rsa_private_key'
+  require_relative '../lib/bitster/rsa_machine'
+end
+
+key_pair = Bitster::RSAKeyPair.new(1024)
+machine = Bitster::RSAMachine.new(:keypair => key_pair)
+
+ciphertext = %w(H E L L O).collect do |char|
+  machine.encrypt(char.ord)
+end
+
+plaintext = ciphertext.collect do |ascii_code|
+  machine.decrypt(ascii_code).chr
+end.join('')
+
+puts plaintext
+

data/lib/bitster.rb

@@ -0,0 +1,14 @@
+require 'bitster/version'
+require 'bitster/crypto_math'
+require 'bitster/var_helpers'
+require 'bitster/rsa_key_pair'
+require 'bitster/rsa_pub_key'
+require 'bitster/rsa_private_key'
+require 'bitster/rsa_machine'
+
+
+require 'json'
+
+module Bitster
+  include self::CryptoMath
+end

data/lib/bitster/crypto_math.rb

@@ -0,0 +1,132 @@
+module Bitster
+
+  # This module implements mathematical functions needed by the RSA layer,
+  # i.e. primality tests, modular arithmetic, and random odd number generation.
+  #
+  # ToDo: Error handling (with custom Exception class, etc.)
+  #
+  module CryptoMath
+
+    # This function performs what is known as Modular exponentiation
+    # https://en.wikipedia.org/wiki/Modular_exponentiation
+    #
+    # Modular exponentiation are easy to compute, even when the numbers
+    # involved are enormous.
+    #
+    def modular_pow(base, exponent, modulus)
+      return nil if modulus == 1
+      result = 1
+      base = base % modulus
+      while exponent > 0 do
+        if (exponent % 2) == 1
+          result = (result * base) % modulus
+        end
+        exponent = exponent >> 1
+        base = (base * base) % modulus
+      end
+      result
+    end
+
+    # This function just combines Fermat test and Rabin-Miller test.
+    # If both witness the primality, we consider the argument a
+    # probable prime
+    #
+    # ToDo: How to calculate an optimal number of RM rounds instead of 7?
+    #
+    def probable_prime?(p, k=7)
+      fermat_prime?(p) && rm_prime?(p, k)
+    end
+
+    # This is Fermat primality test.
+    # https://en.wikipedia.org/wiki/Fermat_primality_test
+    #
+    # ToDo: How to really choose "a" and how many iterations to run?
+    #
+    def fermat_prime?(p)
+      raise ArgumentError, 'Argument must be an Integer greater than 3' unless p.is_a?(Integer) && (p>3)
+      [p-1, p/2, p/3, p/4, 1].each do |a|
+        # return false if (a**(p-1) % p) != (1 % p)
+        return false if modular_pow(a, (p-1), p) != (1 % p)
+      end
+      true
+    end
+
+    # This is Rabin-Miller primality test
+    # https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
+    #
+    def rm_prime?(n, k)
+      r=0; d=0
+      (1..128).each do |i|
+        d = n / (2**i)
+        r = i
+        break unless (d % 2) == 0
+      end
+      k.times do
+        flg = false
+        a = rand(2..(n-2))
+        x = modular_pow(a, d, n)
+        if (x == 1) || (x == (n - 1))
+          next
+        end
+        (r-1).times do
+          x = modular_pow(x, 2, n)
+          return false if x == 1
+          if x == (n - 1)
+            flg = true
+            break
+          end
+        end
+        next if flg
+        return false
+      end
+      true
+    end
+
+    # This function generates a random odd integer in a range of
+    # 2^(bits-1) ... 2^(bits)
+    #
+    # ToDo: What should the minimum really be?
+    #
+    def gen_odd(bits)
+      max = 2**bits
+      min = 2**(bits-1)
+      r = rand(min..max)
+      return r - 1 if r%2 == 0
+      r
+    end
+
+    # This function calculates the Modular multiplicative inverse
+    # which is needed in the key generation process.
+    # https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
+    #
+    def modular_multiplicative_inverse(a, n)
+      t = 0
+      nt = 1
+      r = n
+      nr = a % n
+
+      if n < 0
+        n = -n
+      end
+      if a < 0
+        a = n - (-a % n)
+      end
+      while nr != 0 do
+        quot = 0
+        quot = (r/nr) unless (r/nr) == 0
+        tmp = nt; nt = t - quot*nt; t = tmp
+        tmp = nr; nr = r - quot*nr; r = tmp
+      end
+      if r > 1
+        raise StandardError, "#{a} and #{n} are not coprimes, can't find MMI"
+      end
+      if t < 0
+        t += n
+      end
+      t
+    end
+    
+    extend self
+
+  end
+end

data/lib/bitster/rsa_key_pair.rb

@@ -0,0 +1,87 @@
+module Bitster
+
+  # This class represents a RSA key-pair. The most important feature is the
+  # generation of the key-pair, so it is an implementation of the process
+  # outlined in https://en.wikipedia.org/wiki/RSA_(cryptosystem)#Key_generation
+  #
+  class RSAKeyPair
+
+    class RSAKeyPairError < StandardError
+    end
+
+    attr_reader :len, :shorter, :p, :q, :n, :k, :e, :private_key, :public_key
+
+    def initialize(len)
+      @len = len
+
+      @shorter = rand(0..1)
+      @p = gen_p
+      @q = gen_q
+      @n = @p * @q # modulus
+      @k = gen_totient
+      @e = gen_e # pubkey exponent
+      @d = gen_d # prikey exponent
+
+      @private_key = RSAPrivateKey.new(@p, @q, @d, @len)
+      @public_key = RSAPubKey.new(@n, @e, @len)
+
+    end
+
+    private
+    include CryptoMath
+
+    # ToDo: what should the length difference of p and q really be?
+    def gen_p
+      handle_exceptions do
+        len_p = @len/2
+        len_p -= rand(2..4) if @shorter == 0
+        loop do
+          p = gen_odd(len_p)
+          return p if probable_prime?(p)
+        end
+      end
+    end
+
+    # ToDo: what should the length difference of p and q really be?
+    def gen_q
+      handle_exceptions do
+        len_q = @len/2
+        len_q -= rand(2..4) if @shorter == 1
+        loop do
+          q = gen_odd(len_q)
+          return q if probable_prime?(q)
+        end
+      end
+    end
+
+    def gen_totient
+      handle_exceptions do
+        (@p-1)*(@q-1)
+      end
+    end
+
+    # ToDo: what should the lower bound really be?
+    def gen_e
+      handle_exceptions do
+        loop do
+          e = rand(4..@k)
+          return e if e.gcd(@k) == 1
+        end
+      end
+    end
+
+    def gen_d
+      handle_exceptions do
+        modular_multiplicative_inverse(e, k)
+      end
+    end
+
+    def handle_exceptions
+      begin
+        yield
+      rescue StandardError => e
+        raise RSAKeyPairError, "Exception in RSAKeyPair: #{e}"
+      end
+    end
+  end
+end

data/lib/bitster/rsa_machine.rb

@@ -0,0 +1,32 @@
+module Bitster
+
+  # This class implements RSA encryption and decryption functions.
+  # It is initialized with necessary keys, represented as instances
+  # of their according classes.
+  #
+  class RSAMachine
+    attr_accessor :pubkey, :prikey
+
+    def initialize(opts={})
+      @pubkey = opts[:pubkey] if opts.has_key?(:pubkey)
+      @prikey = opts[:prikey] if opts.has_key?(:prikey)
+      if opts.has_key?(:keypair)
+        @pubkey = opts[:keypair].public_key
+        @prikey = opts[:keypair].private_key
+      end
+    end
+
+    # https://en.wikipedia.org/wiki/RSA_(cryptosystem)#Encryption
+    #
+    def encrypt(plaintext_msg_code)
+      CryptoMath::modular_pow(plaintext_msg_code, @pubkey.exponent, @pubkey.modulus)
+    end
+
+    # https://en.wikipedia.org/wiki/RSA_(cryptosystem)#Decryption
+    #
+    def decrypt(ciphertext_msg_code)
+      CryptoMath::modular_pow(ciphertext_msg_code, @prikey.exponent, @prikey.modulus)
+    end
+
+  end
+end

data/lib/bitster/rsa_private_key.rb

@@ -0,0 +1,31 @@
+module Bitster
+
+  # This class represents RSA private key and provides various
+  # formatting and similar helper methods associated with it.
+  #
+  class RSAPrivateKey
+
+    attr_reader :modulus, :exponent, :len, :p, :q
+
+    def initialize(p, q, exponent, len)
+      @exponent = exponent
+      @modulus = p*q
+      @p = p; @q = q
+      @len = len
+    end
+
+    def get_hash
+      { modulus: pad(@modulus, 16, @len), exponent: pad(@exponent, 16, @len) }
+    end
+
+    def get_json
+      JSON.pretty_generate get_hash
+    end
+
+    private
+    include VarHelpers
+
+  end
+end
+
+

data/lib/bitster/rsa_pub_key.rb

@@ -0,0 +1,28 @@
+module Bitster
+
+  # This class represents RSA public key and provides various
+  # formatting and similar helper methods associated with it.
+  #
+  class RSAPubKey
+
+    attr_reader :modulus, :exponent, :len
+
+    def initialize(modulus, exponent, len)
+      @modulus = modulus
+      @exponent = exponent
+      @len = len
+    end
+
+    def get_hash
+      { modulus: pad(@modulus, 16, @len), exponent: pad(@exponent, 16, @len) }
+    end
+
+    def get_json
+      JSON.pretty_generate get_hash
+    end
+
+    private
+    include VarHelpers
+
+  end
+end

data/lib/bitster/var_helpers.rb

@@ -0,0 +1,13 @@
+module Bitster
+  module VarHelpers
+    include Math
+
+    def pad(num, base, len)
+      digits = (len*log(2)) / (log(base))
+      num.to_s(base).rjust(digits, '0')
+    end
+
+    extend self
+
+  end
+end

data/lib/bitster/version.rb

@@ -0,0 +1,3 @@
+module Bitster
+  VERSION='0.0.1c'
+end