Mysql escaping quotes. At ang hindi bababa sa tulong ay mula sa function na iyong binuo. Walang kwentang karakter na tumatakas


Una, kaunti tungkol sa kung bakit kailangan ang mga slash na ito sa pangkalahatan.
Kung papalitan namin ang anumang data sa query, pagkatapos ay upang makilala ang data na ito mula sa mga SQL command, dapat silang ilagay sa mga panipi.
Halimbawa, kung nagsusulat ka
SELECT * FROM table WHERE name = Bill
pagkatapos ay magpapasya ang database na ang Bill ay ang pangalan ng isa pang field, hindi ito mahahanap, at magtapon ng error. Samakatuwid, ang pinalit na data (sa kasong ito, ang pangalang Bill) ay dapat na nakapaloob sa mga quote - pagkatapos ay isasaalang-alang ito ng database na isang string, ang halaga nito ay dapat italaga sa field ng pangalan:
SELECT * FROM table WHERE name = "Bill"
Gayunpaman, maaari ring lumitaw ang mga quote sa mismong data. Halimbawa,
SELECT * FROM table WHERE name = "D"Artagnan"
Dito ang database ay magpapasya na ang "D" ay data, at ang Artagnan ay isang utos na hindi nito alam, at magtapon din ng isang error. Samakatuwid, kinakailangang subaybayan ang lahat ng data upang maipaliwanag sa database na ang mga panipi (at ilang iba pang mga espesyal na character) na matatagpuan sa mga ito ay tumutukoy sa data.
Bilang resulta, makakatanggap kami ng tamang kahilingan na hindi magdudulot ng mga error:
SELECT * FROM table WHERE name = "D\"Artagnan"

Kaya, nalaman namin na kapag pinapalitan ang string ng data sa isang query, dalawang panuntunan ang dapat sundin:
- lahat ng ipinasok na string data ay dapat na nakapaloob sa mga quote (single o double, ngunit ang mga single ay mas maginhawa at mas madalas na ginagamit).
- ang mga espesyal na character ay dapat na makatakas sa mga slash.

Dapat itong espesyal na tandaan: ang mga idinagdag na slash ay HINDI pumupunta sa database. Ang mga ito ay kailangan lamang sa kahilingan. Kapag tumama sa base, ang mga slash ay itinatapon. Alinsunod dito, ang isang karaniwang pagkakamali ay ang paggamit ng mga stripslashes kapag kumukuha ng data mula sa database.

Nalalapat ang lahat ng nasa itaas sa string data at mga petsa. Ang mga numero ay maaaring ipasok nang walang trailing o nakapalibot sa kanila ng mga panipi. Kung gagawin mo ito pagkatapos KINAKAILANGAN! pilitin ang data sa nais na uri bago ito ipasok sa query, halimbawa:
$id = intval ($id);
Gayunpaman, para sa pagiging simple (at pagiging maaasahan), maaari kang magtrabaho sa mga numero tulad ng sa mga string (dahil ang mysql ay nagko-convert pa rin sa mga ito sa nais na uri). Alinsunod dito, susubaybayan namin ang anumang data na ipinasok sa kahilingan at ilakip ito sa mga panipi.

Gayundin, may isa pang panuntunan - opsyonal, ngunit dapat itong sundin upang maiwasan ang mga error:
Ang mga pangalan ng mga patlang at talahanayan ay dapat na nakapaloob sa likod ng mga solong panipi - "`" (ang susi na may ganitong simbolo ay matatagpuan sa isang karaniwang keyboard sa kaliwa ng "1" na key). mga keyword, ngunit kung gagamit tayo ng back quote, mauunawaan ng MySQL na tama ang lahat:
PUMILI * MULA SA `table` WHERE `date` = "2006-04-04"
Dapat mong makilala ang pagitan ng mga panipi na ito at huwag malito ang isa sa isa. Dapat mo ring tandaan na ang mga backtick ay hindi natatakasan ng mga slash.

Kaya, natutunan namin kung paano wastong palitan ang data sa isang kahilingan.
PERO! Ang pagbuo ng dynamic na query ay hindi limitado sa pagpapalit ng data. Kadalasan kailangan nating palitan ang mga SQL command at field name sa isang query. At narito tayo lumipat sa paksa ng seguridad:

Ang SQL Injection ay isang paraan ng pag-atake ng hacker kapag ang data na inilipat sa isang script ay binago sa paraang ang query na nabuo sa script na ito ay nagsimulang magsagawa ng isang bagay na ganap na naiiba mula sa kung ano ang nilayon nito.
Ang mga patakaran para sa pagprotekta laban sa mga naturang pag-atake ay maaaring nahahati sa dalawang punto:
1. Paggawa gamit ang data.
2. Paggawa gamit ang mga kontrol sa query.

Tinalakay namin ang unang punto nang detalyado sa itaas. Masasabing hindi ito, sa katunayan, isang depensa. Ang pagsunod sa mga panuntunan para sa pagdaragdag ng data sa isang query ay idinidikta, una sa lahat, ng mga kinakailangan ng SQL SYNTAX. At bilang side effect, mayroon din kaming proteksyon laban sa pag-hack.

Ang pangalawang punto ay mas mahirap, dahil walang iisang unibersal na panuntunan tulad ng para sa data - hindi mapoprotektahan ng mga backtick ang pangalan ng field mula sa pagbabago ng isang hacker. Hindi posibleng gumamit ng mga quote para protektahan ang mga pangalan ng talahanayan, SQL statement, LIMIT command parameter, at iba pang statement.
Samakatuwid, ang pangunahing panuntunan kapag pinapalitan ang mga elemento ng kontrol sa isang query ay:
Kung kailangan mong dynamic na magpasok ng mga SQL statement o mga pangalan ng mga field, database, table sa isang query, sa anumang pagkakataon ay hindi mo dapat ipasok ang mga ito nang direkta sa query.
Ang lahat ng mga opsyon para sa mga naturang karagdagan ay dapat na nakasulat sa ADVANCE sa iyong script at piliin batay sa kung ano ang ipinasok ng user.
Halimbawa, kung kailangan mong magpasa ng pangalan ng field sa order ng operator, sa anumang pagkakataon ay hindi mo ito dapat direktang palitan. Kailangan muna nating suriin ito. Halimbawa, gumawa ng hanay ng mga wastong halaga, at palitan ito sa kahilingan lamang kung ang naipasa na parameter ay nasa array na ito:
$orders =array("pangalan" , "presyo" , "qty" );
$key = array_search($_GET["sort"], $orders));
$orderby = $orders [ $key ];
$query = "PUMILI * MULA SA `table` ORDER NI$orderby " ;

Hinahanap namin ang hanay ng mga paunang inilarawan na opsyon para sa salitang ipinasok ng user, at kung makita namin ito, pipiliin namin ang kaukulang elemento ng array. Kung walang nakitang tugma, pipiliin ang unang elemento ng array.
Kaya, ang ipinalit sa kahilingan ay hindi kung ano ang ipinasok ng gumagamit, ngunit kung ano ang nakasulat sa aming script.
Ang parehong ay dapat gawin sa lahat ng iba pang mga kaso.
Halimbawa, kung ang sugnay na WHERE ay dynamic na nabuo:
kung (!empty($_GET [ "presyo" ])) $where .= "price="" . mysql_real_escape_string ($_GET [ "presyo" ]). """ ;
$query = "PUMILI * MULA SA `table` SAAN $where " ;

Mahirap para sa akin na isipin ang isang kaso kung saan maaaring maipasok ang isang pangalan ng talahanayan sa isang query nang pabago-bago, ngunit kung mangyari ito, kailangan ding ipasok ang pangalan mula lamang sa isang set na paunang natukoy sa script.
Ang mga parameter ng LIMIT operator ay dapat na pilitin sa isang uri ng integer gamit ang mga pagpapatakbo ng arithmetic o ang intval() function.
Huwag isipin na nauubos ng mga halimbawang nakalista dito ang lahat ng opsyon para sa pagbuo ng dynamic na query. Kailangan mo lamang na maunawaan ang prinsipyo at ilapat ito sa lahat ng ganoong kaso.


Una, kaunti tungkol sa kung bakit kailangan ang mga slash na ito sa pangkalahatan.
Kung papalitan namin ang anumang data sa query, pagkatapos ay upang makilala ang data na ito mula sa mga SQL command, dapat silang ilagay sa mga panipi.
Halimbawa, kung nagsusulat ka
SELECT * FROM table WHERE name = Bill
pagkatapos ay magpapasya ang database na ang Bill ay ang pangalan ng isa pang field, hindi ito mahahanap, at magtapon ng error. Samakatuwid, ang pinalit na data (sa kasong ito, ang pangalang Bill) ay dapat na nakapaloob sa mga quote - pagkatapos ay isasaalang-alang ito ng database na isang string, ang halaga nito ay dapat italaga sa field ng pangalan:
SELECT * FROM table WHERE name = "Bill"
Gayunpaman, maaari ring lumitaw ang mga quote sa mismong data. Halimbawa,
SELECT * FROM table WHERE name = "D"Artagnan"
Dito ang database ay magpapasya na ang "D" ay data, at ang Artagnan ay isang utos na hindi nito alam, at magtapon din ng isang error. Samakatuwid, kinakailangan na subaybayan ang lahat ng data upang maipaliwanag sa database na ang mga panipi (at ilang iba pang mga espesyal na character) na matatagpuan sa mga ito ay tumutukoy sa data.
Bilang resulta, makakatanggap kami ng tamang kahilingan na hindi magdudulot ng mga error:
SELECT * FROM table WHERE name = "D\"Artagnan"

Kaya, nalaman namin na kapag pinapalitan ang data sa isang query, dalawang panuntunan ang dapat sundin:
- lahat ng data na ipinasok sa kahilingan ay dapat na nakapaloob sa mga panipi (single o double, ngunit ang mga single ay mas maginhawa at mas madalas na ginagamit).
- sa lahat ng string variable, ang mga espesyal na character ay dapat na i-escape gamit ang mga slash.

Dapat itong espesyal na tandaan: ang mga idinagdag na slash ay HINDI pumupunta sa database. Ang mga ito ay kailangan lamang sa kahilingan. Kapag tumama sa base, ang mga slash ay itinatapon. Alinsunod dito, ang isang karaniwang pagkakamali ay ang paggamit ng mga stripslashes kapag kumukuha ng data mula sa database.

Sa katunayan, lahat ng nasa itaas ay nalalapat sa string data at mga petsa. Maaaring ipasok ang mga numero nang walang trailing o nakapalibot sa kanila ng mga panipi. Kung gagawin mo ito pagkatapos KINAKAILANGAN! pilitin ang data sa nais na uri bago ito ipasok sa query, halimbawa:
$id = intval ($id);
Gayunpaman, para sa pagiging simple (at pagiging maaasahan), maaari kang magtrabaho sa mga numero tulad ng sa mga string (dahil ang mysql ay nagko-convert pa rin sa mga ito sa nais na uri). Alinsunod dito, susubaybayan namin ang anumang data na ipinasok sa kahilingan at ilakip ito sa mga panipi.

Gayundin, may isa pang panuntunan - opsyonal, ngunit dapat itong sundin upang maiwasan ang mga error:
Ang mga pangalan ng mga patlang at talahanayan ay dapat na nakapaloob sa likod ng mga solong panipi - "`" (ang susi na may ganitong simbolo ay matatagpuan sa isang karaniwang keyboard sa kaliwa ng "1" na key). mga keyword, ngunit kung gagamit tayo ng back quote, mauunawaan ng MySQL na tama ang lahat:
PUMILI * MULA SA `table` WHERE `date` = "2006-04-04"
Dapat mong makilala ang pagitan ng mga panipi na ito at huwag malito ang isa sa isa. Dapat mo ring tandaan na ang mga backtick ay hindi natatakasan ng mga slash.

Kaya, natutunan namin kung paano wastong palitan ang data sa isang kahilingan.
PERO! Ang pagbuo ng dynamic na query ay hindi limitado sa pagpapalit ng data. Kadalasan kailangan nating palitan ang mga SQL command at field name sa isang query. At narito tayo lumipat sa paksa ng seguridad:

Ang SQL Injection ay isang paraan ng pag-atake ng hacker kapag ang data na inilipat sa isang script ay binago sa paraang ang query na nabuo sa script na ito ay nagsimulang magsagawa ng isang bagay na ganap na naiiba mula sa kung ano ang nilayon nito.
Ang mga patakaran para sa pagprotekta laban sa mga naturang pag-atake ay maaaring nahahati sa dalawang punto:
1. Paggawa gamit ang data.
2. Paggawa gamit ang mga kontrol sa query.

Tinalakay namin ang unang punto nang detalyado sa itaas. Masasabing hindi ito, sa katunayan, isang depensa. Ang pagsunod sa mga panuntunan para sa pagdaragdag ng data sa isang query ay idinidikta, una sa lahat, ng mga kinakailangan ng SQL SYNTAX. At bilang side effect, mayroon din kaming proteksyon laban sa pag-hack.

Ang pangalawang punto ay mas mahirap, dahil walang iisang unibersal na panuntunan tulad ng para sa data - hindi mapoprotektahan ng mga backtick ang pangalan ng field mula sa pagbabago ng isang hacker. Hindi posibleng gumamit ng mga quote para protektahan ang mga pangalan ng talahanayan, SQL statement, LIMIT command parameter, at iba pang statement.
Samakatuwid, ang pangunahing panuntunan kapag pinapalitan ang mga elemento ng kontrol sa isang query ay:
Kung kailangan mong dynamic na magpasok ng mga SQL statement o mga pangalan ng mga field, database, table sa isang query, sa anumang pagkakataon ay hindi mo dapat ipasok ang mga ito nang direkta sa query.
Ang lahat ng mga opsyon para sa mga naturang karagdagan ay dapat na nakasulat sa ADVANCE sa iyong script at piliin batay sa kung ano ang ipinasok ng user.
Halimbawa, kung kailangan mong magpasa ng pangalan ng field sa order ng operator, sa anumang pagkakataon ay hindi mo ito dapat direktang palitan. Kailangan muna nating suriin ito. Halimbawa, gumawa ng hanay ng mga wastong halaga, at palitan ito sa kahilingan lamang kung ang naipasa na parameter ay nasa array na ito:
$orders =array("pangalan" , "presyo" , "qty" );
$key = array_search($_GET["sort"], $orders));
$orderby = $orders [ $key ];
$query = "PUMILI * MULA SA `table` ORDER NG $orderby";
 Hinahanap namin ang hanay ng mga paunang inilarawan na opsyon para sa salitang ipinasok ng user, at kung makita namin ito, pipiliin namin ang kaukulang elemento ng array. Kung walang nakitang tugma, pipiliin ang unang elemento ng array.
Kaya, ang ipinalit sa kahilingan ay hindi kung ano ang ipinasok ng gumagamit, ngunit kung ano ang nakasulat sa aming script.
Ang parehong ay dapat gawin sa lahat ng iba pang mga kaso.
Halimbawa, kung ang sugnay na WHERE ay dynamic na nabuo:
kung (!empty($_GET [ "presyo" ])) $where .= "price="" . mysql_real_escape_string ($_GET [ "presyo" ]). """ ;
$query = "PUMILI * MULA SA `table` KUNG SAAN $where";
 Mahirap para sa akin na isipin ang isang kaso kung saan maaaring maipasok ang isang pangalan ng talahanayan sa isang query nang pabago-bago, ngunit kung mangyari ito, kailangan ding ipasok ang pangalan mula lamang sa isang set na paunang natukoy sa script.
Ang mga parameter ng LIMIT operator ay dapat na pilitin sa isang uri ng integer gamit ang mga pagpapatakbo ng arithmetic o ang intval() function.
Huwag isipin na nauubos ng mga halimbawang nakalista dito ang lahat ng opsyon para sa pagbuo ng dynamic na query. Kailangan mo lamang na maunawaan ang prinsipyo at ilapat ito sa lahat ng ganoong kaso.

Mga tampok ng pagtatrabaho sa operator ng LIKE
Ang isang ganap na hiwalay na kaso ay ang TULAD operator.
Una, bilang karagdagan sa karaniwang pagsubaybay, ang mga slash ay dapat na doble sa mga variable na pinapalitan sa LIKE. Iyon ay, kung ang variable ay naglalaman ng character na \, dapat itong doblehin, at pagkatapos ay ang karaniwang pagtakas ay dapat gawin sa pamamagitan ng mysql_real_escape_string.
Halimbawa, kung hinahanap natin ang string
ang \ character ay tinatawag na "backslash" at kailangan namin ng eksaktong tugma, pagkatapos ay ginagamit lang namin ang mysql_real_escape_string at ang query ay pamantayan:
SELECT * FROM test WHERE field = "ang simbolo \\ ay tinatawag na \"backslash\"" Kung gusto nating palitan ang string na ito sa LIKE, kailangan muna nating palitan ang bawat slash ng dalawa, at pagkatapos ay ilapat ang mysql_real_escape_string. Ang magiging resulta
PUMILI * MULA sa talahanayan KUNG SAAN ang field na TULAD ng "%character \\\\ ay tinatawag na \"backslash\"%"
Ang pangalawang bagay na dapat tandaan ay wala sa mga function na nagdaragdag ng mga slash ang nagdaragdag sa mga ito sa "%" at "_" na mga metacharacter sa paghahanap na ginamit sa operator ng LIKE. Samakatuwid, kung gagamitin mo ang operator na ito at ayaw mong gamitin ang _ at % na mga character bilang mga wildcard, pagkatapos ay manu-manong magdagdag ng mga slash. Magagawa ito sa utos
$data = addCslashes($data, "%_");

Pansin - hindi ito nagdaragdag ng mga pilikmata! Ang pangalan ng function na ito ay may dagdag na "c" sa pangalan nito.
Kaya, lumalabas na dapat nating iproseso nang hiwalay ang mga variable na ginagamit sa operator ng LIKE.
palitan muna ang isang slash ng dalawa, gamit, halimbawa, ang code na tulad nito:
$var = str_replace ("\\" , "\\\\" , $var ); pagkatapos (maaari mong, kasama ang lahat ng iba pang data na pumapasok sa kahilingan), bakas:
$var = mysql_real_escape_string ($var);
at pagkatapos ay kung gusto namin ang _ at % na eksaktong tumugma sa kanilang mga sarili, gagawin namin
$var = addCslashes($var, "_%"); Bilang resulta, kung maghahanap tayo, halimbawa, para sa naturang linya
ang \ character ay tinatawag na "backslash" at ang _ character ay tinatawag na "underscore" pagkatapos ay pagkatapos ng pagproseso, sa kahilingan dapat itong magmukhang ganito:

"Ang %symbol \\\\ ay tinatawag na \"backslash\" at ang simbolo na \_ ay tinatawag na \"underscore\"
Ibig sabihin, apat na beses na ang slash na orihinal na nasa linya. Ang natitirang mga character ay sinusubaybayan gaya ng dati. Dagdag pa - nakita ang underscore na character.
Nangyayari ito dahil sa mga espesyal na setting ng PHP, kadalasang pinapagana sa pagho-host bilang default. Sa teorya, ang mga setting na ito ay maaaring tumaas ang seguridad ng mga script na gumagana sa database. Sa pagsasagawa, ang awtomatikong pagdaragdag ng mga slash ay kadalasang nagreresulta sa pagkalito at abala, kapwa kapag nagtatrabaho sa database at sa kawalan nito.
Sa ibaba ay susuriin natin nang detalyado ang parehong mga kasong ito.

Ang mga direktiba ng php.ini, na kung saan ay tinatawag na "magic quotes", ay responsable para sa awtomatikong pagdaragdag ng mga slash:
magic_quotes_gpc at magic_quotes_runtime Kung ang una ay pinagana, ang PHP ay awtomatikong nagdaragdag ng mga slash sa data na nagmumula sa user - mula sa POST, GET na mga kahilingan at cookies (pati na rin sa login at password na natanggap sa pamamagitan ng HTTP Authorization).
Kung ang pangalawa, pagkatapos ay idinagdag ang mga slash sa data na natanggap sa panahon ng pagpapatupad ng script - halimbawa, mula sa isang file o database.

Kung nagtatrabaho ka nang walang database, o nagtatrabaho sa database nang tama (na tatalakayin sa ibaba), ang mga dagdag na slash ay nakakaabala lamang sa iyo, at kailangan mong alisin ang mga ito. Ang pinakamadali at pinakatamang paraan ay ang hindi paganahin ang awtomatikong pagdaragdag sa mga setting ng PHP.
Magagawa ito alinman sa pamamagitan ng pagwawasto sa kaukulang mga direktiba sa php.ini, kung mayroon kang access dito, o sa pamamagitan ng paglikha ng .htaccess file sa huling direktoryo ng site at pagdaragdag ng mga linya dito
php_flag magic_quotes_gpc 0
php_flag magic_quotes_runtime 0
Kung hindi mo ito ma-disable sa ganitong paraan, kailangan mong magsulat ng code na may iba't ibang antas ng pagiging kumplikado upang i-clear ang papasok na data mula sa mga slash. (Gayunpaman, kung gusto mong magsulat ng isang portable na application na hindi nakadepende sa mga setting ng PHP, kailangan mo pa ring isulat ito. At isama ito bilang isang hiwalay na bloke sa simula ng iyong mga script).

Ang pinakamadaling paraan upang maunawaan ang data na nakuha sa panahon ng operasyon ay ang pagsulat sa simula ng script:
set_magic_quotes_runtime(0);

  • Para sa data na natanggap mula sa gumagamit, ang lahat ay mas kumplikado. Para sa code na ito kailangan namin ng dalawang function:
  • Maaari mong suriin kung naidagdag ito ng PHP gamit ang get_magic_quotes_gpc function.
    Ang stripslashes function ay nag-aalis ng mga slash.
    Alinsunod dito, kailangan mong suriin gamit ang una, at kung naidagdag ang PHP, pagkatapos ay dumaan sa lahat ng mga papasok na variable at i-clear ang mga ito gamit ang pangalawa.
    Kung nagtatrabaho ka nang tama, na may register_globals = off , sapat na upang maglapat ng mga stripslashes sa lahat ng array na naglalaman ng data na nagmumula sa browser.
    halimbawa, maaari mong isama ang sumusunod na code sa lahat ng script ng site:
    function strips (& $el ) (
    kung (is_array($el))
    foreach($el bilang $k => $v )
    strips($el[$k]);
    }
    iba pa $el = stripslashes ($el );
    kung (get_magic_quotes_gpc()) (
    strips($_POST);
    strips($_COOKIE);
    strips($_REQUEST);
    if (isset($_SERVER [ "PHP_AUTH_USER" ])) strips ($_SERVER [ "PHP_AUTH_USER" ]);
    if (isset($_SERVER [ "PHP_AUTH_PW" ])) strips ($_SERVER [ "PHP_AUTH_PW" ]);
    }
    Sa kaso ng hindi tamang mga setting ng register_globals, magiging mahirap na makahanap ng isang katanggap-tanggap na solusyon, kaya ito ay mas mahusay - ulitin ko - upang agad na gumana sa tamang mga setting.

    Mga Tala

    • Kabilang sa mga dahilan kung bakit hindi ka dapat umasa sa "magic quotes" ay isa pa. Napaka hindi malamang, ngunit gayon pa man. Ang "magic quotes" ay talagang tumutukoy hindi sa dalawang direktiba, ngunit tatlo. Ang pangatlo ay magic_quotes_sybase. Hindi lamang ito nagdaragdag ng quote sa halip na isang slash, ngunit kinakansela rin nito ang epekto ng magic_quotes_gpc. Kung sa pamamagitan ng ilang himala ang parehong mga direktiba na ito ay may katayuang "naka-on", kung gayon ang huli hindi gagana! Iyon ay, sa pamamagitan ng pag-asa sa "magic quotes", sa kasong ito ay makukuha natin ang lahat ng kasiyahan ng mga query na hindi wastong binubuo. Sa pangkalahatan, puro theoretically, dapat nating isaalang-alang ang pagkakaroon ng direktiba na ito, dahil nagpapakita rin ito ng isang sorpresa gaya ng... pagbabago ng pag-uugali ng mga addslashes at stripslashes function! Kung magic_quotes_sybase = on , ang mga function na ito ay magsisimulang magdagdag at mag-alis ng isang quote sa halip na isang slash, ayon sa pagkakabanggit.
    • Ang lahat ng mga halimbawang ibinigay ay nag-aalala lamang sa database ng MySQL. Maaaring mag-iba ang mga partikular na panuntunan para sa pagbuo ng mga query para sa iba pang mga DBMS, ngunit ang pangkalahatang prinsipyo ay nananatiling pareho:
      • kung ang isang API para sa pagtatrabaho sa isang database o isang third-party na library ay nagbibigay mga espesyal na function para sa pagbuo ng mga query, at may posibilidad na gamitin ang mga ito, pagkatapos ay kailangan mo munang gamitin ang mga ito.
      • Kung walang ganoong mga function, dapat kang tumingin sa dokumentasyon para sa mga function para sa pagtakas ng mga espesyal na character para sa DBMS na ito.
    Tandaan: mga form
    Kapag nagpapakita ng halaga sa mga input tag ng mga form, hindi nakakatulong ang mga slash.
    Upang ipakita ang buong teksto sa ganoong field, ang halaga ay dapat na nakapaloob sa mga panipi, at sa output data gamitin ang htmlspecialchars() function
    Halimbawa:

    Dapat ding tandaan (bagaman ito ay walang kinalaman sa mga quote at slash) na ang htmlspecialchars function ay dapat ilapat kapag nag-output sa browser sa pangkalahatan sa lahat ng data na natanggap mula sa isang hindi na-verify na user. Bakit ito dapat gawin, maaari mong basahin sa Google sa kahilingan ng kung ano ang isang kahinaan ng XSS
    sa pamamagitan ng phpfaq.ru

    • Dahil sa likas na katangian ng aking trabaho, kailangan kong magsagawa ng mga pag-audit sa seguridad ng source code ng mga web application.
    Maraming web application at maraming code...

    Hindi lihim na ang mga kahinaan ng SQL injection ay ang pinakakaraniwan sa lahat ng mga kahinaan sa web application sa panig ng server. May mga platform at frameworks kung saan halos hindi kasama ang mga ganoong bagay, halimbawa ORM at iba pa, ngunit patuloy na sinasabi sa amin ng mga istatistika ang tungkol sa ganap na pangingibabaw ng mga web application na may simpleng pinagsama-samang mga query ng SQL sa Internet sa pangkalahatan ay naaangkop Hindi ito maaari Halimbawa, kapag hindi lamang ang mga parameter ng expression, kundi pati na rin ang lohika ng query mismo sa antas ng operator ay dapat nakadepende sa data ng user.

    Kaya simulan na natin.

    Walang kwentang karakter na tumatakas
    Natagpuan sa 83% ng mga web application ng PHP na mahina sa mga SQL injection
    Gamit ang escape function para sa mga character tulad ng
    mysql_escape_string
    mysql_real_escape_string
    magdagdag ng mga pilikmata
    walang panipi. Kadalasan ito ay nagpapakita ng sarili sa mga numeric na parameter (lahat ng uri ng *_id).
    Halimbawa
    $sql = "PUMILI NG user MULA sa listahan ng mga user WHERE userid=".mysql_real_escape_string($_GET["uid"]);

    Lumilitaw na ito ay ligtas na code, ngunit sa ibabaw lamang. Ang pinakakaraniwang pattern ng SQL injection sa PHP sa aking pagsasanay ay pumasok dito. Upang atakehin ang kahinaang ito, kailangan lang ng isang umaatake na iwasan ang paggamit ng " " \x00 \r \n \x1a character sa attack vector.
    Halimbawa:
    /index.php?uid=-777 UNION SELECT password MULA sa userlist

    Maghanap sa code
    Kumplikado ng semantika ng wika. Para sa isang simpleng paghahanap maaari mong gamitin ang egrep:
    egrep -Rin "(piliin | i-update | ipasok | tanggalin | palitan).*(mula sa | itakda | sa).*(mysql_escape_string|mysql_real_escape_string|addslashes)" . | grep -v "[\""]["\"]"

    Ang lohika ng expression ng paghahanap ay ang mga sumusunod: hanapin ang lahat ng mga linya kung saan walang pagkakasunud-sunod ng mga quote na character ("", "", "", "") sa kaliwa ng mga function ng pag-filter. Ang pamamaraan, siyempre, ay malayo sa 100%, ngunit imposibleng mangailangan ng isang regular na expression upang maisagawa ang semantic analysis.
    Upang gawing mas madali ang pagpapakita ng impormasyon, maaari mong i-highlight ang function sa kulay sa console:
    egrep -Rin "(piliin | i-update | ipasok | tanggalin | palitan).*(mula sa | itakda | sa).*(mysql_escape_string|mysql_real_escape_string|addslashes)" . | grep -v "[\""]["\"]" | egrep --color "(mysql_escape_string|mysql_real_escape_string|addslashes)"

    Upang maprotektahan laban sa wildcard na kahinaan na ito, pinakamahusay na gumamit ng uri ng pag-cast.
    Palagi itong gumagana nang mas mabilis at mas maaasahan kaysa sa lahat ng uri ng pag-filter at screening.
    Para sa halimbawa sa itaas, ang patch ay maaaring ganito:
    $sql = "PUMILI NG user MULA sa listahan ng mga user WHERE userid=".intval($_GET["uid"]);

    Ito ang nagtatapos sa maikling sanaysay. Hinihimok ko ang lahat ng mga web developer na subukang suriin ang kanilang mga mapagkukunan para sa mga naturang disenyo. Mas mabuti pa, palawakin ang ibinigay na script sa paghahanap para sa mga tao.

    (PHP 4 >= 4.3.0, PHP 5)

    mysql_real_escape_string — Tinatakasan ang mga espesyal na character sa isang string para gamitin sa isang SQL statement

    Paglalarawan

    mysql_real_escape_string (string $unescaped_string [, mapagkukunan $link_identifier = NULL]): string

    Tinatakas ang mga espesyal na character sa unescaped_string , isinasaalang-alang ang kasalukuyang set ng character ng koneksyon upang ligtas itong ilagay sa isang mysql_query(). Kung ang binary data ay ilalagay, ang function na ito ay dapat gamitin.

    mysql_real_escape_string() tinatawag ang function ng library ng MySQL na mysql_real_escape_string, na naglalagay ng mga backslashes sa mga sumusunod na character: \x00, \n, \r, \ , " , " at \x1a.

    Ang function na ito ay dapat palaging (na may ilang mga pagbubukod) upang gawing ligtas ang data bago magpadala ng query sa MySQL.

    Pag-iingat

    Seguridad: ang default na set ng character

    Ang set ng character ay dapat itakda alinman sa antas ng server, o sa function ng API mysql_set_charset() para maapektuhan mysql_real_escape_string() . Tingnan ang seksyon ng mga konsepto sa set ng character para sa higit pang impormasyon.

    Mga Parameter

    unescaped_string

    Ang string na dapat takasan.

    Link_identifier

    Ang koneksyon sa MySQL. Kung hindi tinukoy ang link identifier, ang huling link na binuksan ni mysql_connect() ay ipinapalagay. Kung walang nakitang ganoong link, susubukan nitong lumikha ng isa na parang mysql_connect() ay tinawag na walang mga argumento. Kung walang nakitang koneksyon o itinatag, an E_BABALA nabuo ang error sa antas.

    Ibalik ang mga Halaga

    Ibinabalik ang nakatakas na string, o MALI sa pagkakamali.

    Mga Error/Exception

    Ang pagsasagawa ng function na ito nang walang koneksyon sa MySQL ay maglalabas din E_BABALA antas ng mga error sa PHP. Isagawa lamang ang function na ito na may valid na koneksyon sa MySQL.

    Mga halimbawa

    Halimbawa #1 Simple mysql_real_escape_string() halimbawa

    //Kumonekta
    $link = mysql_connect("mysql_host" , "mysql_user" , "mysql_password")
    O mamatay(mysql_error());

    //Tanong
    $query = sprintf ( "PUMILI * MULA SA mga user WHERE user="%s" AT password="%s"",
    mysql_real_escape_string($user),
    mysql_real_escape_string($password));
    ?>

    Halimbawa #2 mysql_real_escape_string() nangangailangan ng halimbawa ng koneksyon

    Ipinapakita ng halimbawang ito kung ano ang mangyayari kung walang koneksyon sa MySQL kapag tinatawagan ang function na ito.

    Ang halimbawa sa itaas ay maglalabas ng katulad ng:

    Babala: mysql_real_escape_string(): Walang ganoong file o direktoryo sa /this/test/script.php sa linya 5 Babala: mysql_real_escape_string(): Hindi maitatag ang link sa server sa /this/test/script.php sa linya 5 bool(false) string(41) "PUMILI * MULA sa mga aktor WHERE last_name = """

    Halimbawa #3 Isang halimbawa ng SQL Injection Attack

    // Hindi namin sinuri ang $_POST["password"], maaaring kahit anong gusto ng user Halimbawa:
    $_POST [ "username" ] = "aidan" ;
    $_POST [ "password" ] = "" O ""="" ;

    // Query database upang suriin kung mayroong anumang tumutugmang mga gumagamit
    $query = ($_POST [ "username" ]) " AT password=" ( $_POST [ "password" ]) "" ;
    mysql_query($query);

    // Nangangahulugan ito na ang query na ipinadala sa MySQL ay:
    echo $query ;
    ?>

    Ang query na ipinadala sa MySQL:

    Ito ay magpapahintulot sa sinuman na mag-log in nang walang wastong password.

    Mga Tala

    Ang isang koneksyon sa MySQL ay kinakailangan bago gamitin mysql_real_escape_string() kung hindi man ay isang error ng antas E_BABALA ay nabuo, at MALI ay ibinalik. Kung hindi tinukoy ang link_identifier, gagamitin ang huling koneksyon sa MySQL.

    Tandaan: mysql_real_escape_string() hindi nakatakas % at _ . Ito ay mga wildcard sa MySQL kung isasama sa LIKE, PAGBIGAY, o Bawiin.

    8 taon na ang nakalipas

    Isang maliit na function na ginagaya ang orihinal na mysql_real_escape_string ngunit hindi nangangailangan ng isang aktibong mysql na koneksyon ay maaaring ipatupad bilang isang static na function sa isang database class.

    function mysql_escape_mimic ($inp) (
    if(is_array($inp))
    return array_map (__METHOD__ , $inp );

    If(!empty($inp ) && is_string ($inp )) (
    return str_replace (array("\\" , "\0" , "\n" , "\r" , """ , """ , "\x1a" ), array("\\\\" , "\ \0" , "\\n" , "\\r" , "\\"" , "\\"" , "\\Z" ), $inp );
    }

    Ibalik ang $inp ;
    }
    ?>

    13 taon na ang nakalipas

    Tandaan na ang mysql_real_escape_string ay hindi naglalagay ng mga backslashes sa \x00, \n, \r, at \x1a gaya ng nabanggit sa dokumentasyon, ngunit talagang pinapalitan ang character ng isang MySQL na katanggap-tanggap na representasyon para sa mga query (hal. \n ay pinalitan ng "\ n" litteral). (\, ", at " ay nakatakas bilang dokumentado) Hindi nito binabago kung paano mo dapat gamitin ang function na ito, ngunit sa tingin ko magandang malaman ito.

    6 na taon na ang nakalipas

    Walang talakayan tungkol sa pagtakas ay kumpleto nang hindi sinasabi sa lahat na hindi ka dapat gumamit ng panlabas na input upang makabuo ng na-interpret na code. Napupunta ito para sa mga pahayag ng SQL, o anumang bagay na tatawagin mo sa anumang uri ng function na "eval".

    Kaya, sa halip na gamitin ang napakasira na function na ito, gumamit na lang ng mga parametric na inihandang pahayag.

    Sa totoo lang, ang paggamit ng data na ibinigay ng user upang bumuo ng mga SQL statement ay dapat ituring na propesyonal na kapabayaan at dapat kang panagutin ng iyong tagapag-empleyo o kliyente para sa hindi paggamit ng mga pahayag na inihandang parametric.

    Ano ang ibig sabihin nito?

    Nangangahulugan ito sa halip na bumuo ng isang SQL statement tulad nito:

    "INSERT IN TO X (A) VALUES(".$_POST["a"].)"

    Dapat mong gamitin ang mysqli's prepare() function () upang magsagawa ng isang pahayag na ganito ang hitsura:

    "INSERT IN TO X (A) VALUES(?)"

    NB: Hindi ito nangangahulugan na hindi ka dapat kailanman bumuo ng mga dynamic na SQL statement. Ang ibig sabihin nito ay hindi ka dapat gumamit ng data na ibinigay ng user upang bumuo ng mga statement na iyon. Ang anumang data na ibinigay ng user ay dapat ipasa bilang mga parameter sa statement pagkatapos nito pinaghandaan.

    Kaya, halimbawa, kung bubuo ka ng isang maliit na balangkas at nais mong gumawa ng isang insert sa isang talahanayan batay sa kahilingang URI, ito ay sa iyong pinakamahusay na interes na huwag kunin ang halaga ng $_SERVER["REQUEST_URI"] (o anumang bahagi nito) at direktang pagsamahin iyon sa iyong query, sa halip, dapat mong i-parse ang bahagi ng $_SERVER["REQUEST_URI"] na halaga na gusto mo, at i-map iyon sa pamamagitan ng ilang uri ng function o associative array sa isang hindi gumagamit. ibinigay na halaga. Kung ang pagmamapa ay walang halaga, alam mong may mali sa ibinigay na data ng user.

    Ang hindi pagsunod dito ay naging sanhi ng maraming problema sa SQL-injection sa balangkas ng Ruby On Rails, kahit na gumagamit ito ng mga pahayag na inihandang parametric. Ito ay kung paano na-hack ang GitHub sa isang punto. Kaya, walang wika ang immune sa problemang ito. Iyon ang dahilan kung bakit ito ay isang pangkalahatang pinakamahusay na kasanayan at hindi isang bagay na partikular sa PHP at kung bakit dapat mo itong TALAGANG gamitin.

    Gayundin, dapat ka pa ring gumawa ng ilang uri ng pagpapatunay ng data na ibinigay ng mga user, kahit na gumagamit ng mga pahayag na inihandang parametric. Ito ay dahil ang data na ibinigay ng user ay kadalasang magiging bahagi ng ilang nabuong HTML, at gusto mong tiyakin na ang data na ibinigay ng user ay hindi magdudulot ng mga problema sa seguridad sa browser.

    9 taon na ang nakalipas

    Mayroong isang kawili-wiling quirk sa halimbawa #2 tungkol sa SQL injection: AT mas inuuna ang OR, kaya ang na-inject na query ay talagang gumagana bilang WHERE (user="aidan" AND password="") O ""="", kaya sa halip ng pagbabalik ng isang database record na naaayon sa isang arbitrary na username (sa kasong ito "aidan"), ito ay aktwal na ibabalik ang LAHAT ng mga rekord ng database Sa walang partikular na pagkakasunud-sunod Kaya ang isang umaatake ay maaaring makapag-log in bilang anumang account, ngunit hindi kinakailangan sa alinman . kontrol sa kung aling account ito.

    Siyempre, maaaring baguhin ng isang potensyal na atake ang kanilang mga parameter upang i-target ang mga partikular na user ng interes:

    //Hal. mga halaga ng umaatake
    $_POST [ "username" ] = "" ;
    $_POST["password"] = "" O user = "administrator" AT "" = "";

    // Maling nabuong query
    $query = "PUMILI * MULA sa mga user WHERE user="$_POST [ username ] " AT password=" $_POST [ password ] "" ;

    echo $query ;

    // Ang query na ipinadala sa MySQL ay mababasa:
    // SELECT * FROM users WHERE user="" AND password="" OR user="administrator" AT ""="";
    // na magpapahintulot sa sinuman na magkaroon ng access sa account na pinangalanang "administrator"

    ?>

    1 taon na ang nakalipas

    @feedr
    Inilarawan ko ang kanyang tala bilang sumusunod:
    $string = "asda\0sd\x1aas\\\\\\\\dasd\"asdasd\na\"\"sdasdad";
    $array1 = array("\\\\\\\", "\0", "\n", "\r", """, """, "\x1a");
    $array2 = array("\\\\\\\\\\\\\\\\\\", "\\\0", "\\\n", "\\\r", "\\\ " ", "\\\"", "\\\Z");
    echo($string);
    echo(PHP_EOL);
    para sa ($i=0; $i kung ($i==0)
    $p = "/(?iba pa
    $p = "/(?echo($i);
    echo($p);
    echo($array2[$i]);
    $string = preg_replace($p, $array2[$i], $string);
    echo("\t");
    echo($string);
    echo(PHP_EOL);
    }
    echo(PHP_EOL);
    echo($string);

    2 taon na ang nakalipas

    Upang Sipiin si Sam sa Numb Safari

    [ "Walang talakayan tungkol sa pagtakas ay kumpleto nang hindi sinasabi sa lahat na hindi ka dapat gumamit ng panlabas na input upang makabuo ng interpreted code. Ito ay para sa mga SQL statement, o anumang bagay na tatawagin mo sa anumang uri ng "eval" na function.

    Kaya, sa halip na gamitin ang napakasira na function na ito, gumamit na lang ng mga parametric na inihandang pahayag.

    Sa totoo lang, ang paggamit ng data na ibinigay ng user upang bumuo ng mga SQL statement ay dapat ituring na propesyonal na kapabayaan at dapat kang panagutin ng iyong tagapag-empleyo o kliyente para sa hindi paggamit ng mga pahayag na inihandang parametric." ]

    Tama si Sam.......

    Gayunpaman, sa palagay ko ay hindi makatwirang ihinto ang lahat ng paglilinis at ipasa lamang ang gawain sa mga inihandang pahayag ng parametric.

    Ang isang partikular na developer na nagtatrabaho sa isang partikular na sitwasyon ay palaging makakaalam ng higit pa tungkol sa wastong input (partikular sa kontekstong iyon).

    Kung hihilingin mo sa isang user na ipasa ang isang halaga na naibigay mo na sa kanila at alam mo na ang lahat ng naturang mga halaga ay nagsisimula sa AB****** at ang string ay dapat na may haba na 7 o 11 ngunit hindi kailanman sa anumang iba pang haba kung gayon mayroon kang ang batayan ng isang mahusay na pre-sanitiser - maaaring magpahiwatig ng legacy data ang iba't ibang pinapayagang haba ng string.

    Hindi ko kailanman gugustuhin na basta na lang ipasa ang mga basura na maaaring ipinasa ng isang malisyosong user sa pamamagitan ng isang form sa mga inihandang pahayag ng parametric, gusto kong palaging gawin muna ang sarili kong mga pagsusuri sa katinuan at sa ilang mga kaso ay maaaring magkamali ito sa panig ng pag-iingat at piliin lamang na ganap na i-abort ang Database op.

    Sa ganoong paraan ang aking DB ay hindi barado sa mga hindi ligtas na pahayag na ginawang ligtas - hindi lang ito barado na mas mabuti.

    Seguridad sa mga layer - sanitization at validation ay dapat pa ring isaalang-alang sa bawat sitwasyon BAGO gumamit ng mga inihandang pahayag.

    Bilang karagdagan sa abot ng aking nabasa sa opisyal na doc
    ==============================================

    "Pagtakas at SQL injection

    Ang mga nakatali na variable ay ipinapadala sa server nang hiwalay sa query at sa gayon ay hindi makagambala dito. Ginagamit ng server ang mga halagang ito nang direkta sa punto ng pagpapatupad, pagkatapos ma-parse ang template ng pahayag. Ang mga nakatali na parameter ay hindi kailangang i-escape dahil hindi sila direktang pinapalitan sa query string"

    Iyon ay nagmumungkahi sa akin na ang panganib ay maiiwasan sa mga panloob sa pamamagitan ng alternatibong paghawak hindi sa pamamagitan ng pagpapawalang-bisa.

    Nangangahulugan ito na ang isang malaking proyekto na may hindi kumpletong conversion sa mga inihandang pahayag, legacy code sa iba't ibang bahagi ng isang organisasyon o mga server na nakikipag-usap sa isa't isa ay maaaring magpasa ng masamang balita mula sa isang immune na lokasyon o sitwasyon sa isang hindi immune.

    Hangga't ang sanitization ay mahusay na isinasagawa nang hindi nagkakaroon ng karagdagang mga panganib, personal kong mananatili sa ilang mga layer ng sanitization at pagkatapos ay tatawagan ang mga inihandang pahayag.

    So basically I dug deep into the areas of MySQL and PHP... specifically the security measures I should take when dealing with the database and form inputs. Sa ngayon ay natagpuan ko ang mga sumusunod na lubos na inirerekomenda:

    1. Mga Inihandang Pahayag
    2. Gamit ang _real_escape_string()
    3. HINDI gumagamit ng mga magic quotes dahil nalilito nito ang mga database at nagtatapos sa pagbibigay sa iyo ng mga bagay tulad ng "Hindi mo ito tinawag...".

    Mahusay ang lahat ng ito at binabantayan ko ito. Gayunpaman, iniisip ko kung ang mga character tulad ng dollar sign [$], percent sign [%] at marahil ang iba ay dapat na makatakas. Maaari bang bigyang-kahulugan ng query ang dollar sign bilang isang variable ng PHP? Paano naman ang LIKE syntax na narinig ko na gumagamit ng % na simbolo o kahit isang wildcard? Ang mga inihandang pahayag ay dapat teknikal na pangasiwaan ang lahat ng ito, ngunit gusto ko lang na maging ligtas at tiyaking naalis ko ang lahat ng bagay nang maayos. Sa mga kaso kung saan nakalimutan kong gumamit ng mga inihandang pahayag o pinabayaan lamang ang mga ito, umaasa ako na ang pangalawang linya ng depensang ito ay makapagsasabi sa akin na maaari kong maalis ang pagkahilo.

    Narito ang kasalukuyang ginagamit ko para sa pagtakas:

    Function escape($koneksyon, $data)( $new_data = trim($data); $new_data = i_real_escape_string($koneksyon, $new_data); $new_data = addcslashes($new_data, "%_$"); $new_data = htmlspecialchars ($new_data, ENT_NOQUOTES);

    So tama ba ito? May ginagawa ba akong napakalaking mali? Pakitandaan na kapag ibinabalik ang data ng database ay kailangan kong tanggalin ang mga backslashes bago ang $,% at _ na mga character.

    May ginagawa ba akong napakalaking mali?

    Una tungkol sa iyong pananaliksik.

    Inihanda na mga pahayag - ang nag-iisa kahanga-hangang bagay na iyong natagpuan.

    Bagaman ang paggamit ng mysqli_real_escape_string (ipagpalagay na gumagamit ka ng mga inihandang pahayag) ay magiging walang silbi at nakakapinsala(paglikha ng resulta na ikaw mismo ang nagsabi: "Tumawag ka ay hindi...").

    At ang Magic Quotes ay matagal nang tinanggal mula sa wika - kaya wala talagang halaga.

    Kaya kahit na ang karamihan sa iyong mga unang lugar ay malinaw na mali.

    Ngayon sa iyong tanong.

    Maaari bang bigyang-kahulugan ng query ang dollar sign bilang variable ng PHP?

    Paano naman ang LIKE syntax na narinig ko na gumagamit ng % na simbolo o kahit isang wildcard?

    Oo, tama ang narinig mo. Ang eksaktong layunin ng LIKE operator ay magsagawa ng pattern search. Ang pag-disable sa mga character na ito sa LIKE ay hindi magkakaroon ng kaunting kahulugan.

    Sa tuwing gagamitin mo ang operator ng LIKE, dapat kang magpasya kung aling karakter ang gagamitin at alin ang hindi papayagan. Hindi ka maaaring gumamit ng isang beses na solusyon. Hindi banggitin na sa lahat ng iba pang mga pakikipag-ugnayan sa mysql ang % sign ay walang espesyal na kahulugan.

    Ang mga inihandang pahayag ay dapat teknikal na pangalagaan ang lahat ng ito

    Ang mga inihandang pahayag ay walang kinalaman sa $ o % na mga palatandaan. Ang mga inihandang pahayag ay tumutukoy sa SQL injection, ngunit walang karakter ang maaaring magdulot nito (hindi mo matatawag ang "injection" bilang isang operator na TULAD na ginamit nang maayos, hindi ba?).

    Sa wakas, sa pinakamasamang bahagi.

    Kung sakaling makalimutan mong gumamit ng mga inihandang pahayag o basta basta na lamang pinabayaan na sundin ang mga ito,

    walang magliligtas sa iyo.

    At ang hindi bababa sa tulong ay mula sa function na iyong binuo.

    ibuod.

    1. Alisin ang tampok na ito.
    2. Gamitin mga tagapuno * upang kumatawan sa bawat indibidwal na variable sa query.
    3. Itakas ang % at _ na mga character sa input lamang kung gagamitin ang mga ito sa operator ng LIKE at hindi mo nais na bigyang-kahulugan ang mga ito.
    4. Gumamit ng htmlspecialchars() para sa output, hindi mysql input.

    *basahin ang mga inihandang pahayag kung ang terminong ito ay hindi pamilyar sa iyo.

    Hindi mo kailangang iwasan ang dollar sign. Hindi partikular na tinitingnan ng MySQL ang karakter na ito, at kinikilala lamang ito ng PHP sa source code, hindi sa mga halaga ng string (maliban kung tatawagin mo ang eval sa string, ngunit iyon ay isang buong iba pang mga uod ng bulate).

    Kakailanganin mo lamang na i-escape ang % at _ kung gumagamit ka ng input ng user bilang LIKE argument at hindi mo gustong gumamit ang user ng mga wildcard. Maaaring mangyari ito kung pinoproseso mo ang isang form sa paghahanap. Hindi mo kailangang gamitin ito kapag nag-iimbak sa isang database.

    Hindi mo kailangang gumamit ng htmlspecialchars kapag ina-access ang database. Dapat lang itong gamitin kapag nagpapakita ng data sa user sa isang HTML page upang maiwasan ang XSS injection.

    Depende sa kung anong data at para saan ito ginagamit.

    Kung nalaman mong masyadong malaki at kumplikado ang default na out-of-the-box na mga pahayag ng PHP, iminumungkahi kong tingnan ang ilan sa mga klase na available sa github para mabigyan ka ng ideya ng mga pinasimpleng query.

    Isang halimbawa ng paglalagay ng mga query sa klase na ito

    $data = Array ("login" => "admin", "active" => true, "firstName" => "John", "lastName" => "Doe", "password" => $db->func( "SHA1(?)",Array ("secretpassword+salt")), // password = SHA1("secretpassword+salt") "createdAt" => $db->now(), // createdAt = NOW() " mag-e-expire" => $db->now("+1Y") // mag-e-expire = NOW() + interval 1 year // Mga sinusuportahang interval [s]econd, [m]inute, [h]hour, [d]day, [M]buwan, [Y]tainga); $id = $db->insert("mga gumagamit", $data); if ($id) echo "nalikha ang user. Id=" . $id; else echo "nabigo ang pagpasok: " . $db->getLastError();



    MGA KAUGNAY NA ARTIKULO