इसका मतलब क्या है, "एक उपयोगकर्ता को यह तय नहीं करना चाहिए कि यह एक व्यवस्थापक है या नहीं। विशेषाधिकार या सुरक्षा प्रणाली होनी चाहिए। ”


55

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

user.isAdmin()

इसने एक टिप्पणी को दोहराया जो कई बार दोहराया गया और कई बार मतदान हुआ:

एक उपयोगकर्ता को यह तय नहीं करना चाहिए कि यह एक व्यवस्थापक है या नहीं। प्रिविलेज या सिक्योरिटी सिस्टम चाहिए। किसी चीज को किसी वर्ग के साथ कसकर जोड़े जाने का मतलब यह नहीं है कि इसे उस कक्षा का हिस्सा बनाना अच्छा है।

मैंने उत्तर दिया,

उपयोगकर्ता कुछ भी तय नहीं कर रहा है। उपयोगकर्ता ऑब्जेक्ट / टेबल प्रत्येक उपयोगकर्ता के बारे में डेटा संग्रहीत करता है। वास्तविक उपयोगकर्ताओं को अपने बारे में सब कुछ बदलने के लिए नहीं मिलता है।

लेकिन यह उत्पादक नहीं था। स्पष्ट रूप से परिप्रेक्ष्य का एक अंतर्निहित अंतर है जो संचार को कठिन बना रहा है। क्या कोई मुझे समझा सकता है कि user.isAdmin () खराब क्यों है, और यह "सही" होने पर जो दिखता है उसका एक संक्षिप्त स्केच पेंट करें?

वास्तव में, मैं उस सिस्टम से सुरक्षा को अलग करने का लाभ देखने में विफल हूं जो इसे बचाता है। कोई भी सुरक्षा पाठ कहेगा कि सुरक्षा को शुरुआत से ही एक प्रणाली के रूप में तैयार किया जाना चाहिए और विकास, परिनियोजन, रखरखाव और यहां तक ​​कि जीवन के हर चरण पर विचार किया जाना चाहिए। यह ऐसा कुछ नहीं है जिसे किनारे पर लगाया जा सकता है। लेकिन इस टिप्पणी पर अब तक 17 अप-वोट कहते हैं कि मुझे कुछ महत्वपूर्ण याद आ रहा है।


8
मुझे नहीं लगता कि इसका बुरा है, खासकर अगर यह केवल उपयोगकर्ता डीबी तालिका में एक झंडा है। क्या भविष्य में बदलाव होना चाहिए , भविष्य में इसे बदलना चाहिए। आप उपयोगकर्ता ऑब्जेक्ट से सुरक्षा प्रणाली को भी कॉल कर सकते हैं। मैंने एक बार डिज़ाइन पैटर्न के बारे में पढ़ा है कि हर db / रिसोर्स एक्सेस को वर्तमान-उपयोगकर्ता ऑब्जेक्ट के माध्यम से जाना चाहिए, यह सुनिश्चित करने के लिए कि आप कभी भी ऐसा कुछ करने की कोशिश न करें जो कि अनुमति नहीं है। थोड़ा बहुत हो सकता है, लेकिन उपयोगकर्ता एक "विशेषाधिकार" ऑब्जेक्ट प्रदान कर सकता है जो सभी सुरक्षा-संबंधित सामान को कवर करता है।
सेफेलोपॉड

मुझे लगता है कि एक गलतफहमी थी। आपके लिए, "उपयोगकर्ता" का अर्थ उस व्यक्ति से है जो सॉफ़्टवेयर का उपयोग करता है। उनके लिए, "उपयोगकर्ता" का मतलब कोड है जो आपकी कार्यक्षमता का उपयोग करता है।
फिलिप नोव

2
ऐसा नहीं है कि आपने पूछा है, लेकिन इस मामले में मैं सबसे ज्यादा सावधान रहूंगा, जहां भी आप इसे डालते हैं, वह एक एडमीन () विधि है। मैं आमतौर पर "एडमिन" को हार्ड-कोडेड नहीं होने की सलाह दूंगा, लेकिन बस संभावित अनुमतियों का एक सेट है और "एडमिन" बस पूरे सेट के लिए होता है। इस तरह जब आपको बाद में व्यवस्थापक भूमिका को विभाजित करने की आवश्यकता होती है, तो चीजें बहुत आसान होती हैं। और यह विशेष केस लॉजिक में कटौती करता है।
Psr

1
@Philipp मुझे ऐसा नहीं लगता ... दोनों साइट स्पष्ट रूप Userसे एक isAdmin()विधि के साथ एक वस्तु के बारे में बात कर रही हैं (जो भी यह पर्दे के पीछे करता है)
इज़काता

संपादित करने में बहुत देर हो गई; मेरा मतलब था "दोनों पक्ष", न कि "दोनों साइटें" ... = P
इज़्काता

जवाबों:


12

एक कुंजी के रूप में उपयोगकर्ता और एक मूल्य के रूप में अनुमतियों के बारे में सोचें।

विभिन्न संदर्भों में प्रत्येक उपयोगकर्ता के लिए अलग-अलग अनुमतियाँ हो सकती हैं। चूंकि अनुमतियाँ संदर्भ-प्रासंगिक हैं, इसलिए आपको प्रत्येक संदर्भ के लिए उपयोगकर्ता को बदलना होगा। इसलिए यह बेहतर है कि आप उस तर्क को कहीं और रखें (उदाहरण के संदर्भ वर्ग), और जहां आवश्यक हो वहीं अनुमतियों को देखें।

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


40

वह टिप्पणी बुरी तरह से शब्दबद्ध थी।

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


6
आउच (यह मेरी टिप्पणी थी), लेकिन आप इसे बहुत बेहतर करते हैं जो मैंने किया था।
मार्जन वेनमा

आप एक अलग भूमिका वर्ग में भूमिका निभाने के लिए कह रहे हैं, उपयोगकर्ता वर्ग पर नहीं? आप LDAP जैसी एक अलग प्रणाली की सिफारिश नहीं कर रहे हैं? क्या होगा अगर हर एक निर्णय जो रोल क्लास करता है, उसे उपयुक्त उपयोगकर्ता रिकॉर्ड की आवश्यकता होती है और किसी अन्य जानकारी की आवश्यकता नहीं होती है? क्या यह अभी भी उपयोगकर्ता से अलग होना चाहिए और यदि हां, तो क्यों?
ग्लेनपेटर्सन

2
@GlenPeterson: जरूरी नहीं कि, बस कक्षाएं <> टेबल और आमतौर पर टेबल की तुलना में बहुत अधिक कक्षाएं हैं। डेटा-ओरिएंटेड होने के कारण वर्गों पर सब्लिस्ट को परिभाषित करने का मार्ग प्रशस्त होता है, जब कई बार इन सूचियों को किसी अन्य "लीडर" (आदेशों) या उपयोगकर्ता में गुजरने वाले कुछ ऐसे वर्ग (या ऑर्डर) पर परिभाषित किया जाना चाहिए जिसके लिए ... यह क्रियाओं और संज्ञाओं से अधिक जिम्मेदारियों का विषय है।
मार्जन वेनेमा

9
एक कुंजी के रूप में उपयोगकर्ता और एक मूल्य के रूप में अनुमतियों के बारे में सोचें। विभिन्न संदर्भों में प्रत्येक उपयोगकर्ता के लिए अलग-अलग अनुमतियाँ हो सकती हैं। जैसा कि अनुमतियाँ संदर्भ-प्रासंगिक हैं, आपको या तो प्रत्येक संदर्भ के लिए उपयोगकर्ता को बदलना होगा। इसलिए यह बेहतर है कि आप उस तर्क को कहीं और रखें (उदाहरण के संदर्भ वर्ग)।
विल्बर्ट

2
@Wilbert: प्रसंग! यह विशेष रूप से ज्ञानवर्धक है! हां, यदि आपके पास उन अनुमतियों के लिए एक से अधिक संदर्भ हैं तो सब कुछ मेरे लिए मायने रखता है। आमतौर पर मैं एक ही संदर्भ में इन अनुमतियों को देखता हूं, और उपयोगकर्ता पर उन्हें चिपकाना उस मामले में सबसे सरल समाधान है। स्पष्ट रूप से वे वहां नहीं हैं यदि वे दूसरे संदर्भ में अलग तरीके से लागू होते हैं। यदि आप इसे एक उत्तर के रूप में लिखते हैं, तो मुझे इसे स्वीकार करने की संभावना है। धन्यवाद।
ग्लेनपेटर्सन

30

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

विशेष रूप से, जो चिंताएं अलग-अलग होती हैं, वे प्रमाणीकरण बनाम प्राधिकरण हैं

प्रमाणीकरण से तात्पर्य है लॉग इन करने और पहचान प्राप्त करने की प्रक्रिया से। यह है कि सिस्टम कैसे जानता है कि आप कौन हैं , और निजीकरण, वस्तु स्वामित्व आदि जैसी चीजों के लिए उपयोग किया जाता है।

प्राधिकरण का तात्पर्य है कि आपको क्या करने की अनुमति है , और यह (आम तौर पर) यह निर्धारित नहीं होता है कि आप कौन हैं । इसके बजाय, यह कुछ सुरक्षा नीतियों जैसे भूमिकाओं या अनुमतियों द्वारा निर्धारित किया जाता है, जो आपके नाम या ईमेल पते जैसी चीजों की परवाह नहीं करते हैं।

ये दोनों एक-दूसरे को ऑर्थोगोनली बदल सकते हैं। उदाहरण के लिए, आप OpenID / OpenAuth प्रदाताओं को जोड़कर प्रमाणीकरण मॉडल बदल सकते हैं। और आप एक नई भूमिका जोड़कर या RBAC से ABAC तक सुरक्षा नीति बदल सकते हैं।

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

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

Microsoft और Sun / Oracle (Java) सुरक्षा प्रिंसिपल के रूप में प्रमाणीकरण और प्राधिकरण जानकारी के एकत्रीकरण को संदर्भित करते हैं । यह सही नहीं है, लेकिन यह काफी अच्छी तरह से काम करता है। नेट में, उदाहरण के लिए, आपके पास है, जो समाहित - पूर्व एक जा रहा है नीति (प्राधिकरण) वस्तु, जबकि दूसरा एक है पहचान (प्रमाणीकरण)। आप यथोचित रूप से एक को दूसरे के अंदर रखने के निर्णय पर सवाल उठा सकते हैं , लेकिन महत्वपूर्ण बात यह है कि आपके द्वारा लिखा गया अधिकांश कोड केवल एक सार के लिए होगा, जिसका अर्थ है कि यह परीक्षण करना और रिफ्लेक्टर करना आसान है।IPrincipalIIdentity

एक User.IsAdminक्षेत्र में कुछ भी गलत नहीं है ... जब तक कि कोई User.Nameक्षेत्र भी नहीं है । यह इंगित करता है कि "उपयोगकर्ता" अवधारणा को ठीक से परिभाषित नहीं किया गया है और यह दुख की बात है, डेवलपर्स के बीच एक बहुत ही सामान्य गलती है जो सुरक्षा के बारे में कानों के पीछे थोड़ा गीला है। आमतौर पर, केवल एक चीज जिसे पहचान और नीति द्वारा साझा किया जाना चाहिए , वह यूजर आईडी है, जो संयोग से नहीं, बिल्कुल वैसा ही है, जिसे विंडोज और * निक्स दोनों सुरक्षा मॉडल में लागू किया जाता है।

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

एक सरलीकृत सुरक्षा मॉडल हमेशा एक अच्छे विचार की तरह लगता है जब आप पहली बार एक नया आवेदन तैयार कर रहे हैं, क्योंकि YAGNI और वह सब, लेकिन यह लगभग हमेशा समाप्त होता है बाद में आपको काटने के लिए वापस आ जाता है, क्योंकि, आश्चर्य की बात है, नई सुविधाओं को जोड़ा जाता है!

इसलिए, यदि आप जानते हैं कि आपके लिए सबसे अच्छा क्या है, तो आप प्रमाणीकरण और प्राधिकरण जानकारी को अलग रखेंगे। यहां तक ​​कि अगर "प्राधिकरण" अभी "IsAdmin" ध्वज के समान सरल है, तो आप अभी भी बेहतर होंगे यदि यह उसी वर्ग या तालिका का हिस्सा नहीं है जो प्रमाणीकरण सूचना के रूप में है, ताकि यदि और जब आपकी सुरक्षा नीति की आवश्यकता हो परिवर्तन, आपको अपने प्रमाणीकरण प्रणालियों पर पुनर्निर्माण सर्जरी करने की आवश्यकता नहीं है जो पहले से ही ठीक है।


11
ओह, काश मेरे पास यह लिखने का समय होता। तो फिर, मैं शायद इसे नहीं डाल सकता था और साथ ही साथ आपने मेरी ओर से बहुत अधिक सोचा भी नहीं था। बहुत बार मेरी आंत की वृत्ति मुझे एक या दूसरे रास्ते पर जाने के लिए कहती है, लेकिन यह समझाती है कि - अपने आप को या किसी और के लिए - बहुत अधिक सोच और प्रयास लेता है। इस पोस्ट के लिए धन्यवाद। मल्टीपल-प्लेस्ड होगा, लेकिन एसई मुझे जाने नहीं देगा ...
मार्जन वेनमा

यह एक परियोजना के समान चौंकाने वाला है जिस पर मैं काम कर रहा हूं और आपके जवाब ने मुझे एक और दृष्टिकोण दिया। आपको बहुत - बहुत धन्यवाद!
ब्रैंडन

"आप User.IsAdmin फ़ील्ड के साथ कुछ भी गलत नहीं है ... जब तक कि कोई User.Name फ़ील्ड भी नहीं है" आप लिखते हैं। लेकिन isAdminएक विधि क्या है? यह सिर्फ एक वस्तु को सौंप सकता है जिसकी ज़िम्मेदारी अनुमतियों पर नज़र रखना है। एक संबंधपरक मॉडल के डिजाइन में सबसे अच्छा अभ्यास क्या है (एक क्षेत्र क्या है) एक OO मॉडल में सबसे अच्छा अभ्यास क्या वस्तु है (क्या संदेश एक वस्तु का जवाब दे सकता है) के लिए अनुवाद करने योग्य नहीं है।
KaptajnKold 12

@KaptajnKold: मैं इस मंच में विभिन्न क्यू एंड ए थ्रेड्स में इस भावना को पढ़ता रहता हूं। यदि कोई विधि मौजूद है, तो इससे कोई फर्क नहीं पड़ता कि यह सीधे कार्य करता है या यह उन्हें प्रत्यायोजित करता है, फिर भी यह एक जिम्मेदारी के रूप में गिना जाता है क्योंकि अन्य वर्ग इस पर भरोसा कर सकते हैं । आपका User.IsAdminबहुत अच्छी तरह से एक-लाइनर हो सकता है जो कॉल करने के अलावा कुछ नहीं करता है PermissionManager.IsAdmin(this.Id), लेकिन अगर इसे 30 अन्य वर्गों द्वारा संदर्भित किया जाता है, तो आप इसे बदल या निकाल नहीं सकते। इसलिए एसआरपी मौजूद है।
एरोन्यूज़

और, @KaptajnKold, जहां तक ​​संबंधपरक मॉडल चलते हैं, मुझे यकीन नहीं है कि आप क्या प्राप्त कर रहे हैं; यह एक क्षेत्र के लिए भी बदतर है । यह उस तरह का क्षेत्र है जो आरबीएसी या कुछ और जटिल में विकसित होने के बाद लंबे समय तक घूमता रहता है, और धीरे-धीरे "वास्तविक" अनुमतियों के साथ सिंक से बाहर हो जाता है, और लोग भूल जाते हैं कि वे अब इसका उपयोग करने वाले नहीं हैं, और ... ठीक है, बस ना कहना। यहां तक ​​कि अगर आपको लगता है कि आपके पास केवल दो भूमिकाएँ हैं, तो "व्यवस्थापक" और "गैर-व्यवस्थापक", इसे बूलियन / बिट फ़ील्ड के रूप में संग्रहीत न करें, ठीक से सामान्य करें और एक अनुमति तालिका रखें। IsAdmin
एरोन्यूज़

28

खैर, बहुत कम से कम यह एकल जिम्मेदारी सिद्धांत का उल्लंघन करता है । क्या बदलाव होने चाहिए (कई व्यवस्थापक स्तर, और भी अलग-अलग भूमिकाएँ?) इस तरह का डिज़ाइन बनाए रखने के लिए काफी गड़बड़ और भयानक होगा।

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


2
@GlenPeterson: नहीं, उपयोगकर्ता सुरक्षा के बिना बहुत अच्छी तरह से मौजूद हो सकते हैं। मेरे नाम, मेरे प्रदर्शन का नाम, मेरा पता, मेरा ई-मेल पता आदि के बारे में क्या कहेंगे? पहचान (प्रमाणीकरण) और प्राधिकरण अलग-अलग जानवर हैं।
मार्जन वेनमा

2
class Userपहचान, प्रमाणीकरण, प्राधिकरण के सुरक्षा ट्रिपल में एक मुख्य घटक है । ये डिज़ाइन स्तर पर आंतरिक रूप से बंधे होते हैं, इसलिए कोड के लिए इस परस्पर निर्भरता को प्रतिबिंबित करना अनुचित नहीं है।
MSLERS

1
सवाल यह है कि, क्या उपयोगकर्ता वर्ग को त्रिभुज को संभालने के लिए सभी तर्क होने चाहिए!
12

3
@MSalters: यदि यह इस तरह के तर्क के लिए एक एपीआई है, तो यह इसके बारे में जानता है, भले ही वह सटीक तर्क के लिए कहीं और प्रतिनिधि करता हो। मुद्दा यह है कि प्राधिकरण (अनुमतियाँ) किसी अन्य चीज़ के साथ एक उपयोगकर्ता के संयोजन के बारे में है और इसलिए उपयोगकर्ता या कुछ और का हिस्सा नहीं होना चाहिए, लेकिन अनुमतियों के सिस्टम का हिस्सा जो उपयोगकर्ताओं और दोनों के लिए सही रूप से जानते हैं के लिए अनुमति दी जा रही है।
मार्जन वेनेमा

2
Should there be changes- ठीक है, हम नहीं जानते कि परिवर्तन होने जा रहे हैं। YAGNI और सभी। क्या यह आवश्यक होने पर बदल जाता है, है ना?
इजाकाता

10

मुझे लगता है कि इस मुद्दे, शायद खराब प्रदर्शन, यह है कि यह Userवर्ग पर बहुत अधिक भार डालता है । नहीं, एक विधि होने के साथ कोई सुरक्षा मुद्दा नहीं है User.isAdmin(), जैसा कि उन टिप्पणियों में सुझाया गया था। आखिरकार, यदि कोई आपके कोड में इतना गहरा है कि आपके किसी कोर क्लास के लिए दुर्भावनापूर्ण कोड इंजेक्ट करता है, तो आपको गंभीर समस्या है। दूसरी ओर, यह Userतय करने का कोई मतलब नहीं है कि क्या यह हर संदर्भ के लिए एक व्यवस्थापक है। कल्पना करें कि आप अलग-अलग भूमिकाएँ जोड़ते हैं: आपके मंच के लिए मॉडरेटर, संपादक जो फ्रंट पेज पर पोस्ट प्रकाशित कर सकते हैं, लेखक जो संपादकों को प्रकाशित करने के लिए सामग्री लिख सकते हैं, और इसी तरह। Userऑब्जेक्ट पर डालने के दृष्टिकोण के साथ , आप बहुत सारे तरीकों के साथ समाप्त होंगे और Userउस पर रहने वाले बहुत अधिक तर्क सीधे वर्ग से संबंधित नहीं हैं।

इसके बजाय, आप विभिन्न प्रकार की अनुमतियों, और एक PermissionsManagerवर्ग का उपयोग कर सकते हैं । शायद आपके पास एक विधि हो सकती है PermissionsManager.userHasPermission(User, Permission), जैसे कि बूलियन मूल्य वापस करना। व्यवहार में, ऐसा लग सकता है (जावा में):

if (!PermissionsManager.userHasPermission(user, Permissions.EDITOR)) {
  Site.renderSecurityRejectionPage();
}

यह अनिवार्य रूप से रेल विधि before_filterविधि के समतुल्य है , जो वास्तविक दुनिया में इस प्रकार की अनुमतियों की जाँच का एक उदाहरण प्रदान करता है।


6
यह कैसे अलग है user.hasPermission(Permissions.EDITOR), सिवाय इसके कि यह ओओ के बजाय अधिक क्रियात्मक और प्रक्रियात्मक है?
सेफालोपॉड

9
@ एरियन: क्योंकि user.hasPermissionsउपयोगकर्ता वर्ग में बहुत सारी जिम्मेदारियां डालता है। यह उपयोगकर्ता को अनुमतियों के बारे में जानने की आवश्यकता है, जबकि एक उपयोगकर्ता (वर्ग) को इस तरह के ज्ञान के बिना मौजूद होना चाहिए। आप एक उपयोगकर्ता वर्ग नहीं जानते हैं कि प्रिंट या डिस्प्ले (फॉर्म का निर्माण) या तो कैसे करें, आप इसे प्रिंटर रेंडरर / बिल्डर या डिस्प्ले रेंडर / बिल्डर क्लास के लिए छोड़ देते हैं।
मार्जन वेनेमा

4
user.hasPermission(P)सही एपीआई है, लेकिन यह केवल इंटरफ़ेस है। सुरक्षा उपतंत्र में निश्चित रूप से वास्तविक निर्णय होना चाहिए। परीक्षण पर सीरियन की टिप्पणी को संबोधित करने के लिए, परीक्षण के दौरान आप उस सबसिस्टम को स्वैप कर सकते हैं। हालाँकि, सीधा user.hasPermission(P)का लाभ यह है कि आप सभी कोड को प्रदूषित नहीं करते हैं, ताकि आप परीक्षण कर सकें class User
12

3
@MarjanVenema उस तर्क से, उपयोगकर्ता एक डेटा ऑब्जेक्ट रहेगा जिसमें कोई ज़िम्मेदारियाँ नहीं हैं। मैं यह नहीं कह रहा हूँ कि पूरे अनुमति प्रबंधन, उपयोगकर्ता कक्षा में लागू किया जाना चाहिए अगर वहाँ इस तरह के एक जटिल प्रणाली के लिए की जरूरत है। आप कहते हैं कि किसी उपयोगकर्ता को अनुमतियों के बारे में जानने की आवश्यकता नहीं है, लेकिन मैं यह नहीं देखता कि किसी अन्य वर्ग को यह जानने की आवश्यकता है कि किसी उपयोगकर्ता के लिए अनुमतियाँ कैसे हल करें। इससे मज़ाक करना और परीक्षण करना अधिक कठिन हो जाता है।
सेफालोपॉड

6
@ एरियन: जबकि एनीमिक कक्षाएं एक गंध हैं, कुछ वर्गों का कोई व्यवहार नहीं होता है ... उपयोगकर्ता, इम्हो, एक ऐसा वर्ग है जो एक पैरामीटर के रूप में अन्य सामानों के पूरे गुच्छा के लिए बेहतर उपयोग किया जाता है (जो चीजें करना चाहते हैं। / निर्णय लें कि उनके लिए कौन पूछ रहा है) के आधार पर, सभी प्रकार के व्यवहार के लिए एक कंटेनर के रूप में उपयोग किया जा रहा है, क्योंकि यह उस तरह से कोड करने के लिए सुविधाजनक लगता है।
मार्जन वेनेमा

9

Object.isX () का उपयोग ऑब्जेक्ट और X के बीच एक स्पष्ट संबंध को दर्शाने के लिए किया जाता है, जिसे बूलियन परिणाम के रूप में व्यक्त किया जा सकता है, उदाहरण के लिए:

Water.isBoiling ()

Circuit.isOpen ()

User.isAdmin () सिस्टम के हर संदर्भ में 'एडमिनिस्ट्रेटर' का एक ही अर्थ मानता है , कि एक उपयोगकर्ता, सिस्टम के प्रत्येक भाग में एक प्रशासक है।

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

इस स्थिति को आमतौर पर आवश्यकताओं की जांच की आवश्यकता होती है। शायद ही कभी, अगर कोई ग्राहक उस संबंध को चाहेगा जो User.isAdmin () वास्तव में प्रतिनिधित्व करता है, तो मैं स्पष्टीकरण के बिना इस तरह के किसी भी समाधान को लागू करने में संकोच करूंगा।


6

पोस्टर में मन में एक अलग और अधिक जटिल डिजाइन था। मेरी राय में, User.isAdmin()ठीक है । यहां तक ​​कि अगर आप बाद में कुछ जटिल अनुमति मॉडल पेश करते हैं, तो मुझे स्थानांतरित करने का बहुत कम कारण दिखाई देता है User.isAdmin()। बाद में, आप उपयोगकर्ता वर्ग को एक लॉग-इन उपयोगकर्ता का प्रतिनिधित्व करने वाली वस्तु में विभाजित कर सकते हैं और एक स्थिर वस्तु उपयोगकर्ता के बारे में डेटा का प्रतिनिधित्व कर सकते हैं। या आप नहीं कर सकते। कल के लिए कल बचाओ।


4
Save tomorrow for tomorrow। हाँ। जब आप यह पता लगाते हैं कि आपने जो कसकर युग्मित कोड लिखा है, उसने आपको कबूतर मार दिया है और आपको इसे फिर से लिखना होगा क्योंकि आपने इसे डिकॉउल करने के लिए अतिरिक्त 20 मिनट नहीं लिए थे ...
दर्पण

5
@MirroredFate: User.isAdminउपयोगकर्ता वर्ग को उस विशिष्ट तंत्र को युग्मित किए बिना एक मनमानी अनुमति तंत्र से जुड़ा एक तरीका पूरी तरह से संभव है ।
केविन क्लाइन

3
User.isAdmin के लिए एक विशिष्ट तंत्र पर युग्मन के बिना भी एक अनियंत्रित अनुमति तंत्र को युग्मित किया जाना आवश्यक है ... अच्छी तरह से ... युग्मन। जिनमें से न्यूनतम एक इंटरफेस के लिए होगा। और वह इंटरफ़ेस बस वहाँ नहीं होना चाहिए। यह उपयोगकर्ता वर्ग (और इंटरफ़ेस) को कुछ दे रहा है जिसके लिए उसे बस जिम्मेदार नहीं होना चाहिए। आरोनियट ने इसे मेरे द्वारा बताए गए अनुसार बहुत बेहतर बताया (जैसा कि इस प्रश्न के अन्य सभी उत्तरों का संयोजन है)।
मार्जन वेनमा

8
@MirroredFate: मुझे परवाह नहीं है अगर मुझे अधिक जटिल आवश्यकताओं को पूरा करने के लिए एक सरल कार्यान्वयन को फिर से लिखना है। लेकिन मेरे पास वास्तव में खराब एपीआई के साथ बहुत बुरे अनुभव हैं जिनकी कल्पना भविष्य की आवश्यकताओं को पूरा करने के लिए की गई है जो कभी उत्पन्न नहीं हुई।
केविन क्लाइन

3
@kevincline जब ओवरली-कॉम्प्लेक्स API एक बुरी बात होती है, तो मैं यह सुझाव नहीं दे रहा था कि व्यक्ति को ओवरली-कॉम्प्लेक्स API लिखना चाहिए। मैं कह रहा था कि Save tomorrow for tomorrowयह एक भयानक डिजाइन दृष्टिकोण है क्योंकि यह उन समस्याओं को बनाता है जो सिस्टम को सही ढंग से बदतर रूप से लागू किए जाने पर तुच्छ होगा। वास्तव में, यह मानसिकता अत्यधिक जटिल एपीआई में परिणाम है, के रूप में परत पर परत प्रारंभिक गरीब डिजाइन को पैच करने के लिए जोड़ा जाता है। मुझे लगता है कि मेरा रुख है measure twice, cut once
प्रतिबिंबित

5

वास्तव में कोई समस्या नहीं है ...

मुझे इसमें कोई समस्या नहीं दिख रही है User.isAdmin()। मैं निश्चित रूप से इसे कुछ पसंद करता हूं PermissionManager.userHasPermission(user, permissions.ADMIN), जो एसआरपी के पवित्र नाम में कोड को कम स्पष्ट करता है और कुछ भी मूल्य नहीं जोड़ता है।

मुझे लगता है कि एसआरपी को कुछ लोगों द्वारा शाब्दिक रूप से व्याख्या की जा रही है। मुझे लगता है कि यह ठीक है, यहां तक ​​कि एक वर्ग के लिए भी बेहतर इंटरफ़ेस है। एसआरपी का मतलब सिर्फ इतना है कि एक वस्तु को किसी भी चीज के लिए सहयोगियों को सौंपना चाहिए जो कि इसकी जिम्मेदारी नहीं है। यदि उपयोगकर्ता की व्यवस्थापक भूमिका बूलियन फ़ील्ड की तुलना में कुछ अधिक शामिल है, तो उपयोगकर्ता ऑब्जेक्ट के लिए अनुमतियाँ अनुमत करने के लिए यह बहुत अच्छी तरह से कर सकता है। लेकिन इसका मतलब यह नहीं है कि यह एक उपयोगकर्ता के लिए यह isAdminविधि रखने के लिए भी एक अच्छा विचार नहीं है । वास्तव में इसका मतलब है कि जब आपका एप्लिकेशन सरल से जटिल में स्नातक होता है, तो आप चाहते हैं कि उपयोगकर्ता ऑब्जेक्ट का उपयोग करने वाले कोड को बदलना पड़े। IOW, आपके क्लाइंट को यह जानने की आवश्यकता नहीं है कि उपयोगकर्ता एक व्यवस्थापक है या नहीं, इस सवाल का जवाब देने में वास्तव में क्या लगता है।

... लेकिन आप वास्तव में क्यों जानना चाहते हैं?

उस ने कहा, यह मुझे ऐसा लगता है कि आपको शायद ही यह जानने की आवश्यकता है कि क्या कोई उपयोगकर्ता एक व्यवस्थापक है, जो कुछ अन्य प्रश्नों का उत्तर देने में सक्षम है, जैसे कि किसी उपयोगकर्ता को कुछ विशिष्ट कार्रवाई करने की अनुमति है या नहीं, जैसे कि एक विजेट को अपडेट करना। अगर ऐसा है, तो मैं विजेट पर एक विधि रखना पसंद करूंगा, जैसे isUpdatableBy(User user):

boolean isUpdatableBy(User user) {
    return user.isAdmin();
}

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

[संपादित करें]

समस्या नहीं होने User.isAdmin()और उपयोग करने के साथPermissionManager.userHasPermission(...)

मुझे लगा कि मैं अपने उत्तर को यह बताने के लिए जोड़ूंगा कि मैं क्यों उपयोगकर्ता ऑब्जेक्ट पर एक विधि को कॉल करना पसंद करता हूं एक PermissionManager ऑब्जेक्ट पर एक विधि को कॉल करना अगर मैं जानना चाहता हूं कि क्या उपयोगकर्ता एक व्यवस्थापक है (या एक व्यवस्थापक भूमिका है)।

मुझे लगता है कि यह मान लेना उचित है कि आप हमेशा उपयोगकर्ता वर्ग पर निर्भर रहने वाले हैं जहाँ आपको सवाल पूछने की आवश्यकता है कि क्या यह उपयोगकर्ता व्यवस्थापक है? यह एक निर्भरता है जिससे आप छुटकारा नहीं पा सकते हैं। लेकिन अगर आपको उपयोगकर्ता को इसके बारे में एक प्रश्न पूछने के लिए एक अलग वस्तु पर जाने की आवश्यकता है, तो यह उस वस्तु पर एक नई निर्भरता बनाता है जिसके पास आपके पास पहले से ही उपयोगकर्ता है। यदि प्रश्न बहुत कुछ पूछा जाता है, तो यह बहुत सी जगहें हैं जहां आप एक अतिरिक्त निर्भरता बनाते हैं, और यह बहुत सारी जगहें हैं यदि आपको या तो निर्भरता की मांग करनी पड़ सकती है।

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

isAdminअनुमतियाँ सबसिस्टम पर उपयोगकर्ता वर्ग में निर्भरता बनाने के डर से उपयोगकर्ता पर एक विधि नहीं होने पर जोर देते हुए , मेरे दिमाग में एक पैसा कमाने के लिए एक डॉलर खर्च करने का मन है। ज़रूर, आप उपयोगकर्ता वर्ग में एक निर्भरता से बचते हैं, लेकिन हर जगह एक बनाने की कीमत पर जहां आपको सवाल पूछने की आवश्यकता होती है। अच्छा मोलभाव नहीं।


2
"SRP सिर्फ मतलब है कि एक वस्तु कुछ भी है कि भीतर यह एक जिम्मेदारी है नहीं आता सहयोगियों को सौंपने चाहिए" - झूठी । एसआरपी की परिभाषा में वह सब कुछ शामिल है जो एक वस्तु सीधे करती है और वह सब कुछ जो उसे सौंपती है। एक वर्ग जो केवल एक कार्य सीधे करता है, लेकिन 50 अन्य कार्यों को परोक्ष रूप से प्रतिनिधिमंडल के माध्यम से करता है, अभी भी (शायद) एसआरपी का उल्लंघन कर रहा है।
Aaronaught

KaptajnKold: I + 1'd क्योंकि मैं आपसे सहमत हूं और मैं इसके बारे में थोड़ा दोषी महसूस करता हूं। आपकी पोस्ट चर्चा में शामिल होती है, लेकिन यह सवाल का जवाब नहीं देती है।
ग्लेनपेटर्सन

@GlenPeterson खैर, मैंने प्रश्न के उस भाग को संबोधित करने की कोशिश की, जो '' जैसा दिखता है '' सही '' किया जाता है, '' यह भी: आपको मेरे साथ सहमत होने के बारे में बिल्कुल दोषी नहीं लगना चाहिए :)
KaptajnKold

1
@ जेम्ससेल शायद। अगर। लेकिन यह एक कार्यान्वयन विवरण है जो मैं अभी भी उपयोगकर्ता पर isAdmin विधि के भीतर सीमित कर दूंगा। इस तरह से आपके क्लाइंट कोड को तब बदलना नहीं पड़ता है जब उपयोगकर्ता का "एडमिन-नेस" बूलियन फ़ील्ड से कुछ अधिक उन्नत होने तक विकसित होता है। आपके पास कई जगह हो सकती हैं, जहां आपको यह जानना होगा कि क्या कोई उपयोगकर्ता एक व्यवस्थापक है और आप नहीं चाहते कि हर बार आपके प्राधिकरण प्रणाली में परिवर्तन हो।
KaptajnKold

1
@JamesSnell शायद हम एक दूसरे को गलत समझ रहे हैं? का सवाल है या नहीं, यदि कोई उपयोगकर्ता एक व्यवस्थापक है के सवाल के समान नहीं है एक उपयोगकर्ता एक विशिष्ट कार्यवाही करने की अनुमति है या नहीं । पहले प्रश्न का उत्तर हमेशा संदर्भ से स्वतंत्र होता है। दूसरे का उत्तर संदर्भ पर बहुत निर्भर है। यह वही है जो मैंने अपने मूल उत्तर के दूसरे भाग में संबोधित करने की कोशिश की।
KaptajnKold

1

इस चर्चा ने मुझे एरिक लिपर्ट द्वारा एक ब्लॉग पोस्ट की याद दिला दी, जो वर्ग डिजाइन, सुरक्षा और शुद्धता के बारे में इसी तरह की चर्चा में मेरे ध्यान में लाया गया था।

क्यों इतने सारे फ्रेमवर्क क्लासेस सील हैं?

विशेष रूप से, एरिक ने मुद्दा उठाया:

4) सुरक्षित। बहुरूपता की पूरी बात यह है कि आप जानवरों की तरह दिखने वाली वस्तुओं के आसपास से गुजर सकते हैं लेकिन वास्तव में जिराफ हैं। यहां सुरक्षा के संभावित मुद्दे हैं।

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

यह एक स्पर्शरेखा की तरह लग सकता है, लेकिन मुझे लगता है कि इस बिंदु के साथ डॉकटेल अन्य पोस्टर ने SOLID- जिम्मेदारी सिद्धांत के बारे में उठाया है । निम्नलिखित दुर्भावनापूर्ण वर्ग को एक User.IsAdminविधि या संपत्ति को लागू नहीं करने के कारण के रूप में देखें ।

public class MyUser : User
{

    public new boolean IsAdmin()
    {
        // You know it!
        return true;
    }

    // Anything else we can break today?

}

दी, यह थोड़ा खिंचाव है: किसी ने अभी तक IsAmdminएक आभासी विधि बनाने का सुझाव नहीं दिया है , लेकिन यह तब हो सकता है जब आपके उपयोगकर्ता / भूमिका आर्किटेक्चर का विचित्र रूप से जटिल होना समाप्त हो जाए। (या शायद नहीं। विचार करें public class Admin : User { ... }: इस तरह के एक वर्ग में उस कोड के ठीक ऊपर हो सकता है।) जगह में एक दुर्भावनापूर्ण बाइनरी प्राप्त करना एक सामान्य हमला वेक्टर नहीं है और एक अस्पष्ट उपयोगकर्ता लाइब्रेरी की तुलना में अराजकता के लिए बहुत अधिक संभावना है - फिर, यह प्रिविलेज एस्केलेशन बग हो सकता है जो वास्तविक शेंनिगन्स के लिए दरवाजा खोलता है। अंत में, यदि दुर्भावनापूर्ण बाइनरी या ऑब्जेक्ट इंस्टेंस ने रन टाइम में अपना रास्ता खोज लिया, तो "प्रिविलेज या सिक्योरिटी सिस्टम" को एक समान तरीके से बदलने की कल्पना करना बहुत अधिक नहीं है।

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

ओह, और सिर्फ रिकॉर्ड के लिए सटीक होना चाहिए, मैं इस प्रश्न में पोस्ट के साथ सहमत हूं: "एक उपयोगकर्ता को यह तय नहीं करना चाहिए कि यह एक व्यवस्थापक है या नहीं। विशेषाधिकार या सुरक्षा प्रणाली चाहिए। ”एक User.IsAdminविधि एक बुरा विचार है यदि आप सिस्टम पर कोड चला रहे हैं तो आप कोड के 100% नियंत्रण में नहीं रहते हैं - आपको इसके बजाय करना चाहिए Permissions.IsAdmin(User user)


है ना? यह कैसा है? इससे कोई फर्क नहीं पड़ता कि आपने सुरक्षा नीति कहाँ रखी है, आप हमेशा इसे किसी असुरक्षित चीज़ से सम्बद्ध कर सकते हैं। इससे कोई फर्क नहीं पड़ता कि कुछ उपयोगकर्ता, प्रिंसिपल, पॉलिसी, परमिशनसेट या जो भी हो। यह पूरी तरह से असंबंधित मुद्दा है।
हारून

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

मुझे यकीन नहीं है कि आप ऐसा क्यों कहते हैं सुरक्षा और अनुमतियों के बहुत सारे ढांचे अत्यधिक एक्स्टेंसिबल हैं। कोर नेट सुरक्षा (IPrincipal, IIdentity, ClaimSet, आदि) से संबंधित प्रकार के अधिकांश केवल नहीं कर रहे हैं नहीं सील लेकिन इतना है कि आप प्लग कर सकते हैं जो कुछ भी आप चाहते हैं, वास्तव इंटरफेस या सार कक्षाओं में कर रहे हैं। एरिक के बारे में जो बात कर रहा है, वह यह है कि आप ऐसा कुछ नहीं चाहते हैं जो System.Stringकि अंतर्निहित हो, क्योंकि सभी प्रकार के क्रिटिकल फ्रेमवर्क कोड बहुत विशिष्ट धारणाएं बनाते हैं कि यह कैसे काम करता है। व्यवहार में, अधिकांश "उपयोगकर्ता कोड" (सुरक्षा सहित) परीक्षण युगल के लिए अनुमति देने के लिए अंतर्निहित है।
Aaronaught

1
वैसे भी, सवाल में कहीं भी बहुरूपता का उल्लेख नहीं किया गया है, और यदि आप लेखक के लिंक का पालन करते हैं जहां मूल टिप्पणी की गई थी, तो यह स्पष्ट है कि यह सामान्य रूप से वंशानुक्रम या यहां तक ​​कि वर्ग के आक्रमणकारियों का जिक्र नहीं था - यह जिम्मेदारियों के बारे में था।
एरोन

मुझे पता है कि इसका उल्लेख नहीं किया गया था, लेकिन वर्ग जिम्मेदारियों का सिद्धांत सीधे तौर पर बहुरूपता से संबंधित है। यदि IsAdminओवरराइड / को-ऑप्ट करने की कोई विधि नहीं है , तो संभावित सुरक्षा छेद नहीं है। उन सिस्टम इंटरफेस के तरीकों की समीक्षा करना, IPrincipalऔर IIdentity, यह स्पष्ट है कि डिजाइनर मुझसे असहमत हैं, और इसलिए मैं इस बिंदु को स्वीकार करता हूं।
पैट्रिक एम

0

यहाँ समस्या यह है:

if (user.isAdmin()) {
   doPriviledgedOp();
} else {
   // maybe we can anyway!
   doPriviledgedOp();
}

या तो आपने अपनी सुरक्षा को ठीक से स्थापित किया है जिस स्थिति में विशेषाधिकार प्राप्त विधि की जाँच करनी चाहिए कि क्या कॉल करने वाले के पास पर्याप्त अधिकार है - जिस स्थिति में जाँच अतिसुधार है। या आप सुरक्षा पर अपने निर्णय लेने के लिए एक गैर-निजीकृत वर्ग पर भरोसा नहीं कर रहे हैं और कर रहे हैं।


4
एक वंचित वर्ग क्या है?
ब्रैंडन

1
इस तरह के कोड को लिखे जाने से रोकने के लिए वास्तव में आप कुछ नहीं कर सकते। कोई फर्क नहीं पड़ता कि आप अपने ऐप को कैसे डिज़ाइन करते हैं, कहीं न कहीं इस तरह की एक स्पष्ट जाँच होने वाली है, और कोई इसे असुरक्षित लिख सकता है। भले ही आपकी अनुमति प्रणाली एक भूमिका या अनुमति विशेषता के साथ एक विधि को सजाने के रूप में सुव्यवस्थित हो - कोई व्यक्ति गलत तरीके से "सार्वजनिक" या "सभी" अनुमति को फेंक सकता है। इसलिए मैं वास्तव में नहीं देखता कि यह User.IsAdmin विशेष रूप से एक समस्या जैसी एक विधि कैसे बनाता है।
एरोन्यूज़
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.