Module: RSA

Defined in:

lib/rsa.rb

Defined Under Namespace

Modules: OPEN Classes: Private, Public

Class Method Summary

• .decode(menssage_encode) ⇒ Object
• .encode(menssage) ⇒ Object
• .generated ⇒ Object
• .generated_open_keys ⇒ Object

Class Method Details

.decode(menssage_encode) ⇒ Object

# File 'lib/rsa.rb', line 185

def self.decode(menssage_encode)  
  d = nil
  n = nil

  if RSA::OPEN::Private.d && RSA::OPEN::Private.n
    d = RSA::OPEN::Private.d
    n = RSA::OPEN::Private.n
  else
    archive_private = ArchivePrivate.new
    private_file = archive_private.read
    d = private_file[:key_d].to_i
    n = private_file[:key_p].to_i * private_file[:key_q].to_i
  end

  menssage_decode = menssage_encode.map { |block|
    original_chunk = block.to_i.mod_pow(d, n)
    TextChunk.new(original_chunk).to_s
  }.join

  MessageCompile.back_pre_compile(menssage_decode)
end

.encode(menssage) ⇒ Object

# File 'lib/rsa.rb', line 162

def self.encode(menssage)
  e = nil
  n = nil

  if RSA::OPEN::Public.e && RSA::OPEN::Public.n
    e = RSA::OPEN::Public.e
    n = RSA::OPEN::Public.n
  else
    archive_public = ArchivePublic.new
    file = archive_public.read
    e = file[:e].to_i
    n = file[:key_n].to_i
  end
  chunk_size = TextChunk.block_size(n)
  split_in_regex = /.{1,#{chunk_size}}/

  pre_compile = MessageCompile.pre_compile(menssage)
  array_chunk = pre_compile.scan(split_in_regex)
  array_chunk.map { |chunk| 
    TextChunk.new(chunk).to_i.mod_pow(e, n) 
  }
end

.generated ⇒ Object

# File 'lib/rsa.rb', line 146

def self.generated
  private = RSA::Private.new
  public = RSA::Public.new(private: private)

  private.create_file_of_keys
  public.create_file_of_keys
end

.generated_open_keys ⇒ Object

# File 'lib/rsa.rb', line 154

def self.generated_open_keys
  private = RSA::Private.new
  public = RSA::Public.new(private: private)

  private.create_file(ArchivePrivateOpen.new)
  public.create_file(ArchivePublicOpen.new)
end