Valósítsa meg saját SecurityControllerét
Webügynökség » Digitális hírek » Valósítsa meg saját SecurityControllerét

Valósítsa meg saját SecurityControllerét

Nemrég írtam egy cikket a cégemnek a felhasználók kezeléséről és hitelesítésükről natívan a Symfony2 Core használatával, tehát FOSUserBundle nélkül. Ezt az amúgy is gazdag első cikket követően szerettem volna leírni egy második, hasonlóan hasznos részt, amely lehetővé teszi számunkra a lényeges funkciók gyors beállítását, nevezetesen a jelszó visszaállítását, a jelszó megváltoztatását, a fiók érvényesítését vagy akár a regisztrációt. A műveletek ugyanolyan nélkülözhetetlenek, ha a felhasználókat kezelő rendszerrel rendelkezik.

Állítson be egy SecurityControllert

Először is, ha még nem követte az első oktatóanyagot a felhasználókezelés beállításáról, azt tanácsolom, hogy vessen egy pillantást. Ha követted a megoldást, akkor logikailag kellene egy SecurityController vagy valami más. Az én esetemben csak három módszerem van, amelyek közül csak az egyik használható igazán.

  1. loginAction
    Ez a módszer összekapcsolja a felhasználót.
  2. checkAction
    Ez a módszer egyszerűen lehetővé teszi, hogy deklaráljon egy útvonalat a tűzfal számára, lehetővé téve a felhasználó számára a szerveroldali csatlakozást.
  3. kijelentkezésAction
    Ezzel a módszerrel deklarálható egy útvonal a tűzfal számára, amely lehetővé teszi a felhasználó leválasztását.

Nyissa meg platformunkat új felhasználók számára

Különösen érdekes lenne, ha felhasználóink ​​kapcsolódhatnának, és így előzetesen regisztrálhatnának.

Először létrehozzuk az űrlapot azokkal az információkkal, amelyeket a felhasználótól kérni szeretne.

A felhasználó regisztrálásához használt űrlappal kapcsolatban tudja, hogy a mező" jelszó ne legyen a te formádban. Ehhez azonban hozzá kell adnia két mezőt " nincs feltérképezve hogy a kívánt jelszót kétszer beírjuk.

1
2
3
4
5
6
7
8
9
10
11
12
13
/ **
 * @Módszer({"KAP"})
 * @Út(“/regiszter”, név=”regiszter”)
 * @Biztonságos(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
 * @Sablon()
 */
nyilvános funkció Regisztráció()
{
    $forma = $ ezt->createForm(új UserType(Felhasználótípus::REGISZTRÁCIÓ), új Felhasználó());
    visszatérés sor(
        "forma" => $form->createView(),
        );
}

Aztán amikor a felhasználó visszatér kitöltött űrlappal, regisztrálnunk kell őt, vagy el kell utasítanunk a fájlt :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
/ **
* @Módszer({"POST"})
* @Út("/Regisztráció")
* @Biztonságos(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
* @Sablon()
*/
nyilvános funkció regisztrálj most($request kérés)
{
$params = $kérelem->kérés->összes()[„az_űrlap_neve”];
$forma = $ ezt->createForm(új UserType(Felhasználótípus::REGISZTRÁCIÓ), új Felhasználó());
$form->submit($request);
if (tömb_kulcs_exists(„plain_password”, $params) && array_key_exists("sima_jelszó2", $params) && $params[„plain_password”] == $params["sima_jelszó2"]) {
if ($form->isValid()) {
$adat = $form->getData();
$data->setPassword($ ezt->container->get("security.encoder_factory")->getEncoder($data)->encodePassword($params[„plain_password”], $adat->getSalt()));
$em->persist($data);
$em->flush();
visszatérés $ ezt->átirányítás($ ezt->generateUrl("Belépés", sor("üzenet" => „E-mailt kapott a fiókja érvényesítésére. »)));
}
}
visszatérés sor(
"hibák" => $params[„plain_password”] == $params["sima_jelszó2"]? $form->getErrors(): sor("A két jelszónak azonosnak kell lennie"),
"forma" => $form->createView(),
);
}

Itt gyorsan részletezzük a munkafolyamat új felhasználó regisztrálásához.

  1. Nézzük ha az összes kötelező mezőt helyesen töltötte be, beleértve a két "jelszó" mezőt, és ha az utóbbi kettő azonos.
  2. A jelszót kódoljuk és „beállítjuk” az entitásban.
  3. Bármilyen hiba esetén visszaküldjük az űrlapot azzal a hibával, amelyet szerintünk részletezni kell.

Hozzon létre egy funkciót a jelszó visszaállításához

Mostantól a felhasználó bejelentkezhet, de mit tegyünk, ha elveszíti jelszavát. Nyilvánvaló, hogy nem fogunk felállítani egy kapcsolattartási e-mail-címet, amelyet a haszontalan műveletek számára szentelünk.

Amint fentebb láthatta, általában két módszert deklarálok minden funkciómhoz: az egyik metódusom a kérés nyomán létrehozott nézet kezeléséért felelős. GET és egy kérés eredménye POST. Ezt a két módszert abszolút összefűzheti egy és ugyanabban a metódusban.

1
2
3
4
5
6
7
8
9
/ **
  * @Módszer({"KAP"})
  * @Út(“/reset”, név=”reset”)
  * @Biztonságos(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
  * @Sablon()
  */
  nyilvános funkció vissza() {
   visszatérés sor,
  }

Második lépésben deklaráljuk a kéréseket kezelő kiegészítő módszert 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
/ **
* @Módszer({"POST"})
* @Út("/Visszaállítás")
* @Biztonságos(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
*/
nyilvános funkció resetNow($request kérés)
{
$params = $request->request->all();
if (!tömb_kulcs_exists("Belépés", $params)) {
dobás új kivétel("Nincs megadva bejelentkezés");
}
$login = &$params["Belépés"];
$em = $ ezt->container->get(„doctrine.orm.default_entity_manager”);
$user = $em->getRepository("NamespaceMyBundle:Felhasználó")->findOneBy(sor("Belépés" => $bejelentkezés));
if ($felhasználó == null) {
visszatérés $ ezt->átirányítás($ ezt->generateUrl("Belépés", sor()));
}
$jelszó = „myRandowPassword”;
$user->setPassword($ ezt->container->get("security.encoder_factory")->getEncoder($user)->encodePassword($password, $user->getSalt()));
$em->persist($user);
$em->flush();
// A jelszót e-mailben küldjük el
visszatérés $ ezt->átirányítás($ ezt->generateUrl("Belépés", sor()));
}

Ezt a módszert arra tervezték, hogy Visszaállítás annak a felhasználónak a jelszava, aki megadta a sajátját bejelentkezés/felhasználónév. Az én esetemben a jelszót ezután e-mailben küldték el. Hozzáteszem azt a gáláns sort.

  1. Szóval megyünk felhasználó keresése.
  2. Jelszót generálunk hogy értesítjük a felhasználót, ha az Ön által meghatározott szabályok szerint kódolt.

Jelszómódosítás beállítása

Ezen a ponton felhasználónk generálhat új jelszót, ha elveszett, de ha csak meg akarja változtatni, akkor szükségünk van egy kapura a kapu meghatározásához.

1
2
3
4
5
6
7
8
9
/ **
* @Módszer({"KAP"})
* @Út(„/módosítás”, név=”jelszó módosítása”)
* @Biztonságos(roles=”IS_AUTHENTICATED_FULLLY”)
* @Sablon()
*/
nyilvános funkció változik() {
visszatérés sor,
}

Itt található a nézet létrehozásához szükséges kód. Először meg kell adnia a régi jelszavát, majd kétszer az új jelszót. A második alkalommal megerősítés.

Most látni fogjuk a kódot resetter a jelszó. A folyamat hasonló egy új véletlenszerű jelszó generálásához.

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
/ **
 * @Módszer({"POST"})
 * @Út("/változás")
 * @Biztonságos(roles=”IS_AUTHENTICATED_FULLLY”)
 * @Sablon()
 */
nyilvános funkció változtasd meg most($request kérés)
{
    $params = $request->request->all();
    if (!tömb_kulcs_exists("jelenlegi", $params)
        || !array_key_exists("új", $params)
        || !array_key_exists("új2", $params))
    {
        visszatérés sor("hiba" => "Kérjük, töltse ki az összes mezőt");
    }
    $em = $ ezt->container->get(„doctrine.orm.default_entity_manager”);
    $felhasználó = $ ezt->getUser();
    $user_encoders = $ ezt->container->get("security.encoder_factory")->getEncoder($user);
    $user_repository = $em->getRepository("NamespaceMyBundle:Felhasználó");
    $current_password_encoded = $user_encoders->encodePassword($params["jelenlegi"], $user->getSalt());
    $new_password_encoded = $user_encoders->encodePassword($params["új"], $user->getSalt());
    if ($user_repository->findOneBy(sor("Jelszó" => $aktuális_jelszó_kódolt)) == null) {
        visszatérés sor("hiba" => „A jelenlegi jelszó rossz”);
    } elseif ($params["új"] != $params["új2"]) {
        visszatérés sor("hiba" => "A két mező jelszó nem ugyanaz");
    }
    $user->setPassword($new_password_encoded);
    $em->persist($user);
    $em->flush();
    visszatérés $ ezt->átirányítás($ ezt->generateUrl("Kijelentkezés", sor()));
}

Ha 1 percet vesz igénybe a kód elolvasására, látni fogja, hogy ez különösen egyszerű.

  1. Először ellenőrizzük, hogy a három mezőt (régi jelszó, új jelszó és megerősítés) helyesen adta-e meg.
  2. On írja be a jelszót jelenlegi és összehasonlítjuk a jelenlegi jelszóvalmentse az adatbázisban, hogy lássa, megfelel-e a beírt régi jelszónak.
  3. Ellenőrizzük, hogy a "két" új jelszó megvan-e azonos.
  4. Írja be az új jelszót és nyomja az entitásban.

Fiókja aktiválása

Ezt a funkciót máshol nem részletezik tökéletesen töredék felett. Célja, hogy feloldja a most regisztrált felhasználó blokkolását, amikor például érvényesítette az e-mailjét. Ezt a funkciót szinte az összes általunk ismert platformon fejlesztették több okból is. Egy felhasználó letiltásának beállításához szükség lehet egy szolgáltató megvalósítására is.

  • tömb/limit fiókok hamisítvány és spam.
  • ellenőrzés hogy a felhasználó egy első látásra használhatónak tűnő e-mail címet töltött be.
  • Távolítsuk olyan fiókok, amelyeket egy bizonyos idő elteltével nem ellenőriztek.

munkafolyamat

  1. Egy felhasználó regisztrál. Fiókját ezután egy Önre vonatkozó mezőben blokkolják. Ennek a mezőnek meg kell akadályoznia a csatlakozást mindaddig, amíg ez a mező azt jelzi, hogy a fiók le van tiltva.
1
2
3
4
5
6
7
8
// NamespaceMyBundleEntityUser
osztály használó {
nyilvános funkció __konstruálni() {
$ ezt->token = hash("sha512", uniqid());
}
...
}
1
$user->setEnabled(hamis);
  1. A felhasználó kapott egy e-mailt, amikor a profilja volt flush adatbázisban. Ennek az e-mailnek egy Ön által létrehozott cím részének kell lennie.
    Ezen az úton a token vagy egyedi azonosítót kell megadni, amely lehetővé teszi az érintett felhasználó megtalálását. Azt tanácsolom, hogy egy véletlenszerű UUID4-et használjon. Megtalálhatja az UUID-k listáját, valamint az összes verzió leírását.
1
2
3
4
/ **
* @Út(“/aktiválás”, név=”aktiválás”)
*/
nyilvános funkció aktív() {…}
1
$ ezt->generateUrl("aktiválja", sor(« token » => $user->getToken()), igaz);

Ilyen URL-címmel kell rendelkeznie.

1
http://gazdanév/aktiválás?token=egyediToken
  1. A felhasználó megnyitja e-mailjét, és a megadott linkre kattintva megpróbálja aktiválni fiókját. Ezután belépünk az alábbi folyamatba.
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
/ **
 * @Módszer({"KAP"})
 * @Út(“/aktiválás”, név=”aktiválás”)
 * @Biztonságos(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
 * @Sablon()
 */
nyilvános funkció aktív($request kérés) {
    $params = sor,
    $token = $request->query->get(« token »);
    $em = $ ezt->container->get(„doctrine.orm.default_entity_manager”);
$user = $em->getRepository("NamespaceMyBundle:Felhasználó")->findOneBy(sor(« token » => $token));
    if ($felhasználó != null) {
        $user->setEnabled(igaz);
        $em->persist($user);
        $em->flush();
        $params["aktiválja"] = igaz;
    } más {
        $params["aktiválja"] = hamis;
    }
    visszatérés $params;
}

Ezzel a folyamattal nem jelenthet problémát a felhasználói fiók érvényesítésének engedélyezése.

Ezt az egyenértékű kódot ezen a lényegen találhatja meg.

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
használ JMSSecurityExtraBundleJegyzetBiztos;
használ SensioCsomagFrameworkExtraBundleConfigurationMódszer;
használ SensioCsomagFrameworkExtraBundleConfigurationÚtvonal;
használ SensioCsomagFrameworkExtraBundleConfigurationSablon;
használ symfonyCsomagFrameworkBundleellenőrellenőr;
használ symfonyÖsszetevőHttpFoundationKérjen;
használ symfonyÖsszetevőBiztonságMagSecurityContext;
osztály SecurityController nyúlik ellenőr
{
/ **
* @Módszer({"KAP"})
* @Út(“/login”, név=”bejelentkezés”)
* @Sablon()
*/
nyilvános funkció Belépés($request kérés)
{
$kérelem = $ ezt->getRequest();
$session = $request->getSession();
if ($request->attributes->has(SecurityContext::AUTHENTICATION_ERROR)) {
$hiba = $request->attributes->get(SecurityContext::AUTHENTICATION_ERROR);
} más {
$hiba = $session->get(SecurityContext::AUTHENTICATION_ERROR);
$session->remove(SecurityContext::AUTHENTICATION_ERROR);
}
$params = sor(
"last_username" => $session->get(SecurityContext::LAST_USERNAME),
"hiba" => $hiba,
"üzenet" => $request->get("üzenet"),
);
if ($request->isXmlHttpRequest()) {
visszatérés $ ezt->render("GCDirectoryMainBundle:Security:login-ajax.html.twig", $params);
}
visszatérés $params;
}
/ **
* @Módszer({"POST"})
* @Út("/bejelentkezési_ellenőrzés", név="bejelentkezési_ellenőrzés")
*/
nyilvános funkció ellenőrizze()
{
dobás új RuntimeException("Be kell állítania a tűzfal által kezelendő ellenőrzési útvonalat a form_login használatával a biztonsági tűzfal konfigurációjában.");
}
/ **
* @Módszer({"KAP"})
* @Út(“/logout”, név=”kijelentkezés”)
*/
nyilvános funkció logout()
{
dobás új RuntimeException("A biztonsági tűzfal konfigurációjában aktiválnia kell a kijelentkezést.");
}
/ **
* @Módszer({"KAP"})
* @Út(“/reset”, név=”reset”)
* @Biztonságos(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
* @Sablon()
*/
nyilvános funkció vissza() {
visszatérés sor,
}
/ **
* @Módszer({"POST"})
* @Út("/Visszaállítás")
* @Biztonságos(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
*/
nyilvános funkció resetNow($request kérés)
{
$params = $request->request->all();
if (!tömb_kulcs_exists("Belépés", $params)) {
dobás új kivétel("Nincs megadva bejelentkezés");
}
$login = &$params["Belépés"];
$em = $ ezt->container->get(„doctrine.orm.default_entity_manager”);
$user = $em->getRepository("NamespaceMyBundle:Felhasználó")->findOneBy(sor("Belépés" => $bejelentkezés));
if ($felhasználó == null) {
visszatérés $ ezt->átirányítás($ ezt->generateUrl("Belépés", sor()));
}
$jelszó = „myRandowPassword”;
$user->setPassword($ ezt->container->get("security.encoder_factory")->getEncoder($user)->encodePassword($password, $user->getSalt()));
$em->persist($user);
$em->flush();
visszatérés $ ezt->átirányítás($ ezt->generateUrl("Belépés", sor()));
}
/ **
* @Módszer({"KAP"})
* @Út(„/módosítás”, név=”jelszó módosítása”)
* @Biztonságos(roles=”IS_AUTHENTICATED_FULLLY”)
* @Sablon()
*/
nyilvános funkció változik() {
visszatérés sor,
}
/ **
* @Módszer({"POST"})
* @Út("/változás")
* @Biztonságos(roles=”IS_AUTHENTICATED_FULLLY”)
* @Sablon()
*/
nyilvános funkció változtasd meg most($request kérés)
{
$params = $request->request->all();
if (!tömb_kulcs_exists("jelenlegi", $params)
|| !array_key_exists("új", $params)
|| !array_key_exists("új2", $params))
{
visszatérés sor("hiba" => "Kérjük, töltse ki az összes mezőt");
}
$em = $ ezt->container->get(„doctrine.orm.default_entity_manager”);
$felhasználó = $ ezt->getUser();
$user_encoders = $ ezt->container->get("security.encoder_factory")->getEncoder($user);
$user_repository = $em->getRepository("NamespaceMyBundle:Felhasználó");
$current_password_encoded = $user_encoders->encodePassword($params["jelenlegi"], $user->getSalt());
$new_password_encoded = $user_encoders->encodePassword($params["új"], $user->getSalt());
if ($user_repository->findOneBy(sor("Jelszó" => $aktuális_jelszó_kódolt)) == null) {
visszatérés sor("hiba" => „A jelenlegi jelszó rossz”);
} elseif ($params["új"] != $params["új2"]) {
visszatérés sor("hiba" => "A két mező jelszó nem ugyanaz");
}
$user->setPassword($new_password_encoded);
$em->persist($user);
$em->flush();
visszatérés $ ezt->átirányítás($ ezt->generateUrl("Kijelentkezés", sor()));
}
/ **
* @Módszer({"KAP"})
* @Út(“/regiszter”, név=”regiszter”)
* @Biztonságos(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
* @Sablon()
*/
nyilvános funkció Regisztráció()
{
$forma = $ ezt->createForm(új UserType(Felhasználótípus::REGISZTRÁCIÓ), új Felhasználó());
visszatérés sor(
"forma" => $form->createView(),
);
}
/ **
* @Módszer({"POST"})
* @Út("/Regisztráció")
* @Biztonságos(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
* @Sablon()
*/
nyilvános funkció regisztrálj most($request kérés)
{
$params = $kérelem->kérés->összes()[„az_űrlap_neve”];
$forma = $ ezt->createForm(új UserType(Felhasználótípus::REGISZTRÁCIÓ), új Felhasználó());
$form->submit($request);
if (tömb_kulcs_exists(„plain_password”, $params) && array_key_exists("sima_jelszó2", $params) && $params[„plain_password”] == $params["sima_jelszó2"]) {
if ($form->isValid()) {
$adat = $form->getData();
$data->setPassword($ ezt->container->get("security.encoder_factory")->getEncoder($data)->encodePassword($params[„plain_password”], $adat->getSalt()));
$em->persist($data);
$em->flush();
visszatérés $ ezt->átirányítás($ ezt->generateUrl("Belépés", sor("üzenet" => „E-mailt kapott a fiókja érvényesítésére. »)));
}
}
visszatérés sor(
"hibák" => $params[„plain_password”] == $params["sima_jelszó2"]? $form->getErrors(): sor("A két jelszónak azonosnak kell lennie"),
"forma" => $form->createView(),
);
}
/ **
* @Módszer({"KAP"})
* @Út(“/aktiválás”, név=”aktiválás”)
* @Biztonságos(roles=”IS_AUTHENTICATED_ANONYMOUSLY”)
* @Sablon()
*/
nyilvános funkció aktív($request kérés) {
$params = sor,
$token = $request->query->get(« token »);
$em = $ ezt->container->get(„doctrine.orm.default_entity_manager”);
$user = $em->getRepository("NamespaceMyBundle:Felhasználó")->findOneBy(sor(« token » => $token));
if ($felhasználó != null) {
$user->setActive(Felhasználó::ACTIVE_ACTIVE);
$em->persist($user);
$em->flush();
$params["aktiválja"] = igaz;
} más {
$params["aktiválja"] = hamis;
}
visszatérés $params;
}
}

★ ★ ★ ★ ★