Segurança

Assim como qualquer software que tenha interface gráfica, nos sites, a maior parte de dados têm como entrada os formulários.

O grande problema, é que na internet, esses formulários estão na maioria das vezes expostos à qualquer um que tenha acesso a rede.

Problemas estes, que não existiriam se todos os desenvolvedores se preocupassem em tratar essas entradas de dados.

Um formulário pode ser explorado por uma pessoa mal intencionada das seguintes formas:

• File Injection
  Ocorre em campos para upload de arquivos para o site. Muito utilizado em upload de fotos, arquivos de currículos, etc. Uma pessoa mal intencionada poderá fazer upload de xploits do mais diversos tipos e que exploram diversas falhas em servidores, desde falha em permissões até a execução de códigos maliciosos.
  
  Ataques realizado através destes xploits são muito difíceis de detectar pois são originados na porta 80, e o armazenamento desse xploit poderá ser feito em qualquer diretório do site que esteja acessível pela porta 80.
  
  Exemplo de xploit bem utilizado em campos de upload: Rhtools
  
  Como evitar?
  
  1 - Validação do tipo de arquivo no lado do cliente.
  
  2 - Validação do tipo de arquivo no lado do servidor.
  
  3 - Aceitar somente extensões de arquivos confiáveis.
  
  4 - Aceitar somente arquivos com extensões esperadas, ou seja, num campo de currículo, aceitar somente arquivos .doc ou .pdf, num campo de foto aceitar somente .png, .jpg, .gif ou .tiff
  
  
• SQL Injection
  Ocorre em qualquer campo com entrada de dados no formato texto e que tenha ligação com o banco de dados. Uma pessoa mal intencionada poderá passar comandos SQL através de um scape usando ' (áspas simples) e logo após sua instrução maliciosa como "DELETE * FROM contas WHERE 1=1".
  
  Como evitar?
  
  1 - Validação/remoção de caracteres "especiais" do lado cliente
  
  2 - Validação/remoção de caracteres "especiais" do lado servidor 
  
  
• Data Flood
  Ocorre em formulários do tipo "cadastro" com inserção das informações diretamente no banco de dados. Uma pessoa mal intencionada, poderá realizar milhares e até milhões de novos cadastros, e com isso causar diversos transtornos no banco e no software em si, já que o software depende do bom funcionamento do banco consecutivamente.
  
  Em hostings comerciais, onde os ambientes e recursos são compartilhados, é sabido que, mesmo usando SGDBs de grande porte como PostgreSQL, Oracle e SQL Server, tabelas contendo em média ou acima de 10 mil registros, começam a responder de forma muito lenta querys simples como "SELECT id FROM produtos WHERE 1=1;". Alguns servidores começam a "responder de forma lenta" com menos registros, como 5 mil por exemplo. Leve em consideração, que muitos SGDBs, mesmo após você ter excluído o registro, o mesmo "permanece na memória" a fim de futura recuperação deste registro. A exemplo disto, podemos citar o "VACUUM" do PostgreSQl que tem com uma de suas funções, "apagar essa memória recuperável".
  
  Como evitar?
  
  1 - Usar Captcha.
  
  2 - A imagens usadas em Captcha deverão ter fundo com illustrações a fim de evitar a leitura da mesma via OCR.
  
  3 - O código sequencial da Captcha nunca poderá ser repetido, pois mesmo sem OCR, existe possibilidade de recuperar a imagem da Captcha e retorná-la dentro do xploit usado no ataque.

Antes de qualquer coisa, é preciso saber que toda “estrutura computacional” possui “limites”. Limites estes do mais diversos tipos, como “limite de processamento”, “limite de conexões simultâneas”, “limite de armazenagem”, e por ai vai.

Um site, pra poder “ser acessível” pelas pessoas, precisa “estar hospedado” em uma “estrutura computacional” que tenha ligação direta com a internet.

Esta estrutura onde ele está hospedado se caracteriza pelo conjunto de “aparatos” necessários “para que o conteúdo do site” possa ser servido para a internet. Dentre estes aparatos, estão equipamentos como computadores de alta disponibilidade, switchs e roteadores por exemplo. Vale ressaltar que cada equipamento desses, possui seus próprios ”limites”.

Para que um site seja “servido” na internet sem nenhum problema, dois destes limites não poderão jamais ser “extrapolados”, e são eles:

1. Limite de Tráfego ou Banda – quando se excede a banda disponível para o site, o mesmo pode ficar inacessível.
2. Limite de Conexões simultâneas – sabe-se que todo banco de dados têm limites de acessos simultâneos, e em servidores comerciais esse número de conexões simultâneas geralmente não podem passar de 100 conexões.

Em ambas as situações o site poderá sair do ar.

O ataque DoS, ou Denial of Service, tem como propósito explorar estes “limites” e consecutivamente tirar o site do ar através de um grande número de conexões e operações simultâneas no site alvo.

Alguns ataques DoS não são necessariamente para tirar o site do ar, mas poderão criar muitos transtornos prejudicando serviços de e-mails, lentidão nas redes, dentre outros.

Como são feitos os ataques DoS?

Os ataques DOS podem ser feitos de diversas formas e podem ter diversos “tipos de alvos”. Mas um conceito que é comum á todos, é de que o “atacante” obtém controle de computadores diversos, e através deles realiza um grande número de requisições ao servidor alvo ao mesmo tempo.

Vale dizer que apesar dos ataques terem essa característica em comum, os “limites”que eles exploram nem sempre são os mesmos.

Alguns ataques propõem causar problemas no DNS (serviço de resolução de domínios), outros já exploram os limites do banco de dados ao realizar diversos cadastros ao mesmo tempo em um formulário no site, outros visam onerar os servidores de e-mail disparando milhões de mensagens falsas ao mesmo tempo. Enfim, as possibilidades são muitas.

Através de LOGs e varreduras é possível identificar as origens dos ataques e bloqueá-los consecutivamente.

Apesar de ser um tipo de ataque bem antigo, é obvio que sempre irão existir. Por isso é necessário tomar muitos cuidados tanto com as estruturas computacionais, tanto com a estrutura dos sites e aplicativos web em si.

Lembre-se, segurança nunca é demais.

Hoje em dia, muitos administradores de servidores e afins pesquisam sobre novas vulnerabilidades e novos tipos de ataques.

O que muitos não sabem, é que grandas ataques, e muitas das vezes devastadores, são originados por vulnerabilidades e más práticas bem antigas.

Recentemente foram reportados ataques a diversos servidores conhecidos (ex.: Locaweb) através de táticas bem "pré-históricas", "a exploração de permissões" em diretórios de hospedagem web bem como no disco todo.

Aproveitando a oportunidade, vou falar uma pouco sobre "PERMISSÕES".

Permissões e descritores de segurança

Todo recipiente e objeto da rede possui um conjunto de informações sobre o controle de acesso anexado a ele. Denominadas descritores de segurança, essas informações controlam o tipo de acesso permitido a usuários e grupos.

O descritor de segurança é criado automaticamente junto com o recipiente ou objeto. Um arquivo é um exemplo comum de um objeto com um descritor de segurança. As permissões são definidas em um descritor de segurança do objeto. Elas são associadas a usuários e grupos específicos, ou a eles atribuídas.

Por exemplo, para o arquivo Temp.dat, ao grupo interno Administradores podem ser atribuídas as permissões Ler, Gravar e Excluir, enquanto ao grupo Operadores de backup podem ser atribuídas apenas as permissões Ler e Gravar.

Cada atribuição de permissões a um usuário ou grupo é representada no sistema como uma entrada de permissão ou entrada de controle de acesso (ACE). O conjunto todo de entradas de permissão em um descritor de segurança é conhecido como conjunto de permissões ou lista de controle de acesso (ACL). Portanto, para um arquivo denominado Temp.dat, o conjunto de permissões inclui duas entradas de permissão, uma para o grupo interno Administradores e outra para o grupo Operadores de backup.

Todo recipiente e objeto da rede possui um conjunto de informações sobre o controle de acesso anexado a ele. Denominadas descritores de segurança, essas informações controlam o tipo de acesso permitido a usuários e grupos. As permissões são definidas em um descritor de segurança do objeto. Elas são associadas a usuários e grupos específicos, ou a eles atribuídas.

Permissões explícitas e herdadas

Há dois tipos de permissão: permissões explícitas e permissões herdadas.

• As permissões explícitas são aquelas definidas por padrão em objetos que não são filho quando o objeto é criado ou por ação do usuário em objetos pai, filho ou que não são filho.
  
  
• As permissões herdadas são as propagadas até um objeto a partir de um objeto pai. As permissões herdadas facilitam a tarefa de gerenciar permissões e garantir a consistência das permissões em todos os objetos de um determinado recipiente.

Por padrão, os objetos de um recipiente herdam as permissões desse recipiente ao serem criados. Por exemplo, quando você cria uma pasta denominada MinhaPasta, todas as subpastas e todos os arquivos criados nela herdam automaticamente as suas permissões. Portanto, MinhaPasta possui permissões explícitas e as subpastas e os arquivos terão permissões herdadas.

Para proteger um computador e seus recursos, leve em consideração os direitos a serem concedidos aos usuários. Você pode proteger um ou vários computadores, concedendo direitos de usuário específicos a usuários ou grupos. Você pode proteger um objeto, como um arquivo ou uma pasta, atribuindo permissões que permitam que usuários ou grupos executem ações específicas nesse objeto.

Qualquer arquivo, pra que possa ser executado, ele deverá ter "permissões" para o mesmo.

Todo arquivo, pra ser executado, deverá ser executado por algum usuário do sistema operacional.

Os servidores web (IIS, Apache, Nginx, etc), precisam usar um usuário do sistema operacional para servir conteúdo para web.

Exemplo de política de Permissões

Para muitos leigos, Hackers se tornam quase uma figura exclusivamente de ficção científica, invadindo sistemas com efeitos visuais, como isso se acontecesse por meio de mágica ou algo parecido.

Mas a realidade, é que toda invasão ou qualquer outro problema de segurança só existe mediante à negligência humana, seja no desenvolvimento, seja no uso do software.

Afirmar que um software ou um ambiente é 100% seguro é um tanto quanto "complexo" e até mesmo impossível as vezes. Porém fica claro cada vez mais que o número crescente de ataques é proporcional ao número crescente de desenvolvedores que se preocupam cada vez menos com Segurança e Engenharia.

Muito se fala em testes unitários, padrão de qualidade de software, mas a realidade é que até mesmo grandes empresas acabam negligenciando muita coisa que deveriam ser observadas no desenvolvimento de softwares, web ou não.

O crescimento "exponencial" da web deve-se muito á agências de publicidades, programadores autônomos, vasto repositório open source de scripts (muitos em PHP). E nesse crescimento, devemos fazer algumas observações

1. Agência de Publicidades é Agência de Publicidade! Reduntante? Não, estou querendo dizer, que o trabalho de colocar um site no ar ta muito além de ter layouts bonitos. Agências de publicidade, desenvolvem site tendo apenas um Designer e um Programador nível Junior. Ai vem o questionamento? Não seria necessário um engenheiro no processo de produção? Não seria necessário um DBA no projeto?
   
   
2. Assim como é possível encontrar fontes completos de aplicativos Delphi na internet, o mesmo acontece com sistemas de e-commerces, sistemas CMS (Content Management System - O TI do Governo adora), Sistemas Acadêmicos, sistemas de todas as naturezas. 80% desses scripts open source são em PHP. Isso é de fato um fator positivo se for observar a velocidade do crescimento da internet. Mas por outro lado, isso criou um verdadeiro "câncer" na web.
   
   
3. O problema todo está no simples fato da maioria dos usuários desses sistemas baixarem o zip, colocar a logo deles, e, indiscriminadamente colocar o mesmo na web sem sequer fazer alguns testes de segurança, ou até mesmo estudar o aplicativo todo antes. O software Open Source é excelente em vários aspectos, inclusive no social, porém, tem esse lado negativo de possibilitar que qualquer uma pessoa má intencionada conheça o código.
   
   
4. Um só website vulnerável pode comprometer todo o servidor (dependendo de outros fatores que irei abordar mais a frente)
   
   
5. Estudante é estudante, Profissional é profissional! Outro grande problema, estudantes que deveriam produzir a caráter de estudo, produzem não só para o estudo, mas acabam colocando esses aplicativos em produção, e é onde de fato, existe várias "lacunas" que muitas vezes não são preenchidas.
   
   
6. A maoiria das empresas que fornecem soluções para internet não conseguem acompanhar o rítimo de crescimento e a demanda de novas pesquisas e melhorias.
   
   
7. Até mesmo um site de puro HTML pode ser atacado, o que afirma ainda mais a afirmativa que falta especialização e capacidade técnica de muitos fornecedores desse mercado.

Negligência no processo produtivo

Atualmente, é grande o número de empresas que se aventuram no mercado de softwares sem sequer se preocupar com fatores de segurança ou até mesmo sem conhecê-los.
A negligência no processo produtivo de um software, é de fato o que o deixa mais vulnerável à ataques de todos os tipos

À seguir, segue lista de erros mais comuns cometidos em processos produtivos:

1. Ausência de máscaras e validações em "inputs" de formulários do lado do cliente e do lado do servidor.
   
   
2. Ausência de validação em "file fields" de formulários do lado do cliente e do lado do servidor.
   |
3. Ausência de tratamento de URLs
   
   
4. Ausência de sistemas de identificação de requisitores (software aceita requisição de qualquer endereço).
   
   
5. Ausência de Captcha em formulários, ou Captcha sem imagem.
   
   
6. Deixar "comandos" expostos em URLs, ex.: http://www.acme.com.br/gerenciador.php?acao=delete&id=3
   
7. Ausência de testes de segurança ao escolher um hosting.

Negligência do usuário final

O usuário final de um software é sem dúvida outro fator que deveria ser observado quando se pensa em segurança.

Ainda que tenhamos produzido um software dentro de "normas e padrões" de segurança, o mesmo ainda poderá ser explorado de forma criminosa através do mal uso de seus usuários. A exemplo disso, podemos citar clientes de banco que acessam o "internet banking" através de computadores infectados por trojans e worms de diversos tipos.

Cabe ao "mantenedor" do software trabalhar constantemente essa temática com os usuários do mesmo.

Vejamos algumas funções de trojans e worms:

1. Keylloger - Recupera e armazena todas as teclas que foram acionadas no teclado a partir de determinado momento (ao acessar o site do banco por exemplo)
   
   
2. DNS Redirect - Armazena na máquina local, mapeamentos DNS redirecionando o cliente para IPs contendo o site clonado do banco.
   
   
3. Screenshoter - Captura "print screen" da tela do usuário.
   
   
4. Explorar aplicativos de mensagem instantânea para propagação da praga.
   
   
5. Explorar clients de e-mail para propagação da praga.

Nos últimos tempos, um problema recorrente e perigoso em aplicações web conhecido como CSRF (Cross-Site Request Forgery) tem sido muito comentado.

Um ataque de CSRF consiste em inserir requisições em uma sessão já aberta pelo usuário.

O processo básico é: o usuário se autentica em uma aplicação web alvo o usuário utiliza a mesma instância de browser para navegar em um site malévolo o site malévolo manipula o browser para que seja feita uma requisição à aplicação alvo como há uma sessão autenticada aberta para o usuário, a aplicação alvo executa a operação conforme a requisição recebida.

Ou seja, o site malévolo consegue manipular a situação de forma a executar uma ação em nome do usuário. A manipulação do browser citada no item 3 acima pode ser feita de várias formas: se a aplicação alvo aceitar requisições via método GET, basta incluir uma tag <img > contendo todos os parâmetros necessários à aplicação alvo (qualquer outra tag que faça uma requisição HTTP funcionará da mesma forma); usando scripts incluídos na página, o que permite a execução de requisições GET ou POST.

Este ataque é extremamente difícil de ser detectado, dado que um identificador de sessão correto e válido será incluído na requisição recebida pela aplicação e a requisição partirá do mesmo browser e endereço IP das requisições legítimas. A aplicação web não como separar a requisição correspondente ao ataque das requisições legítimas.

É o estudo dos princípios e técnicas pelas quais a informação pode ser transformada da sua forma original para outra ilegível, de forma que possa ser conhecida apenas por seu destinatário (detentor da "chave secreta"), o que a torna difícil de ser lida por alguém não autorizado. Assim sendo, só o receptor da mensagem pode ler a informação com facilidade.

A criptografia é um ramo da matemática.

Tipos de criptografia:

1. Por chave simétrica
2. Por chave assimétrica
3. Por Hash
4. Quântica (em desenvolvimento)

A criptografia, pode ser implementada utilizando algorítimos e especificações já existentes ou poderá ser criado um novo modelo para tal. Vejamos alguns dos algorítimos / especificações mais utilizadas na internet.

MD5

O MD5 (Message-Digest algorithm 5) é um algoritmo de hash de 128 bits unidirecional desenvolvido pela RSA Data Security, Inc., descrito na RFC 1321, e muito utilizado por softwares com protocolo ponto-a-ponto (P2P, ou Peer-to-Peer, em inglês) na verificação de integridade de arquivos e logins.

Por ser um algoritmo unidirecional, uma hash md5 não pode ser transformada novamente no texto que lhe deu origem. O método de verificação é, então, feito pela comparação das duas hash (uma da mensagem original confiável e outra da mensagem recebida). 

O MD5 também é usado para verificar a integridade de um arquivo através, por exemplo, do programa md5sum, que cria a hash de um arquivo. Isto pode-se tornar muito útil para downloads de arquivos grandes, para programas P2P que constroem o arquivo através de pedaços e estão sujeitos a corrupção dos mesmos. Como autenticação de login é utilizada em vários sistemas operacionais unix e em muitos sites com autentificação.

Salting
Como o uso de MD5 se dá por comparação de de strings e não há uma chave distinta na geração do hash, uma pessoa mal intencionada, que sabe que alguem tem uma senha como "123456" poderá obter o hash dessa string facilmente.

Para evitar isso, existe uma técnica chamada de Salting, que nada mais é que adicionar textos fixos às strings, ex.: banestes_123456, onde o texto fixo é "banestes_", assim, o pirata poderá até saber o hash de 123456, mas nao saberá o hash resultante da string original que é banestes_123456.

Implementação MD5 em ASP-VBScript

Private Const BITS_TO_A_BYTE = 8
Private Const BYTES_TO_A_WORD = 4
Private Const BITS_TO_A_WORD = 32

Private m_lOnBits(30)
Private m_l2Power(30)
 
    m_lOnBits(0) = CLng(1)
    m_lOnBits(1) = CLng(3)
    m_lOnBits(2) = CLng(7)
    m_lOnBits(3) = CLng(15)
    m_lOnBits(4) = CLng(31)
    m_lOnBits(5) = CLng(63)
    m_lOnBits(6) = CLng(127)
    m_lOnBits(7) = CLng(255)
    m_lOnBits(8) = CLng(511)
    m_lOnBits(9) = CLng(1023)
    m_lOnBits(10) = CLng(2047)
    m_lOnBits(11) = CLng(4095)
    m_lOnBits(12) = CLng(8191)
    m_lOnBits(13) = CLng(16383)
    m_lOnBits(14) = CLng(32767)
    m_lOnBits(15) = CLng(65535)
    m_lOnBits(16) = CLng(131071)
    m_lOnBits(17) = CLng(262143)
    m_lOnBits(18) = CLng(524287)
    m_lOnBits(19) = CLng(1048575)
    m_lOnBits(20) = CLng(2097151)
    m_lOnBits(21) = CLng(4194303)
    m_lOnBits(22) = CLng(8388607)
    m_lOnBits(23) = CLng(16777215)
    m_lOnBits(24) = CLng(33554431)
    m_lOnBits(25) = CLng(67108863)
    m_lOnBits(26) = CLng(134217727)
    m_lOnBits(27) = CLng(268435455)
    m_lOnBits(28) = CLng(536870911)
    m_lOnBits(29) = CLng(1073741823)
    m_lOnBits(30) = CLng(2147483647)
    
    m_l2Power(0) = CLng(1)
    m_l2Power(1) = CLng(2)
    m_l2Power(2) = CLng(4)
    m_l2Power(3) = CLng(8)
    m_l2Power(4) = CLng(16)
    m_l2Power(5) = CLng(32)
    m_l2Power(6) = CLng(64)
    m_l2Power(7) = CLng(128)
    m_l2Power(8) = CLng(256)
    m_l2Power(9) = CLng(512)
    m_l2Power(10) = CLng(1024)
    m_l2Power(11) = CLng(2048)
    m_l2Power(12) = CLng(4096)
    m_l2Power(13) = CLng(8192)
    m_l2Power(14) = CLng(16384)
    m_l2Power(15) = CLng(32768)
    m_l2Power(16) = CLng(65536)
    m_l2Power(17) = CLng(131072)
    m_l2Power(18) = CLng(262144)
    m_l2Power(19) = CLng(524288)
    m_l2Power(20) = CLng(1048576)
    m_l2Power(21) = CLng(2097152)
    m_l2Power(22) = CLng(4194304)
    m_l2Power(23) = CLng(8388608)
    m_l2Power(24) = CLng(16777216)
    m_l2Power(25) = CLng(33554432)
    m_l2Power(26) = CLng(67108864)
    m_l2Power(27) = CLng(134217728)
    m_l2Power(28) = CLng(268435456)
    m_l2Power(29) = CLng(536870912)
    m_l2Power(30) = CLng(1073741824)

Private Function LShift(lValue, iShiftBits)
    If iShiftBits = 0 Then
        LShift = lValue
        Exit Function
    ElseIf iShiftBits = 31 Then
        If lValue And 1 Then
            LShift = &H80000000
        Else
            LShift = 0
        End If
        Exit Function
    ElseIf iShiftBits < 0 Or iShiftBits > 31 Then
        Err.Raise 6
    End If

    If (lValue And m_l2Power(31 - iShiftBits)) Then
        LShift = ((lValue And m_lOnBits(31 - (iShiftBits + 1))) * m_l2Power(iShiftBits)) Or &H80000000
    Else
        LShift = ((lValue And m_lOnBits(31 - iShiftBits)) * m_l2Power(iShiftBits))
    End If
End Function

Private Function RShift(lValue, iShiftBits)
    If iShiftBits = 0 Then
        RShift = lValue
        Exit Function
    ElseIf iShiftBits = 31 Then
        If lValue And &H80000000 Then
            RShift = 1
        Else
            RShift = 0
        End If
        Exit Function
    ElseIf iShiftBits < 0 Or iShiftBits > 31 Then
        Err.Raise 6
    End If
    
    RShift = (lValue And &H7FFFFFFE) \ m_l2Power(iShiftBits)

    If (lValue And &H80000000) Then
        RShift = (RShift Or (&H40000000 \ m_l2Power(iShiftBits - 1)))
    End If
End Function

Private Function RotateLeft(lValue, iShiftBits)
    RotateLeft = LShift(lValue, iShiftBits) Or RShift(lValue, (32 - iShiftBits))
End Function

Private Function AddUnsigned(lX, lY)
    Dim lX4
    Dim lY4
    Dim lX8
    Dim lY8
    Dim lResult
 
    lX8 = lX And &H80000000
    lY8 = lY And &H80000000
    lX4 = lX And &H40000000
    lY4 = lY And &H40000000
 
    lResult = (lX And &H3FFFFFFF) + (lY And &H3FFFFFFF)
 
    If lX4 And lY4 Then
        lResult = lResult Xor &H80000000 Xor lX8 Xor lY8
    ElseIf lX4 Or lY4 Then
        If lResult And &H40000000 Then
            lResult = lResult Xor &HC0000000 Xor lX8 Xor lY8
        Else
            lResult = lResult Xor &H40000000 Xor lX8 Xor lY8
        End If
    Else
        lResult = lResult Xor lX8 Xor lY8
    End If
 
    AddUnsigned = lResult
End Function

Private Function F(x, y, z)
    F = (x And y) Or ((Not x) And z)
End Function

Private Function G(x, y, z)
    G = (x And z) Or (y And (Not z))
End Function

Private Function H(x, y, z)
    H = (x Xor y Xor z)
End Function

Private Function Iy(x, y, z)
    I = (y Xor (x Or (Not z)))
End Function

Private Sub FF(a, b, c, d, x, s, ac)
    a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac))
    a = RotateLeft(a, s)
    a = AddUnsigned(a, b)
End Sub

Private Sub GG(a, b, c, d, x, s, ac)
    a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac))
    a = RotateLeft(a, s)
    a = AddUnsigned(a, b)
End Sub

Private Sub HH(a, b, c, d, x, s, ac)
    a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac))
    a = RotateLeft(a, s)
    a = AddUnsigned(a, b)
End Sub

Private Sub II(a, b, c, d, x, s, ac)
    a = AddUnsigned(a, AddUnsigned(AddUnsigned(Iy(b, c, d), x), ac))
    a = RotateLeft(a, s)
    a = AddUnsigned(a, b)
End Sub

Private Function ConvertToWordArray(sMessage)
    Dim lMessageLength
    Dim lNumberOfWords
    Dim lWordArray()
    Dim lBytePosition
    Dim lByteCount
    Dim lWordCount
    
    Const MODULUS_BITS = 512
    Const CONGRUENT_BITS = 448
    
    lMessageLength = Len(sMessage)
    
    lNumberOfWords = (((lMessageLength + ((MODULUS_BITS - CONGRUENT_BITS) \ BITS_TO_A_BYTE)) \ (MODULUS_BITS \ BITS_TO_A_BYTE)) + 1) * (MODULUS_BITS \ BITS_TO_A_WORD)
    ReDim lWordArray(lNumberOfWords - 1)
    
    lBytePosition = 0
    lByteCount = 0
    Do Until lByteCount >= lMessageLength
        lWordCount = lByteCount \ BYTES_TO_A_WORD
        lBytePosition = (lByteCount Mod BYTES_TO_A_WORD) * BITS_TO_A_BYTE
        lWordArray(lWordCount) = lWordArray(lWordCount) Or LShift(Asc(Mid(sMessage, lByteCount + 1, 1)), lBytePosition)
        lByteCount = lByteCount + 1
    Loop

    lWordCount = lByteCount \ BYTES_TO_A_WORD
    lBytePosition = (lByteCount Mod BYTES_TO_A_WORD) * BITS_TO_A_BYTE

    lWordArray(lWordCount) = lWordArray(lWordCount) Or LShift(&H80, lBytePosition)

    lWordArray(lNumberOfWords - 2) = LShift(lMessageLength, 3)
    lWordArray(lNumberOfWords - 1) = RShift(lMessageLength, 29)
    
    ConvertToWordArray = lWordArray
End Function

Private Function WordToHex(lValue)
    Dim lByte
    Dim lCount
    
    For lCount = 0 To 3
        lByte = RShift(lValue, lCount * BITS_TO_A_BYTE) And m_lOnBits(BITS_TO_A_BYTE - 1)
        WordToHex = WordToHex & Right("0" & Hex(lByte), 2)
    Next
End Function

Public Function MD5(sMessage)
    Dim x
    Dim k
    Dim AA
    Dim BB
    Dim CC
    Dim DD
    Dim a
    Dim b
    Dim c
    Dim d
    
    Const S11 = 7
    Const S12 = 12
    Const S13 = 17
    Const S14 = 22
    Const S21 = 5
    Const S22 = 9
    Const S23 = 14
    Const S24 = 20
    Const S31 = 4
    Const S32 = 11
    Const S33 = 16
    Const S34 = 23
    Const S41 = 6
    Const S42 = 10
    Const S43 = 15
    Const S44 = 21

    x = ConvertToWordArray(sMessage)
    
    a = &H67452301
    b = &HEFCDAB89
    c = &H98BADCFE
    d = &H10325476

    For k = 0 To UBound(x) Step 16
        AA = a
        BB = b
        CC = c
        DD = d
    
        FF a, b, c, d, x(k + 0), S11, &HD76AA478
        FF d, a, b, c, x(k + 1), S12, &HE8C7B756
        FF c, d, a, b, x(k + 2), S13, &H242070DB
        FF b, c, d, a, x(k + 3), S14, &HC1BDCEEE
        FF a, b, c, d, x(k + 4), S11, &HF57C0FAF
        FF d, a, b, c, x(k + 5), S12, &H4787C62A
        FF c, d, a, b, x(k + 6), S13, &HA8304613
        FF b, c, d, a, x(k + 7), S14, &HFD469501
        FF a, b, c, d, x(k + 8), S11, &H698098D8
        FF d, a, b, c, x(k + 9), S12, &H8B44F7AF
        FF c, d, a, b, x(k + 10), S13, &HFFFF5BB1
        FF b, c, d, a, x(k + 11), S14, &H895CD7BE
        FF a, b, c, d, x(k + 12), S11, &H6B901122
        FF d, a, b, c, x(k + 13), S12, &HFD987193
        FF c, d, a, b, x(k + 14), S13, &HA679438E
        FF b, c, d, a, x(k + 15), S14, &H49B40821
    
        GG a, b, c, d, x(k + 1), S21, &HF61E2562
        GG d, a, b, c, x(k + 6), S22, &HC040B340
        GG c, d, a, b, x(k + 11), S23, &H265E5A51
        GG b, c, d, a, x(k + 0), S24, &HE9B6C7AA
        GG a, b, c, d, x(k + 5), S21, &HD62F105D
        GG d, a, b, c, x(k + 10), S22, &H2441453
        GG c, d, a, b, x(k + 15), S23, &HD8A1E681
        GG b, c, d, a, x(k + 4), S24, &HE7D3FBC8
        GG a, b, c, d, x(k + 9), S21, &H21E1CDE6
        GG d, a, b, c, x(k + 14), S22, &HC33707D6
        GG c, d, a, b, x(k + 3), S23, &HF4D50D87
        GG b, c, d, a, x(k + 8), S24, &H455A14ED
        GG a, b, c, d, x(k + 13), S21, &HA9E3E905
        GG d, a, b, c, x(k + 2), S22, &HFCEFA3F8
        GG c, d, a, b, x(k + 7), S23, &H676F02D9
        GG b, c, d, a, x(k + 12), S24, &H8D2A4C8A
            
        HH a, b, c, d, x(k + 5), S31, &HFFFA3942
        HH d, a, b, c, x(k + 8), S32, &H8771F681
        HH c, d, a, b, x(k + 11), S33, &H6D9D6122
        HH b, c, d, a, x(k + 14), S34, &HFDE5380C
        HH a, b, c, d, x(k + 1), S31, &HA4BEEA44
        HH d, a, b, c, x(k + 4), S32, &H4BDECFA9
        HH c, d, a, b, x(k + 7), S33, &HF6BB4B60
        HH b, c, d, a, x(k + 10), S34, &HBEBFBC70
        HH a, b, c, d, x(k + 13), S31, &H289B7EC6
        HH d, a, b, c, x(k + 0), S32, &HEAA127FA
        HH c, d, a, b, x(k + 3), S33, &HD4EF3085
        HH b, c, d, a, x(k + 6), S34, &H4881D05
        HH a, b, c, d, x(k + 9), S31, &HD9D4D039
        HH d, a, b, c, x(k + 12), S32, &HE6DB99E5
        HH c, d, a, b, x(k + 15), S33, &H1FA27CF8
        HH b, c, d, a, x(k + 2), S34, &HC4AC5665
    
        II a, b, c, d, x(k + 0), S41, &HF4292244
        II d, a, b, c, x(k + 7), S42, &H432AFF97
        II c, d, a, b, x(k + 14), S43, &HAB9423A7
        II b, c, d, a, x(k + 5), S44, &HFC93A039
        II a, b, c, d, x(k + 12), S41, &H655B59C3
        II d, a, b, c, x(k + 3), S42, &H8F0CCC92
        II c, d, a, b, x(k + 10), S43, &HFFEFF47D
        II b, c, d, a, x(k + 1), S44, &H85845DD1
        II a, b, c, d, x(k + 8), S41, &H6FA87E4F
        II d, a, b, c, x(k + 15), S42, &HFE2CE6E0
        II c, d, a, b, x(k + 6), S43, &HA3014314
        II b, c, d, a, x(k + 13), S44, &H4E0811A1
        II a, b, c, d, x(k + 4), S41, &HF7537E82
        II d, a, b, c, x(k + 11), S42, &HBD3AF235
        II c, d, a, b, x(k + 2), S43, &H2AD7D2BB
        II b, c, d, a, x(k + 9), S44, &HEB86D391
    
        a = AddUnsigned(a, AA)
        b = AddUnsigned(b, BB)
        c = AddUnsigned(c, CC)
        d = AddUnsigned(d, DD)
    Next
    
    MD5 = LCase(WordToHex(a) & WordToHex(b) & WordToHex(c) & WordToHex(d))
End Function

sinopse:

response.write MD5("senha")

SHA-1

Usada numa grande variedade de aplicações e protocolos de segurança, incluindo TLS, SSL, PGP, SSH, S/MIME e IPSec. SHA-1 foi considerado o sucessor do MD5.

Ambos têm vulnerabilidades comprovadas.

Em algumas correntes, é sugerido que o SHA-256 ou superior seja usado para tecnologia crítica.

Usado pelo emule para verificar duplicidade e integridade de arquivos

RSA

RSA é um algoritmo de criptografia de dados, que deve o seu nome a três professores do Instituto MIT (fundadores da actual empresa RSA Data Security, Inc.), Ronald Rivest, Adi Shamir e Leonard Adleman.

A mais bem sucedida implementação de sistemas de chaves assimétricas até 2008, e fundamenta-se em teorias clássicas dos números.

É considerado dos mais seguros, já que mandou por terra todas as tentativas de quebrá-lo. Foi também o primeiro algoritmo a possibilitar criptografia e assinatura digital, e uma das grandes inovações em criptografia de chave pública. 

O RSA envolve um par de chaves, uma chave pública que pode ser conhecida por todos e uma chave privada que deve ser mantida em sigilo.

Toda mensagem cifrada usando uma chave pública só pode ser decifrada usando a respectiva chave privada.

A criptografia RSA atua diretamente na internet, por exemplo, em mensagens de emails, em compras on-line e o que você imaginar; tudo isso é codificado e recodificado pela criptografia RSA.

DESVANTAGEM

Uma pessoa mal intencionada, que de alguma forma possua acesso direto a chave pública, poderá facilmente "descifrar" strings cifradas com com RSA

Implementação RSA em ASP-VBScript

Dim Base64Chars

Function CryptText(strIn, fubarKey, action)
	Dim n,w1,w2,w3,w4,strOut,c1,c2,c3
	
	Select Case action
			
	Case False

		For n = 1 To Len( strIn ) Step 3
			c1 = Asc( Mid( strIn, n, 1 ) )
			c2 = Asc( Mid( strIn, n + 1, 1 ) + Chr(0) )
			c3 = Asc( Mid( strIn, n + 2, 1 ) + Chr(0) )
			w1 = Int( c1 / 4 ) : w2 = ( c1 And 3 ) * 16 + Int( c2 / 16 )
			If Len( strIn ) >= n + 1 Then 
				w3 = ( c2 And 15 ) * 4 + Int( c3 / 64 ) 
			Else 
				w3 = -1
			End If
			If Len( strIn ) >= n + 2 Then 
				w4 = c3 And 63 
			Else 
				w4 = -1
			End If
			strOut = strOut + mimeencode( w1 ) + mimeencode( w2 ) + _
			mimeencode( w3 ) + mimeencode( w4 )
		Next
		CryptText = strOut
		
	Case True
		
		For n = 1 To Len( strIn ) Step 4
			w1 = mimedecode( Mid( strIn, n, 1 ) )
			w2 = mimedecode( Mid( strIn, n + 1, 1 ) )
			w3 = mimedecode( Mid( strIn, n + 2, 1 ) )
			w4 = mimedecode( Mid( strIn, n + 3, 1 ) )
			If w2 >= 0 Then _
				strOut = strOut + _
				Chr( ( ( w1 * 4 + Int( w2 / 16 ) ) And 255 ) )
			If w3 >= 0 Then _
				strOut = strOut + _
				Chr( ( ( w2 * 16 + Int( w3 / 4 ) ) And 255 ) )
			If w4 >= 0 Then _
				strOut = strOut + _
				Chr( ( ( w3 * 64 + w4 ) And 255 ) )
		Next
		CryptText = strOut
	End Select
End Function

Function mimedecode(strIn)
	Base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
	If Len( strIn ) = 0 Then 
		mimedecode = -1 : Exit Function
	Else
		mimedecode = InStr( Base64Chars, strIn ) - 1
	End If
End Function

Function mimeencode(intIn)
	Base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
	If intIn >= 0 Then 
		mimeencode = Mid( Base64Chars, intIn + 1, 1 ) 
	Else 
		mimeencode = ""
	End If
End Function



sinopse:

descifra: pwd=CryptText(stringcifrada, adminkey, true)

cifra: pwd=CryptText(stringsenhaoriginal, adminkey, false)