SHA-3 અલ્ગોરિધમના મુખ્ય અમલીકરણ સાથે પુસ્તકાલયમાં નબળાઈ

XKCP પેકેજ (એક્સ્ટેન્ડેડ કેકેક કોડ પેકેજ) માં ઓફર કરાયેલ SHA-3 (Keccak) ક્રિપ્ટોગ્રાફિક હેશ ફંક્શનના અમલીકરણમાં નબળાઈ (CVE-2022-37454) ઓળખવામાં આવી છે, જે ચોક્કસ ડેટાની પ્રક્રિયા કરતી વખતે બફર ઓવરફ્લો તરફ દોરી શકે છે. સમસ્યા SHA-3 ના ચોક્કસ અમલીકરણના કોડમાં બગને કારણે છે, અને અલ્ગોરિધમમાં જ નબળાઈને કારણે નહીં. XKCP પૅકેજને SHA-3 ના અધિકૃત અમલીકરણ તરીકે ઓળખવામાં આવે છે, કેકેક ડેવલપમેન્ટ ટીમના ઇનપુટ સાથે વિકસાવવામાં આવે છે, અને વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં SHA-3 ફંક્શન્સ માટે આધાર તરીકે ઉપયોગમાં લેવાય છે (દા.ત., XKCP કોડનો ઉપયોગ પાયથોન હેશલિબમાં થાય છે. મોડ્યુલ, રૂબી ડાયજેસ્ટ પેકેજ sha3 અને PHP hash_* કાર્યો).

સમસ્યાની ઓળખ કરનાર સંશોધકના જણાવ્યા અનુસાર, તે હેશ ફંક્શનના ક્રિપ્ટોગ્રાફિક ગુણધર્મોનું ઉલ્લંઘન કરવા અને પ્રથમ અને દ્વિતીય પ્રીઇમેજ શોધવા તેમજ અથડામણો શોધવા માટે નબળાઈનો ઉપયોગ કરવામાં સક્ષમ હતો. વધુમાં, એવી જાહેરાત કરવામાં આવી હતી કે એક પ્રોટોટાઇપ એક્સ્પ્લોઇટ બનાવવામાં આવશે જે ખાસ ડિઝાઇન કરેલી ફાઇલના હેશની ગણતરી કરતી વખતે કોડને એક્ઝિક્યુટ કરવાની મંજૂરી આપશે. નબળાઈનો ઉપયોગ SHA-3 (ઉદાહરણ તરીકે, Ed448) નો ઉપયોગ કરતા ડિજિટલ સિગ્નેચર વેરિફિકેશન એલ્ગોરિધમ્સ પર હુમલો કરવા માટે પણ થઈ શકે છે. દરેક જગ્યાએ નબળાઈ દૂર થઈ ગયા પછી હુમલાની પદ્ધતિઓની વિગતો પછીથી પ્રકાશિત કરવાની યોજના છે.

તે હજી સુધી સ્પષ્ટ નથી કે વ્યવહારમાં અસ્તિત્વમાં રહેલી એપ્લિકેશનોને નબળાઈ કેટલી અસર કરે છે, કારણ કે કોડમાં સમસ્યા પોતાને પ્રગટ કરવા માટે, બ્લોક્સમાં ચક્રીય હેશ ગણતરીઓનો ઉપયોગ કરવો આવશ્યક છે અને પ્રોસેસ્ડ બ્લોક્સમાંના એકનું કદ લગભગ 4 જીબી હોવું જોઈએ (ઓછામાં ઓછું 2^32 - 200 બાઇટ્સ). એક જ સમયે ઇનપુટ ડેટાની પ્રક્રિયા કરતી વખતે (ભાગોમાં હેશની ક્રમિક ગણતરી કર્યા વિના), સમસ્યા દેખાતી નથી. સુરક્ષાની સૌથી સરળ પદ્ધતિ તરીકે, હેશ ગણતરીના એક પુનરાવર્તનમાં સામેલ ડેટાના મહત્તમ કદને મર્યાદિત કરવાનો પ્રસ્તાવ છે.

ઇનપુટ ડેટાના બ્લોક પ્રોસેસિંગમાં ભૂલને કારણે નબળાઈ સર્જાય છે. "int" પ્રકાર સાથે મૂલ્યોની ખોટી સરખામણીને કારણે, બાકી ડેટાનું ખોટું કદ નક્કી કરવામાં આવે છે, જે ફાળવેલ બફરની બહાર પૂંછડી લખવામાં આવે છે. ખાસ કરીને, સરખામણીએ "partialBlock + instance->byteIOIndex" અભિવ્યક્તિનો ઉપયોગ કર્યો હતો, જે ઘટક ભાગોના મોટા મૂલ્યો માટે પૂર્ણાંક ઓવરફ્લો તરફ દોરી જાય છે. વધુમાં, કોડમાં એક અયોગ્ય પ્રકારનું કાસ્ટ "(અનસાઇન્ડ int)(ડેટાબાઇટલેન - i)" હતું, જે 64-બીટ કદ_ટી પ્રકાર સાથે સિસ્ટમો પર ઓવરફ્લોનું કારણ બને છે.

ઉદાહરણ કોડ જે ઓવરફ્લોનું કારણ બને છે: hashlib h = hashlib.sha3_224() m1 = b"\x00" * 1; m2 = b"\x00″ * 4294967295; h.update(m1) h.update(m2) પ્રિન્ટ(h.hexdigest())

સોર્સ: opennet.ru