Blog do programador e tecnico em redes ….

Categoria — PHP

Fazendo cache de dados MySQL no PHP com XCACHE

XCache é outro programa de cache por chave-valor onde o armazenamento é em memória como o memcached. Este recurso permite que você leve a memória uma variável e depois você pode chamar ela novamente facilmente somente usando a chave criada anteriormente.
Isso ajuda muito no controle do que realmente desejamos colocar em cache na memoria e a retornar, as funções do xcache para salvar e retornar um valor são xcache_set e xcache_get, tambem é possivel remover com xcache_unset, no exemplo do codigo abaixo a função mysql_queryCache mostra como funciona na pratica o cache de dados do MySQL, mais pode ser usado com outro banco como o SQLite ou até mesmo com arquivos de textos:

<?php
$connTeste = mysql_pconnect("localhost", "root", "vertrigo");
mysql_select_db("pedrofilho", $connTeste);
function mysql_queryCache($consulta, $tempo = 60) {
$chave = md5($consulta);
$query = xcache_get($chave);
if ($query == false) {
$query = mysql_query($consulta);
if (is_resource($query) && (($rows = mysql_num_rows($query)) !== 0)) {
for ($i=0; $i<$rows; $i++) {
$fields = mysql_num_fields($query);
$row = mysql_fetch_array($query);
for ($j=0; $j<$fields; $j++) {
if ($i === 0) {
$columns[$j] = mysql_field_name($query, $j);
}
$cache[$i][$columns[$j]] = $row[$j];
}
}
}
xcache_set($chave, $cache, $tempo);
return $cache;
}
return $query;
}
$query_rsCliente = "SELECT nome, telefone, email FROM clientes LIMIT 250";
$rsCliente = mysql_queryCache($query_rsCliente);
?>
<html>
<head>
<title> Clientes </title>
</head>
<body>
<H2> Relatorio de clientes </H2>
<table width="100%" border="0" cellpadding="1" bgcolor="#000000">
<tr bgcolor="#FFFF99">
<td>Nome</td>
<td>Telefone</td>
<td>E-Mail</td>
</tr>
<?php if (count($rsCliente) > 0) { ?>
<?php for ($i=0; $i<count($rsCliente); $i++) { ?>
<tr bgcolor="#FFFFFF">
<td><?php echo $rsCliente[$i]['nome']; ?></td>
<td><?php echo $rsCliente[$i]['telefone']; ?></td>
<td><?php echo $rsCliente[$i]['email']; ?></td>
</tr>
<?php } ?>
<?php } ?>
</table>
</body>
</html>

8 / fevereiro / 2016   Sem Comentarios

cast128 com php

abaixo mais um algoritimo com classe e exemplo para usar com o php, ele usa um dos meios de criptografias mais rápidos e eficientes que já testei:


< ?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 …

11 / janeiro / 2010   1 Comentario

HASH com senha – HMAC

Dias atrais precisei criar um algoritmo para verificar se um form realmente esta vindo de uma pagina especifica, usando MD5 para isso como hoje existem alguns sites com dicionarios inteiros de hash que facilita a vida dos malas, pensei em concatenar a string com outra que seria secreta para ficar diferente.

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:

// varios  - md5, sha1, sha256, crc32 e ripemd160 com e senha senha e 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 SHA256</b><br>";
echo hash('sha256','pedro','');
echo "<br>";
echo hash_hmac('sha256','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>";

<?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>";

?>

saida do codigo acima:

Algoritmo MD5
c6cc8094c2dc07b700ffcc36d64e2138
a1d018ffaf490f6a5b92742ef3ccd173

Algoritmo SHA1

4410d99cefe57ec2c2cdbd3f1d5cf862bb4fb6f8
5c82ffca9902349d22bf36ab133b40cbb2f2ea76

Algoritmo crc32

e86f00aa
0f6fd579

Algoritmo ripemd160

7755874530352e4d9fce481fbf92ac0e46581b16
a2a25fa6891b36bbd4761cf84ad01a7a0ceee458

14 / novembro / 2009   Sem Comentarios

Identificador Universal Original (UUID)

Um identificador universal original (UUID) é um padrão do identificador usado na construção do software, criado pela fundação de software aberto (OSF) como parte do Distributed Computing Environment (DCE).

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 versão 4 em PHP:


function uuid() {
return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
mt_rand(0, 0xffff), mt_rand(0, 0xffff),
mt_rand(0, 0xffff),
mt_rand(0, 0x0fff) | 0x4000,
mt_rand(0, 0x3fff) | 0x8000,
mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff));
}

echo uuid();

13 / novembro / 2009   Sem Comentarios