vaas 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d825f4cbd3edbbdf6d391ad3dcc1257b30c3df7c9a2e53f1caae99bc57036bf3
-  data.tar.gz: 29ef4d52405ef1381b63a9f68e014446f9fadc58bc16bd810bbea2f75066ccc6
+  metadata.gz: a05b70f5292bec90b8e2155e46351bb419e09cfa9c2ab2adc7a9b7518c2461bd
+  data.tar.gz: f35d1a3472a24c1361e643d58fafd37b20d2cb9aa3cc37217e650a9e295537d4
 SHA512:
-  metadata.gz: fed95ea1cf2622afabbd5d85b9fa884e02a8a4b009f8f04711d70c7a23248fb7598b433341e8f7f997ddecdbdecdbf4802c17eb88bfac27728843e443702a0bd
-  data.tar.gz: 9a796c1a3c49e384db42d727370caca6fcd8b72f16b5f64fe667fa409f2833695d622949e8c816ce1731e50812116379d14c7c542c29d4be890108eb9ab6b805
+  metadata.gz: 86dacfaee9ab76cea8301ebc704a9e6e46001c45c7ac6d9ef8c9b77cf3fcf2b759300087205bfe02ae2952b4bc9ff88858ea68426b7231768a37597fb5b36322
+  data.tar.gz: df21c2cfd66cdca06ed715dc89fa4f39d3df1e54685b9f8a86be4ec149b4ee2659dbaf3325ae2bdc7baca15b8e16c6356d6a3637fdfc859be5b0aaafe1dfceb9

data/README.md

@@ -54,10 +54,10 @@ token = authenticator.get_token
 Verdict Request for SHA256:
 ```ruby
 Async do
-  Async { vaas.connect(token) }.wait
+  vaas.connect(token)
   sha256 = "275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f"
-  verdict = vaas.for_sha256(sha256)
-ensure
+  verdict = vaas.for_sha256(sha256) # starts a task
+  puts verdict.wait.verdict # await task
   vaas.close
 end
 ```
@@ -65,10 +65,10 @@ end
 Verdict Request for a file:
 ```ruby
 Async do
-  Async { vaas.connect(token) }.wait
+  vaas.connect(token)
   path = "/path/to/file"
-  verdict = vaas.for_file(path)
-ensure
+  verdict = vaas.for_file(path) # starts a task
+  puts verdict.wait.verdict # await task
   vaas.close
 end
 ```
@@ -76,10 +76,10 @@ end
 Verdict Request for a URL:
 ```ruby
 Async do
-  Async { vaas.connect(token) }.wait
+  vaas.connect(token)
   url = "https://www.gdatasoftware.com/oem/verdict-as-a-service"
-  verdict = vaas.for_url(url)
-ensure
+  verdict = vaas.for_url(url) # starts a task
+  puts verdict.wait.verdict # await task
   vaas.close
 end
 ```

data/examples/example_with_reconnect.rb

@@ -4,7 +4,7 @@ require 'vaas/vaas_main'
 
 CLIENT_ID = ENV.fetch('CLIENT_ID')
 CLIENT_SECRET = ENV.fetch('CLIENT_SECRET')
-PATH = ENV.fetch('PATH')
+URL = ENV.fetch('URL')
 
 def main
   authenticator = VAAS::ClientCredentialsGrantAuthenticator.new(
@@ -18,21 +18,18 @@ def main
   token = authenticator.get_token
 
   Async do
-    # wait to connect and authenticate
-    Async { vaas.connect(token) }.wait
+    vaas.connect(token)
 
     # reconnect if connection closed
     begin
-      verdict = vaas.for_file(PATH)
+      verdict = vaas.for_url(URL)
     rescue VAAS::VaasConnectionClosedError
       token = authenticator.get_token
-      Async { vaas.connect(token) }.wait
+      vaas.connect(token)
       retry
     end
+    puts "Verdict #{verdict.wait.sha256} is detected as #{verdict.wait.verdict}"
 
-    puts "Verdict #{verdict.sha256} is detected as #{verdict.verdict}"
-
-  ensure
     vaas.close
   end
 end

data/examples/simple_example.rb

@@ -4,7 +4,7 @@ require 'vaas/vaas_main'
 
 CLIENT_ID = ENV.fetch('CLIENT_ID')
 CLIENT_SECRET = ENV.fetch('CLIENT_SECRET')
-PATH = ENV.fetch('PATH')
+URL = ENV.fetch('URL')
 
 def main
   authenticator = VAAS::ClientCredentialsGrantAuthenticator.new(
@@ -18,15 +18,11 @@ def main
   token = authenticator.get_token
 
   Async do
-    # wait to connect and authenticate
-    Async { vaas.connect(token) }.wait
+    vaas.connect(token)
 
-    # simple method to get the verdict of a file
-    verdict = vaas.for_file(PATH)
+    verdict = vaas.for_url(URL)
+    puts "Verdict #{verdict.wait.sha256} is detected as #{verdict.wait.verdict}"
 
-    puts "Verdict #{verdict.sha256} is detected as #{verdict.verdict}"
-
-  ensure
     vaas.close
   end
 end

data/lib/vaas/vaas_main.rb

@@ -14,125 +14,174 @@ require_relative 'vaas_errors'
 module VAAS
   class VaasMain
 
-    attr_accessor :session_id, :websocket, :url
-
-    def initialize(url="wss://gateway-vaas.gdatasecurity.de")
+    def initialize(url = "wss://gateway-vaas.gdatasecurity.de", timeout = 600)
       @url = url
+      @timeout = timeout
+      @requests = {}
     end
 
     def connect(token)
       # connect to endpoint
-      endpoint = Async::HTTP::Endpoint.parse(url, alpn_protocols: Async::HTTP::Protocol::HTTP1.names)
-      self.websocket = Async::WebSocket::Client.connect(endpoint)
+      endpoint = Async::HTTP::Endpoint.parse(@url, alpn_protocols: Async::HTTP::Protocol::HTTP1.names)
+      @websocket = Async::WebSocket::Client.connect(endpoint)
+
+      read_messages
+      keep_alive
 
       # send authentication request
-      auth_request = JSON.generate({:kind => "AuthRequest", :token => token})
-      websocket.write(auth_request)
-
-      # receive authentication message
-      while message = websocket.read
-        message = JSON.parse(message)
-        if message['success'] == true
-          self.session_id = message['session_id']
-          break
-        else
-          raise VaasAuthenticationError
+      auth_task = Async do |task|
+        task.with_timeout(@timeout) do
+          @auth_notification = Async::Notification.new
+          auth_request = JSON.generate({:kind => "AuthRequest", :token => token})
+          @websocket.write(auth_request)
+          @websocket.flush
+          @auth_notification.wait
+        rescue Async::TimeoutError
+          close
+          raise VaasTimeoutError
         end
       end
-    end
 
-    def get_authenticated_websocket
-      raise VaasInvalidStateError unless websocket
-      raise VaasInvalidStateError, "connect() was not awaited" unless session_id
-      raise VaasConnectionClosedError if websocket.closed?
-      websocket
+      message = auth_task.wait
+      raise VaasAuthenticationError if message['success'] == false
+      @session_id = message['session_id']
     end
 
-    def close
-        websocket&.close
+    def keep_alive
+      @keep_alive_task = Async do
+        until @websocket.closed?
+          sleep 10
+          @websocket.send_ping
+          @websocket.flush
+        end
+      end
     end
 
-    def __for_sha256(sha256, guid)
-      # send verdict request with sha256
-      websocket = get_authenticated_websocket
-      guid = guid || SecureRandom.uuid.to_s
-      verdict_request =  JSON.generate({:kind => "VerdictRequest",
-                                        :session_id => session_id,
-                                        :sha256 => sha256,
-                                        :guid => guid})
-      websocket.write(verdict_request)
-
-      # receive verdict message
-      while message = websocket.read
-        message = JSON.parse(message)
-        if message['kind'] == "VerdictResponse"
-          return message
+    def read_messages
+      @read_task = Async do |task|
+        task.with_timeout(@timeout) do
+          while message = @websocket.read
+            message = JSON.parse(message)
+            if message['kind'] == "AuthResponse"
+              @auth_notification.signal(message)
+            elsif message['kind'] == "VerdictResponse"
+              @requests[message['guid']].signal(message)
+            end
+          end
+        rescue Async::TimeoutError
+          close
+          raise VaasTimeoutError
         end
       end
     end
 
-    def for_sha256(sha256, guid = nil)
-      response = __for_sha256(sha256, guid)
-      VaasVerdict.new(response)
+    def get_authenticated_websocket
+      raise VaasInvalidStateError unless @websocket
+      raise VaasInvalidStateError, "connect() was not awaited" unless @session_id
+      raise VaasConnectionClosedError if @websocket.closed?
+      @websocket
     end
 
-    def for_file(path, guid = nil)
-      # get sha256 of file and send verdict request
-      sha256 = Digest::SHA256.file(path).hexdigest
-      response = __for_sha256(sha256, guid)
+    def close
+      @keep_alive_task&.stop
+      @read_task&.stop
+      @websocket&.close
+    end
 
-      # upload file if verdict is unknown
-      if response['verdict'] == 'Unknown'
-        upload(response, path)
-      else
-        return VaasVerdict.new(response)
+    def for_sha256(sha256)
+      Async do |task|
+        task.with_timeout(@timeout) do
+          verdict_notification = Async::Notification.new
+          guid = SecureRandom.uuid.to_s
+          websocket = get_authenticated_websocket
+          verdict_request =  JSON.generate({:kind => "VerdictRequest",
+                                            :session_id => @session_id,
+                                            :sha256 => sha256,
+                                            :guid => guid})
+          @requests[guid] = verdict_notification
+          websocket.write(verdict_request)
+          websocket.flush
+          VaasVerdict.new(verdict_notification.wait)
+        rescue Async::TimeoutError
+          close
+          raise VaasTimeoutError
+        end
       end
+    end
 
-      # receive verdict message of uploaded file
-      while message = websocket.read
-        message = JSON.parse(message)
-        if message['kind'] == "VerdictResponse" && message['verdict'] != "Unknown"
-          return VaasVerdict.new(message)
+    def for_url(url)
+      Async do |task|
+        task.with_timeout(@timeout) do
+          verdict_notification = Async::Notification.new
+          guid = SecureRandom.uuid.to_s
+          websocket = get_authenticated_websocket
+          verdict_request =  JSON.generate({:kind => "VerdictRequestForUrl",
+                                            :session_id => @session_id,
+                                            :url => url,
+                                            :guid => guid})
+          @requests[guid] = verdict_notification
+          websocket.write(verdict_request)
+          websocket.flush
+          VaasVerdict.new(verdict_notification.wait)
+        rescue Async::TimeoutError
+          close
+          raise VaasTimeoutError
         end
       end
     end
 
-    def for_url(url, guid = nil)
-      #send verdict request with url
-      websocket = get_authenticated_websocket
-      guid = guid || SecureRandom.uuid.to_s
-      url = URI(url).to_s
-      verdict_request =  JSON.generate({:kind => "VerdictRequestForUrl",
-                                        :session_id => session_id,
-                                        :guid => guid,
-                                        :url => url})
-      websocket.write(verdict_request)
-
-      # receive verdict message
-      while message = websocket.read
-        message = JSON.parse(message)
-        if message['kind'] == "VerdictResponse"
-          return VaasVerdict.new(message)
+    def for_file(path)
+      Async do |task|
+        task.with_timeout(@timeout) do
+          sha256 = Digest::SHA256.file(path).hexdigest
+          verdict_notification = Async::Notification.new
+          guid = SecureRandom.uuid.to_s
+          websocket = get_authenticated_websocket
+          verdict_request =  JSON.generate({:kind => "VerdictRequest",
+                                            :session_id => @session_id,
+                                            :sha256 => sha256,
+                                            :guid => guid})
+          @requests[guid] = verdict_notification
+          websocket.write(verdict_request)
+          websocket.flush
+          message = verdict_notification.wait
+
+          if message['verdict'] == "Unknown"
+            upload_notification = Async::Notification.new
+            @requests[guid] = upload_notification
+            upload(message, path)
+            VaasVerdict.new(upload_notification.wait)
+          else
+            VaasVerdict.new(message)
+          end
+        rescue Async::TimeoutError
+          close
+          raise VaasTimeoutError
         end
       end
     end
 
-    def upload (message, path)
-      token = message['upload_token']
-      url = message['url']
+    def upload(message, path)
+      Async do |task|
+        task.with_timeout(@timeout) do
+          token = message['upload_token']
+          url = message['url']
 
-      Async do
-        client = Async::HTTP::Internet.new
+          client = Async::HTTP::Internet.new
 
-        header = [['authorization', token]]
-        body = Protocol::HTTP::Body::File.open(File.join(path))
+          header = [['authorization', token]]
+          body = Protocol::HTTP::Body::File.open(File.join(path))
 
-        client.put(url, header, body).read
+          response = client.put(url, header, body)
+          response.read
 
-      rescue => e
-        raise VaasUploadError, e
-      ensure
-        client&.close
+          raise VaasUploadError, "Upload failed with code: #{response.status}" if response.status != 200
+        rescue Async::TimeoutError
+          close
+          raise VaasTimeoutError, "Upload timed out"
+        ensure
+          client&.close
+        end
       end
     end
   end

data/lib/vaas/version.rb

@@ -1,3 +1,3 @@
 module VAAS
-  VERSION = '1.0.1'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vaas
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Allie Weitenkamp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-19 00:00:00.000000000 Z
+date: 2023-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -91,7 +91,6 @@ files:
 - ".vscode/launch.json"
 - Gemfile
 - README.md
-- examples/example_with_lists.rb
 - examples/example_with_reconnect.rb
 - examples/simple_example.rb
 - lib/vaas.rb

data/examples/example_with_lists.rb

@@ -1,37 +0,0 @@
-require 'async'
-require 'vaas/client_credentials_grant_authenticator'
-require 'vaas/vaas_main'
-
-CLIENT_ID = ENV.fetch('CLIENT_ID')
-CLIENT_SECRET = ENV.fetch('CLIENT_SECRET')
-PATHS = ENV.fetch('PATHS')
-
-def main
-  authenticator = VAAS::ClientCredentialsGrantAuthenticator.new(
-    CLIENT_ID,
-    CLIENT_SECRET,
-    "https://keycloak-vaas.gdatasecurity.de/realms/vaas/protocol/openid-connect/token"
-  )
-
-  # create a vaas object and get a token to authenticate
-  vaas = VAAS::VaasMain.new
-  token = authenticator.get_token
-
-  Async do
-    # wait to connect and authenticate
-    Async { vaas.connect(token) }.wait
-
-    # simple loop to get the verdict of a list of files
-    PATHS.each do |file|
-      verdict = vaas.for_file(file)
-      puts "Verdict #{verdict.sha256} is detected as #{verdict.verdict}"
-    end
-
-  ensure
-    vaas.close
-  end
-end
-
-if __FILE__  == $0
-  main
-end