Theory
Portal છેવટે સાંભળે છે
અત્યાર સુધી બધું PHP નું પોતાની સાથે બોલવા જેવું હતું. હવે event portal એ સાંભળવું પડશે: વિદ્યાર્થી form માં પોતાનું નામ અને password લખીને submit કરે છે. એ લખાયેલો data તમારા PHP સુધી કઈ રીતે પહોંચે છે?
જવાબ છે superglobals $_POST અને $_GET. અને જે ક્ષણે ખરા વપરાશકારો તમને data મોકલી શકે, એ ક્ષણે કડક નિયમ લાગુ પડે છે: વપરાશકારે ભરેલા input પર કદી ભરોસો ન કરો. બેદરકાર PHP અસલામત PHP બની જાય એ જગ્યા બરાબર login form જ છે. આ પાઠ forms ને code સાથે જોડે છે, logic ને FUNCTIONS માં બાંધે છે, અને દરેક input ની validation તથા sanitization થી ચોકી કરે છે.
Theory
Functions અને scope
Function ફરી વાપરી શકાય એવા logic ને બાંધે છે:
function lineTotal($price, $qty) { return $price * $qty; }
Parameters data ને અંદર લાવે છે; return કિંમત પાછી મોકલે છે; parameters ને મૂળભૂત કિંમત પણ આપી શકાય ($qty = 1).
Scope એ પરીક્ષામાં પુછાય એવી ઝીણી વાત છે: function ની અંદરનાં variables મૂળભૂત રીતે સ્થાનિક હોય છે અને બહાર જાહેર થયેલાં variables એમને દેખાતાં નથી. Function ને બહારના $seats ની આપોઆપ ખબર પડતી નથી. બહારના (global) variable સુધી પહોંચવા તમારે global શબ્દ કે $GLOBALS array વાપરવું પડે, પણ વધુ સ્વચ્છ રીત એ છે કે data ને PARAMETER તરીકે અંદર મોકલો. સ્થાનિક scope એ ખામી નહીં પણ ખૂબી છે: એ functions ને સ્વયંસંપૂર્ણ અને ધારી શકાય એવાં રાખે છે.
Theory
$_GET અને $_POST: form ના બે દરવાજા
HTML form નું method નક્કી કરે છે કે એનો data કઈ રીતે મુસાફરી કરે:
- GET: data URL ના query string માં જાય છે (
portal.php?event=garba), દેખાય છે અને bookmark થઈ શકે છે: બિનસંવેદનશીલ વાચન માટે, અને એ$_GETમાં આવે છે - POST: data request ના શરીરમાં જાય છે, URL માં નહીં: submissions અને password જેવા સંવેદનશીલ data માટે, અને એ
$_POSTમાં આવે છે
તમે ખાનાને એના name થી વાંચો છો: $_POST['username']. BCA405-01 ના AJAX માં તમે મળ્યા હતા એ જ GET સામે POST ની પસંદગી છે: વાચન અને bookmark થઈ શકે એવો data GET વાપરે છે; ખાનગી કે સ્થિતિ બદલતું કંઈ પણ (login, registration) POST વાપરે છે, કારણ કે password URL માં પડ્યો રહે એવું તમે કદી ન ઇચ્છો.
Practical
login.php: form, POST, validate, sanitize
<!-- The form: method POST sends data in the body -->
<form method="POST" action="login.php">
<input type="text" name="username">
<input type="password" name="password">
<button type="submit">Log in</button>
</form>
<?php
if ($_SERVER["REQUEST_METHOD"] === "POST") {
// SANITIZE: clean the input
$user = trim($_POST["username"] ?? "");
$user = htmlspecialchars($user); // neutralise HTML/scripts
// VALIDATE: check it is acceptable
if ($user === "") {
echo "Username is required";
} else {
echo "Welcome, " . $user;
}
}
?>
Theory
Validation અને sanitization: input પર કદી ભરોસો નહીં
$_GET કે $_POST માંથી આવતી દરેક કિંમત અજાણી વ્યક્તિનો data છે, અને એ ખાલી, ખોટા ઘાટની કે દુષ્ટ ઇરાદાવાળી હોઈ શકે. એટલે હંમેશા બે ચોકીદાર:
- Validation: શું એ સ્વીકારવા જેવી છે? ફરજિયાત ખાનું ભરાયું છે? એ ખરું email છે (
filter_var($e, FILTER_VALIDATE_EMAIL))? સંખ્યા વ્યાપની અંદર છે? - Sanitization: એને સાફ કરો.
trim()આજુબાજુની ખાલી જગ્યા કાઢે છે;htmlspecialchars()HTML ને નિષ્ક્રિય કરે છે જેથી કોઈ<script>ઘુસાડી ન શકે (XSS હુમલો); sanitize filter સાથેનુંfilter_varઅનિચ્છનીય અક્ષરો કાઢી નાખે છે.
નિયમ સંપૂર્ણ છે: જ્યાં સુધી ચકાસાય અને સફાઈ ન થાય ત્યાં સુધી વપરાશકારના દરેક input ને દુશ્મન ગણો. આ છોડી દેવાથી જ ખરી sites hack થાય છે, અને પરીક્ષકો પણ સલામતીનો આ મુદ્દો જ જોવા માગે છે.
Quiz
Portal ના login માં password માટે GET ને બદલે POST કેમ વાપરવું જ પડે?
- GET વધુ ઝડપી છે, એટલે POST ફક્ત ધીમાં forms માટે છે
- GET data ને દેખાતા URL માં મૂકે છે; password એ request ના શરીરમાં (POST માં) મુસાફરી કરવો જોઈએ, URL, ઇતિહાસ કે logs માં પડ્યો ન રહેવો જોઈએ
- POST GET કરતાં વધુ ખાનાં મોકલી શકે છે
- ખરેખર કોઈ ફરક નથી; passwords માટે બેમાંથી કોઈ પણ ચાલે
Show the answer
GET data ને દેખાતા URL માં મૂકે છે; password એ request ના શરીરમાં (POST માં) મુસાફરી કરવો જોઈએ, URL, ઇતિહાસ કે logs માં પડ્યો ન રહેવો જોઈએ
GET form નો data URL ના query string માં ગોઠવે છે, જ્યાં એ screen પર દેખાય છે, browser ના ઇતિહાસમાં સચવાય છે અને ઘણી વાર server ના logs માં પણ લખાય છે: password માટે એ સર્વનાશ છે. POST data ને request ના શરીરમાં મૂકે છે, URL ની બહાર, અને એટલે જ સંવેદનશીલ તથા સ્થિતિ બદલતાં submissions POST વાપરે છે. આ BCA405-01 ના GET સામે POST ના નિયમનું જ પ્રતિબિંબ છે. વિકલ્પ A ઝડપનો ઉપજાવેલો ફરક છે. વિકલ્પ C ખરી પણ ગૌણ વાત કહે છે (GET માં લંબાઈની મર્યાદા હોય છે), જે સલામતીનું કારણ નથી. વિકલ્પ D જોખમી રીતે ખોટો છે: ઓળખાણનાં પ્રમાણ GET થી કદી ન મોકલો. વાચન અને bookmarks માટે GET; submissions અને ગુપ્ત વસ્તુઓ માટે POST.
Think first
જે function ને seats દેખાયાં જ નહીં
એક વિદ્યાર્થી function showSeats() { echo $seats; } લખે છે, અને $seats = 350 એ function ની બહાર જાહેર થયેલું છે, છતાં કશું છપાતું નથી (ચેતવણી સાથે). શા માટે, અને સ્વચ્છ ઉપાય શું છે? વિચારીને પછી tap કરો.
Show the answer
કારણ છે PHP નું variable SCOPE: function ની અંદરનાં variables સ્થાનિક હોય છે, અને function એની બહાર જાહેર થયેલાં variables આપોઆપ જોઈ શકતું નથી, એટલે showSeats() ની અંદર $seats વ્યાખ્યાયિત જ નથી, જેથી null મળે છે અને ચેતવણી આવે છે. બે ઉપાય છે: ઝડપી પણ નાપસંદ કરાયેલો ઉપાય એટલે function ની અંદર global $seats; (કે $GLOBALS['seats']); સ્વચ્છ ઉપાય એટલે એને અંદર મોકલવો: function showSeats($seats) { echo $seats; } અને showSeats(350) બોલાવવું. Parameters મોકલવા વધુ સારા છે કારણ કે એથી function સ્વયંસંપૂર્ણ અને ધારી શકાય એવું રહે છે, જ્યારે globals પર આધાર રાખવાથી છુપાયેલી પરાધીનતા ઊભી થાય છે. સ્થાનિક scope તમારું જ રક્ષણ કરે છે: એ તમને function કયો data વાપરે છે તે સ્પષ્ટ કહેવા મજબૂર કરે છે.
Watch out
Function અને form ના ફાંદા
Globals દેખાશે એમ માની લેવું: function નાં variables સ્થાનિક હોય છે; data ને parameters તરીકે મોકલો.
કાચા input પર ભરોસો કરવો: $_GET અને $_POST ને વાપરતાં પહેલાં હંમેશા ચકાસો અને સાફ કરો.
GET થી password: કદી નહીં; ઓળખાણનાં પ્રમાણ અને સ્થિતિના કોઈ પણ ફેરફાર માટે POST વાપરો.
ખૂટતી ચાવી: submit ન થયેલા ખાના પર $_POST['x'] ચેતવણી આપે છે; સલામત મૂળભૂત કિંમત માટે $_POST['x'] ?? '' (null coalescing) વાપરો.
વપરાશકારનું input કાચું જ છાપવું: પહેલાં એના પર htmlspecialchars() કરો, નહીં તો XSS નું બાકોરું ખૂલી જાય છે.
Theory
Unit 1 પૂરું: portal જીવતું થયું
હવે તમારી પાસે ચાલતું Core PHP છે: ગોઠવણ, syntax, types, control flow, arrays, functions, અને સલામત રીતે પ્રક્રિયામાં લેવાયેલું ખરું form. Event portal ચકાસાયેલા વપરાશકારને આવકારી શકે છે. Unit 2 વધુ આગળ જાય છે: files અને uploads સંભાળવાં, JSON, cookies અને sessions (જેથી login pages વચ્ચે યાદ રહી શકે), email મોકલવું, અને exceptions સાથે PHP નાં પોતાનાં object-oriented લક્ષણો. Portal ને હવે યાદશક્તિ અને માળખું બંને મળવાનાં છે.
Summary
Key takeaways
- Functions logic ને બાંધે છે: function name($params){ return $x; }; parameters data અંદર લાવે છે, return કિંમત પાછી મોકલે છે.
- Scope: function ની અંદરનાં variables સ્થાનિક હોય છે; global વાપરવાને બદલે data ને parameters તરીકે મોકલો (એ જ પસંદ કરવા જેવું છે).
- Form નો data $_GET માં (URL નું query string, દેખાતું વાચન) કે $_POST માં (request નું શરીર, submissions અને ગુપ્ત વસ્તુઓ) આવે છે.
- ખાનાને એના name થી વાંચો: $_POST['username']; passwords અને સ્થિતિના ફેરફાર માટે POST વાપરો, GET કદી નહીં.
- Validation તપાસે છે કે input સ્વીકારવા જેવો છે (ફરજિયાત, ખરું email); sanitization એને સાફ કરે છે (trim, htmlspecialchars, filter_var).
- વપરાશકારના input પર કદી ભરોસો ન કરો: injection અને XSS અટકાવવા દરેક કિંમત ચકાસો અને સાફ કરો.
- યાદ રાખવાની કડી: મૂળભૂત રીતે સ્થાનિક scope, ગુપ્ત વસ્તુઓ માટે POST, અને અજાણી વ્યક્તિના input પર કદી ભરોસો નહીં.