ably 0.8.8 → 0.8.9

data/lib/ably/auth.rb

@@ -585,7 +585,7 @@ module Ably
       token_request = Ably::Models::TokenRequest(token_request)
 
       response = client.post("/keys/#{token_request.key_name}/requestToken",
-                             token_request.hash, send_auth_header: false,
+                             token_request.attributes, send_auth_header: false,
                              disable_automatic_reauthorise: true)
 
       Ably::Models::TokenDetails.new(response.body)

data/lib/ably/exceptions.rb

@@ -32,6 +32,15 @@ module Ably
     # An invalid request was received by Ably
     class InvalidRequest < BaseAblyException; end
 
+    # Similar to 403 Forbidden, but specifically for use when authentication is required and has failed or has not yet been provided
+    class UnauthorizedRequest < BaseAblyException; end
+
+    # The request was a valid request, but Ably is refusing to respond to it
+    class ForbiddenRequest < BaseAblyException; end
+
+    # The requested resource could not be found but may be available again in the future
+    class ResourceMissing < BaseAblyException; end
+
     # Ably Protocol message received that is invalid
     class ProtocolError < BaseAblyException; end
 
@@ -92,7 +101,7 @@ module Ably
     # The token request could not be created
     class TokenRequestFailed < BaseAblyException; end
 
-    # The token has expired
+    # The token has expired, 40140..40149
     class TokenExpired < BaseAblyException; end
 
     # The message could not be delivered to the server

data/lib/ably/models/cipher_params.rb

@@ -0,0 +1,114 @@
+require 'base64'
+require 'ably/util/crypto'
+
+module Ably::Models
+  # Convert cipher param attributes to a {CipherParams} object
+  #
+  # @param attributes (see #initialize)
+  #
+  # @return [CipherParams]
+  def self.CipherParams(attributes)
+    case attributes
+    when CipherParams
+      return attributes
+    else
+      CipherParams.new(attributes || {})
+    end
+  end
+
+  # CipherParams is used to configure a channel for encryption
+  #
+  class CipherParams
+    include Ably::Modules::ModelCommon
+
+    # @param params [Hash]
+    # @option params [String,Binary]  :key         Required private key must be either a binary (e.g. a ASCII_8BIT encoded string), or a base64-encoded string. If the key is a base64-encoded string, the it will be automatically converted into a binary
+    # @option params [String]         :algorithm   optional (default AES), specify the encryption algorithm supported by {http://ruby-doc.org/stdlib-2.0/libdoc/openssl/rdoc/OpenSSL/Cipher.html OpenSSL::Cipher}
+    # @option params [String]         :mode        optional (default CBC), specify the cipher mode supported by {http://ruby-doc.org/stdlib-2.0/libdoc/openssl/rdoc/OpenSSL/Cipher.html OpenSSL::Cipher}
+    # @option params [Integer]        :key_length  optional (default 128), specify the key length of the cipher supported by {http://ruby-doc.org/stdlib-2.0/libdoc/openssl/rdoc/OpenSSL/Cipher.html OpenSSL::Cipher}
+    # @option params [String]         :combined    optional (default AES-128-CBC), specify in one option the algorithm, key length and cipher of the cipher supported by {http://ruby-doc.org/stdlib-2.0/libdoc/openssl/rdoc/OpenSSL/Cipher.html OpenSSL::Cipher}
+    #
+    def initialize(params = {})
+      @attributes = IdiomaticRubyWrapper(params.clone)
+
+      raise Ably::Exceptions::CipherError, ':key param is required' unless attributes[:key]
+      raise Ably::Exceptions::CipherError, ':key param must be a base64-encoded string or byte array (ASCII_8BIT enocdede string)' unless key.kind_of?(String)
+      attributes[:key] = decode_key(key) if key.kind_of?(String) && key.encoding != Encoding::ASCII_8BIT
+
+      if attributes[:combined]
+        match = /(?<algorithm>\w+)-(?<key_length>\d+)-(?<mode>\w+)/.match(attributes[:combined])
+        raise Ably::Exceptions::CipherError, "Invalid :combined param, expecting format such as AES-256-CBC" unless match
+        attributes[:algorithm] = match[:algorithm]
+        attributes[:key_length] = match[:key_length].to_i
+        attributes[:mode] = match[:mode]
+      end
+
+      if attributes[:key_length] && (key_length != attributes[:key_length])
+        raise Ably::Exceptions::CipherError, "Incompatible :key length of #{key_length} and provided :key_length of #{attributes[:key_length]}"
+      end
+
+      if algorithm == 'aes' && mode == 'cbc'
+        unless [128, 256].include?(key_length)
+          raise Ably::Exceptions::CipherError, "Unsupported key length #{key_length} for aes-cbc encryption. Encryption key must be 128 or 256 bits (16 or 32 ASCII characters)"
+        end
+      end
+
+      attributes.freeze
+    end
+
+    # The Cipher algorithm string such as AES-128-CBC
+    # @param [Hash]  params  Hash containing :algorithm, :key_length and :mode key values
+    #
+    # @return [String]
+    def self.cipher_type(params)
+      "#{params[:algorithm]}-#{params[:key_length]}-#{params[:mode]}".to_s.upcase
+    end
+
+    # @!attribute [r] algorithm
+    # @return [String] The algorithm to use for encryption, currently only +AES+ is supported
+    def algorithm
+      attributes.fetch(:algorithm) do
+        Ably::Util::Crypto::DEFAULTS.fetch(:algorithm)
+      end.downcase
+    end
+
+    # @!attribute [r] key
+    # @return [Binary] Private key used to encrypt and decrypt payloads
+    def key
+      attributes[:key]
+    end
+
+    # @!attribute [r] key_length
+    # @return [Integer] The length in bits of the +key+
+    def key_length
+      key.unpack('b*').first.length
+    end
+
+    # @!attribute [r] mode
+    # @return [String] The cipher mode, currently only +CBC+ is supported
+    def mode
+      attributes.fetch(:mode) do
+        Ably::Util::Crypto::DEFAULTS.fetch(:mode)
+      end.downcase
+    end
+
+    # @!attribute [r] cipher_type
+    # @return [String] The complete Cipher algorithm string such as AES-128-CBC
+    def cipher_type
+      self.class.cipher_type(algorithm: algorithm, key_length: key_length, mode: mode)
+    end
+
+    # @!attribute [r] attributes
+    # @return [Hash] Access the token details Hash object ruby'fied to use symbolized keys
+    def attributes
+      @attributes
+    end
+
+    private
+
+    def decode_key(encoded_key)
+      normalised_key = encoded_key.gsub('_', '/').gsub('-', '+')
+      Base64.decode64(normalised_key)
+    end
+  end
+end

data/lib/ably/models/connection_details.rb

@@ -32,23 +32,25 @@ module Ably::Models
     #
     def initialize(attributes = {})
       @hash_object = IdiomaticRubyWrapper(attributes.clone)
-      hash[:connection_state_ttl] = (hash[:connection_state_ttl].to_f / 1000).round if hash[:connection_state_ttl]
-      hash.freeze
+      if self.attributes[:connection_state_ttl]
+        self.attributes[:connection_state_ttl] = (self.attributes[:connection_state_ttl].to_f / 1000).round
+      end
+      self.attributes.freeze
     end
 
     %w(client_id connection_key max_message_size max_frame_size max_inbound_rate connection_state_ttl server_id).each do |attribute|
       define_method attribute do
-        hash[attribute.to_sym]
+        attributes[attribute.to_sym]
       end
     end
 
     def has_client_id?
-      hash.has_key?(:client_id)
+      attributes.has_key?(:client_id)
     end
 
-    # @!attribute [r] hash
+    # @!attribute [r] attributes
     # @return [Hash] Access the token details Hash object ruby'fied to use symbolized keys
-    def hash
+    def attributes
       @hash_object
     end
   end

data/lib/ably/models/error_info.rb

@@ -8,7 +8,7 @@ module Ably::Models
   #   @return [Integer] Ably error code (see ably-common/protocol/errors.json)
   # @!attribute [r] status
   #   @return [Integer] HTTP Status Code corresponding to this error, where applicable
-  # @!attribute [r] hash
+  # @!attribute [r] attributes
   #   @return [Hash] Access the protocol message Hash object ruby'fied to use symbolized keys
   #
   class ErrorInfo
@@ -21,12 +21,12 @@ module Ably::Models
 
     %w(message code status_code).each do |attribute|
       define_method attribute do
-        hash[attribute.to_sym]
+        attributes[attribute.to_sym]
       end
     end
     alias_method :status, :status_code
 
-    def hash
+    def attributes
       @hash_object
     end
 

data/lib/ably/models/idiomatic_ruby_wrapper.rb

@@ -57,14 +57,14 @@ module Ably::Models
         $stderr.puts "<IdiomaticRubyWrapper#initialize> WARNING: Wrapping a IdiomaticRubyWrapper with another IdiomaticRubyWrapper"
       end
 
-      @hash = mixedCaseHashObject
-      @stop_at = Array(stop_at).each_with_object({}) do |key, hash|
-        hash[convert_to_snake_case_symbol(key)] = true
+      @attributes = mixedCaseHashObject
+      @stop_at = Array(stop_at).each_with_object({}) do |key, object|
+        object[convert_to_snake_case_symbol(key)] = true
       end.freeze
     end
 
     def [](key)
-      value = hash[source_key_for(key)]
+      value = attributes[source_key_for(key)]
       if stop_at?(key) || !value.kind_of?(Hash)
         value
       else
@@ -73,7 +73,7 @@ module Ably::Models
     end
 
     def []=(key, value)
-      hash[source_key_for(key)] = value
+      attributes[source_key_for(key)] = value
     end
 
     def fetch(key, default = nil)
@@ -91,7 +91,7 @@ module Ably::Models
     end
 
     def size
-      hash.size
+      attributes.size
     end
 
     def keys
@@ -103,14 +103,14 @@ module Ably::Models
     end
 
     def has_key?(key)
-      hash.has_key?(source_key_for(key))
+      attributes.has_key?(source_key_for(key))
     end
 
     # Method ensuring this {IdiomaticRubyWrapper} is {http://ruby-doc.org/core-2.1.3/Enumerable.html Enumerable}
     def each
       return to_enum(:each) unless block_given?
 
-      hash.each do |key, value|
+      attributes.each do |key, value|
         key = convert_to_snake_case_symbol(key)
         value = self[key]
         yield key, value
@@ -138,9 +138,10 @@ module Ably::Models
       end
     end
 
-    # Access to the raw Hash object provided to the constructer of this wrapper
-    def hash
-      @hash
+    # @!attribute [r] Hash
+    # @return [Hash] Access to the raw Hash object provided to the constructer of this wrapper
+    def attributes
+      @attributes
     end
 
     # Takes the underlying Hash object and returns it in as a JSON ready Hash object using snakeCase for compability with the Ably service.
@@ -149,7 +150,7 @@ module Ably::Models
     #   wrapper = IdiomaticRubyWrapper({ 'mixedCase': true, mixed_case: false, 'snake_case': 1 })
     #   wrapper.as_json({ 'mixedCase': true, 'snakeCase': 1 })
     def as_json(*args)
-      hash.each_with_object({}) do |key_val, new_hash|
+      attributes.each_with_object({}) do |key_val, new_hash|
         key                      = key_val[0]
         mixed_case_key           = convert_to_mixed_case(key)
         wrapped_val              = self[key]
@@ -171,26 +172,32 @@ module Ably::Models
     #   wrapper = IdiomaticRubyWrapper({ 'mixedCase': true, mixed_case: false, 'snake_case': 1 })
     #   wrapper.to_hash({ mixed_case: true, snake_case: 1 })
     def to_hash(*args)
-      each_with_object({}) do |key_val, hash|
-        key, val  = key_val
-        val       = val.to_hash(args) if val.kind_of?(IdiomaticRubyWrapper)
-        hash[key] = val
+      each_with_object({}) do |key_val, object|
+        key, val    = key_val
+        val         = val.to_hash(args) if val.kind_of?(IdiomaticRubyWrapper)
+        object[key] = val
       end
     end
 
     # Method to create a duplicate of the underlying Hash object
     # Useful when underlying Hash is frozen
     def dup
-      Ably::Models::IdiomaticRubyWrapper.new(hash.dup)
+      Ably::Models::IdiomaticRubyWrapper.new(attributes.dup, stop_at: stop_at.keys)
     end
 
     # Freeze the underlying data
     def freeze
-      hash.freeze
+      attributes.freeze
     end
 
     def to_s
-      hash.to_s
+      attributes.to_s
+    end
+
+    # @!attribute [r] hash
+    # @return [Integer] Compute a hash-code for this hash. Two hashes with the same content will have the same hash code
+    def hash
+      attributes.hash
     end
 
     private
@@ -214,7 +221,7 @@ module Ably::Models
       ]
 
       preferred_format = format_preferences.detect do |format|
-        hash.has_key?(format.call(symbolized_key))
+        attributes.has_key?(format.call(symbolized_key))
       end || format_preferences.first
 
       preferred_format.call(symbolized_key)

data/lib/ably/models/message.rb

@@ -34,7 +34,7 @@ module Ably::Models
   #   @return [String] A globally unique message ID
   # @!attribute [r] connection_id
   #   @return [String] The connection_id of the publisher of the message
-  # @!attribute [r] hash
+  # @!attribute [r] attributes
   #   @return [Hash] Access the protocol message Hash object ruby'fied to use symbolized keys
   #
   class Message
@@ -45,17 +45,17 @@ module Ably::Models
 
     # {Message} initializer
     #
-    # @param  hash_object [Hash]            object with the underlying message details
+    # @param  attributes [Hash]             object with the underlying message detail key value attributes
     # @param  [Hash]      options           an options Hash for this initializer
     # @option options     [ProtocolMessage] :protocol_message  An optional protocol message to assocate the presence message with
     # @option options     [Logger]          :logger            An optional Logger to be used by {Ably::Modules::SafeDeferrable} if an exception is caught in a callback
     #
-    def initialize(hash_object, options = {})
+    def initialize(attributes, options = {})
       @logger           = options[:logger] # Logger expected for SafeDeferrable
       @protocol_message = options[:protocol_message]
-      @raw_hash_object  = hash_object
+      @raw_hash_object  = attributes
 
-      set_hash_object hash_object
+      set_attributes_object attributes
 
       ensure_utf_8 :name,      name,      allow_nil: true
       ensure_utf_8 :client_id, client_id, allow_nil: true
@@ -64,32 +64,32 @@ module Ably::Models
 
     %w( name client_id encoding ).each do |attribute|
       define_method attribute do
-        hash[attribute.to_sym]
+        attributes[attribute.to_sym]
       end
     end
 
     def data
-      @data ||= hash[:data].freeze
+      @data ||= attributes[:data].freeze
     end
 
     def id
-      hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
+      attributes.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
     end
 
     def connection_id
-      hash.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
+      attributes.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
     end
 
     def timestamp
-      if hash[:timestamp]
-        as_time_from_epoch(hash[:timestamp])
+      if attributes[:timestamp]
+        as_time_from_epoch(attributes[:timestamp])
       else
         protocol_message.timestamp
       end
     end
 
-    def hash
-      @hash_object
+    def attributes
+      @attributes
     end
 
     def to_json(*args)
@@ -128,8 +128,8 @@ module Ably::Models
       protocol_message.messages.map(&:object_id).index(self.object_id)
     end
 
-    def set_hash_object(hash)
-      @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
+    def set_attributes_object(new_attributes)
+      @attributes = IdiomaticRubyWrapper(new_attributes.clone.freeze, stop_at: [:data])
     end
 
     def logger

data/lib/ably/models/message_encoders/cipher.rb

@@ -4,7 +4,7 @@ require 'ably/util/crypto'
 
 module Ably::Models::MessageEncoders
   # Cipher Encoder & Decoder that automatically encrypts & decrypts messages using Ably::Util::Crypto
-  # when a channel has option encrypted: true.
+  # when a channel has the +:cipher+ channel option configured
   #
   class Cipher < Base
     ENCODING_ID = 'cipher'
@@ -20,16 +20,17 @@ module Ably::Models::MessageEncoders
 
       if channel_configured_for_encryption?(channel_options)
         add_encoding_to_message 'utf-8', message unless is_binary?(message) || is_utf8_encoded?(message)
-
         crypto = crypto_for(channel_options)
         message[:data] = crypto.encrypt(message[:data])
-        add_encoding_to_message "#{ENCODING_ID}+#{crypto.cipher_type.downcase}", message
+        add_encoding_to_message "#{ENCODING_ID}+#{crypto.cipher_params.cipher_type.downcase}", message
       end
     rescue ArgumentError => e
       raise Ably::Exceptions::CipherError.new(e.message, nil, 92005)
     rescue RuntimeError => e
       if e.message.match(/unsupported cipher algorithm/i)
         raise Ably::Exceptions::CipherError.new(e.message, nil, 92004)
+      else
+        raise e
       end
     end
 
@@ -40,8 +41,8 @@ module Ably::Models::MessageEncoders
         end
 
         crypto = crypto_for(channel_options)
-        unless crypto.cipher_type == cipher_algorithm(message).upcase
-          raise Ably::Exceptions::CipherError.new("Cipher algorithm #{crypto.cipher_type} does not match message cipher algorithm of #{cipher_algorithm(message).upcase}", nil, 92002)
+        unless crypto.cipher_params.cipher_type == cipher_algorithm(message).upcase
+          raise Ably::Exceptions::CipherError.new("Cipher algorithm #{crypto.cipher_params.cipher_type} does not match message cipher algorithm of #{cipher_algorithm(message).upcase}", nil, 92002)
         end
 
         message[:data] = crypto.decrypt(message[:data])
@@ -61,11 +62,11 @@ module Ably::Models::MessageEncoders
     end
 
     def crypto_for(channel_options)
-      @cryptos[channel_options.fetch(:cipher_params, :default)] ||= Ably::Util::Crypto.new(channel_options.fetch(:cipher_params, {}))
+      @cryptos[channel_options.to_s] ||= Ably::Util::Crypto.new(channel_options.fetch(:cipher, {}))
     end
 
     def channel_configured_for_encryption?(channel_options)
-      channel_options.fetch(:encrypted, false)
+      channel_options[:cipher]
     end
 
     def is_cipher_encoded?(message)