securenative 0.1.5 → 0.1.21

data/out/production/securenative-ruby/event_options.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class EventOptions
+  MAX_PROPERTIES_SIZE = 10
+
+  def initialize(event_type, user_id, user_traits, user_name, email, phone, created_at, context, properties, timestamp)
+    traits = UserTraits(user_name)
+    if user_name && email && phone && created_at
+      traits = UserTraits(user_name, email, phone, created_at)
+    elsif user_name && email && phone
+      traits = UserTraits(user_name, email, phone)
+    elsif user_name && email
+      traits = UserTraits(user_name, email)
+    end
+
+    @event_options = EventOptions(event_type)
+    @event_options.user_id = user_id
+    @event_options.user_traits = user_traits if user_traits
+    @event_options.user_traits = traits
+    @event_options.context = context
+    @event_options.properties = properties
+    @event_options.timestamp = timestamp
+  end
+
+  def build
+    if !@event_options.properties.nil? && @event_options.properties.length > MAX_PROPERTIES_SIZE
+      raise SecureNativeInvalidOptionsError('You can have only up to {} custom properties', MAX_PROPERTIES_SIZE)
+    end
+
+    @event_options
+  end
+end

data/out/production/securenative-ruby/http/http_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class HttpResponse
+  attr_reader :ok, :status_code, :body
+  attr_writer :ok, :status_code, :body
+
+  def initialize(ok, status_code, body)
+    @ok = ok
+    @status_code = status_code
+    @body = body
+  end
+end

data/out/production/securenative-ruby/http/securenative_http_client.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'httpclient'
+
+class SecureNativeHttpClient
+  AUTHORIZATION_HEADER = 'Authorization'
+  VERSION_HEADER = 'SN-Version'
+  USER_AGENT_HEADER = 'User-Agent'
+  USER_AGENT_HEADER_VALUE = 'SecureNative-python'
+  CONTENT_TYPE_HEADER = 'Content-Type'
+  CONTENT_TYPE_HEADER_VALUE = 'application/json'
+
+  def initialize(securenative_options)
+    @options = securenative_options
+    @client = HTTPClient.new
+  end
+
+  def _headers
+    {
+      CONTENT_TYPE_HEADER => CONTENT_TYPE_HEADER_VALUE,
+      USER_AGENT_HEADER => USER_AGENT_HEADER_VALUE,
+      VERSION_HEADER => VersionUtils.version,
+      AUTHORIZATION_HEADER => @options.api_key
+    }
+  end
+
+  def post(path, body)
+    url = "#{@options.api_url}/#{path}"
+    headers = _headers
+    @client.post(url, body, headers)
+  end
+end

data/out/production/securenative-ruby/models/client_token.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class ClientToken
+  attr_reader :cid, :vid, :fp
+  attr_writer :cid, :vid, :fp
+
+  def initialize(cid, vid, fp)
+    @cid = cid
+    @vid = vid
+    @fp = fp
+  end
+end

data/out/production/securenative-ruby/models/device.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Device
+  attr_reader :device_id
+  attr_writer :device_id
+
+  def initialize(device_id)
+    @device_id = device_id
+  end
+end

data/out/production/securenative-ruby/models/event_options.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class EventOptions
+  attr_reader :event, :user_id, :user_traits, :context, :properties, :timestamp
+  attr_writer :event, :user_id, :user_traits, :context, :properties, :timestamp
+
+  def initialize(event, user_id = nil, user_traits = nil, context = nil, properties = nil, timestamp = nil)
+    @event = event
+    @user_id = user_id
+    @user_traits = user_traits
+    @context = context
+    @properties = properties
+    @timestamp = timestamp
+  end
+end

data/out/production/securenative-ruby/models/request_context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class RequestContext
+  attr_reader :cid, :vid, :fp, :ip, :remote_ip, :headers, :url, :http_method
+  attr_writer :cid, :vid, :fp, :ip, :remote_ip, :headers, :url, :http_method
+
+  def initialize(cid = nil, vid = nil, fp = nil, ip = nil, remote_ip = nil, headers = nil, url = nil, method = nil)
+    @cid = cid
+    @vid = vid
+    @fp = fp
+    @ip = ip
+    @remote_ip = remote_ip
+    @headers = headers
+    @url = url
+    @method = method
+  end
+end
+

data/out/production/securenative-ruby/models/request_options.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class RequestOptions
+  attr_reader :url, :body, :retry_sending
+  attr_writer :url, :body, :retry_sending
+
+  def initialize(url, body, retry_sending)
+    @url = url
+    @body = body
+    @retry_sending = retry_sending
+  end
+end

data/out/production/securenative-ruby/models/sdk_event.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class SDKEvent
+  attr_reader :context, :rid, :event_type, :user_id, :user_traits, :request, :timestamp, :properties
+  attr_writer :context, :rid, :event_type, :user_id, :user_traits, :request, :timestamp, :properties
+
+  def initialize(event_options, securenative_options)
+    @context = if !event_options.context.nil?
+                 event_options.context
+               else
+                 ContextBuilder.default_context_builder
+               end
+
+    client_token = EncryptionUtils.decrypt(@context.client_token, securenative_options.api_key)
+
+    @rid = SecureRandom.uuid.to_str
+    @event_type = event_options.event
+    @user_id = event_options.user_id
+    @user_traits = event_options.user_traits
+    @request = RequestContext(cid = client_token ? client_token.cid : '', vid = client_token ? client_token.vid : '',
+                              fp = client_token ? client_token.fp : '', ip = @context.ip,
+                              remote_ip = @context.remote_ip, method = @context.http_method, url = @context.url,
+                              headers = @context.headers)
+
+    @timestamp = DateUtils.to_timestamp(event_options.timestamp)
+    @properties = event_options.properties
+  end
+
+  def to_s
+    "context: #{@context}, rid: #{@rid}, event_type: #{@event_type}, user_id: #{@user_id},
+user_traits: #{@user_traits}, request: #{@request}, timestamp: #{@timestamp}, properties: #{@properties}"
+  end
+end

data/out/production/securenative-ruby/models/user_traits.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class UserTraits
+  attr_reader :name, :email, :phone, :created_at
+  attr_writer :name, :email, :phone, :created_at
+
+  def initialize(name = nil, email = nil, phone = nil, created_at = nil)
+    @name = name
+    @email = email
+    @created_at = created_at
+    @phone = phone
+  end
+end

data/out/production/securenative-ruby/models/verify_result.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class VerifyResult
+  attr_reader :risk_level, :score, :triggers
+  attr_writer :risk_level, :score, :triggers
+
+  def initialize(risk_level = nil, score = nil, triggers = nil)
+    @risk_level = risk_level
+    @score = score
+    @triggers = triggers
+  end
+end

data/out/production/securenative-ruby/securenative.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'utils/secure_native_logger'
+require 'utils/signature_utils'
+require 'utils/utils'
+require 'errors/securenative_sdk_error'
+require 'errors/securenative_sdk_Illegal_state_error'
+require 'errors/securenative_config_error'
+require 'enums/failover_strategy'
+require 'config/configuration_builder'
+require 'event_manager'
+
+class SecureNative
+  attr_reader :options
+
+  def initialize(options)
+    @securenative = nil
+    raise SecureNativeSDKError, 'You must pass your SecureNative api key' if Utils.null_or_empty?(options.api_key)
+
+    @options = options
+    @event_manager = EventManager.new(@options)
+
+    @event_manager.start_event_persist unless @options.api_url.nil?
+
+    @api_manager = ApiManager.new(@event_manager, @options)
+    SecureNativeLogger.init_logger(@options.log_level)
+  end
+
+  def self.init_with_options(options)
+    if @securenative.nil?
+      @securenative = SecureNative.new(options)
+      @securenative
+    else
+      SecureNativeLogger.debug('This SDK was already initialized.')
+      raise SecureNativeSDKError, 'This SDK was already initialized.'
+    end
+  end
+
+  def self.init_with_api_key(api_key)
+    raise SecureNativeConfigError, 'You must pass your SecureNative api key' if Utils.null_or_empty?(api_key)
+
+    if @securenative.nil?
+      options = ConfigurationBuilder.new(api_key: api_key)
+      @securenative = SecureNative.new(options)
+      @securenative
+    else
+      SecureNativeLogger.debug('This SDK was already initialized.')
+      raise SecureNativeSDKError, 'This SDK was already initialized.'
+    end
+  end
+
+  def self.init
+    options = ConfigurationManager.load_config
+    init_with_options(options)
+  end
+
+  def self.instance
+    raise SecureNativeSDKIllegalStateError if @securenative.nil?
+
+    @securenative
+  end
+
+  def self.config_builder(api_key = nil, api_url = 'https://api.securenative.com/collector/api/v1', interval = 1000,
+                          max_events = 1000, timeout = 1500, auto_send = true, disable = false, log_level = 'FATAL',
+                          fail_over_strategy = FailOverStrategy::FAIL_OPEN)
+    ConfigurationBuilder.new(api_key, api_url, interval, max_events, timeout, auto_send, disable, log_level, fail_over_strategy)
+  end
+
+  def self.context_builder(client_token = nil, ip = nil, remote_ip = nil, headers = nil, url = nil, method = nil, body = nil)
+    ContextBuilder.new(client_token, ip, remote_ip, headers, url, method, body)
+  end
+
+  def track(event_options)
+    @api_manager.track(event_options)
+  end
+
+  def verify(event_options)
+    @api_manager.verify(event_options)
+  end
+
+  def self._flush
+    @securenative = nil
+  end
+
+  def verify_request_payload(request)
+    request_signature = request.header[SignatureUtils.SIGNATURE_HEADER]
+    body = request.body
+
+    SignatureUtils.valid_signature?(@options.api_key, body, request_signature)
+  end
+end

data/out/production/securenative-ruby/utils/date_utils.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class DateUtils
+  def self.to_timestamp(date)
+    return Time.now.strftime('%Y-%m-%dT%H:%M:%S%Z') if date.nil?
+
+    Time.parse(date).iso8601
+  end
+end

data/out/production/securenative-ruby/utils/encryption_utils.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+class EncryptionUtils
+  BLOCK_SIZE = 16
+  KEY_SIZE = 32
+
+  def self.encrypt(text, cipher_key)
+    cipher = OpenSSL::Cipher::AES.new(KEY_SIZE, :CBC).encrypt
+    cipher.padding = 0
+
+    if text.size % BLOCK_SIZE != 0
+      return nil
+    end
+
+    cipher_key = Digest::SHA1.hexdigest cipher_key
+    cipher.key = cipher_key.slice(0, BLOCK_SIZE)
+    s = cipher.update(text) + cipher.final
+
+    s.unpack('H*')[0].upcase
+  end
+
+  def self.decrypt(encrypted, cipher_key)
+    cipher = OpenSSL::Cipher::AES.new(KEY_SIZE, :CBC).decrypt
+    cipher.padding = 0
+
+    cipher_key = Digest::SHA1.hexdigest cipher_key
+    cipher.key = cipher_key.slice(0, BLOCK_SIZE)
+    s = [encrypted].pack('H*').unpack('C*').pack('c*')
+
+    rv = cipher.update(s) + cipher.final
+    rv.strip
+  end
+end

data/out/production/securenative-ruby/utils/ip_utils.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "resolv"
+
+class IpUtils
+  def self.ip_address?(ip_address)
+    return true if ip_address =~ Resolv::IPv4::Regex
+    return true if ip_address =~ Resolv::IPv6::Regex
+
+    false
+  end
+
+  def self.valid_public_ip?(ip_address)
+    ip = IPAddr.new(ip_address)
+    return false if ip.loopback? || ip.private? || ip.link_local? || ip.untrusted? || ip.tainted?
+
+    true
+  end
+
+  def self.loop_back?(ip_address)
+    IPAddr.new(ip_address).loopback?
+  end
+end

data/out/production/securenative-ruby/utils/request_utils.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class RequestUtils
+  SECURENATIVE_COOKIE = '_sn'
+  SECURENATIVE_HEADER = 'x-securenative'
+
+  def self.get_secure_header_from_request(headers)
+    return headers[RequestUtils.SECURENATIVE_HEADER] unless headers.nil?
+
+    []
+  end
+
+  def self.get_client_ip_from_request(request)
+    x_forwarded_for = request.env['HTTP_X_FORWARDED_FOR']
+    return x_forwarded_for unless x_forwarded_for.nil?
+
+    request.env['REMOTE_ADDR']
+  end
+
+  def self.get_remote_ip_from_request(request)
+    request.remote_ip
+  end
+end

data/out/production/securenative-ruby/utils/secure_native_logger.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+class SecureNativeLogger
+  @logger = Logger.new(STDOUT)
+
+  def self.init_logger(level = 'DEBUG')
+    @logger.level = case level
+                    when 'WARN'
+                      SecureNativeLogger::WARN
+                    when 'DEBUG'
+                      SecureNativeLogger::DEBUG
+                    when 'ERROR'
+                      SecureNativeLogger::ERROR
+                    when 'FATAL'
+                      SecureNativeLogger::FATAL
+                    when 'INFO'
+                      SecureNativeLogger::INFO
+                    else
+                      SecureNativeLogger::FATAL
+                    end
+
+    @logger.formatter = proc do |severity, datetime, progname, msg|
+      "[#{datetime}] #{severity}  (#{progname}): #{msg}\n"
+    end
+  end
+
+  def self.info(msg)
+    @logger.info(msg)
+  end
+
+  def self.debug(msg)
+    @logger.debug(msg)
+  end
+
+  def self.warning(msg)
+    @logger.warning(msg)
+  end
+
+  def self.error(msg)
+    @logger.error(msg)
+  end
+end