diaspora-vines 0.1.26 → 0.1.27

data/lib/vines/stream/server/auth_method.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class AuthMethod < State
+        VERIFY, VALID_TYPE, INVALID_TYPE = %w[verify valid invalid].map {|t| t.freeze }
+        STARTTLS, RESULT, FROM, TO = %w[starttls result from to].map {|s| s.freeze }
+        PROCEED  = %Q{<proceed xmlns="#{NAMESPACES[:tls]}"/>}.freeze
+        FAILURE  = %Q{<failure xmlns="#{NAMESPACES[:tls]}"/>}.freeze
+
+        def initialize(stream, success=AuthRestart)
+          super
+        end
+
+        def node(node)
+          if dialback_verify?(node)
+            id, from, to = %w[id from to].map {|a| node[a] }
+            key = node.text
+            outbound_stream = stream.router.stream_by_id(id)
+
+            unless outbound_stream && outbound_stream.state.is_a?(Stream::Server::Outbound::AuthDialbackResult)
+              stream.write(%Q{<db:verify from="#{to}" to=#{from} id=#{id} type="error"><error type="cancel"><item-not-found xmlns="#{NAMESPACES[:stanzas]}" /></error></db:verify>})
+              return
+            end
+
+            secret = outbound_stream.state.dialback_secret
+            type = Kit.dialback_key(secret, from, to, id) == key ? VALID_TYPE : INVALID_TYPE
+            stream.write(%Q{<db:verify from="#{to}" to="#{from}" id="#{id}" type="#{type}" />})
+            stream.close_connection_after_writing
+          elsif starttls?(node)
+            if stream.encrypt?
+              stream.write(PROCEED)
+              stream.encrypt
+              stream.reset
+              advance
+            else
+              stream.write(FAILURE)
+              stream.write('</stream:stream>')
+              stream.close_connection_after_writing
+            end
+          elsif dialback_result?(node)
+            begin
+              Vines::Stream::Server.start(stream.config, node[FROM], node[TO], true) do |authoritative|
+                if authoritative
+                  authoritative.write("<db:verify from='#{node[TO]}' id='#{stream.id}' to='#{node[FROM]}'>#{node.text}</db:verify>")
+                end
+              end
+              # We need to be discoverable for the dialback connection
+              stream.router << stream
+            rescue StanzaErrors::RemoteServerNotFound => e
+              stream.write("<db:result from='#{node[TO]}' to='#{node[FROM]}' " \
+                           "type='error'><error type='cancel'><item-not-found " \
+                           "xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/></error></db:result>")
+              stream.close_connection_after_writing
+            end
+          else
+            raise StreamErrors::NotAuthorized
+          end
+        end
+
+        private
+
+        def starttls?(node)
+          node.name == STARTTLS && namespace(node) == NAMESPACES[:tls]
+        end
+
+        def dialback_verify?(node)
+          node.name == VERIFY && namespace(node) == NAMESPACES[:legacy_dialback]
+        end
+
+        def dialback_result?(node)
+          node.name == RESULT && namespace(node) == NAMESPACES[:legacy_dialback]
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/auth_restart.rb

@@ -3,10 +3,36 @@
 module Vines
   class Stream
     class Server
-      class AuthRestart < Client::AuthRestart
+      class AuthRestart < State
         def initialize(stream, success=Auth)
           super
         end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless stream?(node)
+          stream.start(node)
+          doc = Document.new
+          features = doc.create_element('stream:features')
+          if stream.dialback_retry?
+            if stream.vhost.force_s2s_encryption?
+              stream.close_connection
+              return
+            end
+            @success = AuthMethod
+            features << doc.create_element('dialback') do |db|
+              db.default_namespace = NAMESPACES[:dialback]
+            end
+          else
+            features << doc.create_element('mechanisms') do |parent|
+              parent.default_namespace = NAMESPACES[:sasl]
+              stream.authentication_mechanisms.each do |name|
+                parent << doc.create_element('mechanism', name)
+              end
+            end
+          end
+          stream.write(features)
+          advance
+        end
       end
     end
   end

data/lib/vines/stream/server/outbound/auth.rb

@@ -5,24 +5,58 @@ module Vines
     class Server
       class Outbound
         class Auth < State
-          NS = NAMESPACES[:sasl]
+          REQUIRED = 'required'.freeze
+          FEATURES = 'features'.freeze
 
-          def initialize(stream, success=AuthResult)
+          def initialize(stream, success=AuthDialbackResult)
             super
           end
 
           def node(node)
-            raise StreamErrors::NotAuthorized unless external?(node)
-            authzid = Base64.strict_encode64(stream.domain)
-            stream.write(%Q{<auth xmlns="#{NS}" mechanism="EXTERNAL">#{authzid}</auth>})
-            advance
+            # We have to remember tls_require for
+            # closing or restarting the stream
+            stream.outbound_tls_required(tls_required?(node))
+
+            if stream.dialback_verify_key?
+              @success = Authoritative
+              stream.callback!
+              advance
+            elsif tls?(node)
+              @success = TLSResult
+              stream.write("<starttls xmlns='#{NAMESPACES[:tls]}'/>")
+              advance
+            elsif dialback?(node)
+              secret = Kit.auth_token
+              dialback_key = Kit.dialback_key(secret, stream.remote_domain, stream.domain, stream.id)
+              stream.write("<db:result xmlns:db='#{NAMESPACES[:legacy_dialback]}' " \
+                "from='#{stream.domain}' to='#{stream.remote_domain}'>#{dialback_key}</db:result>")
+              advance
+              stream.router << stream # We need to be discoverable for the dialback connection
+              stream.state.dialback_secret = secret
+            else
+              raise StreamErrors::NotAuthorized
+            end
           end
 
           private
 
-          def external?(node)
-            external = node.xpath("ns:mechanisms/ns:mechanism[text()='EXTERNAL']", 'ns' => NS).any?
-            node.name == 'features' && namespace(node) == NAMESPACES[:stream] && external
+          def tls_required?(node)
+            child = node.xpath('ns:starttls', 'ns' => NAMESPACES[:tls]).children.first
+            child && child.name == REQUIRED
+          end
+
+          def dialback?(node)
+            dialback = node.xpath('ns:dialback', 'ns' => NAMESPACES[:dialback]).any?
+            features?(node) && dialback
+          end
+
+          def tls?(node)
+            tls = node.xpath('ns:starttls', 'ns' => NAMESPACES[:tls]).any?
+            features?(node) && tls
+          end
+
+          def features?(node)
+            node.name == FEATURES && namespace(node) == NAMESPACES[:stream]
           end
         end
       end

data/lib/vines/stream/server/outbound/auth_dialback_result.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class AuthDialbackResult < State
+          RESULT, VALID, INVALID, TYPE = %w[result valid invalid type].map {|s| s.freeze }
+
+          attr_accessor :dialback_secret
+
+          def initialize(stream, success=Ready)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless result?(node)
+
+            case node[TYPE]
+            when VALID
+              advance
+              stream.notify_connected
+            when INVALID
+              stream.close_connection
+            else
+              raise StreamErrors::NotAuthorized
+            end
+          end
+
+          private
+
+          def result?(node)
+            node.name == RESULT && namespace(node) == NAMESPACES[:legacy_dialback]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/outbound/auth_external.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class AuthExternal < State
+          def initialize(stream, success=AuthExternalResult)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless external?(node)
+            authzid = Base64.strict_encode64(stream.domain)
+            stream.write(%Q{<auth xmlns="#{NAMESPACES[:sasl]}" mechanism="EXTERNAL">#{authzid}</auth>})
+            advance
+          end
+
+          private
+
+          def external?(node)
+            external = node.xpath("ns:mechanisms/ns:mechanism[text()='EXTERNAL']", 'ns' => NAMESPACES[:sasl]).any?
+            features?(node) && external
+          end
+
+          def features?(node)
+            node.name == 'features' && namespace(node) == NAMESPACES[:stream]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/outbound/{auth_result.rb → auth_external_result.rb}

@@ -4,7 +4,7 @@ module Vines
   class Stream
     class Server
       class Outbound
-        class AuthResult < State
+        class AuthExternalResult < State
           SUCCESS = 'success'.freeze
           FAILURE = 'failure'.freeze
 

data/lib/vines/stream/server/outbound/auth_restart.rb

@@ -5,12 +5,19 @@ module Vines
     class Server
       class Outbound
         class AuthRestart < State
-          def initialize(stream, success=Auth)
+          def initialize(stream, success=AuthExternal)
             super
           end
 
           def node(node)
             raise StreamErrors::NotAuthorized unless stream?(node)
+            if stream.dialback_retry?
+              if stream.outbound_tls_required?
+                stream.close_connection
+                return
+              end
+              @success = Auth
+            end
             advance
           end
         end

data/lib/vines/stream/server/outbound/authoritative.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class Authoritative < State
+          VALID, INVALID, ERROR, TYPE = %w[valid invalid error type]
+          VERIFY, ID, FROM, TO = %w[verify id from to].map {|s| s.freeze }
+
+          def initialize(stream, success=nil)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless authoritative?(node)
+
+            case node[TYPE]
+            when VALID
+              @inbound.write("<db:result xmlns:db='#{NAMESPACES[:legacy_dialback]}' " \
+                "from='#{node[TO]}' to='#{node[FROM]}' type='#{node[TYPE]}'/>")
+              @inbound.advance(Server::Ready.new(@inbound))
+              @inbound.notify_connected
+            when INVALID
+              @inbound.write("<db:result xmlns:db='#{NAMESPACES[:legacy_dialback]}' " \
+                "from='#{node[TO]}' to='#{node[FROM]}' type='#{node[TYPE]}'/>")
+              @inbound.close_connection_after_writing
+            else
+              @inbound.write("<db:result xmlns:db='#{NAMESPACES[:legacy_dialback]}' " \
+                "from='#{node[TO]}' to='#{node[FROM]}' type='#{ERROR}'>" \
+                "<error type='cancel'><item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" \
+                "</error></db:result>")
+              @inbound.close_connection_after_writing
+            end
+            stream.close_connection
+          end
+
+          private
+
+          def authoritative?(node)
+            @inbound = stream.router.stream_by_id(node[ID])
+            node.name == VERIFY && namespace(node) == NAMESPACES[:legacy_dialback] && !@inbound.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/outbound/start.rb

@@ -5,7 +5,7 @@ module Vines
     class Server
       class Outbound
         class Start < State
-          def initialize(stream, success=TLS)
+          def initialize(stream, success=Auth)
             super
           end
 

data/lib/vines/stream/server/start.rb

@@ -3,10 +3,37 @@
 module Vines
   class Stream
     class Server
-      class Start < Client::Start
-        def initialize(stream, success=TLS)
+      class Start < State
+        FROM = "from".freeze
+
+        def initialize(stream, success=AuthMethod)
           super
         end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless stream?(node)
+          stream.start(node)
+          doc = Document.new
+          features = doc.create_element('stream:features', 'xmlns:stream' => NAMESPACES[:stream]) do |el|
+            unless stream.dialback_retry?
+              el << doc.create_element('starttls') do |tls|
+                tls.default_namespace = NAMESPACES[:tls]
+                tls << doc.create_element('required') if force_s2s_encryption?
+              end
+            end
+            el << doc.create_element('dialback') do |db|
+              db.default_namespace = NAMESPACES[:dialback]
+            end
+          end
+          stream.write(features)
+          advance
+        end
+
+        private
+
+        def force_s2s_encryption?
+          stream.vhost.force_s2s_encryption?
+        end
       end
     end
   end

data/lib/vines/stream/state.rb

@@ -8,12 +8,10 @@ module Vines
     class State
       include Nokogiri::XML
       include Vines::Log
+      include Vines::Node
 
       attr_accessor :stream
 
-      BODY   = 'body'.freeze
-      STREAM = 'stream'.freeze
-
       def initialize(stream, success=nil)
         @stream, @success = stream, success
       end
@@ -40,21 +38,9 @@ module Vines
         stream.advance(@success.new(stream))
       end
 
-      def stream?(node)
-        node.name == STREAM && namespace(node) == NAMESPACES[:stream]
-      end
-
-      def body?(node)
-        node.name == BODY && namespace(node) == NAMESPACES[:http_bind]
-      end
-
-      def namespace(node)
-        node.namespace ? node.namespace.href : nil
-      end
-
       def to_stanza(node)
-        Stanza.from_node(node, stream)
+        super(node, stream)
       end
     end
   end
-end
+end

data/lib/vines/version.rb

@@ -2,5 +2,5 @@
 
 module Vines
   # vines forked version 0.4.10
-  VERSION = '0.1.26'
+  VERSION = '0.1.27'
 end

data/test/storage/sql_test.rb

@@ -110,6 +110,18 @@ describe Vines::Storage::Sql do
     end
   end
 
+  def test_find_avatar_by_jid
+    fibered do
+      db = storage
+
+      assert_nil db.find_avatar_by_jid("")
+      assert_nil db.find_avatar_by_jid("someone@inthe.void")
+
+      image_path = db.find_avatar_by_jid(@test_user[:jid])
+      assert_equal @test_user[:image_url], image_path
+    end
+  end
+
   def test_find_messages
     fibered do
       db = storage
@@ -185,6 +197,10 @@ describe Vines::Storage::Sql do
       assert (user != nil), "no user found"
       assert_equal @test_user[:name], user.name
 
+      user.roster do |contact|
+        assert_equal "Harry Hirsch", contact.name
+      end
+
       user = db.find_user(Vines::JID.new(@test_user[:jid]))
       assert (user != nil), "no user found"
       assert_equal @test_user[:name], user.name