🚢 👞 👩🏻‍🏫 Laravel 4 पर क्लाइंट और सर्वर के बीच एन्क्रिप्टेड संचार 🔙 🐦 👩🏿‍🤝‍👩🏽

परिचय

सभी को शुभ दिन! लारवेल पर अपने पहले लेख में, मैं एक क्लाइंट (डेस्कटॉप एप्लिकेशन) और लारवेल चलाने वाले सर्वर के बीच एन्क्रिप्टेड संचार के आयोजन में अपने अनुभव को साझा करना चाहता हूं।

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

लेकिन समस्या यह है कि यदि क्लाइंट और सर्वर के बीच का ट्रैफ़िक एन्क्रिप्ट नहीं किया गया है, तो कोई भी अंततः सर्वर को नकली बना सकता है और जब तक आवश्यक हो, एप्लिकेशन का उपयोग कर सकता है।

इस लेख में मैं क्लाइंट और सर्वर के बीच एन्क्रिप्टेड संचार को व्यवस्थित करने के तरीके के बारे में बात करूंगा। सर्वर प्लेटफॉर्म के रूप में लारवेल 4.1 इंजन (प्रकाशन के समय नवीनतम संस्करण) पर एक आवेदन होगा। यह माना जाता है कि ग्राहक सी # में लिखा गया एक आवेदन होगा, लेकिन इस लेख में मैं ग्राहक के लेखन का वर्णन नहीं करूंगा। इसके बजाय, मैं CodeProject के एक लेख की सिफारिश कर सकता हूं जो C # में क्रिप्टोग्राफी का उपयोग करने का एक उदाहरण प्रदान करता है: C # और PHP के बीच संचार एन्क्रिप्ट करना । दरअसल, यह लेख मेरे शोध का शुरुआती बिंदु था।

मैं निम्नलिखित मुद्दों को उजागर करने का प्रयास करूंगा:

क्रिप्टोग्राफी की मूल बातें (यह मूल बातों के बारे में है, क्योंकि मेरे पास क्रिप्टोग्राफी नहीं है);
लारवेल के तहत प्रोग्रामिंग, एसओएलआईडी-डिजाइन का पालन (आदर्श रूप से, लेकिन व्यवहार में, लेख को सरल बनाने के लिए, सभी एसओएलआईडी-सिद्धांतों का सम्मान नहीं किया जाएगा)
शायद कुछ और

क्रिप्टोग्राफी मूल बातें

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

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

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

यह किस लिए है? बीच में आदमी जैसे हमले को रोकने के लिए, जब यातायात को बाधित किया जाता है और किसी हमलावर द्वारा अपने उद्देश्यों के लिए उपयोग किया जाता है।

हमारे मामले में, एन्क्रिप्शन के अलावा, डेटा पर भी हस्ताक्षर किए जाएंगे ताकि ग्राहक 100% सुनिश्चित हो कि डेटा उसके सर्वर से प्राप्त किया गया था, और संभावित जाली से नहीं।

सर्वर अनुप्रयोग की संरचना के बारे में थोड़ा सा

मैं यहाँ नहीं कहूंगा कि एक खाली लारवेल एप्लिकेशन कैसे बनाया जाए, आप इसके बारे में फ्रेमवर्क की आधिकारिक वेबसाइट पर पढ़ सकते हैं। मान लीजिए कि आपने पहले ही MySecureApp नामक एक एप्लिकेशन बना लिया है। हमारे सभी कोड ऐप डायरेक्टरी के अंदर स्थित होंगे। अधिक सटीक रूप से, नियंत्रकों, मॉडलों और विचारों के अलावा, हम एक और चीज़ बनाएँगे:

ऐप फोल्डर के अंदर, लिबर फ़ोल्डर बनाएं, इसमें MySecureApp - यहां हमारे सभी वर्ग जो एप्लिकेशन के व्यावसायिक तर्क को लागू करते हैं, स्थित होगा।
ऐप फ़ोल्डर के अंदर, चाबियाँ फ़ोल्डर बनाएँ। यह हमारी निजी कुंजी संग्रहीत करेगा।
निम्नलिखित लाइनों को जोड़कर एप्लिकेशन की जड़ में कंपोज़र.जसन फ़ाइल को संपादित करें:
```
"autoload": { "classmap": [ "app/commands", "app/controllers", "app/models", "app/database/migrations", "app/database/seeds", "app/tests/TestCase.php" ], "psr-0": { "MySecureApp": "app/lib" } }, 
```
उसके बाद, आपको कमांड चलाने की आवश्यकता है ताकि ऑटोलैडर हमारी कक्षाओं को देख सके:
```
  संगीतकार डंप-ऑटोलॉड 
```

हमारे आवेदन में निम्नलिखित निर्देशिका संरचना होनी चाहिए:

  / ऐप
   / दायित्व
     / MySecureApp
       / क्रिप्टोग्राफी - कक्षाएं जो सीधे एन्क्रिप्शन को लागू करती हैं
       / Dto - डेटा ट्रांसफर ऑब्जेक्ट
         / प्रतिक्रियाएं - हमारी एपीआई प्रतिक्रिया कक्षाएं
       / Facades - कुछ वर्गों के लिए आसान पहुँच के लिए facades
       / फ़िल्टर - फ़िल्टर
       / सहायक - सहायक वर्ग
       / प्रदाता - सेवा प्रदाता लारवेल एप्लिकेशन में हमारी कार्यक्षमता को पंजीकृत करते हैं

धीरे-धीरे, हम इन निर्देशिकाओं को कक्षाओं के साथ आबाद करते हैं।

क्लाइंट-सर्वर इंटरैक्शन

क्लाइंट एप्लिकेशन और सर्वर के बीच सभी इंटरैक्शन एक ही कंट्रोलर - ApiController के माध्यम से होगा। यही है, फार्म के माध्यम से mysecureapp / एपीआई *

तर्क इस प्रकार है: ग्राहक ब्याज की एपीआई विधि के लिए एक पोस्ट अनुरोध भेजता है, प्रत्येक पैरामीटर को एन्क्रिप्टेड रूप में पास करता है। प्रतिक्रिया में, सर्वर फॉर्म का JSON प्रतिक्रिया देता है:

 { "data": "<AES encrypted JSON object>", "sign": "<RSA signature of data>" }

क्रिप्टोग्राफी कार्यान्वयन

हम एईएस को एक सममित एन्क्रिप्शन एल्गोरिथ्म के रूप में उपयोग करेंगे। असममित के रूप में - आरएसए। सौभाग्य से, क्रिप्टोग्राफिक लाइब्रेरी phpseclib पहले से ही लारवेल के साथ आपूर्ति की जाती है, जिसमें वह सब कुछ है जो हमें चाहिए। आरएसए के साथ शुरू करते हैं।

RSA को काम करने के लिए, हमें कुंजियों की एक जोड़ी की आवश्यकता है - सार्वजनिक और निजी। ठीक है, और अधिक ठीक है, अगर हम सर्वर कार्यान्वयन के बारे में बात करते हैं, तो हमें केवल निजी कुंजी की आवश्यकता है। सार्वजनिक कुंजी क्लाइंट की आवश्यकता होगी। आइए इस प्रमुख जोड़ी को बनाते हैं।

ऐसा करने के लिए, हमें कंप्यूटर पर ओपनएसएसएल स्थापित करना होगा। जहाँ तक मुझे पता है, लिनक्स सिस्टम पर यह डिफ़ॉल्ट रूप से स्थापित है। विंडोज के लिए, आप इसे यहाँ से डाउनलोड कर सकते हैं: http://slproweb.com/products/Win32OpenSSL.html । व्यक्तिगत रूप से, मुझे लाइट डिस्ट्रीब्यूशन का उपयोग करने में कठिनाई हुई - उनके पास काम के लिए आवश्यक Opensl.cfg नहीं था। इसलिए, पूर्ण संस्करण (~ 19 एमबी) डाउनलोड और इंस्टॉल करना उचित है। स्थापना के बाद, उपरोक्त कॉन्फ़िगरेशन को इंगित करते हुए, पर्यावरण चर OPENSSL_CONF बनाना आवश्यक है। आप कंसोल में टाइप करके ऐसा कर सकते हैं

  OPENSSL_CONF = \ path \ to to \ssl.cfg सेट करें

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

  Opensl genrsa -aes256 -out temp.key 1024
 खुलता है rsa -in temp.key -out private.key

अब, प्राप्त कुंजी के आधार पर, हम एक X509 प्रमाणपत्र, या दूसरे शब्दों में, एक सार्वजनिक कुंजी उत्पन्न करेंगे:

  Opensl req -new -x509 -nodes -sha1 -key private.key -out public.crt -days 365000

आपसे कुछ प्रश्न पूछे जाएंगे, जिनका उत्तर दिया जाना आवश्यक नहीं है। आप कुछ भी जवाब दे सकते हैं।
हमारे पास कुल:

Private.key - निजी कुंजी
public.crt - खुला

इसके लिए पहले से तैयार किए गए ऐप / कुंजियों के फोल्डर में उन्हें स्थानांतरित करें, और एप्लिकेशन कॉन्फिग में (एप्लिकेशन / कॉन्फिग / ऐप.एफ़पी) निम्नलिखित पंक्ति जोड़ें

 'privateKey' => 'private.key',

RSA कार्यान्वयन को शुरू करने से पहले, हम Base64 से / के लिए एन्कोडिंग / डिकोडिंग स्ट्रिंग्स के लिए एक सहायक वर्ग बनाएंगे। निम्नलिखित सामग्री के साथ ऐप / लिब / MySecureApp / Helpers / Base64.php फ़ाइल बनाएं:

 <?php namespace MySecureApp\Helpers; class Base64 { public static function UrlDecode($x) { return base64_decode(str_replace(array('_','-'), array('/','+'), $x)); } public static function UrlEncode($x) { return str_replace(array('/','+'), array('_','-'), base64_encode($x)); } }

खैर, अब आरएसए के कार्यान्वयन के लिए सीधे आगे बढ़ते हैं। ऐसा करने के लिए, एप्लिकेशन / lib / MySecureApp / Cryptography / Cryptography.php में क्रिप्टोग्राफ़ी वर्ग बनाएं:

 <?php namespace MySecureApp\Cryptography; use MySecureApp\Helpers\Base64; class Cryptography { /** * RSA instance * @var \Crypt_RSA */ protected $rsa; /** * RSA private key * @var string */ protected $rsaPrivateKey; /** * Whether RSA instance is initialized * @var bool */ private $isRsaInitialized = false; /** * Initializes the RSA instance using either provided private key file or config value * @param String $privateKeyFile Path to private key file * @throws Exception */ public function initRsa($privateKeyFile = '') { // } /** * Decrypts RSA-encrypted data * @param String $data Data to decrypt * @return String */ public function rsaDecrypt($data) { // } /** * Encrypts data using RSA * @param String $data Data to encrypt * @return String */ public function rsaEncrypt($data) { // } /** * Signs provided data * @param String $data Data to sign * @throws \Exception * @return string Signed data */ public function rsaSign($data) { // } }

एक त्वरित नोट : क्रिप्टोग्राफी वर्ग का प्रस्तावित संस्करण SOLID डिजाइन सिद्धांतों का काफी अनुपालन नहीं करता है। मैं सामग्री को सरल बनाने के उद्देश्य से ऐसा कर रहा हूं। मैं इस बारे में बात करूंगा कि लेख के अंत में इसे कैसे सुधारें।

आरएसए के तरीकों को भरना शुरू करते हैं। चलो rsaInit () से शुरू करते हैं। एल्गोरिदम सरल है: हम पैरामीटर में, या कॉन्फ़िगरेशन से ली गई निजी कुंजी को पढ़ते हैं, और phpseclib लाइब्रेरी द्वारा आपूर्ति की गई Crypt_RSA क्लास को इनिशियलाइज़ करते हैं:

  public function initRsa($privateKeyFile = '') { //    ,     if (!$privateKeyFile) { $privateKeyFile = app_path() . '/keys/' . \Config::get('app.privateKey'); } // ,     if (!\File::exists($privateKeyFile)) { Log::error("Error reading private key file."); throw new Exception("Error reading private key file."); } $this->rsaPrivateKey = \File::get($privateKeyFile); //   RSA $rsa = new \Crypt_RSA(); $rsa->setEncryptionMode(CRYPT_RSA_ENCRYPTION_PKCS1); $rsa->loadKey($this->rsaPrivateKey); //       //    true    // ()  $this->rsa = $rsa; $this->isRsaInitialized = true; }

अब हम डेटा के साथ काम करने के तरीकों को स्वयं लागू करते हैं:

  public function rsaDecrypt($data) { //  RSA       if (!$this->isRsaInitialized) { $this->initRsa(); } //   return $this->rsa->decrypt(Base64::UrlDecode($data)); } // ... public function rsaEncrypt($data) { //  rsaDecrypt if (!$this->isRsaInitialized) { $this->initRsa(); } return Base64::UrlEncode($this->rsa->encrypt($data)); } // ... public function rsaSign($data) { if (!$this->isRsaInitialized) { $this->initRsa(); } // ,   PHP- openssl if (!function_exists('openssl_sign')) { throw new \Exception("OpenSSL is not enabled."); } //   $signature = ''; $keyId = openssl_get_privatekey($this->rsaPrivateKey); openssl_sign($data, $signature, $keyId); openssl_free_key($keyId); return $signature; }

ध्यान दें कि rsaDecrypt विधि से आधारित डेटा को Base64 में एन्कोडेड होने की उम्मीद है। सममित रूप से, rsaEncrypt रिटर्न एन्क्रिप्टेड डेटा Base64 में एन्कोडेड है।

इस पर क्रिप्टोग्राफी वर्ग का आरएसए हिस्सा पूरा हो गया है। आइए एईएस के लिए नीचे उतरें।

फ़ील्ड में वर्ग जोड़ें:

  /** * AES instance * @var \Crypt_AES */ protected $aes; /** * Whether AES instance is initialized * @var bool */ private $isAesInitialized = false;

अब तरीके:

  /** * Initializes AES instance using either provided $options or session values * @param array $options Array of options, containing 'key' and 'iv' values * @throws Exception */ public function initAes($options = array()) { // ... } /** * Encrypts data using AES * @param String $data Data to encrypt * @return String */ public function aesEncrypt($data) { // ... } /** * Decrypts AES encrypted data * @param String $data Data to decrypt * @return String */ public function aesDecrypt($data) { // ... }

एईएस आरंभीकरण:

  public function initAes($options = array()) { //  $options ,      if (empty($options) && Session::has('aes_key') && Session::has('aes_iv')) { $options = array( 'key' => Session::get('aes_key'), 'iv' => Session::get('aes_iv'), ); } //       ,    if (!(isset($options['key']) && isset($options['iv']))) { Log::error("Either key or iv not set"); throw new Exception("Either key or iv not set"); } //     Session::put('aes_key', $options['key']); Session::put('aes_iv', $options['iv']); //  Crypt_AES,   phpseclib $aes = new \Crypt_AES(CRYPT_AES_MODE_CBC); $aes->setKeyLength(256); $aes->setKey(Base64::UrlDecode($options['key'])); $aes->setIV(Base64::UrlDecode($options['iv'])); $aes->enablePadding(); //     $this->aes = $aes; $this->isAesInitialized = true; }

अब डेटा प्रोसेसिंग के तरीके स्वयं:

  public function aesEncrypt($data) { //     RSA if (!$this->isAesInitialized) { $this->initAes(); } return $this->aes->encrypt($data); } public function aesDecrypt($data) { if (!$this->isAesInitialized) { $this->initAes(); } return $this->aes->decrypt($data); }

क्रिप्टोग्राफी क्लास इसके लिए तैयार है। लेकिन अभी तक यह केवल एक उपकरण है, और इसका उपयोग कैसे करना है, हालांकि ऐसा लगता है और स्पष्ट है, आगे दिखाया जाएगा।

अगला, हमें एक उपकरण की आवश्यकता है जो डिक्रिप्टेड इनकमिंग डेटा प्रदान करता है। मेरा क्या मतलब है? उदाहरण के लिए, एक ग्राहक लॉग इन करना चाहता है, और इसके लिए, वह (मैं थोड़ा आगे निकलता है ) mysecureapp / api के लिए एक POST अनुरोध भेजता है: निम्नलिखित डेटा के साथ लॉगिन करें: ईमेल = asdpofih345kjafg और पासवर्ड = zxcvzxcvzxcvzxcv - यह एईएस एन्क्रिप्टेड डेटा है। डिक्रिप्ट किए गए डेटा को प्राप्त करने के लिए, हमें इनपुट मुखौटा के समान एक वर्ग की आवश्यकता है, लेकिन पहले से ही डीक्रिप्ट किए गए डेटा को वापस करना। इसे DecryptedInput कहें और इसे एप्लिकेशन / lib / MySecureApp / Cryptography / DecryptedInput.php में बनाएँ। हम इसे सबसे लोकप्रिय इनपुट विधियों में लागू करते हैं: प्राप्त करें (), सभी () और केवल ():

 <?php namespace MySecureApp\Cryptography; use MySecureApp\Helpers\Base64; /** * Provides funcitonality for getting decrypted Input paramters * (encrypted with AES) * Class DecryptedInput * @package MySecureApp\Cryptography */ class DecryptedInput { /** * Array of raw (non-decrypted) input parameters * @var array */ protected $params; /** * Array of decrypted values * @var array */ protected $decryptedParams = array(); /** * @var Cryptography */ protected $crypt; /** * @param Cryptography $crypt Injected Cryptography object used for decrypting */ public function __construct(Cryptography $crypt) { //     Cryptography //  $this->crypt = $crypt; //     $params $this->params = \Input::all(); } /** * Returns decrypted input parameter * @param $key * @return String */ public function get($key) { // ,        if (isset($this->decryptedParams[$key])) { return $this->decryptedParams[$key]; } //  $value = $this->crypt->aesDecrypt(Base64::UrlDecode($this->params[$key])); //     $this->decryptedParams[$key] = $value; //    return $value; } /** * Returns all input params decrypted * @return array */ public function all() { //       foreach ($this->params as $key => $value) { $this->decryptedParams[$key] = $this->get($key); } //      return $this->decryptedParams; } /** * Returns only specified input parameters * @return array */ public function only() { $args = func_get_args(); $result = array(); foreach($args as $arg) { $result[$arg] = $this->get($arg); } return $result; } }

लाइन 33 पर ध्यान दें: क्रिप्टोग्राफी का एक उदाहरण कंस्ट्रक्टर को दिया जाता है। लेकिन आपको स्वीकार करना चाहिए, हमारे लिए इस वर्ग को लगातार "मैन्युअल" करना असुविधाजनक होगा, इसलिए हम लारवेल की सर्वश्रेष्ठ परंपराओं का पालन करेंगे - ताकि वह हमारे लिए सब कुछ करे।

ऐसा करने के लिए, हम निम्न कार्य करेंगे:

आइए DecryptedIntput के मुखौटे को नियमित इनपुट के समान बनाएं
क्रिप्टोग्राफी के बाहर सिंगलटन बनाते हैं।
हम अपने स्वयं के सेवा प्रदाता के अंदर पूरी बात "रजिस्टर" करते हैं।

तो, चलो क्रम में चलते हैं। DecryptedInput का मुखौटा बनाएं। ऐसा करने के लिए, एप्लिकेशन / lib / MySecureApp / Facades में DecryptedInput.php फ़ाइल बनाएं:

 <?php namespace MySecureApp\Facades; use Illuminate\Support\Facades\Facade; class DecryptedInput extends Facade { protected static function getFacadeAccessor() { // " ",     // DecryptedInput   return 'decryptedinput'; } }

शायद आपको नामों में भ्रम होगा: हमारे पास दो वर्ग हैं जिन्हें DecryptedInput कहा जाता है: एक इनपुट का एक एनालॉग है, दूसरा इसका मुखौटा है, उनके पास बस अलग नामस्थान हैं। इसलिए, यह संभवतः डिक्रिप्टेडइनपुटफैकेड का नाम बदलने के लिए अधिक तर्कसंगत होगा। लेकिन यह केवल नोट पर जानकारी है - आप तय करते हैं। नेमस्पेस के लिए धन्यवाद, हम हमेशा निर्दिष्ट कर सकते हैं कि हम किस वर्ग का उपयोग करने जा रहे हैं।

अब हमारे लिए अपना स्वयं का सेवा प्रदाता लिखने के लिए सब कुछ तैयार है (मैं इसे अंग्रेजी में लिखता हूं, क्योंकि मैं अभी तक इस शब्द के एक सभ्य अनुवाद के साथ नहीं आया हूं, शब्दशः यह एक सेवा प्रदाता होगा, लेकिन मुझे सेवा प्रदाता अधिक पसंद है)। निम्नलिखित के साथ एप्लिकेशन / lib / MySecureApp / प्रदाता में CryptoServiceProvider.php फ़ाइल बनाएं:

 <?php namespace MySecureApp\Providers; use Illuminate\Foundation\AliasLoader; use Illuminate\Support\ServiceProvider; use MySecureApp\Cryptography\Cryptography; use MySecureApp\Cryptography\DecryptedInput; class CryptoServiceProvider extends ServiceProvider { /** * Register the service provider. * * @return void */ public function register() { //   Cryptograpgy $this->app->singleton('cryptography', function() { return new Cryptography(); }); //    Input'   'decryptedinput' $this->app['decryptedinput'] = $this->app->share(function($app) { return new DecryptedInput($app['cryptography']); }); //     DirectInput' $this->app->booting(function() { $loader = AliasLoader::getInstance(); $loader->alias('DecryptedInput', 'MySecureApp\Facades\DecryptedInput'); }); } }

खैर, मैं हमें इस तथ्य पर बधाई दे सकता हूं कि हमने आधा काम किया है। अभी बहुत से बचे हैं। बस मजाक कर रहे हैं, थोड़ा कम ... हकीकत में, इस समय हमने सिर्फ एक उपकरण का एक शस्त्रागार तैयार किया है जिसका उपयोग करना अभी बाकी है।

आप एक ब्रेक ले सकते हैं। इस बीच, मैं संक्षेप में वर्णन करता हूं कि यह कैसे काम करता है। मैं DecryptedInput के साथ शुरू करूँगा। अब हम इसे इस तरह उपयोग कर सकते हैं:

  // ... $email = DecryptedInput::get('email'); $password = DecryptedInput::get('password'); //  ... extract(DecryptedInput::only('email', 'password')); //    2  : // $email  $password

यह कैसा चल रहा है? प्रदाता में पंजीकृत उर्फ के लिए धन्यवाद, लारवेल जानता है कि डिक्रिप्टेडइंपुट वर्ग का उल्लेख करते समय, हमें हमारे द्वारा किए गए मुखौटे का उपयोग करना चाहिए। कैसे काम करता है? डिक्रिप्टेडिनपुट कुंजी ( एक्सेसर ) के लिए धन्यवाद getFacadeAccessor () द्वारा लौटाया गया, लारवेल जानता है कि मुखौटा के स्थिर तरीकों के सभी कॉलों के लिए, प्रदाता द्वारा \ MySececAppApp \ Cryptography \ DecryptedInput class ('डिक्रिप्टेडिनपुट' कुंजी ) के तरीकों को "खींचना" आवश्यक है।

  // ... $this->app['decryptedinput'] = $this->app->share(function($app) { //   DecryptedInput    // Input',  )    , //  )      // use MySecureApp/Cryptography/DecryptedInput //   ,     //  Cryptography,   return new DecryptedInput($app['cryptography']); }); // ...

खैर, हम जारी रख सकते हैं :) जैसा कि मैंने पहले ही उल्लेख किया है, सभी क्लाइंट-सर्वर इंटरैक्शन ApiController के माध्यम से होता है । इस नियंत्रक की विशेषता क्या है?

एनक्रिप्टेड डेटा उसे ट्रांसफर कर दिया जाता है
इसे एक एन्क्रिप्टेड प्रतिक्रिया वापस करनी चाहिए।

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

ठीक है, चलो इस फिल्टर को लिखें। निम्नलिखित सामग्रियों से एप्लिकेशन / lib / MySecureApp / Filters में OutgoingCryptFilter.php फ़ाइल बनाएं:

 <?php namespace MySecureApp\Filters; use MySecureApp\Cryptography\Cryptography; use MySecureApp\Helpers\Base64; /** * Class OutgoingCryptFilter * Encrypts and signs the response * * @package MySecureApp\Filter */ class OutgoingCryptFilter { private $crypt; public function __construct(Cryptography $crypt) { //      , //        //  Cryptography - Laravel    $this->crypt = $crypt; } //   public function filter($route, $request, $response) { //    ,   //   $content = $response->getOriginalContent(); if (!is_string($content)) { $content = json_encode($content); } //   $content = Base64::UrlEncode($this->crypt->aesEncrypt($content)); //    $sign = Base64::UrlEncode($this->crypt->rsaSign($content)); //    (  ) : // 'data' => $content, -  // 'sign' => $sign, -  // ""   ,     $response->setContent(['data' => $content, 'sign' => $sign]); } }

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

अब आपको इस फ़िल्टर को पंजीकृत करने की आवश्यकता है। हमने यहां दार्शनिकता हासिल नहीं की है और इसके लिए दिए गए स्थान का उपयोग करें: app / filter.php :

 //   cryptOut Route::filter('cryptOut', 'MySecureApp\Filters\OutgoingCryptFilter');

बस थोड़ा सा बचा है। कम से कम दो विधियों के साथ नियंत्रक स्वयं लिखें: क्लाइंट और सर्वर (तथाकथित हैंडशेक) और डेटा को वापस करने वाले कुछ थ्रेड प्रदर्शन विधि के बीच कनेक्शन को इनिशियलाइज़ करना।

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

तो, यहाँ ApiController नियंत्रक संरचना है :

 <?php use MySecureApp\Cryptography\Cryptography; class ApiController extends BaseController { /** * @var Crypt */ private $crypt; public function __construct(Cryptography $crypt) { $this->crypt = $crypt; //  after- (    ) //     :    except: //       postInit,    //       $this->afterFilter('cryptOut', array('except' => 'postInit')); } //  ()     //   :    RSA- //   AES .     : key  iv public function postInit() { // ,    if (!(Input::has('key') && Input::has('iv'))) { return 'ERROR 1'; } //     $key  $iv extract(Input::only('key', 'iv')); //   $key = $this->crypt->rsaDecrypt($key); $iv = $this->crypt->rsaDecrypt($iv); //       == false (  ) //    if (!($key && $iv)) { return 'ERROR 2'; } //  AES   $this->crypt->initAes(array( 'key' => $key, 'iv' => $iv, )); return 'OK'; } }

यह क्लाइंट-सर्वर इंटरैक्शन का इनिशियलाइज़ेशन था। सफल होने पर, ग्राहक बस एक पाठ संदेश वापस कर देगा ठीक है। त्रुटि के मामले में, ERROR। मैंने जानबूझकर त्रुटि के बारे में एक पाठ संदेश नहीं लौटाया - संभावित पटाखा को यह जानने की आवश्यकता नहीं है कि क्या चल रहा है।

अब आइए कुछ विधि लिखें जो पहले से ही एन्क्रिप्शन की आवश्यकता होगी। मैं प्राधिकरण लिखने का सुझाव देता हूं। क्लाइंट हमें अपना ईमेल और पासवर्ड भेजता है, और जवाब में, सर्वर डेटा लौटाता है: क्लाइंट ने सफलतापूर्वक लॉग इन किया है या नहीं, और जब उसका लाइसेंस समाप्त हो जाए। मैं केवल नियंत्रक और Dto ऑब्जेक्ट LoginResponse तक सीमित रहूंगा । हर कोई खुद के लिए एक मॉडल लिख सकता है, प्रदर्शन के लिए यह शानदार होगा।

सबसे पहले, सभी सर्वर प्रतिक्रियाओं के लिए एक बेस क्लास बनाएं। app / lib / MySecureApp / Dto / Responses / ResponseBase.php :

 <?php namespace MySecureApp\Dto\Responses; abstract class ResponseBase implements \JsonSerializable { //   public $type; }

कहीं आसान नहीं है। एक वर्ग का केवल एक क्षेत्र होता है - यह एक प्रतिक्रिया प्रकार होता है। इस क्षेत्र के लिए धन्यवाद, ग्राहक एक पैकेज मैनेजर की तरह कुछ लिखने में सक्षम होगा। अब हम एक विशिष्ट उत्तर लिखेंगे : LoginResponse ( app / lib / MySecureApp / Dto / Responses / LoginResponse.php ):

 <?php namespace MySecureApp\Dto\Responses; class LoginResponse extends ResponseBase { const LOGIN_SUCCESS = true; const LOGIN_FAIL = false; public $loginResult; //   public $expire; // ,      public function __construct() { $this->type = 'login'; $this->expire = '0000-00-00 00:00:00'; } /** * (PHP 5 &gt;= 5.4.0)<br/> * Specify data which should be serialized to JSON * @link http://php.net/manual/en/jsonserializable.jsonserialize.php * @return mixed data which can be serialized by <b>json_encode</b>, * which is a value of any type other than a resource. */ public function jsonSerialize() { return [ 'type' => $this->type, 'loginResult' => $this->loginResult, 'expire' => $this->expire, ]; } }

अब पोस्टलाइन नियंत्रक विधि स्वयं :

  public function postLogin() { //    $creds = [ 'email' => DecryptedInput::get('email'), 'password' => DecryptedInput::get('password'), ]; $response = new \MySecureApp\Dto\Responses\LoginResponse; if (!Auth::attempt($creds, false)) { //    ,     loginResult $response->loginResult = \MySecureApp\Dto\Responses\LoginResponse::LOGIN_FAIL; //   return json_encode($response); } $response->loginResult = \MySecureApp\Dto\Responses\LoginResponse::LOGIN_SUCCESS; $response->expire = Auth::user()->tariffExpire; return json_encode($response); }

खैर, बस इतना ही। 4 वीं और 5 वीं लाइनों पर ध्यान दें - हम POST में हमारे लिए प्रेषित डेटा प्राप्त करने के लिए DecryptedInput का उपयोग करते हैं।

सादर,
अलेक्जेंडर [अमीगा] ईगोरोव।

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

मैं स्थिति को कैसे ठीक कर सकता हूं (मैं केवल एक सिद्धांत दूंगा, बिना कोड के - मैं इसे होमवर्क के रूप में आपको छोड़ दूंगा)?

सबसे पहले, एक वर्ग के लिए एक सार्वभौमिक इंटरफ़ेस बनाएं जो एन्क्रिप्शन / डिक्रिप्शन के लिए कार्यक्षमता प्रदान करता है। एसिमिट्रिक डीक्रिप्ट, सिमिट्रिकइन्क्रिप्ट, आदि जैसी विधियों के साथ। और वर्तमान क्रिप्टोग्राफी वर्ग को इस इंटरफ़ेस से विरासत में मिला है और इसे एक अधिक विशिष्ट RsAAesCryptography नाम दिया गया है ।

दूसरे, इस इंटरफ़ेस को ऐप कंटेनर में पंजीकृत करें। और जहां भी क्रिप्टोग्राफी के वर्तमान संस्करण में एक इंजेक्शन है , इसे क्रिप्टोग्राफीइंटरफेस के साथ बदलें।

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

अब सब कुछ होने लगा है।

PPS कुछ भूल गया: एक मार्ग जोड़ें। में एप्लिकेशन / routes.php :

 Route::controller('api', 'ApiController');

और हमारे सेवा प्रदाता को पंजीकृत करें। में एप्लिकेशन / config / app.php :

 'providers' => array( // ... 'MySecureApp\Providers\CryptoServiceProvider', ),

UPD : उपरोक्त सभी को लागू करने के लिए तैयार पैकेज लिखा: Amegatron / Cryptoapi

Laravel 4 पर क्लाइंट और सर्वर के बीच एन्क्रिप्टेड संचार

परिचय

क्रिप्टोग्राफी मूल बातें

सर्वर अनुप्रयोग की संरचना के बारे में थोड़ा सा

क्लाइंट-सर्वर इंटरैक्शन

क्रिप्टोग्राफी कार्यान्वयन

More articles: