Pag-encrypt sa PHP. I-encrypt, i-decrypt ang data gamit ang isang key sa PHP Encryption at mga authentication key

  • Pagsasalin
  • Pagtuturo

Mula sa tagasalin: sa proseso ng programming, hindi ko nakakalimutan na ako ay mapanganib na walang kakayahan sa cryptography, at pinapayuhan ko ang lahat na magpatuloy mula sa thesis na ito (mabuti na lang, maliban sa iyo at sa cool na tao doon). Gayunpaman, sa isang paraan o iba pa, sa proseso ng mga problema sa trabaho ay lumitaw na may kaugnayan sa proteksyon ng data, at dapat silang malutas. Samakatuwid, dinadala ko sa iyong pansin ang isang pagsasalin ng isang artikulo ng developer ng Finnish na si Timo H, na nakita kong medyo kawili-wili at kapaki-pakinabang.

Ito ay isang mabilis na gabay kung paano maiwasan ang mga karaniwang pitfalls na may simetriko na pag-encrypt sa PHP.

Isasaalang-alang namin ang kaso kapag ang data ay naproseso sa gilid ng server (sa partikular, ang pag-encrypt ay nangyayari sa server, at ang data ay maaaring matanggap, halimbawa, mula sa kliyente sa anyo ng malinaw na teksto, password, atbp.), na isang tipikal na kaso para sa mga aplikasyon ng PHP.

Ang impormasyon sa gabay na ito ay hindi dapat gamitin upang lumikha ng mga naka-encrypt na koneksyon sa network na may mas kumplikadong mga kinakailangan. Para sa mga ganitong kaso, kailangan mong gumamit ng spied o TLS.

Naturally, ang mga rekomendasyong ibinigay dito ay hindi ang "tanging posibleng paraan" upang ayusin ang pag-encrypt sa PHP. Ang layunin ng gabay na ito ay subukang mag-iwan ng mas kaunting puwang para sa mga pagkakamali at mahirap, hindi malinaw na mga desisyon.

Mga function ng pag-encrypt sa PHP

Gumamit ng mga extension ng Mcrypt o OpenSSL.

Algoritmo ng pag-encrypt at ang mode ng operasyon nito, isang beses na code (vector ng pagsisimula)

Gamitin ang AES-256 sa CTR mode na may random na isang beses na code ( tinatayang pagsasalin: wala). Ang AES ay isang pamantayan, kaya maaari mong gamitin ang mga function ng alinman sa mga extension - Mcrypt o OpenSSL.

Palaging bumuo ng bagong isang beses na code. Sa kasong ito, dapat kang gumamit ng cryptographically secure na mapagkukunan ng mga random na numero. Magbasa ng kaunti pa tungkol sa random na pagbuo ng numero sa ibaba. Ang isang beses na code ay hindi isang lihim, at maaaring pagsamahin sa ciphertext para sa paghahatid at kasunod na pag-decryption.

Ang isang beses na code ay dapat na 128 bits (16 bytes) ang haba, isang string lang ng mga byte na walang anumang pag-encode.

Sa extension ng Mcrypt, ang AES ay kilala bilang Rijndael-128 ( tinatayang transl.: sa kabila ng katotohanan na pinag-uusapan natin ang tungkol sa AES-256, hindi ito isang error. AES-256 != Rijndael-256). Sa OpenSSL, ayon sa pagkakabanggit, AES-256-CTR.

Halimbawa ng paggamit ng Mcrypt:
Halimbawa ng OpenSSL:
I-verify na gumagana nang tama ang pag-encrypt gamit ang mga test vectors ( tinatayang pagsasalin: para sa AES-256-CTR tingnan ang talata F.5.5 sa pahina 57).

Para sa CTR mode, mayroong ilang mga paghihigpit sa kabuuang dami ng naka-encrypt na data. Maaaring hindi mo ito maranasan sa pagsasanay, ngunit tandaan na hindi ka dapat mag-encrypt ng higit sa 2^64 byte ng data gamit ang isang key, hindi alintana kung ito ay isang mahabang mensahe o maraming maikli.

Ang CTR mode ay nananatiling stable lamang kung hindi mo ginagamit ang parehong isang beses na code na may parehong key. Para sa kadahilanang ito, mahalagang bumuo ng isang beses na mga code gamit ang isang malakas na cryptographically source ng randomness. Bukod pa rito, nangangahulugan ito na hindi ka dapat mag-encrypt ng higit sa 2^64 na mensahe gamit ang isang key. Dahil ang haba ng isang beses na code ay 128 bits, ang limitasyon sa bilang ng mga mensahe (at ang kanilang katumbas na isang beses na code) na 2^128/2 ay mahalaga dahil sa Birthday Paradox ( tinatayang pagsasalin:).

At tandaan na hindi itatago ng pag-encrypt ang katotohanan kung gaano karaming data ang iyong ipinapadala. Bilang isang halimbawa ng isang matinding kaso, kung ine-encrypt mo ang mga mensaheng naglalaman lamang ng "oo" o "hindi", malinaw na hindi itatago ng pag-encrypt ang impormasyong iyon.

Pagpapatunay ng data

Palaging suriin ang pagiging tunay at integridad ng data.
Upang gawin ito, gamitin ang MAC pagkatapos ng pag-encrypt. Yung. Una ang data ay naka-encrypt, at pagkatapos ay ang HMAC-SHA-256 ay kinuha mula sa nagresultang ciphertext, kasama ang ciphertext mismo at ang isang beses na code.

Kapag nagde-decryption, suriin muna ang HMAC gamit ang algorithm ng paghahambing na lumalaban sa mga pag-atake sa timing. Huwag direktang ikumpara ang $user_submitted_mac at $calculated_mac gamit ang == o === na mga operator ng paghahambing. Mas mabuti pang gumamit ng "HMAC double check".

Kung matagumpay ang pagsusuri sa HMAC, maaaring maisagawa nang ligtas ang pag-decryption. Kung hindi angkop ang HMAC, isara kaagad.

Encryption at authentication key

Sa isip, gumamit ng mga susi na nagmula sa isang malakas na cryptographic na pinagmumulan ng randomness. Ang AES-256 ay nangangailangan ng 32 bytes ng random na data (isang "raw" na string - isang pagkakasunud-sunod ng mga bit nang hindi gumagamit ng anumang pag-encode).

Kung ang application ay tumatakbo sa ilalim ng bersyon ng PHP sa ibaba 5.5, na walang built-in na pagpapatupad ng PBKDF2, kakailanganin mong gamitin ang iyong sariling pagpapatupad sa PHP, isang halimbawa nito ay makikita dito: https://defuse. ca/php-pbkdf2.htm. Magkaroon ng kamalayan na ang pag-asa sa iyong sariling pagpapatupad ay maaaring hindi malutas nang maayos ang susi tulad ng ginagawa ng built-in na hash_pbkdf2() function.

Huwag gumamit ng parehong key para sa pag-encrypt at pagpapatunay. Gaya ng nakasaad sa itaas, 32 byte ang kinakailangan para sa encryption key at 32 bytes para sa authentication key (HMAC). Sa PBKDF2 maaari kang kumuha ng 64 byte mula sa password at gamitin, halimbawa, ang unang 32 byte bilang encryption key, at ang natitirang 32 bytes para sa authentication key.

Kung ang iyong mga password ay naka-imbak sa isang file, halimbawa, bilang isang HEX string, huwag muling i-encode ang mga ito bago i-feed ang mga ito sa mga function ng pag-encrypt. Sa halip, gamitin ang PBKDF2 upang direktang i-convert ang mga HEX-encode na key sa isang de-kalidad na encryption o authentication key. O gumamit ng SHA-256 na walang karagdagang pag-encode na output (isang 32 byte string lang) para mag-hash ng mga password. Ang paggamit ng regular na pag-hash ng password ay nagbibigay ng sapat na entropy. Higit pang mga detalye ay ibinigay sa mga sumusunod na talata.

Susi kahabaan

Una, dapat mong iwasan ang paggamit ng mababang entropy key. Ngunit gayon pa man, kung kailangan mong gumamit, halimbawa, mga password ng gumagamit, dapat mong tiyak na gumamit ng PBKDF2 na may malaking bilang ng mga pag-ulit upang ma-maximize ang pangunahing seguridad.

Ang isa sa mga parameter ng PBKDF2 ay ang bilang ng mga pag-ulit ng hashing. At kung mas mataas ito, mas malaki ang seguridad ng susi na maaasahan mo. Kung tumatakbo ang iyong code sa isang 64-bit na platform, gamitin ang SHA-512 bilang hashing algorithm para sa PBKDF2. Para sa isang 32-bit na platform, gamitin ang SHA-256.

Gayunpaman, hindi posibleng gumamit ng medyo mataas na bilang ng mga pag-ulit sa mga online na application dahil sa panganib ng pag-atake ng DoS. Samakatuwid, ang pangunahing kalidad ay hindi magiging kasing taas ng sa mga offline na application, na kayang bayaran ang isang malaking bilang ng mga pag-ulit nang walang ganoong panganib. Bilang isang patakaran, para sa mga online na aplikasyon, ang gayong bilang ng mga pag-ulit ng hashing ay pinili upang ang PBKDF2 ay tumatagal ng hindi hihigit sa 100 ms.

Kung sakaling maaari kang gumamit ng mga password na may mataas na entropy, hindi kinakailangang i-stretch ito tulad ng gagawin mo para sa mga password na mababa ang entropy. Halimbawa, kung lumikha ka ng "encryption_master_key" at isang "auth_master_key" gamit ang /dev/urandom, hindi na kailangan ang PBKDF2. Siguraduhing gamitin ang mga key bilang mga pagkakasunud-sunod ng mga bit, nang walang anumang pag-encode.

Bilang karagdagan, sa PBKDF2 hindi mahirap makuha ang parehong mga encryption at authentication key mula sa isang master password (gumamit lamang ng isang maliit na bilang ng mga pag-ulit o kahit isa). Ito ay kapaki-pakinabang kung mayroon ka lamang isang "master password" na ginagamit para sa parehong pag-encrypt at pagpapatunay.

Pangunahing imbakan at pamamahala

Ang pinakamagandang bagay ay ang gumamit ng hiwalay na nakalaang key storage device (HSM).

Kung hindi ito posible, para gawing kumplikado ang pag-atake, maaaring gumamit ng pag-encrypt ng key file o configuration file (na nag-iimbak ng aktwal na encryption/authentication key) gamit ang isang key na nakaimbak sa isang hiwalay na lokasyon (sa labas ng home directory o site root) . Halimbawa, maaari kang gumamit ng variable ng kapaligiran ng Apache sa httpd.conf upang iimbak ang susi na kailangan para i-decrypt ang aktwal na file ng mga key:
SetEnv keyfile_key crypto_strong_high_entropy_key # Maa-access mo ang variable na ito sa PHP gamit ang $_SERVER["keyfile_key"] # Natitira sa config
Ngayon, kung ang mga file sa ugat ng site at sa ibaba, kasama ang mga file na may mga susi, ay nakompromiso (halimbawa, kung ang isang backup ay na-leak), ang naka-encrypt na data ay mananatiling ligtas dahil ang key na nakaimbak sa environment variable ay hindi nakompromiso. Mahalagang tandaan na ang mga httpd.conf file ay dapat na i-back up nang hiwalay, at hindi ikompromiso ang keyfile_key variable sa pamamagitan ng, halimbawa, ang output ng phpinfo().

Kung gumagamit ka ng isang file sa halip na isang parameter ng pagsasaayos, posible na ayusin ang pag-ikot ng key. Sa pinakamasamang sitwasyon, kung nakuha ng kalaban ang iyong mga encryption at authentication key nang hindi napapansin, ang pag-ikot ng mga key sa ilang mga pagitan ay maaaring limitahan ang kanilang pag-access (ipagpalagay na hindi sila makakakuha ng mga bagong key). Ang pamamaraan na ito ay makakatulong na mabawasan ang pinsala dahil ang kaaway ay hindi makakagamit ng mga nakompromisong key nang walang katapusan.

Pag-compress ng data

Sa pangkalahatan, hindi mo dapat i-compress ang source text bago ito i-encrypt. Maaari itong magbigay sa kaaway ng karagdagang kasangkapan para sa pagsusuri.

Halimbawa, kung mag-iimbak ka ng data ng session sa naka-encrypt na cookies, ang ilan sa mga ito ay ibinibigay ng user, at ang ilan ay kumakatawan sa lihim na impormasyon, ang isang kalaban ay maaaring matuto ng karagdagang impormasyon tungkol sa lihim sa pamamagitan ng pagpapadala, bilang isang ordinaryong user, ng ilang espesyal na ginawang data at pagsukat kung paano nagbabago ang haba ng mga resultang ciphertext.

Mas mahusay na na-compress ang text kung may mga umuulit na lugar. Sa pamamagitan ng pagmamanipula ng data ng user, maaari mo itong piliin upang bahagyang tumutugma ito sa lihim na data. Kung mas malaki ang tugma, mas maliit ang ciphertext sa output. Ang ganitong uri ng pag-atake ay tinatawag na KRIMEN.

Kung wala kang mahirap na pangangailangan na i-compress ang data, huwag i-compress ito.

Kapaligiran ng server

Bilang pangkalahatang tuntunin, hindi ka dapat mag-host ng mga application na sensitibo sa seguridad sa isang nakabahaging server. Halimbawa, sa shared hosting, kung saan maaaring ma-access ng isang kalaban ang isang virtual machine sa parehong pisikal na server na gaya mo.

Mayroong iba't ibang mga dahilan kung bakit ang mga nakabahaging server ay isang kahina-hinalang lugar upang mag-host ng mga aplikasyong kritikal sa seguridad. Halimbawa, ang mga pag-atake sa pagitan ng mga virtual na server ay ipinakita kamakailan: eprint.iacr.org/2014/248.pdf. Ito ay isang magandang paalala na ang mga nakakasakit na diskarte ay hindi bumababa, ngunit sa halip ay hinahasa at pinagbubuti sa paglipas ng panahon. Ang ganitong mga pitfalls ay dapat palaging isinasaalang-alang.

Expert consultation

Panghuli ngunit hindi bababa sa, kumunsulta sa isang eksperto upang suriin ang iyong code ng seguridad.

(PHP 4, PHP 5, PHP 7)

crypt — One-way string hashing

Babala

Ang function na ito ay hindi (pa) binary safe!

Paglalarawan

crypt (string $str [, string $asin]): string

crypt() ay magbabalik ng hashed string gamit ang karaniwang Unix DES-based na algorithm o mga alternatibong algorithm na maaaring available sa system.

Ang parameter ng asin ay opsyonal. gayunpaman, crypt() lumilikha ng mahinang hash na walang asin. Ang PHP 5.6 o mas bago ay nagtataas ng E_NOTICE error nang wala ito. Tiyaking tumukoy ng sapat na malakas na asin para sa mas mahusay na seguridad.

password_hash() gumagamit ng malakas na hash, bumubuo ng malakas na asin, at awtomatikong naglalapat ng mga tamang round. password_hash() ay isang simple crypt() wrapper at tugma sa umiiral na mga hash ng password. Paggamit ng password_hash() ay hinihikayat.

Sinusuportahan ng ilang operating system ang higit sa isang uri ng hash. Sa katunayan, kung minsan ang karaniwang DES-based na algorithm ay pinapalitan ng isang MD5-based na algorithm. Ang uri ng hash ay na-trigger ng argumentong asin. Bago ang 5.3, tutukuyin ng PHP ang mga available na algorithm sa oras ng pag-install batay sa crypt() ng system. Kung walang ibibigay na asin, awtomatikong bubuo ang PHP ng alinman sa karaniwang dalawang character (DES) na asin, o labindalawang character ( MD5), depende sa availability ng MD5 crypt(). Nagtatakda ang PHP ng pare-parehong pinangalanan CRYPT_SALT_LENGTH na nagpapahiwatig ng pinakamahabang wastong asin na pinapayagan ng mga available na hash.

Ang karaniwang DES-based crypt() ibinabalik ang asin bilang unang dalawang character ng output. Ginagamit lang din nito ang unang walong character ng str , kaya ang mas mahahabang string na nagsisimula sa parehong walong character ay bubuo ng parehong resulta (kapag ang parehong asin ang ginamit).

Sa mga system kung saan sinusuportahan ng function na crypt() ang maraming uri ng hash, ang mga sumusunod na constant ay nakatakda sa 0 o 1 depende sa kung available ang ibinigay na uri:

  • CRYPT_STD_DES- Standard na hash na nakabatay sa DES na may dalawang character na asin mula sa alpabeto na "./0-9A-Za-z". Ang paggamit ng mga di-wastong character sa asin ay magiging sanhi ng pagkabigo ng crypt().
  • CRYPT_EXT_DES- Pinalawak na hash na nakabatay sa DES. Ang "salt" ay isang 9-character na string na binubuo ng isang underscore na sinusundan ng 4 na byte ng bilang ng pag-ulit at 4 na byte ng asin. Ang mga ito ay naka-encode bilang napi-print na mga character, 6 bits bawat character, hindi gaanong makabuluhang character muna. Ang mga value na 0 hanggang 63 ay naka-encode bilang "./0-9A-Za-z". Ang paggamit ng mga di-wastong character sa asin ay magiging sanhi ng pagkabigo ng crypt().
  • CRYPT_MD5- MD5 hashing na may labindalawang character na asin simula sa $1
  • CRYPT_BLOWFISH- Blowfish hashing na may asin gaya ng sumusunod: "$2a$", "$2x$" o "$2y$", isang dalawang digit na parameter ng gastos, "$", at 22 character mula sa alpabeto "./0-9A- Za-z". Ang paggamit ng mga character sa labas ng hanay na ito sa asin ay magiging sanhi ng pagbabalik ng crypt() ng zero-length na string. Ang dalawang digit na parameter ng gastos ay ang base-2 logarithm ng bilang ng pag-ulit para sa pinagbabatayan na Blowfish-based na hashing algorithmeter at dapat ay nasa hanay na 04-31, ang mga halaga sa labas ng hanay na ito ay magiging sanhi ng pagbagsak ng crypt(). Sinusuportahan lang ng mga bersyon ng PHP bago ang 5.3.7 ang "$2a$" bilang prefix ng asin: Ipinakilala ng PHP 5.3.7 ang mga bagong prefix upang ayusin ang kahinaan ng seguridad sa pagpapatupad ng Blowfish. Mangyaring sumangguni sa para sa buong detalye ng pag-aayos ng seguridad, ngunit upang buod, ang mga developer na nagta-target lamang ng PHP 5.3.7 at mas bago ay dapat gumamit ng "$2y$" bilang kagustuhan sa "$2a$".
  • CRYPT_SHA256- SHA-256 hash na may labing-anim na character na asin na may prefix na $5. Kung ang salt string ay nagsisimula sa "rounds=
  • CRYPT_SHA512- SHA-512 hash na may labing-anim na character na asin na may prefix na $6$. Kung ang salt string ay nagsisimula sa "rounds= $", ang numeric na halaga ng N ay ginagamit upang isaad kung gaano karaming beses dapat isagawa ang hashing loop, katulad ng cost parameter sa Blowfish. Ang default na bilang ng mga round ay 5000, mayroong minimum na 1000 at maximum na 999,999,999. Ang anumang seleksyon ng N sa labas ng saklaw na ito ay puputulin sa pinakamalapit na limitasyon.

Mula sa PHP 5.3.0, naglalaman ang PHP ng sarili nitong pagpapatupad at gagamitin iyon kung walang suporta ang system para sa isa o higit pa sa mga algorithm.

Mga Parameter

Ang string na i-hash.

Pag-iingat

Gamit ang CRYPT_BLOWFISH algorithm, ay magreresulta sa str parameter na pinutol sa maximum na haba na 72 character.

Isang opsyonal na salt string na pagbabatayan ng hashing. Kung hindi ibinigay, ang gawi ay tinutukoy ng pagpapatupad ng algorithm at maaaring humantong sa mga hindi inaasahang resulta.

Ibalik ang mga Halaga

Ibinabalik ang na-hash na string o isang string na mas maikli sa 13 character at garantisadong naiiba sa asin kapag nabigo.

Babala

Kapag nagpapatunay ng mga password, dapat gamitin ang isang string ng paghahambing na function na hindi vulnerable sa mga pag-atake sa timing upang ihambing ang output ng crypt() sa dating kilalang hash. Nagbibigay ang PHP 5.6 pataas hash_equals() para sa layuning ito.

Changelog

Bersyon Paglalarawan
5.6.5 Kapag ang failure string na "*0" ay ibinigay bilang salt , "*1" ay ibabalik na ngayon para sa pagkakapare-pareho sa iba pang mga pagpapatupad ng crypt. Bago ang bersyong ito, ang PHP 5.6 ay maling magbabalik ng DES hash.
5.6.0 Itaas ang E_NOTICE na babala sa seguridad kung ang asin ay tinanggal.
5.5.21 Kapag ang failure string na "*0" ay ibinigay bilang salt , "*1" ay ibabalik na ngayon para sa pagkakapare-pareho sa iba pang mga pagpapatupad ng crypt. Bago ang bersyong ito, ang PHP 5.5 (at mga naunang sangay) ay maling magbabalik ng DES hash.
5.3.7 Idinagdag $2x$ at $2y$ Blowfish mode upang harapin ang mga potensyal na high-bit na pag-atake.
5.3.2 Idinagdag ang SHA-256 at SHA-512 crypt batay sa pagpapatupad ni Ulrich Drepper.
5.3.2 Inayos ang gawi ng Blowfish sa mga invalid na round upang ibalik ang string na "failure" ("*0" o "*1"), sa halip na bumalik sa DES.
5.3.0 Naglalaman na ngayon ang PHP ng sarili nitong pagpapatupad para sa MD5 crypt, Standard DES, Extended DES at mga algorithm ng Blowfish at gagamitin iyon kung walang suporta ang system para sa isa o higit pa sa mga algorithm.

Mga halimbawa

Halimbawa #1 crypt() mga halimbawa

$hashed_password = crypt("mypassword"); // hayaang awtomatikong mabuo ang asin

/* Dapat mong ipasa ang buong resulta ng crypt() bilang asin para sa paghahambing ng a
password, upang maiwasan ang mga problema kapag iba't ibang mga algorithm ng hashing ang ginagamit. (Bilang
sabi nito sa itaas, ang karaniwang DES-based na password hashing ay gumagamit ng 2-character na asin,
ngunit ang hashing na nakabatay sa MD5 ay gumagamit ng 12.) */
kung (hash_equals ($hashed_password , crypt ($user_input , $hashed_password ))) (
echo "Na-verify ang password!" ;
}
?>

Halimbawa #2 Paggamit crypt() gamit ang htpasswd

// Itakda ang password
$password = "mypassword" ;

// Kunin ang hash, hayaang awtomatikong mabuo ang asin
$hash = crypt ($password);
?>

Halimbawa #3 Paggamit crypt() na may iba't ibang uri ng hash

/* Ang mga asin na ito ay mga halimbawa lamang, at hindi dapat gamitin sa verbatim sa iyong code.
Dapat kang bumuo ng isang natatanging, wastong na-format na asin para sa bawat password.
*/
 kung (CRYPT_STD_DES == 1 ) (
echo "Pamantayang DES: " . crypt ("rasmuslerdorf" , "rl" ). "\n" ;
}

kung (CRYPT_EXT_DES == 1 ) (
echo "Extended DES: " . crypt ("rasmuslerdorf" , "_J9..rasm" ) . "\n" ;
}

kung (CRYPT_MD5 == 1 ) (
echo "MD5: " . crypt ("rasmuslerdorf" , "$1$rasmusle$" ) . "\n" ;
}

kung (CRYPT_BLOWFISH == 1 ) (
echo "Blowfish: " . crypt("rasmuslerdorf", "$2a$07$usesomesillystringforsalt$"). "\n" ;
}

kung (CRYPT_SHA256 == 1 ) (
echo "SHA-256: " . crypt("rasmuslerdorf", "$5$rounds=5000$usesomesillystringforsalt$"). "\n" ;
}

kung (CRYPT_SHA512 == 1 ) (
echo "SHA-512: " . crypt("rasmuslerdorf", "$6$rounds=5000$usesomesillystringforsalt$"). "\n" ;
}
?>

Ang anumang impormasyon ay maaaring i-encrypt o i-decrypt, kabilang ang paggamit ng PHP. Ang wikang ito ay may maraming mga kakayahan sa pag-encrypt ng data, mula sa simple hanggang sa kumplikado.

Tingnan natin ang mga pangunahing paraan ng pag-encrypt

base64- nagbibigay-daan sa iyong i-encrypt at i-decrypt ang data gamit ang algorithm ng MIME base64. Hindi ito gumagamit ng mga susi at kadalasang ginagamit upang itago ang mga link sa PHP.

Mga halimbawa:
//i-encrypt ang teksto
$text = "Link";
echo base64_encode($text); //Produces: PGEgaHJlZj0iIyI+0KHRgdGL0LvQutCwPC9hPg==
//decryption
echo base64_decode("PGEgaHJlZj0iIyI+0KHRgdGL0LvQutCwPC9hPg==");
?>

Tulad ng nakikita mo, ginamit muna namin ang base64_encode na operasyon at nakuha ang cipher: PGEgaHJlZj0iIyI+0KHRgdGL0LvQutCwPC9hPg==, at pagkatapos ay pinalitan ito sa base64_decode at ibinalik ang link.

md5- nagbibigay-daan sa iyo na mag-hash ng data nang unilaterally. Iyon ay, hindi tulad ng base64, hindi mo na magagawang i-decrypt ang mga ito pabalik. Kadalasan ang md5 ay ginagamit upang mag-imbak ng mga password sa isang database, ngunit kamakailan ang naka-encrypt na kumbinasyon ng md5 ay naging madaling mahanap sa mga talahanayan ng decryption, na mabait na ibinigay ng maraming mga site at algorithm. Samakatuwid, upang mag-imbak ng mga password ng md5, mas mahusay na palitan ang mga algorithm ng Blowfish.

Halimbawa:

//i-encrypt ang teksto
echo md5("kumbinasyon");
?>

Key encryption

At ang huling halimbawa ng pag-encrypt/decryption na gusto kong pag-usapan ay gumagamit ng isang susi (bilang isang password). Iyon ay, ipinapasa mo ang isang natatanging susi sa pag-andar ng pag-encrypt, at ang code ay naka-encrypt kasama nito. Upang i-decrypt, dapat mong ibigay ang function na may naka-encrypt na code at isang key na ikaw lang ang nakakaalam. Isang halimbawa ng paggamit ng mga function sa pinakailalim ng code.

function na __encode($text, $key) (



$enc_text=base64_encode(mcrypt_generic($td,$iv.$text));
mcrypt_generic_deinit($td);
mcrypt_module_close($td);
ibalik ang $enc_text; ) )
function na strToHex($string) (
$hex="";
para sa ($i=0; $i< strlen($string); $i++) { $hex .= dechex(ord($string[$i])); }
ibalik ang $hex; )
function __decode($text, $key) (
$td = mcrypt_module_open("tripledes", "", "cfb", "");
$iv_size = mcrypt_enc_get_iv_size($td);
$iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
kung (mcrypt_generic_init ($td, $key, $iv) != -1) (
$decode_text = substr(mdecrypt_generic($td, base64_decode($text)),$iv_size);
mcrypt_generic_deinit($td);
mcrypt_module_close($td);
ibalik ang $decode_text; ) )
function hexToStr($hex) (
$string="";
para sa ($i=0; $i< strlen($hex)-1; $i+=2) { $string .= chr(hexdec($hex[$i].$hex[$i+1])); }
ibalik ang $string; )

$str = "Mga bun na kailangang i-encrypt!
Sa pamamagitan ng susi";
$code = strToHex(__encode($str, "My#key-do-36-simvolov"));
echo "Naka-encrypt na code: ".$code."
";

$str = __decode(hexToStr($code), "My#key-do-36-simvolov");
echo "Na-decrypt na code: ".$str."
";
?>

Maaari mong i-encrypt ang nilalaman ng html. Ang haba ng key ay dapat na hindi hihigit sa 36 na mga character.

Ang pamamaraang ito ay maaaring gamitin upang i-encrypt ang ilang data at ilagay ito sa isang txt file o database, at matanggap ito gamit ang decryption na may susi.

Siyempre, ang anumang code ay maaaring i-decrypted/hack at ito ay walang pagbubukod, kaya gumamit ng malakas na paraan ng pag-encrypt.

Isa sa mga pangunahing katotohanan ng cryptography ay hindi ka dapat mag-imbento ng anuman sa lugar na ito maliban kung ikaw ay isang propesyonal. Ito ay bahagyang totoo, dahil ang lahat ng pinakamahusay ay matagal nang naimbento, nagdusa at ginamit sa loob ng mga dekada sa larangan ng teknolohiya ng impormasyon. Ang kabilang panig ng katotohanan ay ang pag-unlad ng isang tiyak na larangan ng kaalaman ay nangyayari lamang sa patuloy na pagdagsa ng mga sariwang ideya at orihinal na mga solusyon dito.

Para sa malinaw na mga kadahilanan, hindi namin tutukuyin ang mga higante ng pang-industriyang cryptography tulad ng AES, ngunit sasabak, wika nga, sa aming sariling cryptographic na pananaliksik na may blackjack at kagalakan.

Bahagyang dahil ito ay kawili-wili, isang bahagi dahil sa pamamagitan ng pagmomodelo ng sarili mong bagay at paghahambing nito sa mga kinikilalang pamantayan, malinaw mong nakikita ang kaibahan, epektibong mga solusyon at tahasang pagkukulang, at nauunawaan mo kung ano ang maaari mong pagsikapang mapahusay ang kahusayan.

Ngunit sapat na ang tubig.

Sabihin nating ang aming web application ay nakasulat sa PHP, nangangailangan ng reversible encryption, at naniniwala kami na maaari naming isulat ang aming sariling cipher system.

Kaya, isulat natin ang sarili nating reversible encryption system na may pribado at pampublikong mga key, isa na magkakaroon ng mga sumusunod na feature ng isang mas o hindi gaanong secure na cryptographic algorithm:

  1. Ang pagkakaroon ng mga simbolo ng ingay sa huling cipher.
  2. Ang impormasyon sa bawat channel ng Sender-Destination ay ie-encrypt gamit ang isang pribadong key, at ang pagtutugma ng function ay magiging kakaiba para sa bawat key.
  3. Ang bawat mensahe ay makakatanggap ng isang digest code - isang natatanging code na isang function ng pribadong key at ang orihinal na mensahe. Ito ay kinakailangan upang makamit ang pagiging natatangi ng "source symbol" na tumutugmang function<=>naka-encode na simbolo" hindi lamang para sa channel na "Sender-Receiver", kundi para din sa bawat indibidwal na mensahe.

    Kaya, kahit na isipin natin na ang pagsusulatan ng mga naka-encode at orihinal na mga simbolo para sa isang partikular na mensahe ay naging kilala sa pamamagitan ng paggamit ng cryptographic analysis, halimbawa, frequency analysis, hindi ito nagbibigay ng anumang mga kagustuhan kapag nag-aaral ng isa pang mensahe.

  4. Upang gawing kumplikado ang pagsusuri ng dalas, ie-encode namin ang bawat simbolo ng paunang mensahe na may dalawang simbolo ng cipher.
So anong nangyari.

Sa katunayan, makikita mo ang huling resulta

Kasama sa klase ng SymCoder ang mga pamamaraan ng pag-encrypt at pag-decryption.

Ang pag-encrypt ay isinasagawa sa pamamagitan ng code() na pamamaraan, na kumukuha ng orihinal na mensahe bilang input.

Dito, ang isang mensahe mula sa nabuong talahanayan ng pagsusulatan sa tab_coded ay lumilikha ng isang naka-encrypt na mensahe, diluted kasama ang mga gilid at sa loob na may mga simbolo ng ingay.

Siyanga pala, ang mga simbolo ng ingay ay natatangi para sa bawat channel ng patutunguhan ng nagpadala, dahil nabuo ang mga ito gamit ang key ng channel, ngunit hindi natatangi para sa mga mensahe. Ang mga simbolo na ginagamit para sa pag-encrypt sa code_symbols ay ilang mga bantas at simbolo tulad ng %, @, atbp.

Para sa bawat naka-encode na simbolo, mayroong dalawang simbolo mula sa code_symbols, para sa malinaw na mga kadahilanan na may ilang beses na mas kaunti sa mga ito kaysa sa mga naka-encode na simbolo.

Ang create_tab_coded correspondence table ay binuo gamit ang pagsasalin ng message key hash sa isang array na may bilang ng mga elemento na katumbas ng bilang ng mga elemento sa code symbol array. Ang panimulang posisyon para sa pagtawid sa dalawang-character na code ay palaging naiiba at nauugnay sa channel key. Ginagawa nitong posible na matiyak na ang algorithm para sa pagtawid sa mga naka-encode na simbolo at pagtutugma ng mga simbolo ng code sa kanila ay palaging magiging iba (o ginagarantiyahan na madalas).

Halimbawa, ang "hello world" na mensahe, kapag naka-encode, ay ganito ang hitsura:

Digest-a00bf11d-&?==&!&?.@.@=!=-.?&1.#&?=:.:.1%!&-%@&@%~&1^#=?%% .!%+.?.~=?..&?%&&:%~.#%@&1&1.#=?.#.?.!&1==&=.-=!

At narito ang parehong mensahe, na na-encode muli:

Digest-a00bf11d-=:.?=:&!.?.1&-=:=?.?.=.?.!&=%!=-%@=!%~.=^#.1%%. !%+=:.~.@..==%&&1%~.1%@=?.@.!&=.!&@=:&1.==:=!.1&:

Makikita na ang digest ng parehong mensahe ay pareho, ngunit ang cipher ay nagiging iba - ang mga simbolo ng ingay ay idinagdag sa isang arbitrary na tugma at sa isang arbitrary na pagkakasunud-sunod para sa bawat bagong pag-encrypt.

Ang mga mensahe ay may redundancy, na bumababa habang tumataas ang volume ng mensahe, hanggang 10% na ingay (para sa pinakamaikling mensahe, ang ingay ay umabot sa 90% o mas mataas na porsyento), ang minimum na haba ng isang naka-encrypt na mensahe ay 116 na character. Ang isa sa mga kawalan ng paraan ng pag-encrypt na ito ay ang mga naka-encode na mensahe ay hindi bababa sa nadoble.

Ang pag-decode ay binubuo ng reverse translation ng form na "code symbol" - ang orihinal na simbolo na may ingay na pinutol mula sa mensahe. Ano kaya ang susi? Karaniwan, anumang string na natatangi para sa bawat pares ng destination-receiver.

Halimbawa, kung gumagawa ka ng messenger na may pag-encrypt ng mensahe, ang pinakasimpleng bersyon ng pribadong key ay maaaring md5($user_id_1. $salt. $user_id_2), kung gayon ang key ay magiging kakaiba para sa bawat channel ng mensahe.

Sabihin nating kailangan mong makipagpalitan ng data sa pagitan ng dalawang server. Upang maprotektahan ang data mula sa pag-eavesdrop ng trapiko, naka-encrypt ang data. Well, halimbawa, paglilipat ng mga aksyon sa loob ng isang botnet. Ito ang mahalagang hindi pag-encrypt, ngunit tinatawag na pag-encode, at ang mga kilalang function ay ginagamit upang i-decode ang naturang code.

Bilang isa pang halimbawa ng pseudo-encryption, magbibigay ako ng isang halimbawa ng "encryption" ng mga password sa database ng isang CMS - may mga password ay hindi naka-encrypt sa md5() o , ngunit naka-encode lamang sa pamamagitan ng base64. Yung. Kapag na-leak ang database, hindi magiging mahirap para sa isang hacker na i-decrypt ang lahat ng mga password gamit ang built-in na PHP function na base64_decode().

Kailangan nating magpadala ng data nang hindi nababahala na may makakapigil sa text at ma-decrypt ito. Ang PHP ay may sikat na data encryption package na tinatawag na Mcrypt, na nagbibigay ng two-way encryption (iyon ay, ang aktwal na encryption at decryption ng data).

Sinusuportahan ng Mcrypt version 2.4.7 ang mga sumusunod na symmetric encryption algorithm: Blowfish, RC2, Safer-sk64 xtea, Cast-256, RC4, Safer-sk128, DES, RC4-iv, Serpent, Enigma, Rijndael-128, Threeway, Rijndael-192 , TripleDES, LOKI97, Rijndael-256, Twofish, Panama, Saferplus, atbp. Higit pang mga detalye tungkol sa bawat algorithm ay nakasulat sa Wikipedia.

Dahil ginagamit ang simetriko na pag-encrypt, ang susi ay dapat na malaman ng parehong partido at pinananatiling lihim.

Halimbawa ng pag-encrypt at pag-decryption ng isang string

mcrypt_module_open("des", "", "ecb", "")
Binubuksan ng function na ito ang algorithm module at ang mode na ginamit. Para sa halimbawang ito, ang DES algorithm ay nasa ECB mode.

$key = substr($key, 0, mcrypt_enc_get_key_size($td));
Ang maximum na laki ng key ay dapat makuha sa pamamagitan ng pagtawag sa mcrypt_enc_get_key_size() function, at anumang halaga na mas mababa dito ay magiging tama.

$s = mcrypt_generic($td, $source);
Kapag nag-e-encrypt, ang data ay nilagyan ng zero byte upang matiyak na ang data ay n*blocksize ang haba. Ang block size ng block ay tinutukoy ng algorithm (para sa DES ang block size ay 64 bits). Samakatuwid, kapag nagde-decryption, maaaring lumabas ang “\0” sa dulo ng linya, na inaalis ng trim() function



Mga kaugnay na publikasyon