meshchat 0.8.0 → 0.10.0

data/lib/meshchat/debug.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module Meshchat
+  # This file is stupid.
+  # But very helpful when debugging problems...
+  module Debug
+    module_function
+
+    # TODO: extract this idea to a gem
+    #       - automatic logging of method calls
+    def log(method_list)
+      method_list = Array[method_list]
+      method_list.each do |method|
+        backup_name = "#{method}_bak".to_sym
+        alias_method :backup_name, :method
+        define_method(method) do |*args|
+          Display.debug("##{method}: ")
+          Display.debug(args.inspect)
+        end
+      end
+    end
+
+    def message_type_not_found(type)
+      Display.debug('Type not found: ' + type.to_s)
+    end
+
+    def not_on_local_network(node)
+      Display.debug('SENDING: ' + node.alias_name + ' is not on the local network')
+    end
+
+    def received_message_from_relay(message, relay_url)
+      Display.debug('RECEIVING on RELAY: ' + relay_url)
+      Display.debug('RECEIVING on RELAY: ')
+      Display.debug(message)
+    end
+
+    def sending_message_over_relay(node, message, relay_url)
+      Display.debug('SENDING on RELAY: ' + relay_url)
+      Display.debug('SENDING on RELAY: ' + node.as_json.to_json)
+      Display.debug('SENDING on RELAY: ' + message.class.name)
+      Display.debug('SENDING on RELAY: ' + message.inspect)
+    end
+
+    def receiving_message(message)
+      Display.debug('RECEIVING: ' + message.type)
+      Display.debug('RECEIVING: ' + message.sender.to_s)
+      Display.debug('RECEIVING: ' + message.message.to_s)
+    end
+
+    def sending_message(message)
+      Display.debug('SENDING: ' + message.type)
+      Display.debug('SENDING: ' + message.sender.to_s)
+      Display.debug('SENDING: ' + message.message.to_s)
+    end
+
+    def person_not_online(node, message, e)
+      Display.debug("#{message.class.name}: Issue connectiong to #{node.alias_name}@#{node.location}")
+      Display.debug(e.message)
+    end
+
+    def encryption_failed(node)
+      Display.info "Public key encryption for #{node.try(:alias_name) || 'unknown'} failed"
+    end
+
+    def creating_input_failed(e)
+      Display.error e.message
+      Display.error e.backtrace.join("\n").colorize(:red)
+    end
+  end
+end

data/lib/meshchat/encryption.rb

@@ -1,8 +1,14 @@
+# frozen_string_literal: true
 require 'meshchat/encryption/aes_rsa'
 require 'meshchat/encryption/passthrough'
 
-module MeshChat
+module Meshchat
   module Encryption
+    extend ActiveSupport::Autoload
+
+    autoload :AES_RSA
+    autoload :Passthrough
+
     module_function
 
     DEFAULT_ENCRYPTOR = AES_RSA
@@ -22,6 +28,5 @@ module MeshChat
     def encrypt(*args)
       current_encryptor.encrypt(*args)
     end
-
   end
 end

data/lib/meshchat/encryption/aes_rsa.rb

@@ -1,4 +1,5 @@
-module MeshChat
+# frozen_string_literal: true
+module Meshchat
   module Encryption
     # Using AES266-CBC with RSA
     #

data/lib/meshchat/encryption/passthrough.rb

@@ -1,15 +1,17 @@
-module MeshChat
+# frozen_string_literal: true
+module Meshchat
   module Encryption
     # This should normally be for testing
     #
     # It just retuns the message that is asked to be encrypted
     module Passthrough
       module_function
-      def encrypt(msg, *args)
+
+      def encrypt(msg, *_args)
         msg
       end
 
-      def decrypt(msg, *args)
+      def decrypt(msg, *_args)
         msg
       end
     end

data/lib/meshchat/locale/en.yml

@@ -0,0 +1,14 @@
+confirm_options: ' (Y/N)'
+confirm_yes: yes
+confirm_y: y
+identity:
+  settings_not_detected: a settings file was not detected or incomplete, would you like to generate one?
+  unknown_error_try_again: something went wrong with identity creation. try again?
+  settings_are_invalid: settings are invalid
+  confirm_uid_replace: uid exists, are you sure you want a new identity?
+  confirm_alias_replace: alias exists, would you like to overwrite it?
+  confirm_key_replace: keys exist, overwrite?
+  ask_for_alias: 'Type the name/alias you would like to go by in meshchat:'
+  current_alias: 'Your current name/alias is: %{name}'
+node:
+  not_found: "Node not found, or does not have a location. Have you imported %{name}?"

data/lib/meshchat/models/node.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+module Meshchat
+  class Node < ActiveRecord::Base
+    IPV4_WITH_PORT = /((?:(?:^|\.)(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])){4})(:\d*)?/
+    # http://rubular.com/r/WYT09ptct3
+    DOMAIN_WITH_PORT = /(https?:\/\/)?([\da-z\.-]+)\.?([a-z\.]{2,6})([\/\w \.-]*)*[^\/](:\d*)?/
+
+    validates :alias_name,
+      :location,
+      :public_key, presence: true
+
+    validates :uid, presence: true, uniqueness: true
+
+    # ipv4 with port
+    validates_format_of :location_on_network, with: lambda { |e|
+      location_on_network = e.location_on_network || ''
+      is_domain = location_on_network.include?('//') ||
+        location_on_network.include?('localhost')
+
+      is_domain ? DOMAIN_WITH_PORT : IPV4_WITH_PORT
+    }
+
+    scope :on_local_network, -> { where(on_local_network: true) }
+    scope :on_relay, -> { where(on_relay: true) }
+    scope :online, -> { on_local_network.or(on_relay) }
+
+    class << self
+      def sha_preimage
+        all.map(&:public_key).sort.join(',')
+      end
+
+      def as_sha512
+        digest = Digest::SHA512.new
+        digest.hexdigest sha_preimage
+      end
+
+      def as_json
+        # must also include ourselves
+        # so that we can pass our own public key
+        # to those who don't have it
+        others = all.map(&:as_json)
+        me = APP_CONFIG.user.identity_as_json
+        others << me
+      end
+
+      def from_json(json)
+        new(
+          alias_name: json['alias'],
+          location_on_network: json['location'],
+          uid: json['uid'],
+          public_key: json['publickey']
+        )
+      end
+
+      def public_key_from_uid(uid)
+        find_by_uid(uid).try(:public_key)
+      end
+
+      # @param [Array] theirs array of hashes representing node entries
+      # @return [Array<-,+>] nodes only we have, and nodes only they have
+      def diff(theirs)
+        ours = as_json
+        we_only_have = ours - theirs
+        they_only_have = theirs - ours
+
+        [we_only_have, they_only_have]
+      end
+
+      def import_from_file(filename)
+        f = File.read(filename)
+        hash = JSON.parse(f)
+        n = from_json(hash)
+        n.save
+        n
+      rescue => e
+        Display.alert e.message
+      end
+
+      # Try to find the node, given a location, or uid
+      #
+      # TODO: do we want to also be able to find by relay address?
+      #       - this would be non-unique
+      #       - maybe finding should only happen via UID
+      # @param [String] location - the local network address
+      # @param [String] uid - the node's UID
+      # @param [Node] node - the node
+      # @return [Node]
+      def for(location: nil, uid: nil, node: nil)
+        unless node
+          node = Node.find_by_location_on_network(location) if location
+          node = Node.find_by_uid(uid) if uid && !node
+        end
+
+        unless node && node.valid?
+          msg =  I18n.t('node.not_found', name: location || uid || '')
+          return Display.alert msg
+        end
+
+        node
+      end
+    end
+
+    def ==(other)
+      result = false
+
+      if other.is_a?(Hash)
+        result = as_json.values_at(*other.keys) == other.values
+      end
+
+      result || super
+    end
+
+    def online
+      on_relay? || on_local_network?
+    end
+    alias_method :online?, :online
+
+    def location
+      return location_of_relay if on_relay?
+      location_on_network
+    end
+
+    def location_is_web_socket?
+      location.match(/wss?/).present?
+    end
+
+    def as_json
+      {
+        'alias' => alias_name,
+        'location' => location_on_network,
+        'uid' => uid,
+        'publickey' => public_key
+      }
+    end
+
+    def as_info
+      "#{alias_name}@#{location}"
+    end
+  end
+end

data/lib/meshchat/network.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    extend ActiveSupport::Autoload
+    NETWORK_LOCAL = :local
+    NETWORK_RELAY = :relay
+
+    eager_autoload do
+      autoload :Errors
+      autoload :Message
+      autoload :Dispatcher
+      autoload :Incoming
+      autoload :Local
+      autoload :Remote
+      autoload :MessageProcessor
+      autoload :RequestProcessor
+    end
+  end
+end

data/lib/meshchat/network/dispatcher.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    class Dispatcher
+      # creates messages
+      attr_reader :_message_factory
+
+      # standard peer-to-peer message sending
+      attr_reader :_local_client
+
+      # the action cable client ( web socket / connection beyond the firewall)
+      #  - responsible for the relay server if the http client can't find the recipient
+      attr_reader :_relay_client
+
+      def initialize
+        @_message_factory = Message::Factory.new(self)
+        @_local_client = Local::Connection.new(self, @_message_factory)
+        @_relay_client = Remote::Connection.new(self, @_message_factory)
+      end
+
+      # @note Either the location, node, or uid should be present
+      #
+      # @param [String] location (Optional) location of target
+      # @param [String] uid (Optional) uid of target
+      # @param [Node] node (Optional) target
+      # @param [Message] message (Required) what to send to the target
+      def send_message(location: nil, uid: nil, node: nil, message: nil)
+        # verify node is valid
+        node = Node.for(location: location, uid: uid, node: node)
+        # don't proceed if we don't have a node
+        return unless node
+        # don't send to ourselves
+        return if APP_CONFIG.user['uid'] == node.uid
+
+        # everything is valid so far... DISPATCH!
+        dispatch!(node, message)
+      end
+
+      private
+
+      def dispatch!(node, message)
+        Debug.sending_message(message)
+
+        message = encrypted_message(node, message)
+
+        # determine last known sending method
+        if node.on_local_network?
+          try_dispatching_over_local_network_first(node, message)
+        else
+          try_dispatching_over_the_relay_first(node, message)
+        end
+      end
+
+      # this attempts to send over http to the local network,
+      # if that fails, the passed block will be invoked
+      def try_dispatching_over_local_network_first(node, message)
+        _local_client.send_message(node, message) do
+          Debug.not_on_local_network(node)
+          node.update(on_local_network: false)
+          _relay_client.send_message(node, message)
+        end
+      end
+
+      # this attempts to send over the relay first
+      # if that fails, the passed block will be invked
+      def try_dispatching_over_the_relay_first(node, message)
+        # Due to the constant-connection nature of web-sockets,
+        # The sending via http client will happen if the node's-
+        # on_local_network property is true.
+        # node.update(on_local_network: true)
+        _relay_client.send_message(node, message)
+      end
+
+      def encrypted_message(node, message)
+        message.encrypt_for(node)
+      rescue => e
+        Display.debug e.message
+        Display.debug e.backtrace
+        Debug.encryption_failed(node)
+      end
+    end
+  end
+end

data/lib/meshchat/network/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Errors
+      class NotAuthorized < StandardError; end
+      class Forbidden < StandardError; end
+      class BadRequest < StandardError; end
+      class MessageTypeNotRecognized < StandardError; end
+    end
+  end
+end

data/lib/meshchat/network/incoming.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Incoming
+      extend ActiveSupport::Autoload
+      eager_autoload do
+        autoload :MessageProcessor
+        autoload :RequestProcessor
+        autoload :MessageDecryptor
+      end
+    end
+  end
+end

data/lib/meshchat/network/incoming/message_decryptor.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Incoming
+      class MessageDecryptor
+        attr_reader :_json, :_message, :_input
+        attr_reader :_message_factory
+
+        def initialize(encoded_message, message_factory)
+          @_message_factory = message_factory
+          @_input = try_decrypt(encoded_message)
+          @_json = parse_json(@_input)
+          @_message = process_json
+        end
+
+        def message
+          _message
+        end
+
+        private
+
+        def parse_json(input)
+          return JSON.parse(input)
+        rescue => e
+          Display.debug e.message
+          Display.debug e.backtrace.join("\n")
+          raise Errors::BadRequest, 'could not parse json'
+        end
+
+        def try_decrypt(input)
+          begin
+            decoded = Base64.decode64(input)
+            input = Encryption.decrypt(decoded, APP_CONFIG.user[:privatekey])
+          rescue => e
+            Display.debug e.message
+            Display.debug e.backtrace.join("\n")
+            Display.debug input
+            raise Errors::NotAuthorized, e.message
+          end
+
+          input
+        end
+
+        def process_json
+          type = _json['type']
+          _message_factory.create(type, data: { payload: _json })
+        end
+      end
+    end
+  end
+end