diaspora_federation 0.1.9 → 0.2.0

data/lib/diaspora_federation/salmon/encrypted_slap.rb

@@ -48,32 +48,12 @@ module DiasporaFederation
     # Finally, before decrypting the magic envelope payload, the signature should
     # first be verified.
     #
-    # @example Generating an encrypted Salmon Slap
-    #   author_id = "author@pod.example.tld"
-    #   author_privkey = however_you_retrieve_the_authors_private_key(author_id)
-    #   recipient_pubkey = however_you_retrieve_the_recipients_public_key()
-    #   entity = YourEntity.new(attr: "val")
-    #
-    #   slap_xml = EncryptedSlap.prepare(author_id, author_privkey, entity).generate_xml(recipient_pubkey)
-    #
     # @example Parsing a Salmon Slap
     #   recipient_privkey = however_you_retrieve_the_recipients_private_key()
     #   entity = EncryptedSlap.from_xml(slap_xml, recipient_privkey).payload
     #
     # @deprecated
     class EncryptedSlap < Slap
-      # the author of the slap
-      # @param [String] value the author diaspora* ID
-      attr_writer :author_id
-
-      # the key and iv if it is an encrypted slap
-      # @param [Hash] value hash containing the key and iv
-      attr_writer :cipher_params
-
-      # the prepared encrypted magic envelope xml
-      # @param [Nokogiri::XML::Element] value magic envelope xml
-      attr_writer :magic_envelope_xml
-
       # Creates a {MagicEnvelope} instance from the data within the given XML string
       # containing an encrypted payload.
       #
@@ -87,7 +67,7 @@ module DiasporaFederation
       # @raise [MissingMagicEnvelope] if the +me:env+ element is missing in the XML
       def self.from_xml(slap_xml, privkey)
         raise ArgumentError unless slap_xml.instance_of?(String) && privkey.instance_of?(OpenSSL::PKey::RSA)
-        doc = Nokogiri::XML::Document.parse(slap_xml)
+        doc = Nokogiri::XML(slap_xml)
 
         header_elem = doc.at_xpath("d:diaspora/d:encrypted_header", Slap::NS)
         raise MissingHeader if header_elem.nil?
@@ -98,44 +78,6 @@ module DiasporaFederation
         MagicEnvelope.unenvelop(magic_env_from_doc(doc), sender, cipher_params)
       end
 
-      # Creates an encrypted Salmon Slap.
-      #
-      # @param [String] author_id diaspora* ID of the author
-      # @param [OpenSSL::PKey::RSA] privkey sender private key for signing the magic envelope
-      # @param [Entity] entity payload
-      # @return [EncryptedSlap] encrypted Slap instance
-      # @raise [ArgumentError] if any of the arguments is of the wrong type
-      def self.prepare(author_id, privkey, entity)
-        raise ArgumentError unless author_id.instance_of?(String) &&
-                                   privkey.instance_of?(OpenSSL::PKey::RSA) &&
-                                   entity.is_a?(Entity)
-
-        EncryptedSlap.new.tap do |slap|
-          slap.author_id = author_id
-
-          magic_envelope = MagicEnvelope.new(entity)
-          slap.cipher_params = magic_envelope.encrypt!
-          slap.magic_envelope_xml = magic_envelope.envelop(privkey)
-        end
-      end
-
-      # Creates an encrypted Salmon Slap XML string.
-      #
-      # @param [OpenSSL::PKey::RSA] pubkey recipient public key for encrypting the AES key
-      # @return [String] Salmon XML string
-      # @raise [ArgumentError] if any of the arguments is of the wrong type
-      def generate_xml(pubkey)
-        raise ArgumentError unless pubkey.instance_of?(OpenSSL::PKey::RSA)
-
-        Slap.build_xml do |xml|
-          xml.encrypted_header(encrypted_header(@author_id, @cipher_params, pubkey))
-
-          xml.parent << @magic_envelope_xml
-        end
-      end
-
-      private
-
       # Decrypts and reads the data from the encrypted XML header
       # @param [String] data base64 encoded, encrypted header data
       # @param [OpenSSL::PKey::RSA] privkey private key for decryption
@@ -160,46 +102,7 @@ module DiasporaFederation
         key = JSON.parse(privkey.private_decrypt(Base64.decode64(cipher_header["aes_key"])))
 
         xml = AES.decrypt(cipher_header["ciphertext"], Base64.decode64(key["key"]), Base64.decode64(key["iv"]))
-        Nokogiri::XML::Document.parse(xml).root
-      end
-
-      # Encrypt the header xml with an AES cipher and encrypt the cipher params
-      # with the recipients public_key.
-      # @param [String] author_id diaspora_handle
-      # @param [Hash] envelope_key envelope cipher params
-      # @param [OpenSSL::PKey::RSA] pubkey recipient public_key
-      # @return [String] encrypted base64 encoded header
-      def encrypted_header(author_id, envelope_key, pubkey)
-        data = header_xml(author_id, strict_base64_encode(envelope_key))
-        header_key = AES.generate_key_and_iv
-        ciphertext = AES.encrypt(data, header_key[:key], header_key[:iv])
-
-        json_key = JSON.generate(strict_base64_encode(header_key))
-        encrypted_key = Base64.strict_encode64(pubkey.public_encrypt(json_key))
-
-        json_header = JSON.generate(aes_key: encrypted_key, ciphertext: ciphertext)
-
-        Base64.strict_encode64(json_header)
-      end
-
-      # Generate the header xml string, including the author, aes_key and iv
-      # @param [String] author_id diaspora_handle of the author
-      # @param [Hash] envelope_key { key: "...", iv: "..." } (values in base64)
-      # @return [String] header XML string
-      def header_xml(author_id, envelope_key)
-        @header_xml ||= Nokogiri::XML::Builder.new(encoding: "UTF-8") {|xml|
-          xml.decrypted_header {
-            xml.iv(envelope_key[:iv])
-            xml.aes_key(envelope_key[:key])
-            xml.author_id(author_id)
-          }
-        }.to_xml.strip
-      end
-
-      # @param [Hash] hash { key: "...", iv: "..." }
-      # @return [Hash] encoded hash: { key: "...", iv: "..." }
-      def strict_base64_encode(hash)
-        hash.map {|k, v| [k, Base64.strict_encode64(v)] }.to_h
+        Nokogiri::XML(xml).root
       end
     end
   end

data/lib/diaspora_federation/salmon/magic_envelope.rb

@@ -76,22 +76,6 @@ module DiasporaFederation
         }
       end
 
-      # Encrypts the payload with a new, random AES cipher and returns the cipher
-      # params that were used.
-      #
-      # This must happen after the MagicEnvelope instance was created and before
-      # {MagicEnvelope#envelop} is called.
-      #
-      # @see AES#generate_key_and_iv
-      # @see AES#encrypt
-      #
-      # @return [Hash] AES key and iv. E.g.: { key: "...", iv: "..." }
-      def encrypt!
-        AES.generate_key_and_iv.tap do |key|
-          @payload_data = AES.encrypt(payload_data, key[:key], key[:iv])
-        end
-      end
-
       # Extracts the entity encoded in the magic envelope data, if the signature
       # is valid. If +cipher_params+ is given, also attempts to decrypt the payload first.
       #
@@ -128,7 +112,7 @@ module DiasporaFederation
 
         logger.debug "unenvelop message from #{sender}:\n#{data}"
 
-        new(XmlPayload.unpack(Nokogiri::XML::Document.parse(data).root), sender)
+        new(XmlPayload.unpack(Nokogiri::XML(data).root), sender)
       end
 
       private
@@ -136,7 +120,7 @@ module DiasporaFederation
       # The payload data as string
       # @return [String] payload data
       def payload_data
-        @payload_data ||= XmlPayload.pack(@payload).to_xml.strip.tap do |data|
+        @payload_data ||= payload.to_xml.to_xml.strip.tap do |data|
           logger.debug "send payload:\n#{data}"
         end
       end
@@ -153,7 +137,7 @@ module DiasporaFederation
       def build_xml
         Nokogiri::XML::Builder.new(encoding: "UTF-8") {|xml|
           yield xml
-        }.doc.root
+        }.doc
       end
 
       # Creates the signature for all fields according to specification

data/lib/diaspora_federation/salmon/slap.rb

@@ -13,13 +13,6 @@ module DiasporaFederation
     #     {magic_envelope}
     #   </diaspora>
     #
-    # @example Generating a Salmon Slap
-    #   author_id = "author@pod.example.tld"
-    #   author_privkey = however_you_retrieve_the_authors_private_key(author_id)
-    #   entity = YourEntity.new(attr: "val")
-    #
-    #   slap_xml = Slap.generate_xml(author_id, author_privkey, entity)
-    #
     # @example Parsing a Salmon Slap
     #   entity = Slap.from_xml(slap_xml).payload
     #
@@ -40,7 +33,7 @@ module DiasporaFederation
       # @raise [MissingMagicEnvelope] if the +me:env+ element is missing from the XML
       def self.from_xml(slap_xml)
         raise ArgumentError unless slap_xml.instance_of?(String)
-        doc = Nokogiri::XML::Document.parse(slap_xml)
+        doc = Nokogiri::XML(slap_xml)
 
         author_elem = doc.at_xpath("d:diaspora/d:header/d:author_id", Slap::NS)
         raise MissingAuthor if author_elem.nil? || author_elem.content.empty?
@@ -49,40 +42,6 @@ module DiasporaFederation
         MagicEnvelope.unenvelop(magic_env_from_doc(doc), sender)
       end
 
-      # Creates an unencrypted Salmon Slap and returns the XML string.
-      #
-      # @param [String] author_id diaspora* ID of the author
-      # @param [OpenSSL::PKey::RSA] privkey sender private_key for signing the magic envelope
-      # @param [Entity] entity payload
-      # @return [String] Salmon XML string
-      # @raise [ArgumentError] if any of the arguments is not the correct type
-      def self.generate_xml(author_id, privkey, entity)
-        raise ArgumentError unless author_id.instance_of?(String) &&
-                                   privkey.instance_of?(OpenSSL::PKey::RSA) &&
-                                   entity.is_a?(Entity)
-
-        build_xml do |xml|
-          xml.header {
-            xml.author_id(author_id)
-          }
-
-          xml.parent << MagicEnvelope.new(entity, author_id).envelop(privkey)
-        end
-      end
-
-      # Builds the xml for the Salmon Slap.
-      #
-      # @yield [xml] Invokes the block with the
-      #   {http://www.rubydoc.info/gems/nokogiri/Nokogiri/XML/Builder Nokogiri::XML::Builder}
-      # @return [String] Slap XML
-      def self.build_xml
-        Nokogiri::XML::Builder.new(encoding: "UTF-8") {|xml|
-          xml.diaspora("xmlns" => Salmon::XMLNS, "xmlns:me" => MagicEnvelope::XMLNS) {
-            yield xml
-          }
-        }.to_xml
-      end
-
       # Parses the magic envelop from the document.
       #
       # @param [Nokogiri::XML::Document] doc Salmon XML Document

data/lib/diaspora_federation/salmon/xml_payload.rb

@@ -13,25 +13,6 @@ module DiasporaFederation
     # (The +post+ element is there for historic reasons...)
     # @deprecated
     module XmlPayload
-      # Encapsulates an Entity inside the wrapping xml structure
-      # and returns the XML Object.
-      #
-      # @param [Entity] entity subject
-      # @return [Nokogiri::XML::Element] XML root node
-      # @raise [ArgumentError] if the argument is not an Entity subclass
-      def self.pack(entity)
-        raise ArgumentError, "only instances of DiasporaFederation::Entity allowed" unless entity.is_a?(Entity)
-
-        entity_xml = entity.to_xml
-        doc = entity_xml.document
-        wrap = Nokogiri::XML::Element.new("XML", doc)
-        wrap_post = Nokogiri::XML::Element.new("post", doc)
-        entity_xml.parent = wrap_post
-        wrap << wrap_post
-
-        wrap
-      end
-
       # Extracts the Entity XML from the wrapping XML structure, parses the entity
       # XML and returns a new instance of the Entity that was packed inside the
       # given payload.

data/lib/diaspora_federation/schemas/federation_entities.json

@@ -0,0 +1,379 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "id": "https://diaspora.github.io/diaspora_federation/schemas/federation_entities.json",
+  "oneOf": [
+    {"$ref": "#/definitions/comment"},
+    {"$ref": "#/definitions/like"},
+    {"$ref": "#/definitions/participation"},
+    {"$ref": "#/definitions/poll_participation"},
+    {"$ref": "#/definitions/status_message"},
+    {"$ref": "#/definitions/reshare"},
+    {"$ref": "#/definitions/profile"},
+    {"$ref": "#/definitions/location"},
+    {"$ref": "#/definitions/photo"},
+    {"$ref": "#/definitions/poll"},
+    {"$ref": "#/definitions/poll_answer"}
+  ],
+
+  "definitions": {
+    "signature": {
+      "oneOf" : [
+        {
+          "type": "string",
+          "minLength": 30
+        },
+        {
+          "type": "string",
+          "maxLength": 0,
+          "description": "Allow empty string when no signature is provided"
+        }
+      ]
+    },
+
+    "guid": {
+      "type": "string",
+      "minLength": 16,
+      "maxLength": 255
+    },
+
+    "relayable": {
+      "type": "object",
+      "description": "please don't use this object unless you're defining a new child relayable schema",
+      "properties": {
+        "entity_data": {
+          "type": "object",
+          "properties": {
+            "author": { "type": "string" },
+            "guid": { "$ref": "#/definitions/guid" },
+            "parent_guid": { "$ref": "#/definitions/guid" },
+            "author_signature": { "$ref": "#/definitions/signature" }
+          },
+          "required": [
+            "author", "guid", "parent_guid"
+          ]
+        },
+        "property_order": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      },
+      "required": [
+        "entity_data", "entity_type", "property_order"
+      ]
+    },
+
+    "comment": {
+      "allOf": [
+        {"$ref": "#/definitions/relayable"},
+        {
+          "type": "object",
+          "properties": {
+            "entity_data": {
+              "type": "object",
+              "properties": {
+                "text": { "type": "string" },
+                "created_at": { "type": "string" }
+              },
+              "required": ["text"]
+            },
+            "entity_type": {
+              "type": "string",
+              "pattern": "^comment$"
+            }
+          }
+        }
+      ]
+    },
+
+    "like": {
+      "allOf": [
+        {"$ref": "#/definitions/relayable"},
+        {
+          "type": "object",
+          "properties": {
+            "entity_type": {
+              "type": "string",
+              "pattern": "^like$"
+            },
+            "entity_data": {
+              "type": "object",
+              "properties": {
+                "positive": { "type": "boolean" },
+                "parent_type": { "enum": ["Post", "Comment"] }
+              },
+              "required": ["positive"]
+            }
+          }
+        }
+      ]
+    },
+
+    "participation": {
+      "type": "object",
+      "properties": {
+        "entity_type": {
+          "type": "string",
+          "pattern": "^participation$"
+        },
+        "entity_data": {
+          "type": "object",
+          "properties": {
+            "author": { "type": "string" },
+            "guid": { "$ref": "#/definitions/guid" },
+            "parent_guid": { "$ref": "#/definitions/guid" },
+            "parent_type": {"enum": ["Post"]}
+          }
+        }
+      }
+    },
+
+    "poll_participation": {
+      "allOf": [
+        {"$ref": "#/definitions/relayable"},
+        {
+          "type": "object",
+          "properties": {
+            "entity_type": {
+              "type": "string",
+              "pattern": "^poll_participation$"
+            },
+            "entity_data": {
+              "type": "object",
+              "properties": {
+                "poll_answer_guid": { "$ref": "#/definitions/guid" }
+              },
+              "required": ["poll_answer_guid"]
+            }
+          }
+        }
+      ]
+    },
+
+    "post": {
+      "type": "object",
+      "description": "please don't use this object unless you're defining a new child post schema",
+      "properties": {
+        "entity_data": {
+          "type": "object",
+          "properties": {
+            "guid": { "$ref": "#/definitions/guid" },
+            "public": { "type": "boolean" },
+            "created_at": { "type": "string" },
+            "provider_display_name" : { "type": "string" }
+          },
+          "required": [
+            "guid", "public", "created_at"
+          ]
+        },
+        "required": [
+          "entity_type", "entity_data"
+        ]
+      }
+    },
+
+    "status_message": {
+      "allOf": [
+        {"$ref": "#/definitions/post"},
+        {
+          "type": "object",
+          "properties": {
+            "entity_type": {
+              "type": "string",
+              "pattern": "^status_message$"
+            },
+
+            "entity_data": {
+              "type": "object",
+              "properties": {
+                "text": { "type": "string" },
+
+                "location": {
+                  "oneOf": [
+                    { "$ref": "#/definitions/location" },
+                    { "type": "null" }
+                  ]
+                },
+
+                "poll": {
+                  "oneOf": [
+                    { "$ref": "#/definitions/poll" },
+                    { "type": "null" }
+                  ]
+                },
+
+                "photos": {
+                  "type": ["array", "null"],
+                  "items": { "$ref": "#/definitions/photo" }
+                }
+              },
+
+              "required": ["text"]
+            }
+          }
+        }
+      ]
+    },
+
+    "reshare": {
+      "allOf": [
+        {"$ref": "#/definitions/post"},
+        {
+          "type": "object",
+          "properties": {
+            "entity_type": {
+              "type": "string",
+              "pattern": "^reshare$"
+            },
+
+            "entity_data": {
+              "type": "object",
+              "properties": {
+                "root_author": {"type": "string"},
+                "root_guid": {"$ref": "#/definitions/guid"}
+              },
+
+              "required": ["root_author", "root_guid"]
+            }
+          }
+        }
+      ]
+    },
+
+    "profile": {
+      "type": "object",
+      "properties": {
+        "entity_type": {
+          "type": "string",
+          "pattern": "^profile$"
+        },
+        "entity_data": {
+          "type": "object",
+          "properties": {
+            "first_name": { "type": ["string", "null"] },
+            "last_name": { "type": ["string", "null"] },
+            "gender": { "type": ["string", "null"] },
+            "bio": { "type": ["string", "null"] },
+            "birthday": { "type": ["string", "null"] },
+            "location": { "type": ["string", "null"] },
+            "image_url": { "type": ["string", "null"] },
+            "author": { "type": "string" }
+          },
+          "required": [
+            "author"
+          ]
+        }
+      },
+      "required" :["entity_data", "entity_type"]
+    },
+
+    "photo": {
+      "type": "object",
+      "properties": {
+        "entity_type": {
+          "type": "string",
+          "pattern": "^photo$"
+        },
+        "entity_data": {
+          "type": "object",
+          "properties": {
+            "author": { "type": "string" },
+            "guid": {"$ref": "#/definitions/guid"},
+            "public": {"type": "boolean"},
+            "created_at": {"type": "string"},
+            "remote_photo_path": {"type": "string"},
+            "remote_photo_name": {"type": "string"},
+            "text": {"type": ["null", "string"]},
+            "status_message_guid": {"$ref": "#/definitions/guid"},
+            "width": {"type": "number"},
+            "height": {"type": "number"}
+          },
+          "required": [
+            "author", "guid", "public", "created_at", "remote_photo_path", "remote_photo_name", "width", "height"
+          ]
+        }
+      }
+    },
+
+    "poll_answer": {
+      "type": "object",
+      "properties": {
+        "entity_type": {
+          "type": "string",
+          "pattern": "^poll_answer$"
+        },
+        "entity_data": {
+          "type": "object",
+          "properties": {
+            "guid": { "$ref": "#/definitions/guid" },
+            "answer": { "type": "string" }
+          },
+          "required": [
+            "answer",
+            "guid"
+          ]
+        }
+      }
+    },
+
+    "poll": {
+      "type": "object",
+      "properties": {
+        "entity_type": {
+          "type": "string",
+          "pattern": "^poll$"
+        },
+        "entity_data": {
+          "type": "object",
+          "properties": {
+            "guid": {
+              "$ref": "#/definitions/guid"
+            },
+            "question": {
+              "type": "string"
+            },
+            "poll_answers": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/poll_answer"
+              }
+            }
+          },
+          "required": [
+            "guid",
+            "question",
+            "poll_answers"
+          ]
+        }
+      }
+    },
+
+    "location": {
+      "type": "object",
+      "properties": {
+        "entity_type": {
+          "type": "string",
+          "pattern": "^location$"
+        },
+        "entity_data": {
+          "type": "object",
+          "properties": {
+            "address": {
+              "type": "string"
+            },
+            "lat": {
+              "type": "string"
+            },
+            "lng": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "address",
+            "lat",
+            "lng"
+          ]
+        }
+      }
+    }
+  }
+}

data/lib/diaspora_federation/validators/account_deletion_validator.rb

@@ -4,7 +4,7 @@ module DiasporaFederation
     class AccountDeletionValidator < Validation::Validator
       include Validation
 
-      rule :author, %i(not_empty diaspora_id)
+      rule :author, %i[not_empty diaspora_id]
     end
   end
 end

data/lib/diaspora_federation/validators/account_migration_validator.rb

@@ -0,0 +1,12 @@
+module DiasporaFederation
+  module Validators
+    # This validates a {Entities::AccountMigration}.
+    class AccountMigrationValidator < Validation::Validator
+      include Validation
+
+      rule :author, %i[not_empty diaspora_id]
+
+      rule :profile, :not_nil
+    end
+  end
+end

data/lib/diaspora_federation/validators/contact_validator.rb

@@ -4,8 +4,8 @@ module DiasporaFederation
     class ContactValidator < Validation::Validator
       include Validation
 
-      rule :author, %i(not_empty diaspora_id)
-      rule :recipient, %i(not_empty diaspora_id)
+      rule :author, %i[not_empty diaspora_id]
+      rule :recipient, %i[not_empty diaspora_id]
       rule :following, :boolean
       rule :sharing, :boolean
     end