terça-feira, 2 de dezembro de 2014

Bash Script para verificar robustez de servidor SSL

"É quando o tempo sacode
 A cabeleira
 A trança toda vermelha
 Um olho cego vagueia
 Procurando por um."
                   (Frevo mulher - Zé Ramalho).


Alguns anos atrás eu havia criado um simples shell script para automatizar a listagem de cifras permitidas em um servidor SSL.

Até hoje esse script me é útil no levantamento de informações sobre a versão SSL e as cifras utilizadas em um servidor remoto.

Na internet há diversos 'serviços' de listagem de informações sobre um servidor SSL e também sobre quais cifras são seguras e quais são fracas. Isso tudo é muito relativo, pois uma cifra do tipo EXP-RC4-MD5 pode ser amplamenta considerada fraca, mas num ambiente onde não há nenhuma informação crítica ela pode ser usada. De modo que, não só conhecer os algoritmos de criptografia é fundamental mas também enxergar para que os mesmos estão sendo usados.

Um outro exemplo que podemos contemplar é o de uma loja virtual. Nesse caso utilizar uma cifra fraca ou mesmo média pode ser problemática. Por que isso?

- Por exemplo, não raro dados de cartões de crédito levam anos para expirarem, logo, um atacante que consegue 'sniffar' dados de um servidor SSL que está executando uma cifra média pode levar anos para quebrar a criptografia e obter a chave mestre, então, do ponto de vista dele, pode valer a pena a investida.

Ou seja, um cartão que levará 4,6 anos para expirar pode ser vitimado após ter realizado uma compra num site sniffado há anos atrás.

Diante disso, resolvi compartilhar o shell script para demonstrar como é fácil executar o levantamento de informações de robustez de um servidor SSL e aproveito orientar quanto ao estudo do mesmo. 

Um excelente livro sobre implementações prática de SSL/TLS é o "Implementing SSL / TLS Using Cryptography and PKI" de Joshua Davis.

Nele vemos vários exemplos, inclusive em C para o aprendizado dos principais protocolos SSL(versão 2, TLS versão 1) que servem para orientar um hacker no que procurar ao analisar um servidor SSL. Hoje a maioria dos servidores não permitem mais SSL versões 2 e 3, mas ainda vemos algumas lojas virtuais com suporte a esses protocolos. Conhecer os antigos ataques e fraquezas pode ser útil para implementar novos ataques e descobrir novas vulnerabilidade.

O output da ferramenta segue abaixo:

$ ./cipher_check_ssl.sh ssl2 fortes carrinho.extra.com.br 443
#-#-#-# Verificando se servidor SSL esta disponivel...
#-#-#-# OK.
#-#-#-# Verificando Cifras Permitidas em SSL versao 2 (Cifras Fortes)...
#-#-#-# Finalizado Checagem de Cifras.

Acima vemos que não há suporte a SSL versão 2.

$ ./cipher_check_ssl.sh ssl3 fracas carrinho.extra.com.br 443
#-#-#-# Verificando se servidor SSL esta disponivel...
#-#-#-# OK.
#-#-#-# Verificando Cifras Permitidas em TLS versao 1.0 (Cifras Fracas)...
[ADH-DES-CBC-SHA]
    Algoritmo_de_Troca_de_Chaves=DH
    Autenticacao=None
    Criptografia_Simetrica=DES(56)
    Mandatory_Acess_Control=SHA1
[EDH-RSA-DES-CBC-SHA]
    Algoritmo_de_Troca_de_Chaves=DH
    Autenticacao=RSA
    Criptografia_Simetrica=DES(56)
    Mandatory_Acess_Control=SHA1
[EDH-DSS-DES-CBC-SHA]
    Algoritmo_de_Troca_de_Chaves=DH
    Autenticacao=DSS
    Criptografia_Simetrica=DES(56)
    Mandatory_Acess_Control=SHA1
[DES-CBC-SHA]
    Algoritmo_de_Troca_de_Chaves=RSA
    Autenticacao=RSA
    Criptografia_Simetrica=DES(56)
    Mandatory_Acess_Control=SHA1
#-#-#-# Finalizado Checagem de Cifras Fracas.
Acima vemos as seguintes cifras 'fracas' sendo permitidas, inclusive DES de 56 bits.

$ ./cipher_check_ssl.sh ssl3 medias carrinho.extra.com.br 443
#-#-#-# Verificando se servidor SSL esta disponivel...
#-#-#-# OK.
#-#-#-# Verificando Cifras Permitidas em TLS versao 1.0 (Cifras Medias)...
[ADH-RC4-MD5]
    Algoritmo_de_Troca_de_Chaves=DH
    Autenticacao=None
    Criptografia_Simetrica=RC4(128)
    Mandatory_Acess_Control=MD5
[RC4-SHA]
    Algoritmo_de_Troca_de_Chaves=RSA
    Autenticacao=RSA
    Criptografia_Simetrica=RC4(128)
    Mandatory_Acess_Control=SHA1
[RC4-MD5]
    Algoritmo_de_Troca_de_Chaves=RSA
    Autenticacao=RSA
    Criptografia_Simetrica=RC4(128)
    Mandatory_Acess_Control=MD5
[RC4-MD5]
    Algoritmo_de_Troca_de_Chaves=RSA
    Autenticacao=RSA
    Criptografia_Simetrica=RC4(128)
    Mandatory_Acess_Control=MD5
#-#-#-# Finalizado Checagem de Cifras Medias.
Acima vemos outras cifras que podem ser atacadas, inclusive RC4 de 128 bits
(tem de ter poder de processamento pra isso!).

O código fonte do shell script segue abaixo:

---------------------------- cipher_check_ssl.sh ---------------------------------
#!/bin/bash
# SSL Cipher Check - Validando Hardening SSL
#
# Glaudson Ocampos <glaudson@securitylabs.com.br>
# Kryptonia - SecurityLabs Cryptography Division
# criptografia.securitylabs.com.br
#
# Testado em Slackware 13.1.0, Debian 6.0 e Ubuntu 12.04.
#
# Pre-Requisitos:
# Sistema Operacional: Linux com OpenSSL >= 0.9.8n
#

#Programas Necessarios.

OPENSSL="/usr/bin/openssl"
ECHO="/bin/echo"
WC="/usr/bin/wc"
HEAD="/usr/bin/head"
TAIL="/usr/bin/tail"
CUT="/usr/bin/cut"

#Slackware 13.1.0
#GREP="/usr/bin/grep"
#RM="/usr/bin/rm"
#SED="/usr/bin/sed"

#Ubuntu
#Debian 
GREP="/bin/grep"
RM="/bin/rm"
SED="/bin/sed"

#Variaveis Estaticas

HTTP_REQUEST="HEAD / HTTP/1.1"
ARQ_TMP="/tmp/saida.txt"
STRING="SSL handshake"
STRING_FALHA_CONEXAO="Connection timed out"

#Lista de Cifras
#As cifras dependem da compilacao do OpenSSL.
#Abaixo estao agrupadas por nivel de seguranca.

TLS1_CIFRAS_FRACAS=([0]="ADH-DES-CBC-SHA" [1]="EDH-RSA-DES-CBC-SHA" [2]="EDH-DSS-DES-CBC-SHA" [3]="DES-CBC-SHA" [4]="DES-CBC-MD5")
TLS1_CIFRAS_FRACAS_TOTAL=5

TLS1_CIFRAS_MEDIAS=([0]="ADH-RC4-MD5" [1]="RC4-SHA" [2]="RC4-MD5" [3]="RC2-CBC-MD5" [4]="RC4-MD5")
TLS1_CIFRAS_MEDIAS_TOTAL=5

TLS1_CIFRAS_FORTES=([0]="ADH-AES256-SHA" [1]="DHE-RSA-AES256-SHA" [2]="DHE-DSS-AES256-SHA" [3]="AES256-SHA" [4]="ADH-AES128-SHA" [5]="DHE-RSA-AES128-SHA" [6]="DHE-DSS-AES128-SHA" [7]="AES128-SHA" [8]="ADH-DES-CBC3-SHA" [9]="EDH-RSA-DES-CBC3-SHA" [10]="EDH-DSS-DES-CBC3-SHA" [11]="DES-CBC3-SHA" [12]="DES-CBC3-MD5")
TLS1_CIFRAS_FORTES_TOTAL=13

TLS1_CIFRAS_EXPORTADAS=([0]="EXP-ADH-DES-CBC-SHA" [1]="EXP-ADH-RC4-MD5" [2]="EXP-EDH-RSA-DES-CBC-SHA" [3]="EXP-EDH-DSS-DES-CBC-SHA" [4]="EXP-DES-CBC-SHA" [5]="EXP-RC2-CBC-MD5" [6]="EXP-RC4-MD5")
TLS1_CIFRAS_EXPORTADAS_TOTAL=7

SSL2_CIFRAS_FRACAS=([0]="DES-CBC3-MD5")
SSL2_CIFRAS_FRACAS_TOTAL=1

SSL2_CIFRAS_MEDIAS=([0]="RC2-CBC-MD5" [1]="RC4-MD5")
SSL2_CIFRAS_MEDIAS_TOTAL=2

SSL2_CIFRAS_FORTES=([0]="DES-CBC3-MD5")
SSL2_CIFRAS_FORTES_TOTAL=1

SSL2_CIFRAS_EXPORTADAS=([0]="EXP-RC2-CBC-MD5" [1]="EXP-RC4-MD5")
SSL2_CIFRAS_EXPORTADAS_TOTAL=2


function checa_conexao {
  if [ -f $ARQ_TMP ]; then
        ${RM} $ARQ_TMP
  fi
  ${ECHO} "#-#-#-# Verificando se servidor SSL esta disponivel..."
  ${ECHO} $HTTP_REQUEST | ${OPENSSL} s_client -connect $hostname:$porta &> $ARQ_TMP
        Retorno=`${GREP} "$STRING_FALHA_CONEXAO" $ARQ_TMP | ${WC} -l`
        if [ $Retorno -eq 0 ]; then
                ${ECHO} -n ""
        else
    ${ECHO} "#-#-#-# Falha na conexao com o servidor: $hostname:$porta."
  exit -1
        fi
  ${ECHO} "#-#-#-# OK."
}

function checa_cifras_tls1_fracas {
  if [ -f $ARQ_TMP ]; then
   ${RM} $ARQ_TMP
  fi
  ${ECHO} "#-#-#-# Verificando Cifras Permitidas em TLS versao 1.0 (Cifras Fracas)..."
     for((i=0;i<$TLS1_CIFRAS_FRACAS_TOTAL;i++)); do
 ${ECHO} $HTTP_REQUEST | ${OPENSSL} s_client -tls1 -connect $hostname:$porta -cipher ${TLS1_CIFRAS_FRACAS[${i}]} &> $ARQ_TMP
 Retorno=`${GREP} "$STRING" $ARQ_TMP | ${WC} -l`
   if [ $Retorno -eq 0 ]; then
  ${ECHO} -n ""
 else
  ${ECHO} "[${TLS1_CIFRAS_FRACAS[${i}]}]"
  ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_FRACAS[${i}]}  | ${SED} 's/Kx/"\nAlgoritmo_de_Troca_de_Chaves/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
  ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_FRACAS[${i}]}  | ${SED} 's/Au/\nAutenticacao/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
  ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_FRACAS[${i}]}  | ${SED} 's/Enc/\nCriptografia_Simetrica/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
  ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_FRACAS[${i}]}  | ${SED} 's/Mac/\nMandatory_Acess_Control/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
   fi  
      done
  ${ECHO} "#-#-#-# Finalizado Checagem de Cifras Fracas."
}


function checa_cifras_tls1_medias {
  if [ -f $ARQ_TMP ]; then
        ${RM} $ARQ_TMP
  fi
  ${ECHO} "#-#-#-# Verificando Cifras Permitidas em TLS versao 1.0 (Cifras Medias)..."
     for((i=0;i<$TLS1_CIFRAS_MEDIAS_TOTAL;i++)); do
        ${ECHO} $HTTP_REQUEST | ${OPENSSL} s_client -tls1 -connect $hostname:$porta -cipher ${TLS1_CIFRAS_MEDIAS[${i}]} &> $ARQ_TMP
        Retorno=`${GREP} "$STRING" $ARQ_TMP | ${WC} -l`
        if [ $Retorno -eq 0 ]; then
                ${ECHO} -n ""   
        else
                ${ECHO} "[${TLS1_CIFRAS_MEDIAS[${i}]}]"
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_MEDIAS[${i}]}  | ${SED} 's/Kx/"\nAlgoritmo_de_Troca_de_Chaves/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_MEDIAS[${i}]}  | ${SED} 's/Au/\nAutenticacao/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_MEDIAS[${i}]}  | ${SED} 's/Enc/\nCriptografia_Simetrica/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_MEDIAS[${i}]}  | ${SED} 's/Mac/\nMandatory_Acess_Control/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
        fi
      done
  ${ECHO} "#-#-#-# Finalizado Checagem de Cifras Medias."
}


function checa_cifras_tls1_fortes {
  if [ -f $ARQ_TMP ]; then
        ${RM} $ARQ_TMP
  fi
  ${ECHO} "#-#-#-# Verificando Cifras Permitidas em TLS versao 1.0 (Cifras Fortes)..."
     for((i=0;i<$TLS1_CIFRAS_FORTES_TOTAL;i++)); do
        ${ECHO} $HTTP_REQUEST | ${OPENSSL} s_client -tls1 -connect $hostname:$porta -cipher ${TLS1_CIFRAS_FORTES[${i}]} &> $ARQ_TMP
        Retorno=`${GREP} "$STRING" $ARQ_TMP | ${WC} -l`
        if [ $Retorno -eq 0 ]; then
                ${ECHO} -n ""   
        else
                ${ECHO} "[${TLS1_CIFRAS_FORTES[${i}]}]"
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_FORTES[${i}]}  | ${SED} 's/Kx/"\nAlgoritmo_de_Troca_de_Chaves/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_FORTES[${i}]}  | ${SED} 's/Au/\nAutenticacao/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_FORTES[${i}]}  | ${SED} 's/Enc/\nCriptografia_Simetrica/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_FORTES[${i}]}  | ${SED} 's/Mac/\nMandatory_Acess_Control/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
        fi
      done
  ${ECHO} "#-#-#-# Finalizado Checagem de Cifras Fortes."
}


function checa_cifras_tls1_exportadas {
  if [ -f $ARQ_TMP ]; then
        ${RM} $ARQ_TMP
  fi
  ${ECHO} "#-#-#-# Verificando Cifras Permitidas em TLS versao 1.0 (Cifras Exportadas)..."
     for((i=0;i<$TLS1_CIFRAS_EXPORTADAS_TOTAL;i++)); do
        ${ECHO} $HTTP_REQUEST | ${OPENSSL} s_client -tls1 -connect $hostname:$porta -cipher ${TLS1_CIFRAS_EXPORTADAS[${i}]} &> $ARQ_TMP
        Retorno=`${GREP} "$STRING" $ARQ_TMP | ${WC} -l`
        if [ $Retorno -eq 0 ]; then
                ${ECHO} -n ""
        else
                ${ECHO} "[${TLS1_CIFRAS_EXPORTADAS[${i}]}]"
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_EXPORTADAS[${i}]}  | ${SED} 's/Kx/"\nAlgoritmo_de_Troca_de_Chaves/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_EXPORTADAS[${i}]}  | ${SED} 's/Au/\nAutenticacao/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_EXPORTADAS[${i}]}  | ${SED} 's/Enc/\nCriptografia_Simetrica/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${TLS1_CIFRAS_EXPORTADAS[${i}]}  | ${SED} 's/Mac/\nMandatory_Acess_Control/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
        fi
      done  
  ${ECHO} "#-#-#-# Finalizado Checagem de Cifras Exportadas."
} 


function checa_cifras_ssl2_fracas {
  if [ -f $ARQ_TMP ]; then
        ${RM} $ARQ_TMP
  fi
  ${ECHO} "#-#-#-# Verificando Cifras Permitidas em SSL versao 2 (Cifras Fracas)..."
     for((i=0;i<$SSL2_CIFRAS_FRACAS_TOTAL;i++)); do
        ${ECHO} $HTTP_REQUEST | ${OPENSSL} s_client -ssl2 -connect $hostname:$porta -cipher ${SSL2_CIFRAS_FRACAS[${i}]} &> $ARQ_TMP
        Retorno=`${GREP} "$STRING" $ARQ_TMP | ${WC} -l`
        if [ $Retorno -eq 0 ]; then
                ${ECHO} -n ""
        else
                ${ECHO} "[${SSL2_CIFRAS_FRACAS[${i}]}]"
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_FRACAS[${i}]}  | ${SED} 's/Kx/"\nAlgoritmo_de_Troca_de_Chaves/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_FRACAS[${i}]}  | ${SED} 's/Au/\nAutenticacao/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_FRACAS[${i}]}  | ${SED} 's/Enc/\nCriptografia_Simetrica/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_FRACAS[${i}]}  | ${SED} 's/Mac/\nMandatory_Acess_Control/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
        fi
      done
  ${ECHO} "#-#-#-# Finalizado Checagem de Cifras Fracas."
}


function checa_cifras_ssl2_medias {
  if [ -f $ARQ_TMP ]; then
        ${RM} $ARQ_TMP
  fi      
  ${ECHO} "#-#-#-# Verificando Cifras Permitidas em SSL versao 2 (Cifras Medias)..."
     for((i=0;i<$SSL2_CIFRAS_MEDIAS_TOTAL;i++)); do
        ${ECHO} $HTTP_REQUEST | ${OPENSSL} s_client -ssl2 -connect $hostname:$porta -cipher ${SSL2_CIFRAS_MEDIAS[${i}]} &> $ARQ_TMP
        Retorno=`${GREP} "$STRING" $ARQ_TMP | ${WC} -l`
        if [ $Retorno -eq 0 ]; then
                ${ECHO} -n ""
        else
                ${ECHO} "[${SSL2_CIFRAS_MEDIAS[${i}]}]"
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_MEDIAS[${i}]}  | ${SED} 's/Kx/"\nAlgoritmo_de_Troca_de_Chaves/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_MEDIAS[${i}]}  | ${SED} 's/Au/\nAutenticacao/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_MEDIAS[${i}]}  | ${SED} 's/Enc/\nCriptografia_Simetrica/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_MEDIAS[${i}]}  | ${SED} 's/Mac/\nMandatory_Acess_Control/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
        fi  
      done
  ${ECHO} "#-#-#-# Finalizado Checagem de Cifras."
}       

function checa_cifras_ssl2_fortes {
  if [ -f $ARQ_TMP ]; then
        ${RM} $ARQ_TMP
  fi      
  ${ECHO} "#-#-#-# Verificando Cifras Permitidas em SSL versao 2 (Cifras Fortes)..."
     for((i=0;i<$SSL2_CIFRAS_FORTES_TOTAL;i++)); do
        ${ECHO} $HTTP_REQUEST | ${OPENSSL} s_client -ssl2 -connect $hostname:$porta -cipher ${SSL2_CIFRAS_FORTES[${i}]} &> $ARQ_TMP
        Retorno=`${GREP} "$STRING" $ARQ_TMP | ${WC} -l`
        if [ $Retorno -eq 0 ]; then
                ${ECHO} -n ""
        else
                ${ECHO} "[${SSL2_CIFRAS_FORTES[${i}]}]"
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_FORTES[${i}]}  | ${SED} 's/Kx/"\nAlgoritmo_de_Troca_de_Chaves/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_FORTES[${i}]}  | ${SED} 's/Au/\nAutenticacao/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_FORTES[${i}]}  | ${SED} 's/Enc/\nCriptografia_Simetrica/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_FORTES[${i}]}  | ${SED} 's/Mac/\nMandatory_Acess_Control/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
        fi  
      done
  ${ECHO} "#-#-#-# Finalizado Checagem de Cifras."
}       

function checa_cifras_ssl2_exportadas {
  if [ -f $ARQ_TMP ]; then
        ${RM} $ARQ_TMP
  fi      
  ${ECHO} "#-#-#-# Verificando Cifras Permitidas em SSL versao 2 (Cifras Exportadas)..."
     for((i=0;i<$SSL2_CIFRAS_EXPORTADAS_TOTAL;i++)); do
        ${ECHO} $HTTP_REQUEST | ${OPENSSL} s_client -ssl2 -connect $hostname:$porta -cipher ${SSL2_CIFRAS_EXPORTADAS[${i}]} &> $ARQ_TMP
        Retorno=`${GREP} "$STRING" $ARQ_TMP | ${WC} -l`
        if [ $Retorno -eq 0 ]; then
                ${ECHO} -n ""
        else
                ${ECHO} "[${SSL2_CIFRAS_EXPORTADAS[${i}]}]"
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_EXPORTADAS[${i}]}  | ${SED} 's/Kx/"\nAlgoritmo_de_Troca_de_Chaves/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_EXPORTADAS[${i}]}  | ${SED} 's/Au/\nAutenticacao/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_EXPORTADAS[${i}]}  | ${SED} 's/Enc/\nCriptografia_Simetrica/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
                ${ECHO} -e \\t`${OPENSSL} ciphers -v ${SSL2_CIFRAS_EXPORTADAS[${i}]}  | ${SED} 's/Mac/\nMandatory_Acess_Control/g' | ${TAIL} -n 1 | ${CUT} -d' ' -f1`
        fi  
      done
  ${ECHO} "#-#-#-# Finalizado Checagem de Cifras."
}       



EXPECTED_ARGS=3
E_BADARGS=-1

if [ $# -le $EXPECTED_ARGS ]; then
  ${ECHO} "**** Kryptonia - SSL Cipher Check v0.1"
  ${ECHO} "Uso: `basename $0` {versao} {robustez} {hostname} {porta}"
  ${ECHO} ""
  ${ECHO} "versao   -   Versao SSL. Pode ser: tls1, ssl2 ou ssl3."
  ${ECHO} "robustez -   Checar Cifras de determinada Robustez. Pode ser: fracas,medias,fortes ou exportadas."
  ${ECHO} "hostname -   Servidor SSL a ser checado. Exemplo: www.securitylabs.com.br"
  ${ECHO} "porta    -   Porta SSL."
  ${ECHO} ""
  ${ECHO} "Exemplo de Uso:"
  ${ECHO} " $0 tls1 fracas www.securitylabs.com.br 443"
  ${ECHO} ""
  exit $E_BADARGS
fi


case "$1" in
'tls1')
 case "$2" in
 'fracas')
   hostname="$3"
   porta="$4"
   checa_conexao
   checa_cifras_tls1_fracas
 ;;
 'medias')
   hostname="$3"
   porta="$4"
   checa_conexao
   checa_cifras_tls1_medias
 ;;
 'fortes')
   hostname="$3"
   porta="$4"
   checa_conexao
   checa_cifras_tls1_fortes
 ;;
 'exportadas')
   hostname="$3"
   porta="$4"
   checa_conexao
   checa_cifras_tls1_exportadas
 ;;
 *)
  ${ECHO} "Opcao Invalida: robustez"
 esac
  ;;
'ssl2')
       case "$2" in
        'fracas')
          hostname="$3"
          porta="$4"   
   checa_conexao
          checa_cifras_ssl2_fracas
        ;;
        'medias')
          hostname="$3"
          porta="$4"   
   checa_conexao
          checa_cifras_ssl2_medias
        ;;
        'fortes')
          hostname="$3"
          porta="$4"
   checa_conexao
   checa_cifras_ssl2_fortes
 ;;
       'exportadas')
          hostname="$3"
          porta="$4"
   checa_conexao
          checa_cifras_ssl2_exportadas
        ;;
        *)
         ${ECHO} "Opcao Invalida: robustez"
        esac
  ;;
#O OpenSSL trata o SSLv3 como TLSv1.
'ssl3')
        case "$2" in
        'fracas')
          hostname="$3"
          porta="$4"
   checa_conexao
          checa_cifras_tls1_fracas
        ;;
        'medias')
          hostname="$3"
          porta="$4"
   checa_conexao
          checa_cifras_tls1_medias
        ;;
        'fortes')
          hostname="$3"
          porta="$4"
   checa_conexao
          checa_cifras_tls1_fortes
        ;;
        'exportadas')
          hostname="$3"
          porta="$4"
   checa_conexao
          checa_cifras_tls1_exportadas
        ;;
        *)
         ${ECHO} "Opcao Invalida: robustez"
        esac
  ;;
*)
  echo "Opcao invalida: versao"
esac

#EOF
-----------------------------------------------------------------------------------------------







Postado por às

Nenhum comentário:

Postar um comentário

Comentários são moderados visando evitar spams e permitir discussões sadias.

Assinar: Postar comentários (Atom)