mixin_bot 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1bfa2114ffe972196a7d934cc499f08cc43b108a274ebca7740cf7ce150b58c
-  data.tar.gz: 7fd0378e46a47bdb0ce558496dff98327f66f0b9cfef16e5cb042cfd3c511f32
+  metadata.gz: c7444d18a70abce961709af67cf6ad5a60b75c4ca42eefa00893bff00941c3b3
+  data.tar.gz: 8bc1bbc95ee57b65ed32e1ce88f6118eecc2651cbd6c6bea7a34f5365c0304bd
 SHA512:
-  metadata.gz: 46d7366d604e930323471ab60cbec49fe8e881dc5a3d58b5a9302712ea17c611d8cd0c7a99b6afde424ab028d28a810a52cb7a790bf945aa8327765e4fb653e5
-  data.tar.gz: fef02f6c7722bb033317be3ddc9878b4a0739f88b676192fbc85b956a0cb51aaf477a25737e925b1388da3402a48989d691a75fe4dc16877f8b9c6416c8be4c3
+  metadata.gz: 2b036b4f994283e0332f02c74155c51f7acf97c4fe69ba7df895d213945785dbb29af6f9784d383ce2c5c302b0592955ec233f8712ab0c6555188522bf416222
+  data.tar.gz: 1e5800db35abccd37683b427d6a607a71f73e294c6903da4ee929037c50673705acd6bdca86a451d6609d30c5aed9956b41a9fee72947d887497a2c9d3706295

data/lib/mixin_bot/api/encrypted_message.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: false
+
+module MixinBot
+  class API
+    module EncryptedMessage
+      def encrypted_text(options)
+        options.merge!(category: 'ENCRYPTED_TEXT')
+        base_encrypted_message_params(options)
+      end
+
+      def encrypted_post(options)
+        options.merge!(category: 'ENCRYPTED_POST')
+        base_encrypted_message_params(options)
+      end
+
+      def encrypted_image(options)
+        options.merge!(category: 'ENCRYPTED_IMAGE')
+        base_encrypted_message_params(options)
+      end
+
+      def encrypted_data(options)
+        options.merge!(category: 'ENCRYPTED_DATA')
+        base_encrypted_message_params(options)
+      end
+
+      def encrypted_sticker(options)
+        options.merge!(category: 'ENCRYPTED_STICKER')
+        base_encrypted_message_params(options)
+      end
+
+      def encrypted_contact(options)
+        options.merge!(category: 'ENCRYPTED_CONTACT')
+        base_encrypted_message_params(options)
+      end
+
+      def encrypted_audio(options)
+        options.merge!(category: 'ENCRYPTED_AUDIO')
+        base_encrypted_message_params(options)
+      end
+
+      def encrypted_video(options)
+        options.merge!(category: 'ENCRYPTED_VIDEO')
+        base_encrypted_message_params(options)
+      end
+
+      # use HTTP to send message
+      def send_encrypted_text_message(options)
+        send_encrypted_message encrypted_text(options)
+      end
+
+      def send_encrypted_post_message(options)
+        send_encrypted_message encrypted_post(options)
+      end
+
+      def send_encrypted_image_message(options)
+        send_encrypted_message encrypted_image(options)
+      end
+
+      def send_encrypted_data_message(options)
+        send_encrypted_message encrypted_data(options)
+      end
+
+      def send_encrypted_sticker_message(options)
+        send_encrypted_message encrypted_sticker(options)
+      end
+
+      def send_encrypted_contact_message(options)
+        send_encrypted_message encrypted_contact(options)
+      end
+
+      def send_encrypted_audio_message(options)
+        send_encrypted_message encrypted_audio(options)
+      end
+
+      def send_encrypted_video_message(options)
+        send_encrypted_message encrypted_video(options)
+      end
+
+      # base format of message params
+      def base_encrypted_message_params(options)
+        data = options[:data].is_a?(String) ? options[:data] : options[:data].to_json
+        data_base64 = encrypt_message Base64.urlsafe_encode64(data, padding: false), options[:sessions]
+        session_ids = options[:sessions].map(&->(s) { s['session_id'] }).sort
+        checksum = Digest::MD5.hexdigest session_ids.join
+
+        {
+          conversation_id: options[:conversation_id],
+          recipient_id: options[:recipient_id],
+          representative_id: options[:representative_id],
+          category: options[:category],
+          quote_message_id: options[:quote_message_id],
+          message_id: options[:message_id] || SecureRandom.uuid,
+          data_base64: data_base64,
+          checksum: checksum,
+          recipient_sessions: session_ids.map(&->(s) { { session_id: s } }),
+          silent: false
+        }
+      end
+
+      def send_encrypted_messages(messages)
+        send_encrypted_message messages
+      end
+
+      # http post request
+      def send_encrypted_message(payload)
+        path = '/encrypted_messages'
+        payload = [payload] unless payload.is_a?(Array)
+        access_token ||= access_token('POST', path, payload.to_json)
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+      end
+
+      def encrypt_message(data, sessions = [], sk: nil, pk: nil)
+        raise ArgumentError, 'Wrong sessions format!' unless sessions.all?(&->(s) { s.key?('session_id') && s.key?('public_key') })
+
+        sk = private_key[0...32]
+        pk ||= private_key[32...]
+
+        checksum = Digest::MD5.hexdigest sessions.map(&->(s) { s['session_id'] }).sort.join
+        encrypter = OpenSSL::Cipher.new('AES-128-GCM').encrypt
+        key = encrypter.random_key
+        nounce = encrypter.random_iv
+        encrypter.key = key
+        encrypter.iv = nounce
+        encrypter.auth_data = ''
+        ciphertext = encrypter.update(Base64.urlsafe_decode64(data)) + encrypter.final + encrypter.auth_tag
+
+        bytes = [1]
+        bytes += [sessions.size].pack('v*').bytes
+        bytes += JOSE::JWA::Ed25519.pk_to_curve25519(pk).bytes
+        
+        sessions.each do |session|
+          aes_key = JOSE::JWA::X25519.shared_secret(
+            Base64.urlsafe_decode64(session['public_key']),
+            JOSE::JWA::Ed25519.secret_to_curve25519(sk)
+          )
+
+          padding = 16 - key.size % 16
+          padtext = ([padding] * padding).pack('C*')
+
+          encrypter = OpenSSL::Cipher.new('AES-256-CBC').encrypt
+          encrypter.key = aes_key
+          iv = encrypter.random_iv
+          encrypter.iv = iv
+
+          bytes += (MixinBot::Utils::UUID.new(hex: session['session_id']).packed + iv).bytes
+          bytes += encrypter.update(key + padtext).bytes
+        end
+
+        bytes += nounce.bytes
+        bytes += ciphertext.bytes
+
+        Base64.urlsafe_encode64 bytes.pack('C*'), padding: false
+      end
+
+      def decrypt_message(data, sk: nil, si: nil)
+        bytes = Base64.urlsafe_decode64(data).bytes
+
+        si ||= session_id
+        sk ||= private_key[0...32]
+
+        size = 16 + 48
+        return '' if bytes.size < 1 + 2 + 32 + size + 12
+
+        session_length = bytes[1...3].pack('v*').unpack1('C*')
+        prefix_size = 35 + session_length * size
+
+        i = 35
+        key = ''
+        while i < prefix_size
+          uuid = MixinBot::Utils::UUID.new(raw: bytes[i...(i + 16)].pack('C*')).unpacked
+          if uuid == si
+            pub = bytes[3...35]
+            aes_key = JOSE::JWA::X25519.shared_secret(
+              pub.pack('C*'),
+              JOSE::JWA::Ed25519.secret_to_curve25519(sk)
+            )
+            iv = bytes[(i + 16)...(i + 16 + 16)].pack('C*')
+            encrypted_key = bytes[(i + 16 + 16)...(i + size)].pack('C*')
+
+            decrypter = OpenSSL::Cipher.new('AES-256-CBC').decrypt
+            decrypter.iv = iv
+            decrypter.key = aes_key
+            cipher = decrypter.update(encrypted_key)
+            key = cipher[...16]
+            break
+          end
+          i += size
+        end
+
+        return '' unless key.size == 16
+
+        decrypter = OpenSSL::Cipher.new('AES-128-GCM').decrypt
+        decrypter.key = key
+        decrypter.iv = bytes[prefix_size...(prefix_size + 12)].pack('C*')
+        decrypter.auth_tag = bytes.last(16).pack('C*')
+        decrypted = decrypter.update(bytes[(prefix_size + 12)...(bytes.size - 16)].pack('C*'))
+        decrypter.final
+
+        Base64.urlsafe_encode64 decrypted
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/message.rb

@@ -8,15 +8,6 @@ module MixinBot
         write_ws_message(action: 'LIST_PENDING_MESSAGES', params: {})
       end
 
-      # ACKNOWLEDGE_MESSAGE_RECEIPT ack server received message
-      # {
-      #   "id": "UUID",
-      #   "action": "ACKNOWLEDGE_MESSAGE_RECEIPT",
-      #   "params": {
-      #     "message_id": "UUID // message_id is you received message's message_id",
-      #     "status": "READ"
-      #   }
-      # }
       def acknowledge_message_receipt(message_id)
         params = {
           message_id: message_id,
@@ -25,200 +16,56 @@ module MixinBot
         write_ws_message(action: 'ACKNOWLEDGE_MESSAGE_RECEIPT', params: params)
       end
 
-      # {
-      #   "id": "UUID // generated by client",
-      #   "action":  "CREATE_MESSAGE",
-      #   "params": {
-      #     "conversation_id": "UUID",
-      #     "category": "PLAIN_TEXT",
-      #     "status": "SENT",
-      #     "message_id": "UUID // generated by client",
-      #     "data": "Base64 encoded data" ,
-      #   }
-      # }
       def plain_text(options)
         options.merge!(category: 'PLAIN_TEXT')
         base_message_params(options)
       end
 
-      # {
-      #   "id": "UUID // generated by client",
-      #   "action":  "CREATE_MESSAGE",
-      #   "params": {
-      #     "conversation_id": "UUID",
-      #     "category": "PLAIN_POST",
-      #     "status": "SENT",
-      #     "message_id": "UUID // generated by client",
-      #     "data": "Base64 encoded data content is markdown" ,
-      #   }
-      # }
       def plain_post(options)
         options.merge!(category: 'PLAIN_POST')
         base_message_params(options)
       end
 
-      # {
-      #   "id": "UUID",
-      #   "action": "CREATE_MESSAGE",
-      #   "params": {
-      #     "conversation_id": "UUID"
-      #     "category": "PLAIN_IMAGE"
-      #     "status": "SENT",
-      #     "message_id": "UUID",
-      #     "data": "Base64 encoded data"
-      #   }
-      # }
-      # data format:
-      # {
-      #   "attachment_id":
-      #   "Read From POST /attachments",
-      #   "mime_type": "",
-      #   "width": 1024,
-      #   "height": 1024,
-      #   "size": 1024,
-      #   "thumbnail": "base64 encoded"
-      # }
       def plain_image(options)
         options.merge!(category: 'PLAIN_IMAGE')
         base_message_params(options)
       end
 
-      # {
-      #   "id":  "UUID",
-      #   "action":  "CREATE_MESSAGE",
-      #   "params": {
-      #     "conversation_id": "UUID",
-      #     "category": "PLAIN_DATA",
-      #     "status": "SENT",
-      #     "message_id": "UUID",
-      #     "data": "Base64 encoded data",
-      #   }
-      # }
-      # data format:
-      # {
-      #   "attachment_id": "Read From POST /attachments",
-      #   "mime_type": "",
-      #   "size": 1024,
-      #   "name": "Share"
-      # }
       def plain_data(options)
         options.merge!(category: 'PLAIN_DATA')
         base_message_params(options)
       end
 
-      # {
-      #   "id":  "UUID",
-      #   "action":  "CREATE_MESSAGE",
-      #   "params": {
-      #     "conversation_id": "UUID",
-      #     "category": "PLAIN_STICKER",
-      #     "status": "SENT",
-      #     "message_id":  "UUID",
-      #     "data": "Base64 encoded data"
-      #   }
-      # }
-      # data format:
-      # {
-      #   "name": "hello",
-      #   "album_id": "UUID"
-      # }
       def plain_sticker(options)
         options.merge!(category: 'PLAIN_STICKER')
         base_message_params(options)
       end
 
-      # {
-      #   "id": "UUID",
-      #   "action": "CREATE_MESSAGE",
-      #   "params": {
-      #     "conversation_id": "UUID",
-      #     "category": "PLAIN_CONTACT"
-      #     "status": "SENT",
-      #     "message_id": "UUID",
-      #     "data":  "Base64 encoded data"
-      #   }
-      # }
-      # data format:
-      # { "user_id": "UUID"}
       def plain_contact(options)
         options.merge!(category: 'PLAIN_CONTACT')
         base_message_params(options)
       end
 
-      # {
-      #   "id": "UUID",
-      #   "action": "CREATE_MESSAGE",
-      #   "params": {
-      #     "conversation_id": "UUID",
-      #     "category": "APP_CARD",
-      #     "status": "SENT",
-      #     "message_id": "UUID",
-      #     "data": "Base64 encoded data"
-      #   }
-      # }
-      # data format:
-      # {
-      #   "icon_url": "https://mixin.one/assets/98b586edb270556d1972112bd7985e9e.png",
-      #   "title": "Mixin",
-      #   "description": "A free and lightning fast peer-to-peer transactional network for digital assets.",
-      #   "action": "https://mixin.one"
-      # }
+      def plain_audio(options)
+        options.merge!(category: 'PLAIN_AUDIO')
+        base_message_params(options)
+      end
+
+      def plain_video(options)
+        options.merge!(category: 'PLAIN_VIDEO')
+        base_message_params(options)
+      end
+
       def app_card(options)
         options.merge!(category: 'APP_CARD')
         base_message_params(options)
       end
 
-      # {
-      #   "id": "UUID",
-      #   "action": "CREATE_MESSAGE",
-      #   "params": {
-      #     "conversation_id": "UUID",
-      #     "category": "APP_BUTTON_GROUP",
-      #     "status": "SENT",
-      #     "message_id": "UUID",
-      #     "data": "Base64 encoded data"
-      #   }
-      # }
-      # data format:
-      # [
-      #   {
-      #     "label": "Mixin Website",
-      #     "color": "#ABABAB",
-      #     "action": "https://mixin.one"
-      #   },
-      #   ...
-      # ]
       def app_button_group(options)
         options.merge!(category: 'APP_BUTTON_GROUP')
         base_message_params(options)
       end
 
-      # {
-      #   "id": "UUID",
-      #   "action": "CREATE_MESSAGE",
-      #   "params": {
-      #     "conversation_id": "UUID",
-      #     "category": "PLAIN_VIDEO",
-      #     "status": "SENT",
-      #     "message_id": "UUID",
-      #     "data": "Base64 encoded data"
-      #   }
-      # }
-      # data format:
-      # {
-      #   "attachment_id": "Read From POST /attachments",
-      #   "mime_type": "",
-      #   "width": 1024,
-      #   "height": 1024,
-      #   "size": 1024,
-      #   "duration": 1024,
-      #   "thumbnail": "base64 encoded"
-      # }
-      def plain_video(options)
-        options.merge!(category: 'PLAIN_VIDEO')
-        base_message_params(options)
-      end
-
       def recall_message_params(message_id, options)
         raise 'recipient_id is required!' if options[:recipient_id].nil?
 
@@ -304,24 +151,6 @@ module MixinBot
         send_message [recall_message_params(message_id, options)]
       end
 
-      # {
-      #   "id": "UUID",
-      #   "action": "CREATE_PLAIN_MESSAGES",
-      #   "params": {
-      #     "messages": [
-      #       {
-      #         "conversation_id": "UUID",
-      #         "recipient_id": "UUID",
-      #         "message_id": "UUID",
-      #         "representative_id": "UUID (optional, only supported in peer to peer conversation)",
-      #         "quote_message_id": "UUID (optional, only supported text, e.g. PLAIN_TEXT)",
-      #         "category": "Only support plain category e.g.: PLAIN_TEXT, PLAIN_STICKER etc",
-      #         "data": "Correspond to category."
-      #       },
-      #       ...
-      #     ]
-      #   }
-      # }
       def send_plain_messages(messages)
         send_message messages
       end

data/lib/mixin_bot/api/snapshot.rb

@@ -25,7 +25,7 @@ module MixinBot
           offset: options[:offset],
           asset: options[:asset],
           opponent: options[:opponent],
-          order: options[:order],
+          order: options[:order]
         )
 
         access_token = options[:access_token] || access_token('GET', path)

data/lib/mixin_bot/api.rb

@@ -8,6 +8,7 @@ require_relative './api/auth'
 require_relative './api/blaze'
 require_relative './api/collectible'
 require_relative './api/conversation'
+require_relative './api/encrypted_message'
 require_relative './api/me'
 require_relative './api/message'
 require_relative './api/multisig'
@@ -83,6 +84,7 @@ module MixinBot
     include MixinBot::API::Blaze
     include MixinBot::API::Collectible
     include MixinBot::API::Conversation
+    include MixinBot::API::EncryptedMessage
     include MixinBot::API::Me
     include MixinBot::API::Message
     include MixinBot::API::Multisig

data/lib/mixin_bot/cli/utils.rb

@@ -6,12 +6,12 @@ module MixinBot
     option :keystore, type: :string, aliases: '-k', required: true, desc: 'keystore or keystore.json file path'
     option :iterator, type: :string, aliases: '-i', desc: 'Iterator'
     def encrypt(pin)
-      log api_instance.encrypt_pin options[:pin].to_s, iterator: options[:iterator]
+      log api_instance.encrypt_pin pin.to_s, iterator: options[:iterator]
     end
 
     desc 'unique UUIDS', 'generate unique UUID for two or more UUIDs'
     def unique(*uuids)
-      log MixinBot::Utils.unique_uuid *uuids
+      log MixinBot::Utils.unique_uuid(*uuids)
     end
 
     desc 'generatetrace HASH', 'generate trace ID from Tx hash'

data/lib/mixin_bot/utils/nfo.rb

@@ -31,7 +31,7 @@ module MixinBot
 
         @collection = NULL_UUID if collection.blank?
         @chain = NFT_MEMO_DEFAULT_CHAIN
-        @nm_class= NFT_MEMO_DEFAULT_CLASS
+        @nm_class = NFT_MEMO_DEFAULT_CLASS
         mark 0
         encode
 
@@ -59,9 +59,8 @@ module MixinBot
 
       def mark(*indexes)
         indexes.map do |index|
-          if index >= 64 || index < 0
-            raise ArgumentError, "invalid NFO memo index #{index}"
-          end
+          raise ArgumentError, "invalid NFO memo index #{index}" if index >= 64 || index.negative?
+
           @mask = mask ^ (1 << index)
         end
       end
@@ -69,7 +68,7 @@ module MixinBot
       def encode
         bytes = []
 
-        bytes += prefix.bytes 
+        bytes += prefix.bytes
         bytes += [version]
 
         if mask != 0

data/lib/mixin_bot/utils.rb

@@ -7,13 +7,13 @@ require_relative './utils/transaction'
 module MixinBot
   module Utils
     class << self
-      MAGIC = [0x77, 0x77]
+      MAGIC = [0x77, 0x77].freeze
       TX_VERSION = 2
       MAX_ENCODE_INT = 0xFFFF
-      NULL_BYTES = [0x00, 0x00]
+      NULL_BYTES = [0x00, 0x00].freeze
       AGGREGATED_SIGNATURE_PREFIX = 0xFF01
-      AGGREGATED_SIGNATURE_ORDINAY_MASK = [0x00]
-      AGGREGATED_SIGNATURE_SPARSE_MASK = [0x01]
+      AGGREGATED_SIGNATURE_ORDINAY_MASK = [0x00].freeze
+      AGGREGATED_SIGNATURE_SPARSE_MASK = [0x01].freeze
 
       def generate_unique_uuid(uuid_1, uuid_2)
         md5 = Digest::MD5.new
@@ -53,9 +53,7 @@ module MixinBot
       end
 
       def sign_raw_transaction(tx)
-        if tx.is_a? String
-          tx = JSON.parse tx
-        end
+        tx = JSON.parse tx if tx.is_a? String
         raise ArgumentError, "#{tx} is not a valid json" unless tx.is_a? Hash
 
         tx = tx.with_indifferent_access
@@ -64,7 +62,7 @@ module MixinBot
           asset: tx[:asset],
           inputs: tx[:inputs],
           outputs: tx[:outputs],
-          extra: tx[:extra],
+          extra: tx[:extra]
         ).encode.hex
       end
 
@@ -74,15 +72,15 @@ module MixinBot
 
       def nft_memo(collection, token, extra)
         MixinBot::Utils::Nfo.new(
-          collection: collection, 
-          token: token, 
+          collection: collection,
+          token: token,
           extra: extra
         ).mint_memo
       end
 
       def encode_int(int)
         raise ArgumentError, "only support int #{int}" unless int.is_a?(Integer)
-        raise ArgumentError,"int #{int} is larger than MAX_ENCODE_INT #{MAX_ENCODE_INT}" if int > MAX_ENCODE_INT
+        raise ArgumentError, "int #{int} is larger than MAX_ENCODE_INT #{MAX_ENCODE_INT}" if int > MAX_ENCODE_INT
 
         [int].pack('S*').bytes.reverse
       end
@@ -97,8 +95,9 @@ module MixinBot
         bytes = []
         loop do
           break if int === 0
+
           bytes.push int & 255
-          int = int / (2 ** 8) | 0
+          int = int / (2**8) | 0
         end
 
         bytes.reverse
@@ -107,7 +106,7 @@ module MixinBot
       def bytes_to_int(bytes)
         int = 0
         bytes.each do |byte|
-          int = int * (2 ** 8) + byte
+          int = int * (2**8) + byte
         end
 
         int

data/lib/mixin_bot/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MixinBot
-  VERSION = '0.9.0'
+  VERSION = '0.11.0'
 end