lord-feistel/power_analysisप्रूफ-ऑफ-कॉन्सेप्ट जो Arduino (Atmega328P) पर एक कमजोर RSA कार्यान्वयन के विरुद्ध पावर विश्लेषण साइड-चैनल हमले को प्रदर्शित करता है, विस्तृत हार्डवेयर सेटअप और माप पद्धति सहित।
हाल ही में, मैंने देखा कि लोग स्वयं Arduino के लिए क्रिप्टोग्राफी लागू कर रहे हैं, जैसा कि stackoverflow पर इस विषय में कहा गया है:
https://stackoverflow.com/questions/39189065/rsa-encryption-decryption-functions-for-arduino
इनमें से कई इंटरनेट पर पाए जा सकते हैं, कुछ तो प्रसिद्ध पुस्तकालयों में भी हैं।
मैंने यह छोटा PoC (प्रूफ ऑफ कॉन्सेप्ट) करने का निर्णय लिया ताकि यह दिखाया जा सके कि अपना स्वयं का क्रिप्टोग्राफी एल्गोरिदम न बनाना क्यों महत्वपूर्ण है, बल्कि ऐसे एल्गोरिदम का एक मजबूत कार्यान्वयन भी उपयोग करना चाहिए।
यह PoC RSA कार्यान्वयन (तेज घातांक) में उपयोग की जाने वाली एक सहायक रूटीन के खराब कार्यान्वयन के विरुद्ध एक साइड-चैनल हमला (पावर एनालिसिस अटैक) करता है।
साइड-चैनल हमला एक क्रिप्टोग्राफिक सिस्टम से समझौता करने की एक विधि है जो सीधे क्रिप्टोग्राफिक एल्गोरिदम या प्रोटोकॉल पर हमला करने के बजाय अप्रत्यक्ष सूचना रिसाव का शोषण करती है।
इस प्रकार का रिसाव विभिन्न स्रोतों जैसे समय की जानकारी, बिजली की खपत, विद्युत चुम्बकीय उत्सर्जन, या यहां तक कि ध्वनि से उत्पन्न हो सकता है।
ऐसे हमले RSA जैसी क्रिप्टोग्राफिक प्रणालियों से समझौता करने में अत्यधिक प्रभावी हो सकते हैं, बिना इस आवश्यकता के कि हमलावर को उन अंतर्निहित गणितीय समस्याओं को हल करना पड़े जो क्रिप्टोग्राफिक योजना की सुरक्षा सुनिश्चित करती हैं (Kocher, Jaffe, & Jun, 1999)।
यह पेपर Arduino (Atmega328P) के फर्मवेयर में RSA एल्गोरिदम के एक कार्यान्वयन में एक सुविख्यात कमजोरी पर पावर एनालिसिस अटैक करेगा।
नोट: मैंने इसे जल्दबाजी में किया है, कृपया वर्तनी/व्याकरण की त्रुटियों के लिए मुझे क्षमा करें जो आपको मिल सकती हैं।
पावर एनालिसिस अटैक में क्रिप्टोग्राफिक संक्रियाओं के दौरान किसी उपकरण की बिजली खपत को मापना शामिल है।
डिफरेंशियल पावर एनालिसिस (DPA) में गुप्त जानकारी निकालने के लिए कई क्रिप्टोग्राफिक संक्रियाओं में बिजली खपत पैटर्न का सांख्यिकीय विश्लेषण शामिल है, जो इसे सिंपल पावर एनालिसिस (SPA) से अधिक परिष्कृत बनाता है, जो सीधे बिजली के उतार-चढ़ाव को विशिष्ट क्रिप्टोग्राफिक संक्रियाओं से जोड़ता है ताकि गुप्त जानकारी का अनुमान लगाया जा सके।
डिफरेंशियल पावर एनालिसिस (DPA) और सिंपल पावर एनालिसिस (SPA) का उपयोग RSA गणनाओं के दौरान बिजली खपत पैटर्न का विश्लेषण करके निजी कुंजियाँ निकालने के लिए किया जा सकता है।
ये हमले विभिन्न कुंजी बिट्स से जुड़े विशिष्ट बिजली उपयोग पैटर्न की पहचान करके निजी कुंजी को प्रकट कर सकते हैं (Kocher, Jaffe, & Jun, 1999)।
RSA (Rivest-Shamir-Adleman) एक व्यापक रूप से उपयोग किया जाने वाला सार्वजनिक-कुंजी एन्क्रिप्शन एल्गोरिदम है, जिसका नाम इसके आविष्कारकों: रॉन रिवेस्ट, आदि शमीर और लियोनार्ड एडलमैन के नाम पर रखा गया है, जिन्होंने इसे 1977 में प्रस्तुत किया था (Paar & Pelzl, 2010)।
यह इंटरनेट पर डेटा को सुरक्षित रूप से प्रेषित करने के सबसे सुरक्षित तरीकों में से एक बना हुआ है।
RSA की सुरक्षा की नींव में से एक बड़ी भाज्य संख्याओं को उनके अभाज्य गुणनखंडों में गुणनखंडित करने की कठिनाई में निहित है (Menezes, van Oorschot, & Vanstone, 1996)।
यह समस्या, जिसे गुणनखंडन समस्या के रूप में जाना जाता है, में वे अभाज्य संख्याएँ ढूँढना शामिल है जो एक दी गई बड़ी संख्या बनाने के लिए एक साथ गुणा करती हैं।
RSA एन्क्रिप्शन इस धारणा पर निर्भर करता है कि यह गुणनखंडन समस्या कम्प्यूटेशनल रूप से इतनी कठिन है कि मापांक को उसके अभाज्य गुणनखंडों में गुणनखंडित करके एन्क्रिप्शन को तोड़ना अव्यावहारिक है (Menezes, van Oorschot, & Vanstone, 1996)।
चित्र 1 एक सरल उदाहरण का उपयोग करके RSA एन्क्रिप्शन और डिक्रिप्शन प्रक्रिया को दर्शाता है।
चित्र 1 - RSA उदाहरण।
कृपया ध्यान दें कि इस मामले में, 3 और 33 सार्वजनिक हैं। उदाहरण में संख्या 7 निजी कुंजी है।
Phi (N) फलन, यूलर का टोटिएंट फलन, 1 से 33 के अंतराल में सभी सह-अभाज्य संख्याओं की गणना करता है।
मान 33, P और Q के गुणन से प्राप्त होता है; इस मामले में, 11 को 3 से गुणा किया गया है।
Phi फलन का परिणाम (P - 1) को (Q - 1) से गुणा करके प्राप्त किया जाता है; इस मामले में, 10 को 2 से गुणा किया गया है।
संक्रिया e<sup>-1</sup> mod 20 मॉड्यूलर व्युत्क्रम संक्रिया को दर्शाती है (Menezes, van Oorschot, & Vanstone, 1996)।
नोट: यदि आप RSA में गहराई से जाना चाहते हैं, जो इस पेपर को समझने के लिए आवश्यक नहीं है। इस रिपॉजिटरी में फ़ाइल number_theory.md में इन मूल संख्या सिद्धांत संक्रियाओं का एक त्वरित परिचय है। यह स्पष्टीकरण RSA संक्रियाओं के बारे में आपकी समझ को बढ़ा सकता है।
प्रयोग में Rigol द्वारा निर्मित एक DS1102 ऑसिलोस्कोप (चित्र 2 में प्रस्तुत) का उपयोग किया गया।
ऑसिलोस्कोप का मैनुअल संदर्भों में पाया जा सकता है (RIGOL Technologies, Inc., 2017)।
एक सामान्य बिजली आपूर्ति का भी उपयोग किया गया (चित्र 3 में प्रस्तुत)।
चित्र 2 - प्रयोग में प्रयुक्त ऑसिलोस्कोप।
चित्र 3 - प्रयोग में प्रयुक्त बिजली आपूर्ति।
ओम का नियम विद्युत अभियांत्रिकी और भौतिकी के क्षेत्र में एक मूलभूत सिद्धांत है।
यह बताता है कि दो बिंदुओं के बीच एक चालक के माध्यम से बहने वाली धारा, दो बिंदुओं के पार वोल्टेज के समानुपाती और उनके बीच प्रतिरोध के व्युत्क्रमानुपाती होती है (Boylestad, 2015)।
चित्र 4 एक परिपथ और ओम का नियम दिखाता है।
चित्र 4 - ओम के नियम का चित्रण।
ओम का नियम यह दर्शाता है कि यदि आप किसी चालक के पार वोल्टेज बढ़ाते हैं, तो धारा भी बढ़ेगी, बशर्ते प्रतिरोध स्थिर रहे (Johnson & Hilburn, 2013)। चित्र 5 ओम के नियम के अनुप्रयोग का एक उदाहरण प्रस्तुत करता है जिसका उद्देश्य परिपथ में धारा ज्ञात करना है।
चित्र 5 - ओम के नियम का उदाहरण।
किरचॉफ का वोल्टेज नियम (KVL) विद्युत अभियांत्रिकी और भौतिकी में एक मूलभूत सिद्धांत है (Boylestad, 2015)।
यह बताता है कि किसी भी बंद नेटवर्क या लूप के चारों ओर सभी विद्युत विभव अंतरों (वोल्टेज) का योग शून्य होता है (Boylestad, 2015)।
चित्र 6 किरचॉफ के वोल्टेज नियम को दर्शाता है।
चित्र 6 - किरचॉफ के नियम का चित्रण।
चित्र 7 में किरचॉफ के नियम के अनुप्रयोग का एक उदाहरण है ताकि प्रतिरोधकों R1 और R2 पर धारा ज्ञात की जा सके।
चित्र 7 - किरचॉफ के नियम का उदाहरण।
वोल्टेज विभाजक किरचॉफ के वोल्टेज नियम (KVL) का एक परिणाम है और Vout की गणना करने का एक तरीका बताता है, जो प्रतिरोधक R1 और R2 के बीच का वोल्टेज है।
वोल्टेज विभाजक का सूत्र चित्र 8 में प्रस्तुत किया गया है।
वोल्टेज विभाजक अनुप्रयोग का एक उदाहरण चित्र 9 में प्रस्तुत किया गया है।
चित्र 8 - वोल्टेज विभाजक का चित्रण।
चित्र 9 - वोल्टेज विभाजक का उदाहरण।
शंट रेसिस्टर एक कम मान वाला प्रतिरोधक होता है जिसे परिपथ की बिजली आपूर्ति के साथ श्रेणीक्रम में रखा जाता है ताकि परिपथ के माध्यम से बहने वाली धारा को मापा जा सके।
धारा मापने के लिए शंट का उपयोग करना आधुनिक मल्टीमीटर में उपयोग की जाने वाली तकनीकों में से एक है (Boylestad, 2015)।
शंट रेसिस्टर पर वोल्टेज ड्रॉप को मापना और इसके प्रतिरोध को जानना, ओम के नियम का उपयोग करके धारा की गणना करने के लिए पर्याप्त जानकारी देता है।
Arduino डिवाइस की धारा खपत को मापने के लिए, VCC (धनात्मक) के साथ श्रेणीक्रम में एक शंट रेसिस्टर रखना आवश्यक है।
इसे जिस तरह से जोड़ा जाएगा वह चित्र 10 में प्रस्तुत किया गया है।
नोट 1: कृपया ध्यान दें कि PoC में, Arduino Uno बोर्ड का उपयोग करने के बजाय, लक्ष्य (माइक्रोकंट्रोलर atmega328p) को एक अलग ब्रेडबोर्ड पर स्थानांतरित किया गया है जैसा कि चित्र 11 में प्रस्तुत किया गया है। यह माइक्रोकंट्रोलर के पिनआउट में आसानी से हेरफेर करने की अनुमति देता है, जिसमें सोल्डरिंग की आवश्यकता नहीं होती है।
नोट 2: यदि आप नहीं जानते कि यह कैसे करना है, तो ग्लिचिंग कैसे काम करता है, इस पर मेरा पिछला लेख यह सिखाता है और इसे यहां पाया जा सकता है: https://github.com/lord-feistel/hardware_hacking_lab
चित्र 10 - Arduino के साथ शंट।
चित्र 11 - ब्रेडबोर्ड पर शंट का परिपथ।
शंट रेसिस्टर का उपयोग करके धारा खपत के मापन को प्रदर्शित करने के लिए, एक LED (Sedra & Smith, 2014) को माइक्रोकंट्रोलर के GPIO से जोड़ा जाएगा (चित्र 12) और ऑसिलोस्कोप का उपयोग यह देखने के लिए किया जाएगा कि यह उन स्थितियों में शंट रेसिस्टर पर बिजली की खपत को कैसे प्रभावित करता है जहाँ LED चालू या बंद है।
ध्यान दें: कुंजी निकालने या बिजली की खपत पर चार्जर प्रभाव का निरीक्षण करने के लिए, धारा प्राप्त करने के लिए ओम के नियम का उपयोग करना आवश्यक नहीं है, केवल वोल्टेज ड्रॉप ही पर्याप्त है (Johnson & Hilburn, 2013)।
चित्र 12 - शक्ति मापन।
इसे बेहतर ढंग से देखने के लिए, कृपया वीडियो 1 देखें जो दिखाता है कि जब LED चालू होती है तो वोल्टेज ड्रॉप कैसे होता है।
वीडियो 1 - LED खपत के कारण वोल्टेज ड्रॉप।
LED को ब्लिंक करने के लिए निम्नलिखित कोड का उपयोग किया गया। इसे इस रिपॉजिटरी में भी पाया जा सकता है।```C const int PIN_CHARGE = 9 ; void setup() { pinMode(PIN_CHARGE, OUTPUT);
}
void loop() {
digitalWrite(PIN_CHARGE, HIGH);
delay(10);
digitalWrite(PIN_CHARGE, LOW);
delay(10);
}
यह बताना महत्वपूर्ण है कि यह वोल्टेज ड्रॉप एक जटिल गणना होने पर भी होता है (Kocher, Jaffe, & Jun, 1999)।
निम्नलिखित कोड **चित्र 13** में प्रस्तुत वोल्टेज ड्रॉप का कारण बनता है।```C
void setup() {
}
void loop() {
volatile unsigned long i = 0;
i = ((i + 1) * (i - 1) + (i * i) - (i / 2) * (i % 3) + (i * i * i * i)) * ((i + 2) * (i - 2) + (i * i) - (i / 3) * (i % 5) + (i * i * i * i));
delayMicroseconds(100);
}
यदि वोल्टेज ड्रॉप गणना को प्रतिबिंबित करता है, तो इसका उपयोग संसाधित किए जा रहे डेटा को निर्धारित करने के लिए किया जा सकता है।
चित्र 13 - भारी गणना में बिजली की खपत।
शक्ति संक्रिया करने का पारंपरिक तरीका आधार को n बार गुणा करना है।
मान लीजिए 23 का परिणाम 2*2*2 होगा क्योंकि 2 आधार है और 3 n है।
यह बहुत अच्छा काम करता है, लेकिन RSA को संभव बनाने के लिए पर्याप्त कुशल नहीं है।
ऐसे कार्यान्वयन को प्राप्त करने के लिए तीव्र घातांकन एल्गोरिथ्म का उपयोग किया जाता है।
तीव्र घातांकन, जिसे वर्ग द्वारा घातांकन भी कहा जाता है, किसी संख्या को घात तक बढ़ाने की एक कुशल विधि है।
तीव्र घातांकन के लिए स्यूडो-कोड निम्नलिखित में पाया जा सकता है।```C
function fast_exponentiation(a, b): result = 1 base = a exponent = b
while exponent > 0:
if (exponent % 2 == 1): // If exponent is odd
result = result * base
base = base * base // Square the base
exponent = exponent // 2 // Divide exponent by 2
return result
.
.
2<sup>4</sup> के तीव्र घातांक के चरण **तालिका 1** में पाए जा सकते हैं।
| पुनरावृत्ति | आधार मान | द्विआधारी में घातांक | संक्रिया | परिणाम |
|-------------|------------|-------------------------------|-------------|-----------------------|
| प्रारंभिक | 2 | 100 | प्रारंभ | 1 |
| 1 | 4 | 010 | वर्ग | 1 |
| 2 | 16 | 001 | वर्ग | 1 |
| 3 | 256 | 000 | गुणा | 16 |
| अंतिम | - | - | समाप्त | 16 |
**तालिका 1** - 2<sup>4</sup> के तीव्र घातांक की पुनरावृत्तियाँ।
प्रक्रिया निम्नानुसार समझाई गई है:```
- **Initialization:**
Start with base = 2 , exponent = 4 ( binary 100) , result = 1.
- **Iteration 1:** exponent = 4 (binary 100, even)
Square base to get 4 .
result remains 1.
- **Iteration 2:** exponent = 2 (binary 010, even)
Square base to get 16 .
result remains 1.
- **Iteration 3:** exponent = 1 (binary: 001, odd)
Multiply result by a = 16 to get 16.
result becomes 16.
- **Final:** n = 0 (binary: 000)
The loop ends with result = 16.
ध्यान दें कि छोटी संख्याओं के लिए कुछ भी नहीं बदलता या यह और खराब हो सकता है, हालांकि बड़ी संख्याओं के लिए यह दक्षता में एक महत्वपूर्ण उपलब्धि प्राप्त करता है।
यह सामान्य दृष्टिकोण की तुलना में गुणात्मक संक्रियाओं की संख्या कम करता है, जो विशेष रूप से बड़े घातांकों के लिए उपयोगी है।
तालिका 2 सामान्य घातांक और तीव्र घातांक का उपयोग करके ऐसी संख्या के लिए पुनरावृत्तियों की तुलना दर्शाती है।
तीव्र घातांक RSA में एन्क्रिप्शन और डिक्रिप्शन दोनों प्रक्रियाओं के लिए महत्वपूर्ण है, क्योंकि इन प्रक्रियाओं में बड़ी संख्याओं को किसी अन्य बड़ी संख्या के मॉड्यूलो में बड़ी घातों तक बढ़ाना शामिल है (Paar & Pelzl, 2010)।
जैसा कि RSA उदाहरण अनुभाग में प्रस्तुत किया गया है, कुंजी घातांक है और सामान्यतः यह एक बहुत बड़ी संख्या होगी।
तालिका 2 - पारंपरिक घातांक और तीव्र घातांक के बीच दक्षता की तुलना।
एक तीव्र घातांक को Arduino में कार्यान्वित किया गया और atmega328p में अपलोड किया गया। चूंकि यह एक PoC है, हमने इसे देखने में सबसे आसान तरीके से कार्यान्वित किया।
उदाहरण के लिए, आमतौर पर यह एक पूर्णांक चर पर शिफ्ट संक्रिया का उपयोग करता है, लेकिन हमने घातांक को एक सरणी के रूप में कार्यान्वित किया ताकि इसे बेहतर ढंग से समझा जा सके।
ध्यान दें कि कुंजी को दर्शाने वाला घातांक सरणी {0, 1, 0, 1, 0, 1, 0, 1} है, जो ऑसिलोस्कोप द्वारा अधिग्रहित माप में एक पैटर्न बनाएगा, जो इस बात का प्रमाण है कि यह काम करता है।```C
#include <Arduino.h>
volatile long long dumb_vulnerableExponentiation(volatile long long base, const volatile int* exponentArray, volatile int arrayLength, volatile long long modulo) { volatile long long result = 1; base %= modulo;
for (volatile int i = 0; i < arrayLength; ++i) {
result = (result * result) % modulo;
if (exponentArray[i] == 1) {
result = (result * base) % modulo;
}
}
return result;
}
void setup() { }
void loop() { volatile long long base = 3; volatile long long modulo = 1000000007; const volatile int exponentArray[] = {0, 1, 0, 1, 0, 1, 0, 1}; volatile int arrayLength = sizeof(exponentArray) / sizeof(exponentArray[0]); delay(2); volatile long long result = dumb_vulnerableExponentiation(base, exponentArray, arrayLength, modulo); }
### परिणाम
जैसा कि शुरुआत में प्रस्तुत किया गया है, एन्क्रिप्शन और डिक्रिप्शन ऑपरेशन के लिए कुंजी एक्सपोनेंट है, इसलिए एक्सपोनेंट की खोज करने पर RSA कुंजी उजागर हो जाती है।
पूर्व में उल्लिखित हार्डवेयर का उपयोग करके ऑसिलोस्कोप में बिजली खपत के स्पेक्ट्रम को देखना संभव है जैसा कि **Figure* 14* और **Figure 15** में प्रस्तुत किया गया है।
वे अवधि जिनमें वोल्टेज लंबे समय तक गिरता है, इसका मतलब है कि कुंजी का बिट `1` प्रोसेस हो रहा है, अन्यथा बिट `0` है।
कृपया ध्यान दें कि जब एक्सपोनेंट सम होता है तो एक अतिरिक्त गुणा होता है जिससे ऊर्जा गिरावट अधिक समय लेती है, जिससे कुंजी की जानकारी उजागर होती है।
**Video 2** कुंजी की कैप्चरिंग दिखाता है। कृपया अवधि और आयाम को नियंत्रित करने के तरीके को समझने के लिए ऑसिलोस्कोप मैनुअल देखें।
**Figure 14** - कुंजी कैप्चर करना
**Figure 15** - ऑसिलोस्कोप का उपयोग करके कुंजी के 0 और 1 को उजागर करना
[](https://youtu.be/MBZ1abtTN_k)
**Video 2** - ऑसिलोस्कोप से कुंजी कैप्चर करना।
ऐसा हमला एक ऐसे परिदृश्य में इस्तेमाल किया जा सकता है जहां माइक्रोकंट्रोलर एक प्रसिद्ध लाइब्रेरी का उपयोग कर रहा है, हालांकि फर्मवेयर लॉक है जो हमलावर को सीधे मेमोरी से कुंजी प्राप्त करने की अनुमति नहीं देता है।
इस प्रकार का हमला हार्डवेयर के विरुद्ध भी इस्तेमाल किया जा सकता है।
### निष्कर्ष
अपना स्वयं का RSA (Rivest-Shamir-Adleman) एन्क्रिप्शन सिस्टम लागू करना कई महत्वपूर्ण कारणों से अत्यधिक हतोत्साहित किया जाता है, विशेष रूप से पावर विश्लेषण हमलों जैसे परिष्कृत हमलों के प्रति संवेदनशीलता।
RSA एन्क्रिप्शन, जब सही ढंग से लागू किया जाता है तो गणितीय रूप से मजबूत होता है, लेकिन सुरक्षा सुनिश्चित करने के लिए इसके कार्यान्वयन में विस्तार पर सावधानीपूर्वक ध्यान देने की आवश्यकता होती है।
यहां तक कि मामूली कार्यान्वयन दोष या चूक अनजाने में निजी कुंजी के बारे में जानकारी लीक कर सकते हैं, जिससे पूरे सिस्टम की सुरक्षा से समझौता हो सकता है।
इसके अलावा, स्थापित क्रिप्टोग्राफिक लाइब्रेरी और फ्रेमवर्क सुरक्षा समुदाय द्वारा कठोर जांच और परीक्षण से गुजरते हैं, यह सुनिश्चित करते हुए कि वे ज्ञात हमलों और कमजोरियों के प्रति लचीले हैं। इन जांची-परखी लाइब्रेरी का उपयोग न केवल समय और प्रयास बचाता है बल्कि सिस्टम में अनजाने में कमजोरियां पेश करने के जोखिम को भी काफी कम करता है।
### संदर्भ
1. Understanding Cryptography - Paar, C., & Pelzl, J. (2010). **Understanding Cryptography**. Springer.
2. Handbook of Applied Cryptography - Menezes, A. J., van Oorschot, P. C., & Vanstone, S. A. (1996). **Handbook of Applied Cryptography**. CRC Press.
3. Differential Power Analysis - Kocher, P., Jaffe, J., & Jun, B. (1999). **Differential Power Analysis**. Proceedings of CRYPTO '99, Lecture Notes in Computer Science, vol 1666. Springer, Berlin, Heidelberg. DOI: 10.1007/3-540-48405-1_25.
4. DS1102 Oscilloscope Datasheet - RIGOL Technologies, Inc. (2017). **DS1000E, DS1000D Series Digital Oscilloscope Datasheet**. Retrieved from [RIGOL Datasheet](https://beyondmeasure.rigoltech.com/acton/attachment/1579/f-03b8/1/-/-/-/-/DS1000E_DS1000D_DataSheet_EN.pdf)
5. Introductory Circuit Analysis - Boylestad, R. L. (2015). **Introductory Circuit Analysis** (13th ed.). Pearson.
6. Fundamentals of Electrical Circuits - Johnson, D., & Hilburn, J. L. (2013). **Fundamentals of Electrical Circuits**. McGraw-Hill Education.
7. Microelectronic Circuits - Sedra, A. S., & Smith, K. C. (2014). **Microelectronic Circuits** (7th ed.). Oxford University Press.
| घातांक (b) | द्विआधारी (b) | पारंपरिक घातांक संक्रियाएं | तीव्र घातांक संक्रियाएं |
|---|
| 1 | 1 | 1 | 1 |
| 2 | 10 | 1 | 1 |
| 4 | 100 | 3 | 2 |
| 8 | 1000 | 7 | 3 |
| 16 | 10000 | 15 | 4 |
| 32 | 100000 | 31 | 5 |
| 64 | 1000000 | 63 | 6 |
| 128 | 10000000 | 127 | 7 |
| 256 | 100000000 | 255 | 8 |
| 512 | 1000000000 | 511 | 9 |
| 1024 | 10000000000 | 1023 | 10 |