Explication détaillée de la compression, du cryptage et du décryptage des données PHP (pack, unpack)

Les données sont souvent échangées dans le cadre de la communication réseau et du stockage de fichiers. Afin de réduire le trafic de communication réseau, la taille du stockage des fichiers et les règles de communication cryptées, il est souvent nécessaire d'effectuer un cryptage et un décryptage bidirectionnels des données pour garantir la sécurité des données.
Les principales fonctions nécessaires pour implémenter cette fonction en PHP sont principalement les fonctions pack et unpack

pack
pour compresser les données en une chaîne de bits.
Syntaxe : string pack(string format, Mixed [args]...);
Valeur de retour : String
Cette fonction est utilisée pour compresser et regrouper des données dans une chaîne.
a - NUL - Chaîne rembourrée [chaîne rembourrée] Complétez les espaces de chaîne avec des caractères NULL
A - ESPACE - Chaîne rembourrée [chaîne rembourrée]
h - Chaîne hexadécimale, faible "nibble first" (faible nibble d'abord )
H - chaîne hexadécimale, "nibble" élevé [nibble élevé en premier] (nibble élevé en premier)
c – caractère signé
C – caractère non signé
s – motif court signé [court] (généralement 16 bits, dans l'ordre des octets machine)
S – mode court signé non signé [court] (généralement 16 bits, octet machine trié)
n - mode court non signé [court] (généralement 16 bits, octet big endian trié)
v - motif court non signé [court] (généralement 16 bits, trié en petits octets endian)
i - entier signé (déterminé par la taille et l'ordre des octets)
I - entier non signé (déterminé par la taille et l'ordre des octets) ordre)
l – modèle long signé [long] (généralement 32 bits, dans l'ordre des octets machine)
L – mode long non signé [long] (généralement 32 bits, dans l'ordre des octets machine)
N – non signé mode long [long] (généralement 32 bits, dans l'ordre des octets edian)
V – mode long non signé [long] (généralement 32 bits, dans l'ordre des octets edian)
f – virgule flottante (déterminé par la taille et ordre des octets)
d – double (déterminé par la taille et l'ordre des octets) Déterminé par l'ordre des octets)
x – octet NUL [octet NUL]
X- Sauvegarder un octet (rembobiner un octet)

décompresser
Décompresser les données de la chaîne de bits.
Syntaxe : string pack(string format, Mixed [args]...);
Valeur de retour : Array
Cette fonction est utilisée pour décompresser les données d'une chaîne de bits. Cette fonction a exactement les mêmes fonctionnalités et utilisations que la fonction Perl du même nom.

Cas 1, le pack implémente la réduction de la taille de stockage des données du fichier

<?php 
//存储整数1234567890 
file_put_contents("test.txt", 1234567890);

À l'heure actuelle, la taille du fichier test.txt est de 10 octets. Notez que la taille du fichier est actuellement de 10 octets et que l'espace réellement occupé est de 1 Ko.
Les entiers stockés ci-dessus sont en fait stockés dans le fichier test.txt sous forme de chaînes.
Mais s'il est stocké sous forme de chaîne binaire entière, il sera réduit à 4 octets.

<?php 
print_r(unpack("i", file_get_contents("test.txt")));

Cas 2, cryptage des données
Stockage d'une donnée significative sous la forme d'une chaîne, 7-110-abcdefg-117.
Une fois le caractère "-" divisé, le premier chiffre représente la longueur de la chaîne, le deuxième chiffre représente l'emplacement de stockage, le troisième chiffre représente la chaîne réellement stockée et le quatrième chiffre représente la position finale.

<?php 
file_put_contents("test.txt", "7-110-abcdefg-117");

Inconvénients de la méthode ci-dessus :
1. Taille de stockage des données
2. Les données sont stockées en texte clair si elles sont sensibles. informations, cela peut entraîner un accès dangereux.
3. La taille de stockage des fichiers augmente de manière irrégulière.
Cryptage :

<?php 
file_put_contents("test.txt", pack("i2a7i1", 7, 110, "abcdefg", 117));

stocke une donnée, le format de cryptage est : entier de 2 chiffres, chaîne de 10 chiffres, entier de 1 chiffre.
Avantages :
1. Optimisation de la taille des données
2 Lorsque vous ne connaissez pas le format de compression tel que "i2a7i1", même si vous obtenez le fichier, vous ne pouvez pas le lire correctement. la conversion de fichier binaire Pour le texte brut.
3. Lorsque les données augmentent, la taille de stockage des fichiers augmente du même montant. À chaque fois, il est incrémenté de 19 octets.

Cas 3, stockage de fichiers clé-valeur
Les fichiers générés par le stockage sont au nombre de deux : fichier d'index, fichier de données
Le format de stockage des données dans le fichier est le suivant :


Mise en œuvre du code :

<?php 
error_reporting(E_ALL); 
 
class fileCacheException extends Exception{ 
 
} 
 
//Key-Value型文件存储 
class fileCache{ 
   private $_file_header_size = 14; 
   private $_file_index_name; 
   private $_file_data_name; 
   private $_file_index;//索引文件句柄 
   private $_file_data;//数据文件句柄 
   private $_node_struct;//索引结点结构体 
   private $_inx_node_size = 36;//索引结点大小 
 
   public function __construct($file_index="filecache_index.dat", $file_data="filecache_data.dat"){ 
     $this->_node_struct = array( 
        &#39;next&#39;=>array(1, &#39;V&#39;), 
        &#39;prev&#39;=>array(1, &#39;V&#39;), 
       &#39;data_offset&#39;=>array(1,&#39;V&#39;),//数据存储起始位置 
       &#39;data_size&#39;=>array(1,&#39;V&#39;),//数据长度 
       &#39;ref_count&#39;=>array(1,&#39;V&#39;),//引用此处，模仿PHP的引用计数销毁模式 
       &#39;key&#39;=>array(16,&#39;H*&#39;),//存储KEY 
     ); 
 
     $this->_file_index_name = $file_index; 
     $this->_file_data_name = $file_data; 
 
     if(!file_exists($this->_file_index_name)){ 
        $this->_create_index(); 
     }else{ 
        $this->_file_index = fopen($this->_file_index_name, "rb+"); 
     } 
 
     if(!file_exists($this->_file_data_name)){ 
        $this->_create_data(); 
     }else{ 
        $this->_file_data = fopen($this->_file_data_name, "rb+");//二进制存储需要使用b 
     } 
   } 
 
   //创建索引文件 
   private function _create_index(){ 
     $this->_file_index = fopen($this->_file_index_name, "wb+");//二进制存储需要使用b 
     if(!$this->_file_index)  
        throw new fileCacheException("Could&#39;t open index file:".$this->_file_index_name); 
 
     $this->_index_puts(0, &#39;<&#39;.&#39;?php exit()?&#39;.&#39;>&#39;);//定位文件流至起始位置0, 放置php标记防止下载 
     $this->_index_puts($this->_file_header_size, pack("V1", 0)); 
   } 
 
 
   //创建存储文件 
   private function _create_data(){ 
     $this->_file_data = fopen($this->_file_data_name, "wb+");//二进制存储需要使用b 
     if(!$this->_file_index)  
        throw new fileCacheException("Could&#39;t open index file:".$this->_file_data_name); 
 
     $this->_data_puts(0, &#39;<&#39;.&#39;?php exit()?&#39;.&#39;>&#39;);//定位文件流至起始位置0, 放置php标记防止下载 
   } 
 
   private function _index_puts($offset, $data, $length=false){ 
     fseek($this->_file_index, $offset); 
 
     if($length) 
     fputs($this->_file_index, $data, $length); 
     else 
     fputs($this->_file_index, $data); 
   } 
 
   private function _data_puts($offset, $data, $length=false){ 
     fseek($this->_file_data, $offset); 
     if($length) 
     fputs($this->_file_data, $data, $length); 
     else 
     fputs($this->_file_data, $data); 
   } 
 
   /** 
   * 文件锁 
   * @param $is_block 是否独占、阻塞锁 
   */ 
   private function _lock($file_res, $is_block=true){ 
     flock($file_res, $is_block ? LOCK_EX : LOCK_EX|LOCK_NB); 
   } 
 
   private function _unlock($file_res){ 
     flock($file_res, LOCK_UN); 
   } 
 
   public function add($key, $value){ 
     $key = md5($key); 
     $value = serialize($value); 
     $this->_lock($this->_file_index, true); 
     $this->_lock($this->_file_data, true); 
 
     fseek($this->_file_index, $this->_file_header_size); 
 
     list(, $index_count) = unpack(&#39;V1&#39;, fread($this->_file_index, 4)); 
 
     $data_size = filesize($this->_file_data_name); 
 
     fseek($this->_file_data, $data_size); 
 
     $value_size = strlen($value); 
 
     $this->_data_puts(filesize($this->_file_data_name), $value); 
 
     $node_data =  
     pack("V1V1V1V1V1H32", ($index_count==0) ? 0 : $index_count*$this->_inx_node_size, 0, filesize($this->_file_data_name), strlen($value), 0, $key); 
 
     $index_count++; 
 
     $this->_index_puts($this->_file_header_size, $index_count, 4); 
 
     $this->_index_puts($this->get_new_node_pos($index_count), $node_data); 
 
     $this->_unlock($this->_file_data); 
     $this->_unlock($this->_file_index); 
   } 
 
   public function get_new_node_pos($index_count){ 
     return $this->_file_header_size + 4 + $this->_inx_node_size * ($index_count-1); 
   } 
 
   public function get_node($key){ 
     $key = md5($key); 
     fseek($this->_file_index, $this->_file_header_size); 
     $index_count = fread($this->_file_index, 4); 
 
     if($index_count>0) { 
        for ($i=0; $i < $index_count ; $i++) {  
          fseek($this->_file_index, $this->_file_header_size + 4 + $this->_inx_node_size * $i); 
          $data = fread($this->_file_index, $this->_inx_node_size); 
          $node = unpack("V1next/V1prev/V1data_offset/V1data_size/V1ref_count/H32key", $data); 
 
          if($key == $node[&#39;key&#39;]){ 
             return $node; 
          } 
        } 
     }else{ 
        return null; 
     } 
   } 
 
   public function get_data($offset, $length){ 
     fseek($this->_file_data, $offset); 
     return unserialize(fread($this->_file_data, $length)); 
   } 
} 
 
//使用方法 
$cache = new fileCache(); 
$cache->add(&#39;abcdefg&#39; , &#39;testabc&#39;); 
$data = $cache->get_node(&#39;abcdefg&#39;); 
print_r($data); 
echo $cache->get_data($data[&#39;data_offset&#39;], $data[&#39;data_size&#39;]);

Cas 4, chiffrement des communications socket
Les deux parties communicantes définissent le format de chiffrement :
Par exemple :

$LOGIN = array( 
   'COMMAND'=>array('a30', 'LOGIN'), 
   'DATA'=>array('a30', 'HELLO') 
); 
 
$LOGOUT = array( 
   'COMMAND'=>array('a30', 'LOGOUT'), 
   'DATA'=>array('a30', 'GOOD BYE') 
); 
 
$LOGIN_SUCCESS = array( 
   'COMMAND'=>array('a30', 'LOGIN_SUCCESS'), 
   'DATA'=>array('V1', 1) 
); 
 
$LOGOUT_SUCCESS = array( 
   'COMMAND'=>array('a30', 'LOGIN_SUCCESS'), 
   'DATA'=>array('V1', time()) 
);

Le serveur et le client analysent le format COMMAND, trouvent la méthode de décodage DATA correspondante et obtiennent les données correctes

Le ci-dessus est une explication détaillée du contenu de compression, de cryptage et de décryptage (pack, unpack) des données PHP, veuillez faire attention au site Web PHP chinois (www.php.cn) pour plus de contenu connexe !