এই পর্বে যা শিখবেন
- Chain of trust আর root of trust ব্যাখ্যা করা, আর একটি MCU-র flash-এ bootloader, দুই slot আর image header-এর নকশা আঁকা
- Hash, HMAC আর digital signature কোনটি কী প্রমাণ করে আর কোনটি করে না, তা চালানো উদাহরণে দেখানো
- একটি bootloader-এর যাচাইয়ের ক্রম পড়া: magic, size-এর সীমা, SHA-256, constant-time তুলনা, version, তারপর VTOR আর MSP বসিয়ে লাফ
- Anti-rollback counter কখন বাড়বে, আর A/B slot-এ trial boot, confirm আর watchdog-এর rollback কীভাবে একসঙ্গে কাজ করে তা নকশা করা
- OTA-র পুরো পথ, delta update আর MCUboot-এর মতো বাস্তব ব্যবস্থার জায়গা বোঝা, আর AI-এর দেওয়া bootloader কোড যাচাই করা
১ · যে firmware চলছে, সেটি কি সত্যিই আপনার?
বাজারঘরের smart scale-এ আলুর দাম বসানো 65.50 টাকা/kg (6550 paisa), আর 1250 g-এর দাম 81.88 টাকা। এবার ভাবুন, কেউ দোকানের scale-এর firmware এমনভাবে বদলে দিল যে দাম 95.50 টাকা/kg হয়ে গেল, অথবা ওজন চুপচাপ ৫% বাড়িয়ে দেখায়। পাল্লার বাটখারায় কারচুপির ডিজিটাল রূপ। Cold-storage monitor-এ একই কাজ আরও বিপজ্জনক: কেউ alarm-এর অংশটুকু বাদ দিলে 8.00 °C-এর ওপরে তাপমাত্রা উঠলেও কেউ জানবে না।
বদলানো firmware যন্ত্রে ঢোকার পথ কয়েকটি: OTA update-এর চ্যানেল (পর্ব ৭৫), debug port (SWD বা JTAG, যার তালা দেওয়া পর্ব ৭৬-এ দেখেছেন), কারখানা থেকে দোকান পর্যন্ত সরবরাহের পথ, আর হাতে যন্ত্র পাওয়া কেউ। পর্ব ৭৬-এর threat model-এ এগুলো “Tampering” ঘরের ঝুঁকি। এই পর্বে দুটি প্রতিরক্ষা: secure boot, যা চালানোর আগে কোড যাচাই করে, আর নিরাপদ OTA update, যা নতুন কোডকে নিরাপদে আনে আর ব্যর্থ হলে পুরোনোটিতে ফেরে। এই মডিউলে hex লেখা হয় C-এর ধাঁচে, যেমন 0x08008000.
উপমা — বোর্ড পরীক্ষার প্রশ্নপত্রের সিলগালা খাম: শিক্ষা বোর্ড প্রশ্নপত্র ছাপিয়ে খামে সিলগালা করে পাঠায়। কেন্দ্রের সচিব খাম খোলার আগে দেখেন সিল অক্ষত কি না আর সিলটি সত্যিই বোর্ডের কি না; তারপর হলের পরিদর্শকদের হাতে দেন, তাঁরা আবার প্যাকেটের সিল দেখে খোলেন। প্রতিটি ধাপ পরের ধাপকে যাচাই করে হাতে তুলে দেয়, আর পুরো ব্যবস্থার ভিত্তি একটি জিনিস: বোর্ডের সিল, যা নকল করা যায় না। Secure boot-এ সেই সিল হলো digital signature, আর বোর্ডের পরিচয় জানা আছে chip-এর এমন জায়গায়, যা মাঠে কেউ বদলাতে পারে না।
Chain of trust — প্রথম কড়া থেকে application পর্যন্ত
এই ধারাবাহিক যাচাইয়ের নাম chain of trust, বাংলায় বিশ্বাসের শিকল। প্রথম কড়াটি root of trust: সাধারণত chip-এর boot ROM, যা কারখানায় লেখা আর বদলানো যায় না, সঙ্গে OTP বা eFuse-এ বসানো একটি public key বা তার hash. ROM bootloader যাচাই করে, bootloader application যাচাই করে। কোনো কড়া যাচাই ছাড়া পরেরটিকে চালালে শিকল সেখানেই ভাঙে, কারণ তার পরের সব যাচাই তখন বদলকারীর কোড করছে। Reset vector থেকে main পর্যন্ত পথ পর্ব ৩২-এ দেখেছেন; এখানে সেই পথের মাঝে একটি পাহারাদার বসছে।
ছবি ৭৭.১ — বিশ্বাসের শিকল আর আমার lab-এর flash-এর নকশা
বেগুনি = আসল chip-এর root of trust (কোর্সের board-এ নেই); নীল = bootloader; সবুজ = image-এর slot; হলুদ = SRAM-এর boot অবস্থা
দুটি শব্দ আলাদা রাখুন। Integrity মানে image বদলায়নি; authenticity মানে image সত্যিই সেই নির্মাতার, যাঁকে যন্ত্র বিশ্বাস করে। Secure boot-এর দুটিই লাগে, আর পরের অংশ দেখাবে কোন হাতিয়ার কোনটি দেয়।
২ · Hash, HMAC আর signature — কে কী প্রমাণ করে
Cryptography-র তত্ত্ব Cybersecurity কোর্সের পর্ব ০৯ (Hash আর MAC) আর পর্ব ১১ (Digital signature আর PKI)-এ আছে; এখানে শুধু firmware-এর চোখে তিনটির তুলনা:
| বিষয় | SHA-256 (hash) | HMAC | Signature (যেমন Ed25519) |
|---|---|---|---|
| প্রমাণ করে | বদলায়নি (যদি digest নিজে নিরাপদ জায়গায় থাকে) | বদলায়নি আর key-ধারী বানিয়েছে | বদলায়নি আর private key-এর মালিক সই করেছে |
| যন্ত্রে কী রাখতে হয় | ঠিক digest, বদলানো যায় না এমন জায়গায় | গোপন key, যা কারখানার কাছেও আছে | শুধু public key, গোপন নয় |
| একটি যন্ত্র ভাঙলে | — | Key বের হলে পুরো বহরের জন্য জাল tag বানানো যায় | Public key জানা গেলেও সই বানানো যায় না |
| খরচ | সবচেয়ে কম | Hash-এর প্রায় দ্বিগুণ | যাচাইয়ে অনেক বেশি গণনা আর কোড |
নিচের ব্লক একটি নকল scale firmware-এ দামের ৪ byte বদলায় (65.50 থেকে 95.50) আর তিনটি প্রশ্ন করে: digest কতটা বদলায়, digest যদি image-এর পাশেই থাকে তবে কী হয়, আর HMAC কী বাঁচায়। Ed25519 Python-এর standard library-তে নেই, তাই signature-এর অংশ অংশ ৪-এ আমার lab-এর host-এ চলেছে।
# hash, HMAC আর signature-এর পার্থক্য, একটি নকল firmware image দিয়ে
import hashlib, hmac
def image(rate): # নকল smart scale firmware: কোড + calibration
return b"BAZARGHAR-SCALE-v1|code|" * 100 + rate.to_bytes(4, "little")
good, bad = image(6550), image(9550) # কেউ দাম 65.50 থেকে 95.50 করে দিল
hg, hb = hashlib.sha256(good).digest(), hashlib.sha256(bad).digest()
print("image", len(good), "bytes, changed bytes:", sum(a != b for a, b in zip(good, bad)))
print("sha256 good", hg.hex()[:16], ".. tampered", hb.hex()[:16], "..")
print("digest bits that differ:", sum(bin(a ^ b).count("1") for a, b in zip(hg, hb)), "of 256")
# ১. শুধু hash: digest যদি image-এর পাশেই থাকে, বদলকারী নতুন digest বসায়
header = hashlib.sha256(bad).digest()
print("hash-only check, tampered image + new digest:", hashlib.sha256(bad).digest() == header)
# ২. HMAC: কারখানা আর device-এর কাছে একই গোপন key (এটি নকল, শুধু demo)
KEY = b"DEMO-KEY-not-a-real-secret"
tag = hmac.new(KEY, good, "sha256").digest() # release-এর সময় বানানো
ok = hmac.compare_digest(hmac.new(KEY, good, "sha256").digest(), tag)
forged = hmac.new(b"attacker-guess", bad, "sha256").digest()
bad_ok = hmac.compare_digest(hmac.new(KEY, bad, "sha256").digest(), forged)
print("HMAC check, genuine image:", ok, "| tampered + forged tag:", bad_ok)
print("but KEY sits in every device: leak it once -> forge tags for all")আসল আউটপুট (ব্রাউজারের Python):
image 2404 bytes, changed bytes: 2
sha256 good 004fbda80ea76117 .. tampered 56cc9db3111c424b ..
digest bits that differ: 134 of 256
hash-only check, tampered image + new digest: True
HMAC check, genuine image: True | tampered + forged tag: False
but KEY sits in every device: leak it once -> forge tags for all
6550 আর 9550-এর little-endian রূপে (96 19 00 00 আর 4E 25 00 00) মাত্র ২টি byte আলাদা, অথচ digest-এর ২৫৬টি বিটের ১৩৪টি উল্টে গেছে: hash-এর এই “avalanche” আচরণের জন্যই একটি বিটের বদলও ধরা পড়ে। কিন্তু চতুর্থ লাইন আসল শিক্ষা: digest যদি image-এর সঙ্গেই আসে, বদলকারী নতুন digest হিসাব করে বসিয়ে দেয়, আর hash-এর পরীক্ষা True বলে। HMAC এটি ঠেকায়, কারণ key ছাড়া ঠিক tag বানানো যায় না; কিন্তু শেষ লাইনের সমস্যাটি থাকে। এজন্যই firmware-এ মানদণ্ড হলো signature.
Signature কীভাবে কাজ করে, এক লাইনে: নির্মাতা একটি key-জোড়া বানান। Private key দিয়ে image-এর বিবরণীর ওপর সই হয়, আর যন্ত্রের ভেতরে থাকে শুধু public key, যা দিয়ে সই যাচাই করা যায় কিন্তু বানানো যায় না। Ed25519 (RFC 8032)-এ public key ৩২ byte, signature ৬৪ byte; ECDSA P-256 আর RSA-ও firmware-এ প্রচলিত। Private key কারখানার একটি HSM বা offline কম্পিউটারে থাকে, কখনো build server-এর সাধারণ disk-এ নয়।
৩ · আমার lab-এর bootloader — header, slot আর যাচাইয়ের পথ
কথা থেকে কাজে যাই। কোর্সের virtual “বাজারঘর board” BG-M3 কোনো আসল পণ্য নয়; এটি Unicorn emulator-এর একটি ARMv7-M CPU, চারপাশে Python-এ লেখা STM32-ধাঁচের সরল peripheral (পর্ব ০৬)। আমার lab-এ reference lab-এর board.py নকল করে একটি ছোট bootloader লেখা হয়েছে, আর ছবি ৭৭.১-এর মতো flash ভাগ করতে নিজের একটি linker script (পর্ব ৩১-এর ধাঁচে):
- Bootloader 0x08000000 থেকে, 32 KiB-এর জায়গা; map file অনুযায়ী আসল আকার 3632 byte, যার মধ্যে SHA-256-এর কোড আর ধ্রুবক 1274 byte.
- Slot A 0x08008000 আর slot B 0x08010000, প্রতিটি 32 KiB. Slot-এর শুরুতে ৪৪ byte-এর image header: magic
"BGIM", version, size আর SHA-256 digest. Link-এর পরে একটি Python script size আর digest বসিয়ে দেয়। - Vector table slot-এর +0x80-এ, কারণ ARMv7-M-এ table-কে অন্তত 128 byte-এর সীমায় বসাতে হয় (ARMv7-M Architecture Reference Manual); board-ও
VTOR-এর নিচের ৭টি বিট ফেলে দেয়। - Application নিজের মধ্যেই সম্পূর্ণ: bootloader-এর কোনো function ডাকে না (object file-এর undefined symbol শুধু
boot_stateআর_estack), তাই slot-এর hash তার সব কোড ঢেকে রাখে। - Boot-এর অবস্থা
.noinitSRAM-এর একটিvolatilestruct-এ, যা watchdog বা software reset পেরিয়ে টেকে (Spec decision 18, পর্ব ৬১-এর কৌশল)। Board-এর flash-এ লেখা যায় না, তাই এটি সেই flash বা OTP-এর বদলি, যেখানে আসল যন্ত্র এই তথ্য রাখে।
যাচাইয়ের মূল function, boot.c থেকে (ছাপার লাইন ছেঁটে):
static int verify(uint32_t s) /* 0 = image may run */
{
const img_hdr_t *h = (const img_hdr_t *)slot_addr[s];
uint8_t d[32];
if (h->magic != IMG_MAGIC)
return 1; /* no image */
if (h->size == 0u || h->size > SLOT_SIZE - HDR_SIZE)
return 2; /* bad size: never trust it */
sha256((const uint8_t *)(slot_addr[s] + HDR_SIZE), h->size, d);
if (!digest_equal(d, h->sha256)) /* constant-time compare */
return 3; /* MISMATCH -> rejected */
if (h->version < boot_state.min_version)
return 4; /* anti-rollback */
return 0;
}
__attribute__((noreturn)) static void jump(uint32_t s)
{
const uint32_t *vec = (const uint32_t *)(slot_addr[s] + HDR_SIZE);
SCB->VTOR = (uint32_t)vec; /* the app's vector table */
__asm volatile ("msr msp, %0\n\tbx %1" /* its stack, its reset */
: : "r"(vec[0]), "r"(vec[1]) : "memory");
__builtin_unreachable();
}ক্রমটি লক্ষ করুন: header-এর প্রতিটি মান বদলকারীর হাতে থাকতে পারে, তাই size-এর সীমা আগে, hash পরে। Size না দেখে hash করলে কী হয়, তা অনুশীলন ২-এ সত্যিকারের run-এ দেখবেন। এবার Clang দিয়ে build করে board-এ চালানো, প্রথমে স্বাভাবিক boot. সত্যিকারের run (Clang 22.1.8, PyPI ziglang 0.17.1, MIT আর LLVM-এর Apache-2.0 license; Unicorn 2.1.4, binding BSD, engine GPLv2; Python 3.13.5):
$ python -B mk.py run v1only
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0620 ms] UART: bootloader: reset cause POWER-ON, active A, min_version 1
[ 0.0806 ms] MARK 1
[ 13.1780 ms] MARK 2
[ 13.2502 ms] UART: verify slot A: v1, 2500 bytes, sha256 55a4f447.. ok
[ 13.2797 ms] UART: jump to slot A: reset handler
[ 13.3355 ms] UART: app v1 (slot A): rate 65.50 Tk/kg, 1250 g -> 81.88 Tk
[ 113.3529 ms] UART: app idle -> exit
[ 113.3538 ms] exit(0) after 906830 cycles
Board-এর ছাপা digest-এর শুরু 55a4f447, আর host-এ Python-এর hashlib একই 2500 byte থেকে 55a4f4475971a70a… পেয়েছে: C-তে লেখা SHA-256 ঠিক কাজ করছে। MARK 1 আর MARK 2 (SIMCTRL-এর emulator-চিহ্ন, Spec decision 29) hash-এর দুই পাশে: (13.1780 − 0.0806) ms × 8000 = প্রায় 104779 নির্দেশ, অর্থাৎ byte-প্রতি প্রায় ৪২টি। এটি board-এর মডেল, যেখানে ১টি নির্দেশ = ১ cycle (Spec decision 17); আসল chip-এর সময় datasheet বা মাপ থেকে নিতে হয়, আর অনেক নতুন MCU-তে hash-এর hardware accelerator থাকে।
| সময় (ms) | |
| কে চলছে | |
| পরীক্ষা | |
| ফল |
- Power-on. Board vector table-এর প্রথম দুটি word থেকে MSP আর PC নেয় (Spec decision 18): চলে bootloader-এর Reset_Handler, যা .data কপি আর .bss শূন্য করে main ডাকে।
.noinit-এ হাত দেয় না। - Boot-এর অবস্থা।
boot_state.magicঠিক নেই, অর্থাৎ প্রথম power-on: active = A, pending নেই, min_version = 1 বসানো হলো, তারপর reset-এর কারণ ছাপা। - Header-এর পরীক্ষা। Slot A-র magic “BGIM” ঠিক, size 2500, যা সীমার (0x8000 − 0x80 = 32640) মধ্যে আছে। এগুলো না মিললে hash শুরুই হয় না।
- Hash. 0x08008080 থেকে 0x08008A43 পর্যন্ত 2500 byte-এর SHA-256: padding-সহ ৪০টি ৬৪-byte block. Board-এর মডেলে প্রায় 104779 নির্দেশ।
- তুলনা আর version. হিসাব করা digest header-এর ৩২ byte-এর সঙ্গে constant-time-এ মিলল; version 1 ≥ min_version 1. দুটিই পাস।
- লাফ। VTOR = 0x08008080, MSP = slot-এর table-এর প্রথম word 0x20005000, তারপর
bxদ্বিতীয় word 0x080080C1-এ; শেষ বিট 1 মানে Thumb অবস্থা। - Application. App v1 নিজের UART কোডে দাম ছাপে: 1250 × 6550 + 500, ÷ 1000 = 8188 paisa = 81.88 টাকা, README-এর হিসাবের সঙ্গে হুবহু।
আসল bootloader-এর লাফের আগে আরও কাজ: লাফের আগে bootloader-এর চালু করা interrupt, SysTick, DMA আর peripheral বন্ধ করতে হয়, pending interrupt মুছতে হয়, নইলে app-এর প্রথম মুহূর্তে পুরোনো handler-এর জন্য interrupt আসতে পারে (পর্ব ৩০)। আমার bootloader শুধু UART চালু করে, interrupt চালু করে না, তাই এখানে সমস্যা নেই।
৪ · বদলানো image — hash ধরে, কিন্তু signature কেন লাগে
এবার নিজের কোডের ওপর একটি নিয়ন্ত্রিত পরীক্ষা, শুধু আমার lab-এর virtual board-এ। Map file বলে দামের ধ্রুবক rate_paisa_per_kg বসেছে 0x080089C4-এ। একটি Python script ELF ফাইলের ওই ৪ byte 6550 থেকে 9550 করে দুটি নকল বানায়: tamper1, যেখানে header অপরিবর্তিত, আর tamper2, যেখানে বদলকারী header-এর digest-ও নতুন করে হিসাব করে বসিয়েছে।
$ python -B mk.py run tamper1
[ 0.0620 ms] UART: bootloader: reset cause POWER-ON, active A, min_version 1
[ 13.2851 ms] UART: verify slot A: v1, 2500 bytes, sha256 f16e06d1.. MISMATCH (header 55a4f447..) -> rejected
[ 13.3105 ms] UART: verify slot B: no image
[ 13.3468 ms] UART: no valid image: stay in bootloader, alarm ON
[ 13.3480 ms] GPIO PA6 ALARM ON
[ 13.3485 ms] exit(2) after 106788 cycles
$ python -B mk.py run tamper2
[ 13.2502 ms] UART: verify slot A: v1, 2500 bytes, sha256 f16e06d1.. ok
[ 13.2797 ms] UART: jump to slot A: reset handler
[ 13.3376 ms] UART: app v1 (slot A): rate 95.50 Tk/kg, 1250 g -> 119.38 Tk
[ 113.3559 ms] exit(0) after 906847 cycles
(প্রথম লাইন আর MARK-গুলো জায়গা বাঁচাতে বাদ।) প্রথম নকল ধরা পড়ল, যন্ত্র চলল না, alarm জ্বলল: এটি fail-safe. দ্বিতীয়টি সোজা চলে গেল, আর 1250 g আলুর দাম দেখাল 119.38 টাকা। Hash ঠিক কাজই করেছে; সমস্যা হলো digest নিজেই image-এর সঙ্গে আসে। একই তিনটি image-কে এবার host-এ সেভাবে যাচাই করা হলো, যেভাবে একটি signature-যাচাইকারী bootloader করে: image-এর hash মেলে কি না, আর ৪৪ byte-এর header, অর্থাৎ manifest, নির্মাতার Ed25519 key-এ সই করা কি না। Key-জোড়াটি lab-এ শুধু এই run-এর জন্য memory-তে বানানো, কোথাও সংরক্ষিত নয়; নিচে public key-এর ছাপের শুধু প্রথম ৮ byte. সত্যিকারের run (cryptography 50.0.2, Apache-2.0 বা BSD-3-Clause license, নিজের lab-এর আলাদা venv-এ; এতে কোনো telemetry নেই, package-এর কোড খুঁজে যাচাই করা):
$ python -B sign_tool.py
public key fingerprint (sha256, first 8 bytes): dea3c9a7e46ea281
signed manifest of v1: version 1, 2500 bytes, digest 55a4f447.., signature 64 bytes
v1only hash ok signature valid -> ACCEPT
tamper1 hash MISMATCH signature valid -> REJECT
tamper2 hash ok signature INVALID -> REJECT
| Image | |
| দামের ৪ byte | |
| Header-এর digest | |
| Board (শুধু hash) | |
| Host (hash + Ed25519) |
- আসল image. দামের ৪ byte little-endian-এ 96 19 00 00 = 6550. Header-এর digest image-এর সঙ্গে মেলে, signature বৈধ: সব পরীক্ষা পাস।
- প্রথম বদল। কেউ ওই ৪ byte 4E 25 00 00 (9550) করল, header ছুঁলো না। Image-এর দুটি byte বদলেছে।
- Board ধরল। হিসাব করা digest f16e06d1.., header বলে 55a4f447..: মেলে না। Slot B-তে image নেই, তাই bootloader থেমে alarm জ্বালায়।
- চালাক বদল। এবার বদলকারী নতুন image-এর SHA-256 হিসাব করে header-এ f16e06d1.. বসাল। Hash আর digest এখন মেলে।
- Board ঠকল। শুধু hash দেখা bootloader image চালিয়ে দিল: দাম 95.50 টাকা/kg, 1250 g = 1250 × 9550 + 500, ÷ 1000 = 11938 paisa = 119.38 টাকা।
- Signature থামাল। Host-এ tamper1-এর hash মেলে না; tamper2-এর manifest বদলেছে বলে Ed25519 সই অবৈধ। দুটিই REJECT, কারণ private key ছাড়া নতুন manifest-এ সই বানানো যায় না।
তাহলে আসল যন্ত্রে কী চাই? Bootloader-এর ভেতরেই signature যাচাই: hash মেলানো, তারপর manifest-এর সই chip-এর OTP বা bootloader-এ রাখা public key দিয়ে যাচাই। আমার lab ভাগ করে দেখিয়েছে (hash board-এ, signature host-এ), কারণ Ed25519-এর যাচাই C-তে লেখা আর board-এর Python-চালিত emulator-এ চালানো এই পর্বের পরিসরের বাইরে; MCUboot-এর মতো বাস্তব bootloader এটি device-এই করে (অংশ ৮)। মনে রাখুন, bootloader-এর নিজের কোডও তো কেউ বদলাতে পারে; তাই bootloader-কে লিখতে-বন্ধ flash-এ রাখা আর ROM দিয়ে তাকে যাচাই করা শিকলের অংশ।
Digest-এর তুলনা constant-time কেন
আমার digest_equal() প্রথম অমিলে থামে না, ৩২টি byte-এর সবগুলোর XOR জমিয়ে শেষে একবার দেখে। কেন, তা নিচের ব্লক দেখায়: একটি গোপন tag-এর সঙ্গে ধাপে ধাপে আরও ঠিক অনুমান, আর দুই ধরনের তুলনায় কয়টি byte দেখা হলো।
#include <stdio.h>
#include <stdint.h>
static int steps; /* bytes examined = time taken */
static int early_exit_equal(const uint8_t *a, const uint8_t *b, int n)
{
for (int i = 0; i < n; i++) {
steps++;
if (a[i] != b[i]) return 0; /* leaks where the first mismatch is */
}
return 1;
}
static int ct_equal(const uint8_t *a, const uint8_t *b, int n)
{
uint8_t d = 0;
for (int i = 0; i < n; i++) { steps++; d |= (uint8_t)(a[i] ^ b[i]); }
return d == 0; /* always looked at all n bytes */
}
int main(void)
{
uint8_t tag[32], guess[32];
for (int i = 0; i < 32; i++) tag[i] = (uint8_t)(i * 37 + 11);
for (int k = 0; k <= 32; k += 8) { /* first k bytes guessed right */
for (int i = 0; i < 32; i++) guess[i] = (i < k) ? tag[i] : (uint8_t)~tag[i];
steps = 0; int r1 = early_exit_equal(tag, guess, 32), s1 = steps;
steps = 0; int r2 = ct_equal(tag, guess, 32), s2 = steps;
printf("first %2d right: early-exit %d (steps %2d), constant-time %d (steps %2d)\n",
k, r1, s1, r2, s2);
}
return 0;
}আসল আউটপুট (Wandbox-এর gcc):
first 0 right: early-exit 0 (steps 1), constant-time 0 (steps 32)
first 8 right: early-exit 0 (steps 9), constant-time 0 (steps 32)
first 16 right: early-exit 0 (steps 17), constant-time 0 (steps 32)
first 24 right: early-exit 0 (steps 25), constant-time 0 (steps 32)
first 32 right: early-exit 1 (steps 32), constant-time 1 (steps 32)
প্রথম ধরনের তুলনায় ধাপের সংখ্যা, অর্থাৎ সময়, বলে দেয় কতগুলো byte ঠিক হয়েছে: ঠিক অনুমান ০, ৮, ১৬, ২৪ হলে ধাপ 1, 9, 17, 25. যে কেউ বারবার tag পাঠিয়ে সময় মাপতে পারে, সে byte ধরে ধরে ঠিক tag খুঁজে নিতে পারে; একে বলে timing attack. Constant-time তুলনা সবসময় ৩২ ধাপ নেয়। গোপন HMAC tag বা token মেলানোয় এটি অপরিহার্য; image-এর SHA-256 গোপন নয়, তাই সেখানে ঝুঁকি কম, কিন্তু অভ্যাসটি সস্তা আর পর্যালোচনায় প্রশ্ন কমায়। পর্ব ৭৬-এ PIN-এর তুলনায় একই শিক্ষা দেখেছেন।
৫ · Anti-rollback — পুরোনো, কিন্তু বৈধ version-এর বিপদ
ধরুন v1-এ একটি bug ছিল, ধরা যাক UART-এর একটি command যাচাই ছাড়া calibration বদলে দেয়। v2-তে সেটি সারানো হলো। কিন্তু v1-এর image আর তার signature কোথাও না কোথাও থেকে যায়, আর signature তো এখনো বৈধ! কেউ যন্ত্রকে v1-এ ফিরিয়ে দিলে (downgrade attack) পুরোনো bug আবার খোলা। Signature এটি থামায় না, কারণ v1 সত্যিই নির্মাতার সই করা।
উত্তর anti-rollback: যন্ত্রে একটি সংখ্যা min_version, আর bootloader শুধু সেই image চালায় যার version এর সমান বা বেশি। এই counter শুধু বাড়তে পারে, কমতে নয়: এমন counter-এর নাম monotonic counter, অর্থাৎ একমুখী গণক। আসল chip-এ এটি থাকে OTP বা eFuse-এর বিটে (একটি বিট একবার ১ হলে আর ০ করা যায় না), কোনো secure element-এ, বা TrustZone-এর মতো সুরক্ষিত জগতে; কোর্সের board-এ .noinit-এর volatile একটি word তার বদলি, যা board-এর একটি run-এর মধ্যে reset পেরিয়ে টেকে।
সবচেয়ে সূক্ষ্ম প্রশ্ন: counter কখন বাড়বে? নতুন image নামার সঙ্গে সঙ্গে বাড়ালে, আর নতুন image-এ এমন bug থাকলে যা তাকে চালুই হতে দেয় না, তখন পুরোনো image-এ ফেরার পথও বন্ধ: যন্ত্র অচল। তাই আমার bootloader counter বাড়ায় নতুন image নিজেকে সুস্থ প্রমাণ (confirm) করার পরে, পরের boot-এ। নিচের সত্যিকারের run-এ v2 confirm হলো, তারপর কেউ “downgrade” চাইল:
$ python -B mk.py run upd_good update_then_downgrade
[ 13.3355 ms] UART: app v1 (slot A): rate 65.50 Tk/kg, 1250 g -> 81.88 Tk
[ 20.0000 ms] > UART RX 'update\n'
[ 20.0379 ms] UART: update: slot B staged, reboot
[ 20.0389 ms] RESET (software, AIRCR.SYSRESETREQ)
[ 20.0995 ms] UART: bootloader: reset cause SOFTWARE, active A, min_version 1
[ 33.9449 ms] UART: verify slot B: v2, 2664 bytes, sha256 619a7861.. ok
[ 33.9474 ms] watchdog started, timeout 200 ms
[ 33.9700 ms] UART: trial boot, watchdog 200 ms
[ 33.9990 ms] UART: jump to slot B: reset handler
[ 34.0546 ms] UART: app v2 (slot B): rate 65.50 Tk/kg, 1250 g -> 81.88 Tk
[ 34.0817 ms] UART: self-test ok -> image confirmed
[ 60.0003 ms] > UART RX 'downgrade\n'
[ 60.0460 ms] UART: downgrade: slot A staged, reboot
[ 60.0470 ms] RESET (software, AIRCR.SYSRESETREQ)
[ 60.1076 ms] UART: bootloader: reset cause SOFTWARE, active A, min_version 1
[ 60.1566 ms] UART: trial slot B: confirmed -> active, min_version 2
[ 73.3954 ms] UART: verify slot A: v1, 2500 bytes, sha256 55a4f447.. ok, but v1 < min_version 2 -> rejected (anti-rollback)
[ 87.2403 ms] UART: verify slot B: v2, 2664 bytes, sha256 619a7861.. ok
[ 87.2698 ms] UART: jump to slot B: reset handler
[ 87.3254 ms] UART: app v2 (slot B): rate 65.50 Tk/kg, 1250 g -> 81.88 Tk
[ 187.3444 ms] exit(0) after 1498755 cycles
| সময় (ms) | |
| ঘটনা | |
| active | |
| pending · trial | |
| confirmed | |
| min_version |
- Update staged. App v1 UART-এ “update” পায়,
pending = Bলিখে AIRCR-এ SYSRESETREQ দেয়। Slot B-তে image আগেই নামানো ধরা হয়েছে (নামানোর পথ পর্ব ৭৫-এ)। - Trial boot. Bootloader B যাচাই করে (v2 ≥ 1), trial = B, confirmed = 0 লিখে 200 ms-এর watchdog চালু করে তারপর B-তে লাফ দেয়।
- Confirm. v2-এর self-test পাস, তাই সে নিজে
confirmed = 1লেখে আর নিয়মিত watchdog kick করে। Counter এখনো 1. - Downgrade-এর অনুরোধ। 60 ms-এ কেউ “downgrade” পাঠায়; v2 slot A-কে pending করে reboot দেয়। (বাস্তবে এমন command-এর নিজেরই যাচাই লাগে।)
- Trial শেষ। Bootloader আগে আগের trial-এর হিসাব মেটায়: B confirmed, তাই active = B আর min_version = B-র version 2. এই মুহূর্তে counter বাড়ল, confirm-এর পরে, আগে নয়।
- Downgrade প্রত্যাখ্যাত। Slot A-র hash ঠিক, signature থাকলে সেটিও বৈধ হতো, কিন্তু v1 < min_version 2: rejected (anti-rollback).
- নিরাপদ পথ। স্বাভাবিক boot-এ active B আবার যাচাই হয়ে চলে। যন্ত্র v2-তেই রইল।
৬ · A/B slot, trial boot আর rollback
OTA-এর সবচেয়ে বড় ভয় দুটি: নামানোর মাঝে বিদ্যুৎ চলে যাওয়া (বাংলাদেশে load-shedding-এর কথা ভাবুন), আর নতুন image-এ এমন bug যা যন্ত্রকে আর চালু হতে দেয় না। দুটির ফলই “brick”: যন্ত্রটি ইটের মতো অকেজো, ঠিক করতে মানুষ পাঠাতে হয়। A/B partition-এ পুরোনো image (A) অক্ষত থাকে, আর নতুনটি (B) নামে অন্য slot-এ। এর ওপর একটি নিয়ম বসে, যার নাম trial boot:
- Bootloader নতুন image যাচাই করে, “trial” চিহ্ন দেয়, watchdog চালু করে (পর্ব ৬১) আর একবার চালায়।
- নতুন firmware নিজের আসল কাজ পরীক্ষা করে: sensor পড়া, server-এ যুক্ত হওয়া। পাস করলে নিজেই
confirmed = 1লেখে। - Confirm না করে আটকে গেলে watchdog reset দেয়; পরের boot-এ bootloader দেখে trial অসমাপ্ত, আর পুরোনো slot-এ ফেরে: rollback.
এই পর্বের আরেকটি সত্যিকারের run, যেখানে slot B-র v2-এ ইচ্ছা করে রাখা একটি bug: self-test-এ sensor চালু করতে গিয়ে চিরকাল আটকে যায়।
$ python -B mk.py run upd_bad update
[ 13.3355 ms] UART: app v1 (slot A): rate 65.50 Tk/kg, 1250 g -> 81.88 Tk
[ 20.0000 ms] > UART RX 'update\n'
[ 20.0379 ms] UART: update: slot B staged, reboot
[ 20.0389 ms] RESET (software, AIRCR.SYSRESETREQ)
[ 20.0995 ms] UART: bootloader: reset cause SOFTWARE, active A, min_version 1
[ 34.5973 ms] UART: verify slot B: v2, 2780 bytes, sha256 2ec3f6f3.. ok
[ 34.5998 ms] watchdog started, timeout 200 ms
[ 34.6224 ms] UART: trial boot, watchdog 200 ms
[ 34.6514 ms] UART: jump to slot B: reset handler
[ 34.7069 ms] UART: app v2 (slot B): rate 65.50 Tk/kg, 1250 g -> 81.88 Tk
[ 34.7416 ms] UART: self-test: sensor init hangs (bug), no confirm
[ 234.5998 ms] RESET (watchdog timeout)
[ 234.6604 ms] UART: bootloader: reset cause WATCHDOG, active A, min_version 1
[ 234.7063 ms] UART: trial slot B: NOT confirmed -> roll back to slot A
[ 247.8945 ms] UART: verify slot A: v1, 2500 bytes, sha256 55a4f447.. ok
[ 247.9797 ms] UART: app v1 (slot A): rate 65.50 Tk/kg, 1250 g -> 81.88 Tk
[ 347.9980 ms] exit(0) after 2783984 cycles
| সময় (ms) | |
| কে চলছে | |
| pending · trial | |
| confirmed | |
| Watchdog |
- পুরোনো firmware চলছে। Slot A-র v1, active = A, কোনো trial নেই।
- Update staged. “update” পেয়ে v1
pending = Bলেখে আর software reset (SYSRESETREQ) দেয়। - Trial শুরু। B-র hash আর version ঠিক, তাই trial = B; 34.5998 ms-এ watchdog চালু, অর্থাৎ শেষ সময় 34.5998 + 200 = 234.5998 ms. তারপর B-তে লাফ।
- নতুন firmware আটকে গেল। v2 দাম ছাপে, কিন্তু self-test-এ আটকে যায়: confirm নেই, kick নেই। বাইরে থেকে দেখলে যন্ত্র “চালু”, অথচ কাজ বন্ধ।
- Watchdog reset. ঠিক 234.5998 ms-এ IWDG reset দেয়।
.noinit-এর boot_state টিকে আছে, trial = B, confirmed = 0. - Rollback. Bootloader trial-এর হিসাব মেটায়: confirm হয়নি, তাই active A-ই থাকে, trial মুছে যায়। min_version 1-ই রইল, কারণ counter বাড়ে শুধু confirm-এর পরে।
- পুরোনো firmware ফিরল। A আবার যাচাই হয়ে চলে। যন্ত্র কাজ করছে, আর এই ঘটনা পরের telemetry-তে server-কে জানানো উচিত।
সিদ্ধান্তের যুক্তিটুকু ছোট, তাই একে Python-এ মডেল করে দুটি গল্পই চালানো যায়। নিচের ব্লক boot.c-এর তিন ধাপ হুবহু অনুসরণ করে; এর লাইনগুলো board-এর লাইনের সঙ্গে মিলিয়ে দেখুন।
# boot.c-এর A/B সিদ্ধান্তের Python মডেল: trial, rollback আর anti-rollback
def make(versions):
return dict(ver=versions, active="A", pending=None, trial=None,
confirmed=False, min_version=1)
def boot(st, cause, self_test_ok):
print(f"[{cause}] active {st['active']}, min_version {st['min_version']}")
t = st["trial"]
if t: # ১. আগের trial-এর ফল
if st["confirmed"]:
st["active"], st["min_version"] = t, st["ver"][t]
print(f" trial {t} confirmed -> active, min_version {st['min_version']}")
else:
print(f" trial {t} NOT confirmed -> roll back to {st['active']}")
st["trial"], st["confirmed"] = None, False
s, st["pending"] = st["pending"], None
if s: # ২. staged update
if st["ver"][s] >= st["min_version"]:
st["trial"] = s
st["confirmed"] = self_test_ok # নতুন app নিজে confirm করে কি না
print(f" trial boot {s} v{st['ver'][s]}, watchdog on ->",
"confirmed" if self_test_ok else "hangs, no confirm")
return
print(f" {s} v{st['ver'][s]} < min_version {st['min_version']} -> rejected")
print(f" boot {st['active']} v{st['ver'][st['active']]}") # ৩. স্বাভাবিক boot
SCENARIOS = {"buggy v2": [("POWER-ON", True, "B"), ("SOFTWARE", False, None), ("WATCHDOG", True, None)],
"good v2, then downgrade": [("POWER-ON", True, "B"), ("SOFTWARE", True, "A"),
("SOFTWARE", True, None)]}
for title, steps in SCENARIOS.items():
print("==", title, "==")
st = make({"A": 1, "B": 2})
for cause, ok, stage in steps:
boot(st, cause, ok)
st["pending"] = stage # app একটি update stage করে reboot দেয়আসল আউটপুট (ব্রাউজারের Python):
== buggy v2 ==
[POWER-ON] active A, min_version 1
boot A v1
[SOFTWARE] active A, min_version 1
trial boot B v2, watchdog on -> hangs, no confirm
[WATCHDOG] active A, min_version 1
trial B NOT confirmed -> roll back to A
boot A v1
== good v2, then downgrade ==
[POWER-ON] active A, min_version 1
boot A v1
[SOFTWARE] active A, min_version 1
trial boot B v2, watchdog on -> confirmed
[SOFTWARE] active A, min_version 1
trial B confirmed -> active, min_version 2
A v1 < min_version 2 -> rejected
boot B v2
দুটি গল্পের প্রতিটি সিদ্ধান্ত board-এর run-এর লাইনের সঙ্গে মেলে, শুধু hash-এর অংশ এখানে বাদ (দুটি image-কেই ঠিক ধরা)। এমন একটি host-এর মডেল পর্ব ৬৪-এর host test-এর কাজে লাগে: power-cut, দুবার ব্যর্থতা, পুরোনো version-এর চেষ্টা, এমন বহু ক্রম hardware ছাড়াই দ্রুত পরীক্ষা করা যায়। অনুশীলন ৩-এ এই মডেল দিয়েই একটি নতুন ক্রম অনুমান করবেন।
A/B-র দাম আর বিকল্প: দুটি পূর্ণ slot মানে flash প্রায় দ্বিগুণ। ছোট MCU-তে তাই কয়েকটি বিকল্প চলে: নতুন image একটি “download slot”-এ নামিয়ে যাচাইয়ের পরে চলার জায়গায় কপি (overwrite), বা দুটি slot-এর মধ্যে page ধরে অদলবদল (swap), যাতে দরকারে উল্টো swap করে ফেরা যায়; অথবা একটি ছোট recovery image. প্রতিটির নিয়ম একই: কোনো মুহূর্তে বিদ্যুৎ গেলেও bootloader যেন বুঝতে পারে কোন অবস্থায় ছিল, আর অন্তত একটি বৈধ image যেন সবসময় থাকে।
৭ · OTA-র পুরো পথ আর delta update
Cloud-এর দিক, অর্থাৎ manifest প্রকাশ, chunk ধরে নামানো, আকার আর hash মেলানো আর বহরে ধাপে ধাপে ছাড়া (staged rollout), পর্ব ৭৫-এ সত্যিকারের run-এ দেখেছেন। যন্ত্রের দিক থেকে পুরো পথটি এক জায়গায়:
- খবর: server একটি signed manifest দেয়: model, hardware revision, version, আকার, SHA-256. যন্ত্র আগে manifest-এর সই আর version দেখে, image নামানোর আগেই।
- নামানো: TLS-এর ওপর (Computer Networks পর্ব ৪৮), chunk ধরে, অন্য slot-এ; মাঝপথে থামলে আবার সেখান থেকে। TLS পথটি রক্ষা করে, কিন্তু image-এর signature শেষ পর্যন্ত, নির্মাতা থেকে যন্ত্র পর্যন্ত রক্ষা করে: server ভাঙলেও জাল image চলবে না।
- যাচাই: পুরো image-এর hash, signature আর version ≥ min_version.
- পালা বদল: pending চিহ্ন আর reboot; bootloader আবার যাচাই করে, কারণ নামানোর পরে flash-এ কিছু বদলাতে পারে।
- Confirm: trial boot, self-test, confirm, counter বাড়ানো, আর server-কে নতুন version জানানো।
আরেকটি বাস্তব সাবধানতা: battery-চালিত যন্ত্রে flash লেখা বড় খরচ, তাই charge কম থাকলে update শুরু না করাই নিয়ম (পর্ব ৬২)।
Delta update: LPWAN-এর মতো ধীর link-এ (পর্ব ৭২) পুরো image পাঠানো কষ্টকর, তাই শুধু পার্থক্যটুকু পাঠানো হয়, আর যন্ত্র পুরোনো image-এর সঙ্গে মিলিয়ে নতুনটি গড়ে। বাস্তবে bsdiff-এর মতো আরও চতুর পদ্ধতি চলে; নিচের ব্লক সবচেয়ে সরল রূপটি দেখায়, block ধরে, আর তার সঙ্গে একটি জরুরি শিক্ষা।
# Delta update: শুধু বদলানো block পাঠানো, device-এ নতুন image গড়া, তারপর পুরোটার যাচাই
import hashlib, random
random.seed(77)
v1 = bytes(random.randrange(256) for _ in range(8192)) # slot A-র চলমান নকল image
v2 = bytearray(v1)
v2[1000:1040] = bytes(40) # v2-তে দুটি জায়গা বদলেছে
v2[6000:6004] = (6550).to_bytes(4, "little")
v2 = bytes(v2)
manifest = {"base_sha256": hashlib.sha256(v1).hexdigest(), # কোন image-এর ওপর patch
"size": len(v2), "sha256": hashlib.sha256(v2).hexdigest()} # signed ধরে নিন
B = 256
patch = [(i, v2[i:i + B]) for i in range(0, len(v2), B) if v1[i:i + B] != v2[i:i + B]]
print("delta blocks", [i // B for i, _ in patch], "->",
sum(len(d) for _, d in patch), "of", len(v2), "bytes to send")
def apply(base, patch): # device: slot A + patch -> slot B
out = bytearray(base)
for off, data in patch:
out[off:off + len(data)] = data
return bytes(out)
def verify(img):
return len(img) == manifest["size"] and hashlib.sha256(img).hexdigest() == manifest["sha256"]
print("correct base + patch :", verify(apply(v1, patch)))
old = bytearray(v1); old[7000] ^= 0xFF # base slot-এর একটি byte আগেই নষ্ট
print("base check before patching:", hashlib.sha256(old).hexdigest() == manifest["base_sha256"])
print("damaged base + patch :", verify(apply(bytes(old), patch)))
bad = list(patch); bad[0] = (bad[0][0], bytes(B)) # পথে patch-এর একটি block বদলাল
print("correct base + bad patch :", verify(apply(v1, bad)))আসল আউটপুট (ব্রাউজারের Python):
delta blocks [3, 4, 23] -> 768 of 8192 bytes to send
correct base + patch : True
base check before patching: False
damaged base + patch : False
correct base + bad patch : False
৪০ byte-এর বদল 1000 থেকে 1039-এ, যা block ৩ (768–1023) আর block ৪ (1024–1279) দুটিই ছোঁয়; 6000 পড়ে block ২৩-এ। তাই 8192-এর বদলে 768 byte পাঠালেই চলে। কিন্তু শেষ তিন লাইন আসল কথা: patch একটি নির্দিষ্ট পুরোনো image-এর ওপর খাটে, তাই manifest-এ base-এর hash রেখে patch-এর আগে base মেলানো হয়, আর গড়া image-এর ওপর আবার পুরো যাচাই হয়, signature-সহ। Delta শুধু পাঠানোর খরচ কমায়, যাচাইয়ের নিয়ম একটুও কমায় না।
৮ · বাস্তবের ব্যবস্থা আর পরীক্ষার ধাঁচে একটি হিসাব
নিজের bootloader লেখা শেখার জন্য ভালো, পণ্যে সাধারণত একটি পরীক্ষিত ব্যবস্থা নেওয়া হয়। কয়েকটি নাম, যেগুলোর খুঁটিনাটি নিজের chip আর version-এর documentation থেকে মেলাবেন:
- MCUboot: ৩২-বিট MCU-র জন্য open-source secure bootloader, যা Zephyr-সহ কয়েকটি RTOS-এ ব্যবহৃত। এর documentation অনুযায়ী এটি image-এর signature (RSA, ECDSA বা Ed25519) যাচাই করে, overwrite, swap আর direct-XIP-এর মতো কয়েকটি update পদ্ধতি দেয়, আর “test” হিসেবে চালানো image app নিজে confirm না করলে আগেরটিতে ফেরে; সই করার জন্য
imgtoolনামে একটি tool আছে। - Chip-এর নিজের ব্যবস্থা: অনেক নতুন MCU-র ROM-এ secure boot থাকে, যা OTP বা eFuse-এ বসানো public key বা তার hash দিয়ে প্রথম image যাচাই করে। একবার চালু করলে বন্ধ করা যায় না, তাই কারখানার ধাপ খুব সাবধানে সাজাতে হয়।
- চাবির জায়গা: secure element chip, বা Armv8-M-এর TrustZone-এর সুরক্ষিত দিক, যেখানে key আর counter সাধারণ কোডের নাগালের বাইরে থাকে।
- মানদণ্ড: IETF-এর SUIT দল IoT firmware update-এর একটি architecture (RFC 9019) আর manifest-এর বিবরণ প্রকাশ করেছে; consumer IoT-র ETSI EN 303 645 নিরাপদ update চায় (পর্ব ৭৬)।
আরও গভীরে: Signature-এর নিরাপত্তা শেষ পর্যন্ত private key-এর নিরাপত্তা। তাই বড় নির্মাতারা key রাখেন HSM-এ, সই করেন কয়েকজনের অনুমোদনে, আর একটি key ফাঁস হলে বাতিল করে নতুন key-এ যাওয়ার পথ আগে থেকেই রাখেন: যেমন OTP-তে কয়েকটি key-এর hash-এর ঘর, যার একটিকে পরে “বাতিল” চিহ্ন দেওয়া যায়। আরেকটি সূক্ষ্ম ফাঁদ time-of-check to time-of-use: যাচাইয়ের পরে image যদি বাইরের flash থেকে আবার পড়া হয়, মাঝে কেউ তা বদলে দিতে পারে; তাই যাচাই আর চালানো একই অপরিবর্তনীয় কপির ওপর হওয়া চাই। আর হাতে যন্ত্র পাওয়া আক্রমণকারী voltage বা clock-এ ঝাঁকুনি দিয়ে (fault injection) একটি if লাফিয়ে যাওয়ার চেষ্টা করতে পারে বলে গবেষণায় বহুবার দেখানো হয়েছে; শক্ত bootloader তাই গুরুত্বপূর্ণ পরীক্ষা দুবার করে আর সফলতার মান হিসেবে সরল ১-এর বদলে একটি বড় নির্দিষ্ট সংখ্যা ব্যবহার করে।
পরীক্ষার ধাঁচে — slot-এর ঠিকানা আর hash-এর block
প্রশ্ন: একটি image slot 0x08008000-এ শুরু, header 0x80 byte, image-এর আকার 2500 byte. (ক) Hash কোন ঠিকানা থেকে কোন ঠিকানা পর্যন্ত? (খ) SHA-256-এ কয়টি ৬৪-byte block? (গ) VTOR-এ কী লেখা হবে, আর এটি বৈধ কেন?
- শুরু = 0x08008000 + 0x80 = 0x08008080; শেষ = 0x08008080 + 2500 − 1 = 0x08008080 + 0x9C4 − 1 = 0x08008A43.
- SHA-256-এর padding: বার্তার পরে ১ byte 0x80, তারপর শূন্য, আর শেষে ৮ byte-এ বিটে দৈর্ঘ্য। মোট অন্তত 2500 + 9 = 2509 byte, ÷ 64 = 39.2, তাই ৪০টি block (আমার C কোডে ৩৯টি পূর্ণ block আর শেষের ৪ byte-সহ একটি)।
- VTOR = 0x08008080. এটি 128 byte-এর সীমায় (0x80-এর গুণিতক); ৩২টি পর্যন্ত exception-এর table-এর জন্য ARMv7-M-এর নিয়মে এটুকুই যথেষ্ট।
পরীক্ষা ও ইন্টারভিউতে: “Secure boot আর chain of trust কী?” → প্রতিটি ধাপ পরের কোডের signature যাচাই করে তবেই চালায়, শুরু হয় অপরিবর্তনীয় ROM আর OTP-তে রাখা key থেকে। “Hash আর signature-এর পার্থক্য?” → hash শুধু বদল ধরে; signature বদল আর উৎস দুটিই প্রমাণ করে, যন্ত্রে লাগে শুধু public key. “Anti-rollback কেন, আর counter কখন বাড়ে?” → পুরোনো বৈধ কিন্তু ত্রুটিপূর্ণ version ঠেকাতে; নতুন image confirm হওয়ার পরে। “A/B update-এ rollback কীভাবে?” → নতুন slot-এ trial boot, watchdog চালু; confirm না এলে reset-এর পরে bootloader পুরোনো slot চালায়। “Digest-এর তুলনায় memcmp কেন নয়?” → প্রথম অমিলে থামে বলে সময় থেকে তথ্য ফাঁস হয়; constant-time তুলনা লাগে।
৯ · AI-এর যুগে secure boot আর OTA-র কোড যাচাই
“STM32-এর জন্য OTA bootloader লিখে দিন” বললে AI assistant দ্রুত একটি bootloader দেয়, যা প্রায়ই চলে, কিন্তু নিরাপত্তার দিক থেকে ফাঁপা হতে পারে। কয়েকটি পরিচিত ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| শুধু CRC বা SHA-256 মেলায়, আর digest রাখে image-এর পাশেই; signature নেই | নিজের কোডে digest-সহ image বদলে দেখা; এই পর্বের tamper2 ঠিক এটি দেখায় |
| Header-এর size বা offset যাচাই না করে hash বা কপি করে | Header-এ বিশাল size বসিয়ে simulator-এ চালানো (অনুশীলন ২) |
| Private key source code-এ বা build script-এ রাখে, “example” বলে | Repository-তে key খোঁজা; key থাকবে HSM বা আলাদা নিরাপদ জায়গায় |
memcmp দিয়ে tag বা digest মেলায় | Constant-time function ব্যবহার, কোড পড়ে যাচাই |
| Version-এর পরীক্ষা নেই, বা counter বাড়ায় নামানোর সঙ্গে সঙ্গে | পুরোনো সই করা image দিয়ে চেষ্টা, আর একটি ত্রুটিপূর্ণ নতুন image দিয়ে rollback পরীক্ষা |
| Trial boot-এ watchdog নেই, বা app boot-এর সঙ্গে সঙ্গেই confirm করে | ইচ্ছা করে আটকে যাওয়া নতুন image দিয়ে চালানো; confirm আসুক আসল কাজের পরে |
| অন্য chip-এর register, flash-এর page-এর আকার বা VTOR-এর নিয়ম বানিয়ে বলে | নিজের chip-এর reference manual আর ARMv7-M বা Armv8-M-এর manual মেলানো |
AI-কে কাজে লাগাতে নকশার শর্ত আর যাচাইয়ের নিয়ম শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Root of trust-কে “অপরিবর্তনীয়” রাখা হয়, অথচ ২০১৮ সালে একটি জনপ্রিয় chip-এর boot ROM-এর একটি bug প্রকাশ্যে আসে, যা আর সারানো যায়নি। অপরিবর্তনীয়তা তাহলে শক্তি না দুর্বলতা?
২০১৮ সালে NVIDIA-র Tegra X1 SoC-এর boot ROM-এর USB recovery mode-এর একটি ত্রুটি প্রকাশ করা হয় (CVE-2018-6242; গবেষক Kate Temkin-এর দল একে “Fusée Gelée” নাম দেয়)। এই chip একটি জনপ্রিয় game console-সহ নানা যন্ত্রে ছিল। ত্রুটিটি ছিল ROM-এ, যা কারখানায় একবার লেখা হয়; তাই আগে বিক্রি হওয়া chip-এ software update দিয়ে এটি সারানো সম্ভব ছিল না বলে তখনকার প্রকাশিত বিবরণে বলা হয়, আর নির্মাতা পরের উৎপাদনে নতুন revision আনে বলে জানা যায়। Recovery mode-এ হাতে যন্ত্র পাওয়া কেউ chain of trust-এর একেবারে গোড়ায় নিজের কোড চালাতে পারত।
এখান থেকে দুই দিকের শিক্ষা। প্রথমত, অপরিবর্তনীয়তা কেন দরকার: root of trust যদি software update দিয়ে বদলানো যেত, তাহলে সেই update-এর পথটিই আক্রমণের লক্ষ্য হতো, আর একবার ভাঙলে আক্রমণকারী root-টিই বদলে দিত। যে জিনিস বদলানো যায় না, তাকে পরের কোনো কোড মিথ্যা বলাতে পারে না; এজন্য OTP, eFuse আর ROM.
দ্বিতীয়ত, অপরিবর্তনীয়তার দাম: ভুলও স্থায়ী। এর উত্তর হলো ROM-এর কোড যত সম্ভব ছোট আর সরল রাখা, কারণ কম কোড মানে কম ভুলের সুযোগ। ROM-এর কাজ শুধু পরের ধাপের signature যাচাই আর একটি ন্যূনতম উদ্ধারের পথ; বাকি সব জটিলতা, যেমন network, file system বা A/B-র যুক্তি, যায় এমন bootloader-এ, যা নিজে যাচাই হয় আর দরকারে signed update পায়। এই পর্বের নকশায় bootloader 3632 byte; বাস্তব ROM-এর জন্য এটুকুও বড় হতে পারে।
আরেকটি লক্ষণীয় দিক: ত্রুটিটি কাজে লাগাতে হাতে যন্ত্র লাগত, দূর থেকে নয়। Threat model-এ (পর্ব ৭৬) “হাতে যন্ত্র পাওয়া আক্রমণকারী” আর “network-এর আক্রমণকারী” আলাদা ঘর, আর প্রতিরক্ষাও আলাদা: debug port-এর তালা, recovery mode-এ ঢোকার শর্ত, tamper-প্রতিরোধী আবরণ।
মূল উপলব্ধি: Root of trust অপরিবর্তনীয় হবে, তাই তাকে ছোট আর সরল হতেই হবে; যা বদলাতে হতে পারে, তা যাচাইযোগ্য পরের ধাপে রাখুন।
প্র ০২২০১০ সালে একটি game console-এর firmware-এর signature-এর private key প্রকাশ্যে চলে আসে, গণিত না ভেঙেই। কীভাবে, আর firmware সই করার নিয়মে এর শিক্ষা কী?
২০১০ সালের ডিসেম্বরে Chaos Communication Congress (27C3)-এ fail0verflow নামের একটি দল দেখায় যে Sony PlayStation 3-এর firmware সই করার ECDSA-তে প্রতিটি সইয়ে একই “এলোমেলো” সংখ্যা ব্যবহার হচ্ছিল। ECDSA-র প্রতিটি সইয়ে একটি নতুন, গোপন, অননুমেয় সংখ্যা (nonce) লাগে; দুটি ভিন্ন বার্তার সইয়ে একই nonce থাকলে সাধারণ বীজগণিত দিয়েই private key বের করা যায়। ফলে নির্মাতার private key জানা হয়ে যায়, আর তা দিয়ে যে কেউ “বৈধ” firmware সই করতে পারত বলে তখন ব্যাপকভাবে প্রকাশিত হয়।
লক্ষ করুন, এখানে ECDSA-র গণিত ভাঙেনি, ভেঙেছে ব্যবহারের নিয়ম। Cryptography-র বেশিরভাগ বাস্তব ব্যর্থতা এমনই: ভুল random number, key-এর ভুল জায়গা, যাচাইয়ের একটি ধাপ বাদ। Cybersecurity কোর্সের পর্ব ১৪ (Cryptography-র সাধারণ ভুল) এই ধরনের ভুলের তালিকা দেয়।
Firmware-এর জন্য তিনটি শিক্ষা। এক, এমন signature পদ্ধতি বেছে নেওয়া যা এই ভুলের সুযোগই কম রাখে: Ed25519 (RFC 8032) nonce বানায় private key আর বার্তা থেকে নির্দিষ্ট নিয়মে (deterministic), তাই সই করার মুহূর্তে random number-এর মান খারাপ হলেও একই ভুল হয় না; ECDSA-র জন্যও RFC 6979-এ deterministic nonce-এর নিয়ম আছে। দুই, সই করার কাজ একটি পরীক্ষিত library আর HSM-এ, নিজের লেখা কোডে নয়। তিন, key ফাঁস হলে কী হবে তা আগে থেকে ভাবা: যন্ত্রে যদি শুধু একটি public key স্থায়ীভাবে বসানো থাকে আর বাতিল করার পথ না থাকে, তাহলে ফাঁস হওয়া key-এর সই চিরকাল বৈধ থাকবে। তাই OTP-তে একাধিক key-এর ঘর আর বাতিলের ব্যবস্থা নকশায় রাখা হয়।
এই পর্বের lab-এ throwaway key memory-তে বানিয়ে run শেষে ফেলে দেওয়া হয়েছে, আর page-এ শুধু public key-এর ছাপের প্রথম ৮ byte দেখানো হয়েছে; পণ্যের key-এর জন্য অভ্যাসটি এর চেয়ে অনেক কঠোর হতে হবে।
মূল উপলব্ধি: Signature যত শক্তই হোক, তার নিরাপত্তা private key-এর সুরক্ষা আর সই করার প্রক্রিয়ার মানের সমান; গণিতের চেয়ে প্রক্রিয়াই বেশি ভাঙে।
প্র ০৩Anti-rollback counter একবার বাড়লে আর কমে না। একটি নির্মাতা দেখল নতুন v5-এ গুরুতর bug, আর counter ইতিমধ্যে ৫. এখন কী করা যায়, আর counter-এর নকশায় এ থেকে কী শিখবেন?
Counter-এর পুরো উদ্দেশ্যই এক দিকে চলা, তাই v4-এ ফেরা আর সম্ভব নয়, এমনকি নির্মাতার নিজের ইচ্ছাতেও না। একমাত্র পথ সামনে যাওয়া: v4-এর কোড নিয়ে তাকে v6 নামে নতুন করে build আর সই করে পাঠানো (অনেকে একে “roll forward” বলেন)। এজন্য release-এর প্রক্রিয়া এমন হওয়া চাই যে যেকোনো পুরোনো কোড দ্রুত নতুন version নম্বরে ছাড়া যায়।
নকশার শিক্ষা কয়েকটি। প্রথমত, counter বাড়ানোর মুহূর্ত: এই পর্বের bootloader বাড়ায় নতুন image confirm হওয়ার পরে। Confirm মানে যন্ত্রটি নিজে প্রমাণ করেছে যে নতুন firmware চলে আর আসল কাজ করে; তার আগে বাড়ালে A/B-র rollback-ও আটকে যেত, যেমন অংশ ৫-এ আলোচনা করেছেন।
দ্বিতীয়ত, “security version” আর সাধারণ version আলাদা রাখা। Android-এর verified boot-এ rollback index-এর ধারণা এমনই বলে জানা যায়: প্রতিটি release-এ counter বাড়ানো হয় না, বাড়ানো হয় যখন পুরোনো version-এ একটি গুরুতর নিরাপত্তা-ত্রুটি সারানো হয়েছে। তাতে সাধারণ ছোট release-গুলোর মধ্যে দরকারে ফেরা যায়, আর শুধু বিপজ্জনক পুরোনোগুলো চিরতরে বন্ধ হয়।
তৃতীয়ত, counter-এর দৈর্ঘ্য। eFuse-এ প্রতিটি বৃদ্ধি একটি fuse পোড়ায়; ৩২টি fuse থাকলে মোট ৩২ বার বাড়ানো যায়। প্রতিটি release-এ বাড়ালে কয়েক বছরে ফুরিয়ে যাবে; নিরাপত্তা-version আলাদা রাখলে যন্ত্রের পুরো জীবনে যথেষ্ট। আর counter থাকে কোথায়, তাও প্রশ্ন: সাধারণ flash-এ রাখলে, flash-এ লিখতে পারে এমন যে কেউ কমিয়ে দিতে পারে; এজন্য OTP, secure element বা TrustZone-এর সুরক্ষিত দিক। কোর্সের board-এর .noinit শুধু শেখার বদলি, কারণ power-on-এ তা হারায়।
মূল উপলব্ধি: Anti-rollback একমুখী দরজা; তাই কখন খুলবেন (confirm-এর পরে), কতবার খুলতে পারবেন (security version) আর দরজাটি কোথায় (বদলানো যায় না এমন memory), এই তিনটিই নকশার অংশ।
প্র ০৪নতুন firmware কখন নিজেকে “confirm” করবে? Boot-এর সঙ্গে সঙ্গে, এক মিনিট পরে, নাকি server-এ যুক্ত হওয়ার পরে? বাজারঘরের cold-storage monitor-এর জন্য একটি নীতি যুক্তিসহ দিন।
Confirm-এর অর্থ “এই firmware রাখার যোগ্য”, আর তার পরে rollback-এর দরজা বন্ধ, counter বাড়ে। তাই প্রশ্নটা আসলে: কতটা প্রমাণ পেলে আমরা নিশ্চিন্ত? Boot-এর সঙ্গে সঙ্গে confirm করলে শুধু প্রমাণ হয় যে reset handler পর্যন্ত চলে; এই পর্বের ত্রুটিপূর্ণ v2-ও দাম ছাপতে পেরেছিল, আটকেছিল তার পরে। এমন confirm প্রায় অর্থহীন।
অন্য প্রান্তে, “এক সপ্তাহ ঠিক চললে confirm” বেশি সাবধানী শোনায়, কিন্তু এতদিন trial অবস্থায় থাকা মানে যেকোনো সাধারণ reset, যেমন বিদ্যুৎ যাওয়া, rollback ঘটাবে, আর বহরে অর্ধেক যন্ত্র পুরোনো version-এ ফিরে যেতে পারে।
Cold-storage monitor-এর আসল কাজ দুটি: তাপমাত্রা পড়া আর alarm বা telemetry পৌঁছানো। তাই একটি যুক্তিসঙ্গত নীতি: পরপর ৩টি বৈধ sensor-এর পড়া (README-এর alarm-এর confirm সংখ্যার সঙ্গে মিলিয়ে), আর অন্তত একটি telemetry বার্তার broker-এর স্বীকৃতি (QoS 1-এর PUBACK, পর্ব ৭৩), নির্দিষ্ট সময়সীমার মধ্যে, ধরা যাক 60 s. সময়সীমা পেরোলে নতুন firmware নিজেই watchdog kick বন্ধ করে, যাতে rollback হয়। অনুশীলন ১-এ এই নীতির C function, আর আমার lab-এ host-এ তিনটি ক্রমে চালানো ফল আছে।
দুটি সূক্ষ্ম দিক। এক, trial চলাকালীনও যন্ত্রের নিরাপত্তার কাজ বন্ধ রাখা যায় না: alarm-এর যুক্তি প্রথম সেকেন্ড থেকেই চলবে। দুই, server-এর ওপর নির্ভরতা: Wi-Fi সাময়িক বন্ধ থাকলে একটি ভালো firmware-ও confirm হতে পারবে না আর rollback হবে। এটি গ্রহণযোগ্য, কারণ ফল নিরাপদ দিকে (পুরোনো, জানা-ভালো firmware), আর পরে আবার চেষ্টা করা যায়; কিন্তু server-কে এমন ঘটনা গুনতে হবে, নইলে বহরের অর্ধেক কেন পুরোনো version-এ তা কেউ বুঝবে না (পর্ব ৭৫)।
মূল উপলব্ধি: Confirm হবে যন্ত্রের আসল কাজের প্রমাণে, সময়সীমার মধ্যে; প্রমাণ না এলে ফল হবে নিরাপদ rollback, অচল যন্ত্র নয়।
প্র ০৫২০১৫ সালে গবেষকেরা দূর থেকে একটি গাড়ির নিয়ন্ত্রণে ঢোকার পথ দেখান, আর এর পরে নির্মাতাকে বিপুল সংখ্যক গাড়ির update-এ USB stick ডাকযোগে পাঠাতে হয়। firmware-এর signature আর OTA-র নকশা নিয়ে এই ঘটনা কী বলে?
২০১৫ সালে নিরাপত্তা-গবেষক Charlie Miller আর Chris Valasek একটি Jeep Cherokee-র infotainment ব্যবস্থার cellular সংযোগ দিয়ে দূর থেকে ঢুকে গাড়ির কিছু নিয়ন্ত্রণে প্রভাব ফেলার পথ দেখান। তাঁদের প্রকাশিত বিবরণ অনুযায়ী শৃঙ্খলের একটি গুরুত্বপূর্ণ ধাপ ছিল infotainment-এর ভেতরের একটি নিয়ন্ত্রক chip-এর firmware নতুন করে লেখা, যা CAN bus-এর সঙ্গে যুক্ত (পর্ব ৫২), আর সেই firmware update-এ কার্যকর signature যাচাই ছিল না বলে তাঁরা জানান। ঘটনার পরে নির্মাতা প্রায় ১৪ লাখ গাড়ির জন্য recall ঘোষণা করে, আর মালিকদের USB stick-এ update পাঠানো হয় বলে তখনকার সংবাদে আসে।
প্রথম শিক্ষা: শুধু “প্রধান” processor নয়, যন্ত্রের প্রতিটি programmable chip-এর firmware-এর নিজের যাচাই লাগে। একটি যন্ত্রে প্রায়ই কয়েকটি MCU থাকে, আর সবচেয়ে দুর্বলটিই প্রবেশপথ। বাজারঘরের warehouse gateway-তে Wi-Fi module-এর firmware আর মূল MCU-র firmware দুটিকেই এই প্রশ্নের মুখোমুখি করতে হবে।
দ্বিতীয় শিক্ষা: নিরাপদ OTA না থাকলে সমাধানের খরচ বিশাল। লাখ লাখ যন্ত্রের মালিককে হাতে update বসাতে বলা ধীর, অনেকে কখনো বসান না, আর USB stick নিজেও নতুন ঝুঁকি। Signed OTA, anti-rollback আর A/B থাকলে একই সংশোধন দিনে বা সপ্তাহে বহরে পৌঁছায়। এজন্য গাড়ির ক্ষেত্রে জাতিসংঘের UN Regulation No. 156 (software update-এর ব্যবস্থা) প্রায় ২০২১ সাল থেকে কিছু বাজারে প্রযোজ্য হতে শুরু করে বলে জানা যায়, আর ETSI EN 303 645-ও consumer IoT-তে নিরাপদ update চায়।
তৃতীয় শিক্ষা: OTA নিজেই সবচেয়ে শক্তিশালী আক্রমণের পথ, কারণ এটি নতুন কোড চালানোর বৈধ দরজা। তাই এর প্রতিটি ধাপ, অর্থাৎ manifest-এর signature, version, hardware মেলানো আর trial boot, একটিও বাদ দেওয়া চলে না; এই পর্বের tamper2-এর run দেখিয়েছে, একটি ধাপ বাদ পড়লে কী হয়।
মূল উপলব্ধি: প্রতিটি programmable chip-এ চালানোর আগে signature যাচাই, আর একটি নিরাপদ OTA-র পথ, দুটি একসঙ্গে একটি যন্ত্রকে মাঠে রক্ষণযোগ্য রাখে; যেকোনো একটির অভাব শেষে হাতে হাতে সারাইয়ে গিয়ে দাঁড়ায়।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর কোর্সের virtual board-এ, host-এর C-তে বা Python-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — cold room-এর confirm নীতি: নতুন firmware trial-এ চলছে। প্রতি 1 s-এ ডাকা হয় এমন একটি C function
trial_tick(t_s, reading_ok, mqtt_acked)লিখুন, যা পরপর ৩টি বৈধ পড়া আর অন্তত একটি telemetry-র PUBACK পেলেboot_state.confirmedবসায়, আর 60 s-এর মধ্যে না পেলে watchdog kick বন্ধ করিয়ে rollback ঘটায়।#define NEED_READINGS 3u #define CONFIRM_DEADLINE_S 60u static uint32_t good; /* good readings in a row */ static int acked; /* one telemetry PUBACK seen */ void trial_tick(uint32_t t_s, int reading_ok, int mqtt_acked) { if (!boot_state.trial || boot_state.confirmed || stop_kicking) return; good = reading_ok ? good + 1u : 0u; if (mqtt_acked) acked = 1; if (good >= NEED_READINGS && acked) { boot_state.confirmed = 1u; /* bootloader makes it permanent */ return; } if (t_s >= CONFIRM_DEADLINE_S) stop_kicking = 1u; /* watchdog -> reset -> rollback */ }boot_stateআরstop_kickingদুটিইvolatile; kick যে কোড করে, সেstop_kickingদেখে থামে। একটি খারাপ পড়ায়goodশূন্য হয়, কারণ “পরপর” চাওয়া হয়েছে। আমার lab-এ এই function host-এ (Clang 22.1.8,-Wall -Wextra, কোনো warning নেই) তিনটি ক্রমে চালানো হয়েছে: সুস্থ যন্ত্র, PUBACK 5 s-এ →confirmed at t=5 s; PUBACK কখনো আসে না →stop kicking (rollback) at t=60 s; sensor মৃত →stop kicking (rollback) at t=60 s. Trial চলাকালীনও alarm-এর যুক্তি আলাদাভাবে চলতে থাকবে। -
ভুল খুঁজুন — size না দেখা bootloader: একজন সহকর্মী
verify()থেকে “অপ্রয়োজনীয়” মনে করেh->size-এর সীমার পরীক্ষা বাদ দিলেন। কেউ slot A-র header-এ size 0x00100000 (1 MiB) বসাল। কোর্সের board-এ সত্যিকারের run:
কী ঘটেছে, আসল যন্ত্রে এর ফল কী, আর সমাধান কী?[ 0.0620 ms] UART: bootloader: reset cause POWER-ON, active A, min_version 1 [ 0.0799 ms] MARK 1 [ 501.3186 ms] HardFault: Invalid memory read (UC_ERR_READ_UNMAPPED) at PC=0x080006E0 block+0x18 [ 5000.0000 ms] UART: verify slot A: (no newline) [ 5000.0000 ms] stopped: cycle limit (40000000) reached after 40000000 cyclesHeader বদলকারীর হাতে, আর size তার একটি মান। পরীক্ষা ছাড়া SHA-256 0x08008080 থেকে 1 MiB পড়তে শুরু করে, কিন্তু board-এর flash শেষ 0x08020000-এ (128 KiB); সেখানে পৌঁছে
block()-এর ভেতরে একটি অবৈধ পড়া, HardFault, আর bootloader-এর default handler চিরকাল ঘোরে: যন্ত্র কোনো image না চালিয়ে আটকে গেল, পুরোনো ভালো image থাকা সত্ত্বেও। আসল chip-এ এর ফল আরও খারাপ হতে পারে: flash-এর পরে অন্য memory থাকলে কোড সেখান থেকে পড়তে থাকে, আর header-এর অন্য কোনো মান (যেমন কপির ঠিকানা) একইভাবে বিশ্বাস করলে memory-র বাইরে লেখাও সম্ভব। সমাধান: header-এর প্রতিটি মান ব্যবহারের আগে সীমা-পরীক্ষা (size == 0 || size > SLOT_SIZE - HDR_SIZEহলে প্রত্যাখ্যান), আর trial না হলেও bootloader-এ watchdog রাখা। পরীক্ষা ফিরিয়ে একই header-এ সত্যিকারের run:verify slot A: bad size -> rejected,verify slot B: no image, তারপর alarm ON আরexit(2) after 1286 cycles: যন্ত্র স্পষ্টভাবে, নিরাপদে থামে। -
আগে বলুন, তারপর মিলিয়ে দেখুন — v3-এর দুবারের চেষ্টা: একটি যন্ত্রে active = B (v2), min_version = 2. Slot A-তে v3 নামানো হয়েছে আর pending = A. এরপর চারটি boot: (১) software reset, v3-এর self-test আটকে যায়; (২) watchdog reset, তারপর app আবার A-কে pending করে; (৩) software reset, এবার v3 confirm করে; (৪) আরেকটি software reset. প্রতিটি boot-এ bootloader কী সিদ্ধান্ত নেবে, আর শেষে active আর min_version কত?
(১) trial boot A v3, confirm নেই। (২) trial A NOT confirmed → B-তে rollback, B v2 চলে; app আবার A-কে pending করে। (৩) trial boot A v3, এবার confirmed. (৪) trial A confirmed → active = A, min_version = 3, A v3 চলে। এখন থেকে v2 আর চলবে না। অংশ ৬-এর Python মডেল দিয়ে আমার lab-এ যাচাই করা আসল আউটপুট:
[SOFTWARE] active B, min_version 2 trial boot A v3, watchdog on -> hangs, no confirm [WATCHDOG] active B, min_version 2 trial A NOT confirmed -> roll back to B boot B v2 [SOFTWARE] active B, min_version 2 trial boot A v3, watchdog on -> confirmed [SOFTWARE] active B, min_version 2 trial A confirmed -> active, min_version 3 boot A v3লক্ষ করুন, প্রথম ব্যর্থতায় min_version 2-ই ছিল, তাই B-তে ফেরা সম্ভব হয়েছে।
-
হিসাব — flash-এর ভাগ আর update-এর খরচ: একটি MCU-তে 512 KiB flash. Bootloader 32 KiB, boot-এর অবস্থার জন্য 8 KiB, বাকিটা দুটি সমান slot; প্রতিটি slot-এর শুরুতে 128 byte header. (ক) প্রতিটি slot কত, আর image সর্বোচ্চ কত byte? (খ) 200 000 byte-এর image-এ SHA-256-এর কয়টি block? (গ) 50 kbit/s কার্যকর গতিতে নামাতে কত সময়? (ঘ) কোর্সের board-এর মডেলে hash-এর হার (2500 byte-এ প্রায় 104779 নির্দেশ) ধরলে 200 000 byte hash করতে মোটামুটি কত নির্দেশ আর 8 MHz-এ কত সময়?
(ক) (512 − 32 − 8) ÷ 2 = 236 KiB = 241664 byte; image সর্বোচ্চ 241664 − 128 = 241536 byte. (খ) (200000 + 9) ÷ 64 = 3125.14, তাই 3126টি block. (গ) 200000 × 8 ÷ 50000 = 32 s. (ঘ) 104779 ÷ 2500 ≈ 41.9 নির্দেশ প্রতি byte, × 200000 ≈ 8.38 মিলিয়ন নির্দেশ; board-এ ১ নির্দেশ = ১ cycle ধরা, তাই 8 MHz-এ প্রায় 1.05 s. এটি শুধু board-এর মডেলের সংখ্যা (Spec decision 17); আসল chip-এ cycle-প্রতি-নির্দেশ, flash-এর wait state আর hash accelerator সবকিছু বদলে দেয়, তাই পণ্যের জন্য মাপতে হয়। সব সংখ্যা আমার lab-এ Python-এ হিসাব করে মেলানো।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি A/B যন্ত্রে নিরাপদ OTA update-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Server নতুন version-এর signed manifest প্রকাশ করে: version, আকার, SHA-256
- যন্ত্র manifest-এর সই আর version দেখে image অন্য slot-এ নামায়
- পুরো image-এর hash, signature আর version ≥ min_version যাচাই
- নতুন slot-কে pending চিহ্ন দিয়ে reboot
- Bootloader আবার যাচাই করে watchdog চালু রেখে trial boot দেয়
- নতুন firmware self-test পাস করে confirm করে, তারপর counter বাড়ে
একটি bootloader image চালানোর আগে তার SHA-256 হিসাব করে image-এর header-এ রাখা digest-এর সঙ্গে মেলায়। কেউ image বদলে header-এর digest-ও নতুন করে হিসাব করে বসাল। কী হবে?
- Hash মিলবে না, তাই image প্রত্যাখ্যাত হবে
- SHA-256 নির্মাতার চিহ্ন বহন করে, তাই জাল ধরা পড়বে
- Image চলবে, কারণ hash মেলে; signature থাকলে তবেই ধরা পড়ত
- CPU HardFault দেবে
Firmware যাচাইয়ে HMAC-এর বদলে digital signature বেশি পছন্দ করা হয় কেন?
- Signature যাচাই HMAC-এর চেয়ে দ্রুত
- যন্ত্রে শুধু public key রাখতে হয়, যা ফাঁস হলেও সই বানানো যায় না
- HMAC image-এর বদল ধরতে পারে না
- Signature image-কে encrypt করে গোপন রাখে
একটি যন্ত্রের anti-rollback counter-এ min_version = 5. Server থেকে নির্মাতার বৈধ signature-সহ version 4-এর একটি image এল, যার hash-ও ঠিক। Bootloader কী করবে?
- চালাবে, কারণ signature আর hash দুটিই বৈধ
- চালাবে আর counter 4-এ নামিয়ে দেবে
- Hash ঠিক থাকায় HardFault দেবে
- প্রত্যাখ্যান করবে, কারণ version min_version-এর চেয়ে কম
একটি A/B ব্যবস্থায় bootloader নতুন image-কে trial হিসেবে চালায় আর 200 ms-এর watchdog চালু রাখে। নতুন image চালুর পরে confirm না করে একটি loop-এ আটকে গেল। এরপর কী হবে?
- Watchdog reset দেবে, আর bootloader পুরোনো slot-এ rollback করবে
- Bootloader নিজেই loop ধরে image থামাবে
- যন্ত্র চিরকাল আটকে থাকবে
- Anti-rollback counter বেড়ে যাবে, আর নতুন image স্থায়ী হবে
SHA-256-এ বার্তার পরে অন্তত ১ byte (0x80) আর ৮ byte-এর দৈর্ঘ্য যোগ হয়, আর পুরোটা ৬৪ byte-এর block-এ ভাগ হয়। 2500 byte-এর একটি firmware image hash করতে কয়টি block লাগে?
- ৩৯টি
- ৭৮টি
- ৪০টি
- ৪১টি
একটি OTA ব্যবস্থায় anti-rollback counter কোন মুহূর্তে বাড়ানো সবচেয়ে নিরাপদ?
- Image নামানো শেষ হওয়ার সঙ্গে সঙ্গে
- নতুন image trial boot-এ self-test পাস করে confirm করার পরে
- Signature যাচাইয়ের আগে, server-এর নির্দেশে
- কখনো না; version-এর তুলনাই যথেষ্ট
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Chain of trust: ROM আর OTP-র key থেকে শুরু, প্রতিটি ধাপ পরের কোড যাচাই করে তবেই লাফ দেয়; বদলানো যায় না এমন প্রথম কড়া ছোট আর সরল।
- Hash বনাম signature: hash বদল ধরে (board-এ tamper1: MISMATCH), কিন্তু digest-সহ বদলালে ঠকে (tamper2: 119.38 Tk); signature উৎসও প্রমাণ করে, যন্ত্রে লাগে শুধু public key.
- Bootloader-এর ক্রম: magic, size-এর সীমা, SHA-256, constant-time তুলনা, signature, version; তারপর VTOR, MSP আর লাফ।
- Anti-rollback: একমুখী counter, OTP বা eFuse-এ; বাড়বে নতুন image confirm হওয়ার পরে (board: v2 confirm, তারপর v1 প্রত্যাখ্যাত)।
- A/B আর trial: নতুন slot-এ watchdog-সহ trial boot, আসল কাজের প্রমাণে confirm, না এলে reset আর rollback (board: 34.5998 → 234.5998 ms); delta update শুধু পাঠানোর খরচ কমায়, যাচাই নয়।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৭৬ · IoT securityআগের পর্বThreat model, যন্ত্রের পরিচয়, TLS আর debug port-এর তালা।
- পর্ব ৬১ · Watchdog আর fault handlingভিত্তিযে watchdog আর .noinit-এর ওপর trial boot আর rollback দাঁড়িয়ে।
- পর্ব ৭৫ · IoT cloud আর device managementপাশের পর্বCloud-এর দিক থেকে OTA: manifest, chunk আর ধাপে ধাপে rollout.
- Cybersecurity পর্ব ১১ · Digital signature আর PKIপাশের ট্র্যাকSignature-এর গণিত, certificate আর বিশ্বাসের শিকল।
- Cybersecurity পর্ব ৩৫ · Mobile আর IoT নিরাপত্তাপাশের ট্র্যাকFirmware আর device hardening, নিরাপত্তার বড় ছবি থেকে।