അധികം താമസിയാതെ എന്റെ ഒരു സന്ദർശകൻ എന്നോട് ഒരു ലേഖനം എഴുതാൻ ആവശ്യപ്പെട്ടു സൈറ്റിലെ ഉപയോക്താക്കളെ എങ്ങനെ രജിസ്റ്റർ ചെയ്യുകയും അംഗീകരിക്കുകയും ചെയ്യാം. യഥാർത്ഥത്തിൽ, ഞാൻ അവന്റെ അഭ്യർത്ഥന നിറവേറ്റുകയാണ്, ഈ ലേഖനത്തിൽ ഇത് എങ്ങനെ ചെയ്യപ്പെടുന്നു എന്നതിനെക്കുറിച്ച് ഞാൻ സംസാരിക്കും.
നിരവധി മാർഗങ്ങളുണ്ട് ഉപയോക്തൃ രജിസ്ട്രേഷനും അംഗീകാരവും സൃഷ്ടിക്കുന്നു, എന്നാൽ ഈ ലേഖനത്തിൽ ഞാൻ എന്റെ പ്രിയപ്പെട്ട ഒന്ന് വിശകലനം ചെയ്യും - സെഷൻ അല്ലെങ്കിൽ കുക്കി മെക്കാനിസം വഴി.
ആദ്യം, നിങ്ങൾക്ക് വേണമെങ്കിൽ നിങ്ങളുടെ വെബ്സൈറ്റിൽ രജിസ്റ്റർ ചെയ്യുക, ഉപയോക്തൃ ഡാറ്റ എവിടെയാണ് സംഭരിക്കപ്പെടുന്നതെന്ന് നിങ്ങൾ മനസ്സിലാക്കേണ്ടതുണ്ട്. ഒരു സാധാരണ ടെക്സ്റ്റ് ഫയലിൽ സൂക്ഷിക്കാം XML ഫയൽ, അല്ലെങ്കിൽ ഡാറ്റാബേസിൽ. ആദ്യ രണ്ട് ഓപ്ഷനുകൾ വളരെ അപകടകരമാണ്, അതിനാൽ അവ ഉപയോഗിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നില്ല. ഇതാ മൂന്നാമത്തെ ഓപ്ഷൻ - ഒരു ഡാറ്റാബേസിൽ ഉപയോക്തൃ വിവരങ്ങൾ സംഭരിക്കുന്നു- ഏറ്റവും ജനപ്രിയമായത്, വിവരങ്ങൾ സംഭരിക്കുന്നതിനുള്ള ഈ രീതിയാണ് ഉപയോഗിക്കാൻ ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നത്.
സ്റ്റോറേജ് ലൊക്കേഷൻ ഞങ്ങൾ തീരുമാനിച്ചു. ഇനി നമുക്ക് നേരിട്ട് പോകാം അംഗീകാര അൽഗോരിതം:
- ഇതിനായി ഒരു രജിസ്ട്രേഷൻ ഫോം സൃഷ്ടിക്കുക HTML.
- ഹാൻഡ്ലർ സ്ക്രിപ്റ്റിലെ ഫോമിൽ നിന്ന് ഡാറ്റ സ്വീകരിക്കുക.
- ലഭിച്ച ഡാറ്റ പരിശോധിക്കുക, അത് തെറ്റാണെങ്കിൽ, രജിസ്ട്രേഷൻ ഫോമിലേക്ക് തിരിച്ചുവിടുക.
- ഡാറ്റ ശരിയാണെങ്കിൽ, അത് ഡാറ്റാബേസിലേക്ക് എഴുതുക.
അതാണ് മുഴുവൻ പ്രക്രിയയും സൈറ്റിലെ ഉപയോക്തൃ രജിസ്ട്രേഷൻ. അതായത്, രജിസ്ട്രേഷൻ സൈറ്റിലെ ഉപയോക്താവിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ സംരക്ഷിക്കുന്നു.
അടുത്ത പോയിന്റ് സൈറ്റിലെ ഉപയോക്തൃ അംഗീകാരംഎന്നിരുന്നാലും, അതിലേക്ക് പോകുന്നതിന് മുമ്പ്, രജിസ്ട്രേഷൻ ഫോമിലെ ഒരു പ്രധാന പോയിന്റിനെക്കുറിച്ച് ഞാൻ നിങ്ങളോട് പറയും - പാസ്വേഡ്. വ്യക്തമായ വാചകത്തിൽ പാസ്‌വേഡുകൾ സൂക്ഷിക്കരുതെന്ന് ഞാൻ ശക്തമായി ശുപാർശ ചെയ്യുന്നു (ഉദാഹരണത്തിന്, " 123456 "). കുറഞ്ഞത് ഫംഗ്ഷൻ ഉപയോഗിച്ച് അവ എൻക്രിപ്റ്റ് ചെയ്യുന്നത് ഉറപ്പാക്കുക md5(). കൂടാതെ എൻക്രിപ്റ്റ് ചെയ്ത പാസ്വേഡ് ഡാറ്റാബേസിൽ സൂക്ഷിക്കുക.
ഇപ്പോൾ അംഗീകാരം. നിങ്ങൾ ആദ്യം മനസ്സിലാക്കേണ്ടത് അംഗീകാര വിവരങ്ങൾ എവിടെയെങ്കിലും സൂക്ഷിക്കണം എന്നതാണ്. ഒരു സെഷനിൽ വിവരങ്ങൾ സംഭരിക്കുക എന്നതാണ് ഏറ്റവും ലളിതമായ ഓപ്ഷൻ (അല്ലെങ്കിൽ ഇൻ കുക്കി). ഇപ്പോൾ അൽഗോരിതം:
- ഒരു ഉപയോക്തൃ അംഗീകാര ഫോം സൃഷ്ടിക്കുക HTML, അവിടെ ഉപയോക്താവ് അവന്റെ പ്രവേശനവും പാസ്‌വേഡും നൽകേണ്ടതുണ്ട്.
- ഹാൻഡ്ലർ സ്ക്രിപ്റ്റിൽ, ഉപയോക്താവിൽ നിന്നുള്ള ഡാറ്റ സ്വീകരിക്കുക. നിങ്ങൾ ഞാൻ പറയുന്നത് ശ്രദ്ധിക്കുകയും എൻക്രിപ്റ്റ് ചെയ്ത പാസ്‌വേഡുകൾ ഒരു ഡാറ്റാബേസിൽ സൂക്ഷിക്കുകയും ചെയ്യുന്നുവെങ്കിൽ, ആദ്യം ലഭിക്കുന്ന പാസ്വേഡ് എൻക്രിപ്റ്റ് ചെയ്യുക. ഡാറ്റാബേസിൽ വ്യക്തമായ പാസ്‌വേഡുകൾ ഉണ്ടെങ്കിൽ, അവ എൻക്രിപ്റ്റ് ചെയ്യേണ്ട ആവശ്യമില്ല.
- നൽകിയ ഡാറ്റയുടെ കൃത്യത പരിശോധിക്കുക, ലോഗിനും പാസ്‌വേഡും ഡാറ്റാബേസിൽ നിലവിലുള്ള ഉപയോക്താവുമായി പൊരുത്തപ്പെടുന്നുവെങ്കിൽ, അത് എഴുതുക കുക്കിഅല്ലെങ്കിൽ ഒരു ലോഗിൻ, എൻക്രിപ്റ്റ് ചെയ്ത പാസ്വേഡ് (അല്ലെങ്കിൽ നിങ്ങൾ എൻക്രിപ്റ്റ് ചെയ്തിട്ടില്ലെങ്കിൽ തുറന്ന പാസ്വേഡ്) ഉള്ള സെഷൻ വിവരങ്ങൾ.
- ലോഗിൻ കൂടാതെ/അല്ലെങ്കിൽ പാസ്വേഡ് തെറ്റായി നൽകിയിട്ടുണ്ടെങ്കിൽ, അംഗീകാര ഫോമിലേക്ക് തിരിച്ചുവിടുക.
ഇപ്പോൾ നിങ്ങൾക്ക് ആവശ്യമായ വിവരങ്ങൾ ഉണ്ട് ഉപയോക്തൃ അംഗീകാരം, അവന്റെ സംഭരിച്ചിരിക്കുന്ന കുക്കിഅല്ലെങ്കിൽ സെർവറിൽ (സെഷൻ ആണെങ്കിൽ). വാസ്തവത്തിൽ, ഇപ്പോൾ നിങ്ങൾ സൈറ്റിന്റെ ഓരോ പേജിലും ഈ വിവരങ്ങൾ പരിശോധിക്കുകയും അംഗീകാര ഫോം പരിശോധിക്കുന്നതുപോലെ തന്നെ അത് പരിശോധിക്കുകയും വേണം. അതായത്, നിങ്ങൾ വായിക്കുന്നു കുക്കി(സെഷൻ) ലോഗിൻ, പാസ്വേഡ്, അത് പരിശോധിക്കുക. അവ ശരിയാണെങ്കിൽ, ഒരു പേജ് കാണിക്കുക (രജിസ്റ്റർ ചെയ്ത ഉപയോക്താക്കൾക്ക്), അവ തെറ്റാണെങ്കിൽ മറ്റൊരു പേജ് കാണിക്കുക (അതിഥികൾക്ക്).
പിന്നെ അവസാനമായി ഒരു കാര്യം. ബട്ടൺ എങ്ങനെയാണ് നിർമ്മിച്ചിരിക്കുന്നത് പുറത്ത്"? വളരെ ലളിതമാണ്. നിങ്ങൾ ഈ ബട്ടൺ അമർത്തുമ്പോൾ, കുക്കി, അല്ലെങ്കിൽ സെഷൻ. അങ്ങനെ, ഉപയോക്താവ് യാന്ത്രികമായി സൈറ്റിൽ നിന്ന് പുറത്താക്കപ്പെടും.
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, എല്ലാം പ്രാഥമികമാണ്, എന്നാൽ ഈ അൽഗോരിതം നടപ്പിലാക്കുമ്പോൾ നിങ്ങൾക്ക് തീർച്ചയായും നിരവധി ചോദ്യങ്ങൾ ഉണ്ടാകും. ഉദാഹരണത്തിന്, ഡാറ്റാബേസിൽ ഇതിനകം ലോഗിൻ ചെയ്തിട്ടുള്ള ഒരു ഉപയോക്താവിനെ രജിസ്റ്റർ ചെയ്യുമ്പോൾ എന്തുചെയ്യണം. വിവിധ ഇൻപുട്ട് പരിശോധനകൾ നടപ്പിലാക്കൽ, അസ്തിത്വ പരിശോധന നടപ്പിലാക്കൽ ഇ-മെയിൽതുടങ്ങിയവ - നിങ്ങൾ ആദ്യമായി ചെയ്യുകയാണെങ്കിൽ ഇതെല്ലാം വളരെ ബുദ്ധിമുട്ടാണ്. എന്നാലും ഞാൻ ജ്യൂസ് കൊടുത്തു. നടപ്പിലാക്കുമ്പോൾ നിങ്ങൾക്ക് ചോദ്യങ്ങളുണ്ടെങ്കിൽ, ഫോറത്തിലോ അഭിപ്രായങ്ങളിലോ ചോദിക്കുക.
വെബ്‌സൈറ്റുകൾ വികസിപ്പിച്ചെടുക്കുന്ന എല്ലാവരും താമസിയാതെ അല്ലെങ്കിൽ പിന്നീട് അത്തരം ഒരു ജോലിയെ അഭിമുഖീകരിക്കുന്നു ഉപയോക്തൃ അംഗീകാരവും പ്രാമാണീകരണവും, ഒരു പ്രോഗ്രാമിംഗ് ഭാഷ ഉപയോഗിച്ച് കൃത്യമായി നടപ്പിലാക്കി, കൂടാതെ http പ്രോട്ടോക്കോൾ സ്റ്റാൻഡേർഡ് ഉപയോഗിക്കുന്നില്ല. പി‌എച്ച്‌പി പ്രോഗ്രാമിംഗ് ഭാഷ ഉപയോഗിച്ച് ലളിതമായ ഒരു അംഗീകാരം സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇന്ന് ഞങ്ങൾ നോക്കും, കൂടാതെ ഞങ്ങൾ ഉപയോക്തൃ ഡാറ്റ MySQL ഡാറ്റാബേസിൽ സംഭരിക്കും.
ചുവടെയുള്ള രീതി ലളിതമാണ് അല്ലെങ്കിൽ, ഒരു സാധാരണ അംഗീകാരം സൃഷ്ടിക്കുന്നതിനുള്ള അടിസ്ഥാനം, പക്ഷേ നിങ്ങൾക്ക് ഇത് എളുപ്പത്തിൽ ഉപയോഗിക്കാം, കാരണം ഇത് നന്നായി പ്രവർത്തിക്കുന്നതിനാൽ നിങ്ങൾക്ക് ഈ രീതി സ്വയം മെച്ചപ്പെടുത്താനും നിങ്ങളുടെ വെബ്സൈറ്റിൽ ഇത് നടപ്പിലാക്കാനും കഴിയും.
ഈ രീതി സെഷനുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, പക്ഷേ ഞാൻ ഇവിടെ കുക്കികളും ഉപയോഗിക്കുന്നു, അതുവഴി കഴിഞ്ഞ തവണ പ്രാമാണീകരിച്ച ഉപയോക്താവിനെ ബ്രൗസർ ഓർമ്മിക്കുന്നു, അതിനാൽ ഓരോ തവണയും ലോഗിൻ ചെയ്യാതിരിക്കാൻ, നിങ്ങൾക്ക് തീർച്ചയായും, പാസ്വേഡ് കുക്കികളിൽ സംഭരിക്കാം, പക്ഷേ ഇത് എൻക്രിപ്റ്റ് ചെയ്താലും സുരക്ഷിതമല്ല. സെഷൻ അവസാനിപ്പിക്കാൻ, ബ്രൗസർ അടച്ച് വീണ്ടും തുറക്കുക.
ഡാറ്റാബേസിൽ ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുന്നു
നമുക്ക് പരിശീലനത്തിലേക്ക് പോകാം. ആദ്യം, MySQL ഡാറ്റാബേസിൽ ഉപയോക്തൃ ഡാറ്റ സംഭരിക്കുന്നതിന് ഒരു പട്ടിക ഉണ്ടാക്കാം. ഒരു ലളിതമായ പട്ടിക ഘടന ഉപയോഗിക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു ( തീർച്ചയായും, നിങ്ങൾക്ക് ഇത് എന്തെങ്കിലും സപ്ലിമെന്റ് ചെയ്യാം, എന്റെ ഡാറ്റാബേസിനെ ടെസ്റ്റ് എന്ന് വിളിക്കുന്നു, കൂടാതെ പട്ടിക ഉപയോക്താക്കളാണ്):
ടേബിൾ ടെസ്റ്റ്.ഉപയോക്താക്കൾ സൃഷ്ടിക്കുക(user_id INT(11) സൈൻ ചെയ്യാത്തത് ശൂന്യമല്ല ഓട്ടോ_ഇൻക്രിമെന്റ്, user_login VARCHAR(30) NULL അല്ല, user_password VARCHAR(32) NULL അല്ല, PRIMARY KEY (user_id) ഏകദേശം 80000000000000000000 എഞ്ചിനുകൾ സിഐ;
ഈ പട്ടികയിലേക്ക് ഉടൻ തന്നെ ഒരു എൻട്രി ചേർക്കാം:
test.users (user_login, user_password) മൂല്യങ്ങളിൽ ചേർക്കുക ("mylogin","202cb962ac59075b964b07152d234b70")
മൊത്തത്തിൽ ഞങ്ങൾക്ക് ലഭിച്ചത്:
- ലോഗിൻ- മൈലോഗിൻ;
- Password -;
വ്യക്തമായ ടെക്‌സ്‌റ്റിൽ പാസ്വേഡ് സംഭരിക്കുന്നത് സുരക്ഷിതമല്ല എന്നതിനാൽ, തീർച്ചയായും ഞങ്ങൾ പാസ്വേഡ് ഹാഷ് ചെയ്ത രൂപത്തിൽ സംഭരിക്കും. മുകളിലുള്ള ഞങ്ങളുടെ പാസ്വേഡ് ഹാഷ് 123 ആണ്, അതിനാൽ ഫോമിൽ പാസ്വേഡ് നൽകുമ്പോൾ, ഞങ്ങൾ കൃത്യമായി 123 നൽകും, അല്ല.
ഒരു രജിസ്ട്രേഷൻ ഫോം സൃഷ്ടിക്കുന്നു
ഉപയോക്താവ് സ്വയം രജിസ്റ്റർ ചെയ്യുന്നതിനായി, ഒരു ഫോം ഉണ്ടാക്കുക, അതിൽ നിന്നുള്ള ഡാറ്റ രജിസ്ട്രേഷൻ പ്രോസസ്സിംഗ് ഫയലിലേക്ക് അയയ്ക്കും, അതായത്. ഡാറ്റാബേസിൽ രേഖപ്പെടുത്തും. ഉദാഹരണത്തിന്, ഏറ്റവും ലളിതമായ മാർഗ്ഗം ഇതാ:
0) ( $error = "ഈ ലോഗിൻ ഉള്ള ഒരു ഉപയോക്താവ് ഇതിനകം ഉണ്ട്"; ) // ഇല്ലെങ്കിൽ, ഒരു പുതിയ ഉപയോക്താവിനെ ചേർക്കുക (!isset($error)) ($login = mysql_real_escape_string(trim(htmlspecialchars($_POST[) "ലോഗിൻ" ]))); // സ്‌പെയ്‌സുകൾ നീക്കം ചെയ്ത് പാസ്വേഡ് ഹാഷ് ചെയ്യുക $password = md5(ട്രിം($_POST["പാസ്വേഡ്"])); mysql_query("ഉപയോക്താക്കൾക്ക് ഇൻസേർട്ട് ചെയ്യുക user_login="".$login."" ". echo $error;)) //സ്വതവേ, ഡാറ്റ അതേ പ്രിന്റ് ഫയലിലേക്ക് അയയ്ക്കും<<< html
html; ?>വഴിയിൽ, ഈ രീതി ഉപയോഗിച്ച് ലോഗിൻ ചെയ്യുന്നതിന് ലാറ്റിൻ അക്ഷരങ്ങൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത് ( ആ. ഇംഗ്ലീഷ്), നിങ്ങൾക്ക് റഷ്യൻ ഭാഷയിൽ ഒരു ലോഗിൻ എഴുതണമെങ്കിൽ, നിങ്ങൾ കോഡ് ചെറുതായി ക്രമീകരിക്കേണ്ടതുണ്ട്. നിങ്ങൾക്ക് ആവശ്യമുള്ളത് ഫയലിന് പേരിടാം ( ടെസ്റ്റിനായി ഞാൻ reg.html ഉപയോഗിച്ചു).
കുറിപ്പ്! പരിശോധനയ്ക്കായി, ഞാൻ ഒരു ഫയൽ മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ, ഞാൻ അതിനെ mylogin.html എന്ന് വിളിച്ചു (ചുവടെയുള്ള ഫയൽ കോഡ്). നിങ്ങൾക്ക് ഇത് നിങ്ങളുടെ ഫയലുകളിൽ ഉപയോഗിക്കാനും നിങ്ങൾക്ക് ആവശ്യമുള്ളതെന്തും അവരെ വിളിക്കാനും കഴിയും, അംഗീകാര പ്രക്രിയയെ ഞാൻ ഇവിടെ വിവരിക്കുന്നു, അതിനാൽ നിങ്ങൾക്കത് എല്ലായിടത്തും പ്രയോഗിക്കാൻ കഴിയും. വഴിയിൽ, എല്ലാ ഫയലുകളിലും നിങ്ങൾ സെഷൻ_സ്റ്റാർട്ട്() ഫംഗ്ഷൻ ഉപയോഗിക്കേണ്ടതുണ്ട്; ഉപയോക്താവിന് അംഗീകൃതമാണോ അല്ലയോ എന്ന് നിങ്ങൾക്ക് പരിശോധിക്കാൻ കഴിയും. ഒരു കാര്യം കൂടി, തീർച്ചയായും, ഡാറ്റാബേസിലേക്ക് കണക്റ്റുചെയ്യുന്നതിനുള്ള നിങ്ങളുടെ ക്രമീകരണങ്ങൾ എഴുതുക.
ഒരു അംഗീകാര ഫോം സൃഷ്ടിക്കുന്നു
""നിങ്ങൾ ലോഗിൻ ചെയ്തു
ആ. ഞങ്ങൾ സെഷൻ പരിശോധിച്ചു, കൂടാതെ ചില ഡാറ്റയിലേക്കുള്ള ആക്സസ് തുറക്കാൻ കഴിയും"; ) അല്ലെങ്കിൽ ( $login = ""; //കുക്കി പരിശോധിക്കുക, ഒരുപക്ഷേ അവൻ ഇതിനകം ഇവിടെ സന്ദർശിച്ചിരിക്കാം (isset($_COOKIE["CookieMy"]))($ ലോഗിൻ = htmlspecialchars( $_COOKIE["CookieMy"]); ) //ലളിതമായ പ്രിന്റ് ഫോം<<< html
കുറിപ്പ്! പെട്ടെന്ന് നിങ്ങളുടെ php പാർസർ പ്രവർത്തിക്കാൻ വിസമ്മതിച്ചാൽ, അതായത്. php കോഡ് തന്നെ നിങ്ങളുടെ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും, അപ്പോൾ നിങ്ങൾക്ക് html ഫയലുകളിൽ PHP പ്രോസസ്സിംഗ് പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല. httpd.conf എന്ന വെബ് സെർവർ കോൺഫിഗറേഷൻ ഫയലിലാണ് ക്രമീകരണങ്ങൾ നിർമ്മിച്ചിരിക്കുന്നത് (അപാച്ചെ ആണെങ്കിൽ):
ആഡ്‌ടൈപ്പ് ആപ്ലിക്കേഷൻ/x-httpd-php .php .html
IIS-ൽ, ആഡ് മൊഡ്യൂൾ മാപ്പിംഗ് വിൻഡോയിൽ, കോമകളാൽ വേർതിരിച്ച് *.html-ലേക്ക് *.php ചേർക്കുക. നിങ്ങൾ ഇത് നിങ്ങളുടെ വെബ് സെർവറിൽ വീട്ടിലിരുന്ന് ചെയ്യുകയാണെങ്കിൽ, ഇതെല്ലാം ഹോസ്റ്ററിൽ ചെയ്യുകയാണെങ്കിൽ, നിങ്ങൾ അവർക്ക് കത്തെഴുതുകയും ആവശ്യമായ മാറ്റങ്ങൾ വരുത്താൻ അവരോട് ആവശ്യപ്പെടുകയും ചെയ്യും; ചില ഹോസ്റ്റർമാർ ഇതിനകം അവ ഉണ്ടാക്കിയിട്ടുണ്ട്.
ഞാൻ കോഡ് കമന്റ് ചെയ്തു, അതിനാൽ എല്ലാം വ്യക്തമായിരിക്കണമെന്ന് ഞാൻ കരുതുന്നു. അനധികൃത ഉപയോക്താക്കൾക്ക് കാണിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കാത്ത എല്ലാ ഫയലുകളിലും, നിങ്ങൾ സെഷൻ_സ്റ്റാർട്ട് എന്ന് എഴുതണം, ഒരുപക്ഷേ, അത്രയേയുള്ളൂവെന്ന് ഒരിക്കൽ കൂടി ഞാൻ നിങ്ങളെ ഓർമ്മിപ്പിക്കുന്നു. നിങ്ങൾക്ക് ചോദ്യങ്ങളുണ്ടെങ്കിൽ, അഭിപ്രായങ്ങളിൽ ചോദിക്കുക. നല്ലതുവരട്ടെ!
രചയിതാവിൽ നിന്ന്:താമസിയാതെ അല്ലെങ്കിൽ പിന്നീട്, ഓരോ വെബ് ഡെവലപ്പർമാരും ഒരു നിശ്ചിത പേജിലേക്കോ പേജുകളിലേക്കോ ഡയറക്‌ടറിയിലേക്കോ ആക്‌സസ്സ് നിയന്ത്രിക്കുന്ന ചുമതലയെ അഭിമുഖീകരിക്കുന്നു. ഇത് കേവലം സൈറ്റിലെ ഒരു രഹസ്യ പേജ്, സൈറ്റിന്റെ അഡ്മിനിസ്ട്രേറ്റീവ് ഭാഗം അല്ലെങ്കിൽ ഞങ്ങൾ ആക്സസ് പരിമിതപ്പെടുത്താനും പാസ്വേഡ് മാത്രം നൽകാനും ആഗ്രഹിക്കുന്ന മറ്റേതെങ്കിലും വിഭാഗമായിരിക്കാം. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് തീർച്ചയായും സെർവർ ഉപകരണങ്ങൾ ഉപയോഗിക്കാം. ഏതൊരു ആധുനിക ഹോസ്റ്റിംഗിനും ഒരു ഡയറക്‌ടറി പാസ്വേഡ് പരിരക്ഷിക്കുന്നതിനുള്ള ഒരു ഫംഗ്ഷൻ ഉണ്ടെന്ന് ഞാൻ കരുതുന്നു, അവിടെ നിങ്ങൾക്ക് ഒരു ഉപയോക്താവിനെ സൃഷ്‌ടിക്കാനും അവനു ഒരു പാസ്വേഡ് നൽകാനും ഡയറക്‌ടറി പാസ്വേഡ്-സംരക്ഷിച്ചതിനുശേഷം, അടച്ച ഡയറക്‌ടറിയിലേക്ക് ആക്‌സസ്സ് ശരിയായത് നൽകിയതിനുശേഷം മാത്രമേ നൽകൂ. പ്രവേശനവും പാസ്‌വേഡും. എന്നാൽ ചിലപ്പോൾ നിങ്ങൾ സ്വയം എന്തെങ്കിലും എഴുതാൻ ആഗ്രഹിക്കുന്നു, വേഗമേറിയതും ലളിതവും എന്നാൽ അതേ സമയം വിശ്വസനീയവുമായ ഒന്ന്...
ഈ പാഠത്തിൽ ഞങ്ങൾ സ്വന്തം ലളിതമായ അംഗീകാര സംവിധാനം എഴുതാൻ ശ്രമിക്കും. ഞങ്ങൾക്ക് ഒരു രഹസ്യ പേജ് ഉണ്ടാകും - അതൊരു അഡ്മിനിസ്ട്രേറ്റർ പേജായിരിക്കുമെന്ന് പറയാം, അതിലേക്ക് ഞങ്ങൾ ഒരു അംഗീകൃത ഉപയോക്താവിന് മാത്രമേ പ്രവേശനം നൽകൂ. ഞങ്ങളുടെ അംഗീകാര സംവിധാനം സെഷൻ മെക്കാനിസത്തെ അടിസ്ഥാനമാക്കിയുള്ളതായിരിക്കും. ഈ പാഠം തുടരുന്നതിന് മുമ്പ്, എന്റെ മുൻ പാഠങ്ങളിലൊന്ന് നിങ്ങൾ പരിചയപ്പെടാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു, അതിൽ ഞങ്ങൾ പ്രത്യേകിച്ച്, സെഷനുകളുടെ പ്രവർത്തനം പരിഗണിക്കുന്നു -.
ചുരുക്കത്തിൽ, സെഷനുകളുള്ള എല്ലാ ജോലികളും 3 ഘട്ടങ്ങളായി തിരിക്കാം:
സെഷന്റെ ഉദ്ഘാടനം. സെഷനുകൾ ഉപയോഗിച്ചുള്ള ജോലി സൂചിപ്പിക്കുന്ന എല്ലാ പേജുകളിലും, സെഷൻ_സ്റ്റാർട്ട്() ഫംഗ്ഷൻ ഉപയോഗിച്ചായിരിക്കണം സെഷൻ ആരംഭിക്കേണ്ടത്.
സെഷൻ വേരിയബിളുകൾ രജിസ്റ്റർ ചെയ്യുന്നു.
അൺസെറ്റ്() ഫംഗ്ഷൻ ഉപയോഗിച്ച് സെഷൻ വേരിയബിളുകൾ രജിസ്റ്റർ ചെയ്ത് സെഷൻ_ഡെസ്ട്രോയ്() ഫംഗ്ഷൻ ഉപയോഗിച്ച് സെഷൻ അവസാനിപ്പിക്കുന്നു.
ഘട്ടം 1
അതിനാൽ, ഞങ്ങളുടെ പ്രവർത്തനത്തിനായി, ഞങ്ങൾ 3 ഫയലുകൾ സൃഷ്ടിക്കും - ഹോം പേജ് (index.php), കോൺടാക്റ്റുകൾ (contact.php), അഡ്മിൻ പാനൽ (admin.php). ഞങ്ങൾ ആക്‌സസ്സ് നിയന്ത്രിക്കുന്ന ഫയൽ വിപുലീകരണം .php ആയിരിക്കണം എന്നത് ശ്രദ്ധിക്കുക. നിങ്ങൾ ഊഹിച്ചതുപോലെ, admin.php ഫയലിലേക്കുള്ള ആക്സസ് ഞങ്ങൾ നിയന്ത്രിക്കും. എല്ലാ ഫയലുകൾക്കുമുള്ള കോഡ് ഏറ്റവും ലളിതമാണ് - ഇത് മറ്റ് പേജുകളിലേക്കുള്ള ലിങ്കുകളുള്ള ഒരു ലൈനിലെ ഒരുതരം മെനുവാണ്, അതിന് കീഴിൽ ഓരോ പേജിന്റെയും വ്യക്തിഗത വാചകം, അതുവഴി നമുക്ക് അവയെ പരസ്പരം വേർതിരിച്ചറിയാൻ കഴിയും. ഉദാഹരണത്തിന്, സൂചിക പേജിനുള്ള കോഡ് ഇതാ:
വീട് | ബന്ധങ്ങൾ | അഡ്മിൻ
ഇതാണ് പ്രധാന പേജ്
ബാക്കിയുള്ള പേജുകൾ, ഞാൻ പറഞ്ഞതുപോലെ, ലൈൻ ടാഗിന് ശേഷമുള്ള വാചകത്തിൽ മാത്രമേ അതിൽ നിന്ന് വ്യത്യസ്തമാകൂ. മെറ്റാ ടാഗുകളുള്ള പൂർണ്ണമായ പേജുകൾ ഞാൻ സൃഷ്‌ടിച്ചിട്ടില്ല, കാരണം ഞങ്ങളുടെ ചുമതല ഒരു നിശ്ചിത പേജിലേക്കുള്ള പ്രവേശനം നിയന്ത്രിക്കുക മാത്രമാണ്.
ഘട്ടം 2
ഇപ്പോൾ, അഡ്മിൻ പേജ് ഉൾപ്പെടെ എല്ലാ പേജുകളും സ്വതന്ത്രമായി നാവിഗേറ്റ് ചെയ്യാം. ഇതിലേക്കുള്ള പ്രവേശനം നമുക്ക് എങ്ങനെ പരിമിതപ്പെടുത്താം? അൽഗോരിതം എങ്ങനെയായിരിക്കും? ഞങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്യും: പേജിന്റെ തുടക്കത്തിൽ തന്നെ നമുക്ക് ആവശ്യമുള്ള ലേബൽ സെഷനിൽ ഉണ്ടോ അല്ലെങ്കിൽ കൂടുതൽ ലളിതമായി പറഞ്ഞാൽ, ഒരു പ്രത്യേക സെഷൻ വേരിയബിൾ നിലവിലുണ്ടോ എന്ന് ഞങ്ങൾ പരിശോധിക്കും (ഒരു സെഷൻ വേരിയബിളിന്റെ മൂല്യം ആണോ എന്നും നമുക്ക് പരിശോധിക്കാം. ഒരു നിശ്ചിത മൂല്യത്തിന് തുല്യമാണ്). അത്തരമൊരു വേരിയബിൾ ഇല്ലെങ്കിൽ, ഈ പേജ് അഭ്യർത്ഥിക്കുന്ന ഉപയോക്താവിന് അംഗീകാരമില്ല, അതിനർത്ഥം ഞങ്ങൾ അവനെ അംഗീകാര പേജിലേക്ക് റീഡയറക്‌ടുചെയ്യും, അവിടെ ഒരു പേരും പാസ്‌വേഡും ഉള്ള ഒരു ഫോം പൂരിപ്പിക്കാൻ അവനോട് ആവശ്യപ്പെടും. അൽഗോരിതം വളരെ ലളിതമാണ് - നമുക്ക് അത് നടപ്പിലാക്കാം. admin.php ഫയലിലേക്ക് പോകുക, ഏറ്റവും മുകളിലുള്ള PHP നിർമ്മാണം തുറന്ന് ഇനിപ്പറയുന്ന കോഡ് എഴുതുക:
സെഷൻ_ആരംഭം(); എങ്കിൽ (! $_SESSION [ "admin" ] ) ( തലക്കെട്ട് ("ലൊക്കേഷൻ: enter.php"); പുറത്ത് ; |
ഇനി ഈ കോഡ് വായിക്കാം. ഒന്നാമതായി, നിങ്ങൾ ഓർക്കുന്നതുപോലെ ഞങ്ങൾ ഒരു സെഷൻ തുറന്നു - സെഷനുകളിൽ പ്രവർത്തിക്കുമ്പോൾ ഇത് ഒരു മുൻവ്യവസ്ഥയാണ്. അടുത്തതായി, ഇതുപോലെ വായിക്കാൻ കഴിയുന്ന ഒരു ലളിതമായ വ്യവസ്ഥ ഞങ്ങൾ സൃഷ്ടിച്ചു: "$_SESSION അറേയിൽ അഡ്മിൻ ഘടകം നിലവിലില്ലെങ്കിൽ, ഓപ്പറേറ്റർ ബ്രാക്കറ്റുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പ്രവർത്തനങ്ങളുടെ ബ്ലോക്ക് ഞങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യും." കോഡ് ബ്ലോക്കിൽ, ഹെഡർ () ഫംഗ്ഷൻ ഉപയോഗിച്ച്, ഞങ്ങൾ ഉപയോക്താവിനെ enter.php പേജിലേക്ക് റീഡയറക്ട് ചെയ്യുന്നു (ഇതാണ് അംഗീകാര പേജ്). ഹെഡർ() ഫംഗ്‌ഷന് ശേഷം, എക്‌സിറ്റ്() ഫംഗ്ഷൻ ഉപയോഗിച്ച് സ്‌ക്രിപ്‌റ്റിന്റെ എക്‌സിക്യൂഷൻ പൂർത്തിയാക്കണം. വ്യവസ്ഥ പാലിച്ചില്ലെങ്കിൽ, അതായത്, $_SESSION അറേയിൽ ഒരു അഡ്മിൻ ഘടകം ഉണ്ടാകും, ഇതിനർത്ഥം ഉപയോക്താവിന് ഇതിനകം തന്നെ അംഗീകാരം ലഭിച്ചിട്ടുണ്ടെന്നാണ്, കൂടാതെ ഓപ്പറേറ്റർ ബ്രാക്കറ്റുകളിലെ പ്രവർത്തന ബ്ലോക്ക് ഞങ്ങൾ ഒഴിവാക്കും, അതായത്, റീഡയറക്‌ടൊന്നും സംഭവിക്കില്ല, ഞങ്ങൾ ആവശ്യപ്പെട്ട പേജ് കാണിക്കുന്നു.
ഘട്ടം 3
ഇപ്പോൾ നമ്മൾ ഒരു ലോഗിൻ പേജ് സൃഷ്ടിക്കേണ്ടതുണ്ട് - enter.php. ഇത് ചെയ്യുന്നതിന്, കോഡ് പകർത്തുക, ഉദാഹരണത്തിന്, contact.php പേജ്, ഒരു പുതിയ ഫയൽ സൃഷ്ടിച്ച് അതിൽ പകർത്തിയ കോഡ് ഒട്ടിക്കുക. enter.php എന്ന പേരിൽ ഫയൽ സേവ് ചെയ്യുക. ഇപ്പോൾ ഈ പേജിൽ നിങ്ങളുടെ പ്രവേശനവും പാസ്‌വേഡും നൽകുന്നതിനുള്ള ഒരു ലളിതമായ ഫോം ഞങ്ങൾ എഴുതും:
വീട് | ബന്ധങ്ങൾ | അഡ്മിൻ
ഇതാണ് ലോഗിൻ പേജ്.
< p > < a href = "index.php" >വീട്< / a > | < a href = "contact.php" >ബന്ധങ്ങൾ< / a > | < a href = "admin.php" >അഡ്മിൻ< / a > < / p > < hr / > < br / > < form method = "post" > ഉപയോക്തൃനാമം:< input type = "text" name = "user" / > < br / > Password:< input type = "password" name = "pass" / > < br / > < input type = "submit" name = "submit" value = "അകത്തേക്ക് വരാൻ" / > < / form > |
ഇവിടെ എല്ലാം ലളിതമാണ്. ഫോമിന് 2 ഫീൽഡുകളുണ്ട്: ഒരു ലോഗിൻ ഫീൽഡ് (ഞങ്ങൾ അതിന് "ഉപയോക്താവ്" എന്ന പേര് നൽകി) ഒരു പാസ്വേഡ് ഫീൽഡും ("പാസ്" എന്ന് നാമകരണം ചെയ്തിരിക്കുന്നു). ഞങ്ങൾ ഒരു ബട്ടണും സൃഷ്ടിച്ചു (പേര് "സമർപ്പിക്കുക"), ക്ലിക്ക് ചെയ്യുമ്പോൾ, ഫോമിൽ നിന്നുള്ള ഡാറ്റ അയയ്ക്കും. പോസ്റ്റ് രീതി ഉപയോഗിച്ചാണ് ഡാറ്റ അയയ്‌ക്കുന്നത് - ഫോം ടാഗിന്റെ രീതി ആട്രിബ്യൂട്ടിൽ ഞങ്ങൾ ഇത് വ്യക്തമാക്കിയിട്ടുണ്ട് - അതേ പേജിൽ തന്നെ പ്രോസസ്സ് ചെയ്യും. ഇപ്പോൾ നമുക്ക് അഡ്മിൻ പേജിലേക്ക് പോകാൻ ശ്രമിക്കാം. എല്ലാം പിഴവുകളില്ലാതെ ചെയ്താൽ, ഞങ്ങൾക്ക് അവിടെയെത്താൻ കഴിയില്ല, പക്ഷേ സ്ഥിരീകരണ പേജിൽ സ്ഥിരമായി അവസാനിക്കും.
അത്ഭുതം!
ഘട്ടം 4
അടുത്തതായി, ഫോമിൽ നിന്ന് ഡാറ്റ സ്വീകരിക്കുന്ന ഫോം ഉപയോഗിച്ച് പേജിൽ ഒരു ഹാൻഡ്ലർ എഴുതുകയും ഫോമിൽ നിന്നുള്ള ലോഗിനും പാസ്‌വേഡും ഞങ്ങളുടെ പക്കലുള്ളതുമായി പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് താരതമ്യം ചെയ്യുകയും വേണം. ഇത് ചെയ്യുന്നതിന്, ലോഗിൻ പേജിന്റെ മുകളിലുള്ള PHP നിർമ്മാണം തുറന്ന് കോഡ് എഴുതാൻ ആരംഭിക്കുക. ആദ്യം, ഞങ്ങൾ ഒരു സെഷൻ തുറക്കണം - എല്ലാത്തിനുമുപരി, ശരിയായ ലോഗിനും പാസ്‌വേഡും ലഭിച്ചിട്ടുണ്ടെങ്കിൽ സെഷനിൽ ഞങ്ങൾ ഒരു ലേബൽ സൃഷ്ടിക്കുന്നത് ഇവിടെയാണ്. ഇതേ പേജിൽ ഞങ്ങൾ അഡ്മിനിസ്ട്രേറ്ററുടെ പ്രവേശനവും പാസ്‌വേഡും സംഭരിക്കും. സാധാരണയായി ഈ ഡാറ്റ ഒരു ഡാറ്റാബേസിൽ (DB) സംഭരിക്കുന്നു, എന്നാൽ ഞങ്ങൾക്ക് 1 ഉപയോക്താവ് (അഡ്മിനിസ്ട്രേറ്റർ) മാത്രമേ ഉണ്ടാകൂ, അതിനാൽ DB-യിലേക്ക് ലോഗിൻ ചെയ്യുന്നതിനായി അവന്റെ ഡാറ്റ സംഭരിക്കുന്നത് പൂർണ്ണമായും യുക്തിസഹമല്ല. ഒന്നിൽ കൂടുതൽ ഉപയോക്താക്കൾ ഉണ്ടെങ്കിൽ, അതായത്, ഉദാഹരണത്തിന്, രജിസ്ട്രേഷൻ ഉള്ള ഒരു പ്രോജക്റ്റ് ഞങ്ങൾ എഴുതുകയാണ്, തീർച്ചയായും, ഈ സാഹചര്യത്തിൽ ഒരു ഡാറ്റാബേസ് ഇല്ലാതെ ചെയ്യാൻ ബുദ്ധിമുട്ടായിരിക്കും.
അതിനാൽ, ഞങ്ങളുടെ ലോഗിൻ "അഡ്മിൻ" ആയിരിക്കും, ഞങ്ങൾ അത് $admin വേരിയബിളിൽ സംഭരിക്കും. പാസ്വേഡ് "mypass" ആയിരിക്കും, അത് $pass വേരിയബിളിൽ സംഭരിക്കപ്പെടും. എന്നാൽ വ്യക്തമായ വാചകത്തിൽ പാസ്‌വേഡുകൾ സംഭരിക്കുന്നത് അംഗീകരിക്കില്ല - ഇത് സുരക്ഷാ തത്വങ്ങൾക്ക് വിരുദ്ധമാണ്. ഞങ്ങൾ രഹസ്യവാക്ക് എൻക്രിപ്റ്റ് ചെയ്ത രൂപത്തിൽ സംഭരിക്കും, കൂടാതെ md5() ഫംഗ്ഷൻ അത് എൻക്രിപ്റ്റ് ചെയ്യാൻ ഞങ്ങളെ സഹായിക്കും. ഈ ഫംഗ്ഷൻ ഒരു പ്രത്യേക അൽഗോരിതം ഉപയോഗിച്ച് ഒരു സ്ട്രിംഗ് എൻക്രിപ്റ്റ് ചെയ്യുന്നു, കൂടാതെ ഔട്ട്പുട്ട് 32 പ്രതീകങ്ങളുടെ ഒരു സ്ട്രിംഗ് ആണ് (ഒരു ഹാഷ് എന്ന് വിളിക്കുന്നു). നമ്മൾ "mypass" എന്ന സ്ട്രിംഗ് എൻക്രിപ്റ്റ് ചെയ്യുകയാണെങ്കിൽ (ഇത് ചെയ്യാൻ കഴിയും, ഉദാഹരണത്തിന്, contact.php ഫയലിൽ):
echo md5 ("mypass" ); |
അപ്പോൾ ഔട്ട്പുട്ട് “a029d0df84eb5549c641e04a9ef389e5″ എന്ന വരി ആയിരിക്കും - ഇത് ഞങ്ങളുടെ എൻക്രിപ്റ്റ് ചെയ്ത പാസ്വേഡ് ആയിരിക്കും. ഇപ്പോൾ, ലോഗിൻ പേജ് കോഡ് ഇതുപോലെയായിരിക്കും:
വീട് | ബന്ധങ്ങൾ | അഡ്മിൻ
ഇതാണ് ലോഗിൻ പേജ്.
സെഷൻ_ആരംഭം(); $അഡ്മിൻ = "അഡ്മിൻ" ; $pass = "a029d0df84eb5549c641e04a9ef389e5"; < p > < a href = "index.php" >വീട്< / a > | < a href = "contact.php" >ബന്ധങ്ങൾ< / a > | < a href = "admin.php" >അഡ്മിൻ< / a > < / p > < hr / > < br / > < form method = "post" > ഉപയോക്തൃനാമം:< input type = "text" name = "user" / > < br / > Password:< input type = "password" name = "pass" / > < br / > < input type = "submit" name = "submit" value = "അകത്തേക്ക് വരാൻ" / > < / form > |
ഘട്ടം 5
ലോഗിൻ, പാസ്വേഡ് വേരിയബിളുകളിൽ ഉള്ളത് ഉപയോഗിച്ച് നമുക്ക് ഫോമിൽ നിന്ന് എന്താണ് ലഭിച്ചത് എന്ന് നോക്കാം. ഞങ്ങൾ ഇത് സോപാധികമായി ചെയ്യും - ഫോം ബട്ടൺ അമർത്തിയാൽ മാത്രം. നമുക്ക് ഇത് എങ്ങനെ പരിശോധിക്കാം? ബട്ടണിന് ഒരു പേരുണ്ട് (“സമർപ്പിക്കുക”), ഞങ്ങൾ പോസ്റ്റ് രീതി ഉപയോഗിച്ച് ഡാറ്റ കൈമാറുന്നു. അതനുസരിച്ച്, സമർപ്പിക്കൽ ഘടകം $_POST അറേയിൽ നിലവിലുണ്ടോ എന്ന് നമുക്ക് പരിശോധിക്കാം. ഉണ്ടെങ്കിൽ, ബട്ടൺ അമർത്തി, അയച്ച ഡാറ്റ പരിശോധിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ ഞങ്ങൾ നടത്തും, അല്ലാത്തപക്ഷം ഞങ്ങൾ ഒന്നും ചെയ്യില്ല. പ്രവേശനവും പാസ്‌വേഡും പ്രഖ്യാപിച്ച ശേഷം, ഞങ്ങൾ വ്യവസ്ഥ എഴുതുന്നു:
if($_POST["submit"])( if($admin == $_POST["user"] കൂടാതെ $pass == md5($_POST["pass"]))( $_SESSION["admin"] = $ അഡ്മിൻ; തലക്കെട്ട്("ലൊക്കേഷൻ: admin.php"); പുറത്തുകടക്കുക; )മറ്റേത് പ്രതിധ്വനി "
ലോഗിൻ അല്ലെങ്കിൽ പാസ്വേഡ് തെറ്റാണ്!
"; }എങ്കിൽ ($_POST["സമർപ്പിക്കുക"]) ( എങ്കിൽ ($ അഡ്മിൻ == $_POST [ "ഉപയോക്താവ്" ] കൂടാതെ $ പാസ് == md5 ($ _POST [ "പാസ്" ] ) ) ( $_SESSION["admin"] = $admin; പുറത്ത് ; ) മറ്റ് പ്രതിധ്വനികൾ " ലോഗിൻ അല്ലെങ്കിൽ പാസ്വേഡ് തെറ്റാണ്! |
ലോഗിൻ, പാസ്വേഡ് എന്നിവ പരിശോധിക്കുന്നതിനുള്ള വ്യവസ്ഥ ഞങ്ങൾ ഇരട്ടിയാക്കി. ലോജിക്കൽ ഓപ്പറേറ്റർ AND ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത് (ഇത് ഇങ്ങനെയും എഴുതാം - “&&”). വ്യവസ്ഥ ഇനിപ്പറയുന്ന രീതിയിൽ വായിക്കാം: “($_POST അറേയിലെ ഉപയോക്തൃ ഘടകത്തിന് $അഡ്മിൻ വേരിയബിൾ തുല്യമാണെങ്കിൽ $_POST അറേയിലെ പാസ് എലമെന്റിന്റെ ഹാഷിന് $pass വേരിയബിൾ തുല്യമാണെങ്കിൽ) അപ്പോൾ (ഞങ്ങൾ നിർവഹിക്കുന്നു പ്രവർത്തനങ്ങളുടെ ബ്ലോക്ക്) അല്ലെങ്കിൽ 'ലോഗിൻ അല്ലെങ്കിൽ പാസ്വേഡ് തെറ്റാണ്!'
ലോഗിൻ-പാസ്വേഡ് ജോടി പൊരുത്തപ്പെടുന്നുവെങ്കിൽ, ഞങ്ങൾ $_SESSION["admin"] എന്ന സെഷൻ വേരിയബിൾ രജിസ്റ്റർ ചെയ്യുകയും ഉപയോക്താവിനെ അഡ്മിൻ പേജിലേക്ക് റീഡയറക്ട് ചെയ്യുകയും ചെയ്യുന്നു - admin.php.
നമ്മൾ ഇതിനകം സൃഷ്ടിച്ചത് പരീക്ഷിക്കാൻ ശ്രമിക്കാം. ഞങ്ങൾ ബോധപൂർവം തെറ്റായ ലോഗിൻ, പാസ്വേഡ് എന്നിവ നൽകിയാൽ, "ലോഗിൻ അല്ലെങ്കിൽ പാസ്വേഡ് തെറ്റാണ്!" എന്ന മുന്നറിയിപ്പ് സന്ദേശം ലഭിക്കും. ഇപ്പോൾ ശരിയായ ലോഗിൻ വിവരങ്ങൾ നൽകാൻ ശ്രമിക്കാം. ഞങ്ങൾ എവിടെയും ഒരു തെറ്റ് ചെയ്തിട്ടില്ലെങ്കിൽ, "ലോഗിൻ" ബട്ടണിൽ ക്ലിക്കുചെയ്തതിനുശേഷം ഞങ്ങൾ അഡ്മിൻ പേജിൽ സ്വയം കണ്ടെത്തും.
ഘട്ടം 6
ഇപ്പോൾ ചെയ്യേണ്ടത് കുറച്ച് ചെറിയ വിശദാംശങ്ങൾ ചേർക്കുക മാത്രമാണ്. ഉദാഹരണത്തിന്, ഞങ്ങൾ ഇപ്പോൾ സിസ്റ്റത്തിൽ അംഗീകൃതമാണ്, എന്നാൽ ഞങ്ങൾ അഡ്രസ് ബാറിൽ അംഗീകാര പേജിന്റെ വിലാസം നൽകിയാൽ, നമുക്ക് എളുപ്പത്തിൽ അതിലെത്തുകയും അംഗീകാര ഫോം കാണുകയും ചെയ്യും. ഇത് സംഭവിക്കാൻ പാടില്ല - ഒരു അനധികൃത ഉപയോക്താവ് മാത്രമേ ഫോം കാണൂ. നമുക്ക് ഇത് എങ്ങനെ പരിഹരിക്കാനാകും? admin.php പേജിൽ ലേബൽ സെഷനിൽ ഉണ്ടോ എന്ന് ഞങ്ങൾ പരിശോധിച്ചുവെന്ന് ഓർക്കുക. അത് ഇല്ലെങ്കിൽ, അംഗീകൃത പേജിലേക്ക് ഞങ്ങൾ ഉപയോക്താവിനെ റീഡയറക്ട് ചെയ്തു. ഇവിടെ നമുക്ക് അതേ കാര്യം ചെയ്യാൻ കഴിയും, വിപരീതമായി മാത്രം. അതായത്, ലേബൽ സെഷനിൽ ഉണ്ടോ എന്നും ഞങ്ങൾ പരിശോധിക്കുന്നു. അത്തരമൊരു ലേബൽ ഉണ്ടെങ്കിൽ മാത്രമേ ഞങ്ങൾ ഉപയോക്താവിനെ അഡ്മിൻ പേജിലേക്ക് മാറ്റുകയുള്ളൂ. ഇത് തത്വത്തിൽ യുക്തിസഹമാണ്. ഒരു ലേബൽ ഉണ്ടെങ്കിൽ, ഉപയോക്താവിന് ഇതിനകം അംഗീകാരമുണ്ട്, ഞങ്ങൾക്ക് അവനെ അഡ്മിൻ പേജിലേക്ക് മാറ്റാം. സെഷൻ ആരംഭിച്ചതിന് ശേഷം enter.php പേജിൽ, ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക:
if($_SESSION["admin"])( header("Location: admin.php"); exit; )
എങ്കിൽ ($_SESSION["അഡ്മിൻ"]) ( തലക്കെട്ട് ("ലൊക്കേഷൻ: admin.php" ); പുറത്ത് ; |
ഇപ്പോൾ, ഒരു അംഗീകൃത ഉപയോക്താവ് വിലാസ ബാറിൽ അംഗീകാര പേജിന്റെ പേര് നൽകാൻ ശ്രമിച്ചാൽ, അവനെ അഡ്മിൻ പേജിലേക്ക് റീഡയറക്‌ടുചെയ്യും. അംഗീകൃത പേജ് ഒരു അനധികൃത ഉപയോക്താവിന് സ്വതന്ത്രമായി ആക്സസ് ചെയ്യാൻ കഴിയും.
ഘട്ടം 7
ഞങ്ങൾ നൽകേണ്ട അടുത്ത പോയിന്റ് ഒരു അംഗീകൃത ഉപയോക്താവിന്റെ ലോഗ്ഔട്ട് നടപ്പിലാക്കുക എന്നതാണ്, അതായത്, അഡ്മിനിസ്ട്രേറ്റർ തന്റെ ജോലി പൂർത്തിയാക്കി, ലോഗ് ഔട്ട് ചെയ്യേണ്ടതുണ്ടെന്ന് പറയാം, അതിനാൽ മറ്റാർക്കും അവന്റെ അക്കൗണ്ടിന് കീഴിൽ പ്രവർത്തിക്കാൻ കഴിയില്ല. ഇത് ചെയ്യുന്നതിന്, admin.php പേജിലേക്ക് ഒരു "Exit" ലിങ്ക് ചേർക്കുക. ലിങ്ക് ഒരേ പേജിലേക്ക് നയിക്കും, ഞങ്ങൾക്ക് ആവശ്യമായ പാരാമീറ്റർ മാത്രമേ അതിൽ ചേർക്കൂ. ഒരു ചോദ്യചിഹ്നം ഉപയോഗിച്ചാണ് പാരാമീറ്റർ ചേർത്തിരിക്കുന്നത്:
പുറത്ത്
< a href = "admin.php?do=logout" >പുറത്ത്< / a > |
ഈ ലിങ്ക് നമുക്ക് ആവശ്യമുള്ള സ്ഥലത്ത് സ്ഥാപിക്കാം - പേജ് വാചകത്തിന് ശേഷം ഞാൻ ഇത് ഇടാം. പാരാമീറ്ററിനെ സംബന്ധിച്ചിടത്തോളം, ഇത് GET രീതി ഉപയോഗിച്ച് കൈമാറ്റം ചെയ്യപ്പെടും (രണ്ടാമത്തെ പാരാമീറ്റർ - POST ഉപയോഗിച്ച് ഫോമിൽ നിന്ന് ഞങ്ങൾ ഡാറ്റ ട്രാൻസ്മിറ്റ് ചെയ്തതായി ഓർക്കുക). ഈ രീതി ഉപയോഗിക്കുമ്പോൾ, വിലാസ ബാറിലെ വിലാസത്തിലേക്ക് ഡാറ്റ കൂട്ടിച്ചേർക്കുകയും വിലാസത്തിൽ നിന്ന് ഒരു ചോദ്യചിഹ്നത്താൽ വേർതിരിക്കുകയും ചെയ്യുന്നു. ഞങ്ങൾ ഒരു പാരാമീറ്റർ പാസാക്കുന്നു - ചെയ്യുക - അതേ സമയം അതിന് "ലോഗൗട്ട്" എന്ന മൂല്യം നൽകുക. ഇപ്പോൾ നമുക്ക് എങ്ങനെ ഉപയോക്താവിനെ അംഗീകരിക്കാനാകും? ഇത് വളരെ ലളിതമാണ് - സെഷനുകളിൽ പ്രവർത്തിക്കുമ്പോൾ രണ്ടാമത്തെയും മൂന്നാമത്തെയും ഘട്ടങ്ങൾ ഇവിടെ ഞങ്ങളെ സഹായിക്കും. പേജ് ലോഡ് ചെയ്യുമ്പോൾ, $_GET അറേയിൽ നിന്ന് ഡോ എലമെന്റിന്റെ മൂല്യം നമുക്ക് പരിശോധിക്കാം. ഇത് "ലോഗൗട്ട്" എന്ന സ്ട്രിംഗിന് തുല്യമാണെങ്കിൽ, $_SESSION["admin"] എന്ന സെഷൻ വേരിയബിൾ ഞങ്ങൾ അൺരജിസ്റ്റർ ചെയ്യുകയും സെഷൻ നശിപ്പിക്കുകയും ചെയ്യും. അതനുസരിച്ച്, ഇതിന് ശേഷമുള്ള സെഷനിൽ ലേബൽ ഉണ്ടാകില്ല, അടുത്ത ബ്ലോക്കിൽ, ഞങ്ങൾ ലേബലിന്റെ സാന്നിധ്യം പരിശോധിക്കുന്നിടത്ത്, ഉപയോക്താവിനെ അംഗീകാര പേജിലേക്ക് റീഡയറക്‌ടുചെയ്യും. ഇത് ലളിതമാണ്.
എല്ലാവർക്കും ഹായ്. അതിനാൽ രൂപങ്ങൾ സൃഷ്ടിക്കുന്നതിനുള്ള ചില ഘടകങ്ങൾ ഞങ്ങൾ പഠിച്ചു. ഒരു വലിയ പ്രശ്നം പരിഹരിക്കാൻ നമ്മുടെ അറിവ് സംയോജിപ്പിക്കേണ്ട സമയമാണിത്. സൈറ്റിൽ അംഗീകാരത്തിനായി ഏറ്റവും ലളിതമായ ഫോം സൃഷ്ടിക്കാം. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾക്ക് രണ്ട് ഫീൽഡുകൾ ആവശ്യമാണ്, ഞങ്ങൾ അവയിൽ ഒപ്പുകൾ സൃഷ്ടിക്കുകയും അറ്റാച്ചുചെയ്യുകയും ചെയ്യുന്നു.
ആദ്യ ഫീൽഡ് ലോഗിൻ ചെയ്യാനുള്ളതാണ്, രണ്ടാമത്തേത് പാസ്‌വേഡിനാണ്. രണ്ടാമത്തേതിൽ ഇത് അത്ര ലളിതമല്ല. കാരണം ഇപ്പോൾ ഇത് ഒരു ടെക്സ്റ്റ് ഇൻപുട്ട് ഫീൽഡ് മാത്രമാണ്.
ബ്രൗസറിലെ ഫലം:
ഈ തരത്തിലുള്ള ഒരു ഫീൽഡിന്റെ പതിവ് പോലെ, അതിൽ നൽകിയിട്ടുള്ള വാചകം നക്ഷത്രചിഹ്നങ്ങൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നതിന്, നിങ്ങൾ ഒരു ലളിതമായ പ്രവർത്തനം ചെയ്യേണ്ടതുണ്ട്. അതായത്, ആട്രിബ്യൂട്ട് മൂല്യം മാറ്റിസ്ഥാപിക്കാൻ തരംഓൺ password:
ഫലമായി: 
ഫോം സമർപ്പിക്കുക ബട്ടൺ
ഇവിടെ ആരംഭിക്കുന്നു. ഞങ്ങളുടെ ഫോം ഏകദേശം തയ്യാറാണ്. ഇപ്പോൾ, അതിന്റെ സൃഷ്‌ടി പൂർത്തിയാക്കാൻ, ഫോം സമർപ്പിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ബട്ടൺ നിങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്. ഒരു ടാഗ് ഉപയോഗിച്ചാണ് പ്രശ്നം പരിഹരിക്കുന്നത് തരം ഉപയോഗിച്ച് സമർപ്പിക്കുക.
ബട്ടണിന് ഏതെങ്കിലും തരത്തിലുള്ള ലിഖിതമുണ്ടെങ്കിൽ, അത് ആട്രിബ്യൂട്ട് ഉപയോഗിച്ച് ചെയ്യാം മൂല്യം. ബട്ടണിന് ഒരു പേര് നൽകണോ വേണ്ടയോ എന്നത് നിങ്ങളുടേതാണ്; നിങ്ങൾ ഇത് ചെയ്യുകയാണെങ്കിൽ, സെർവറിന് ഈ പേരും ബട്ടണിന്റെ മൂല്യവും ലഭിക്കും.
ചട്ടം പോലെ, ഫോമിന് നിരവധി ബട്ടണുകൾ ഉള്ളപ്പോൾ ഒരു ഫോം സമർപ്പിക്കാനുള്ള ബട്ടണിന്റെ പേര് ആവശ്യമാണ്, അവയിൽ ഓരോന്നും ഒരു നിർദ്ദിഷ്ട പ്രവർത്തനം നടത്തുന്നു. ഇതിന് നന്ദി, ബ്രൗസറിൽ നിന്ന് ബട്ടണിന്റെ പേരും മൂല്യവും സ്വീകരിക്കുന്ന സെർവർ, ഏത് ബട്ടണാണ് ഉപയോക്താവ് ക്ലിക്ക് ചെയ്തതെന്നും അതിനനുസരിച്ച് എന്താണ് ചെയ്യേണ്ടതെന്നും മനസ്സിലാക്കുന്നു.
തൽഫലമായി, ഞങ്ങളുടെ ഫോമിന്റെ കോഡ് ഇനിപ്പറയുന്നതായിരിക്കും:
ബ്രൗസറിലെ ഫലം: 
അതിനാൽ, ഒരു ചുമതലയുണ്ട് - സിസ്റ്റത്തിൽ രജിസ്ട്രേഷനും അംഗീകാരത്തിനുള്ള സാധ്യതയും ഉണ്ടാക്കുക. ഇത് എങ്ങനെ ചെയ്യാം? നമുക്ക് ക്രമത്തിൽ ആരംഭിക്കാം.
php-ൽ രജിസ്ട്രേഷൻ
ഇവിടെ എല്ലാം ലളിതമാണ്. ഉപയോക്താക്കൾക്കായി ഒരു ഡാറ്റ വെയർഹൗസ് സൃഷ്ടിക്കുന്നു. സാധാരണയായി ഇതൊരു ഡാറ്റാബേസ് പട്ടികയാണ്. ഐഡി, യൂസർ നെയിം, പാസ്വേഡ് തുടങ്ങിയ ഫീൽഡുകൾ ഇതിൽ ഉൾപ്പെടുന്നു. ശേഷിക്കുന്ന ഫീൽഡുകൾ ഓപ്ഷണൽ ആണ്. നിങ്ങൾക്ക് ഉപയോക്താക്കളുടെ ഇ-മെയിലുകൾ, അവരുടെ വിലാസങ്ങൾ, സാധ്യമായ ഐപികൾ, നെറ്റ്‌വർക്കിലേക്കുള്ള ആക്സസ് സമയം, ബാങ്ക് കാർഡുകളിൽ നിന്നുള്ള കോഡ് വാക്കുകൾ, സുരക്ഷാ ചോദ്യങ്ങൾ...
പൊതുവേ, പ്രധാന കാര്യം ലോഗിൻ-പാസ്വേഡ് ജോഡിയാണ്.
ആദ്യത്തെ പ്രധാന പോയിന്റ്— ഉപയോക്തൃ പാസ്‌വേഡുകൾ വ്യക്തമായ വാചകത്തിൽ സൂക്ഷിക്കാൻ കഴിയില്ല. അതായത്, ടെക്സ്റ്റ് പോലെ. ഇത് അസാധ്യമാണ്, കാരണം മറ്റാരെങ്കിലും ഡാറ്റാബേസിലേക്ക് പ്രവേശനം നേടുകയാണെങ്കിൽ, അവർക്ക് ഉപയോക്തൃ ലോഗിൻ പാസ്‌വേഡുകളുടെ ഒരു ഡാറ്റാബേസ് ലഭിക്കും, അത് അവർക്ക് ഇഷ്ടപ്പെടാൻ സാധ്യതയില്ല. വ്യത്യസ്ത സേവനങ്ങളിൽ പല ഉപയോക്താക്കൾക്കും ഒരേ ലോഗിൻ, പാസ്സ്‌വേർഡ് ഉണ്ടെന്ന് നിങ്ങൾ കരുതുന്നുവെങ്കിൽ, ഇത് വ്യക്തിഗത ഡാറ്റയും സാമ്പത്തികവും, വ്യക്തിഗത കത്തിടപാടുകളും മറ്റ് എല്ലാ കാര്യങ്ങളും അപകടത്തിലാക്കുന്നു.
പാസ്‌വേഡുകൾ ഒരു ഹാഷ് ആയി സൂക്ഷിക്കണം. ഹാഷിംഗ്യഥാർത്ഥ ഡാറ്റയെ അറിയപ്പെടുന്ന ദൈർഘ്യമുള്ള ഒരു തരം കാസ്റ്റാക്കി മാറ്റുന്ന ഒരു പ്രവർത്തനമാണ്. അഭിനേതാക്കൾ അതുല്യമായതിനാൽ ഇത് നല്ലതാണ്. അതായത്, സോഴ്സ് ഡാറ്റയിലെ ഒരു പ്രതീകമെങ്കിലും മാറ്റുകയാണെങ്കിൽ, ഹാഷിംഗ് പ്രവർത്തനത്തിന്റെ ഔട്ട്പുട്ട് തിരിച്ചറിയാൻ കഴിയാത്തവിധം തികച്ചും വ്യത്യസ്തമായിരിക്കും. ഹാഷിംഗ് പ്രവർത്തനം മാറ്റാനാവാത്തതാണ്, അതായത്, ഈ സ്നാപ്പ്ഷോട്ടിൽ നിന്നുള്ള യഥാർത്ഥ ഡാറ്റ വികസിപ്പിക്കാൻ കഴിയില്ല. എൻക്രിപ്ഷനിൽ നിന്ന് വ്യത്യസ്തമാകുന്നത് ഇങ്ങനെയാണ്.
MySQL, PHP എന്നിവയ്ക്ക് പൊതുവായതും സുരക്ഷിതവുമായ ഹാഷിംഗ് ഫംഗ്ഷൻ ഉണ്ട് - md5. ഈ അൽഗോരിതം ഡാറ്റ എടുക്കുകയും വിരലടയാളം നൽകുകയും ചെയ്യുന്നു.
അതിനാൽ, ഞങ്ങൾക്ക് ഉപയോക്താവിൽ നിന്ന് ഡാറ്റ ലഭിക്കുന്നു, അത് ശൂന്യമാണോ എന്ന് പരിശോധിക്കുക, അതിൽ ഞങ്ങൾക്ക് ആവശ്യമില്ലാത്ത പ്രതീകങ്ങളൊന്നും അടങ്ങിയിട്ടില്ലെങ്കിൽ (ഉപയോക്താക്കളെ വളരെയധികം പരിമിതപ്പെടുത്തരുത്). ഇപ്പോൾ ഞങ്ങൾ ഇതുപോലെ ഒരു അഭ്യർത്ഥന നടത്തുന്നു:
`ഉപയോക്താക്കൾ` (`id`,`ഉപയോക്തൃനാമം`,`പാസ്വേഡ്`) മൂല്യങ്ങൾ ("",$quoted_username,MD5($quoted_password)) എന്നതിലേക്ക് തിരുകുക;
വേരിയബിളുകൾക്ക് ഞാൻ പ്രത്യേകമായി $quoted_ എന്ന് പേരിട്ടത് ശ്രദ്ധിക്കുക, കാരണം അവ അന്വേഷണത്തിലേക്ക് തിരുകുന്നതിന് മുമ്പ്, mysql_real_escape_string() ഫംഗ്ഷൻ ഉപയോഗിച്ച് അവ ഒഴിവാക്കണം. ഈ ഫംഗ്ഷൻ പലപ്പോഴും ഉപയോഗിക്കുന്നതും വളരെ ദൈർഘ്യമേറിയതുമായതിനാൽ (എനിക്ക് പി‌എച്ച്‌പി ആർക്കിടെക്റ്റുകളെ ഇഷ്ടമാണ്), ഇത് നിങ്ങളുടെ ഷെല്ലിൽ ഇടാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ഇതുപോലെ:
ഫംഗ്ഷൻ ഉദ്ധരണി($var) ( mysql_real_escape_string($var) തിരികെ നൽകുക; )
php-ൽ അംഗീകാരം
ഞങ്ങൾ ഒരു പുതിയ ഉപയോക്താവിനെ ചേർത്തു, ഇപ്പോൾ അയാൾക്ക് അംഗീകാരം ലഭിച്ചു. ഞങ്ങൾ അവനെ ഒരു ലോഗിൻ-പാസ്വേഡ് ഫോം വരച്ച് അവന്റെ ഡാറ്റ പിടിക്കുന്നു. അടുത്തത് എന്താണ്? എല്ലാത്തിനുമുപരി, ഞങ്ങൾക്ക് വ്യക്തമായ വാചകത്തിൽ പാസ്വേഡ് ലഭിച്ചു, കൂടാതെ ഡാറ്റാബേസിൽ പാസ്‌വേഡിന്റെ ഒരു ഹാഷ് ഉണ്ട്. ഞാൻ പാസ്വേഡ് ഒരു ഹാഷിലേക്ക് പരിവർത്തനം ചെയ്ത് അവ താരതമ്യം ചെയ്യേണ്ടതുണ്ടോ? ഇല്ല, നിങ്ങൾക്ക് ഇത് ലളിതമായി ചെയ്യാൻ കഴിയും - ഒരു അഭ്യർത്ഥനയിൽ.
`ലോഗിൻ`=$qoted_login & `password`=MD5($quoted_password) എവിടെനിന്ന് `ഉപയോക്താക്കളിൽ` നിന്ന് തിരഞ്ഞെടുക്കുക;
ചോദ്യം ഒരു സ്ട്രിംഗ് നൽകുന്നുവെങ്കിൽ, അത് ഉപയോക്തൃ ഡാറ്റയുള്ള ഒരു സ്ട്രിംഗ് ആയിരിക്കും. ഇല്ലെങ്കിൽ, പട്ടികയിൽ അത്തരമൊരു ഉപയോക്താവ് ഇല്ല. ഉപയോക്തൃ ഡാറ്റ ഞങ്ങൾക്ക് വളരെ ഉപയോഗപ്രദമാകും - ഇത് ഒരു അസോസിയേറ്റീവ് അറേയിൽ ഉൾപ്പെടുത്തുന്നത് മൂല്യവത്താണ്.
ഉപയോക്താവിനെ ഓർക്കുക
ഉപയോക്താവിന് അധികാരമുണ്ടെന്നും അത് ആരാണെന്ന് കൃത്യമായി അറിയാമെന്നും ഇപ്പോൾ നമ്മൾ ഓർക്കേണ്ടതുണ്ട്. ഇതിനായി കുക്കികൾ ഉപയോഗിക്കുക എന്നതാണ് ആദ്യം മനസ്സിൽ വരുന്നത്. തീർച്ചയായും, ഉപയോക്താവിന്റെ ലോഗിൻ, ഐഡി എന്നിവ കുക്കികളിൽ ഇടുക, ഇപ്പോൾ ആരാണ് പേജ് അഭ്യർത്ഥിക്കുന്നതെന്ന് എപ്പോഴും അറിയുക.
എന്നാൽ ഇതൊരു മോശം ശീലമാണ്. എന്തുകൊണ്ട്? കാരണം, ഉപയോക്താവിന്റെ ബ്രൗസറിൽ സംഭരിച്ചിരിക്കുന്ന ഒരു ഫയലാണ് കുക്കി, ഈ ഫയലിൽ നിന്നുള്ള ഡാറ്റ എല്ലാ അഭ്യർത്ഥനകളിലും സെർവറിലേക്ക് കൈമാറുന്നു. ഒന്നാമതായി, അവ വാചകമായി കൈമാറ്റം ചെയ്യപ്പെടുന്നു, അതായത് അവ തടസ്സപ്പെടുത്താൻ എളുപ്പമാണ്. രണ്ടാമതായി, ഇത് ഉപയോക്താവ് അയച്ച ലളിതമായ വാചകമാണ്. അതിനാൽ, ഇത് അക്ഷരാർത്ഥത്തിൽ മാറ്റിയെഴുതാം. ഉദാഹരണത്തിന്, "വസ്യ" എന്ന ഉപയോക്തൃനാമം കുക്കികളിൽ സംഭരിക്കാൻ ഞങ്ങൾ തീരുമാനിക്കുകയാണെങ്കിൽ, അയാൾക്ക് അവന്റെ ബ്രൗസറിൽ കുക്കി മാനേജ്മെന്റ് തുറക്കാനും ആവശ്യമുള്ള കുക്കി കണ്ടെത്തി അതിനെ "അഡ്മിൻ" എന്ന് മാറ്റാനും കഴിയും. അത്രയേയുള്ളൂ. ഇപ്പോൾ, ഓരോ അഭ്യർത്ഥനയ്‌ക്കൊപ്പവും, ഞങ്ങൾക്ക് ഒരു കുക്കി ലഭിക്കും, അത് ഉപയോക്താവിന്റെ ഉപയോക്തൃനാമം - “അഡ്മിൻ” ഞങ്ങളോട് പറയും.
അതിനാൽ, വെബിൽ നിന്ന് ആക്സസ് ചെയ്യാൻ കഴിയാത്ത സ്ഥലത്ത് സെർവറിലെ എല്ലാ ഡാറ്റയും സംഭരിക്കുന്നത് സുരക്ഷിതമാണ്. ബ്രൗസറിൽ നിന്ന് ആക്സസ് ചെയ്യാൻ കഴിയാത്ത ചില ഫോൾഡറിൽ. ഉപയോക്താവിനെക്കുറിച്ചുള്ള എല്ലാ ഡാറ്റയും ഈ ഫോൾഡറിലേക്ക് എഴുതുകയും അവൻ ഒരു ഡോക്യുമെന്റ് അഭ്യർത്ഥിക്കുമ്പോഴെല്ലാം അവിടെ നിന്ന് വായിക്കുകയും വേണം. ഏത് ഡാറ്റാ ഫയലിന്റെ ഉടമയാണ് ഉപയോക്താവെന്ന് കണ്ടെത്തുന്നതിന്, നിങ്ങൾ ഫയലിനെ ഒരു അദ്വിതീയ നാമം എന്ന് വിളിക്കുകയും ഈ പേര് ഉപയോക്താവിന്റെ കുക്കികളിലേക്ക് ഇടുകയും വേണം. അതിനാൽ, അഡ്മിൻ ഉപയോക്താവിനുള്ള ഫയലിന്റെ പേര് ഉപയോക്താവിന് കണ്ടെത്താൻ കഴിയില്ല - ഈ ഫയൽ സെർവറിലെ സിസ്റ്റം സൃഷ്ടിച്ചതാണ്. കൂടാതെ, പ്രമാണത്തിൽ നിന്ന് പ്രമാണത്തിലേക്ക് പാസ്‌വേഡുകൾ വ്യക്തമായ വാചകത്തിൽ വലിച്ചിടാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.
ഞാൻ വിവരിച്ചത് സെഷൻ സംവിധാനം. ഉദാഹരണത്തിന്, Perl-ൽ, സെഷനുകൾ ഉപയോഗിക്കുന്നതിന് നിങ്ങൾ മൊഡ്യൂളുകൾ ലോഡ് ചെയ്യേണ്ടതുണ്ട്. കൂടാതെ PHP സെഷനുകളിൽ ബോക്‌സിന് പുറത്ത് പിന്തുണയ്‌ക്കുന്നു. വാസ്തവത്തിൽ, നിങ്ങൾക്ക് അറിയേണ്ടത് സെഷൻ_സ്റ്റാർട്ട്() ഫംഗ്‌ഷനും $_SESSION അറേയുമാണ്. ഇതാണ് എല്ലാം. ഞാൻ ഇപ്പോൾ പറയാം.
നിങ്ങൾ ഒരു സെഷനിൽ എഴുതുകയോ വായിക്കുകയോ ചെയ്യുന്ന എല്ലാ സ്ക്രിപ്റ്റിലും, നിങ്ങൾക്കാവശ്യമുണ്ട് നിങ്ങൾ എന്തെങ്കിലും വിവരം ഔട്ട്പുട്ട് ചെയ്യുന്നതിന് മുമ്പ്സെഷൻ_സ്റ്റാർട്ട്() ഫംഗ്ഷൻ വിളിക്കുക. ഇത് സെഷൻ ആരംഭിക്കും. ഈ ഫംഗ്ഷൻ നിലവിലില്ലെങ്കിൽ ഒരു സെഷൻ ഫയൽ സൃഷ്ടിക്കും അല്ലെങ്കിൽ സ്‌ക്രിപ്‌റ്റിലേക്ക് ഒരു പ്രത്യേക കുക്കി നൽകിയാൽ അത് വായിക്കും.
ഒരു സെഷനിലേക്ക് ഡാറ്റ എഴുതാൻ, നിങ്ങൾ അത് $_SESSION അറേയിൽ എഴുതേണ്ടതുണ്ട്. ഇനി നമ്മൾ യൂസർ ഐഡി ഓർക്കണം.
$_SESSION["userid"] = $userinfo["id"];
എല്ലാം. ഇപ്പോൾ, ഓരോ തവണയും ഒരു ഉപയോക്താവ് സെഷനുകൾ ഉപയോഗിക്കുന്ന ഒരു സ്ക്രിപ്റ്റ് അഭ്യർത്ഥിക്കുമ്പോൾ, $_SESSION["userid"] ഘടകത്തിന്റെ മൂല്യം നിങ്ങൾക്ക് ലഭ്യമാകും.
അതിനാൽ, ഉപയോക്താവ് അവന്റെ ലോഗിനും പാസ്‌വേഡും നൽകിയപ്പോൾ, ഡാറ്റാബേസിൽ നിന്ന് ഞങ്ങൾക്ക് അവന്റെ ഡാറ്റ ലഭിച്ചു, അത്തരമൊരു ഉപയോക്താവ് ഞങ്ങളുടെ ഡാറ്റാബേസിൽ ഉണ്ടെന്ന് സ്ഥിരീകരിക്കുന്നു, ഞങ്ങൾ അവനെ സെഷനിൽ ഓർക്കുന്നു.
ഉപയോക്താവിന് അധികാരമുണ്ടോ എന്ന് കണ്ടെത്തുക
ശരി, ഇത് pears ഷെല്ലിംഗ് പോലെ എളുപ്പമാണ്! സെഷനുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഇപ്പോൾ നിങ്ങൾക്കറിയാം, ഒരു ഉപയോക്താവിന് അംഗീകൃതമാണോ എന്ന് കണ്ടെത്തുന്നത് ഒരു വരിയുടെ കാര്യമാണ്. ഇതാ അവൾ:
എങ്കിൽ(isset($_SESSION["userid"])) ("ഉപയോക്താവിന് അധികാരമുണ്ട്" എന്ന് അച്ചടിക്കുക; )
സെഷനിൽ ഒരു ഉപയോക്തൃ ഐഡി നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, അവൻ ഇതിനകം അംഗീകാരം നൽകിക്കഴിഞ്ഞു. എന്നാൽ ഇത് ഏത് ഉപയോക്താവാണെന്ന് നിങ്ങൾക്ക് എങ്ങനെ കണ്ടെത്താനാകും? അവന്റെ ലോഗിൻ എന്താണ്? ജനനത്തീയതി? ഒരു ബാങ്ക് കാർഡിനുള്ള കോഡ് വാക്ക്? അമ്മയുടെ വിളിപ്പേര്?
ശരി, വ്യക്തമായും - ഉപയോക്തൃ പട്ടികയിലേക്ക് ഒരു അന്വേഷണം നടത്തുക. ഈ ഉപയോക്താവിന്റെ ഐഡിയും ഞങ്ങളുടെ പക്കലുണ്ട്.
തിരഞ്ഞെടുക്കുക * `ഉപയോക്താക്കൾ` എവിടെ `id`=$quoted_userid
ഒരു ഉപയോക്താവിനെ എങ്ങനെ ലോഗ് ഔട്ട് ചെയ്ത് ലോഗ് ഔട്ട് ചെയ്യാം
ശരി, ഇത് വളരെ ലളിതമാണ്. സെഷനിൽ userid സാന്നിധ്യമുണ്ടോ എന്ന് ഞങ്ങൾ നിർണ്ണയിക്കുകയാണെങ്കിൽ, അവനെ ലോഗ് ഔട്ട് ചെയ്യുന്നതിന് അവിടെ നിന്ന് അവനെ നീക്കം ചെയ്യേണ്ടതുണ്ട്. ഇത് ഇതുപോലെ ചെയ്തു:
സജ്ജീകരിക്കാത്തത്($_SESSION["userid"]);
നിങ്ങൾക്ക് ഉറപ്പിക്കാൻ സെഷൻ കൊല്ലാനും കഴിയും. ഇത് ഉപയോക്താവിന്റെ കുക്കി മായ്‌ക്കുകയും സെർവറിലെ സെഷൻ ഫയൽ നശിപ്പിക്കുകയും ചെയ്യും. ഈ സാഹചര്യത്തിൽ, അതിൽ നിന്ന് എല്ലാ ഡാറ്റയും നഷ്ടപ്പെടും. ഇത് ഇതുപോലെ ചെയ്തു:
Session_destroy();
അത്രയേയുള്ളൂ. നിങ്ങൾക്ക് എന്തെങ്കിലും ചോദ്യങ്ങളുണ്ടെങ്കിൽ, ഞങ്ങളെ ബന്ധപ്പെടാൻ മടിക്കരുത്. മാത്രമല്ല, നിങ്ങൾക്ക് icq അല്ലെങ്കിൽ മെയിൽ വഴി എന്നെ ബന്ധപ്പെടാനും എന്തെങ്കിലും സഹായം ആവശ്യപ്പെടാനും കഴിയും. ഞാൻ സാധാരണയായി നിരസിക്കാറില്ല. നിങ്ങൾക്ക് ഗുരുതരമായ സഹായം ആവശ്യമുണ്ടെങ്കിൽ, ഞാൻ ഒരു ചെറിയ പേയ്‌മെന്റ് ആവശ്യപ്പെടാം. കൂടാതെ, വിദൂരമായി വെബ്‌സൈറ്റുകൾ എങ്ങനെ നിർമ്മിക്കാമെന്ന് എനിക്ക് നിങ്ങളെ പഠിപ്പിക്കാൻ കഴിയും! ഞാൻ അത്തരത്തിലുള്ള പരിശീലകനും ഗുരുവുമാണ് :) കൂടാതെ നിങ്ങൾക്ക് അത്തരത്തിലുള്ള പാഠങ്ങളും തന്ത്രങ്ങളും ലഭിക്കണമെങ്കിൽ, സൗജന്യമായി, എന്റെ ബ്ലോഗിന്റെ RSS-ലേക്ക് സബ്‌സ്‌ക്രൈബുചെയ്യുക.
ലാപ്‌ടോപ്പ് അറ്റകുറ്റപ്പണികൾ ന്യായമായ വിലയിൽ വാഗ്ദാനം ചെയ്യുന്ന ibooknet.ru ആണ് ഈ പോസ്റ്റ് സ്പോൺസർ ചെയ്യുന്നത്. വ്യക്തിപരമായി, എന്റെ ലാപ്‌ടോപ്പ് മികച്ചതാണ്, അത് ശരിയാക്കേണ്ടതില്ലെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. നിങ്ങൾക്കും ഞാൻ അത് തന്നെ ആശംസിക്കുന്നു.
