Class: ExoBasic::RSAKeys

Inherits:
Object
  • Object
show all
Defined in:
lib/exobasic/encrypt/rsa_keys.rb

Constant Summary collapse

BITS = 
2048

Class Method Summary collapse

Class Method Details

.from_pem(key_pem) ⇒ Object 



48
49
50
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 48

def self.from_pem(key_pem)
  OpenSSL::PKey::RSA.new(key_pem)
end

.gen_key(bits = nil) ⇒ Object 



68
69
70
71
72
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 68

def self.gen_key(bits=nil)
  b = bits.nil? ? RSAKeys::BITS : bits

  RSAKeys.get_key_details(OpenSSL::PKey::RSA.generate(b))
end

.get_key_details(private_key) ⇒ Object 



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 28

def self.get_key_details(private_key)
  private_key_pem = private_key.to_pem
  private_key_hex = private_key.to_der.unpack('H*').first

  public_key      = private_key.public_key
  public_key_pem  = public_key.to_pem
  public_key_hex  = public_key.to_der.unpack('H*').first

  {
    :private_pem => private_key_pem,
    :private_hex => private_key_hex,
    :public_pem => public_key_pem,
    :public_hex => public_key_hex
  }
end

.private_decrypt(private_key_pem, encrypted_base64) ⇒ Object 



108
109
110
111
112
113
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 108

def self.private_decrypt(private_key_pem, encrypted_base64)
  pkey = RSAKeys.from_pem(private_key_pem)

  encrypted = Base64.decode64(encrypted_base64)
  pkey.private_decrypt(encrypted)
end

.private_encrypt(private_key_pem, data) ⇒ Object 



90
91
92
93
94
95
96
97
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 90

def self.private_encrypt(private_key_pem, data)
  pkey = RSAKeys.from_pem(private_key_pem)

  encrypted        = pkey.private_encrypt(data)
  encrypted_base64 = Base64.encode64(encrypted).gsub("\n", '')

  encrypted_base64
end

.private_from_hex(private_hex) ⇒ Object 



52
53
54
55
56
57
58
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 52

def self.private_from_hex(private_hex)
  der = [private_hex].pack('H*')
  b64 = Base64.encode64(der)
  pem = RSAKeys.s_to_private_pem(b64)

  RSAKeys.from_pem(pem)
end

.private_pem_to_s(pem) ⇒ Object 



8
9
10
11
12
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 8

def self.private_pem_to_s(pem)
  pem.gsub("-----BEGIN RSA PRIVATE KEY-----\n", '')
     .gsub("\n-----END RSA PRIVATE KEY-----\n", '')
     .gsub("\n", '')
end

.public_decrypt(public_key_pem, encrypted_base64) ⇒ Object 



115
116
117
118
119
120
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 115

def self.public_decrypt(public_key_pem, encrypted_base64)
  pub_key = RSAKeys.from_pem(public_key_pem)

  encrypted = Base64.decode64(encrypted_base64)
  pub_key.public_decrypt(encrypted)
end

.public_encrypt(public_key_pem, data) ⇒ Object 



99
100
101
102
103
104
105
106
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 99

def self.public_encrypt(public_key_pem, data)
  pub_key = RSAKeys.from_pem(public_key_pem)

  encrypted        = pub_key.public_encrypt(data)
  encrypted_base64 = Base64.encode64(encrypted).gsub("\n", '')

  encrypted_base64
end

.public_from_hex(public_hex) ⇒ Object 



60
61
62
63
64
65
66
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 60

def self.public_from_hex(public_hex)
  der = [public_hex].pack('H*')
  b64 = Base64.encode64(der)
  pem = RSAKeys.s_to_public_pem(b64)

  RSAKeys.from_pem(pem)
end

.public_pem_to_s(pem) ⇒ Object 



18
19
20
21
22
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 18

def self.public_pem_to_s(pem)
  pem.gsub("-----BEGIN PUBLIC KEY-----\n", '')
     .gsub("\n-----END PUBLIC KEY-----\n", '')
     .gsub("\n", '')
end

.s_to_private_pem(b64) ⇒ Object 



14
15
16
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 14

def self.s_to_private_pem(b64)
  "-----BEGIN RSA PRIVATE KEY-----\n#{b64}-----END RSA PRIVATE KEY-----\n"
end

.s_to_public_pem(b64) ⇒ Object 



24
25
26
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 24

def self.s_to_public_pem(b64)
  "-----BEGIN PUBLIC KEY-----\n#{b64}-----END PUBLIC KEY-----\n"
end

.sign_message(private_key_pem, data) ⇒ Object 



74
75
76
77
78
79
80
81
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 74

def self.sign_message(private_key_pem, data)
  pkey = RSAKeys.from_pem(private_key_pem)

  signature        = pkey.sign_pss('SHA256', data, salt_length: :max, mgf1_hash: 'SHA256')
  signature_base64 = Base64.encode64(signature).gsub("\n", '')

  signature_base64
end

.to_pem(key) ⇒ Object 



44
45
46
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 44

def self.to_pem(key)
  key.to_pem
end

.verify_message(public_key_pem, signature_base64, data) ⇒ Object 



83
84
85
86
87
88
 
# File 'lib/exobasic/encrypt/rsa_keys.rb', line 83

def self.verify_message(public_key_pem, signature_base64, data)
  pub_key = RSAKeys.from_pem(public_key_pem)

  signature = Base64.decode64(signature_base64)
  pub_key.verify_pss('SHA256', signature, data, salt_length: :auto, mgf1_hash: 'SHA256')
end