diaspora_federation 0.1.9 → 0.2.0

data/lib/diaspora_federation/entities/participation.rb

@@ -4,11 +4,22 @@ module DiasporaFederation
     #
     # @see Validators::Participation
     class Participation < Entity
-      # Old signature order
-      # @deprecated
-      LEGACY_SIGNATURE_ORDER = %i(guid parent_type parent_guid author).freeze
+      # @!attribute [r] author
+      #   The diaspora* ID of the author
+      #   @see Person#author
+      #   @return [String] diaspora* ID
+      property :author, :string, xml_name: :diaspora_handle
 
-      include Relayable
+      # @!attribute [r] guid
+      #   A random string of at least 16 chars
+      #   @see Validation::Rule::Guid
+      #   @return [String] guid
+      property :guid, :string
+
+      # @!attribute [r] parent_guid
+      #   @see StatusMessage#guid
+      #   @return [String] parent guid
+      property :parent_guid, :string
 
       # @!attribute [r] parent_type
       #   A string describing a type of the target to subscribe on
@@ -16,10 +27,9 @@ module DiasporaFederation
       #   @return [String] parent type
       property :parent_type, :string, xml_name: :target_type
 
-      # It is only valid to receive a {Participation} from the author themself.
-      # @deprecated remove after {Participation} doesn't include {Relayable} anymore
-      def sender_valid?(sender)
-        sender == author
+      # @return [String] string representation of this object
+      def to_s
+        "#{super}:#{parent_type}:#{parent_guid}"
       end
 
       # Validates that the parent exists and the parent author is local
@@ -28,12 +38,12 @@ module DiasporaFederation
         raise ParentNotLocal, "obj=#{self}" unless parent && parent.local
       end
 
-      # Don't verify signatures for a {Participation}. Validate that the parent is local.
-      # @see Entity.populate_entity
-      # @param [Nokogiri::XML::Element] root_node xml nodes
+      # Validate that the parent is local.
+      # @see Entity.from_hash
+      # @param [Hash] hash entity initialization hash
       # @return [Entity] instance
-      private_class_method def self.populate_entity(root_node)
-        new(entity_data(root_node).merge(parent: nil)).tap(&:validate_parent)
+      def self.from_hash(hash)
+        super.tap(&:validate_parent)
       end
 
       # Raised, if the parent is not owned by the receiving pod.

data/lib/diaspora_federation/entities/poll_participation.rb

@@ -4,10 +4,6 @@ module DiasporaFederation
     #
     # @see Validators::PollParticipationValidator
     class PollParticipation < Entity
-      # Old signature order
-      # @deprecated
-      LEGACY_SIGNATURE_ORDER = %i(guid parent_guid author poll_answer_guid).freeze
-
       # The {PollParticipation} parent is a {Poll}
       PARENT_TYPE = "Poll".freeze
 

data/lib/diaspora_federation/entities/profile.rb

@@ -53,6 +53,11 @@ module DiasporaFederation
       #   @return [Boolean] searchable flag
       property :searchable, :boolean, default: true
 
+      # @!attribute [r] public
+      #   Shows whether the profile is visible to everyone or only to contacts
+      #   @return [Boolean] is it public
+      property :public, :boolean, default: false
+
       property :nsfw, :boolean, default: false
       property :tag_string, :string, default: nil
 

data/lib/diaspora_federation/entities/related_entity.rb

@@ -24,10 +24,27 @@ module DiasporaFederation
       #   @return [RelatedEntity] parent entity
       entity :parent, Entities::RelatedEntity, default: nil
 
+      # Get related entity from the backend or fetch it from remote if not available locally
+      # @return [RelatedEntity] fetched related entity
+      def self.fetch(author, type, guid)
+        # Try to fetch locally
+        entity = DiasporaFederation.callbacks.trigger(:fetch_related_entity, type, guid)
+        return entity if entity
+
+        # Fetch and receive entity from remote if not available locally
+        Federation::Fetcher.fetch_public(author, type, guid)
+        DiasporaFederation.callbacks.trigger(:fetch_related_entity, type, guid)
+      end
+
       # never add {RelatedEntity} to xml
       def to_xml
         nil
       end
+
+      # never add {RelatedEntity} to json
+      def to_json
+        nil
+      end
     end
   end
 end

data/lib/diaspora_federation/entities/relayable.rb

@@ -5,18 +5,11 @@ module DiasporaFederation
     # has a parent, identified by guid. Relayables are also signed and signing/verification
     # logic is embedded into Salmon XML processing code.
     module Relayable
-      include Logging
+      include Signable
 
-      # Digest instance used for signing
-      DIGEST = OpenSSL::Digest::SHA256.new
-
-      # Order from the parsed xml for signature
-      # @return [Array] order from xml
-      attr_reader :xml_order
-
-      # Additional properties from parsed xml
-      # @return [Hash] additional xml elements
-      attr_reader :additional_xml_elements
+      # Additional properties from parsed input object
+      # @return [Hash] additional elements
+      attr_reader :additional_data
 
       # On inclusion of this module the required properties for a relayable are added to the object that includes it.
       #
@@ -35,16 +28,15 @@ module DiasporaFederation
       #   @return [String] parent guid
       #
       # @!attribute [r] author_signature
-      #   Contains a signature of the entity using the private key of the author of a post itself
+      #   Contains a signature of the entity using the private key of the author of a relayable itself.
       #   The presence of this signature is mandatory. Without it the entity won't be accepted by
       #   a target pod.
       #   @return [String] author signature
       #
       # @!attribute [r] parent_author_signature
-      #   Contains a signature of the entity using the private key of the author of a parent post
-      #   This signature is required only when federating from upstream (parent) post author to
-      #   downstream subscribers. This is the case when the parent author has to resend a relayable
-      #   received from one of their subscribers to all others.
+      #   Contains a signature of the entity using the private key of the author of a parent post.
+      #   @deprecated This signature isn't required anymore, because we can check the signature from
+      #     the parent author in the MagicEnvelope.
       #   @return [String] parent author signature
       #
       # @!attribute [r] parent
@@ -62,33 +54,33 @@ module DiasporaFederation
           entity :parent, Entities::RelatedEntity
         end
 
-        klass.extend ParseXML
+        klass.extend Parsing
       end
 
       # Initializes a new relayable Entity with order and additional xml elements
       #
       # @param [Hash] data entity data
-      # @param [Array] xml_order order from xml
-      # @param [Hash] additional_xml_elements additional xml elements
+      # @param [Array] signature_order order for the signature
+      # @param [Hash] additional_data additional xml elements
       # @see DiasporaFederation::Entity#initialize
-      def initialize(data, xml_order=nil, additional_xml_elements={})
-        @xml_order = xml_order.reject {|name| name =~ /signature/ } if xml_order
-        @additional_xml_elements = additional_xml_elements
+      def initialize(data, signature_order=nil, additional_data={})
+        self.signature_order = signature_order if signature_order
+        @additional_data = additional_data
 
         super(data)
       end
 
-      # Verifies the signatures (+author_signature+ and +parent_author_signature+ if needed).
-      # @raise [SignatureVerificationFailed] if the signature is not valid or no public key is found
-      def verify_signatures
-        verify_signature(author, :author_signature)
-
-        # This happens only on downstream federation.
-        verify_signature(parent.author, :parent_author_signature) unless parent.local
+      # Verifies the +author_signature+ if needed.
+      # @see DiasporaFederation::Entities::Signable#verify_signature
+      #
+      # @raise [SignatureVerificationFailed] if the signature is not valid
+      # @raise [PublicKeyNotFound] if no public key is found
+      def verify_signature
+        super(author, :author_signature) unless author == parent.author
       end
 
       def sender_valid?(sender)
-        sender == author || sender == parent.author
+        (sender == author && parent.local) || sender == parent.author
       end
 
       # @return [String] string representation of this object
@@ -96,26 +88,23 @@ module DiasporaFederation
         "#{super}#{":#{parent_type}" if respond_to?(:parent_type)}:#{parent_guid}"
       end
 
-      private
-
-      # Check that signature is a correct signature
-      #
-      # @param [String] author The author of the signature
-      # @param [String] signature_key The signature to be verified
-      # @return [Boolean] signature valid
-      def verify_signature(author, signature_key)
-        pubkey = DiasporaFederation.callbacks.trigger(:fetch_public_key, author)
-        raise PublicKeyNotFound, "signature=#{signature_key} person=#{author} obj=#{self}" if pubkey.nil?
-
-        signature = public_send(signature_key)
-        raise SignatureVerificationFailed, "no #{signature_key} for #{self}" if signature.nil?
-
-        valid = pubkey.verify(DIGEST, Base64.decode64(signature), signature_data)
-        raise SignatureVerificationFailed, "wrong #{signature_key} for #{self}" unless valid
+      def to_json
+        super.merge!(property_order: signature_order).tap {|json_hash|
+          missing_properties = json_hash[:property_order] - json_hash[:entity_data].keys
+          missing_properties.each {|property|
+            json_hash[:entity_data][property] = nil
+          }
+        }
+      end
 
-        logger.info "event=verify_signature signature=#{signature_key} status=valid obj=#{self}"
+      # The order for signing
+      # @return [Array]
+      def signature_order
+        @signature_order || self.class.class_props.keys - %i[author_signature parent_author_signature parent]
       end
 
+      private
+
       # Sign with author key
       # @raise [AuthorPrivateKeyNotFound] if the author private key is not found
       # @return [String] A Base64 encoded signature of #signature_data with key
@@ -138,22 +127,14 @@ module DiasporaFederation
         end
       end
 
-      # Sign the data with the key
-      #
-      # @param [OpenSSL::PKey::RSA] privkey An RSA key
-      # @return [String] A Base64 encoded signature of #signature_data with key
-      def sign_with_key(privkey)
-        Base64.strict_encode64(privkey.sign(DIGEST, signature_data))
-      end
-
       # Update the signatures with the keys of the author and the parent
       # if the signatures are not there yet and if the keys are available.
       #
       # @return [Hash] properties with updated signatures
       def enriched_properties
-        super.merge(additional_xml_elements).tap do |hash|
+        super.merge(additional_data).tap do |hash|
           hash[:author_signature] = author_signature || sign_with_author
-          hash[:parent_author_signature] = parent_author_signature || sign_with_parent_author_if_available.to_s
+          hash.delete(:parent_author_signature)
         end
       end
 
@@ -161,90 +142,78 @@ module DiasporaFederation
       #
       # @return [Hash] sorted xml elements
       def xml_elements
-        data = super
-        order = signature_order + %i(author_signature parent_author_signature)
+        data = super.tap do |hash|
+          hash[:parent_author_signature] = parent_author_signature || sign_with_parent_author_if_available.to_s
+        end
+        order = signature_order + %i[author_signature parent_author_signature]
         order.map {|element| [element, data[element] || ""] }.to_h
       end
 
-      # The order for signing
-      # @return [Array]
-      def signature_order
-        if xml_order
-          prop_names = self.class.class_props.keys.map(&:to_s)
-          xml_order.map {|name| prop_names.include?(name) ? name.to_sym : name }
-        else
-          self.class::LEGACY_SIGNATURE_ORDER
-        end
+      def signature_order=(order)
+        prop_names = self.class.class_props.keys.map(&:to_s)
+        @signature_order = order.reject {|name| name =~ /signature/ }
+                                .map {|name| prop_names.include?(name) ? name.to_sym : name }
       end
 
       # @return [String] signature data string
       def signature_data
-        data = normalized_properties.merge(additional_xml_elements)
+        data = normalized_properties.merge(additional_data)
         signature_order.map {|name| data[name] }.join(";")
       end
 
-      # Override class methods from {Entity} to parse the xml
-      module ParseXML
-        private
-
-        # @param [Nokogiri::XML::Element] root_node xml nodes
-        # @return [Entity] instance
-        def populate_entity(root_node)
-          # Use all known properties to build the Entity (entity_data). All additional xml elements
-          # are respected and attached to a hash as string (additional_xml_elements). It also remembers
-          # the order of the xml-nodes (xml_order). This is needed to support receiving objects from
-          # the future versions of diaspora*, where new elements may have been added.
-          entity_data = {}
-          additional_xml_elements = {}
-
-          xml_order = root_node.element_children.map do |child|
-            xml_name = child.name
-            property = find_property_for_xml_name(xml_name)
-
-            if property
-              entity_data[property] = parse_element_from_node(xml_name, class_props[property], root_node)
-              property
-            else
-              additional_xml_elements[xml_name] = child.text
-              xml_name
-            end
-          end
-
-          fetch_parent(entity_data)
-          new(entity_data, xml_order, additional_xml_elements).tap(&:verify_signatures)
+      # Override class methods from {Entity} to parse serialized data
+      module Parsing
+        # Does the same job as Entity.from_hash except of the following differences:
+        # 1) unknown properties from the properties_hash are stored to additional_data of the relayable instance
+        # 2) parent entity fetch is attempted
+        # 3) signatures verification is performed; property_order is used as the order in which properties are composed
+        # to compute signatures
+        # 4) unknown properties' keys must be of String type
+        #
+        # @see Entity.from_hash
+        def from_hash(properties_hash, property_order)
+          # Use all known properties to build the Entity (entity_data). All additional elements
+          # are respected and attached to a hash as string (additional_data). This is needed
+          # to support receiving objects from the future versions of diaspora*, where new elements may have been added.
+          additional_data = properties_hash.reject {|key, _| class_props.has_key?(key) }
+
+          fetch_parent(properties_hash)
+          new(properties_hash, property_order, additional_data).tap(&:verify_signature)
         end
 
+        private
+
         def fetch_parent(data)
           type = data.fetch(:parent_type) {
             break self::PARENT_TYPE if const_defined?(:PARENT_TYPE)
 
-            raise DiasporaFederation::Entity::ValidationError, "invalid #{self}! missing 'parent_type'."
+            raise DiasporaFederation::Entity::ValidationError, error_message_missing_property(data, "parent_type")
           }
           guid = data.fetch(:parent_guid) {
-            raise DiasporaFederation::Entity::ValidationError, "invalid #{self}! missing 'parent_guid'."
+            raise DiasporaFederation::Entity::ValidationError, error_message_missing_property(data, "parent_guid")
           }
 
-          data[:parent] = DiasporaFederation.callbacks.trigger(:fetch_related_entity, type, guid)
+          data[:parent] = RelatedEntity.fetch(data[:author], type, guid)
+        end
 
-          return if data[:parent]
+        def error_message_missing_property(data, missing_property)
+          obj_str = "#{class_name}#{":#{data[:guid]}" if data.has_key?(:guid)}" \
+                    "#{" from #{data[:author]}" if data.has_key?(:author)}"
+          "Invalid #{obj_str}! Missing '#{missing_property}'."
+        end
+
+        def xml_parser_class
+          DiasporaFederation::Parsers::RelayableXmlParser
+        end
 
-          # Fetch and receive parent from remote, if not available locally
-          Federation::Fetcher.fetch_public(data[:author], type, guid)
-          data[:parent] = DiasporaFederation.callbacks.trigger(:fetch_related_entity, type, guid)
+        def json_parser_class
+          DiasporaFederation::Parsers::RelayableJsonParser
         end
       end
 
       # Raised, if creating the author_signature fails, because the private key was not found
       class AuthorPrivateKeyNotFound < RuntimeError
       end
-
-      # Raised, if verify_signatures fails to verify signatures (no public key found)
-      class PublicKeyNotFound < RuntimeError
-      end
-
-      # Raised, if verify_signatures fails to verify signatures (signatures are wrong)
-      class SignatureVerificationFailed < RuntimeError
-      end
     end
   end
 end

data/lib/diaspora_federation/entities/relayable_retraction.rb

@@ -53,52 +53,13 @@ module DiasporaFederation
       #   @return [String] target author signature
       property :target_author_signature, :string, default: nil
 
-      # @!attribute [r] target
-      #   Target entity
-      #   @return [RelatedEntity] target entity
-      entity :target, Entities::RelatedEntity
-
-      # Use only {Retraction} for receive
-      # @return [Retraction] instance as normal retraction
-      def to_retraction
-        Retraction.new(author: author, target_guid: target_guid, target_type: target_type, target: target)
-      end
-
-      # @return [String] string representation of this object
-      def to_s
-        "RelayableRetraction:#{target_type}:#{target_guid}"
+      def initialize(*)
+        raise "Sending RelayableRetraction is not supported anymore! Use Retraction instead!"
       end
 
-      private
-
-      # @param [Nokogiri::XML::Element] root_node xml nodes
       # @return [Retraction] instance
-      private_class_method def self.populate_entity(root_node)
-        entity_data = entity_data(root_node)
-        entity_data[:target] = Retraction.send(:fetch_target, entity_data[:target_type], entity_data[:target_guid])
-        new(entity_data).to_retraction
-      end
-
-      # It updates also the signatures with the keys of the author and the parent
-      # if the signatures are not there yet and if the keys are available.
-      #
-      # @return [Hash] xml elements with updated signatures
-      def enriched_properties
-        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key, author)
-
-        super.tap do |hash|
-          fill_required_signature(privkey, hash) unless privkey.nil?
-        end
-      end
-
-      # @param [OpenSSL::PKey::RSA] privkey private key of sender
-      # @param [Hash] hash hash given for a signing
-      def fill_required_signature(privkey, hash)
-        if target.parent.author == author && parent_author_signature.nil?
-          hash[:parent_author_signature] = SignedRetraction.sign_with_key(privkey, self)
-        elsif target.author == author && target_author_signature.nil?
-          hash[:target_author_signature] = SignedRetraction.sign_with_key(privkey, self)
-        end
+      def self.from_hash(hash)
+        Retraction.from_hash(hash)
       end
     end
   end

data/lib/diaspora_federation/entities/request.rb

@@ -18,21 +18,13 @@ module DiasporaFederation
       #   @return [String] recipient ID
       property :recipient, :string, xml_name: :recipient_handle
 
-      # Use only {Contact} for receive
-      # @return [Contact] instance as contact
-      def to_contact
-        Contact.new(author: author, recipient: recipient)
+      def initialize(*)
+        raise "Sending Request is not supported anymore! Use Contact instead!"
       end
 
-      # @return [String] string representation of this object
-      def to_s
-        "Request:#{author}:#{recipient}"
-      end
-
-      # @param [Nokogiri::XML::Element] root_node xml nodes
       # @return [Retraction] instance
-      private_class_method def self.populate_entity(root_node)
-        super(root_node).to_contact
+      def self.from_hash(hash)
+        Contact.new(hash)
       end
     end
   end

data/lib/diaspora_federation/entities/reshare.rb

@@ -29,17 +29,21 @@ module DiasporaFederation
       end
 
       # Fetch and receive root post from remote, if not available locally
-      def fetch_root
-        root = DiasporaFederation.callbacks.trigger(:fetch_related_entity, "Post", root_guid)
-        Federation::Fetcher.fetch_public(root_author, "Post", root_guid) unless root
+      # and validates if it's from the correct author
+      def validate_root
+        root = RelatedEntity.fetch(root_author, "Post", root_guid)
+
+        return if root_author == root.author
+
+        raise Entity::ValidationError,
+              "root_author mismatch: obj=#{self} root_author=#{root_author} known_root_author=#{root.author}"
       end
 
       # Fetch root post after parse
-      # @see Entity.populate_entity
-      # @param [Nokogiri::XML::Element] root_node xml nodes
+      # @see Entity.from_hash
       # @return [Entity] instance
-      private_class_method def self.populate_entity(root_node)
-        super(root_node).tap(&:fetch_root)
+      def self.from_hash(hash)
+        super.tap(&:validate_root)
       end
     end
   end

data/lib/diaspora_federation/entities/retraction.rb

@@ -39,12 +39,11 @@ module DiasporaFederation
         "Retraction:#{target_type}:#{target_guid}"
       end
 
-      # @param [Nokogiri::XML::Element] root_node xml nodes
+      # @see Entity.from_hash
       # @return [Retraction] instance
-      private_class_method def self.populate_entity(root_node)
-        entity_data = entity_data(root_node)
-        entity_data[:target] = fetch_target(entity_data[:target_type], entity_data[:target_guid])
-        new(entity_data)
+      def self.from_hash(hash)
+        hash[:target] = fetch_target(hash[:target_type], hash[:target_guid])
+        new(hash)
       end
 
       private_class_method def self.fetch_target(target_type, target_guid)

data/lib/diaspora_federation/entities/signable.rb

@@ -0,0 +1,54 @@
+module DiasporaFederation
+  module Entities
+    # Signable is a module that encapsulates basic signature generation/verification flow for entities.
+    module Signable
+      include Logging
+
+      # Digest instance used for signing
+      DIGEST = OpenSSL::Digest::SHA256.new
+
+      # Sign the data with the key
+      #
+      # @param [OpenSSL::PKey::RSA] privkey An RSA key
+      # @return [String] A Base64 encoded signature of #signature_data with key
+      def sign_with_key(privkey)
+        Base64.strict_encode64(privkey.sign(DIGEST, signature_data))
+      end
+
+      # Check that signature is a correct signature
+      #
+      # @param [String] author The author of the signature
+      # @param [String] signature_key The signature to be verified
+      # @raise [SignatureVerificationFailed] if the signature is not valid
+      # @raise [PublicKeyNotFound] if no public key is found
+      def verify_signature(author, signature_key)
+        pubkey = DiasporaFederation.callbacks.trigger(:fetch_public_key, author)
+        raise PublicKeyNotFound, "signature=#{signature_key} person=#{author} obj=#{self}" if pubkey.nil?
+
+        signature = public_send(signature_key)
+        raise SignatureVerificationFailed, "no #{signature_key} for #{self}" if signature.nil?
+
+        valid = pubkey.verify(DIGEST, Base64.decode64(signature), signature_data)
+        raise SignatureVerificationFailed, "wrong #{signature_key} for #{self}" unless valid
+
+        logger.info "event=verify_signature signature=#{signature_key} status=valid obj=#{self}"
+      end
+
+      # This method defines what data is used for a signature creation/verification
+      #
+      # @abstract
+      # @return [String] a string to sign
+      def signature_data
+        raise NotImplementedError.new("you must override this method to define signature base string")
+      end
+
+      # Raised, if verify_signatures fails to verify signatures (no public key found)
+      class PublicKeyNotFound < RuntimeError
+      end
+
+      # Raised, if verify_signatures fails to verify signatures (signatures are wrong)
+      class SignatureVerificationFailed < RuntimeError
+      end
+    end
+  end
+end

data/lib/diaspora_federation/entities/signed_retraction.rb

@@ -30,53 +30,13 @@ module DiasporaFederation
       #   @return [String] author signature
       property :target_author_signature, :string, default: nil
 
-      # @!attribute [r] target
-      #   Target entity
-      #   @return [RelatedEntity] target entity
-      entity :target, Entities::RelatedEntity
-
-      # Use only {Retraction} for receive
-      # @return [Retraction] instance as normal retraction
-      def to_retraction
-        Retraction.new(author: author, target_guid: target_guid, target_type: target_type, target: target)
-      end
-
-      # Create signature for a retraction
-      # @param [OpenSSL::PKey::RSA] privkey private key of sender
-      # @param [SignedRetraction, RelayableRetraction] ret the retraction to sign
-      # @return [String] a Base64 encoded signature of the retraction with the key
-      def self.sign_with_key(privkey, ret)
-        Base64.strict_encode64(privkey.sign(Relayable::DIGEST, [ret.target_guid, ret.target_type].join(";")))
-      end
-
-      # @return [String] string representation of this object
-      def to_s
-        "SignedRetraction:#{target_type}:#{target_guid}"
+      def initialize(*)
+        raise "Sending SignedRetraction is not supported anymore! Use Retraction instead!"
       end
 
-      private
-
-      # @param [Nokogiri::XML::Element] root_node xml nodes
       # @return [Retraction] instance
-      private_class_method def self.populate_entity(root_node)
-        entity_data = entity_data(root_node)
-        entity_data[:target] = Retraction.send(:fetch_target, entity_data[:target_type], entity_data[:target_guid])
-        new(entity_data).to_retraction
-      end
-
-      # It updates also the signatures with the keys of the author and the parent
-      # if the signatures are not there yet and if the keys are available.
-      #
-      # @return [Hash] xml elements with updated signatures
-      def enriched_properties
-        super.tap do |hash|
-          hash[:target_author_signature] = target_author_signature || sign_with_author.to_s
-        end
-      end
-
-      def sign_with_author
-        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key, author)
-        SignedRetraction.sign_with_key(privkey, self) unless privkey.nil?
+      def self.from_hash(hash)
+        Retraction.from_hash(hash)
       end
     end
   end