STM32 के लिए एन्क्रिप्टेड बूटलोडर

इस लेख में मैं फर्मवेयर एन्क्रिप्शन के साथ STM32 के लिए बूटलोडर बनाने के अपने अनुभव के बारे में लिखना चाहूंगा। मैं एक व्यक्तिगत डेवलपर हूं, इसलिए नीचे दिया गया कोड किसी भी कॉर्पोरेट मानकों का अनुपालन नहीं कर सकता है

इस प्रक्रिया में, निम्नलिखित कार्य निर्धारित किए गए थे:

• एसडी कार्ड से डिवाइस उपयोगकर्ता के लिए फर्मवेयर अपडेट प्रदान करें।
• फर्मवेयर की अखंडता का नियंत्रण सुनिश्चित करें और नियंत्रक मेमोरी में गलत फर्मवेयर की रिकॉर्डिंग को बाहर करें।
• डिवाइस क्लोनिंग को रोकने के लिए फर्मवेयर एन्क्रिप्शन प्रदान करें।

कोड Keil uVision में stdperiph, fatFS, और smallAES पुस्तकालयों का उपयोग करके लिखा गया था। प्रयोगात्मक माइक्रोकंट्रोलर STM32F103VET6 था, लेकिन कोड को आसानी से दूसरे एसटीएम नियंत्रक के लिए अनुकूलित किया जा सकता है। इंटीग्रिटी कंट्रोल CRC32 एल्गोरिदम द्वारा दिया गया है, चेकसम फर्मवेयर फाइल के अंतिम 4 बाइट्स में स्थित है।

लेख में एक परियोजना के निर्माण, पुस्तकालयों को जोड़ने, बाह्य उपकरणों को जोड़ने और अन्य तुच्छ चरणों का वर्णन नहीं है।

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

फर्मवेयर के एन्क्रिप्शन को AES128 एल्गोरिथ्म द्वारा निष्पादित किया जाता है और छोटे-छोटे पुस्तकालय का उपयोग करके कार्यान्वित किया जाता है। इसमें केवल दो फाइलें होती हैं, एक एक्सटेंशन .c के साथ, दूसरी एक्सटेंशन .h के साथ, इसलिए इसके कनेक्शन में कोई समस्या नहीं होनी चाहिए।

प्रोजेक्ट बनाने के बाद, आपको लोडर के आकार और मुख्य कार्यक्रम पर निर्णय लेना चाहिए। सुविधा के लिए, आकार को माइक्रोकंट्रोलर के मेमोरी पेज आकार के गुणकों में चुना जाना चाहिए। इस उदाहरण में, बूटलोडर 64 Kb पर कब्जा करेगा, और मुख्य कार्यक्रम शेष 448 Kb पर कब्जा करेगा। बूटलोडर फ्लैश मेमोरी की शुरुआत में स्थित होगा, और बूटलोडर के तुरंत बाद मुख्य कार्यक्रम। इसे Keil में प्रोजेक्ट सेटिंग्स में निर्दिष्ट किया जाना चाहिए। बूटलोडर 0x80000000 पते के साथ शुरू होता है (यह उससे है कि एसटीएम 32 लॉन्च के बाद कोड को निष्पादित करना शुरू कर देता है) और 0x10000 का आकार है, हम इसे सेटिंग्स में दर्शाते हैं।



मुख्य कार्यक्रम 0x08010000 से शुरू होगा और सुविधा के लिए 0x08080000 के साथ समाप्त होगा, हम सभी पते के साथ परिभाषित करेंगे:

#define MAIN_PROGRAM_START_ADDRESS 0x08010000 #define MAIN_PROGRAM_END_ADDRESS 0x08080000 

हम प्रोग्राम में एन्क्रिप्शन कुंजी और एईएस आरंभीकरण वेक्टर भी जोड़ते हैं। ये कुंजी बेतरतीब ढंग से उत्पन्न होती हैं।

 static const uint8_t AES_FW_KEY[] = {0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF}; static const uint8_t AES_IV[] = {0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA}; 

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

 #define FW_START 5 #define FW_READ 1000 #define FW_WRITE 2000 #define FW_FINISH 10000 #define FW_ERROR 100000 

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

 uint32_t t; /*   */ uint32_t fw_step; /*     */ uint32_t fw_buf[512]; /*      */ uint32_t aes_buf[512]; /*       */ /*     Flash-*/ uint32_t idx; /*     */ char tbuf[64]; /*    sprintf */ FATFS FS; /*   fatFS -   */ FIL F; /*   fatFS -  */ case FW_READ: /*   */ { if(f_mount(&FS, "" , 0) == FR_OK) /*   SD-*/ { /* ,     . */ if(f_open(&F, "FIRMWARE.BIN", FA_READ | FA_OPEN_EXISTING) == FR_OK) { f_lseek(&F, 0); /*     */ CRC_ResetDR(); /*    CRC */ lcd_putstr(" ", 1, 0); /*     */ /*        */ idx = MAIN_PROGRAM_START_ADDRESS; fw_step = FW_READ + 10; /*     */ } else {fw_step = FW_FINISH;} /*    -   */ } else {fw_step = FW_FINISH;} /*   SD- -   */ break; } 

अब हमें शुद्धता के लिए फर्मवेयर की जांच करने की आवश्यकता है। यहां, पहले चेकसम वेरिफिकेशन कोड आता है, जब फ़ाइल पढ़ना समाप्त हो जाता है, और तब रीडिंग ही निष्पादित होती है। शायद आपको ऐसा नहीं लिखना चाहिए, टिप्पणियों में लिखें जो आप इसके बारे में सोचते हैं। फ्लैश-मेमोरी के साथ काम करने की सुविधा के लिए रीडिंग 2 केबी में की जाती है, क्योंकि STM32F103VET6 में 2 Kb मेमोरी पेज का आकार है।

 case FW_READ + 10: /*      */ { /*     ,    */ sprintf(tbuf, ": %d", idx - MAIN_PROGRAM_START_ADDRESS); lcd_putstr(tbuf, 2, 1); if (idx > MAIN_PROGRAM_END_ADDRESS) /*      */ { f_read(&F, &t, sizeof(t), &idx); /*  4    */ /*   4       CRC */ CRC_CalcCRC(t); if(CRC_GetCRC() == 0) /*   0,     */ { /*         */ idx = MAIN_PROGRAM_START_ADDRESS; f_lseek(&F, 0); /*     */ fw_step = FW_READ + 20; /*     */ break; } else { lcd_putstr(" ", 3, 2); /*     */ fw_step = FW_ERROR; /*       */ break; } } f_read(&F, &fw_buf, sizeof(fw_buf), &t); /*  2      */ if(t != sizeof(fw_buf)) /*     */ { lcd_putstr(" ", 3, 2); fw_step = FW_ERROR; /*       */ break; } /*     */ AES_CBC_decrypt_buffer((uint8_t*)&aes_buf, (uint8_t *)&fw_buf, sizeof(fw_buf), AES_FW_KEY, AES_IV); for(t=0;t<NELEMS(aes_buf);t++) /*     CRC */ { CRC_CalcCRC(aes_buf[t]); /*    4  */ } idx+=sizeof(fw_buf); /*     2  */ break; } 

अब, यदि फर्मवेयर क्षतिग्रस्त नहीं है, तो आपको इसे फिर से पढ़ने की आवश्यकता है, लेकिन इस बार इसे फ्लैश मेमोरी में लिखें।

 case FW_READ + 20: // Flash Firmware { /*     ,    */ sprintf(tbuf, ": %d", idx - MAIN_PROGRAM_START_ADDRESS); lcd_putstr(tbuf, 4, 2); if (idx > MAIN_PROGRAM_END_ADDRESS) /*     */ { lcd_putstr("", 7, 3); /*     */ f_unlink("FIRMWARE.BIN"); /*     SD- */ fw_step = FW_FINISH; /*   */ break; } f_read(&F, &fw_buf, sizeof(fw_buf), &t); /*   2  */ if(t != sizeof(fw_buf)) /*     */ { lcd_putstr(" ", 3, 3); /*     */ fw_step = FW_ERROR; /*       */ break; } /*     */ AES_CBC_decrypt_buffer((uint8_t*)&aes_buf, (uint8_t *)&fw_buf, sizeof(fw_buf), AES_FW_KEY, AES_IV); FLASH_Unlock(); /*  FLash-   */ FLASH_ErasePage(idx); /*    */ for(t=0;t<sizeof(aes_buf);t+=4) /*    4  */ { FLASH_ProgramWord(idx+t, aes_buf[t/4]); } FLASH_Lock(); /*     */ idx+=sizeof(fw_buf); /*     */ break; } 

अब सुंदरता के लिए, हम त्रुटि से निपटने और सफल अपडेट के लिए राज्यों का निर्माण करेंगे:

 case FW_ERROR: { /*  -     */ break; } case FW_FINISH: { ExecMainFW(); /*    */ /*      */ break; } 

मुख्य कार्यक्रम ExecMainFW () को लॉन्च करने का कार्य अधिक विस्तार से विचार करने योग्य है। यहाँ यह है:

 void ExecMainFW() { /*       */ /*    ,     */ /* +4  ,          */ uint32_t jumpAddress = *(__IO uint32_t*) (MAIN_PROGRAM_START_ADDRESS + 4); pFunction Jump_To_Application = (pFunction) jumpAddress; /*    APB1 */ RCC->APB1RSTR = 0xFFFFFFFF; RCC->APB1RSTR = 0x0; /*    APB2 */ RCC->APB2RSTR = 0xFFFFFFFF; RCC->APB2RSTR = 0x0; RCC->APB1ENR = 0x0; /*     APB1 */ RCC->APB2ENR = 0x0; /*     APB2 */ RCC->AHBENR = 0x0; /*     AHB */ /*      ,   HSI*/ RCC_DeInit(); /*   */ __disable_irq(); /*     */ NVIC_SetVectorTable(NVIC_VectTab_FLASH, MAIN_PROGRAM_START_ADDRESS); /*    */ __set_MSP(*(__IO uint32_t*) MAIN_PROGRAM_START_ADDRESS); /*     */ Jump_To_Application(); } 

स्टार्टअप फ़ाइल शुरू करने के तुरंत बाद, इसने सब कुछ फिर से संगठित कर दिया, इसलिए मुख्य कार्यक्रम को फिर से अपने एड्रेस स्पेस के अंदर इंटरप्ट वेक्टर को पॉइंटर सेट करना चाहिए:

 __disable_irq(); NVIC_SetVectorTable(NVIC_VectTab_FLASH, MAIN_PROGRAM_START_ADDRESS); __enable_irq(); 

मुख्य कार्यक्रम की परियोजना में, आपको सही पते निर्दिष्ट करने की आवश्यकता है:



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

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

 case FW_WRITE: { if(f_mount(&FS, "" , 0) == FR_OK) /*   SD-*/ { /*    */ if(f_open(&F, "FIRMWARE.BIN", FA_WRITE | FA_CREATE_ALWAYS) == FR_OK) { CRC_ResetDR(); /*   CRC */ /*        */ idx = MAIN_PROGRAM_START_ADDRESS; fw_step = FW_WRITE + 10; /*     */ } else {fw_step = FW_ERROR;} /*      */ } else {fw_step = FW_ERROR;} /*      */ break; } case FW_WRITE + 10: { if (idx > MAIN_PROGRAM_END_ADDRESS) /*     */ { t = CRC_GetCRC(); f_write(&F, &t, sizeof(t), &idx); /*       */ f_close(&F); /*  ,   */ fw_step = FW_FINISH; /*   */ } /*  2    Flash-   */ memcpy(&fw_buf, (uint32_t *)idx, sizeof(fw_buf)); for(t=0;t<NELEMS(fw_buf);t++) /*  CRC    */ { CRC_CalcCRC(fw_buf[t]); } /*   */ AES_CBC_encrypt_buffer((uint8_t*)&aes_buf, (uint8_t *)&fw_buf, sizeof(fw_buf), AES_FW_KEY, AES_IV); /*      */ f_write(&F, &aes_buf, sizeof(aes_buf), &t); idx+=sizeof(fw_buf); /*     */ break; } 

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

संदर्भ

tinyAES
FatFS