Įdiekite savo SecurityController
Interneto agentūra » Skaitmeninės naujienos » Įdiekite savo SecurityController

Įdiekite savo SecurityController

Neseniai savo įmonei parašiau straipsnį apie vartotojų valdymą ir jų autentifikavimą naudojant „Symfony2 Core“, taigi be „FOSUserBundle“. Po šiuo jau turtingu pirmuoju straipsniu norėjau aprašyti ne mažiau naudingą antrąją dalį, kuri leis mums greitai nustatyti esmines funkcijas, būtent iš naujo nustatyti slaptažodį, pakeisti slaptažodį, patvirtinti paskyrą ar net užsiregistruoti. Veiksmai tokie pat svarbūs, kai turite vartotojus tvarkančią sistemą.

Nustatykite SecurityController

Pirma, jei nesilaikėte pirmosios vartotojo valdymo nustatymo pamokos, patariu pasidomėti. Jei laikysitės sprendimo, logiškai turėtumėte turėti SecurityController ar ką nors kita. Mano atveju turiu tik tris metodus, iš kurių tik vienas yra tikrai tinkamas naudoti.

  1. prisijungimo veiksmas
    Šis metodas sujungia vartotoją.
  2. checkVeiksmas
    Šis metodas tiesiog leidžia deklaruoti ugniasienės maršrutą, leidžiantį vartotojui prisijungti serverio pusėje.
  3. atsijungimasVeiksmas
    Šis metodas naudojamas ugniasienės maršrutui deklaruoti, leidžiantį atjungti vartotoją.

Atidarykite mūsų platformą naujiems vartotojams

Būtų ypač įdomu, jei mūsų vartotojai galėtų prisijungti ir iš anksto užsiregistruoti.

Pirmiausia sugeneruojame formą su informacija, kurios norite paklausti savo vartotojo.

Kalbant apie formą, kurią naudosite registruodami savo vartotoją, žinok, kad laukas slaptažodis neturėtų būti jūsų formoje. Tačiau turėsite pridėti du laukus " ne žemėlapiuose kad norimas slaptažodis būtų įvestas du kartus.

1
2
3
4
5
6
7
8
9
10
11
12
13
/ **
 * @metodas({"GAUTI"})
 * @Kelias(„/registras“, vardas=“registras“)
 * @Saugu(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
 * @Šablonas()
 */
visuomenės funkcija registruotis()
{
    $forma = $ tai->sukurti formą(Naujas produktas Vartotojo tipas (Vartotojo tipas:: REGISTRACIJA), Naujas produktas Vartotojas());
    grįžti masyvas(
        "forma" => $form->createView(),
        );
}

Tada, kai jūsų vartotojas grįš su užpildyta forma, turėsime jį užregistruoti arba atmesti jo failą :p

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/ **
* @metodas({"POST"})
* @Kelias("/Registruotis")
* @Saugu(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
* @Šablonas()
*/
visuomenės funkcija registruotisDabar(Užklausa $request)
{
$params = $užklausa->užklausa->visi()[„mano_formos_vardas“];
$forma = $ tai->sukurti formą(Naujas produktas Vartotojo tipas (Vartotojo tipas:: REGISTRACIJA), Naujas produktas Vartotojas());
$forma->pateikti($užklausa);
if (masyvas_raktas_egzistuoja(„paprastas_slaptažodis“, $params) && masyvo_key_exists("paprastas_slaptažodis2", $params) && $params[„paprastas_slaptažodis“] == $params["paprastas_slaptažodis2"]) {
if ($form->isValid()) {
$duomenys = $form->getData();
$data->setPassword($ tai->konteineris->gauti(„security.encoder_factory“)->getEncoder($data)->encodePassword($params[„paprastas_slaptažodis“], $duomenys->getSalt()));
$em->persist($duomenys);
$em->flush();
grįžti $ tai->peradresuoti($ tai->generateUrl("Prisijungti", masyvas("žinutė" => „Gavote el. laišką, kad patvirtintumėte savo paskyrą. »)));
}
}
grįžti masyvas(
"klaidos" => $params[„paprastas_slaptažodis“] == $params["paprastas_slaptažodis2"]? $form->getErrors(): masyvas(„Du slaptažodžiai turi būti vienodi“),
"forma" => $form->createView(),
);
}

Čia mes greitai papasakosime apie darbo eiga užregistruoti naują vartotoją.

  1. Mes žiūrime jei visi privalomi laukai įvesti teisingai, įskaitant du „slaptažodžio“ laukus ir jei pastarieji du yra identiški.
  2. Užkoduojame slaptažodį ir mes jį „nustatome“ esybėje.
  3. Bet kokios klaidos atveju grąžiname formą su klaida, kuri, mūsų nuomone, turėtų būti išsami.

Sukurkite funkciją, kad iš naujo nustatytumėte slaptažodį

Dabar jūsų vartotojas gali prisijungti, bet ką darysime, jei jis prarastų slaptažodį. Akivaizdu, kad neketiname nustatyti kontaktinio el. pašto adreso, skirto jo nenaudingoms operacijoms.

Kaip matėte aukščiau, kiekvienai savo funkcijai paprastai deklaruoju du metodus: vienas iš mano metodų yra atsakingas už peržiūros, sukurtos gavus užklausą, valdymą. GET ir prašymo rezultatas POST. Šiuos du metodus galite visiškai sujungti į vieną ir tą patį metodą.

1
2
3
4
5
6
7
8
9
/ **
  * @metodas({"GAUTI"})
  * @Kelias(„/reset“, pavadinimas=“atstatyti“)
  * @Saugu(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
  * @Šablonas()
  */
  visuomenės funkcija iš naujo() {
   grįžti masyvas();
  }

Antrame etape paskelbsime papildomą užklausų valdymo metodą POST.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/ **
* @metodas({"POST"})
* @Kelias(„/atstatyti“)
* @Saugu(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
*/
visuomenės funkcija ResetNow(Užklausa $request)
{
$params = $užklausa->užklausa->visi();
if (!masyvas_key_exists("Prisijungti", $params)) {
mesti Naujas produktas Išimtis(„Prisijungimas nesuteiktas“);
}
$login = &$params["Prisijungti"];
$em = $ tai->konteineris->gauti(„doctrine.orm.default_entity_manager“);
$user = $em->getRepository(„NamespaceMyBundle:User“)->findOneBy(masyvas("Prisijungti" => $prisijungti));
if ($ vartotojas == null) {
grįžti $ tai->peradresuoti($ tai->generateUrl("Prisijungti", masyvas()));
}
$slaptažodis = „myRandowPassword“;
$user->setPassword($ tai->konteineris->gauti(„security.encoder_factory“)->getEncoder($user)->encodePassword($slaptažodis, $user->getSalt()));
$em->persist($vartotojas);
$em->flush();
// Slaptažodį siunčiame el. paštu
grįžti $ tai->peradresuoti($ tai->generateUrl("Prisijungti", masyvas()));
}

Šis metodas buvo skirtas atstatyti vartotojo, kuris jį pateikė, slaptažodį prisijungimas / vartotojo vardas. Mano atveju slaptažodis buvo išsiųstas el. paštu. Leisiu jums pridėti tą galantišką eilutę.

  1. Taigi mes einame paieškos vartotojas.
  2. Sugeneruojame slaptažodį kad mes ateiname informuoti vartotoją, kai jis užkodavo pagal jūsų nustatytas taisykles.

Nustatykite slaptažodžio keitimą

Šiuo metu mūsų vartotojas gali sugeneruoti naują slaptažodį, jei jis buvo prarastas, bet jei jis tiesiog nori jį pakeisti, mums reikia vartų, kad nustatytų vartus.

1
2
3
4
5
6
7
8
9
/ **
* @metodas({"GAUTI"})
* @Kelias(„/pakeisti“, pavadinimas=„pakeisti slaptažodį“)
* @Saugu(roles=”IS_AUTHENTICATED_FULLY”)
* @Šablonas()
*/
visuomenės funkcija keisti() {
grįžti masyvas();
}

Čia yra kodas, skirtas sukurti rodinį. Pirmiausia turėsite įvesti savo senąjį slaptažodį, tada du kartus įveskite naują slaptažodį. Antrą kartą patvirtinimas.

Dabar pamatysime kodą iš naujo nustatantis slaptažodį. THE procesas yra panašus į naujo atsitiktinio slaptažodžio generavimą.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/ **
 * @metodas({"POST"})
 * @Kelias(„/pakeisti“)
 * @Saugu(roles=”IS_AUTHENTICATED_FULLY”)
 * @Šablonas()
 */
visuomenės funkcija pakeisti Dabar(Užklausa $request)
{
    $params = $užklausa->užklausa->visi();
    if (!masyvas_key_exists("dabartinis", $params)
        || !masyvo_key_exists("naujas", $params)
        || !masyvo_key_exists("naujas2", $params))
    {
        grįžti masyvas("klaida" => „Prašome užpildyti visus laukus“);
    }
    $em = $ tai->konteineris->gauti(„doctrine.orm.default_entity_manager“);
    $vartotojas = $ tai->getUser();
    $user_encoders = $ tai->konteineris->gauti(„security.encoder_factory“)->getEncoder($vartotojas);
    $user_repository = $em->getRepository(„NamespaceMyBundle:User“);
    $current_password_encoded = $user_encoders->encodePassword($params["dabartinis"], $user->getSalt());
    $new_password_encoded = $user_encoders->encodePassword($params["naujas"], $user->getSalt());
    if ($user_repository->findOneBy(masyvas("Slaptažodis" => $dabartinis_slaptažodis_užkoduotas)) == null) {
        grįžti masyvas("klaida" => „Dabartinis slaptažodis neteisingas“);
    } elseif ($params["naujas"] != $params["naujas2"]) {
        grįžti masyvas("klaida" => „Dviejų laukų slaptažodis nėra tas pats“);
    }
    $user->setPassword($new_password_encoded);
    $em->persist($vartotojas);
    $em->flush();
    grįžti $ tai->peradresuoti($ tai->generateUrl("Atsijungti", masyvas()));
}

Jei kodą perskaitysite 1 minutę, pamatysite, kad tai ypač paprasta.

  1. Pirmiausia patikriname, ar teisingai įvesti trys laukai (senas slaptažodis, naujas slaptažodis ir patvirtinimas).
  2. On įveskite slaptažodį srovės ir lyginame jį su dabartiniu slaptažodžiuduomenų bazėje, kad pamatytumėte, ar jis atitinka įvestą seną slaptažodį.
  3. Mes patikriname, ar yra „du“ nauji slaptažodžiai identiškas.
  4. Įveskite naują slaptažodį ir stumti esybėje.

Jo paskyros aktyvinimas

Ši funkcija nėra išsamiai aprašyta kitose fragmentus aukščiau. Jos tikslas – atblokuoti ką tik užsiregistravusį vartotoją, kai jis, pavyzdžiui, patvirtino savo el. Ši funkcija sukurta beveik visose mums žinomose platformose dėl kelių priežasčių. Norint nustatyti vartotojo blokavimą, taip pat gali reikėti įdiegti paslaugų teikėją.

  • blokas/limit paskyros padirbtas ir apie šlamštą.
  • Vérifier kad vartotojas įvedė el. pašto adresą, kuris iš pirmo žvilgsnio atrodo tinkamas naudoti.
  • Pašalinti sąskaitos, kurios nebuvo patvirtintos po tam tikro laiko.

Darbo eigos

  1. Vartotojas užsiregistruoja. Tada jo paskyra užblokuojama per jums skirtą lauką. Tada šis laukas turėtų neleisti jam prisijungti, kol šis laukas rodo, kad paskyra išjungta.
1
2
3
4
5
6
7
8
// NamespaceMyBundleEntityUser
klasė vartotojas {
visuomenės funkcija __konstruoti() {
$ tai->token = maiša(„sha512“, uniqid());
}
...
}
1
$user->setEnabled(klaidingas);
  1. Vartotojas gavo el. laišką, kai jo profilis buvo nuplaukite duomenų bazėje. Šis el. laiškas turi būti jūsų sugeneruoto adreso dalis.
    Šiame kelyje a token arba turi būti suteiktas unikalus identifikatorius, leidžiantis rasti atitinkamą vartotoją. Patariu naudoti UUID4, kuris yra atsitiktinis. Galite rasti UUID sąrašą ir visų versijų aprašymą.
1
2
3
4
/ **
* @Kelias(„/aktyvinti“, pavadinimas=„aktyvinti“)
*/
visuomenės funkcija įjungtas() {…}
1
$ tai->generateUrl(„aktyvuoti“, masyvas(« token » => $vartotojas->gautiToken()), tiesa);

Turėtumėte turėti tokį URL.

1
http://hostname/aktyvinti?token=mano unikalusToken
  1. Vartotojas atidaro savo el. laišką ir bando suaktyvinti savo paskyrą spustelėdamas pateiktą nuorodą. Tada įvedame toliau pateiktą procesą.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/ **
 * @metodas({"GAUTI"})
 * @Kelias(„/aktyvinti“, pavadinimas=„aktyvinti“)
 * @Saugu(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
 * @Šablonas()
 */
visuomenės funkcija įjungtas(Užklausa $request) {
    $params = masyvas();
    $token = $request->query->get(« token »);
    $em = $ tai->konteineris->gauti(„doctrine.orm.default_entity_manager“);
$user = $em->getRepository(„NamespaceMyBundle:User“)->findOneBy(masyvas(« token » => $token));
    if ($ vartotojas != null) {
        $user->setEnabled(tiesa);
        $em->persist($vartotojas);
        $em->flush();
        $params[„aktyvuoti“🇧🇷 tiesa;
    } kitas {
        $params[„aktyvuoti“🇧🇷 klaidingas;
    }
    grįžti $params;
}

Atlikdami šį procesą, jums neturėtų kilti problemų įgalinant vartotojo abonemento patvirtinimą.

Šį lygiavertį kodą galite rasti šioje esmėje.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
<?php
naudojimas J.M.S.Security ExtraBundleAnotacijaUžtikrinti;
naudojimas SensioPluoštasFrameworkExtraBundleKonfigūracijaSiuntimas;
naudojimas SensioPluoštasFrameworkExtraBundleKonfigūracijaMaršrutas;
naudojimas SensioPluoštasFrameworkExtraBundleKonfigūracijašablonas;
naudojimas SymfonyPluoštasFrameworkBundlekontrolieriuskontrolierius;
naudojimas SymfonyKomponentasHttpFoundationPrašymas;
naudojimas SymfonyKomponentassaugumasEsmėSecurityContext;
klasė SecurityController tęsiasi kontrolierius
{
/ **
* @metodas({"GAUTI"})
* @Kelias(„/login“, vardas=“prisijungti“)
* @Šablonas()
*/
visuomenės funkcija Vartotoją(Užklausa $request)
{
$užklausa = $ tai->getRequest();
$sesija = $request->getSession();
if ($request->attributes->has(SecurityContext::AUTHENTICATION_ERROR)) {
$klaida = $request->tributes->get(SecurityContext::AUTHENTICATION_ERROR);
} kitas {
$klaida = $sesija->gauti(SecurityContext::AUTHENTICATION_ERROR);
$session->remove(SecurityContext::AUTHENTICATION_ERROR);
}
$params = masyvas(
„last_username“ => $session->get(SecurityContext::LAST_USERNAME),
"klaida" => $klaida,
"žinutė" => $užklausa->gauti("žinutė"),
);
if ($request->isXmlHttpRequest()) {
grįžti $ tai->pateikti(„GCDirectoryMainBundle:Security:login-ajax.html.twig“, $params);
}
grįžti $params;
}
/ **
* @metodas({"POST"})
* @Kelias(„/login_check“, pavadinimas=“login_check“)
*/
visuomenės funkcija tikrinti()
{
mesti Naujas produktas RuntimeException(„Turite sukonfigūruoti patikrinimo kelią, kurį apdorotų ugniasienė, naudodami form_login saugos užkardos konfigūracijoje.“);
}
/ **
* @metodas({"GAUTI"})
* @Kelias(„/logout“, pavadinimas=“atsijungti“)
*/
visuomenės funkcija Atsijungti()
{
mesti Naujas produktas RuntimeException(„Turite suaktyvinti atsijungimą saugos užkardos konfigūracijoje“.);
}
/ **
* @metodas({"GAUTI"})
* @Kelias(„/reset“, pavadinimas=“atstatyti“)
* @Saugu(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
* @Šablonas()
*/
visuomenės funkcija iš naujo() {
grįžti masyvas();
}
/ **
* @metodas({"POST"})
* @Kelias(„/atstatyti“)
* @Saugu(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
*/
visuomenės funkcija ResetNow(Užklausa $request)
{
$params = $užklausa->užklausa->visi();
if (!masyvas_key_exists("Prisijungti", $params)) {
mesti Naujas produktas Išimtis(„Prisijungimas nesuteiktas“);
}
$login = &$params["Prisijungti"];
$em = $ tai->konteineris->gauti(„doctrine.orm.default_entity_manager“);
$user = $em->getRepository(„NamespaceMyBundle:User“)->findOneBy(masyvas("Prisijungti" => $prisijungti));
if ($ vartotojas == null) {
grįžti $ tai->peradresuoti($ tai->generateUrl("Prisijungti", masyvas()));
}
$slaptažodis = „myRandowPassword“;
$user->setPassword($ tai->konteineris->gauti(„security.encoder_factory“)->getEncoder($user)->encodePassword($slaptažodis, $user->getSalt()));
$em->persist($vartotojas);
$em->flush();
grįžti $ tai->peradresuoti($ tai->generateUrl("Prisijungti", masyvas()));
}
/ **
* @metodas({"GAUTI"})
* @Kelias(„/pakeisti“, pavadinimas=„pakeisti slaptažodį“)
* @Saugu(roles=”IS_AUTHENTICATED_FULLY”)
* @Šablonas()
*/
visuomenės funkcija keisti() {
grįžti masyvas();
}
/ **
* @metodas({"POST"})
* @Kelias(„/pakeisti“)
* @Saugu(roles=”IS_AUTHENTICATED_FULLY”)
* @Šablonas()
*/
visuomenės funkcija pakeisti Dabar(Užklausa $request)
{
$params = $užklausa->užklausa->visi();
if (!masyvas_key_exists("dabartinis", $params)
|| !masyvo_key_exists("naujas", $params)
|| !masyvo_key_exists("naujas2", $params))
{
grįžti masyvas("klaida" => „Prašome užpildyti visus laukus“);
}
$em = $ tai->konteineris->gauti(„doctrine.orm.default_entity_manager“);
$vartotojas = $ tai->getUser();
$user_encoders = $ tai->konteineris->gauti(„security.encoder_factory“)->getEncoder($vartotojas);
$user_repository = $em->getRepository(„NamespaceMyBundle:User“);
$current_password_encoded = $user_encoders->encodePassword($params["dabartinis"], $user->getSalt());
$new_password_encoded = $user_encoders->encodePassword($params["naujas"], $user->getSalt());
if ($user_repository->findOneBy(masyvas("Slaptažodis" => $dabartinis_slaptažodis_užkoduotas)) == null) {
grįžti masyvas("klaida" => „Dabartinis slaptažodis neteisingas“);
} elseif ($params["naujas"] != $params["naujas2"]) {
grįžti masyvas("klaida" => „Dviejų laukų slaptažodis nėra tas pats“);
}
$user->setPassword($new_password_encoded);
$em->persist($vartotojas);
$em->flush();
grįžti $ tai->peradresuoti($ tai->generateUrl("Atsijungti", masyvas()));
}
/ **
* @metodas({"GAUTI"})
* @Kelias(„/registras“, vardas=“registras“)
* @Saugu(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
* @Šablonas()
*/
visuomenės funkcija registruotis()
{
$forma = $ tai->sukurti formą(Naujas produktas Vartotojo tipas (Vartotojo tipas:: REGISTRACIJA), Naujas produktas Vartotojas());
grįžti masyvas(
"forma" => $form->createView(),
);
}
/ **
* @metodas({"POST"})
* @Kelias("/Registruotis")
* @Saugu(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
* @Šablonas()
*/
visuomenės funkcija registruotisDabar(Užklausa $request)
{
$params = $užklausa->užklausa->visi()[„mano_formos_vardas“];
$forma = $ tai->sukurti formą(Naujas produktas Vartotojo tipas (Vartotojo tipas:: REGISTRACIJA), Naujas produktas Vartotojas());
$forma->pateikti($užklausa);
if (masyvas_raktas_egzistuoja(„paprastas_slaptažodis“, $params) && masyvo_key_exists("paprastas_slaptažodis2", $params) && $params[„paprastas_slaptažodis“] == $params["paprastas_slaptažodis2"]) {
if ($form->isValid()) {
$duomenys = $form->getData();
$data->setPassword($ tai->konteineris->gauti(„security.encoder_factory“)->getEncoder($data)->encodePassword($params[„paprastas_slaptažodis“], $duomenys->getSalt()));
$em->persist($duomenys);
$em->flush();
grįžti $ tai->peradresuoti($ tai->generateUrl("Prisijungti", masyvas("žinutė" => „Gavote el. laišką, kad patvirtintumėte savo paskyrą. »)));
}
}
grįžti masyvas(
"klaidos" => $params[„paprastas_slaptažodis“] == $params["paprastas_slaptažodis2"]? $form->getErrors(): masyvas(„Du slaptažodžiai turi būti vienodi“),
"forma" => $form->createView(),
);
}
/ **
* @metodas({"GAUTI"})
* @Kelias(„/aktyvinti“, pavadinimas=„aktyvinti“)
* @Saugu(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
* @Šablonas()
*/
visuomenės funkcija įjungtas(Užklausa $request) {
$params = masyvas();
$token = $request->query->get(« token »);
$em = $ tai->konteineris->gauti(„doctrine.orm.default_entity_manager“);
$user = $em->getRepository(„NamespaceMyBundle:User“)->findOneBy(masyvas(« token » => $token));
if ($ vartotojas != null) {
$user->setActive(Vartotojas::ACTIVE_ACTIVE);
$em->persist($vartotojas);
$em->flush();
$params[„aktyvuoti“🇧🇷 tiesa;
} kitas {
$params[„aktyvuoti“🇧🇷 klaidingas;
}
grįžti $params;
}
}

★ ★ ★ ★ ★