Class: Silkey::SDK

Inherits:
Object
  • Object
show all
Defined in:
lib/silkey/sdk.rb

Class Method Summary collapse

Class Method Details

.fetch_silkey_public_key ⇒ Object

Fetches public ethereum Silkey address (directly from blockchain). This address can be used for token verification

See Also:

  • of Silkey contracts addresses: https://github.com/Silkey-Team/silkey-sdk#silkey-sdk


126
127
128
129
130
131
132
 
# File 'lib/silkey/sdk.rb', line 126

def fetch_silkey_public_key
  public_key = Silkey::RegistryContract.get_address('Hades')

  raise "Invalid public key: #{public_key}" unless Silkey::Utils.ethereum_address?(public_key)

  public_key
end

.generate_sso_request_params(private_key, params) ⇒ Hash

Generates all needed parameters (including signature) for requesting Silkey SSO

Examples:


data = { :redirectUrl => 'https://your-website', :refId => '12ab' }
Silkey::SDK.generate_sso_request_params(private_key, data)

Parameters:

  • private_key (string) —

    secret private key of domain owner

  • params (Hash) —

    Hash object with parameters:

    • redirectUrl*,

    • redirectMethod*,

    • cancelUrl*,

    • refId,

    • scope,

    • ssoTimestamp*

    marked with * are required by Silkey

Returns:

  • (Hash) —

    parameters for SSO as key -> value, they all need to be set in URL



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/silkey/sdk.rb', line 55

def generate_sso_request_params(private_key, params)
  raise "params[:redirectUrl] is empty" if Silkey::Utils.empty?(params[:redirectUrl])

  raise "params[:cancelUrl] is empty" if Silkey::Utils.empty?(params[:cancelUrl])

  keys = %w(redirectUrl redirectMethod cancelUrl ssoTimestamp refId scope)

  data_to_sign = keys.reduce({}) do |acc, k|
    if Silkey::Utils.empty?(params[k.to_sym])
      case k
      when 'ssoTimestamp'
        acc[k.to_sym] = Silkey::Utils.current_timestamp
      when 'scope'
        acc[k.to_sym] = 'id'
      else
        # type code here
      end
    else
      acc[k.to_sym] = params[k.to_sym]
    end

    acc
  end

  puts data_to_sign
  message = message_to_sign(data_to_sign)
  data_to_sign['signature'] = Silkey::Utils.sign_message(private_key, message)

  data_to_sign
end

.message_to_sign(to_sign = {}) ⇒ string

Generates message to sign based on plain object data (keys => values)

@example:

Silkey::SDK.message_to_sign({ :redirectUrl => 'http://silkey.io', :refId => 1 });

returns

'redirectUrl=http://silkey.io::refId=1'

Parameters:

  • to_sign (Hash) (defaults to: {}) —

    hash object

Returns:

  • (string) —

    message to sign



21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/silkey/sdk.rb', line 21

def message_to_sign(to_sign = {})
  msg = []
  to_sign.keys.sort.each do |k|
    if Silkey::Utils.empty?(to_sign[k])
      msg.push("#{k}=")
    else
      msg.push("#{k}=#{to_sign[k]}")
    end
  end

  msg.join('::')
end

.token_payload_verifier(token, silkey_public_key = nil) ⇒ JwtPayload|null

Verifies JWT token payload

Examples:


Silkey::SDK.token_payload_verifier(
  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG'\
  '9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c',
  Silkey::SDK.fetch_silkey_public_key
)

Parameters:

  • token (string) —

    JWT token returned by Silkey

  • silkey_public_key (string) (defaults to: nil) —

    public ethereum address of Silkey

Returns:

  • (JwtPayload|null) —

    null when signature(s) are invalid, otherwise token payload

See Also:



107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/silkey/sdk.rb', line 107

def token_payload_verifier(token, silkey_public_key = nil)
  payload = token_payload(token)

  if silkey_signature_valid?(payload, silkey_public_key) != false &&
     user_signature_valid?(payload) != false
    return Silkey::Models::JwtPayload.new.import(payload)
  end

  nil
rescue
  nil
end