< ?php require_once('cast128.class'); ? >
< ?php

$example = new cast128;

$teste = $example->encrypt(“Francisco Pedro da Costa Filho”,”suasenha”);

echo $teste;

echo “

“;

$testebb = $example->decrypt($teste,”suasenha”);

echo $testebb;

? >

em http://www.pedrofilho.com.br/arquivos/cast128.class vc pode baixa a classe do mesmo, vlw …

No windows um excelente programa para chegar o MD5 de arquivos é o md5summer disponivel para download no link abaixo:

http://www.megaupload.com/?d=Y7SMNDGP

No linux existe o comando md5sum que é usado para chegar o md5 de um arquivo, é muito simples de usar, apenas digite no terminal md5sum + nome_do_arquivo que é exibido no terminal o md5 do arquivo, bom é isso espero ter ajudado ….

Mais para minha surpresa pesquisei no site do php sobre as funções de hash nativas e encontrei um recurso bem interessante chamado HMAC ( Hash-based Message Authentication Code ) que permite você adicionar um código de autenticação ao hash final.

Como ele é bem simples, irei colocar abaixo um codigo em php e mais abaixo a saida do codigo:

<?php

// varios  - md5, sha1, crc32 e ripemd160 com e sem senha em hmac

echo “<br><b>Algoritmo MD5</b><br>”;

echo hash(‘md5′,’pedro’,”);

echo “<br>”;

echo hash_hmac(‘md5′,’pedro’,’senha’);

echo “<br>”;

echo “<br><b>Algoritmo SHA1</b><br>”;

echo hash(’sha1′,’pedro’,”);

echo “<br>”;

echo hash_hmac(’sha1′,’pedro’,’senha’);

echo “<br>”;

echo “<br><b>Algoritmo crc32</b><br>”;

echo hash(‘crc32′,’pedro’,”);

echo “<br>”;

echo hash_hmac(‘crc32′,’pedro’,’senha’);

echo “<br>”;

echo “<br><b>Algoritmo ripemd160</b><br>”;

echo hash(‘ripemd160′,’pedro’,”);

echo “<br>”;

echo hash_hmac(‘ripemd160′,’pedro’,’senha’);

echo “<br>”;

Uma Rede Particular Virtual (Virtual Private Network – VPN)é uma rede de comunicações privada normalmente utilizada por umaempresa ou um conjunto de empresas e/ou instituições, construída emcima de uma rede de comunicações pública (como por exemplo, a Internet). O tráfego de dados é levado pela rede pública utilizando protocolos padrão, não necessariamente seguros.

Criação de VPN entre matriz e filial de uma empresa usando servidores Mikrotik nas duas pontas.

Levando em consideração a seguinte estrutura:

Matriz:

* Rede Local: 192.168.0.X/24
* Ip local do Servidor: 192.168.0.1
* Ip Internet do Servidor: 201.200.200.200

Filial:

* Rede Local: 192.168.10.X/24
* Ip local do Servidor: 192.168.10.1
* Ip Internet do Servidor: 189.50.1.200

VPN:

* Faixa IPs: 10.0.0.X/24

Configurações
Partindo do ponto de que os dois servidores já estão devidamente configurados e navegando na Internet repassando a navegação para redeInterna e seus clientes via NAT, iremos configurar o Server VPN namatriz.

Antes de mais nada, devemos habilitar duas opções no menu Ip> firewall > Service Ports, clique com o botão direito eselecione enable em “GRE” e “PPTP”.

Abra o servidor Mikrotik pelo winbox, acesse o menu ppp. Naprimeira guia Interfaces clique na opção PPTP Server marque a opção enable.

Na segunda guia, “secrets”, crie um usuário para conectar ao Server pela VPN:

Usuário: teste
Senha: teste
Local address: 10.0.0.1
Remote address: 10.0.0.2

Dessa forma seu servidor estará preparado para ouvir e autenticar requisições PPTP. Ainda falta configurar as rotas nesseservidor para que as máquinas internas possam ver a outra rede e vice-versa. Vá em Ip > routes e crie as duas rotas abaixo:

Primeira Rota: 10.0.0.0/24 > gateway 192.168.0.1
Segunda Rota: 192.168.10.0/24> Gateway 10.0.0.2

A rota 10.0.0.0/24 apontando para o gateway 192.168.0.1 indicaque a rede usada pela vpn será roteada pelo ip 192.168.0.1 que é daplaca interna do servidor e a rota 192.168.10.0/24 indica que a rede interna do servidor da filial será roteada pelo ip remoto que o servidor da filial receberá quando conectar.

Configuramos o servidor da matriz, agora vamos para o servidor da Filial:

Vá em PPP, na aba Interfaces crie o usuário para se conectar conforme abaixo:

Server: 201.200.200.200
user: teste
password: teste

Clique em ok e logo o usuário já se conectará ao outro servidor, dessa forma você já poderá testar do próprio servidor Mikrotik se está pingando para o IP de alguma maquina na rede internada matriz.

Para que suas máquinas na Filial com a faixa 192.168.10.X possam acessar as máquinas da matriz você terá que criar a mesma estrutura de rotas que foi criada para na matriz só que direcionandopra sua rede interna, abaixo:

Primeira Rota: 10.0.0.0/24 > gateway 192.168.10.1
Segunda Rota: 192.168.0.0/24> Gateway 10.0.0.1

Bom pessoal, com isso estaremos com a vpn funcionando nos dois pontos caso queiram adicionar mais pontos é só seguir o mesmo raciocínio. Outra coisa, você pode também criar um usuário para acessarde qualquer máquina Windows diretamente em rede assistente para novas conexões e marcar a opção conectar-me a uma vpn.

169.254.0.0/16
192.168.0.0/16
10.0.0.0/8
172.16.0.0/16

Usar ips fora da faixa RFC1918 resulta nos seguintes problemas:
- Se você colocar o ip 40.40.40.40 em um computador na rede local, este computadores estará usando um ip de algum servidor existente na internet, logo o site ou serviço que use este ip na internet não poderá ser acessado.
- Softwares de servidores, roteadores, access points são projetados obedecendo as regras internacionais (RFC’s), infringí-las pode resultar em mal funcionamento envolvendo estes equipamentos.

Outra coisa que observo sempre é duvidas a respeito de mascaras de rede, e coloquei abaixo uma lista de quantos hosts cada rede pode ter com determinada mascara:

mascara – numero de hosts
8/255.0.0.0 – 16.777.216
16/255.255.0.0 – 65.536
20/255.255.240.0 – 4096
21/255.255.248.0 – 2048
22/255.255.252.0 – 1028
23/255.255.254.0 – 512
24/255.255.255.0 – 256
25/255.255.255.128 – 128
26/255.255.255.192 – 64
27/255.255.255.224 – 32
28/255.255.255.240 – 16
29/255.255.255.248 – 8
30/255.255.255.252 – 4
31/255.255.255.254 – 2
32/255.255.255.255 – 1

Fica ai a dica ….

A intenção de UUIDs é permitir sistemas distribuídos de identificar excepcionalmente a informação sem coordenação central significativa.

Assim, qualquer um pode criar um UUID e usá-lo para identificar algo com confiança razoável que o identificador que esta sendo usado nunca irar se repetir mesmo involuntariamente por qualquer um para qualquer outra coisa. A informação etiquetada com UUIDs pode conseqüentemente mais tarde ser combinada em uma única base de dados sem precisar de resolver os conflitos conhecidos. O uso o mais difundido deste padrão está em identificadores originais de Microsoft global – (GUIDs). Outros usos significativos incluem o filesystem de ext2/ext3 do linux, as divisórias cifradas LUKS, o GNOME, os KDE, e o Mac OS X, que usam as execuções derivadas da biblioteca do uuid encontrada no pacote de e2fsprogs.
Definição

Um UUID é (128-bit) um número 16-byte. O número de UUIDs teórica possível é conseqüentemente 216 o × 8 = 2128 = 25616 ou aproximadamente 3.4 o × 1038. Isto significa que 1 trilhão UUIDs teriam que ser criados cada nanossegundo por ligeiramente mais de 10 bilhão anos para esgotar o número de UUIDs.

Em seu formulário canônico, um UUID consiste em 32 dígitos hexadecimal indicado em 5 grupos separados por hífens, no formulário 8-4-4-4-12 para um total de 36 caráteres (32 dígitos e 4 “-”). Por exemplo:

550e8400-e29b-41d4-a716-446655440000

Um UUID pode igualmente ser usado com um identificador específico usado intencionalmente repetidamente para identificar a mesma coisa em contextos diferentes. Por exemplo, no modelo de objeto componente de Microsoft, cada componente deve executar a relação de IUnknown, que é feita criando um UUID que representa IUnknown. Em todos os casos onde quer que IUnknown seja usado, se está sendo usado por um processo que tenta alcançar a relação de IUnknown em um componente, ou por um componente que executa a relação de IUnknown, é provido sempre pelo mesmo identificador: 00000000-0000-0000-C000-000000000046.
Versão 1 (MAC address)

Conceptual, (versão 1) o esquema original da geração para UUIDs era concatenar a versão de UUID com o MAC address do computador que está gerando o UUID, e com o número dos intervalos 100-nanosegundos desde a adoção do calendário gregoriano no oeste. Na prática, o algoritmo real é mais complicado. Este esquema foi criticado que não é suficientemente “opaco”; revela a identidade do computador que gerou o UUID e o tempo em que fêz assim.
Versão 2 (segurança do DCE)

A versão 2 UUIDs é similar à versão 1 UUIDs, com o byte superior da seqüência do pulso de disparo substituída pelo identificador para “domínio local” (tipicamente de “domínio POSIX UID” ou de “domínio POSIX GID”) e os primeiros 4 bytes do timestamp substituído por POSIX UID ou GID do usuário (com “a indicação do identificador do domínio local”).
Versão 3 (mistura MD5)

Uso de UUIDs da versão 3 um esquema que deriva um UUID através de MD5 de um URL, um Fully Qualified Domain Name, um identificador do objeto, um distinto nome (DN um pouco usado no Directory Access Protocol ), ou em nomes em namespaces nãos especificado. A versão 3 UUIDs tem o formulário xxxxxxxx-xxxx-3xxx-xxxx-xxxxxxxxxxxx com dígitos hexadecimais x.

Para determinar a versão 3 UUID de um nome dado o UUID do namespace, por exemplo 6ba7b810-9dad-11d1-80b4-00c04fd430c8 para um domínio, é transformado a uma corda dos bytes que correspondem a seus dígitos hexadecimais, concatenada com o nome da entrada, junto com o MD5 que rende 128 partes. Seis partes são substituídas pelos valores fixos, quatro destas indicam a versão, 0011 para a versão 3. A mistura fixa é transformada finalmente de novo no formulário hexadecimal com os hífens que separam as peças relevantes em outras versões de UUID.
Versão 4 (aleatória)

Uso de UUIDs da versão 4 um esquema que confia somente em números aleatórios. Este algoritmo ajusta o número de versão assim como duas partes reservadas. Todo o restante são ajustados usando uma origem de dados aleatória ou pseudo-randonicos. A versão 4 UUIDs tem o formulário xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx com dígitos hexadecimais x e os dígitos hexadecimais 8, 9, o A, ou o B para Y, exemplo:

f47ac10b-58cc-4372-a567-0e02b2c3d479.
Versão 5 (mistura SHA-1)

Uso de UUIDs da versão 5 um esquema com hashing SHA-1, se não é a mesma idéia que em RFC 4122 da versão 3. indica que a versão 5 está referida sobre a versão 3 UUIDs baseada em nome.
Probabilidade aleatória de UUID duplicatas

UUIDs aleatória gerado como aqueles gerados pela classe de java.util.UUID tem 122 partes aleatórias. Há 128 partes completamente com as 4 partes que estão sendo usados para a versão (“UUID aleatória gerado”), e 2 partes para a variação (“Lixivie-Salz “). Com UUIDs aleatório, a possibilidade de dois que têm o mesmo valor pode ser calculada usando a teoria de probabilidade (paradoxo de aniversário).

68.719.476.736 = 236 / 0.0000000000000004 (4 × 10−16)

2.199.023.255.552 = 241 / 0.0000000000004 (4 × 10−13)

70.368.744.177.664 = 246 / 0.0000000004 (4 × 10−10)

Para por estes números na perspectiva, seu risco anual de batida por um meteorito é estimado para ser uma possibilidade em 17 bilhões, que significa que a probabilidade é aproximadamente 0.00000000006 (6 × 10−11), equivalente às probabilidades de criar alguns dez dos trilhões de UUIDs em um ano e de ter uma duplicata. Ou seja, somente depois a geração de 1 bilhão UUIDs a cada segundo pelos próximos 100 anos, a probabilidade de criar apenas uma duplicata seria aproximadamente 50%. A probabilidade de uma duplicata seria aproximadamente 50% assim cada pessoa na terra possui 600 milhões UUIDs.

Entretanto, estas probabilidades prendem somente para geradores criptograficamente seguros do número pseudo-randonicos. Estes devem ser usados para gerar os valores, se não a probabilidade das duplicatas pode ser significativamente mais elevada, desde que a dispersão estatística pode ser mais baixa.
História

O projeto inicial de DCE UUIDs foi baseado em UUIDs como definido no sistema de computação de rede, cujo o projeto por sua vez foi inspirado pelos identificadores originais (64-bit) definido e usado pervasively em Domain/OS, o sistema de exploração projetado pela Apollo Computer Inc.

abaixo codigo para gerar UUID em php:

<?

function uuid() {

return sprintf(’%04x%04x-%04x-%03×4-%04x-%04x%04x%04x’,
mt_rand(0, 65535), mt_rand(0, 65535), // 32 bits for “time_low”
mt_rand(0, 65535), // 16 bits for “time_mid”
mt_rand(0, 4095),  // 12 bits before the 0100 of (version) 4 for “time_hi_and_version”
bindec(substr_replace(sprintf(’%016b’, mt_rand(0, 65535)), ‘01′, 6, 2)),
mt_rand(0, 65535), mt_rand(0, 65535), mt_rand(0, 65535) // 48 bits for “node”
);
}

echo uuid();

echo “<br><br>”;

$token = uniqid(””);
echo $token;

?>

Este texto trata apenas da primeira versão do TEA, um algoritmo do tipo Feistel que faz uso de operações de vários grupos algébricos – XOR, ADD e SHIFT. Esta é uma forma muito engenhosa de obter as propriedades de difusão e confusão, os dois componentes essenciais da segurança da cifra, sem a necessidade de usar P-boxes (caixas de permutação para gerar difusão) ou S-boxes (caixas de substituição para gerar confusão).

O TEA cifra blocos de 64 bits de dados usando uma chave de 128 bits. Parece ser bastante resistente à criptoanálise diferencial e adquire uma difusão completa (quando a diferença de um bit no texto claro causa aproximadamente 32 bits de diferença no texto cifrado) após seis ciclos. Por ser muito curto e simples, a velocidade de processamento impressiona.

De acordo com os autores, este algoritmo pode substituir o DES com vantagens. Além disso, apesar de ter 32 ciclos (64 etapas Feistel) e apesar da velocidade de processamento não ser o principal objetivo, o TEA é três vezes mais rápido que o melhor software de implementação de DES com 16 etapas. Todos os modos de uso do DES também são aplicáveis ao TEA. O número de ciclos pode variar ou até fazer parte da chave. Os autores também sugerem que a segurança pode ser aumentada quando se aumenta o número de iterações.

De acordo com o Prof. Simon Shepher, da Universidade de Bradford, Inglaterra, a segurança do TEA é muito boa, salientando que, até o momento (fevereiro de 2006), não se obteve sucesso com nenhum tipo de criptoanálise. Acredita-se que o TEA seja tão seguro quanto o algoritmo IDEA, projetado por Massey e Xuenjia Lai. Usa a mesma técnica de grupos algébricos misturados, mas é muito mais simples e, por isto mesmo, muito mais rápido. Além disso é de domínio público, enquanto que o IDEA foi patenteado pela Ascom-Tech AG na Suíça. Parece que o professor é um fã de carteirinha do TEA. Louva seu tamanho diminuto, sua velocidade, sua segurança e ressalta que “também é um ótimo gerador de números randômicos que pode ser usado em simulações Monte Carlo e afins”.

abaixo um exemplo do algaritmo em PHP:

<?

class crypto{

var $keyPhrase=”";
var $input=”";
var $output=”";

function encryption_keyer($txt,$encrypt_key){
$ctr=0;
$tmp = “”;
$txt_len=strlen($txt);
for ($i=0;$i<$txt_len;$i++)
{
if ($ctr==strlen($encrypt_key)) $ctr=0;
$tmp.= substr($txt,$i,1) ^ substr($encrypt_key,$ctr,1);
$ctr++;
}
return $tmp;
}

function encrypt_string(){
$txt = $this->input;
$key = $this->keyPhrase;

srand((double)microtime()*1000000);
$encrypt_key = md5(rand(0,32000));
$ctr = 0;
$tmp = “”;
$txt_len = strlen($txt);
for ($i=0;$i < $txt_len;$i++)
{
if ($ctr==strlen($encrypt_key)) $ctr=0;
$tmp.= substr($encrypt_key,$ctr,1) . (substr($txt,$i,1) ^ substr($encrypt_key,$ctr,1));
$ctr++;
}
$hash= $this->encryption_keyer($tmp,$key);
$hashLen = strlen($hash);
$hexa = “”;
for ($j=0;$j < $hashLen;$j++){
$tmpH =  base_convert((ord(substr($hash,$j,1))), 10, 16);
$hexa .= strlen($tmpH)<2?”0$tmpH”:”$tmpH”;
}
$this->output = $hexa;
}

function decrypt_string(){
$txt = $this->input;
$key = $this->keyPhrase;

$hexaLen = strlen($txt);
$hash = “”;
for ($j=0;$j < $hexaLen;$j++){

$tmpHex =  substr($txt,$j,2);
$tempOrd = base_convert($tmpHex,16,10);
$hash .=chr($tempOrd);
$j++;
}
$hashd= $this->encryption_keyer($hash,$key);

$tmp = “”;
$txt_len=strlen($hashd);
for ($i=0;$i<$txt_len;$i++)
{
$md5 = substr($hashd,$i,1);
$i++;
$tmp.= (substr($hashd,$i,1) ^ $md5);
}
$this->output = $tmp;
}
}

function cripto($action, $texto, $senha) {
$dest = ”;

if($action == “E”) {

$k =new crypto();
$k->keyPhrase = $senha;
$k->input = $texto;
$k->encrypt_string();
$dest = $k->output;
}

if($action == “D”) {

$w =new crypto();
$w->keyPhrase = $senha;
$w->input = $texto;
$w->decrypt_string();
$dest = $w->output;

}

return $dest;
}

$cript = cripto(“E”, “jesus salva”, “senha”);
$decript = cripto(“D”, $cript, “senha”);

echo “Texto jesus salva com criptografia TEA com <b>senha</b> como senha:<br />”.$cript;
echo “<br />”.$decript;

?>

Descrição

O protocolo virtual da redundância do router é um protocolo da eleição que forneça a disponibilidade elevada para routeres. Um número de routeres podem participar em uns ou vários routeres virtuais. Uns ou vários IP address podem ser atribuídos a um router virtual. Um nó de um router virtual pode estar em um dos seguintes estados:

• Estado MASTER, quando o nó responder a todos os pedidos aos IP address do exemplo. Pode somente haver um nó MESTRE em um router virtual. Este nó emite pacotes da propaganda de VRRP a todos os routeres alternativos (que usam o endereço do multicast) cada ocasionalmente (ajuste na propriedade do intervalo).
• Estado BACKUP, quando o router de VRRP monitorar a disponibilidade e o estado do router mestre. Não responde a nenhuma pedidos aos IP address do exemplo. Deve dominar tornado não disponível (se três pacotes seqüenciais de VRRP são perdidos pelo menos), o processo eleitoral acontece, e o mestre novo é proclamado baseou em sua prioridade. Para mais detalhes em routeres virtuais, veja RFC2338.

Obs:

VRRP não trabalha atualmente em relações de VLAN, porque é impossível ter o MAC address de uma relação de VLAN diferente do MAC address da relação que física é colocar sobre.

VRRP Routers

Sub-menu em nível: vrrp de /ip

Descrição

Um número de routeres de VRRP podem dar forma a um router virtual. O número máximo de conjuntos em uma rede é 255 cada que têm um VRID original (identificação virtual do router). Cada router que participa em um conjunto de VRRP deve tê-lo jogo de prioridade a um valor válido.

authentication (nenhuma | simples | ah; defeito: nenhuns) – método de autenticação usar-se para pacotes da propaganda de VRRPnone – nenhuma autenticação
simple – autenticação do texto liso
ah – encabeçamento da autenticação usando o algoritmo HMAC-MD5-96
interface (nome) – nome que da relação o exemplo está funcionando sobre

interval (inteiro: 1..255; defeito: 1) – intervalo da actualização de VRRP nos segundos. Define como freqüentemente o mestre do conjunto dado emite pacotes da propaganda de VRRP

name (nome) – nome atribuído do exemplo de VRRP

on-backup (nome; defeito: “”) – script para executar quando o interruptor do nó ao estado alternativo

on-master (nome; defeito: “”) – script para executar quando o interruptor do nó para dominar o estado

password (texto; defeito: “”) – a senha exigida para a autenticação dependendo do método usado pode ser ignorada (se nenhuma autenticação usada), corda de texto longa de 8 caráteres (para a autenticação do plain-text) ou corda de texto longa de 16 caráteres (128-bit fecham exigido para AH a autenticação)

preemption-mode (sim | não; defeito: sim) – se a modalidade do preemption está permitidaNo. – um nó alternativo não será elegido para ser um mestre até a falha mestra atual mesmo se o nó alternativo tem uma prioridade mais elevada do que o mestre atual
Yes. - o nó mestre tem sempre a prioridade

priority (inteiro: 1..255; defeito: ) – prioridade 100 do nó atual (prioridade mais elevada do meio dos valores mais elevados) 255 – O RFC exige que o router que possui os IP address atribuídos a este exemplo teve a prioridade de 255

vrid (inteiro: 0..255; defeito: 1) – identificador virtual do router (deve ser original em uma relação)

nos proximos post’s continuo….

Qualquer pessoa pode obter uma cópia do codigo-fonte do Blowfish apartir da internet e fazer uso em suas aplicações. Não há regras de usodo código. Bruce Schneier pede, somente, que seja notificado deaplicações comerciais para que possam ser listadas em sua página naInternet.

No site oficial, pode se obter o codigo para C, C++, Perl, JAVA eoutras linguagens e na web em geral encontra-se para JavaScript, PHPentre outras tudo livre.

Descrição do Algoritmo

A criptografia é feita através de uma função com 16 iterações.Apesar do complexo algoritmo de inicialização, o Blowfish tem grandeeficiência com os microprocessadores atuais. A cifragem do texto éfeita em blocos de 64 ou 128 bits, nos quais os bits não são tratadosseparadamente, mas em grupos de 32 bits. A fim de aumentar suaeficiência, foi escolhido usar na confecção deste algoritmo funçõessimples para os microprocessadores, tais como XOR, adição emultiplicação modular. O algoritmo consiste de duas partes, sendo elasa expansão da chave e a criptografia dos dados. A primeira consiste natransformação da chave em subchaves, totalizando 4168 bits. A segundaconsiste de 16 fases, sendo que, em cada uma dessas, é feita umapermutação dependente da chave e uma substituição dependente da chave edos dados.

Criação das sub-chaves

A matriz P consiste de 18 subchaves de 32 bits, com seus elementosvariando de P1 ate P18. Utilizam-se também 4 s-boxes, cada umaconstituída de 256 elementos de 32 bits cada. Inicialmente, as S-boxessão preenchidas com os dígitos hexadecimais de PI, exceto o dígitoinicial 3. O bit mais significativo da fração de Pi se torna o maissignificativo da primeira subchave. Como exemplo:

· P1 = 0×243f6a88

· P2 = 0×85a308d3

· P3 = 0×13198a2e

· P4 = 0×03707344

Em seguida, faz-se um XOR entre os 32 primeiros bits da chave comP1, os próximos 32 bits da chave com P2, e assim por diante, até P14.Caso os bits da chave cheguem ao fim antes de P14, então se deverepeti-los até o fim da matriz.

· Ex: Chave de 64 bits.

Após isso, usando-se uma cadeia de caracteres de constituída apenaspor zeros, executa-se o algoritmo usando as sub-chaves já criadas. Oresultado desse processo deve ser armazenado em P1 e P2, e em seguidaservirá de entrada para o algoritmo novamente. Esse novo produto seráarmazenado em P3 e P4, e servirá mais uma vez de entrada, ate que sejampreenchidas todas as subchaves e S-boxes.

No total, serão feitas 512 iterações apenas para gerar assub-chaves. A fim de tornar a utilização do algoritmo mais simples, ésugerido que os aplicativos guardem essas sub-chaves geradas, ao invésde fazer esse complexo processo múltiplas vezes.

Cifragem

A entrada para essa parte do algoritmo são 64 bits, que serãodivididos em dois grupos de 32 bits, que serão chamados de xL e xR. Asoperações abaixo deverão ser feitas 16 vezes.

· xL = xL XOR Pi

· xR = F(xL) XOR xR

· Troca de xL com xR

Após a décima sexta iteração, é necessário trocar xL e xR mais umavez (troca de xL e xR). Em seguida, são feitas as seguintes operações:

· R = xR XOR P17;

· xL = xL XOR P18.

O texto cifrado será a união desses dois grupos (xLxR). A função F segue os seguintes passos:

· 1)Separar xL em quatro blocos de 8 bits. O primeiro bloco será usado comoentrada para achar uma entrada na primeira S-Box, o segundo na segunda,e assim sucessivamente. Em seguida são feitas duas adicões em módulo de232 e um Xor da seguinte forma:(S1 (B1) + S2(B2)) XOR (S3(B3) + S4(B4))

O processo de obtenção do texto original a partir do cifrado é feitoda mesma forma, porém utilizando a matriz P em ordem inversa.

Conclusão

Blowfish é uma das cifras mais rápidas em uso, exce(p)to ao mudarchaves. Cada chave nova requer o pre-processamento equivalente aencriptação de aproximadamente 4 kilobytes do texto, o que é muitolento se comparado a outras cifras. Isto impede seu uso em determinadasaplicações, mas não é um problema em outras. Em algumas aplicações érealmente um benefício: o método da troca de senha usado em OpenBSD usaum algoritmo derivado de Blowfish que emprega a programação de chavelenta; a idéia/ideia é que o esforço computacional extra requerido dá aprote(c)ção de encontro aos ataques de dicionário. Em algumasexecuções, Blowfish tem uma exigência relativamente grande da memória(acima de 4 kilobytes). Este não é um problema mesmo para computadoresmenores e mais velhos ou laptops, mas impede o uso em sistemas menorestais como smartcards.

Como TEA, XTEA é um bloco 64-bit Feistel rede com uma chave de 128 bits e um sugerido 64 rodadas. Várias diferenças são visíveis a partir de TEA, inclusive um pouco mais complexo chave-horário e um rearranjo dos turnos, XORs e aditamentos.

XTEA foi apresentado juntamente com um bloco de largura variável cifra denominado Bloco TEA, que utiliza a função XTEA rodadas, mas aplica-se ciclicamente em toda uma mensagem para várias iterações. Porque opera em toda a mensagem, Bloco TEA tenha a propriedade que não tem um modo de funcionamento. Um ataque a todo o Bloco TEA foi descrito em (Saarinen, 1998), que também detalha uma fraqueza no Bloco TEA do sucessor, XTEA.

Criado após hackers haverem quebrado o a segurança de um console de video game da microsoft que utilizava o TEA como algoritmo de criptografia, parece que foi um erro no bloco 32.

A partir de 2004, o melhor ataque é relatado sobre XTEA-chave relacionadas com um diferencial ataque a 26 dos 64 rounds de XTEA, exigindo 220,5 escolhido plaintexts e complexidade de um tempo 2.115,15 (Ko et al, 2004).

O extraordinariamente pequena dimensão do XTEA algoritmo tornaria uma opção viável em situações onde há extrema constrangimentos por exemplo sistemas legados hardware (talvez embutido), onde a quantidade de RAM disponível é mínimo.

e baixe uma classe bem legal em php para xtea aqui.

Suponha que você tenha um site que permita o usuário cadastrar-se à vontade. Então, um engraçadinho resolve cadastrar o nome dele da seguinte maneira:

<font color=”red” style=”font-size: 30pt”>Adriano Nântua</font>

Pronto. De agora em diante, toda vez que o nome dele for escrito no site estará vermelho e bem grande, diferente das outras pessoas (isso se o palhaço não resolver botar tamanho 800 e esculhambar de vez o seu site).

Para evitar isso, na hora de escrever o nome, ao invés de fazer o usual:

<%= nome %>

faça o funcional:

<%= Server.HtmlEncode(nome) %>

Desta maneira, nome do espertinho, será escrito da mesma maneira que ele informou, pois a função codifica a string em HTML, escrevendo &lt; ao invés de <.

Obviamente, a função não serve somente para se proteger de usuários humoristas. Em geral serve para que os caracteres cadastrados sejam escritos fielmente.
Imagine que você vá jogar a string O filme “A Rocha” ganhou 20 prêmios no value de um input de texto. Só vai dar O Filme, pois o browser vai ler o ” como fim do value, e o resto da string vai ficar fazendo sujeira na Tag. Um desmantelo.
Basta usar, então, o Server.HTMLEncode para consertar as coisas.