diaspora_federation 0.0.13 → 0.1.0

data/lib/diaspora_federation/entities/message.rb

@@ -26,10 +26,35 @@ module DiasporaFederation
       #   @return [String] conversation guid
       property :conversation_guid
 
-      # The {Message} parent is a {Conversation}
-      # @return [String] parent type
-      def parent_type
-        "Conversation"
+      # It is only valid to receive a {Message} from the author itself,
+      # or from the author of the parent {Conversation} if the author signature is valid.
+      # @deprecated remove after {Message} doesn't include {Relayable} anymore
+      def sender_valid?(sender)
+        sender == author || (sender == parent_author && verify_author_signature)
+      end
+
+      private
+
+      # @deprecated remove after {Message} doesn't include {Relayable} anymore
+      def verify_author_signature
+        verify_signature(author, :author_signature)
+        true
+      end
+
+      # @deprecated remove after {Message} doesn't include {Relayable} anymore
+      def parent_author
+        parent = DiasporaFederation.callbacks.trigger(:fetch_related_entity, "Conversation", conversation_guid)
+        raise Federation::Fetcher::NotFetchable, "parent of #{self} not found" unless parent
+        parent.author
+      end
+
+      # Default implementation, don't verify signatures for a {Message}.
+      # @see Entity.populate_entity
+      # @deprecated remove after {Message} doesn't include {Relayable} anymore
+      # @param [Nokogiri::XML::Element] root_node xml nodes
+      # @return [Entity] instance
+      private_class_method def self.populate_entity(root_node)
+        new({parent_guid: nil, parent: nil}.merge(entity_data(root_node)))
       end
     end
   end

data/lib/diaspora_federation/entities/participation.rb

@@ -15,6 +15,30 @@ module DiasporaFederation
       #   currently only "Post" is supported.
       #   @return [String] parent type
       property :parent_type, xml_name: :target_type
+
+      # It is only valid to receive a {Participation} from the author itself.
+      # @deprecated remove after {Participation} doesn't include {Relayable} anymore
+      def sender_valid?(sender)
+        sender == author
+      end
+
+      # validates that the parent exists and the parent author is local
+      def validate_parent
+        parent = DiasporaFederation.callbacks.trigger(:fetch_related_entity, parent_type, parent_guid)
+        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
+      # @return [Entity] instance
+      private_class_method def self.populate_entity(root_node)
+        new(entity_data(root_node).merge(parent: nil)).tap(&:validate_parent)
+      end
+
+      # Raised, if the parent is not owned by the receiving pod.
+      class ParentNotLocal < RuntimeError
+      end
     end
   end
 end

data/lib/diaspora_federation/entities/poll_participation.rb

@@ -8,6 +8,9 @@ module DiasporaFederation
       # @deprecated
       LEGACY_SIGNATURE_ORDER = %i(guid parent_guid author poll_answer_guid).freeze
 
+      # The {PollParticipation} parent is a {Poll}
+      PARENT_TYPE = "Poll".freeze
+
       include Relayable
 
       # @!attribute [r] poll_answer_guid
@@ -15,12 +18,6 @@ module DiasporaFederation
       #   @see PollAnswer#guid
       #   @return [String] poll answer guid
       property :poll_answer_guid
-
-      # The {PollParticipation} parent is a {Poll}
-      # @return [String] parent type
-      def parent_type
-        "Poll"
-      end
     end
   end
 end

data/lib/diaspora_federation/entities/profile.rb

@@ -55,6 +55,11 @@ module DiasporaFederation
 
       property :nsfw, default: false
       property :tag_string, default: nil
+
+      # @return [String] string representation of this object
+      def to_s
+        "Profile:#{author}"
+      end
     end
   end
 end

data/lib/diaspora_federation/entities/related_entity.rb

@@ -0,0 +1,33 @@
+module DiasporaFederation
+  module Entities
+    # Entity meta informations for a related entity (parent or target of
+    # another entity).
+    class RelatedEntity < Entity
+      # @!attribute [r] author
+      #   The diaspora ID of the author.
+      #   @see Person#author
+      #   @return [String] diaspora ID
+      property :author
+
+      # @!attribute [r] local
+      #   +true+ if the owner of the entity is local on the pod
+      #   @return [Boolean] is it a like or a dislike
+      property :local
+
+      # @!attribute [r] public
+      #   shows whether the entity is visible to everyone or only to some aspects
+      #   @return [Boolean] is it public
+      property :public, default: false
+
+      # @!attribute [r] parent
+      #   if the entity also have a parent (Comment or Like), +nil+ if it has no parent
+      #   @return [RelatedEntity] parent entity
+      entity :parent, Entities::RelatedEntity, default: nil
+
+      # never add {RelatedEntity} to xml
+      def to_xml
+        nil
+      end
+    end
+  end
+end

data/lib/diaspora_federation/entities/relayable.rb

@@ -45,20 +45,24 @@ module DiasporaFederation
       #   This signature is required only when federation 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 his subscribers to all others.
-      #
       #   @return [String] parent author signature
       #
-      # @param [Entity] entity the entity in which it is included
-      def self.included(entity)
-        entity.class_eval do
+      # @!attribute [r] parent
+      #   meta information about the parent object
+      #   @return [RelatedEntity] parent entity
+      #
+      # @param [Entity] klass the entity in which it is included
+      def self.included(klass)
+        klass.class_eval do
           property :author, xml_name: :diaspora_handle
           property :guid
           property :parent_guid
           property :author_signature, default: nil
           property :parent_author_signature, default: nil
+          entity :parent, Entities::RelatedEntity
         end
 
-        entity.extend ParseXML
+        klass.extend ParseXML
       end
 
       # Initializes a new relayable Entity with order and additional xml elements
@@ -77,62 +81,59 @@ module DiasporaFederation
       # 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
-        pubkey = DiasporaFederation.callbacks.trigger(:fetch_public_key_by_diaspora_id, author)
-        raise PublicKeyNotFound, "author_signature author=#{author} guid=#{guid}" if pubkey.nil?
-        raise SignatureVerificationFailed, "wrong author_signature" unless verify_signature(pubkey, author_signature)
+        verify_signature(author, :author_signature)
 
-        parent_author_local = DiasporaFederation.callbacks.trigger(:entity_author_is_local?, parent_type, parent_guid)
-        verify_parent_author_signature unless parent_author_local
+        # this happens only on downstream federation
+        verify_signature(parent.author, :parent_author_signature) unless parent.local
       end
 
-      private
-
-      # this happens only on downstream federation
-      def verify_parent_author_signature
-        pubkey = DiasporaFederation.callbacks.trigger(:fetch_author_public_key_by_entity_guid, parent_type, parent_guid)
+      def sender_valid?(sender)
+        sender == author || sender == parent.author
+      end
 
-        raise PublicKeyNotFound, "parent_author_signature parent_guid=#{parent_guid} guid=#{guid}" if pubkey.nil?
-        unless verify_signature(pubkey, parent_author_signature)
-          raise SignatureVerificationFailed, "wrong parent_author_signature parent_guid=#{parent_guid}"
-        end
+      # @return [String] string representation of this object
+      def to_s
+        "#{super}#{":#{parent_type}" if respond_to?(:parent_type)}:#{parent_guid}"
       end
 
+      private
+
       # Check that signature is a correct signature
       #
-      # @param [OpenSSL::PKey::RSA] pubkey An RSA key
-      # @param [String] signature The signature to be verified.
+      # @param [String] author The author of the signature
+      # @param [String] signature_key The signature to be verified
       # @return [Boolean] signature valid
-      def verify_signature(pubkey, signature)
-        if signature.nil?
-          logger.warn "event=verify_signature status=abort reason=no_signature guid=#{guid}"
-          return false
-        end
+      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?
 
-        pubkey.verify(DIGEST, Base64.decode64(signature), signature_data).tap do |valid|
-          logger.info "event=verify_signature status=complete guid=#{guid} valid=#{valid}"
-        end
+        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
 
       # 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
       def sign_with_author
-        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key_by_diaspora_id, author)
-        raise AuthorPrivateKeyNotFound, "author=#{author} guid=#{guid}" if privkey.nil?
+        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key, author)
+        raise AuthorPrivateKeyNotFound, "author=#{author} obj=#{self}" if privkey.nil?
         sign_with_key(privkey).tap do
-          logger.info "event=sign status=complete signature=author_signature author=#{author} guid=#{guid}"
+          logger.info "event=sign status=complete signature=author_signature author=#{author} obj=#{self}"
         end
       end
 
       # sign with parent author key, if the parent author is local (if the private key is found)
       # @return [String] A Base64 encoded signature of #signature_data with key
       def sign_with_parent_author_if_available
-        privkey = DiasporaFederation.callbacks.trigger(
-          :fetch_author_private_key_by_entity_guid, parent_type, parent_guid
-        )
+        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key, parent.author)
         if privkey
           sign_with_key(privkey).tap do
-            logger.info "event=sign status=complete signature=parent_author_signature guid=#{guid}"
+            logger.info "event=sign status=complete signature=parent_author_signature obj=#{self}"
           end
         end
       end
@@ -152,7 +153,7 @@ module DiasporaFederation
       # @return [Hash] sorted xml elements with updated signatures
       def xml_elements
         xml_data = super.merge(additional_xml_elements)
-        Hash[signature_order.map {|element| [element, xml_data[element]] }].tap do |xml_elements|
+        signature_order.map {|element| [element, xml_data[element]] }.to_h.tap do |xml_elements|
           xml_elements[:author_signature] = author_signature || sign_with_author
           xml_elements[:parent_author_signature] = parent_author_signature || sign_with_parent_author_if_available.to_s
         end
@@ -197,19 +198,33 @@ module DiasporaFederation
             end
           end
 
+          fetch_parent(entity_data)
           new(entity_data, xml_order, additional_xml_elements).tap(&:verify_signatures)
         end
+
+        def fetch_parent(data)
+          type = data[:parent_type] || self::PARENT_TYPE
+          guid = data[:parent_guid]
+
+          data[:parent] = DiasporaFederation.callbacks.trigger(:fetch_related_entity, type, guid)
+
+          unless data[:parent]
+            # 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)
+          end
+        end
       end
 
-      # Exception raised when creating the author_signature failes, because the private key was not found
+      # Raised, if creating the author_signature failes, because the private key was not found
       class AuthorPrivateKeyNotFound < RuntimeError
       end
 
-      # Exception raised when verify_signatures fails to verify signatures (no public key found)
+      # Raised, if verify_signatures fails to verify signatures (no public key found)
       class PublicKeyNotFound < RuntimeError
       end
 
-      # Exception raised when verify_signatures fails to verify signatures (signatures are wrong)
+      # Raised, if verify_signatures fails to verify signatures (signatures are wrong)
       class SignatureVerificationFailed < RuntimeError
       end
     end

data/lib/diaspora_federation/entities/relayable_retraction.rb

@@ -53,42 +53,51 @@ module DiasporaFederation
       #   @return [String] target author signature
       property :target_author_signature, 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)
+        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}"
       end
 
       private
 
       # @param [Nokogiri::XML::Element] root_node xml nodes
       # @return [Retraction] instance
-      def self.populate_entity(root_node)
-        super(root_node).to_retraction
+      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
-      private_class_method :populate_entity
 
       # 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 xml_elements
-        target_author = DiasporaFederation.callbacks.trigger(:fetch_entity_author_id_by_guid, target_type, target_guid)
-        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key_by_diaspora_id, author)
+        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key, author)
 
         super.tap do |xml_elements|
-          fill_required_signature(target_author, privkey, xml_elements) unless privkey.nil?
+          fill_required_signature(privkey, xml_elements) unless privkey.nil?
         end
       end
 
-      # @param [String] target_author the author of the entity to retract
       # @param [OpenSSL::PKey::RSA] privkey private key of sender
       # @param [Hash] hash hash given for a signing
-      def fill_required_signature(target_author, privkey, hash)
-        if target_author == author && target_author_signature.nil?
-          hash[:target_author_signature] = SignedRetraction.sign_with_key(privkey, self)
-        elsif target_author != author && parent_author_signature.nil?
+      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
       end
     end

data/lib/diaspora_federation/entities/request.rb

@@ -24,12 +24,16 @@ module DiasporaFederation
         Contact.new(author: author, recipient: recipient)
       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
-      def self.populate_entity(root_node)
+      private_class_method def self.populate_entity(root_node)
         super(root_node).to_contact
       end
-      private_class_method :populate_entity
     end
   end
 end

data/lib/diaspora_federation/entities/reshare.rb

@@ -22,6 +22,11 @@ module DiasporaFederation
       #   has no meaning at the moment
       #   @return [Boolean] public
       property :public, default: true # always true? (we only reshare public posts)
+
+      # @return [String] string representation of this object
+      def to_s
+        "#{super}:#{root_guid}"
+      end
     end
   end
 end

data/lib/diaspora_federation/entities/retraction.rb

@@ -19,6 +19,43 @@ module DiasporaFederation
       #   A string describing the type of the target.
       #   @return [String] target type
       property :target_type, xml_name: :type
+
+      # @!attribute [r] target
+      #   target entity
+      #   @return [RelatedEntity] target entity
+      entity :target, Entities::RelatedEntity
+
+      def sender_valid?(sender)
+        case target_type
+        when "Comment", "Like", "PollParticipation"
+          sender == target.author || sender == target.parent.author
+        else
+          sender == target.author
+        end
+      end
+
+      # @return [String] string representation of this object
+      def to_s
+        "Retraction:#{target_type}:#{target_guid}"
+      end
+
+      # @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] = fetch_target(entity_data[:target_type], entity_data[:target_guid])
+        new(entity_data)
+      end
+
+      private_class_method def self.fetch_target(target_type, target_guid)
+        DiasporaFederation.callbacks.trigger(:fetch_related_entity, target_type, target_guid).tap do |target|
+          raise TargetNotFound, "not found: #{target_type}:#{target_guid}" unless target
+        end
+      end
+
+      # Raised, if the target of the {Retraction} was not found.
+      class TargetNotFound < RuntimeError
+      end
     end
   end
 end