👏🏿 ☎️ 👩🏾‍⚖️ स्मार्टकार्ड I2C प्रोटोकॉल। एक्सचेंज APDU I2C इंटरफ़ेस के माध्यम से कमांड करता है 🏇🏾 👟 👩‍✈️

परिचय

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

दुर्भाग्य से, तब ऐसा समाधान किसी कारण से फिट नहीं हुआ, हालांकि यदि पहले से तैयार रूसी हार्डवेयर क्रिप्टोग्राफी का उपयोग करना संभव था, तो इससे अंतिम उत्पाद के विकास और बाद के प्रमाणीकरण में काफी तेजी आएगी। और USB टोकन या स्मार्टकार्ड का उपयोग करने की असंभवता के कारण बहुत सामान्य थे: डिवाइस को काफी कॉम्पैक्ट होना चाहिए (M2M या IoT डिवाइस के लिए एक छोटा मॉड्यूल), मुख्य रूप से रखरखाव-मुक्त मोड में संचालित और एक विस्तृत तापमान रेंज में काम किया।

इस लेख में मैं ए 7001 चिप का उपयोग करके ऐसे मामले के संभावित समाधान के बारे में बात करना चाहता हूं, जो I2C इंटरफ़ेस के माध्यम से सिस्टम से जुड़ा हुआ है।

पीएसी में क्रिप्टोग्राफी को लागू करने की समस्याएं

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

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

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

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

I2C इंटरफ़ेस के साथ स्मार्ट कार्ड माइक्रोकंट्रोलर

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

माइक्रोकंट्रोलर A7001AG (सिक्योर ऑथेंटिकेशन माइक्रोकंट्रोलर) NXP द्वारा निर्मित है। चिप पर डेटाशीट के अनुसार, ए 7001एजी एक माइक्रोकंट्रोलर है जो एक क्रिप्टोग्राफिक कॉपोसेसर के साथ क्लासिक 80C51 आर्किटेक्चर पर आधारित अनधिकृत पहुंच से सुरक्षित है।

पावर सेविंग मोड में, माइक्रोकंट्रोलर 50 μA की खपत करता है। यह 1.62V से 5.5V की सीमा में आपूर्ति वोल्टेज का समर्थन करता है और इसे °25 ° C से + 85 ° C तक के तापमान पर संचालित किया जा सकता है।

बाहरी उपकरणों के साथ बातचीत करने के लिए, I2C दास इंटरफ़ेस का उपयोग 100 kbit / s तक की गति के साथ किया जाता है।

माइक्रोकंट्रोलर कई आवास विकल्पों में उपलब्ध है। मैं HVQFN32 प्रारूप में समाप्त हुआ। यह एक प्लास्टिक का मामला है जो 32 संपर्कों के साथ 5x5x0.85 मिमी और 0.5 मिमी की पिच को मापता है।

मामले की उपस्थिति:

उसका पिनआउट:

A7001 चिप को जोड़ने के लिए मेजबान प्रणाली

हेल्ट के ESP32 वाईफाई किट 32 बोर्ड को I2C इंटरफ़ेस के साथ मेजबान सिस्टम के लेआउट के रूप में लिया गया था। इसकी लागत 1000 रूबल से कम है, इसमें सभी आवश्यक वायर्ड और वायरलेस इंटरफेस हैं, लिथियम बैटरी को चार्जिंग सर्किट के साथ जोड़ने के लिए एक कनेक्टर है, साथ ही 0.96-इंच का ओएलईडी डिस्प्ले भी है।

विभिन्न IoT और M2M उपकरणों के प्रोटोटाइप के लिए एक लगभग सही प्रणाली, जिसे मैं लंबे समय से खेलना चाहता हूं।

बोर्ड को देशी विकास के माहौल और Arduino IDE दोनों में प्रोग्राम किया जा सकता है। इसके साथ काम करने के लिए कई उदाहरण हैं। सादगी के लिए, मैं मानक Arduino IDE पर बस गया।

सर्किट आरेख

A7001 चिप को जोड़ने के लिए सर्किट आरेख चित्र में दिखाया गया है। ~~यह अनुशंसित डेटाशीट से थोड़ा अलग है।~~ निर्माता के विवरण के अनुसार, टर्मिनल 22 (रीसेट सिग्नल RST_N) में उच्च क्षमता होनी चाहिए, लेकिन सर्किट इस योजना के अनुसार शुरू नहीं हुआ। "वैज्ञानिक प्रहार" के परिणामस्वरूप, नकारात्मक पावर कंडक्टर के लिए पुल-अप रोकनेवाला आर 4 को जोड़कर संचालन क्षमता हासिल की गई थी।

अद्यतन: जैसा कि टिप्पणियों में सुझाया गया है, स्कीमा डेटशीट से मेल खाती है, जबकि आउटपुट विवरण ने मुझे भ्रमित किया

RST_N - रीसेट इनपुट, सक्रिय LOW

सर्किट को एक छोटे ब्रेडबोर्ड पर इकट्ठा किया जाता है। पावर और I2C सिग्नल चार कनेक्टिंग तारों से जुड़े होते हैं, और ESP32 मॉड्यूल खुद ही कंप्यूटर के माध्यम से यूएसबी से जुड़ा होता है ताकि पूरे सर्किट को पावर प्राप्त हो सके और फ़र्मवेयर भरें।

स्मार्ट कार्ड I2C प्रोटोकॉल

जब मैंने पहली बार I2C बस के माध्यम से स्मार्ट कार्ड माइक्रोकंट्रोलर्स को जोड़ने के बारे में सुना, तो उन्होंने मुझे समझाया कि स्मार्ट कार्ड इंटरफ़ेस (GOST R ISO / IEC 7816-3-2013) की भौतिक परत को I2C (SMBus) से बदल दिया गया था, और बाकी सब हमेशा की तरह काम किया APDU आदेशों का उपयोग करके GOST R ISO / IEC 7816-4-2013 के अनुसार स्मार्ट कार्ड।

यह पता चला कि यह बिल्कुल सच नहीं है, या बिल्कुल नहीं है। एक उच्च स्तर पर माइक्रोकंट्रोलर के साथ बातचीत पारंपरिक APDU आदेशों का उपयोग करके होती है, लेकिन साथ ही साथ कुछ "buts" भी थे।

I2C इंटरफ़ेस (SMBus) ru.wikipedia.org/wiki/I%C2%B2C गुलाम संबोधन वाली एक बस है, जो धारावाहिक UART के इंटरफ़ेस से मूलभूत रूप से भिन्न है, जो बिंदु-दर-बिंदु आधार पर दो उपकरणों को संप्रेषित करने के लिए डिज़ाइन किया गया है और पते का उपयोग नहीं कर रहा है । इसका अर्थ है कि सभी संचारित डेटा (APDU कमांड) I2C बस डेटा प्रारूप में "पैक" होने चाहिए।
स्मार्ट कार्ड के साथ काम अपने रीसेट से शुरू होता है, आमतौर पर बिजली बंद करके, उदाहरण के लिए, कार्ड रीडर से कार्ड को शारीरिक रूप से हटाने। रीसेट के बाद, स्मार्ट कार्ड पहले एटीआर (उत्तर को रीसेट करें) डेटा ब्लॉक को भेजता है, जिसमें स्मार्ट कार्ड के साथ इंटरैक्शन को कॉन्फ़िगर करने के लिए आवश्यक कॉन्फ़िगरेशन जानकारी शामिल है।
और I2C बस पर चिप कोई अपवाद नहीं है, लेकिन उस स्थिति में जहां माइक्रोकंट्रोलर को मुद्रित सर्किट बोर्ड में मिलाप किया जाना चाहिए, इसमें माइक्रोक्रेकिट का पावर सप्लाई सर्किट या रीसेट आउटपुट का सॉफ्टवेयर नियंत्रण नहीं हो सकता है। इसलिए, चिप का रीसेट I2C प्रोटोकॉल कमांड के स्तर पर, सहित, लागू किया गया है।

इन और अन्य मुद्दों को स्मार्ट कार्ड I2C प्रोटोकॉल के माध्यम से संबोधित किया जाता है, जिसका एक विवरण NXP वेबसाइट www.nxp.com/docs/en/supporting-information/AN12207.pdf पर पाया जा सकता है।

सॉफ्टवेयर हिस्सा है

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

Arduino IDE के लिए स्केच स्रोत

#include <Wire.h> #include <vector> // I2C address on chip A7001 #define ADDR_A7001 static_cast<uint16_t>(0x48) using namespace std; typedef std::vector<uint8_t> vect; //-------------------------------------------------------------------------- // Output dump data by serial port void vect_dump(const char * prefix, const vect & v, const size_t start = 0, const size_t count = 0) { if(prefix) { Serial.print(prefix); } if(v.size() < start) { Serial.println("Empty"); return; } for(size_t i=0; i < (v.size()-start) && (count == 0 || i < count); i++) { uint8_t b = v[start + i]; // Format output HEX data if(i) Serial.print(" "); if(b < 0x0F) Serial.print("0"); Serial.print(b, HEX); } Serial.println(""); } //-------------------------------------------------------------------------- // Send array bytes by I2C to address A7001 and read response result_size bytes vect sci2c_exchange(const vect data, const uint8_t result_size) { Wire.beginTransmission(ADDR_A7001); Wire.write(data.data(), data.size()); Wire.endTransmission(false); Wire.requestFrom(ADDR_A7001, result_size, true); //delay(1); vect result(result_size, 0); if(result_size >= 2) { result[0] = Wire.read(); // Data size CDB result[1] = Wire.read(); // PCB for(size_t i=2; i<result.size()-2 && Wire.available(); i++) { result[i+2] = Wire.read(); } } return result; } //-------------------------------------------------------------------------- // Read Status Code uint8_t sci2c_status(const char * msg = nullptr) { vect v = sci2c_exchange({0b0111}, 2); uint8_t status = v[1] >> 4; if(msg) { Serial.print(msg); // Prefix switch(status) { case 0b0000: Serial.println("OK (Ready)"); break; case 0b0001: Serial.println("OK (Busy)"); break; case 0b1000: Serial.println("ERROR (Exception raised)"); break; case 0b1001: Serial.println("ERROR (Over clocking)"); break; case 0b1010: Serial.println("ERROR (Unexpected Sequence)"); break; case 0b1011: Serial.println("ERROR (Invalid Data Length)"); break; case 0b1100: Serial.println("ERROR (Unexpected Command)"); break; case 0b1101: Serial.println("ERROR (Invalid EDC)"); break; default: Serial.print("ERROR (Other Exception "); Serial.print(status, BIN); Serial.println("b)"); break; } } return status; } static uint8_t apdu_master_sequence_counter = 0; // Sequence Counter Master, Master to Slave //-------------------------------------------------------------------------- // Send APDU void sci2c_apdu_send(const vect apdu) { vect_dump("C-APDU => ", apdu); vect data(2, 0); // 0x00 - Master to Slave Data Transmission command + reserve to length data.insert(data.end(), std::begin(apdu), std::end(apdu)); data[0] |= (apdu_master_sequence_counter << 4); if(++apdu_master_sequence_counter > 0b111) { apdu_master_sequence_counter = 0; } data[1] = data.size() - 2; sci2c_exchange(data, 2); delay(10); sci2c_status(""); } //-------------------------------------------------------------------------- // Receive APDU vect sci2c_apdu_recv(uint8_t result_size) { Wire.beginTransmission(ADDR_A7001); Wire.write(0b0010); // 0010b - Slave to Master Data Transmission command Wire.endTransmission(false); Wire.requestFrom(ADDR_A7001, result_size, true); vect result(result_size, 0); for(size_t i=0; i<result.size() && Wire.available(); i++) { result[i] = Wire.read(); } vect_dump("R-APDU <= ", result); return result; } //-------------------------------------------------------------------------- void setup(){ Wire.begin(); Serial.begin(9600); while (!Serial); Serial.println(""); Serial.println("Smart Card I2C Protocol Arduino demo on A7001"); Serial.println(""); sci2c_exchange({0b00001111}, 2); //The bits b0 to b5 set to 001111b indicate the Wakeup command. sci2c_status("Status Wakeup: "); sci2c_exchange({0b00001111}, 2); //The bits b0 to b5 set to 001111b indicate the Wakeup command. sci2c_status("Status Wakeup: "); // Soft Reset sci2c_exchange({0b00011111}, 2); //The bits b0 to b5 set to 011111b indicate the Soft Reset command. delay(5); // Wait at least tRSTG (time, ReSeT Guard) sci2c_status("Status SoftReset: "); // Read ATR vect ATR = sci2c_exchange({0b101111}, 29+2); //The bits b0 to b5 set to 101111b indicate the Read Answer to Reset command. sci2c_status("Status ATR: "); vect_dump("ATR: ", ATR, 2); // Parameter Exchange // The bits b0 to b5 set to 111111b of the PCB send by the master device indicate the Parameter Exchange command. // The bits b6 and b7 of the PCB send by the master device code the CDBIsm,max(Command Data Bytes Integer, Slave to Master, MAXimum) vect CDB = sci2c_exchange({0b11111111}, 2); sci2c_status("Status CDB: "); vect_dump("CDB: ", CDB, 1); // Further examples of the exchange of APDU // Exchanges APDU from exmaple chapter sci2c_apdu_send({0x00, 0xA4, 0x04, 0x04, 0x04, 0x54, 0x65, 0x73, 0x74, 0x00}); sci2c_status("Status Test send: "); sci2c_apdu_recv(3+1); // R-APDU size + 1 byte PBC sci2c_status("Status Test recv: "); // Read Card Production Life Cycle sci2c_apdu_send({0x80, 0xCA, 0x9F, 0x7F, 0x00}); sci2c_status("Status card LC send: "); sci2c_apdu_recv(0x30+1); // R-APDU size + 1 byte PBC sci2c_status("Status card LC recv: "); // Read Card Info sci2c_apdu_send({0x80, 0xCA, 0x00, 0x66, 0x00}); sci2c_status("Status card info send: "); sci2c_apdu_recv(0x51+1); // R-APDU size + 1 byte PBC sci2c_status("Status card info recv: "); // Read Key Info sci2c_apdu_send({0x80, 0xCA, 0x00, 0xE0, 0x00}); sci2c_status("Status key send: "); sci2c_apdu_recv(0x17+1); // R-APDU size + 1 byte PBC sci2c_status("Status key recv: "); // Again exchanges APDU from exmaple chapter sci2c_apdu_send({0x00, 0xA4, 0x04, 0x04, 0x04, 0x54, 0x65, 0x73, 0x74, 0x00}); sci2c_status("Status Test send: "); sci2c_apdu_recv(3+1); // R-APDU size + 1 byte PBC sci2c_status("Status Test recv: "); Serial.println("Done!\n"); } //-------------------------------------------------------------------------- void loop() { delay(100); }

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

हां, और वायर कोड के सामान्य उदाहरणों ने पहली बार काम नहीं किया, लेकिन ~~टैम्बोरिन~~ कीबोर्ड के साथ कुछ नृत्य करने के बाद, कई लीटर कॉफी, यैंडेक्स और गूगल में यैंडेक्स में गुग्लिंग, एक समाधान पाया गया।

 Wire.write ( ); Wire.endTransmission (false); Wire.requestFrom (ADDR_A7001, 2, true);

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

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

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

A7001 चिप के साथ काम करने के लिए कोड उदाहरण

उदाहरणों में, मैं कई सहायक कार्यों का उपयोग करता हूं:

vect_dump - डिबग पोर्ट में HEX प्रारूप में आउटपुट डंप डेटा;
Sci2c_exchange - I2C के माध्यम से डेटा की एक सरणी भेजें और प्रतिक्रिया बाइट्स की निर्दिष्ट संख्या पढ़ें;
Sci2c_status - microcircuit की प्रतिक्रिया स्थिति पढ़ें और, यदि आवश्यक हो, तो डिबग पोर्ट में इसकी स्थिति प्रदर्शित करें;
Sci2c_apdu_send - APDU कमांड भेजें;
Sci2c_apdu_recv - APDU कमांड का जवाब पढ़ें।

माइक्रोचिप आरंभीकरण

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

नरम रीसेट

यहां सब कुछ सरल है, हम एक रिबूट कमांड भेजते हैं और निर्धारित समय की प्रतीक्षा करते हैं:

 sci2c_exchange ({0b00011111}, 2); delay(5); //      (tRSTG, time, ReSeT Guard)

रिसेट का उत्तर पढ़ें

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

 vect ATR = sci2c_exchange({0b101111}, 29+2); // 29  + 1  PCB + 1  —   vect_dump("ATR: ", ATR);

ATR डेटा पढ़ें: 1E 00 00 00 B8 03 11 01 05 B9 02 01 01 BA 01 01 01 0 0 41 41 30 30 31 43 47 20 32 34 32 52 31

जहां 1E लौटाए गए डेटा का आकार (29 बाइट्स + पीसीबी का 1 बाइट) है और 00 पीसीबी (प्रोटोकॉल कंट्रोल बाइट) है, जो 0 के बराबर होना चाहिए और जाहिर है, इस उदाहरण में डेटा सही ढंग से नहीं पढ़ा गया था (पीसीबी का एक बाइट होना चाहिए) और उनमें से तीन) हैं।

निम्नलिखित डेटा TLV प्रारूप में एन्कोडेड है:

B8h - निम्न स्तर की डेटा ऑब्जेक्ट , आकार 3 बाइट्स ( 11h 01h 05h );
बी 9 एच - प्रोटोकॉल बाइंडिंग डेटा ऑब्जेक्ट , आकार में 2 बाइट्स ( 01h 01h );
BAh - उच्च परत डेटा ऑब्जेक्ट , आकार में 1 बाइट ( 01h );
BBh - ऑपरेटिंग सिस्टम डेटा ऑब्जेक्ट , 13 बाइट्स ( 41 37 30 30 31 43 47 20 32 32 32 52 31 )।

चिप के रीड कॉन्फ़िगरेशन का डिक्रिप्शन
निम्न स्तर डेटा ऑब्जेक्ट : 11h - समर्थित प्रोटोकॉल के प्रमुख और मामूली संस्करण।

त्रुटि पहचान कोड : 01h - LRC (अनुदैर्ध्य अतिरेक कोड) का उपयोग करके प्रेषित डेटा की त्रुटि का पता लगाने और अखंडता नियंत्रण के लिए समर्थन।

फ़्रेम वेटिंग पूर्णांक (एफडब्ल्यूआई) : 05 एच - दो कमांड के बीच अधिकतम विलंब। मानों की सीमा 10 ms से 5120ms तक हो सकती है, डिफ़ॉल्ट 5120ms है। मान की गणना सूत्र T = 10ms x 2 ^ FWI द्वारा की जाती है। जो इस मामले में हमें 320 एमएस (10ms x 2 ^ 5) की देरी देता है।

प्रोटोकॉल बाइंडिंग डेटा ऑब्जेक्ट - दो मान शामिल हैं, 01h 01h , जो समर्थित प्रोटोकॉल और डिफ़ॉल्ट प्रोटोकॉल को एन्कोड करता है। इन मूल्यों का मतलब APDU प्रोटोकॉल [GOST R ISO / IEC 7816-3-2013] के लिए समर्थन है, और, जैसा कि आप अनुमान लगा सकते हैं, उसी प्रोटोकॉल को डिफ़ॉल्ट रूप से स्थापित किया गया है।

उच्च परत डेटा ऑब्जेक्ट - संख्या 01h का अर्थ है लघु और विस्तारित APDU प्रारूप के लिए समर्थन।

ऑपरेटिंग सिस्टम डेटा ऑब्जेक्ट आकार में 15 बाइट्स तक एक पहचानकर्ता है, जैसा कि मानक [GOST R ISO / IEC 7816-4-2013] में परिभाषित किया गया है। हमारे मामले में, यह स्ट्रिंग " ए 7001 सीजी 242 आर 1 " है।

मास्टर डिवाइस पैरामीटर का आदान-प्रदान करता है

एक्सचेंज सेटिंग्स को इनिशियलाइज़ करने की अंतिम कमांड:

 vect CDB = sci2c_exchange({0b11111111}, 2); sci2c_status("Status CDB: "); vect_dump("CDB: ", CDB, 1);

रिटर्न वैल्यू: CCh - (11001100b) डेटशीट के अनुसार, 4 और 5 बिट्स बिट्स 2 और 3 के बिट वाइज निगेटिव होने चाहिए (एनएनबी बिटवाइड नेगेटिव सीडीबीआईएमएस, मैक्स) को कोड करता है और, एन्कोडिंग वैल्यू के अनुसार, चिप 252 बाइट्स सीडीबीआईएमएस की अधिकतम संभावित कमांड साइज का समर्थन करता है। , मैक्स (कमांड डेटा बाइट्स इंटेगर, मास्टर टू स्लेव, मैक्सिमम) मूल्य।

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

एपीडीयू कमांड का निष्पादन

APDU आदेशों को निष्पादित करने के प्रत्येक चक्र में निम्नलिखित चरण होते हैं:

APDU (मास्टर टू स्लेव डेटा ट्रांसमिशन कमांड) को भेजें।
कमांड प्राप्त करने और संसाधित करने के लिए सुरक्षात्मक समय की प्रतीक्षा करें।
स्थिति (स्थिति कमांड) पढ़ने के लिए कमांड के प्रसंस्करण की प्रतीक्षा करें।
प्रतिक्रिया डेटा पढ़ें (स्लेव टू मास्टर डेटा ट्रांसमिशन कमांड)।

यह तर्क Sci2c_apdu_send और Sci2c_apdu_recv फ़ंक्शन में लागू किया गया है, और यहां एक महत्वपूर्ण बिंदु है: स्मार्ट कार्ड I2C प्रोटोकॉल के प्रारूप में, प्रेषित APDU आदेशों के काउंटर हैं। इन काउंटरों को मास्टर और स्लेव डिवाइस दोनों को नियंत्रित करना होगा और उन्हें प्रेषित डेटा के अनुक्रम को नियंत्रित करने के लिए डिज़ाइन किया गया है, ताकि रिसेप्शन त्रुटि के मामले में APDU डेटा को फिर से प्रसारित या अनुरोध करना संभव हो सके।

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

डेटाशीट से उदाहरण:

C-APDU => 00 A4 04 04 04 54 65 73 74 00 - "टेस्ट" नाम के साथ फाइल पढ़ें।
R-APDU <= 6A 86 - डेटाशीट के अनुसार, उत्तर 64 82 होना चाहिए ( फ़ाइल या एप्लिकेशन नहीं मिला ), लेकिन हमारे मामले में फर्मवेयर माइक्रोक्रिकिट पर अपलोड किया गया है, और उत्तर प्रलेखन में वर्णित उदाहरण से अलग है।

कार्ड उत्पादन जीवन चक्र पढ़ना

C-APDU => 80 CA 9F 7F 00
R-APDU <= 9F 7F 2A 47 90 51 67 47 91 12 10 38 00 53 56 00 40 39 73 50 48 48 53 53 00 00 00 00 00 13 13C 19 30 30 33 39 00 00 00 00 00 00 00 00 90 00

पढ़ें कार्ड की जानकारी

C-APDU => 80 CA 00 66 00
R-APDU <= 66 4C 73 4A 06 07 2A 86 48 86 FC 6B 01 60 0C 06A 2A 86 48 86 FC 6B 02 02 01 01 09 09 07 07A 86 48 86 FC 6B 03 64 0 0 06 06 09 2A 86 48 86 एफसी 6 बी 04 02 55 65 65 0 बी 06 09 2 बी 85 10 86 48 64 02 01 03 66 0 सी 06 बी 2 बी 06 01 01 ए 02 6 ई 01 02 90 00

पढ़ें प्रमुख जानकारी

C-APDU => 80 CA 00 E0 00
R-APDU <= E0 12 C0 04 01 FF 80 10 C0 04 02 FF 80 10 C0 04 03 FF 80 10 90 00

निष्कर्ष में

I2C इंटरफ़ेस के माध्यम से APDU टीमों के आदान-प्रदान को लागू करने का यह अनुभव बहुत दिलचस्प था। मैंने खुद को कई बार यह सोचते हुए पाया कि मुझे सर्किटरी के क्षेत्र से और साधारण सोल्डरिंग से विभिन्न मुद्दों को हल करने में मज़ा आता है, साथ ही, आखिरी बार जब मुझे 5 साल से अधिक समय पहले टांका लगाने वाला लोहा लेना पड़ा था।

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

स्मार्टकार्ड I2C प्रोटोकॉल। एक्सचेंज APDU I2C इंटरफ़ेस के माध्यम से कमांड करता है