rubycord 1.0.0

data/lib/rubycord/voice/encoder.rb

@@ -0,0 +1,113 @@
+# This makes opus an optional dependency
+begin
+  require "opus-ruby"
+  OPUS_AVAILABLE = true
+rescue LoadError
+  OPUS_AVAILABLE = false
+end
+
+# Discord voice chat support
+module Rubycord::Voice
+  # This class conveniently abstracts opus and ffmpeg/avconv, for easy implementation of voice sending. It's not very
+  # useful for most users, but I guess it can be useful sometimes.
+  class Encoder
+    # Whether or not avconv should be used instead of ffmpeg. If possible, it is recommended to use ffmpeg instead,
+    # as it is better supported.
+    # @return [true, false] whether avconv should be used instead of ffmpeg.
+    attr_accessor :use_avconv
+
+    # @see VoiceBot#filter_volume=
+    # @return [Integer] the volume used as a filter to ffmpeg/avconv.
+    attr_accessor :filter_volume
+
+    # Create a new encoder
+    def initialize
+      sample_rate = 48_000
+      frame_size = 960
+      channels = 2
+      @filter_volume = 1
+
+      raise LoadError, "Opus unavailable - voice not supported! Please install opus for voice support to work." unless OPUS_AVAILABLE
+
+      @opus = Opus::Encoder.new(sample_rate, frame_size, channels)
+    end
+
+    # Set the opus encoding bitrate
+    # @param value [Integer] The new bitrate to use, in bits per second (so 64000 if you want 64 kbps)
+    def bitrate=(value)
+      @opus.bitrate = value
+    end
+
+    # Encodes the given buffer using opus.
+    # @param buffer [String] An unencoded PCM (s16le) buffer.
+    # @return [String] A buffer encoded using opus.
+    def encode(buffer)
+      @opus.encode(buffer, 1920)
+    end
+
+    # One frame of complete silence Opus encoded
+    OPUS_SILENCE = [0xF8, 0xFF, 0xFE].pack("C*").freeze
+
+    # Adjusts the volume of a given buffer of s16le PCM data.
+    # @param buf [String] An unencoded PCM (s16le) buffer.
+    # @param mult [Float] The volume multiplier, 1 for same volume.
+    # @return [String] The buffer with adjusted volume, s16le again
+    def adjust_volume(buf, mult)
+      # We don't need to adjust anything if the buf is nil so just return in that case
+      return unless buf
+
+      # buf is s16le so use 's<' for signed, 16 bit, LE
+      result = buf.unpack("s<*").map do |sample|
+        sample *= mult
+
+        # clamp to s16 range
+        sample.clamp(-32_768, 32_767)
+      end
+
+      # After modification, make it s16le again
+      result.pack("s<*")
+    end
+
+    # Encodes a given file (or rather, decodes it) using ffmpeg. This accepts pretty much any format, even videos with
+    # an audio track. For a list of supported formats, see https://ffmpeg.org/general.html#Audio-Codecs. It even accepts
+    # URLs, though encoding them is pretty slow - I recommend to make a stream of it and then use {#encode_io} instead.
+    # @param file [String] The path or URL to encode.
+    # @param options [String] ffmpeg options to pass after the -i flag
+    # @return [IO] the audio, encoded as s16le PCM
+    def encode_file(file, options = "")
+      command = ffmpeg_command(input: file, options: options)
+      IO.popen(command)
+    end
+
+    # Encodes an arbitrary IO audio stream using ffmpeg. Accepts pretty much any media format, even videos with audio
+    # tracks. For a list of supported audio formats, see https://ffmpeg.org/general.html#Audio-Codecs.
+    # @param io [IO] The stream to encode.
+    # @param options [String] ffmpeg options to pass after the -i flag
+    # @return [IO] the audio, encoded as s16le PCM
+    def encode_io(io, options = "")
+      command = ffmpeg_command(options: options)
+      IO.popen(command, in: io)
+    end
+
+    private
+
+    def ffmpeg_command(input: "-", options: null)
+      [
+        @use_avconv ? "avconv" : "ffmpeg",
+        "-loglevel", "0",
+        "-i", input,
+        "-f", "s16le",
+        "-ar", "48000",
+        "-ac", "2",
+        "pipe:1",
+        filter_volume_argument
+      ].concat(options.split).reject { |segment| segment.nil? || segment == "" }
+    end
+
+    def filter_volume_argument
+      return "" if @filter_volume == 1
+
+      @use_avconv ? "-vol #{(@filter_volume * 256).ceil}" : "-af volume=#{@filter_volume}"
+    end
+  end
+end

data/lib/rubycord/voice/network.rb

@@ -0,0 +1,366 @@
+require "websocket-client-simple"
+require "socket"
+require "json"
+
+require "rubycord/websocket"
+
+begin
+  LIBSODIUM_AVAILABLE = if ENV["RUBYCORD_NONACL"]
+    false
+  else
+    require "rubycord/voice/sodium"
+  end
+rescue LoadError
+  puts "libsodium not available! You can continue to use rubycord as normal but voice support won't work.
+        Read https://github.com/dakurei-gems/rubycord/wiki/Installing-libsodium for more details."
+  LIBSODIUM_AVAILABLE = false
+end
+
+module Rubycord::Voice
+  # Signifies to Discord that encryption should be used
+  # @deprecated Discord now supports multiple encryption options.
+  # TODO: Resolve replacement for this constant.
+  ENCRYPTED_MODE = "xsalsa20_poly1305"
+
+  # Signifies to Discord that no encryption should be used
+  # @deprecated Discord no longer supports unencrypted voice communication.
+  PLAIN_MODE = "plain"
+
+  # Encryption modes supported by Discord
+  ENCRYPTION_MODES = %w[xsalsa20_poly1305_lite xsalsa20_poly1305_suffix xsalsa20_poly1305].freeze
+
+  # Represents a UDP connection to a voice server. This connection is used to send the actual audio data.
+  class VoiceUDP
+    # @return [true, false] whether or not UDP communications are encrypted.
+    # @deprecated Discord no longer supports unencrypted voice communication.
+    attr_accessor :encrypted
+    alias_method :encrypted?, :encrypted
+
+    # Sets the secret key used for encryption
+    attr_writer :secret_key
+
+    # The UDP encryption mode
+    attr_reader :mode
+
+    # @!visibility private
+    attr_writer :mode
+
+    # Creates a new UDP connection. Only creates a socket as the discovery reply may come before the data is
+    # initialized.
+    def initialize
+      @socket = UDPSocket.new
+      @encrypted = true
+    end
+
+    # Initializes the UDP socket with data obtained from opcode 2.
+    # @param ip [String] The IP address to connect to.
+    # @param port [Integer] The port to connect to.
+    # @param ssrc [Integer] The Super Secret Relay Code (SSRC). Discord uses this to identify different voice users
+    #   on the same endpoint.
+    def connect(ip, port, ssrc)
+      @ip = ip
+      @port = port
+      @ssrc = ssrc
+    end
+
+    # Waits for a UDP discovery reply, and returns the sent data.
+    # @return [Array(String, Integer)] the IP and port received from the discovery reply.
+    def receive_discovery_reply
+      # Wait for a UDP message
+      message = @socket.recv(74)
+      ip = message[8..-3].delete("\0")
+      port = message[-2..].unpack1("n")
+      [ip, port]
+    end
+
+    # Makes an audio packet from a buffer and sends it to Discord.
+    # @param buf [String] The audio data to send, must be exactly one Opus frame
+    # @param sequence [Integer] The packet sequence number, incremented by one for subsequent packets
+    # @param time [Integer] When this packet should be played back, in no particular unit (essentially just the
+    #   sequence number multiplied by 960)
+    def send_audio(buf, sequence, time)
+      # Header of the audio packet
+      header = [0x80, 0x78, sequence, time, @ssrc].pack("CCnNN")
+
+      nonce = generate_nonce(header)
+      buf = encrypt_audio(buf, nonce)
+
+      data = header + buf
+
+      # xsalsa20_poly1305 does not require an appended nonce
+      data += nonce unless @mode == "xsalsa20_poly1305"
+
+      send_packet(data)
+    end
+
+    # Sends the UDP discovery packet with the internally stored SSRC. Discord will send a reply afterwards which can
+    # be received using {#receive_discovery_reply}
+    def send_discovery
+      # Create empty packet
+      discovery_packet = ""
+
+      # Add Type request (0x1 = request, 0x2 = response)
+      discovery_packet += [0x1].pack("n")
+
+      # Add Length (excluding Type and itself = 70)
+      discovery_packet += [70].pack("n")
+
+      # Add SSRC
+      discovery_packet += [@ssrc].pack("N")
+
+      # Add 66 zeroes so the packet is 74 bytes long
+      discovery_packet += "\0" * 66
+
+      send_packet(discovery_packet)
+    end
+
+    private
+
+    # Encrypts audio data using libsodium
+    # @param buf [String] The encoded audio data to be encrypted
+    # @param nonce [String] The nonce to be used to encrypt the data
+    # @return [String] the audio data, encrypted
+    def encrypt_audio(buf, nonce)
+      raise "No secret key found, despite encryption being enabled!" unless @secret_key
+
+      secret_box = Rubycord::Voice::SecretBox.new(@secret_key)
+
+      # Nonces must be 24 bytes in length. We right pad with null bytes for poly1305 and poly1305_lite
+      secret_box.box(nonce.ljust(24, "\0"), buf)
+    end
+
+    def send_packet(packet)
+      @socket.send(packet, 0, @ip, @port)
+    end
+
+    # @param header [String] The header of the packet, to be used as the nonce
+    # @return [String]
+    # @note
+    #   The nonce generated depends on the encryption mode.
+    #   In xsalsa20_poly1305 the nonce is the header plus twelve null bytes for padding.
+    #   In xsalsa20_poly1305_suffix, the nonce is 24 random bytes
+    #   In xsalsa20_poly1305_lite, the nonce is an incremental 4 byte int.
+    def generate_nonce(header)
+      case @mode
+      when "xsalsa20_poly1305"
+        header
+      when "xsalsa20_poly1305_suffix"
+        Random.urandom(24)
+      when "xsalsa20_poly1305_lite"
+        case @lite_nonce
+        when nil, 0xff_ff_ff_ff
+          @lite_nonce = 0
+        else
+          @lite_nonce += 1
+        end
+        [@lite_nonce].pack("N")
+      else
+        raise "`#{@mode}' is not a supported encryption mode"
+      end
+    end
+  end
+
+  # Represents a websocket client connection to the voice server. The websocket connection (sometimes called vWS) is
+  # used to manage general data about the connection, such as sending the speaking packet, which determines the green
+  # circle around users on Discord, and obtaining UDP connection info.
+  class VoiceWS
+    # The version of the voice gateway that's supposed to be used.
+    VOICE_GATEWAY_VERSION = 4
+
+    # @return [VoiceUDP] the UDP voice connection over which the actual audio data is sent.
+    attr_reader :udp
+
+    # Makes a new voice websocket client, but doesn't connect it (see {#connect} for that)
+    # @param channel [Channel] The voice channel to connect to
+    # @param bot [Bot] The regular bot to which this vWS is bound
+    # @param token [String] The authentication token which is also used for REST requests
+    # @param session [String] The voice session ID Discord sends over the regular websocket
+    # @param endpoint [String] The endpoint URL to connect to
+    def initialize(channel, bot, token, session, endpoint)
+      raise "libsodium is unavailable - unable to create voice bot! Please read https://github.com/dakurei-gems/rubycord/wiki/Installing-libsodium" unless LIBSODIUM_AVAILABLE
+
+      @channel = channel
+      @bot = bot
+      @token = token
+      @session = session
+
+      @endpoint = endpoint.split(":").first
+
+      @udp = VoiceUDP.new
+    end
+
+    # Send a connection init packet (op 0)
+    # @param server_id [Integer] The ID of the server to connect to
+    # @param bot_user_id [Integer] The ID of the bot that is connecting
+    # @param session_id [String] The voice session ID
+    # @param token [String] The Discord authentication token
+    def send_init(server_id, bot_user_id, session_id, token)
+      @client.send({
+        op: 0,
+        d: {
+          server_id: server_id,
+          user_id: bot_user_id,
+          session_id: session_id,
+          token: token
+        }
+      }.to_json)
+    end
+
+    # Sends the UDP connection packet (op 1)
+    # @param ip [String] The IP to bind UDP to
+    # @param port [Integer] The port to bind UDP to
+    # @param mode [Object] Which mode to use for the voice connection
+    def send_udp_connection(ip, port, mode)
+      @client.send({
+        op: 1,
+        d: {
+          protocol: "udp",
+          data: {
+            address: ip,
+            port: port,
+            mode: mode
+          }
+        }
+      }.to_json)
+    end
+
+    # Send a heartbeat (op 3), has to be done every @heartbeat_interval seconds or the connection will terminate
+    def send_heartbeat
+      millis = Time.now.strftime("%s%L").to_i
+      @bot.debug("Sending voice heartbeat at #{millis}")
+
+      @client.send({
+        op: 3,
+        d: millis
+      }.to_json)
+    end
+
+    # Send a speaking packet (op 5). This determines the green circle around the avatar in the voice channel
+    # @param value [true, false, Integer] Whether or not the bot should be speaking, can also be a bitmask denoting audio type.
+    def send_speaking(value)
+      @bot.debug("Speaking: #{value}")
+      @client.send({
+        op: 5,
+        d: {
+          speaking: value,
+          delay: 0
+        }
+      }.to_json)
+    end
+
+    # Event handlers; public for websocket-simple to work correctly
+    # @!visibility private
+    def websocket_open
+      # Give the current thread a name ('Voice Web Socket Internal')
+      Thread.current[:rubycord_name] = "vws-i"
+
+      # Send the init packet
+      send_init(@channel.server.id, @bot.profile.id, @session, @token)
+    end
+
+    # @!visibility private
+    def websocket_message(msg)
+      @bot.debug("Received VWS message! #{msg}")
+      packet = JSON.parse(msg)
+
+      case packet["op"]
+      when 2
+        # Opcode 2 contains data to initialize the UDP connection
+        @ws_data = packet["d"]
+
+        @ssrc = @ws_data["ssrc"]
+        @port = @ws_data["port"]
+
+        @udp_mode = (ENCRYPTION_MODES & @ws_data["modes"]).first
+
+        @udp.connect(@ws_data["ip"], @port, @ssrc)
+        @udp.send_discovery
+      when 4
+        # Opcode 4 sends the secret key used for encryption
+        @ws_data = packet["d"]
+
+        @ready = true
+        @udp.secret_key = @ws_data["secret_key"].pack("C*")
+        @udp.mode = @ws_data["mode"]
+      when 8
+        # Opcode 8 contains the heartbeat interval.
+        @heartbeat_interval = packet["d"]["heartbeat_interval"]
+      end
+    end
+
+    # Communication goes like this:
+    # me                    discord
+    #   |                      |
+    # websocket connect ->     |
+    #   |                      |
+    #   |     <- websocket opcode 2
+    #   |                      |
+    # UDP discovery ->         |
+    #   |                      |
+    #   |       <- UDP reply packet
+    #   |                      |
+    # websocket opcode 1 ->    |
+    #   |                      |
+    # ...
+    def connect
+      # Connect websocket
+      @thread = Thread.new do
+        Thread.current[:rubycord_name] = "vws"
+        init_ws
+      end
+
+      @bot.debug("Started websocket initialization, now waiting for UDP discovery reply")
+
+      # Now wait for opcode 2 and the resulting UDP reply packet
+      ip, port = @udp.receive_discovery_reply
+      @bot.debug("UDP discovery reply received! #{ip} #{port}")
+
+      # Send UDP init packet with received UDP data
+      send_udp_connection(ip, port, @udp_mode)
+
+      @bot.debug("Waiting for op 4 now")
+
+      # Wait for op 4, then finish
+      sleep 0.05 until @ready
+    end
+
+    # Disconnects the websocket and kills the thread
+    def destroy
+      @heartbeat_running = false
+    end
+
+    private
+
+    def heartbeat_loop
+      @heartbeat_running = true
+      while @heartbeat_running
+        if @heartbeat_interval
+          sleep @heartbeat_interval / 1000.0
+          send_heartbeat
+        else
+          # If no interval has been set yet, sleep a second and check again
+          sleep 1
+        end
+      end
+    end
+
+    def init_ws
+      host = "wss://#{@endpoint}:443/?v=#{VOICE_GATEWAY_VERSION}"
+      @bot.debug("Connecting VWS to host: #{host}")
+
+      # Connect the WS
+      @client = Rubycord::WebSocket.new(
+        host,
+        method(:websocket_open),
+        method(:websocket_message),
+        proc { |e| Rubycord::LOGGER.error "VWS error: #{e}" },
+        proc { |e| Rubycord::LOGGER.warn "VWS close: #{e}" }
+      )
+
+      @bot.debug("VWS connected")
+
+      # Block any further execution
+      heartbeat_loop
+    end
+  end
+end

data/lib/rubycord/voice/sodium.rb

@@ -0,0 +1,96 @@
+require "ffi"
+
+module Rubycord::Voice
+  # @!visibility private
+  module Sodium
+    extend ::FFI::Library
+
+    ffi_lib(["sodium", "libsodium.so.18", "libsodium.so.23"])
+
+    # Encryption & decryption
+    attach_function(:crypto_secretbox_xsalsa20poly1305, %i[pointer pointer ulong_long pointer pointer], :int)
+    attach_function(:crypto_secretbox_xsalsa20poly1305_open, %i[pointer pointer ulong_long pointer pointer], :int)
+
+    # Constants
+    attach_function(:crypto_secretbox_xsalsa20poly1305_keybytes, [], :size_t)
+    attach_function(:crypto_secretbox_xsalsa20poly1305_noncebytes, [], :size_t)
+    attach_function(:crypto_secretbox_xsalsa20poly1305_zerobytes, [], :size_t)
+    attach_function(:crypto_secretbox_xsalsa20poly1305_boxzerobytes, [], :size_t)
+  end
+
+  # Utility class for interacting with required `xsalsa20poly1305` functions for voice transmission
+  # @!visibility private
+  class SecretBox
+    # Exception raised when a key or nonce with invalid length is used
+    class LengthError < RuntimeError
+    end
+
+    # Exception raised when encryption or decryption fails
+    class CryptoError < RuntimeError
+    end
+
+    # Required key length
+    KEY_LENGTH = Sodium.crypto_secretbox_xsalsa20poly1305_keybytes
+
+    # Required nonce length
+    NONCE_BYTES = Sodium.crypto_secretbox_xsalsa20poly1305_noncebytes
+
+    # Zero byte padding for encryption
+    ZERO_BYTES = Sodium.crypto_secretbox_xsalsa20poly1305_zerobytes
+
+    # Zero byte padding for decryption
+    BOX_ZERO_BYTES = Sodium.crypto_secretbox_xsalsa20poly1305_boxzerobytes
+
+    # @param key [String] Crypto key of length {KEY_LENGTH}
+    def initialize(key)
+      raise(LengthError, "Key length") if key.bytesize != KEY_LENGTH
+
+      @key = key
+    end
+
+    # Encrypts a message using this box's key
+    # @param nonce [String] encryption nonce for this message
+    # @param message [String] message to be encrypted
+    def box(nonce, message)
+      raise(LengthError, "Nonce length") if nonce.bytesize != NONCE_BYTES
+
+      message_padded = prepend_zeroes(ZERO_BYTES, message)
+      buffer = zero_string(message_padded.bytesize)
+
+      success = Sodium.crypto_secretbox_xsalsa20poly1305(buffer, message_padded, message_padded.bytesize, nonce, @key)
+      raise(CryptoError, "Encryption failed (#{success})") unless success.zero?
+
+      remove_zeroes(BOX_ZERO_BYTES, buffer)
+    end
+
+    # Decrypts the given ciphertext using this box's key
+    # @param nonce [String] encryption nonce for this ciphertext
+    # @param ciphertext [String] ciphertext to decrypt
+    def open(nonce, ciphertext)
+      raise(LengthError, "Nonce length") if nonce.bytesize != NONCE_BYTES
+
+      ct_padded = prepend_zeroes(BOX_ZERO_BYTES, ciphertext)
+      buffer = zero_string(ct_padded.bytesize)
+
+      success = Sodium.crypto_secretbox_xsalsa20poly1305_open(buffer, ct_padded, ct_padded.bytesize, nonce, @key)
+      raise(CryptoError, "Decryption failed (#{success})") unless success.zero?
+
+      remove_zeroes(ZERO_BYTES, buffer)
+    end
+
+    private
+
+    def zero_string(size)
+      str = "\0" * size
+      str.force_encoding("ASCII-8BIT") if str.respond_to?(:force_encoding)
+    end
+
+    def prepend_zeroes(size, string)
+      zero_string(size) + string
+    end
+
+    def remove_zeroes(size, string)
+      string.slice!(size, string.bytesize - size)
+    end
+  end
+end