Annonce

Réduire
Aucune annonce.

Installation pas à pas d’OpenVas: le scanner de vulnérabilités gratuit et open source

Réduire
X
  • Filtre
  • Heure
  • Afficher
Tout nettoyer
nouveaux messages

  • Tutoriel Installation pas à pas d’OpenVas: le scanner de vulnérabilités gratuit et open source

    Installation d’OpenVas – pas à pas


    Force est de constater que beaucoup d’utilisateurs ont du mal à mettre en place certains modules complémentaires ou distribution intelligente sur Kali Linux. Ceci venant du fait qu’elles sont soient très peu utilisé de par les soucis rencontrés lors de l’installation ou méconnu quand à leur utilisation et surtout leurs possibilités de pentest.

    A fin de clarifier ce petit oubli j’ai décidé en m’aidant de ressources trouvés directement sur le site de l’auteur de ce petit bijou de scanner de vulnérabilité. Je ne reviendrais pas sur le fonctionnement d’un tel outil qui est disponible directement sur le site Hackademics mais je vais vous le présentez et vous faire un tutoriel d’installation complète ensemble screen by screen en se basant sur la dernière distribution de Kali 2.0.

    Merci aux lecteurs assidu de mes notes, articles et tutoriels diverses, je me fais plus rare sur la toile, j’ai fermé 2 NDD personnelle et ne participe plus sur beaucoup de forums, ceci du essentiellement à mon travail en hôpitaux et à ma reprise de mes activités sportives ne me laissant que quelques heures sur internet que je passe à étudier (toujours) et à jouer aux échecs sur des forums en ligne.

    Présentation (Ressource Wikipédia, Ubuntu)

    OpenVAS, (acronyme de Open source Vulnerability Assessment Scanner, anciennement GNessUs), est un fork sous licence GNU GPL du scanner de vulnérabilité Nessus dont le but est de permettre un développement libre de l’outil qui est maintenant sous licence propriétaire.
    Vous l’avez compris, il permet de vérifier automatiquement et surtout tester les vulnérabilités des applications concernant une plateforme web et ceci gratuitement, c’est un logiciel libre open source. Téléchargeable sur le site : http://www.openvas.org/
    OpenVAS est capable de scanner un équipement (machine ou matériel réseau), un ensemble d'équipements (à partir d'un fichier ou d'une plage IP) ou encore un réseau entier.
    Le résultat du scan fournira :
    • la liste des vulnérabilités par niveaux de criticité,
    • une description des vulnérabilités,
    • et surtout la méthode ou un lien pour solutionner le problème.

    Le scanner OpenVAS utilise plus de 47.000 Réseau vulnérabilité Tests (NVTs) de Juin 2016.

    Vous avez installé Kali Linux maintenant voyons OpenVAS.

    Installation

    Commençons par installer OpenVAS et exécuter les commandes suivantes dans une session de terminal pour télécharger et installer OpenVAS:

    Code:
    apt-get install openvas 
    openvas-setup
    En fonction de votre vitesse de connexion, cela peut prendre un certain temps pour terminer.
    Lorsque le processus d'installation est terminée, vous sera présenté un long mot de passe sur la dernière ligne de la console. Ce mot de passe est utilisé pour accéder à l'interface web OpenVAS donc vous devez l'enregistrer quelque part et le changer après la première connexion.


    Lorsque le processus d'installation est terminée, le OpenVAS OpenVAS gestionnaire, scanner et services sont à l'écoute sur le port 9390, 9391, 9392 et sur le port 80. Vous pouvez utiliser la commande netstat suivante pour vérifier si ces services sont à l'écoute:
    Code:
    netstat –antp

    Netstat –antp commandes
    -a tous
    -n montre les IP au lieu des noms d’hôte
    -t montrent seulement les connections TCP
    -p montre les process id/name

    Mettre en route et utiliser OpenVAS

    Si les services d’OpenVAS ne sont pas en cours d'exécution utiliser la commande suivante pour démarrer ces services:

    Code:
    openvas-start
    Puis ouvrir le navigateur afin de se connecter à l'interface Web et le pointer vers:

    https://127.0.0.1:9392


    Acceptez le certificat SSL auto-signé et connectez-vous avec l'utilisateur 'admin' et le mot de passe généré au cours du processus d'installation. L'interface Web après la connexion devrait ressembler à ceci:


    Démarrer un scan avec OpenVAS est très facile et simple. Il suffit d'entrer le nom d'hôte ou l'adresse IP de la cible dans le champ de démarrage rapide et appuyez sur le bouton «Start Scan». Assurez-vous que les cibles d'analyse avec OpenVAS soit propriétaire par vous-même physiquement ou avoir (écrit) l'autorisation de numériser un scan. Attention comme beaucoup de scanner, OpenVAS scanner de vulnérabilité va générer un trafic réseau dense qui peut conduire à des accidents ou DOS.
    Lorsque l'analyse est terminée, cliquez sur la page des rapports dans le menu Gestion de la numérisation et jeter un œil à un aperçu des résultats de l'analyse.

    Maintenant vous avez un scanner gratuit, fiable et surtout vous permettant de faire des analyses complètes de vos applications web.
    Dernière modification par DreAmuS, 22 août 2016, 18h47.

  • #2
    Bonjour,

    tout d'abord merci pour ce tuto !
    Je débute et malheureusement j'ai un souci lors de l'exécution d'une tâche OpenVAS sous Metasploit :

    Code:
    root@kali:~# msfconsole
    
    msf > load openvas
    
    msf > openvas_connect admin password 127.0.0.1 9390 ok
    [ *] Connecting to OpenVAS instance at 127.0.0.1:9390 with username admin...
    [+] OpenVAS connection successful
    
    msf > openvas_task_list
    [+] OpenVAS list of tasks
    
    ID  Name      Comment  Status  Progress
    --  ----      -------  ------  --------
    0   ScanASUS           Done    -1
    1   ScanNAS            Done    -1
    
    
    msf > openvas_task_start 0
    [ *] <X><authenticate_response status='200' status_text='OK'><role>Admin</role><timezone>UTC</timezone><severity>nist</severity></authenticate_response><start_task_response status='404' status_text='Failed to find task &apos;0&apos;'/></X>
    Pourquoi OpenVAS ne trouve pas ma tâche ???
    Merci !
    Dernière modification par tchup, 20 septembre 2016, 20h06.

    Commentaire


    • #3
      Je pense simplement parce qu’il ne la trouve pas dans la base de msf. Voici un lien qui détaille une connection complète avec msf. http://resources.infosecinstitute.co...sploit-part-2/


      Tu remarqueras que le scan est fait après connection avec msf et non comme toi avant. Ce qui se passe c'est qu’il a introduit les données dans sa BDD. Alors comme je n'utilise que NESSUS ou NEXPOSE avec msf et que je passe toujours par ce dernier, il n'y a pas un souci de connection suivant le moment du scan ? Je ne pourrais te dire vraiment. Essais de faire le scan comme décrit et vérifie si cela fonctionne. Si rien ne marche alors ça pourrait venir des installations et update. MSF kali,... il y a tellement de BUG que parfois on s'y perd.

      Commentaire


      • #4
        Bonsoir et merci pour ta réponse..

        nan je me connecte bien avant (juste après le chargement d'OpenVAS dans msfconsole)
        Par contre j'avais même pas testé la création d'une tâche via msfconsole car je l'avais déjà fait via l'interface Web en https://localhost:9392 !
        Et comme de par hasard la création de tâche ne fonctionne pas non plus...

        Code:
        msf > openvas_task_create Scan666 new_scan 3 0
        [ *]
        [ +] OpenVAS list of tasks
        
        ID  Name      Comment  Status  Progress
        --  ----      -------  ------  --------
        0   ScanASUS           Done    -1
        1   ScanNAS            Done    -1
        On se rend compte que la tâche Scann666 n'apparait pas et il n'y a pas de message d'erreur !
        Voici ce que je lance avant tout ça (après boot de Kali) :
        Code:
        root@kali:~# service postegresql start
        root@kali:~# openvas-start
        root@kali:~# openvasmd -a 127.0.0.1 -p 9390
        root@kali:~# openvas-check-setup
        [...]
        Step 1 : Checking OpenVAS Scanner ...
        [...]
        Step 10 : Checking presence of optional tools ...
        
        It seems like your OpenVAS-8 installation is OK.
        
        root@kali:~# msfconsole
        
        msf > db_status
        [ *] postegresql connected to msf
        
        msf > openvas_connect admin password 127.0.0.1 9390 ok
        [ *] Connecting to OpenVAS instance at 127.0.0.1:9390 with username admin...
        [+] OpenVAS connection successful
        pour info je suis avec metasploit-framework 4.12.23

        help...

        Commentaire


        • #5
          Alors plutôt que de faire un copier/coller Je te met ce lien de Valentin qui décrit le principe pour mettre en place un workspace avec Opanvas pas à pas et ainsi mettre en place un scan ou même importer.

          https://www.networklab.fr/presentati...-du-workspace/

          "Create a task (name, comment, target, config) Tu doit fournir plusieurs éléments afin de créer un task.

          Commentaire


          • #6
            Bonjour,
            je commence à cibler un peu le problème... après avoir upgradé MSF en 4.12.26.
            en effet, une fois la mise à jour effectuée dès la commande de connexion j'obtiens cet avertissement :
            Code:
            msf > openvas_connect admin password 127.0.0.1 9390 ok
            [ *] Connecting to OpenVAS instance at 127.0.0.1:9390 with username admin...
            /usr/share/metasploit-framework/vendor/bundle/ruby/2.3.0/gems/openvas-omp-0.0.4/lib/openvas-omp.rb:201:in `sendrecv': Object#timeout is deprecated, use Timeout.timeout instead.
            [+] OpenVAS connection successful
            et ensuite les ID des hosts ont été remplacés par des GUID :
            Code:
            msf > openvas_target_list
            /usr/share/metasploit-framework/vendor/bundle/ruby/2.3.0/gems/openvas-omp-0.0.4/lib/openvas-omp.rb:201:in `sendrecv': Object#timeout is deprecated, use Timeout.timeout instead.
            [+] OpenVAS list of targets
            
            ID                                     Name        Hosts           Max Hosts  In Use  Comment
            --                                     ----        -----           ---------  ------  -------
            3c70ac29-82f5-47ba-a108-3fbea58f212c   Localhost   localhost       1          0
            560af9fe-ea43-45a8-8d0a-ffa09b50bfb6   ASUS        192.168.1.151   1          1
            687159d6-297b-472e-a214-47f5cad3941c   NAS         10.0.0.6        1          1
            Après recherche sur le Net, je suis tombé sur : Wrong IDs on openvas plugin : https://github.com/rapid7/metasploit...rk/issues/7267

            Maintenant, nouvel essai :
            Code:
            msf > openvas_task_list
            /usr/share/metasploit-framework/vendor/bundle/ruby/2.3.0/gems/openvas-omp-0.0.4/lib/openvas-omp.rb:201:in `sendrecv': Object#timeout is deprecated, use Timeout.timeout instead.
            [+] OpenVAS list of tasks
            
            ID                                     Name      Comment  Status  Progress
            --                                     ----      -------  ------  --------
            d529e633-4a59-4cdc-9636-5bf16b5698ab   ScanASUS           Done    -1
            3a9e93ef-8714-4dba-9a10-461e74bf2f3d   ScanNAS            Done    -1
            
            msf > openvas_task_start 3a9e93ef-8714-4dba-9a10-461e74bf2f3d
            /usr/share/metasploit-framework/vendor/bundle/ruby/2.3.0/gems/openvas-omp-0.0.4/lib/openvas-omp.rb:201:in `sendrecv': Object#timeout is deprecated, use Timeout.timeout instead.
            [ *] <X><authenticate_response status='200' status_text='OK'><role>Admin</role><timezone>UTC</timezone><severity>nist</severity></authenticate_response><start_task_response status='404' status_text='Failed to find task &apos;0&apos;'/></X>
            
            msf > openvas_task_list
            /usr/share/metasploit-framework/vendor/bundle/ruby/2.3.0/gems/openvas-omp-0.0.4/lib/openvas-omp.rb:201:in `sendrecv': Object#timeout is deprecated, use Timeout.timeout instead.
            [+] OpenVAS list of tasks
            
            ID                                     Name      Comment  Status  Progress
            --                                     ----      -------  ------  --------
            d529e633-4a59-4cdc-9636-5bf16b5698ab   ScanASUS           Done    -1
            3a9e93ef-8714-4dba-9a10-461e74bf2f3d   ScanNAS            Done    30
            30%... La tâche se lance !

            J'ai donc bien un problème avec l'utilisation des GUID des tâches et objets... et de script utilisant timeout à la place de Timeout.timeout
            Comment résoudre cela ???

            Commentaire


            • #7
              Je viens d'installer (sur HDD = non live) Kali et effectuer un apt update & apt dist-upgrade
              pour finalement obtenir exactement les même problèmes...

              Commentaire


              • #8
                j'ai pas testé, mais je pense que dans un premier temps, tu peux déjà corriger ce qui est mentionné dans le message et ensuite voir si ça corrige ton "problème"

                Code:
                 msf > openvas_task_list /usr/share/metasploit-framework/vendor/bundle/ruby/2.3.0/gems/openvas-omp-0.0.4/lib/openvas-omp.rb:201:in `sendrecv': Object#timeout is deprecated,  use Timeout.timeout instead. [+] OpenVAS list of tasks  ID                                     Name      Comment  Status  Progress --                                     ----      -------  ------  -------- d529e633-4a59-4cdc-9636-5bf16b5698ab   ScanASUS           Done    -1 3a9e93ef-8714-4dba-9a10-461e74bf2f3d   ScanNAS            Done    -1
                c'est marqué noir sur blanc:
                Code:
                /usr/share/metasploit-framework/vendor/bundle/ruby/2.3.0/gems/openvas-omp-0.0.4/lib/openvas-omp.rb:201:in `sendrecv': Object#timeout is deprecated,  use Timeout.timeout instead.
                La fonction 'sendrecv' utilise l'objet "timeout"qui est obsolète a la ligne 201 du fichier "openvas-omp.rb" , donc il faut remplacer "timeout" par "Timeout.timeout"
                Code:
                   def sendrecv (tosend)
                            if not @socket
                                connect
                            end
                        
                            if @debug>3 then
                                puts "SENDING: "+tosend
                            end
                            @socket.puts(tosend)
                
                            @rbuf=''
                            size=0
                            begin    
                                begin
                                timeout(@read_timeout) {                                       # c'est ici...
                                    a = @socket.sysread(@bufsize)
                                    size=a.length
                                    # puts "sysread #{size} bytes"
                                    @rbuf << a
                                }
                                rescue Timeout::Error
                                    size=0
                                rescue EOFError
                                    raise OMPResponseError
                                end
                            end while size>=@bufsize
                            response=@rbuf
                            
                            if @debug>3 then
                                puts "RECEIVED: "+response
                            end
                            return response
                        end
                donc soit tu corrige a la main ligne 201, ou soit tu vérifie la version de ruby (2.3.0) et tu cherche s'il existe un correctif pour cette version ( peut etre que la version 2.3.1 corrige ce problème)

                a toi de tester

                @+
                Dernière modification par pl3x, 23 septembre 2016, 20h32.

                Commentaire


                • #9
                  Merci pl3x
                  j'ai corrigé le Timeout et après un reboot, je n'ai plus d'avertissement...
                  PS : si quelqu'un sait comment se passer d'un reboot pour que la correction soit prise en compte, je suis preneur

                  Commentaire


                  • #10
                    Merci pl3x pour ta solution.

                    Commentaire


                    • #11
                      Hello !

                      Je passe aussi par OpenVAS en CLI mais je rencontre un problème similaire à ceux évoqués plus haut sans parvenir à les résoudre, malgré avoir tenté les différentes méthodes proposées.

                      Après avoir lancé le module openvas dans la msfc je parviens bien à obtenir la liste de mes tâches, target... mais les ID on l'air erronés: ex:

                      msf > openvas_config_list
                      [+] OpenVAS list of configs

                      ID Name
                      -- ----
                      085569ce-73ed-11df-83c3-002264764cea empty
                      2d3f051c-55ba-11e3-bf43-406186ea4fc5 Host Discovery
                      698f691e-7489-11df-9d8c-002264764cea Full and fast ultimate
                      708f25c4-7489-11df-8094-002264764cea Full and very deep
                      74db13d6-7489-11df-91b9-002264764cea Full and very deep ultimate
                      8715c877-47a0-438d-98a3-27c7a6ab2196 Discovery
                      bbca7412-a950-11e3-9109-406186ea4fc5 System Discovery
                      daba56c8-73ec-11df-a475-002264764cea Full and fast

                      J'ai tenté de corriger le .rb dans le /plugins/ mais je me suis rendu compte que j'avais une version comparable à celle proposée sur le github.

                      je rencontre du coup ce genre de problème ...

                      X><authenticate_response status='200' status_text='OK'><role>Admin</role><timezone>UTC</timezone><severity>nist</severity></authenticate_response> <start_task_response status='404' status_text='Failed to find task &apos;0&apos;'/></X>

                      Si quelqu'un avait une réponse à m'apporter ... Merci d'avance.
                      Dernière modification par PepeTheFr0g, 28 octobre 2016, 12h54.

                      Commentaire


                      • #12
                        pl3x voici le contenu du .rb que j'ai comparé avec le fichier de github, qui semble être similaire.

                        #!/usr/bin/env ruby
                        #
                        # This plugin provides integration with OpenVAS. Written by kost and
                        # averagesecurityguy.
                        #
                        # $Id$
                        # $Revision$
                        #
                        # Distributed under MIT license:
                        # http://www.opensource.org/licenses/mit-license.php
                        #

                        require 'openvas-omp'

                        module Msf
                        class Plugin::OpenVAS < Msf::Plugin
                        class OpenVASCommandDispatcher
                        include Msf::Ui::Console::CommandDispatcher

                        def name
                        "OpenVAS"
                        end

                        def commands
                        {
                        'openvas_help' => "Displays help",
                        'openvas_version' => "Display the version of the OpenVAS server",
                        'openvas_debug' => "Enable/Disable debugging",
                        'openvas_connect' => "Connect to an OpenVAS manager using OMP",
                        'openvas_disconnect' => "Disconnect from OpenVAS manager",

                        'openvas_task_create' => "Create a task (name, comment, target, config)",
                        'openvas_task_delete' => "Delete task by ID",
                        'openvas_task_list' => "Display list of tasks",
                        'openvas_task_start' => "Start task by ID",
                        'openvas_task_stop' => "Stop task by ID",
                        'openvas_task_pause' => "Pause task by ID",
                        'openvas_task_resume' => "Resume task by ID",
                        'openvas_task_resume_or_start' => "Resume task or start task by ID",

                        'openvas_target_create' => "Create target (name, hosts, comment)",
                        'openvas_target_delete' => "Delete target by ID",
                        'openvas_target_list' => "Display list of targets",

                        'openvas_config_list' => "Quickly display list of configs",

                        'openvas_format_list' => "Display list of available report formats",

                        'openvas_report_list' => "Display a list of available report formats",
                        'openvas_report_delete' => "Delete a report specified by ID",
                        'openvas_report_download' => "Save a report to disk",
                        'openvas_report_import' => "Import report specified by ID into framework",
                        }
                        end

                        def cmd_openvas_help()
                        print_status("openvas_help Display this help")
                        print_status("openvas_debug Enable/Disable debugging")
                        print_status("openvas_version Display the version of the OpenVAS server")
                        print_status
                        print_status("CONNECTION")
                        print_status("==========")
                        print_status("openvas_connect Connects to OpenVAS")
                        print_status("openvas_disconnect Disconnects from OpenVAS")
                        print_status
                        print_status("TARGETS")
                        print_status("=======")
                        print_status("openvas_target_create Create target")
                        print_status("openvas_target_delete Deletes target specified by ID")
                        print_status("openvas_target_list Lists targets")
                        print_status
                        print_status("TASKS")
                        print_status("=====")
                        print_status("openvas_task_create Create task")
                        print_status("openvas_task_delete Delete a task and all associated reports")
                        print_status("openvas_task_list Lists tasks")
                        print_status("openvas_task_start Starts task specified by ID")
                        print_status("openvas_task_stop Stops task specified by ID")
                        print_status("openvas_task_pause Pauses task specified by ID")
                        print_status("openvas_task_resume Resumes task specified by ID")
                        print_status("openvas_task_resume_or_start Resumes or starts task specified by ID")
                        print_status
                        print_status("CONFIGS")
                        print_status("=======")
                        print_status("openvas_config_list Lists scan configurations")
                        print_status
                        print_status("FORMATS")
                        print_status("=======")
                        print_status("openvas_format_list Lists available report formats")
                        print_status
                        print_status("REPORTS")
                        print_status("=======")
                        print_status("openvas_report_list Lists available reports")
                        print_status("openvas_report_delete Delete a report specified by ID")
                        print_status("openvas_report_import Imports an OpenVAS report specified by ID")
                        print_status("openvas_report_download Downloads an OpenVAS report specified by ID")
                        end

                        # Verify the database is connected and usable
                        def database?
                        if !(framework.db and framework.db.usable)
                        return false
                        else
                        return true
                        end
                        end

                        # Verify there is an active OpenVAS connection
                        def openvas?
                        if @ov
                        return true
                        else
                        print_error("No OpenVAS connection available. Please use openvas_connect.")
                        return false
                        end
                        end

                        # Verify correct number of arguments and verify -h was not given. Return
                        # true if correct number of arguments and help was not requested.
                        def args?(args, min=1, max=nil)
                        if not max then max = min end
                        if (args.length < min or args.length > max or args[0] == "-h")
                        return false
                        end

                        return true
                        end

                        #--------------------------
                        # Basic Functions
                        #--------------------------
                        def cmd_openvas_debug(*args)
                        return unless openvas?

                        if args?(args)
                        begin
                        resp = @ov.debug(args[0].to_i)
                        print_good(resp)
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage:")
                        print_status("openvas_debug integer")
                        end
                        end

                        def cmd_openvas_version()
                        return unless openvas?

                        begin
                        ver = @ov.version_get
                        print_good("Using OMP version #{ver}")
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        end


                        #--------------------------
                        # Connection Functions
                        #--------------------------
                        def cmd_openvas_connect(*args)
                        # Is the database configured?
                        if not database?
                        print_error("No database has been configured.")
                        return
                        end

                        # Don't allow duplicate sessions
                        if @ov then
                        print_error("Session already open, please use openvas_disconnect first.")
                        return
                        end

                        # Make sure the correct number of arguments are present.
                        if args?(args, 4, 5)

                        user, pass, host, port, sslv = args

                        # SSL warning. User is required to confirm.
                        if(host != "localhost" and host != "127.0.0.1" and sslv != "ok")
                        print_error("Warning: SSL connections are not verified in this release, it is possible for an attacker")
                        print_error(" with the ability to man-in-the-middle the OpenVAS traffic to capture the OpenVAS")
                        print_error(" credentials. If you are running this on a trusted network, please pass in 'ok'")
                        print_error(" as an additional parameter to this command.")
                        return
                        end

                        begin
                        print_status("Connecting to OpenVAS instance at #{host}:#{port} with username #{user}...")
                        ov = OpenVASOMP::OpenVASOMP.new('user' => user, 'password' => pass, 'host' => host, 'port' => port)
                        rescue OpenVASOMP::OMPAuthError => e
                        print_error("Authentication failed: #{e.reason}")
                        return
                        rescue OpenVASOMP::OMPConnectionError => e
                        print_error("Connection failed: #{e.reason}")
                        return
                        end
                        print_good("OpenVAS connection successful")
                        @ov = ov

                        else
                        print_status("Usage:")
                        print_status("openvas_connect username password host port <ssl-confirm>")
                        end
                        end

                        # Disconnect from an OpenVAS manager
                        def cmd_openvas_disconnect()
                        return unless openvas?
                        @ov.logout
                        @ov = nil
                        end


                        #--------------------------
                        # Target Functions
                        #--------------------------
                        def cmd_openvas_target_create(*args)
                        return unless openvas?

                        if args?(args, 3)
                        begin
                        resp = @ov.target_create('name' => args[0], 'hosts' => args[1], 'comment' => args[2])
                        print_status(resp)
                        cmd_openvas_target_list
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end

                        else
                        print_status("Usage: openvas_target_create <name> <hosts> <comment>")
                        end
                        end

                        def cmd_openvas_target_delete(*args)
                        return unless openvas?

                        if args?(args)
                        begin
                        resp = @ov.target_delete(args[0])
                        print_status(resp)
                        cmd_openvas_target_list
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage: openvas_target_delete <target_id>")
                        end
                        end

                        def cmd_openvas_target_list(*args)
                        return unless openvas?

                        begin
                        tbl = Rex::Text::Table.new(
                        'Columns' => ["ID", "Name", "Hosts", "Max Hosts", "In Use", "Comment"])
                        @ov.target_get_all().each do |target|
                        tbl << [ target["id"], target["name"], target["hosts"], target["max_hosts"],
                        target["in_use"], target["comment"] ]
                        end
                        print_good("OpenVAS list of targets")
                        print_line
                        print_line tbl.to_s
                        print_line
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        end

                        #--------------------------
                        # Task Functions
                        #--------------------------
                        def cmd_openvas_task_create(*args)
                        return unless openvas?

                        if args?(args, 4)
                        begin
                        resp = @ov.task_create('name' => args[0], 'comment' => args[1], 'config' => args[2], 'target'=> args[3])
                        print_status(resp)
                        cmd_openvas_task_list
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end

                        else
                        print_status("Usage: openvas_task_create <name> <comment> <config_id> <target_id>")
                        end
                        end

                        def cmd_openvas_task_delete(*args)
                        return unless openvas?

                        if args?(args, 2)

                        # User is required to confirm before deleting task.
                        if(args[1] != "ok")
                        print_error("Warning: Deleting a task will also delete all reports associated with the ")
                        print_error("task, please pass in 'ok' as an additional parameter to this command.")
                        return
                        end

                        begin
                        resp = @ov.task_delete(args[0])
                        print_status(resp)
                        cmd_openvas_task_list
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage: openvas_task_delete <id> ok")
                        print_error("This will delete the task and all associated reports.")
                        end
                        end

                        def cmd_openvas_task_list(*args)
                        return unless openvas?

                        begin
                        tbl = Rex::Text::Table.new(
                        'Columns' => ["ID", "Name", "Comment", "Status", "Progress"])
                        @ov.task_get_all().each do |task|
                        tbl << [ task["id"], task["name"], task["comment"], task["status"], task["progress"] ]
                        end
                        print_good("OpenVAS list of tasks")
                        print_line
                        print_line tbl.to_s
                        print_line
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        end

                        def cmd_openvas_task_start(*args)
                        return unless openvas?

                        if args?(args)
                        begin
                        resp = @ov.task_start(args[0])
                        print_status(resp)
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage: openvas_task_start <id>")
                        end
                        end

                        def cmd_openvas_task_stop(*args)
                        return unless openvas?

                        if args?(args)
                        begin
                        resp = @ov.task_stop(args[0])
                        print_status(resp)
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage: openvas_task_stop <id>")
                        end
                        end

                        def cmd_openvas_task_pause(*args)
                        return unless openvas?

                        if args?(args)
                        begin
                        resp = @ov.task_pause(args[0])
                        print_status(resp)
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage: openvas_task_pause <id>")
                        end
                        end

                        def cmd_openvas_task_resume(*args)
                        return unless openvas?

                        if args?(args)
                        begin
                        resp = @ov.task_resume_paused(args[0])
                        print_status(resp)
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage: openvas_task_resume <id>")
                        end
                        end

                        def cmd_openvas_task_resume_or_start(*args)
                        return unless openvas?

                        if args?(args)
                        begin
                        resp = @ov.task_resume_or_start(args[0])
                        print_status(resp)
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage: openvas_task_resume_or_start <id>")
                        end
                        end

                        #--------------------------
                        # Config Functions
                        #--------------------------
                        def cmd_openvas_config_list(*args)
                        return unless openvas?

                        begin
                        tbl = Rex::Text::Table.new(
                        'Columns' => [ "ID", "Name" ])

                        @ov.config_get_all.each do |config|
                        tbl << [ config["id"], config["name"] ]
                        end
                        print_good("OpenVAS list of configs")
                        print_line
                        print_line tbl.to_s
                        print_line
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        end

                        #--------------------------
                        # Format Functions
                        #--------------------------
                        def cmd_openvas_format_list(*args)
                        return unless openvas?

                        begin
                        tbl = Rex::Text::Table.new(
                        'Columns' => ["ID", "Name", "Extension", "Summary"])
                        format_get_all.each do |format|
                        tbl << [ format["id"], format["name"], format["extension"], format["summary"] ]
                        end
                        print_good("OpenVAS list of report formats")
                        print_line
                        print_line tbl.to_s
                        print_line
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        end

                        #--------------------------
                        # Report Functions
                        #--------------------------
                        def cmd_openvas_report_list(*args)
                        return unless openvas?

                        begin
                        tbl = Rex::Text::Table.new(
                        'Columns' => ["ID", "Task Name", "Start Time", "Stop Time"])

                        resp = @ov.report_get_raw

                        resp.elements.each("//get_reports_response/report") do |report|
                        report_id = report.elements["report"].attributes["id"]
                        report_task = report.elements["task/name"].get_text
                        report_start_time = report.elements["creation_time"].get_text
                        report_stop_time = report.elements["modification_time"].get_text

                        tbl << [ report_id, report_task, report_start_time, report_stop_time ]
                        end
                        print_good("OpenVAS list of reports")
                        print_line
                        print_line tbl.to_s
                        print_line
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        end

                        def cmd_openvas_report_delete(*args)
                        return unless openvas?

                        if args?(args)
                        begin
                        resp = @ov.report_delete(args[0])
                        print_status(resp)
                        cmd_openvas_report_list
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage: openvas_report_delete <id>")
                        end
                        end

                        def cmd_openvas_report_download(*args)
                        return unless openvas?

                        if args?(args, 4)
                        begin
                        report = @ov.report_get_raw("report_id"=>args[0],"format"=>args[1])
                        ::FileUtils.mkdir_p(args[2])
                        name = ::File.join(args[2], args[3])
                        print_status("Saving report to #{name}")
                        output = ::File.new(name, "w")
                        data = nil
                        report.elements.each("//get_reports_response"){|r| data = r.to_s}
                        output.puts(data)
                        output.close
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage: openvas_report_download <report_id> <format_id> <path> <report_name>")
                        end
                        end

                        def cmd_openvas_report_import(*args)
                        return unless openvas?

                        if args?(args, 2)
                        begin
                        report = @ov.report_get_raw("report_id"=>args[0],"format"=>args[1])
                        data = nil
                        report.elements.each("//get_reports_response"){|r| data = r.to_s}
                        print_status("Importing report to database.")
                        framework.db.import({:data => data})
                        rescue OpenVASOMP::OMPError => e
                        print_error(e.to_s)
                        end
                        else
                        print_status("Usage: openvas_report_import <report_id> <format_id>")
                        print_status("Only the NBE and XML formats are supported for importing.")
                        end
                        end



                        #--------------------------
                        # Format Functions
                        #--------------------------
                        # Get a list of report formats
                        def format_get_all
                        begin
                        resp = @ov.omp_request_xml("<get_report_formats/>")
                        if @debug then print resp end

                        list = Array.new
                        resp.elements.each('//get_report_formats_response/report_format') do |report|
                        td = Hash.new
                        td["id"] = report.attributes["id"]
                        td["name"] = report.elements["name"].text
                        td["extension"] = report.elements["extension"].text
                        td["summary"] = report.elements["summary"].text
                        list.push td
                        end
                        @formats = list
                        return list
                        rescue
                        raise OMPResponseError
                        end
                        end

                        end # End OpenVAS class

                        #------------------------------
                        # Plugin initialization
                        #------------------------------

                        def initialize(framework, opts)
                        super
                        add_console_dispatcher(OpenVASCommandDispatcher)
                        print_status("Welcome to OpenVAS integration by kost and averagesecurityguy.")
                        print_status
                        print_status("OpenVAS integration requires a database connection. Once the ")
                        print_status("database is ready, connect to the OpenVAS server using openvas_connect.")
                        print_status("For additional commands use openvas_help.")
                        print_status
                        @ov = nil
                        @formats = nil
                        @debug = nil
                        end

                        def cleanup
                        remove_console_dispatcher('OpenVAS')
                        end

                        def name
                        "OpenVAS"
                        end

                        def desc
                        "Integrates with the OpenVAS - open source vulnerability management"
                        end
                        end
                        end
                        Dernière modification par PepeTheFr0g, 28 octobre 2016, 14h18.

                        Commentaire


                        • #13
                          merci pour ce tuto d'installation Dreamus.

                          Débutant sur OpenVAS j'ai voulu me pencher sur la question du backup/restore des données: je bosse sur une VM jetable, je veux pouvoir tout backuper et tout restorer sur une clé USB. Je me suis penché sur la doc, je la trouve très mal faite (on tombe sur un backup de leur système de virtualisation), la man page de openvasmd ne mentionne pas de backup, le seul truc que je trouve dans openvasmd -h :

                          --backup Backup the database.
                          -d, --database=<file> Use <file> as database.

                          Donc question: est ce qu'un openvasmd --backup puis un openvasmd -d suffit? J'ai lu sur un site que quelqu'un faisait un rsync de tout, mais il n'a pas donné de dossiers... Et j'ai cru comprendre qu'il y avait des clés générées dans /var, donc ça me fait douter que le backup de la base suffise...

                          Bref quelqu'un a-t-il un process pour faire un backup propre de la chose?

                          Commentaire

                          Chargement...
                          X