👐🏾 ⏱️ 👮 सिम्फनी 2.0 पर परियोजनाओं में गैर-मानक प्रमाणीकरण 👨‍🏫 ♠️ 🆘

इस लेख का उद्देश्य सिम्फनी 2.0 पर आधारित परियोजनाओं के लिए गैर-मानक प्रमाणीकरण के आयोजन के बारे में बात करना है।

इसकी आवश्यकता क्यों हो सकती है?

यह आवश्यक हो सकता है यदि ORM के माध्यम से उपयोगकर्ता खातों तक पहुंच को व्यवस्थित करना मुश्किल है, या बाहरी संसाधनों, जैसे कि सामाजिक नेटवर्क का उपयोग करके प्राधिकरण किया जाता है।

कार्य

मेरे लिए, कार्य इस तरह दिखता था: मेरे पास सिम्फनी 1.4 पर एक परियोजना थी और दूसरे संस्करण की रिलीज के साथ, "मेरे हाथों को खरोंच किया गया", सिस्टम की नींव को बदलने के बिना इसे 2.0 में अनुवाद करता है, अर्थात। डेटाबेस और उस तक पहुंच का सिद्धांत।

मेरी परियोजना में डेटा MongoDB में संग्रहीत किया गया है, और पहुंच अपने स्वयं के सरल आवरण के माध्यम से थी, जो कक्षाओं को आवश्यक संग्रह में बाँध सकती थी। सिम्फनी 2 के लिए एक आवरण को बांधना आसान था।

उपयोगकर्ता प्राधिकरण के संदर्भ में कार्य को शुरुआत में MongoDB से डेटा प्राप्त करने के लिए कम किया गया था। सुधार का कार्य सामाजिक नेटवर्क खातों पर प्राधिकरण की संभावना को महसूस करना है।

सिद्धांत की बिट

इससे पहले कि आप सिम्फनी 2.0 के लिए अपने स्वयं के सुरक्षा एक्सटेंशन पर काम करना शुरू करें, आपको यह समझने की आवश्यकता है कि फ्रेम सामान्य रूप से कैसे काम करता है, और विशेष रूप से सुरक्षा घटक।

मुझे लगता है कि हर कोई जो फ्रेमवर्क के दूसरे संस्करण में रुचि रखता था, वह जानता है कि आने वाले अनुरोधों को घटनाओं या घटनाओं के रूप में माना जाता है और बाद में श्रोताओं द्वारा प्रसंस्करण के लिए प्राप्त किया जाता है। इस प्रसंस्करण के दौरान, एक प्रतिक्रिया प्रकट होती है (उर्फ प्रतिक्रिया), ग्राहक को लौटाई गई।

सामान्य शब्दों में, सब कुछ इस तरह होता है:

कर्नेल अनुरोध प्राप्त करता है;
अनुरोध सुरक्षा प्रणाली द्वारा संसाधित किया जाता है;
अनुरोध "राउटर" द्वारा संसाधित किया जाता है, अनुरोधित नियंत्रक निर्धारित किया जाता है;
कार्रवाई और संबंधित प्रतिक्रिया तैयारी प्रक्रियाएं की जाती हैं;
उत्पन्न उत्तर हैंडलर के माध्यम से रास्ते का अपना हिस्सा गुजरता है, जहां नवीनतम समायोजन किए जाते हैं।

हम चरण 2 और, भाग 3 में रुचि रखते हैं।

सुरक्षा प्रणाली कैसे काम करती है यह एक अलग गीत है। प्रक्रिया कुछ इस तरह दिखती है:

सामान्य सुरक्षा श्रोता अनुरोध घटना को प्राप्त करता है और इसे "बच्चे" प्रमाणीकरण श्रोताओं को वितरित करता है।
श्रोता एक टोकन बनाते हैं और इसे प्रमाणीकरण प्रबंधक का उपयोग करके अधिकृत करने का प्रयास करते हैं;
AuthenticationManager उपयुक्त प्रमाणीकरण प्रदाता का चयन करता है और सत्यापन के लिए उसे टोकन देता है।
प्रमाणीकरण प्रदाता प्रबंधक के पास लौटता है, अन्यथा श्रोता, बदले में, अधिकृत (या अधिकृत नहीं) टोकन है। इस स्तर पर, UserProvider सक्रिय है, जो उपयोगकर्ता डेटा के साथ काम करता है।
श्रोता, प्रमाणीकरण प्रबंधक और उसके स्वयं के कोड द्वारा लौटाए गए परिणाम पर निर्भर करता है, या तो सिक्योरिटीकॉनटेक्स के लिए अधिकृत टोकन "पाम ऑफ" या एक प्रतिक्रिया (प्रतिक्रिया) उत्पन्न करता है, या दोनों करता है। यदि श्रोता एक प्रतिक्रिया उत्पन्न करता है, तो अनुरोध ईवेंट "राउटर" को नहीं भेजा जाएगा और नियंत्रक को कोई कॉल नहीं होगा।
तब प्राधिकरण होता है, मैंने इसे और इसके बाद के कदमों को नहीं बनाया, लेकिन सिद्धांत एक संपूर्ण प्रमाणीकरण के समान है, जैसा कि मैं इसे समझता हूं।

1.x की तुलना में, जहां सभी वर्णित प्रक्रियाएं सीधे क्रियाओं में हुईं, यह योजना अतिभारित, अनावश्यक रूप से जटिल लगती है। हालांकि, इस तरह की संरचना हमें अपने आवेदन में सुरक्षा को व्यवस्थित करने के सभी काम नहीं करने देती है, जिससे हमें केवल आवश्यक भाग को बदलने की अनुमति मिलती है, और शेष कार्य को फ्रेमवर्क को सौंप देता है।

चरण ० - प्रलेखन का अध्ययन करें।

जो कुछ भी आप सिम्फनी 2.0 सुरक्षा से प्राप्त करना चाहते हैं, आपको व्यवसाय से नीचे उतरने से पहले संबंधित दस्तावेज को संकुचित करना होगा। आप सुरक्षा और सेवा कंटेनर पुस्तक के अध्यायों के बिना नहीं कर सकते। यदि आप अपनी भाषा में पढ़ना चाहते हैं, तो आप इस लेख का अध्ययन कर सकते हैं।

वास्तव में, यदि आप "अजीब" स्रोतों से उपयोगकर्ताओं के बारे में जानकारी प्राप्त नहीं करना चाहते हैं, तो आगे पढ़ना आवश्यक नहीं है। डॉक्ट्रिन के माध्यम से डेटाबेस के साथ काम करना सूचीबद्ध लेखों में अच्छी तरह से वर्णित है।

चरण 1 - अपना स्वयं का उपयोगकर्ता आधार।

बॉक्स से बाहर सिम्फनी 2.0 में प्राधिकरण उपकरण का एक बड़ा सेट है। लॉगिन / पासवर्ड जोड़ी प्राधिकरण और प्रमाण पत्र प्राधिकरण जैसे अधिक विदेशी विकल्पों के साथ सबसे सरल विकल्प दोनों हैं।

सबसे पहले, मुझे लॉगिन और पासवर्ड द्वारा सबसे साधारण प्राधिकरण को व्यवस्थित करने की आवश्यकता है, लेकिन अपने स्वयं के डेटाबेस से MongoDB पर और अपने विशेष आवरण के माध्यम से डेटा लें।

यह वास्तव में कार्य का सबसे आसान हिस्सा है। सबसे पहले, हमें एक वर्ग की आवश्यकता है जो UserInterface इंटरफ़ेस को लागू करता है।

namespace MyBundle\Models; use Mh\Mongo\Model\Base; use Symfony\Component\Security\Core\User\AdvancedUserInterface; use Symfony\Component\Security\Core\User\UserInterface; class User extends Base implements UserInterface { public function getRoles() { return $this->credentials; } public function getPassword() { return $this->passw; } public function getSalt() { return $this->salt; } public function getUsername() { return $this->uname; } public function eraseCredentials() { } public function equals(UserInterface $user) { return $this->getUsername() === $user->getUsername(); } public function __toString() { return $this->uname; } }

वर्ग बहुत सरल है, इस मामले में MongoDB से दस्तावेज़ डेटा तक पहुंचने के लिए सभी कार्यक्षमता को मूल वर्ग में प्रदर्शित किया जाता है, जिस पर विचार इस लेख का विषय नहीं है। UserInterface इंटरफ़ेस का कार्यान्वयन कुछ सुरक्षा आवश्यक उपयोगकर्ता डेटा प्राप्त करने और एक दूसरे के साथ उपयोगकर्ता वस्तुओं की तुलना करने की क्षमता के साथ फ्रेमवर्क सुरक्षा प्रणाली प्रदान करता है।

यह getRoles विधि पर ध्यान देने योग्य है, उपरोक्त लेख में यह विधि भूमिका संस्थाओं को लौटाती है, लेकिन हमारे पास आउटपुट पर सरल तारों के साथ एक सरणी है, जो सिस्टम के लिए स्वीकार्य है। यदि हम भूमिकाओं को उन समूहों के रूप में मानते हैं जिनमें अधिकारों का एक परिवर्तनशील समूह हो सकता है, तो हमें रोलइंटरफेस के साथ संगत वस्तुओं को वापस करने की आवश्यकता होगी, हमारे मामले में, भूमिकाएं अधिकारों का एक सेट हैं, इसलिए स्ट्रिंग मान हमारे लिए पर्याप्त हैं।

अगला, आपको एक वर्ग की आवश्यकता है जो UserProviderInterface इंटरफ़ेस को लागू करता है, जो आपको ऊपर वर्णित कक्षा की वस्तुओं को प्राप्त करने की अनुमति देता है।

 namespace MyBundle\Security; use Mh\Mongo\MongoBundle\ConnectionManager; use MyBundle\Models\User; use Symfony\Component\Security\Core\User\UserInterface; use Symfony\Component\Security\Core\User\UserProviderInterface; use \Exception; use Symfony\Component\Security\Core\Exception\UsernameNotFoundException; use Symfony\Component\Security\Core\Exception\UnsupportedUserException; class UserProvider implements UserProviderInterface { protected $collection; protected $db; protected $field; protected $logger; //  ,  ,      //  ,          // . public function __construct(array $params, ConnectionManager $cm, LoggerInterface $logger) { //         $this->db = $cm->getConnection($params['confname']); $this->collection = $this->db->selectCollection($params['collection']); //       ,   $this->field = $params['field']; if (!$this->field || !$this->collection) { throw new Exception("Invalid parameters"); } //     logger',   DI $this->logger = $logger; } //        , //    . public function loadUserByUsername($uname) { //      . $this->logger->debug("user load request. name: $uname"); //         User //   . $user = $this->collection->findOne(array($this->field => $uname)); //  . ,    . if (!isset($user->uname) || $user->uname !== $uname) { throw new UsernameNotFoundException(sprintf('User "%s" does not exist.', $uname)); } //     return $user; } //       . //        . public function refreshUser(UserInterface $user) { if (!($user instanceof User)) throw new UnsupportedUserException(sprintf('Instances of "%s" are not supported.', get_class($user))); $this->logger->info("refresh from mongo"); $_user = $this->collection->findOne(array('_id' => $user->_id)); if ($_user && $_user instanceof User) $this->logger->info("roles: " .implode(', ',$_user->roles)); else throw new UsernameNotFoundException(sprintf('User "%s" does not exist.', $user->uname)); return $_user; } //    . public function supportsClass($class) { $this->logger->debug("support checking: $class"); if ($class == 'MyBundle\Models\User') return true; return false; } }

अब आपको प्रदाता को एक सेवा के रूप में पंजीकृत करना होगा और इसका उपयोग करने के लिए सुरक्षा घटक को "सिखाना" चाहिए।

हमारे बंडल की सेवाओं में। सेवा और इसके लिए मापदंडों के बारे में डेटा जोड़ें:

 पैरामीटर:
   my.users:
     confname: डिफ़ॉल्ट
     संग्रह: उपयोगकर्ता
     फ़ील्ड: अनाम

 सेवाएं:
   my.users.prov:
     वर्ग: MyBundle \ Security \ UserProvider
     तर्क: [% my.users%, @ mongo.manager, @ monolog.logger]

Security.yml एप्लिकेशन में हम लिखेंगे:

 सुरक्षा:
     एनकोडर:
         सिम्फनी \ घटक \ सुरक्षा \ कोर \ उपयोगकर्ता \ उपयोगकर्ता: सादा
         # लॉन्च में आसानी के लिए, आप डेटाबेस में एक अनएन्क्रिप्टेड पासवर्ड स्टोर कर सकते हैं		
         MyBundle \ मॉडल \ उपयोगकर्ता: plaintext

     प्रदाताओं:
	 # अब एक नया उपयोगकर्ता स्रोत घोषित करें (कोई भी नाम सौंपा जा सकता है)
	 # और उसमें उस सेवा का नाम लिखें जो डेटा देगी 
         # उपयोगकर्ताओं के बारे में
         mongobase:
           आईडी: my.userprov
 ...

एक विशेषता यह है कि स्पष्ट रूप से कहीं भी उल्लेख नहीं किया गया है (या मैंने ध्यान नहीं दिया)। यदि एक से अधिक उपयोगकर्ता प्रदाता को सुरक्षा में घोषित किया गया है। तो, यदि दूसरा प्रदाता सीधे प्रमाणीकरण के लिए निर्दिष्ट नहीं है, तो पहला।

दरअसल उसके बाद हम पहले से ही MongoDB के डेटा का उपयोग करके लॉगिंग शुरू कर सकते हैं। मेरे मामले में, डेटाबेस में पहले से ही परियोजना के पिछले संस्करण का डेटा है। एक प्रविष्टि बिंदु कैसे बनाया जाए, उपरोक्त लेखों में वर्णित है, मुझे लगता है कि इसके बारे में फिर से लिखने का कोई मतलब नहीं है।

चरण 2 - OAuth प्रमाणीकरण

परियोजना के नए संस्करण में एक नवाचार के रूप में, मैंने सामाजिक नेटवर्क में खातों से उपयोगकर्ताओं को अधिकृत करने की क्षमता जोड़ने का फैसला किया। नेटवर्क। एक उदाहरण के रूप में, मैं सभी "प्यारे" सामाजिक नेटवर्क के माध्यम से प्रमाणीकरण और पंजीकरण के बारे में बात करूंगा। VKontakte नेटवर्क।

सिम्फनी 2.0 में अपना स्वयं का प्रमाणीकरण विधि बनाना प्रलेखित माना जा सकता है। WSSE का उपयोग करके प्रमाणीकरण को लागू करने के बारे में एक आधिकारिक लेख है । मेरे द्वारा आवश्यक कार्यक्षमता पर काम शुरू करने पर, मैंने इस लेख पर ध्यान केंद्रित किया। सामाजिक के साथ काम के सिद्धांत। मुझे इस लेख से एक हब पर एक नेटवर्क मिला

अब प्राप्त जानकारी का थोड़ा विश्लेषण। एक आधिकारिक लेख में एक उदाहरण के लिए वर्णित प्रमाणीकरण भी मेरी ज़रूरत के समान नहीं है। VKontakte खाते वाले उपयोगकर्ता को प्रमाणित करने की प्रक्रिया सामान्य (लॉगिन / पासवर्ड के आधार पर) प्रमाणीकरण के समान है, लेकिन हमारे पास लॉगिन या पासवर्ड नहीं है। इस बारे में सोचने के बाद, मैंने सिम्फनी के स्रोत कोड का अध्ययन करने का फैसला किया, विशेष रूप से, फॉर्म (form_login) के माध्यम से मूल प्राधिकरण कैसे व्यवस्थित किया जाता है।

यह पता चला कि बिल्ट-इन AuthenticationListeners और AuthenticationProviders को उन अमूर्त वर्गों से विरासत में मिला है जो सिम्फनी में सीधे तौर पर प्रमाणीकरण कार्य से जुड़े अधिकांश रूटीन कार्य लेते हैं, उपयोगकर्ता सत्र के साथ काम करते हैं, आदि। हम अपने काम को सुविधाजनक बनाने के लिए इन कक्षाओं का उपयोग भी कर सकते हैं। ।

चलिए शुरू करते हैं।

आधिकारिक लेख की तरह, आइए टोकन के साथ शुरू करें:

 namespace MyBundle\Social\Authentication; use Symfony\Component\Security\Core\Authentication\Token\AbstractToken; class Token extends AbstractToken { //      . public $social; public $hash; public $add; //   ,    function __construct(array $roles = array()) { parent::__construct($roles); //    ,    //          . parent::setAuthenticated(count($roles) > 0); } // ,    TokenInterface public function getCredentials() { } //         , //      .     “” //     . public function serialize() { $pser = parent::serialize(); return serialize(array($this->social, $this->hash, $this->add, $pser)); } public function unserialize($serialized) { list($this->social, $this->hash, $this->add, $pser) = unserialize($serialized); parent::unserialize($pser); } }

टोकन वर्ग, उपयोगकर्ता वर्ग के मामले में, बहुत सरल है। अगला, हमें एक श्रोता की आवश्यकता है जो केवल वर्णित कक्षा के टोकन बनाएगा।

 namespace MyBundle\Social\Authentication; //       AbstractAuthenticationListener, //     “”   , //       use Symfony\Component\HttpFoundation\Response; use Symfony\Component\HttpKernel\Event\GetResponseEvent; use Symfony\Component\Security\Http\Firewall\ListenerInterface; use Symfony\Component\Security\Core\Exception\AuthenticationException; use Symfony\Component\Security\Core\SecurityContextInterface; use Symfony\Component\Security\Core\Authentication\AuthenticationManagerInterface; use Symfony\Component\Security\Core\Authentication\Token\TokenInterface; use Symfony\Component\Security\Http\Firewall\AbstractAuthenticationListener; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\Security\Http\Session\SessionAuthenticationStrategyInterface; use Symfony\Component\Security\Http\HttpUtils; use Symfony\Component\HttpKernel\Log\LoggerInterface; use Symfony\Component\DependencyInjection\ContainerInterface; use Symfony\Component\EventDispatcher\EventDispatcherInterface; use Symfony\Component\Form\Extension\Csrf\CsrfProvider\CsrfProviderInterface; class AuthenticationListener extends AbstractAuthenticationListener { //      “”  .  protected $social; //    ,  //   public function __construct(SecurityContextInterface $securityContext, AuthenticationManagerInterface $authenticationManager, SessionAuthenticationStrategyInterface $sessionStrategy, HttpUtils $httpUtils, $providerKey, array $options = array(), AuthenticationSuccessHandlerInterface $successHandler = null, AuthenticationFailureHandlerInterface $failureHandler = null, LoggerInterface $logger = null, EventDispatcherInterface $dispatcher = null, array $social = array()) { parent::__construct($securityContext, $authenticationManager, $sessionStrategy, $httpUtils, $providerKey, array_merge(array( 'intention' => 'authenticate', ), $options), $successHandler, $failureHandler, $logger, $dispatcher); $this->social = $social; } //  attemptAuthentication   ,   //    ,    Token' public function attemptAuthentication(Request $request) { //      ,     //     if ($request->get('uid') && $request->get('hash') && $request->cookies->get("vk_app_{$this->social['vk']['id']}")) { $this->logger->debug("vk auth handled"); //     $uid = $request->get('uid'); $fn = $request->get('first_name'); $ln = $request->get('last_name'); $hash = $request->get('hash'); $this->logger->info("user $fn $ln [$uid] // $hash"); $avatars = array( 'sav' => $request->get('photo'), 'srav' => $request->get('photo_rec'), ); //   token     //   .  … $token = new Token(); $token->setUser("vk{$uid}"); // …     token' ... $token->social = 'vk'; $token->hash = $hash; $token->add = array( 'uid' => $uid, 'avatar' => $avatars, 'name' => "$fn $ln", ); // …     ,     return $this->authenticationManager->authenticate($token); } //        -   . } }

संक्षेप में, श्रोता की भूमिका उपयोगकर्ता प्रमाणीकरण के लिए आवश्यक डेटा अनुरोध से निकालने की है। AbstractAuthenticationListener हमें विशेष रूप से सत्यापन के लिए खुद को सीमित करने और अनुरोध के लिए पार्सिंग कोड लिखने का अवसर प्रदान करता है, URI द्वारा फ़िल्टरिंग अनुरोधों के लिए तैयार कार्यक्षमता प्रदान करता है, पुनर्निर्देशन प्रबंधन और अन्य रूटीन जो कि AuthenticationListener की "जिम्मेदारियों" का भी हिस्सा हैं।

श्रो को लागू करने के बाद, हमें एक ऑथेंटिकेशनप्रोवाइडर की जरूरत है, जो सीधे टोकन की जांच करेगा और सफल प्रमाणीकरण की घोषणा करेगा।

 namespace MyBundle\Social\Authentication; use Mh\Mongo\MongoBundle\ConnectionManager; use MyBundle\Models\User as User; use Symfony\Component\Security\Core\Authentication\Provider\AuthenticationProviderInterface; use Symfony\Component\Security\Core\User\UserProviderInterface; use Symfony\Component\Security\Core\Exception\AuthenticationException; use Symfony\Component\Security\Core\Exception\NonceExpiredException; use Symfony\Component\Security\Core\Authentication\Token\TokenInterface; use Symfony\Component\Security\Core\Exception\UsernameNotFoundException; use Symfony\Component\HttpKernel\Log\LoggerInterface; //    AuthenticationProvider'     // ,     UserAuthenticationProvider, //            . class Provider implements AuthenticationProviderInterface { protected $userProvider; protected $logger; //     .  protected $social; //       MongoDB  //    protected $mongo; //   ,     //  . public function __construct(UserProviderInterface $userProvider, array $social, ConnectionManager $cm, LoggerInterface $logger) { $this->userProvider = $userProvider; $this->social = $social; $this->mongo = $cm; $this->logger = $logger; } //    public function authenticate(TokenInterface $token) { $user = null; //      UserProvider'a //      ,      try { $user = $this->userProvider->loadUserByUsername($token->getUsername()); } catch (UsernameNotFoundException $ex) { $this->logger->debug("user ".$token->getUsername()." not yet registred"); } try { //    hash' if ($this->checkHash($token)) { $this->logger->info("hash is valid"); //  ,    hash,   //    -  “” if (!$user) { $this->logger->info("register new user"); $user = new User(array( 'uname' => $token->getUsername(), 'social' => $token->social, 'fullname' => $token->add['name'], 'avatar' => $token->add['avatar'], 'suid' => $token->add['uid'], 'roles' => array('ROLE_EXTUSER', strtoupper($token->social) ), )); $user->save($this->mongo); } //    . ,   Token //      $authenticatedToken = new Token($user->getRoles()); $authenticatedToken->social = $token->social; $authenticatedToken->hash = $token->hash; $authenticatedToken->add = $token->add; $authenticatedToken->setUser($user); //        return $authenticatedToken; } else { $this->logger->debug("hash is invalid."); } } catch (\Exception $ex) { $this->logger->err("auth internal exception: $ex"); } //   -     -  //  . throw new AuthenticationException('The Social authentication failed.'); } //   hesh',      //  . protected function checkHash(Token $token) { if ($token->social == 'vk') { return ($token->hash === md5( $this->social['vk']['id'] . $token->add['uid'] . $this->social['vk']['key'] )); } return false; } //  ,    token'  provider' public function supports(TokenInterface $token) { return $token instanceof Token; } }

AuthenticationProvider पर काम पूरा करने के बाद, यह केवल हमारे द्वारा लिखी गई कक्षाओं का उपयोग करने के लिए रूपरेखा सिखाने के लिए रहता है। UserProvider के विपरीत, यह काम का नहीं बल्कि "पारदर्शी" हिस्सा है।

आधिकारिक दस्तावेज में कहा गया है कि हमारे कोड का उपयोग करने के लिए, सिम्फनी सुरक्षा प्रणाली को SecurityFactoryInterface का कार्यान्वयन लिखना होगा। तो चलिए करते हैं।

 namespace MyBundle\DependencyInjection\Security; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\DependencyInjection\Reference; use Symfony\Component\DependencyInjection\DefinitionDecorator; use Symfony\Component\Config\Definition\Builder\NodeDefinition; use Symfony\Bundle\SecurityBundle\DependencyInjection\Security\Factory\SecurityFactoryInterface; //   Symfony   AbstractFactory     . //    ,      ,   //    AuthenticationProvider' class SocialAuthFactory implements SecurityFactoryInterface { //      firewall'    //  .     form_login. protected $options = array( 'check_path' => '/login_check', 'login_path' => '/login', 'use_forward' => false, 'always_use_default_target_path' => false, 'default_target_path' => '/', 'target_path_parameter' => '_target_path', 'use_referer' => false, 'failure_path' => null, 'failure_forward' => false, ); //  ,       firewall  listener  // provider. //      , id firewall'  // ,       . public function create(ContainerBuilder $container, $id, $config, $userProvider, $defaultEntryPoint) { //      ,     //   . //      “”   // (  )    . //  id    AuthenticationProvider' $providerId = 'security.authentication.provider.social.'.$id; //    -    my.socialauth.prov //  (0)         //   $container ->setDefinition($providerId, new DefinitionDecorator('my.socialauth.prov')) ->replaceArgument(0, new Reference($userProvider)) ; //  listener'    ,    provider' $listenerId = 'security.authentication.listener.social.'.$id; $container ->setDefinition($listenerId, new DefinitionDecorator('my.socialauth.listener')) ->replaceArgument(4, $id) ->replaceArgument(5, array_intersect_key($config, $this->options)); //   id  . return array($providerId, $listenerId, $defaultEntryPoint); } //  ,       //   .      login_form. public function getPosition() { return 'form'; } //      ,      //     . public function getKey() { return 'mysocial'; } //   ,      // AbstractFactory public function addConfiguration(NodeDefinition $node) { $builder = $node->children(); $builder ->scalarNode('provider')->end() ; foreach ($this->options as $name => $default) { if (is_bool($default)) { $builder->booleanNode($name)->defaultValue($default); } else { $builder->scalarNode($name)->defaultValue($default); } } } }

फैक्ट्री बनाने के बाद, यह केवल कॉन्फ़िगरेशन को पूरक करने के लिए बनी हुई है।

चलो सुरक्षा के साथ शुरू करते हैं। वहाँ आप अपने niches के कारखाने विन्यास फाइल के लिए एक लिंक जोड़ने की जरूरत है ...

  सुरक्षा:

     कारखानों:
         - "% kernel.root_dir% / .. / src / MyBundle / Resources / config / socialauth_factory.yml"
 ...

... आगे, हम उस फ़ाइल को बनाएंगे और भरें जिसे हम संदर्भित करते हैं, वाक्यविन्यास सामान्य services.yml के सिंटैक्स के समान है।

 सेवाएं:
     security.authentication.factory.mysocial:
         वर्ग: MyBundle \ DependencyInjection \ Security \ Factory \ SocialFactory
         टैग:
             - {नाम: सुरक्षा।

अब आपको अपने कारखाने में उल्लिखित सेवाओं के साथ services.yml को जोड़ना होगा:

  पैरामीटर:
   my.users:
     confname: डिफ़ॉल्ट
     संग्रह: उपयोगकर्ता
     फ़ील्ड: अनाम

   my.social:
     आईडी: __YOUR_APP_ID__
     कुंजी: __YOUR_APP_PRIVATE_KEY__

 सेवाएं:
   my.users.prov:
     वर्ग: MyBundle \ Security \ UserProvider
     तर्क: [% my.users%, @ mongo.manager, @ monolog.logger]

   # हम एब्सट्रैक्टलिस्ट सर्विस के उत्तराधिकारी के रूप में श्रोता के लिए सेवा की घोषणा करते हैं
   # यहां दिए गए तर्क तर्कों के बाद कंस्ट्रक्टर को दिए जाएंगे,   
   # मूल सेवा में निर्धारित
   my.socialauth.listener:
     वर्ग: MyBundle \ Social \ Authentication \ Listener
     जनक: सुरक्षा
     तर्क: [% my.social%]
    
   # प्रदाता के लिए सेवा में, हम वास्तविक मूल्य के बिना पहला तर्क छोड़ देते हैं।
   # फैक्ट्री में निर्मित डेकोरेटर से मूल्य पारित किया जाएगा।
   my.socialauth.prov:  
     वर्ग: MyBundle \ Social \ Authentication \ प्रदाता
     तर्क: ['',% my.social%, @ mongo.manager, @ monolog.logger]

आखिरी चीज़ जो बनी हुई है वह है हमारे सबसिस्टम को एप्लिकेशन के कॉन्फ़िगरेशन में शामिल करना। ऐसा करने के लिए, फिर से security.yml संपादित करें, और इसमें फ़ायरवॉल ब्लॉक करें:

  ...   
     फायरवॉल:
         myauth:
             पैटर्न: ^ /
             # ब्लॉक में हमारे फ़ायरवॉल को नियमित form_login में जोड़ें, 
             # याद रखें कि इसमें लगभग समान सेटिंग्स हैं।
             mysocial:  
                 check_path: / login / socialauth
                 login_path: / लॉगिन / में
             # हमारी कक्षाएं बॉक्सिंग कक्षाओं और सिम्फनी के साथ समान शर्तों पर काम करेंगी,
             # ताकि वे एक-दूसरे के साथ हस्तक्षेप न करें, अलग-अलग check_path करें
             form_login:
                 check_path: / लॉगिन / ऑर्ट
                 login_path: / लॉगिन / में
	      # हम 2 तरीकों से प्राधिकरण की अनुमति देते हैं, आउटपुट के लिए है 
             # मानक प्रकार से दोनों प्रकार के उपयोगकर्ता के लिए
             लॉगआउट:
                 पथ: / लॉगिन / बाहर
                 लक्ष्य: /
                 अमान्य_सेशन: सच है
             अनाम: ~
 ...

वह सब है। लॉगिन फॉर्म टेम्पलेट में VKontakte के माध्यम से एक प्राधिकरण लिंक जोड़कर, हम इस सामाजिक नेटवर्क का उपयोग करके लॉग इन कर सकते हैं। नेटवर्क।

परिणाम

शुरुआत से सिम्फनी 2.0 की सुरक्षा प्रणाली जटिल और भ्रामक लग सकती है। सामान्य तौर पर, यह वास्तव में जटिल और भ्रामक है, लेकिन यदि आप दूसरे और पहले संस्करणों में सुरक्षा संगठन की तुलना करते हैं, तो आप एक प्रवृत्ति देख सकते हैं।

सुरक्षा प्रणाली को व्यवस्थित किया जाता है ताकि रूपरेखा के विन्यास स्तर पर विशिष्ट कार्यों को हल किया जा सके। हमें लॉगिन / पासवर्ड की जांच करने के लिए प्रोग्राम करने की आवश्यकता नहीं है (फॉर्म को ड्राइंग के अलावा), हमें जांचने के लिए कार्रवाई करने की भी आवश्यकता नहीं है। लॉगआउट के लिए भी यही। व्यक्तिगत तत्वों को लागू करने की जटिलता मुख्य रूप से एक लचीली सुरक्षा वास्तुकला में उन्हें एम्बेड करने की आवश्यकता से जुड़ी है।

आपका ध्यान देने के लिए धन्यवाद।

सिम्फनी 2.0 पर परियोजनाओं में गैर-मानक प्रमाणीकरण