সরাসরি পর্বে যান
পর্ব ৬০ · ৮২-এর মধ্যে · মডিউল ১০

Fuzz testing — এলোমেলো input, coverage-guided fuzzing আর crash

Fuzz Testing — Random Input, Coverage-Guided Fuzzing and Crashes

Taught in Bangla, this lesson treats fuzzing as defensive testing of your own app on localhost. A toy coverage-guided fuzzer in the page finds a phone-form crash in 240 tries where a blind one fails in 2000, then the crash is minimised, grouped by signature and turned into a regression test. Real runs use Hypothesis as a fuzzer and Schemathesis against a local copy of the demo shop, which surfaced a genuine 500 from an oversized integer id. Atheris failed to build on Windows and is shown only as an example.

এই পর্বে যা শিখবেন

  • Fuzzing কী, কোন test design technique-এর সাথে এর মিল, আর এর oracle কী কী হতে পারে
  • Dumb বনাম smart, mutation বনাম generation, grammar-based আর coverage-guided fuzzer-এর পার্থক্য
  • নিজে একটি ছোট coverage-guided fuzzer চালিয়ে দেখা কেন coverage-এর সংকেত এত শক্তিশালী
  • Crash পাওয়ার পরের কাজ: minimise, signature দিয়ে জড়ো করা, triage আর regression test
  • Schemathesis আর Hypothesis দিয়ে নিজের app-এ সীমিত, পুনরুৎপাদনযোগ্য fuzzing, আর CI-তে সময়ের বাজেট

১ · Fuzzing — যন্ত্রের হাতে বিদঘুটে input

মোবাইল রিচার্জের দোকানের কথা ভাবুন। দোকানি দিনে শত শত নম্বর লেখেন, আর ক্রেতারা নম্বর বলেন নানা রূপে: কেউ বাংলায় “শূন্য এক সাত…”, কেউ “প্লাস আট আট” দিয়ে শুরু করে মাঝপথে থেমে যান, কেউ কাগজে লিখে আনেন ড্যাশ আর ফাঁকা দিয়ে। কোনো নিয়মের বই এই সব রূপ আগে থেকে লিখে রাখে না। দোকানের নতুন রিচার্জ-মেশিন সত্যিই শক্ত কি না, জানার একটি উপায়: এক সপ্তাহ ধরে হাজারো অদ্ভুত নম্বর টাইপ করে দেখা, মেশিন কোথাও আটকে যায় বা বন্ধ হয়ে যায় কি না।

Fuzzing (fuzz testing) ঠিক এই কাজ যন্ত্রকে দিয়ে করায়। একটি program স্বয়ংক্রিয়ভাবে প্রচুর অপ্রত্যাশিত, ভাঙা বা এলোমেলো input বানায়, পরীক্ষার system-এ পাঠায়, আর প্রতিটির পরে একটি সরল প্রশ্ন করে: কিছু ভেঙেছে কি? ISTQB-এর glossary-তেও মোটামুটি এভাবেই বলা হয়: অনেক অবৈধ বা অপ্রত্যাশিত input দিয়ে program চালানো, ব্যর্থতা খোঁজার জন্য (ভাষা আমাদের, ভাব তাদের)। লক্ষ করুন, fuzzing-এ সাধারণত প্রতিটি input-এর “সঠিক উত্তর” আগে থেকে জানা থাকে না। তাই প্রশ্নটি হয় “উত্তর কি ঠিক?” নয়, “কিছু কি স্পষ্টভাবে ভুল?”

এই “স্পষ্টভাবে ভুল” ঠিক করে fuzzing-এর oracle. প্রচলিত চারটি:

  • Crash: অপ্রত্যাশিত exception বা process বন্ধ হয়ে যাওয়া। পরিকল্পিত error (যেমন “ফোন নম্বর সঠিক নয়”) crash নয়; অপরিকল্পিত IndexError crash.
  • Hang: একটি input-এ program ঝুলে থাকা বা সময়সীমা পেরোনো।
  • Server error: web API-তে যেকোনো 5xx. Server-এর কাছে 500 মানে “আমি নিজেই জানি না কী হলো”।
  • Invariant ভাঙা: এমন নিয়ম যা সব input-এ সত্য থাকার কথা, যেমন “ছাড় কখনো ৩০০ টাকার বেশি নয়”। এখানে fuzzing মিশে যায় পর্ব ৫৮-এর property-based testing-এর সাথে।

Fuzzing একেবারে নতুন কিছু নয়, আপনি এর আত্মীয়দের চেনেন। পর্ব ১৪-এর error guessing-এ আপনি নিজে বিদঘুটে input-এর তালিকা বানিয়েছিলেন: বাংলা অঙ্ক, +880, শেষে ফাঁকা। পর্ব ০৮-এর boundary value analysis বলেছিল সীমার কাছে খুঁজুন। Fuzzing এই দুটিকে যন্ত্রের গতিতে নিয়ে যায়: মানুষ দশটি অনুমান লেখেন, fuzzer মিনিটে দশ হাজার চেষ্টা করে। আর পর্ব ৫৩-এর ZAP active scan-এ “User Agent Fuzzer” নামের rule দেখেছিলেন; নিরাপত্তার scanner-ও ভেতরে fuzzing-এর কৌশল ব্যবহার করে।

শুধু নিজের app-এ, শুধু নিজের কম্পিউটারে। Fuzzer অল্প সময়ে হাজার হাজার request পাঠায়, data বদলায়, server-এ চাপ দেয়। অন্যের website বা অনুমতিহীন কোনো system-এ এটি চালানো আক্রমণের মতো দেখায় আর ক্ষতি করতে পারে। এই পর্বের সব run একটি কম্পিউটারে, বাজারঘরের নিজস্ব কপিতে, শুধু 127.0.0.1:8843-এ; প্রতিটি run-এ উদাহরণের সংখ্যা বা সময়ের ঊর্ধ্বসীমা বাঁধা।

নামটির জন্ম নিয়ে একটি পরিচিত গল্প আছে, যা Barton Miller নিজে বহুবার বলেছেন: ১৯৮৮ সালের দিকে ঝড়ের রাতে modem-এর লাইনের গোলমাল (“fuzz”) তাঁর টাইপ করা command-এ আবর্জনা ঢুকিয়ে দিচ্ছিল, আর তাতে পরিচিত Unix utility-গুলো crash করছিল। পরে তাঁর ছাত্রদের সাথে তিনি পরিকল্পিতভাবে এলোমেলো input দিয়ে utility-গুলো পরীক্ষা করেন; ১৯৯০ সালে Communications of the ACM-এ প্রকাশিত সেই গবেষণায়, যতদূর জানা যায়, বিভিন্ন Unix-এ মোটামুটি এক-চতুর্থাংশ থেকে এক-তৃতীয়াংশ utility crash করেছিল বা ঝুলে গিয়েছিল। গল্পটির বিস্তার আর নিরাপত্তার দিক সাইবার নিরাপত্তা কোর্সের পর্ব ৪৯-এ আছে; এখানে আমরা tester-এর কাজের দিকটি দেখব।

২ · Fuzzer-এর রকমফের — dumb, smart, mutation আর grammar

সব fuzzer একরকম নয়। তিনটি প্রশ্নে এদের ভাগ করা যায়: input কোথা থেকে আসে, fuzzer input-এর গঠন কতটা জানে, আর program-এর ভেতরের কতটা সে দেখে।

ধরনInput কীভাবে বানায়শক্তিদুর্বলতা
Dumb (অন্ধ) randomপুরো এলোমেলো byte বা অক্ষরবানানো সহজ, কোনো অনুমান নেইবেশিরভাগ input প্রথম যাচাইতেই বাতিল, ভেতরে পৌঁছায় না
Mutation-basedবৈধ নমুনা নিয়ে অক্ষর মোছা, বদলানো, যোগ করানমুনার কাছাকাছি থাকে, তাই অনেক input বৈধের মতোনমুনায় যা নেই, সেদিকে কম যায়
Generation-basedFormat বা schema-র বর্ণনা থেকে শূন্য থেকেগঠন ঠিক রেখে ভেতরের যুক্তিতে পৌঁছায়বর্ণনা লিখতে সময় লাগে; বর্ণনার বাইরের ভুল দেখে না
Grammar-basedGeneration-এর একটি রূপ: নিয়ম একটি grammar-এQuery, JSON, ফর্মুলা, ছোট ভাষার জন্য চমৎকারGrammar যত ভালো, fuzzer তত ভালো
Coverage-guidedMutation, কিন্তু নতুন কোড-চালানো input রেখে দেয়নিজে থেকে গভীর পথ খোঁজেProgram-কে মাপার ব্যবস্থা (instrumentation) লাগে

যে fuzzer input-এর গঠন বা program-এর ভেতরের কিছু জানে, তাকে চলতি কথায় “smart” বলা হয়; যে কিছুই জানে না, সে “dumb”. Program-এর ভেতর দেখার দিক থেকে আরেকটি ভাগ: black-box (শুধু input আর output), grey-box (কোডের কোন অংশ চলল, শুধু সেই হালকা তথ্য) আর white-box (কোডের শর্ত বিশ্লেষণ করে input হিসাব করা, যেমন symbolic execution). আজকের সবচেয়ে প্রচলিত fuzzer-গুলো, যেমন AFL++ আর libFuzzer, grey-box আর coverage-guided.

Generation-based fuzzing কেমন দেখায়, একটি ছোট উদাহরণে দেখা যাক। বাজারঘরের দামের হিসাবের endpoint /api/pricing/quote?subtotal=…&district=…. নিচের grammar প্রতিবার একটি পুরোপুরি গঠনসম্মত query বানায়, কিন্তু subtotal-এর ঘরে বসায় নানা “প্রায়-সংখ্যা”: ঋণাত্মক, সামনে ফাঁকা, e3 বা abc লেজ, বাংলা অঙ্ক, বিশাল সংখ্যা। Oracle এখানে differential testing: একই মান দুটি জায়গায় পড়া হয়, পাতার JavaScript-এর তাৎক্ষণিক preview (parseInt) আর server-এর কড়া নিয়ম (শুধু অঙ্ক, নিরাপদ পূর্ণসংখ্যা)। দুজন একমত না হলে কোথাও একটি ভুল আছে। আগে অনুমান করুন কয় রকম অমিল পাবেন, তারপর চালান।

// Grammar for the pricing-quote query string: every output is well-formed
const G = {
  query: [["subtotal=", "num", "&district=", "dist"]],
  num: [["int"], ["-", "int"], ["int", "e3"], ["int", "abc"], [" ", "int"], ["১০০১"]],
  int: [["1000"], ["1001"], ["0"], ["3000"], ["99999999999999999999"]],
  dist: [["Dhaka"], ["dhaka"], ["Gazipur"], [""]],
};
let seed = 60;                                   // tiny seeded PRNG (reproducible)
const rnd = n => { seed = (seed * 48271) % 2147483647; return seed % n; };
function gen(sym) {
  if (!(sym in G)) return sym;                   // a terminal: plain text
  const rule = G[sym][rnd(G[sym].length)];
  return rule.map(gen).join("");
}
// Two readers of "subtotal": the shop page's quick preview and the server's strict rule
const lenient = v => parseInt(v, 10);           // JS preview code
const strict = v => (/^[0-9]+$/.test(v) && Number.isSafeInteger(+v)) ? +v : "reject";
const seen = new Set(), diffs = new Map();
for (let i = 0; i < 300; i++) {
  const q = gen("query");
  seen.add(q);
  const v = new URLSearchParams(q).get("subtotal");
  const a = lenient(v), b = strict(v);
  const same = (Number.isNaN(a) && b === "reject") || a === b;
  const kind = v.replace(/[0-9]+/g, "N");          // group by shape, keep the first
  if (!same && !diffs.has(kind)) diffs.set(kind, `${JSON.stringify(v)}: preview ${a}, server ${b}`);
}
console.log(`300 generated, ${seen.size} distinct, ${diffs.size} kinds of disagreement:`);
for (const [k, d] of diffs) console.log(`  ${k.padEnd(5)} ${d}`);

আসল আউটপুট (ব্রাউজারের JavaScript):

300 generated, 101 distinct, 5 kinds of disagreement:
  -N    "-3000": preview -3000, server reject
   N    " 1000": preview 1000, server reject
  NeN   "1001e3": preview 1001, server reject
  Nabc  "1001abc": preview 1001, server reject
  N     "99999999999999999999": preview 100000000000000000000, server reject

৩০০টি query-র ১০১টি আলাদা, আর পাঁচ ধরনের অমিল। প্রতিটি একটি আসল প্রশ্ন তোলে। 1001e3 দেখে ব্যবহারকারী হয়তো ১০ লাখ ভেবেছিলেন, preview দেখাচ্ছে ১০০১ টাকার ছাড়; 1001abc-কে preview চুপচাপ ১০০১ বানায়; ঋণাত্মক দামে preview হিসাব চালিয়েই যায়। Server প্রত্যেকটি বাতিল করে, তাই পাতার দেখানো সংখ্যা আর server-এর রায় আলাদা হয়ে যায়: ব্যবহারকারী দেখেন এক, পান আরেক। বাংলা অঙ্কের ১০০১ তালিকায় নেই, কারণ দুজনেই সেটি বাতিল করে (NaN আর reject), অর্থাৎ একমত। Grammar না থাকলে এলোমেলো অক্ষরের বেশিরভাগই subtotal= কাঠামোই ভেঙে ফেলত, আর এই সূক্ষ্ম পার্থক্যগুলো পর্যন্ত পৌঁছাতই না। Grammar-এ num-এর নতুন একটি নিয়ম, যেমন ["int", ".5"], যোগ করে আবার চালিয়ে দেখুন।

৩ · Coverage-guided fuzzing — যে input নতুন পথ খোলে, তাকে রাখুন

অন্ধ fuzzer-এর মূল সমস্যা একটি তালার মতো। ধরুন একটি bug লুকিয়ে আছে তিনটি শর্তের পেছনে: input + দিয়ে শুরু, তারপর 88, তারপর আর কিছু নেই। এলোমেলো চেষ্টায় তিনটি একসাথে মেলার সম্ভাবনা খুব কম। কিন্তু যদি fuzzer টের পায় যে + দিয়ে শুরু করা input কোডের একটি নতুন লাইন চালিয়েছে, তাহলে সে ওই input-টিকে রেখে দিয়ে তার ওপর বদল চালাতে পারে। এভাবে তালার প্রতিটি খাঁজ আলাদা করে খোলে। এটাই coverage-guided fuzzing-এর মূল ধারণা, আর এর জ্বালানি পর্ব ১৩-এর statement coverage, তবে test-এর মান মাপার জন্য নয়, পরের input বাছার জন্য।

Coverage-guided fuzzing-এর loop

Pick from the corpus, mutate, run the harness, measure coverage; keep inputs that reach new code, save every crash

Coverage-guided fuzzing: corpus → mutate → harness → crash বা নতুন coverage → corpus ১ · Corpus seed: 01712345678, ০১৭১… ২ · বেছে নিয়ে mutate মোছা, বদলানো, dictionary: +88 ৩ · Harness চালায় কোন লাইন চলল, মাপা হয় ৪ · Crash? input রাখুন → minimise → test ৫ · নতুন লাইন? হ্যাঁ: corpus-এ যোগ · না: বাদ
ছবি ৬০.১ — বাঁ দিকের তীরটিই coverage-guided fuzzing-এর প্রাণ: নতুন পথ খোলা input ফিরে যায় corpus-এ, আর পরের বদলগুলো সেখান থেকেই শুরু হয়।

ছবির প্রতিটি অংশের একটি নাম আছে। Seed corpus: শুরুর বৈধ নমুনা। Harness: যে ছোট function fuzzer-এর input নিয়ে পরীক্ষার কোড ডাকে। Dictionary: অর্থবহ টুকরো, যেমন +88, যা fuzzer একসাথে বসাতে পারে; এক অক্ষর করে বদলে এমন “জাদুর মান” খুঁজে পাওয়া কঠিন বলে আসল fuzzer-গুলোও এই সুবিধা দেয়।

এবার একটি আসল খেলনা fuzzer. পরীক্ষার কোড বাজারঘরের checkout form-এর একটি ধাপ: validator-এর আগে ফোন নম্বর গুছিয়ে নেওয়া। পর্ব ১৪-এ ঠিক হয়েছিল, validator নিজে বাংলা অঙ্ক নেয় না; form-এর আলাদা একটি ধাপ বাংলা অঙ্ককে ASCII বানায়। আমাদের লেখা সেই ধাপ ফাঁকা আর ড্যাশ মোছে, আর +88 থাকলে সেটি বাদ দেয়। এতে একটি ভুল ইচ্ছা করে রাখা আছে। Coverage মাপা হয় Python-এর sys.settrace দিয়ে, যেভাবে পর্ব ১৩-এর ছোট tracer করেছিল। একই বাজেটে দুটি run: অন্ধ (নতুন coverage পেলেও কিছু রাখে না) আর guided.

import random, sys
BN = str.maketrans("০১২৩৪৫৬৭৮৯", "0123456789")
def to_ascii_phone(raw):            # form step that runs before the validator
    s = raw.strip().translate(BN).replace("-", "").replace(" ", "")
    if s.startswith("+"):
        s = s[1:]
        if s.startswith("88"):      # +88 017… -> 017…
            s = s[2:]
            if s[0] != "0":         # BUG: nothing may follow "+88"
                return None
    return s if len(s) == 11 and s.isdigit() else None
def run(x, hit):                    # record lines of to_ascii_phone; return any crash
    def tr(f, ev, a):
        if f.f_code is to_ascii_phone.__code__ and ev == "line": hit.add(f.f_lineno)
        return tr
    sys.settrace(tr)
    try: to_ascii_phone(x)
    except Exception as e: return e
    finally: sys.settrace(None)
TOKENS = ["+", "88", "0", "১৭", " ", "-"]           # a small fuzzing dictionary
def mutate(s, rng):
    for _ in range(rng.randint(1, 3)):              # 1-3 stacked mutations
        i = rng.randrange(len(s) + 1)
        s = rng.choice([s[:i] + rng.choice(TOKENS) + s[i:], s[:i] + s[i + 1:], s[:i]])
    return s
def fuzz(guided, budget=2000):
    rng, corpus, seen = random.Random(60), ["01712345678", "০১৭১২৩৪৫৬৭৮"], set()
    for x in corpus: run(x, seen)
    for n in range(1, budget + 1):
        x, hit = mutate(rng.choice(corpus), rng), set()
        if err := run(x, hit): return f"exec {n}: CRASH {type(err).__name__} on {x!r} (corpus {len(corpus)})"
        if guided and hit - seen:
            seen |= hit; corpus.append(x); print(f"  exec {n}: new lines, keep {x!r}")
    return f"{budget} execs, no crash (corpus {len(corpus)})"
print("blind :", fuzz(guided=False)); print("guided:"); print("  ->", fuzz(guided=True))

আসল আউটপুট (ব্রাউজারের Python):

blind : 2000 execs, no crash (corpus 2)
guided:
  exec 38: new lines, keep '+০১৭১'
  exec 188: new lines, keep '+88০-১৭১'
  -> exec 240: CRASH IndexError on '+88' (corpus 4)

একই seed, একই mutation, একই ২০০০ বারের বাজেট। অন্ধ run প্রতিবার শুধু দুটি seed থেকে শুরু করে; crash-এর জন্য দরকার একসাথে + বসানো, 88 বসানো আর বাকিটা কেটে ফেলা, যা ১ থেকে ৩টি বদলের একটি চেষ্টায় প্রায় ঘটেই না। Guided run ৩৮তম চেষ্টায় +-যুক্ত একটি input পেল যা দুটি নতুন লাইন চালায়, তাকে রেখে দিল; ১৮৮তম চেষ্টায় +88 পার হওয়া একটি input; আর ২৪০তম চেষ্টায় সেখান থেকে লেজ কেটে '+88': s খালি, s[0]-এ IndexError. ব্যবহারকারী দেশের কোড লিখে থেমে গেলেই form-টি ভেঙে পড়ত। Seed 60 বদলে দেখুন: সংখ্যাগুলো বদলাবে, কিন্তু guided সাধারণত অনেক আগে পৌঁছায়।

Guided run · seed 60 · বাজেট ২০০০
Exec
Input
চলা লাইন
Corpus
ফল
  1. Seed. দুটি বৈধ নম্বর, একটি ASCII-তে, একটি বাংলা অঙ্কে। দুটিই function-এর একই তিনটি লাইন চালায় (লাইন নম্বর function-এর ভেতরে গোনা): গুছানো, + পরীক্ষা আর শেষ return.
  2. বেশিরভাগ চেষ্টা বৃথা। ৩৭টি বদলানো input নতুন কোনো লাইন চালায়নি; guided fuzzer সেগুলো ফেলে দিল। এটাই স্বাভাবিক।
  3. প্রথম খাঁজ। '+০১৭১'-এ + আছে, তাই লাইন 4 (s = s[1:]) আর 5 (88-এর পরীক্ষা) প্রথমবার চলল। Crash নয়, উত্তর None; তবু এই input-টি সম্পদ, corpus-এ রাখা হলো।
  4. আবার অপেক্ষা। Corpus-এর তিনটি input থেকে বদল চলতে থাকে; দেড়শো চেষ্টায় নতুন কিছু নেই।
  5. দ্বিতীয় খাঁজ। Dictionary-র 88 বসে হলো '+88০-১৭১'. গুছানোর পরে +880171; লাইন 6 আর 7 প্রথমবার চলল। এখনো crash নয়, কারণ 88-এর পরে 0 আছে।
  6. Crash. এই input থেকে একটি বদল লেজটি কেটে দিল: '+88'. s খালি হয়ে গেল, আর লাইন 7-এর s[0] পড়তে গিয়ে IndexError. ২৪০টি চেষ্টা।
  7. অন্ধ run-এর সাথে তুলনা। একই ২০০০ চেষ্টা, কিন্তু corpus সবসময় দুটি seed. মাঝের ধাপগুলো মনে রাখার উপায় নেই, তাই তিনটি শর্ত একসাথে মেলাতে হয়; crash আসেনি।

বাস্তবের fuzzer-এ coverage মাপা হয় অনেক সস্তায়: compile-এর সময় কোডের প্রতিটি শাখায় একটি ছোট গণনা বসানো হয়, আর প্রতি সেকেন্ডে হাজার হাজার input চালানো যায়। Michał Zalewski-র AFL (২০১৩ সালের দিকে প্রকাশিত) এই পদ্ধতিকে জনপ্রিয় করে, আর LLVM-এর libFuzzer (২০১৫ সালের দিকে) একই ধারণা program-এর ভেতরেই চালায়; তারিখগুলো প্রকল্পের ইতিহাস অনুযায়ী, মোটামুটি। আমাদের sys.settrace অনেক ধীর, কিন্তু loop-টি হুবহু একই।

৪ · ডেস্কটপে সত্যিকারের run (১) — Python-এ fuzzing: Atheris আর Hypothesis

Python কোডের জন্য একটি পরিচিত coverage-guided fuzzer হলো Google-এর Atheris (Apache-2.0), libFuzzer-এর ওপর তৈরি। প্রথম চেষ্টা তাই সেটিই। এই কোর্সের লেখার সময়ের lab: Windows ডেস্কটপ, uv-এর একটি প্রকল্প, Python 3.12.13. Path নিরপেক্ষ করা।

$ uv pip install atheris
   Building atheris==3.0.0
  × Failed to build `atheris==3.0.0`
  ├─▶ The build backend returned an error
      error: [WinError 193] %1 is not a valid Win32 application

সৎ ফল: install হয়নি। PyPI-তে Atheris-এর সর্বশেষ version 3.1.0, কিন্তু তার জন্য শুধু Linux-এর তৈরি wheel আছে; Windows-এ uv পুরোনো 3.0.0-এর source থেকে build করতে গিয়ে ব্যর্থ, কারণ build-এর জন্য libFuzzer-সহ Clang লাগে। অর্থাৎ Atheris চালাতে হলে Linux বা WSL-এর মতো পরিবেশ লাগবে। আমরা এই পর্বে Atheris চালাইনি; নিচের কোডটি তাই শুধু উদাহরণ, কেমন দেখায় তা বোঝাতে (Atheris-এর নথির ধাঁচে):

import sys, atheris
with atheris.instrument_imports():           # measure coverage of this module
    from phone_form import to_ascii_phone

def test_one_input(data: bytes):
    fdp = atheris.FuzzedDataProvider(data)
    to_ascii_phone(fdp.ConsumeUnicodeNoSurrogates(20))   # any crash = finding

atheris.Setup(sys.argv, test_one_input)
atheris.Fuzz()           # run with e.g. -max_total_time=60 on Linux

Windows-এ আমরা অন্য পথ নিলাম: Hypothesis 6.170.15 (MPL-2.0) আর pytest 9.2.0. Hypothesis coverage-guided নয়; সে strategy থেকে input বানায়, আর ব্যর্থ হলে input ছোট করে (shrinking). Strategy, @given আর settings-এর বিস্তারিত পর্ব ৫৮-এ; এখানে আমরা একে fuzzer হিসেবে ব্যবহার করছি। Lab-এ phone_form.py-তে উপরের একই function; তিনটি test:

PHONEISH = st.text(alphabet="+0123456789০১২৩৪৫৬৭৮৯ -", max_size=16)

@settings(max_examples=500, database=None)
@given(PHONEISH)
def test_never_crashes(raw):                 # oracle 1: no unexpected exception
    to_ascii_phone(raw)

# test_output_shape: same input, oracle 2 = result is None or 11 ASCII digits

SMART = st.builds(lambda cc, sep, body: cc + sep + body,
                  st.sampled_from(["", "+88", "+880", "880", "০০৮৮০"]),
                  st.sampled_from(["", " ", "-"]),
                  st.text(alphabet="0123456789০১২৩৪৫৬৭৮৯", max_size=12))

@settings(max_examples=500, database=None)
@given(SMART)
def test_smart_never_crashes(raw):           # same oracle, structure-aware input
    out = to_ascii_phone(raw)
    assert out is None or (len(out) == 11 and out.isascii() and out.isdigit())

database=None দেওয়া হয়েছে যাতে Hypothesis আগের run-এর ব্যর্থ input মনে রেখে সরাসরি সেটি না চালায়; আমরা প্রতিবার নতুন খোঁজ মাপতে চাই। সত্যিকারের run, নির্দিষ্ট seed দিয়ে (সংক্ষেপিত):

$ uv run pytest -q test_fuzz_phone.py --hypothesis-seed=60 --hypothesis-show-statistics
..F
raw = '+88'
>               if s[0] != "0":             # BUG: nothing may follow "+88"
E               IndexError: string index out of range

test_fuzz_phone.py::test_never_crashes:
    - 500 passing, 0 failing, and 0 invalid test cases
test_fuzz_phone.py::test_output_shape:
    - 500 passing, 0 failing, and 0 invalid test cases
test_fuzz_phone.py::test_smart_never_crashes:
    - 23 passing, 1 failing, and 0 invalid test cases
1 failed, 2 passed in 0.46s

ফলটি শিক্ষণীয়। অক্ষর-ভিত্তিক “বোকা” strategy ৫০০টি করে উদাহরণে দুটি test-এই bug পায়নি। গঠন-জানা strategy, যা দেশের কোডকে একটি গোটা টুকরো হিসেবে বসায়, ২৪তম উদাহরণেই '+88' পেয়েছে। একই কথা আগের অংশে dictionary-ও বলেছিল: input-এর গঠন জানানো fuzzer-কে কয়েকশো গুণ এগিয়ে দেয়। কৌতূহলে বোকা strategy-কে ৫০০০ উদাহরণ দেওয়া হলো (একই seed): প্রায় ৩২৭০টি পাস হওয়ার পরে ব্যর্থতা, আর shrink-এর পরে input '+৮8', একটি বাংলা আর একটি ASCII আট। Hypothesis-এর explain অংশ এটাও লিখেছে: “These lines were always and only run by failing test cases: phone_form.py:10”, অর্থাৎ শুধু ব্যর্থ case-গুলোই লাইন 10-এ পৌঁছেছে।

একই fuzzer, অন্য লক্ষ্য: বাজারঘরের database-স্তর

এবার বাজারঘরের আসল কোড, কোনো বসানো bug ছাড়া। Shop.product(product_id) একটি পণ্য খোঁজে; চুক্তি হলো, পণ্য থাকলে ফেরত দেবে, না থাকলে পরিষ্কার 404-এর AppError. Oracle: এর বাইরে কোনো exception নয়। Strategy: st.integers(), অর্থাৎ যেকোনো পূর্ণসংখ্যা।

@settings(max_examples=300, database=None)
@given(product_id=st.integers())
def test_product_lookup_never_crashes(shop, product_id):
    try:
        shop.product(product_id)             # 200 or a clean 404 is fine
    except AppError as e:
        assert e.status == 404

$ uv run pytest -q test_fuzz_shop.py --hypothesis-seed=60
    def product(self, product_id: int) -> dict:
        with self.read() as conn:
>           row = conn.execute("SELECT * FROM products WHERE id = ?", (product_id,)).fetchone()
E           OverflowError: Python int too large to convert to SQLite INTEGER
E           Failing test case: test_product_lookup_never_crashes(
E               shop=<bazarghar.services.Shop object at 0x…>,
E               product_id=9_223_372_036_854_775_808,
E           )

একটি আসল bug, বসানো নয়। Python-এর পূর্ণসংখ্যার কোনো ঊর্ধ্বসীমা নেই, কিন্তু SQLite-এর INTEGER ৬৪ bit-এর signed সংখ্যা: সবচেয়ে বড় মান 263 − 1 = 9223372036854775807. Shrink-এর পরে Hypothesis যে মান দেখাল, তা ঠিক এর পরের সংখ্যা, 263. এটি পর্ব ০৮-এর একটি লুকানো partition-এর সীমা, যা কোনো requirement-এ লেখা ছিল না, ছিল database-এর ভেতরে। এই একই bug API-র দিক থেকে কেমন দেখায়, §৬-এ দেখবেন।

৫ · Crash পেলেন — তারপর? Minimise, জড়ো করা, triage

Fuzzer-এর রিপোর্ট প্রায়ই অগোছালো। পাওয়া input লম্বা, আবর্জনায় ভরা, আর একই bug শত শত বার আসে। এই অবস্থায় developer-কে পাঠালে তিনি বিরক্ত হবেন, আর ঠিক কোথায় সমস্যা বুঝতে অনেক সময় যাবে। Tester-এর চারটি কাজ:

  1. পুনরুৎপাদন: সংরক্ষিত input দিয়ে crash আবার ঘটানো, seed বা fuzzer ছাড়াই।
  2. Minimise: input-কে ছোট করা, যতক্ষণ একই crash থাকে। Andreas Zeller-এর delta debugging (২০০০ সালের আশেপাশের গবেষণা) এর ক্লাসিক পদ্ধতি; Hypothesis-এর shrinking একই লক্ষ্যের আরেকটি রূপ।
  3. জড়ো করা: প্রতিটি crash-এর একটি crash signature: exception-এর ধরন আর কোন function-এর কোন লাইনে ঘটল। একই signature-এর শত crash সাধারণত একটি bug, একটি ticket.
  4. Triage আর regression test: severity ঠিক করা (পর্ব ১৮), আর ছোট input দিয়ে একটি স্থায়ী test, যাতে bug ফিরে এলে সাথে সাথে ধরা পড়ে।

“একই crash” কথাটি জরুরি। ছোট করার সময় input হঠাৎ অন্য একটি bug-এ গিয়ে পড়তে পারে, যেমন আসল ছিল সীমার বাইরে পড়া, ছোট করতে করতে হলো শূন্য দিয়ে ভাগ। তখন minimiser একটি “ছোট” input দেবে যা আসল সমস্যার নয়। এর প্রতিকার, প্রতিটি ধাপে signature মেলানো। নিচের block একটি সরল chunk-মোছা minimiser: প্রথমে অর্ধেক অর্ধেক মুছে দেখে, তারপর ছোট টুকরো, শেষে এক অক্ষর; প্রতিবার শর্ত, signature হুবহু একই থাকতে হবে।

BN = str.maketrans("০১২৩৪৫৬৭৮৯", "0123456789")
def to_ascii_phone(raw):            # same buggy form step
    s = raw.strip().translate(BN).replace("-", "").replace(" ", "")
    if s.startswith("+"):
        s = s[1:]
        if s.startswith("88"):
            s = s[2:]
            if s[0] != "0":         # BUG: nothing may follow "+88"
                return None
    return s if len(s) == 11 and s.isdigit() else None
def signature(x):                   # which crash? (type + line), None = no crash
    try: to_ascii_phone(x)
    except Exception as e:
        tb = e.__traceback__
        while tb.tb_next: tb = tb.tb_next
        return type(e).__name__, tb.tb_lineno
    return None
def minimise(x):                    # delete chunks while the SAME crash remains
    target, size, tries = signature(x), len(x) // 2, 0
    while size >= 1:
        i, shrunk = 0, False
        while i < len(x):
            y, tries = x[:i] + x[i + size:], tries + 1
            if signature(y) == target:
                x, shrunk = y, True
                print(f"  size {size}: {x!r}")
            else:
                i += size
        if not shrunk: size //= 2
    return x, tries
crash = " + ৮ 8 - -  - "            # saved by a fuzzer: 14 characters
print("signature:", signature(crash))
small, tries = minimise(crash)
print(f"minimal {small!r} after {tries} tries, signature {signature(small)}")

আসল আউটপুট (ব্রাউজারের Python):

signature: ('IndexError', 8)
  size 7: ' + ৮ 8 '
  size 3: ' + ৮ 8'
  size 1: '+ ৮ 8'
  size 1: '+৮ 8'
  size 1: '+৮8'
minimal '+৮8' after 17 tries, signature ('IndexError', 8)

১৪ অক্ষরের input ১৭টি চেষ্টায় নেমে এলো ৩ অক্ষরে, আর signature শুরু থেকে শেষ পর্যন্ত একই: লাইন 8-এ IndexError (এই block-এর লাইন নম্বর)। ফলটি “১-minimal”: আর একটি অক্ষর মুছলেই crash থাকে না। মজার কাকতালীয় মিল: §৪-এ Hypothesis-এর shrink-ও ঠিক '+৮8'-এ থেমেছিল। দুটি পদ্ধতিই শুধু মোছে বা সরল করে, অক্ষর বদলে “সুন্দর” '+88' বানায় না; সেটি মানুষের কাজ। Bug report-এ দুটিই লিখুন: ছোটতম input আর মানুষের পড়ার মতো রূপ।

Minimiser · “·” মানে একটি ফাঁকা জায়গা
ধাপ
Input
দৈর্ঘ্য
মোট চেষ্টা
Signature
  1. শুরু। Fuzzer-এর সংরক্ষিত input: ১৪ অক্ষর, ফাঁকা আর ড্যাশে ভরা। Signature ঠিক করা হলো: IndexError, লাইন 8. এখন থেকে প্রতিটি ছোট রূপকে এই signature মেলাতে হবে।
  2. অর্ধেক মুছে দেখা। প্রথম ৭টি অক্ষর মুছলে বাকি থাকে শুধু ড্যাশ আর ফাঁকা: crash নেই। শেষ ৭টি মুছলে ·+·৮·8·: একই crash. গ্রহণ। ২টি চেষ্টা।
  3. তিন অক্ষরের টুকরো। সাত অক্ষরের মোছা আর কাজ করে না, তাই টুকরো ছোট হয়ে ৩. প্রথম দুটি টুকরো মুছলে + বা 88 হারায়; শেষের ফাঁকাটি মোছা গেল। মোট ৬টি চেষ্টা।
  4. এক অক্ষর করে। সামনের ফাঁকা মোছা গেল। strip() এমনিতেই দুই পাশের ফাঁকা বাদ দেয়, তাই signature একই।
  5. মাঝের ফাঁকা। + আর ৮-এর মাঝের ফাঁকা মোছা গেল; ফাঁকা গুছানোর ধাপে এমনিতেই বাদ পড়ত।
  6. শেষ ফাঁকা। দুটি আটের মাঝের ফাঁকাও গেল: +৮8, ৩ অক্ষর। ১৩টি চেষ্টা।
  7. আর ছোট হয় না। আরেক দফা প্রতিটি অক্ষর একবার করে মোছা হলো: ৮8, +8, +৮; কোনোটিতে crash নেই। মোট ১৭টি চেষ্টা। এই input দিয়েই regression test লেখা হবে।

Regression test-টি ছোট আর স্পষ্ট হওয়া উচিত: "+88", "+৮৮", "+৮8" আর " +88 - ", প্রতিটিতে প্রত্যাশা None, exception নয়। আর পাওয়া input-গুলো fuzzer-এর corpus-এও যোগ হয়, যাতে পরের প্রতিটি fuzzing run প্রথমেই সেগুলো চালায়; এভাবে corpus নিজেই একটি regression suite হয়ে ওঠে।

৬ · ডেস্কটপে সত্যিকারের run (২) — schemathesis দিয়ে API fuzzing

পর্ব ৩১-এ schemathesis-এর প্রথম স্বাদ পেয়েছিলেন: login ছাড়া তিনটি endpoint, প্রতিটিতে ২৫টি উদাহরণ, দুটি অমিল। এবার পুরো API, login-সহ, চারটি ধাপে (schemathesis-এর ভাষায় phase): examples (OpenAPI-তে লেখা উদাহরণ), coverage (প্রতিটি parameter-এর সীমা আর ভুল type-এর পরিকল্পিত মান), fuzzing (Hypothesis দিয়ে এলোমেলো input) আর stateful (stateful testing: OpenAPI-র link ধরে request-এর শিকল, যেমন কার্টে যোগ → অর্ডার → pay). প্রতিটি response-এ check চলে: 5xx নেই, status code নথিতে আছে, body নথির schema মানে, বৈধ request গৃহীত আর অবৈধ বাতিল।

Lab: schemathesis 4.33.4 (MIT), ভেতরে Hypothesis 6.170.15. App: বাজারঘরের নিজস্ব কপি, নিজের SQLite ফাইল, 127.0.0.1:8843, test-mode বন্ধ (তাই reset-এর endpoint নথিতেই নেই)। Schemathesis-এর এই version-এর কোডে আমরা কোনো telemetry বা বাইরে upload-এর ব্যবস্থা পাইনি; --report না দেওয়ায় কোনো রিপোর্ট ফাইলও লেখা হয়নি। মিতুর (seed-এর একজন গ্রাহক) token দিয়ে, সময়ের বাজেট ১২০ সেকেন্ড:

$ uv run st run http://127.0.0.1:8843/openapi.json \
    -H "Authorization: Bearer $TOKEN" --exclude-path-regex logout \
    --max-examples 30 --seed 60 --workers 1 --max-time 120 \
    --phases examples,coverage,fuzzing,stateful
Schemathesis v4.33.4
     Operations:       23 selected / 24 total
 ❌  Examples (in 0.10s)
     ✅  3 passed  ❌  1 failed  ⏭  19 skipped
 ❌  Coverage (in 1.55s)
     ✅  9 passed  ❌ 14 failed
 ❌  Fuzzing (in 21.74s)
     ✅  7 passed  ❌ 16 failed
 ❌  Stateful (in 96.11s)
     Scenarios:    3105
     API Links:    79 covered / 101 selected / 101 total
     ✅ 2815 passed  ❌ 290 failed
…
  ❌ ST101 Server error: 10
  ❌ ST108 Response violates schema: 7
  ❌ ST205 Allow header mismatch: 4
  ❌ ST202 Schema-valid request rejected: 8
  ❌ ST201 Schema-violating request accepted: 1
  ❌ ST103 Undocumented status code: 17
Test cases:
  16709 generated, 33 found 47 unique failures
====================== 47 failures, 1 warning in 120.03s =======================

দুই মিনিটে ১৬৭০৯টি case. সবচেয়ে গুরুতর লাইন ST101 Server error: 10: দশটি আলাদা operation-এ 500. একটির বিবরণ:

________________________ GET /api/products/{product_id} ________________________
- ST101 Server error
- ST103 Undocumented status code
    Received: 500
    Documented: 200, 404, 422
Reproduce with:
    curl -X GET -H 'Authorization: [Filtered]' http://127.0.0.1:8843/api/products/9223372036854775808

চেনা সংখ্যা: 263, §৪-এ Hypothesis যা database-স্তরে পেয়েছিল। এবার app-এর নিজের log খোলা হলো। পুরো run-এ app ১৪৩টি 500 দিয়েছে, আর প্রতিটির traceback-এর শেষ লাইন একই: OverflowError: Python int too large to convert to SQLite INTEGER. Path-এ id নেওয়া প্রতিটি endpoint (পণ্য, রিভিউ, কার্টের লাইন, অর্ডার, pay, transition) আর কার্টে যোগের body-র product_id, সবখানে একই মূল কারণ। Schemathesis-এর ভাষায় দশটি “unique failure”, signature-এর ভাষায় একটি bug. Ticket একটি, সাথে প্রভাবিত endpoint-এর তালিকা।

GET /api/products/{product_id} · শুধু coverage phase
ধাপ
Request
Status
যা শিখি
  1. নথি পড়া। OpenAPI বলছে product_id একটি integer, ব্যস। কোনো minimum বা maximum নেই। Coverage phase ঠিক এমন ফাঁকেই সীমার মান বানায়।
  2. ভুল type. ফাঁকা, AAA, null: প্রতিটিতে FastAPI-র নিজের 422. চুক্তি মানা হচ্ছে, check পাস।
  3. ভগ্নাংশ। 0.5-ও 422. এখনো সব ঠিক।
  4. সীমার বাইরে। সপ্তম request-এ 263. JSON আর Python-এর চোখে এটি বৈধ integer, তাই type-এর যাচাই পার হয়ে যায়, কিন্তু উত্তর 500, যা নথিতে নেই আর server error.
  5. Log. App-এর stderr-এ পুরো traceback: services.py-এর লাইন 97-এ SQLite-এর query, OverflowError. আমাদের কপিতে এটি দেখা যায়, কারণ log আমাদের; আসল system-এ log-এর প্রবেশাধিকার আগে ঠিক করে নিতে হয়।
  6. পুনরুৎপাদন। শুধু coverage phase, শুধু এই endpoint: ১৪টি case, ০.০৭ সেকেন্ড, একটি ব্যর্থতা। Schemathesis নিজেই curl command দিয়েছে; seed বা tool ছাড়াই যে কেউ bug দেখতে পারেন।
  7. ঠিক করার পরে। কপিতে path-এর id-তে সীমা বসানো হলো (Path(ge=1, le=2**63 - 1)), একই URL এখন পরিষ্কার 422. পুরো দুই মিনিটের run আবার: ST101 শূন্য, app-এর log-এ একটিও 500 নেই।

Fix-টি ছোট: lab-এর কপিতে api.py-তে একটি type, DbId = Annotated[int, Path(ge=1, le=2**63 - 1)], আর প্রতিটি path-এর id-তে সেটি; কার্টে যোগের body-তেও একই সীমা। এর সাথে pytest-এ একটি regression test, FastAPI-র TestClient দিয়ে, server চালু না করেই: চারটি বিশাল id-তে 422, আর সবচেয়ে বড় বৈধ id 9223372036854775807-এ পরিষ্কার 404. সত্যিকারের run: আসল কোডে 4 failed, 1 passed, fix-এর পরে 5 passed in 1.43s. মনে রাখুন, fix API-র দরজায়; Shop.product()-কে কেউ সরাসরি বিশাল সংখ্যা দিলে এখনো ভাঙবে, তাই §৪-এর Hypothesis test এখনো লাল। দরজায় যাচাই, নাকি ভেতরেও পাহারা, সেটি দলের নকশার সিদ্ধান্ত।

বাকি ব্যর্থতাগুলো পড়া

  • ST108, schema-র অমিল: পর্ব ৩১-এর চেনা অমিল আবার: plus=null-এ FastAPI-র তালিকা-আকারের 422, অথচ নথি বলে {"detail": {code, message}}. Stateful phase উল্টো দিকটিও দেখাল: POST /api/orders-এ ভুল ফোন নম্বরে app দেয় ব্যবসার 422 (invalid_phone), অথচ এই endpoint-এর নথিতে 422 মানে FastAPI-র তালিকা। একই app-এ দুই রকম 422, আর কোন endpoint-এ কোনটি, নথি জানে না।
  • ST103, নথিতে নেই এমন status: ভাঙা byte-এর body-তে 400 (“There was an error parsing the body”); নথিতে 400 নেই।
  • ST202, বৈধ request বাতিল: নথির schema অতিরিক্ত field-এর অনুমতি দেয়, আর schemathesis অদ্ভুত নামের field জুড়ে দেয়; app বাতিল করে অন্য কারণে (খালি রিভিউ, ভুল ফোন, অচেনা জেলা)। এগুলো বেশিরভাগ নথির ঢিলেঢালা ভাবের ফল; tester-এর কাজ বাছাই করা, কোনটি নথি ঠিক করবে আর কোনটি কোড।
  • ST205, Allow header-এর অমিল: OPTIONS request-এ 405-এর সাথে Allow header-এর তালিকা নথির সাথে মেলে না। কম ঝুঁকির finding.

প্রথম run-টি ভুল ছিল, আর tool-ই তা বলেছিল। প্রথম চেষ্টায় logout বাদ দেওয়ার filter ছিল --exclude-path /api/auth/logout. Windows-এর Git Bash নিজে থেকে /api/…-কে একটি Windows ফোল্ডারের path বানিয়ে দিয়েছিল, filter কিছুই মেলেনি, আর schemathesis শেষে সতর্ক করেছিল: “Unmatched filters: 1 filter matched no API operations”. Fuzzer logout ৫৫ বার চালায়, প্রথমবারেই মিতুর session শেষ, আর app-এর log-এ ১৪০৪৪টি 401: বেশিরভাগ request login-এর দরজাতেই ফিরে গেছে। ঠিক পর্ব ৫৩-এর শিক্ষা: authenticated run সত্যিই ভেতরে গেল কি না, log-এ 401 গুনে প্রমাণ করুন, আর tool-এর সতর্কবার্তা পড়ুন। Regex-এর filter দিয়ে দ্বিতীয় run-এ logout একবারও চলেনি, 401 নেমে এলো ৪৬-এ।

৭ · Oracle, sanitizer, corpus আর CI-তে fuzzing

Oracle-ই সীমা। পর্ব ৩১-এ schemathesis coupon_ge-এর ভুল ধরেনি, কারণ ১০০০ টাকায় ১০০ টাকা ছাড়ের উত্তরের গঠন নিখুঁত। Fuzzer শুধু সেটাই দেখে যা oracle বলে। Crash আর 5xx-এর বাইরে যেতে হলে oracle-কে ব্যবসার জ্ঞান দিতে হয়: invariant (“ছাড় ≤ ৩০০ আর ≤ পণ্যের দামের ১০%”), differential (§২-এর মতো দুই implementation মিলিয়ে দেখা), বা পর্ব ৫৮-এর property. Schemathesis-এও নিজের check যোগ করা যায়; তখন ১৭ হাজার case-এর প্রতিটি ব্যবসার নিয়মও যাচাই করে।

Sanitizer: নীরব ভুলকে শব্দ দেওয়া। Python-এ সীমার বাইরে পড়া সাথে সাথে IndexError. C বা C++-এ একই ভুল প্রায়ই নীরবে পাশের memory পড়ে, কোনো crash ছাড়াই; fuzzer তখন কিছুই টের পায় না। AddressSanitizer-এর মতো compiler-এর পাহারা এই নীরব ভুলকে সাথে সাথে crash বানায়, তাই C/C++ fuzzing প্রায় সবসময় sanitizer-সহ চলে। বিস্তারিত সাইবার নিরাপত্তা কোর্সের পর্ব ৪৭-এ। Web API-তে এর কাছাকাছি কাজ করে server-এর log: আমাদের run-এ 500-এর আসল কারণ বলেছে stderr-এর traceback, response নয়।

Corpus যত্নে রাখুন। একটি দীর্ঘ fuzzing run-এর সবচেয়ে মূল্যবান ফল প্রায়ই crash নয়, corpus: হাজারো input যা মিলে কোডের বেশিরভাগ পথ ছোঁয়। Corpus version control বা artifact-এ রাখা হয়, মাঝে মাঝে ছাঁটা হয় (একই coverage-এর অনেক input-এর বদলে একটি), আর প্রতিটি নতুন run সেখান থেকে শুরু হয়।

CI-তে সময়ের বাজেট। Fuzzing কখনো “শেষ” হয় না; তাই CI-তে তাকে একটি সময় দেওয়া হয়। প্রচলিত ভাগ: প্রতিটি pull request-এ কয়েক মিনিটের ছোট run, শুধু বদলানো অংশের harness-এ; রাতে বা সপ্তাহে লম্বা run; আর প্রতিটি পাওয়া crash একটি ticket আর regression test. Tool-গুলোর নিজস্ব সীমা আছে: libFuzzer-এর -max_total_time, Hypothesis-এর max_examples আর deadline, schemathesis-এর --max-time আর --max-examples. CI-র stage আর gate-এর সামগ্রিক নকশা পর্ব ৬৪-এ (CI-তে test pipeline — stage, parallel, gate আর দ্রুত feedback).

একটি সূক্ষ্ম কথা: সময়ের বাজেট আর পুনরুৎপাদন একসাথে পুরোপুরি মেলে না। আমাদের দুটি run-এ seed একই (60), বাজেট একই (১২০ সেকেন্ড), কিন্তু case-এর সংখ্যা ১৬৭০৯ আর ১৬৯৪০: কম্পিউটার কখন কতটা ব্যস্ত, তার ওপর নির্ভর করে কতগুলো case বাজেটে ধরল। তাই CI-তে একটি fuzzing ব্যর্থতাকে seed দিয়ে নয়, সংরক্ষিত input দিয়ে পুনরুৎপাদন করুন (schemathesis-এর curl বা st replay, Hypothesis-এর example database, libFuzzer-এর crash ফাইল)। নইলে একটি fuzz job পর্ব ৪০-এর flaky test-এর মতো আচরণ করবে: আজ লাল, কাল সবুজ, কেউ জানে না কেন।

আরও গভীরে। বড় পরিসরে fuzzing একটি অবিরাম সেবা: Google-এর OSS-Fuzz (২০১৬ সালে শুরু বলে জানা যায়) বহু open source প্রকল্পে দিনরাত fuzzer চালায় আর পাওয়া ত্রুটি গোপনে maintainer-কে জানায়; প্রকল্পের নিজের হিসাবে এর মাধ্যমে হাজার হাজার bug ধরা পড়েছে। গবেষণায় আরও দুটি দিক সক্রিয়: Microsoft-এর SAGE-এর মতো white-box fuzzing, যা শর্তগুলো সমীকরণ হিসেবে সমাধান করে input বানায় (Godefroid ও সহকর্মীদের কাজ, ২০০৮ সালের দিকে), আর কোন fuzzer ভালো তা মাপার পদ্ধতি নিয়ে সতর্কতা: একবারের run-এর তুলনা প্রায়ই বিভ্রান্তিকর, কারণ fuzzing-এর ফল দৈবের ওপর নির্ভর করে; তাই বহুবার চালিয়ে পরিসংখ্যানগত তুলনার পরামর্শ দেওয়া হয় (Klees ও সহকর্মীদের ২০১৮ সালের একটি পরিচিত গবেষণাপত্র)।

পরীক্ষা ও ইন্টারভিউতে। বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় সাধারণত এমন প্রশ্ন আসে:

  • Fuzzing কী, আর এর oracle কী? স্বয়ংক্রিয় অপ্রত্যাশিত input; oracle সাধারণত crash, hang, 5xx বা invariant ভাঙা।
  • Mutation-based আর generation-based fuzzing-এর পার্থক্য? প্রথমটি বৈধ নমুনা বদলায়; দ্বিতীয়টি format বা grammar থেকে নতুন input বানায়।
  • Coverage-guided fuzzer কোন input রাখে? যেটি কোডের নতুন অংশ চালায়; সেখান থেকেই পরের বদল।
  • Crash minimisation কেন, আর কী সাবধানতা? ছোট input-এ কারণ বোঝা সহজ; প্রতিটি ধাপে একই crash signature রাখতে হয়।
  • Fuzzing কী ধরে না? Oracle যা জানে না: ব্যবসার নিয়মের ভুল, যেমন ভুল ছাড়, যদি invariant লেখা না থাকে।

৮ · AI-এর যুগে fuzzing

AI সহকারী harness, Hypothesis-এর strategy, grammar আর schemathesis-এর command দ্রুত লিখে দেয়। কিন্তু এখানে তার প্রচলিত ভুলগুলো বিশেষভাবে দামি: শুধু happy path-এর input দিয়ে “fuzz” করা; except Exception: pass দিয়ে সব crash গিলে ফেলা, ফলে fuzzer কখনো লাল হয় না; oracle ছাড়া harness, যা কিছুই যাচাই করে না; অস্তিত্বহীন option বানানো বা পুরোনো version-এর option দেওয়া (schemathesis-এর option version-ভেদে বদলেছে); সময় বা উদাহরণের কোনো সীমা না রাখা; উদাহরণে অন্যের বা public server-এর ঠিকানা বসানো; login-এর দরজায় আটকে থাকা run-কে সফল ভাবা; crash পেয়ে কারণ না বুঝেই try/except দিয়ে ঢেকে দেওয়ার “fix”; আর না চালিয়েই “কোনো crash পাওয়া যায়নি” দাবি।

AI-কে fuzzing-এর পরিকল্পনায় কাজে লাগান, সীমা স্পষ্ট করে:

তুমি একজন অভিজ্ঞ QA engineer, fuzzing আর Python-এর Hypothesis ও schemathesis-এ দক্ষ। আমাদের app-এর একটি কপি শুধু http://127.0.0.1:8843-এ চলে; এর বাইরে কোনো ঠিকানায় request পাঠানোর কোড বা command লিখবে না। [পরীক্ষার function বা endpoint-এর কোড, তার নিয়ম আর tool-এর version পেস্ট করুন] ১. প্রথমে oracle-এর তালিকা দাও: কোন exception বা status পরিকল্পিত (ব্যর্থতা নয়), আর কোনগুলো bug. প্রতিটি নিয়মের বাক্য থেকে অন্তত একটি invariant লেখো। ২. Seed corpus (৫টি বৈধ input) আর একটি dictionary দাও, বাংলা অঙ্ক, +880, ফাঁকা আর ড্যাশসহ। ৩. Harness বা test লেখো যেখানে কোনো exception গিলে ফেলা হবে না, আর max_examples বা max-time দিয়ে সীমা বাঁধা থাকবে। Random-এর seed নির্দিষ্ট রাখো। ৪. যে option আর function ব্যবহার করবে, তার তালিকা আলাদা দাও; আমি আমার version-এর অফিসিয়াল নথিতে মিলিয়ে নেব। নিশ্চিত না হলে "অনিশ্চিত" লেখো। ৫. তুমি কিছু চালাওনি; কোনো ফলাফল দাবি করবে না।

AI-এর লেখা fuzz test হাতে পেলে — চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।

প্র ০১Miller-এর এলোমেলো input-এর পরীক্ষা ত্রিশ বছর ধরে বারবার করা হয়েছে, আর প্রতিবারই crash পাওয়া গেছে। একজন tester এ থেকে কী শিখবেন?

১৯৯০ সালের মূল গবেষণার পরে Miller আর তাঁর ছাত্ররা একই পরীক্ষা কয়েকবার ফিরিয়ে এনেছেন: পরের দশকে আবার Unix utility, তারপর Windows-এর GUI program, তারপর macOS. যতদূর জানা যায়, ২০২০ সালের দিকে প্রকাশিত একটি পর্বে তাঁরা আজকের Linux, macOS আর FreeBSD-এর utility-তে একই সরল পদ্ধতি চালিয়ে আবার crash আর hang পেয়েছিলেন, আর লক্ষ করেছিলেন যে কিছু ভুল পুরোনো ধরনেরই, যেমন সীমা না দেখে buffer-এ লেখা বা ফাংশনের ফেরত মান যাচাই না করা। সংখ্যা আর খুঁটিনাটির জন্য মূল গবেষণাপত্রগুলো দেখুন; বড় ছবিটি স্পষ্ট: সবচেয়ে সরল fuzzing-ও বহু বছর পরে কাজের থাকে।

কেন? কারণ developer আর tester দুজনেই “যুক্তিসংগত” input নিয়ে ভাবেন। নিয়মের বই, user story আর acceptance criteria লেখা হয় স্বাভাবিক ব্যবহারকারীর জন্য; error guessing-এর তালিকাও মানুষের কল্পনার সীমায় বাঁধা। এই পর্বের দুটি bug দেখুন। '+88': একজন ব্যবহারকারী দেশের কোড লিখে থেমে গেলেন; কেউ এটিকে test case হিসেবে ভাবেনি। 263: কোনো ব্যবহারকারী এমন id টাইপ করবেন না, কিন্তু একটি ভাঙা client বা একজন কৌতূহলী আক্রমণকারী করতেই পারেন। দুটিই স্বাভাবিক চিন্তার বাইরের, আর দুটিই যন্ত্র কয়েক সেকেন্ডে পেয়েছে।

দ্বিতীয় শিক্ষা পুরোনো ভুলের পুনরাবৃত্তি নিয়ে। নতুন প্রজন্মের developer নতুন কোড লেখেন, কিন্তু input-কে বিশ্বাস করার পুরোনো অভ্যাসও সাথে আসে। তাই একবারের fuzzing যথেষ্ট নয়; এটি একটি নিয়মিত অভ্যাস হওয়া উচিত, প্রতিটি নতুন parser, form-এর ধাপ আর endpoint-এর সাথে। আর tester-এর জন্য সুখবর: শুরু করতে বড় পরিকাঠামো লাগে না। একটি Hypothesis test বা একটি সীমিত schemathesis run এক বিকেলের কাজ, আর এই পর্বে দুটিই আসল bug পেয়েছে।

মূল উপলব্ধি: মানুষের কল্পনার বাইরের input-এর জন্য যন্ত্র লাগে; সরল fuzzing-ও দশকের পর দশক bug পায়, কারণ input-কে অন্ধ বিশ্বাস করার ভুল কখনো পুরোপুরি যায় না।

প্র ০২বিশাল id-তে 500 — কোনো সাধারণ ব্যবহারকারী তো এমন id পাঠাবেন না। এটি কি সত্যিই ঠিক করার মতো bug?

প্রশ্নটি triage-এর একটি বাস্তব বিতর্ক, আর উত্তর “নির্ভর করে”, তবে যুক্তিসহ। প্রথম দিক, চুক্তি। বাজারঘরের OpenAPI বলে GET /api/products/{id}-এর উত্তর 200, 404 বা 422. 500 এই তালিকায় নেই। একটি mobile app বা অন্য দলের service এই নথি পড়ে কোড লেখে; অপ্রত্যাশিত 500 পেলে সে হয়তো বারবার retry করবে, ভাববে server বন্ধ, alert বাজাবে। “Server নিজেই জানে না কী হলো” বার্তাটি client-এর জন্য সবচেয়ে কম তথ্যপূর্ণ।

দ্বিতীয় দিক, পর্যবেক্ষণ। Production-এ 500 সাধারণত error-এর হার মাপার metric-এ যায়, আর on-call দলকে ডাকতে পারে (পর্ব ৫০-এর SLO). একজন কৌতূহলী ব্যবহারকারী বা একটি bot যদি বিশাল id দিয়ে request পাঠাতে থাকে, তাহলে error-এর হার বাড়বে, অথচ আসল সমস্যা নেই; আবার আসল সমস্যার সংকেত এই শব্দে চাপা পড়তে পারে। Log-এ ১৪৩টি পুরো traceback জমা হওয়াও একটি খরচ। তৃতীয় দিক, নিরাপত্তা। Traceback যদি কখনো উত্তরে চলে যায়, ভেতরের file আর query ফাঁস হয়; বাজারঘরে যায় না, শুধু “Internal Server Error” লেখা, যা ভালো। কিন্তু একই ধরনের অযাচাইকৃত input অন্য জায়গায় আরও খারাপ কিছু ঘটাতে পারে।

অন্যদিকে, এখানে data হারায় না, কারো টাকা যায় না, কোনো নিয়মভঙ্গ নেই। তাই severity মাঝারি বা কম, priority নির্ভর করে API কারা ব্যবহার করে তার ওপর। আর fix সস্তা: এক লাইনের সীমা, সাথে একটি regression test. খরচ কম আর ঝুঁকি বাস্তব হলে সাধারণত ঠিক করে ফেলাই যুক্তিসংগত। সবচেয়ে বড় শিক্ষা অবশ্য পদ্ধতিগত: database-এর ৬৪ bit সীমা একটি লুকানো partition, যা কোনো requirement-এ ছিল না। পরের বার id, পরিমাণ বা টাকার যেকোনো ঘরে test design-এর সময় প্রশ্ন করুন: “এই সংখ্যা শেষ পর্যন্ত কোথায় জমা হয়, আর সেখানে সীমা কত?”

মূল উপলব্ধি: “কেউ এমন input পাঠাবে না” যুক্তিটি দুর্বল; 500 চুক্তি ভাঙে, পর্যবেক্ষণ নষ্ট করে, আর এখানে fix সস্তা। Severity মাঝারি হলেও শিক্ষাটি বড়: লুকানো partition-এর সীমা storage-এ থাকে।

প্র ০৩অন্ধ fuzzer ২০০০ বারে কিছু পেল না, guided পেল ২৪০ বারে, আর গঠন-জানা Hypothesis strategy পেল ২৪তম উদাহরণে। তাহলে harness আর grammar লেখায় কতটা সময় দেবেন?

এই পর্বের তিনটি সংখ্যা একই গল্প বলে। Bug-টি তিনটি শর্তের পেছনে: +, তারপর 88, তারপর কিছু না। অন্ধ চেষ্টায় তিনটি একসাথে মেলা বিরল। Coverage-এর সংকেত প্রতিটি শর্তকে আলাদা করে খোলার সুযোগ দেয়: আগে +, তারপর 88. আর strategy যদি আগেই জানে যে দেশের কোড একটি গোটা টুকরো, তাহলে অনুসন্ধানের প্রয়োজনই প্রায় থাকে না। Hypothesis-এর অক্ষর-ভিত্তিক strategy-ও শেষ পর্যন্ত পেয়েছিল, কিন্তু ৫০০০ উদাহরণ লেগেছে, প্রায় ৩২৭০তম-এ।

বাস্তবে এই পার্থক্য আরও বড়। একটি JSON parser, একটি ছবির format বা একটি query-ভাষার ক্ষেত্রে এলোমেলো byte-এর প্রায় সবই প্রথম লাইনেই বাতিল হয়; parser-এর পরের যুক্তিতে, যেখানে আসল bug থাকে, সেখানে পৌঁছায়ই না। AFL-এর জনপ্রিয়তার একটি বড় কারণ ছিল, শুধু coverage-এর সংকেতে সে অনেক জটিল format-এর ভেতরে পৌঁছাতে পারত, কোনো grammar ছাড়াই। কিন্তু পাসওয়ার্ডের মতো দীর্ঘ জাদুর মান (একটি checksum, একটি নির্দিষ্ট keyword) coverage-এর পক্ষেও কঠিন; তাই dictionary, তুলনার মান থেকে শেখার কৌশল, আর grammar.

তাহলে সিদ্ধান্তের নিয়ম কী? এক, শুরু করুন সস্তা দিয়ে: বিদ্যমান test-এর input seed হিসেবে, একটি ছোট dictionary, আর schema বা OpenAPI থাকলে তার থেকে generation, যা প্রায় বিনামূল্যে। দুই, coverage মাপুন: fuzzer কোডের কতটা ছুঁয়েছে, কোথায় আটকে আছে। আটকে থাকা জায়গাই বলে দেবে কোথায় grammar বা dictionary-তে বিনিয়োগ লাগবে। তিন, ঝুঁকি দেখুন: যে কোড বাইরের অবিশ্বস্ত input পড়ে (file upload, payment-এর callback, SMS-এর লেখা, ঠিকানা), সেখানে বেশি সময় দেওয়াই যুক্তিসংগত। Harness সাধারণত একবার লেখা হয়, তারপর বছরের পর বছর CI-তে চলে; শুরুর কয়েক ঘণ্টা তাই সস্তা বিনিয়োগ।

মূল উপলব্ধি: Input-এর গঠন সম্পর্কে fuzzer-কে যতটুকু জানাবেন, অনুসন্ধান তত দ্রুত হবে; coverage দেখে ঠিক করুন কোথায় সেই জ্ঞান সবচেয়ে বেশি দরকার।

প্র ০৪Schemathesis ১৭ হাজার case চালিয়েও coupon-এর ভুল ধরে না। তাহলে fuzzing আর ব্যবসার নিয়মের test-এর সম্পর্ক কী?

Fuzzing-এর শক্তি আর দুর্বলতা দুটোই আসে তার oracle থেকে। Crash, 5xx আর schema-র অমিল, এই প্রশ্নগুলোর উত্তর প্রতিটি input-এ সস্তায় দেওয়া যায়, কোনো ব্যবসার জ্ঞান ছাড়াই। তাই fuzzer একসাথে হাজারো input যাচাই করতে পারে। কিন্তু “১০০০ টাকায় ছাড় ০ হওয়া উচিত” এই জ্ঞান tool-এর নেই; {"discount": 100} গঠনে নিখুঁত উত্তর। পর্ব ৩১-এ ঠিক এটাই দেখা গেছে: coupon_ge চালু থাকা app-এ schemathesis-এর ফল হুবহু একই ছিল। পরীক্ষাবিদ্যায় একে test oracle problem বলা হয়: input বানানো সহজ, কিন্তু প্রতিটির সঠিক উত্তর জানা কঠিন।

সমাধান হলো দুই জগৎকে জোড়া লাগানো। নিয়মের পূর্ণ উত্তর না জানলেও নিয়মের কিছু বৈশিষ্ট্য জানা থাকে: ছাড় কখনো ৩০০-এর বেশি নয়, কখনো পণ্যের দামের ১০%-এর বেশি নয়, ১০০০ বা কম হলে ০, বেশি কিনলে ছাড় কমে না। এগুলো invariant, আর প্রতিটি fuzzer-এর input-এ যাচাই করা যায়। পর্ব ৫৮-এ এভাবেই coupon আর delivery-র property লেখা হয়েছে। Schemathesis-এও নিজস্ব check যোগ করা যায়: প্রতিটি /api/pricing/quote-এর উত্তরে discount ≤ 300 আর subtotal ≤ 1000 হলে discount = 0. তখন ১৭ হাজার case-এর fuzzer একটি ব্যবসার নিয়মেরও পাহারাদার।

আরেকটি পথ differential: একই নিয়মের দুটি স্বাধীন implementation, যেমন পুরোনো আর নতুন version, বা server আর §২-এর preview. দুটি একমত না হলে অন্তত একটি ভুল। তবু হাতে বাছা উদাহরণের জায়গা থাকে: সীমার ঠিক মানগুলো (১০০০, ১০০১, ৩০০০, ৩০১০) একটি ছোট parametrize test-এ নিশ্চিতভাবে প্রতিবার চলে, দৈবের ওপর নির্ভর করে না। ভালো test suite তিন স্তরের: নির্দিষ্ট উদাহরণ, property বা invariant, আর crash-এর জন্য বিস্তৃত fuzzing.

মূল উপলব্ধি: Fuzzer যা দেখে তা তার oracle ঠিক করে; ব্যবসার নিয়মকে invariant বা differential check হিসেবে লিখে দিলে একই fuzzer ব্যবসার ভুলও ধরে।

প্র ০৫Fuzzing দৈবের ওপর চলে, আর CI চায় নির্ভরযোগ্য ফল। দুটিকে কীভাবে মেলাবেন?

এই পর্বের দুটি schemathesis run-এ seed একই ছিল, বাজেট একই, কিন্তু case-এর সংখ্যা ১৬৭০৯ আর ১৬৯৪০. কারণ বাজেট সময়ে মাপা, আর একই সময়ে কম্পিউটার কখনো একটু বেশি, কখনো কম কাজ করে। ফলে একটি fuzz job আজ একটি bug পেতে পারে, কাল না; আর developer-রা এমন job-কে দ্রুত flaky বলে উপেক্ষা করতে শেখেন। অথচ fuzzing-এর পুরো মূল্য এই দৈবের ভেতরেই: প্রতিটি নতুন run নতুন জায়গায় খোঁজে।

প্রচলিত সমাধানে কাজ দুই ভাগে ভাগ হয়। প্রথম ভাগ নির্ধারিত: আগে পাওয়া প্রতিটি crash-input আর corpus একটি সাধারণ regression test হিসেবে চলে, প্রতিবার একই, দ্রুত, সবুজ বা লাল নিশ্চিতভাবে। এটিই pull request আটকায়। দ্বিতীয় ভাগ অনুসন্ধানী: নির্দিষ্ট বাজেটে নতুন খোঁজ, রাতে বা আলাদা job-এ। এর ব্যর্থতা সাধারণত pull request আটকায় না, বরং একটি ticket খোলে, সংরক্ষিত input-সহ; tester সেটি minimise করে প্রথম ভাগে যোগ করেন। Google-এর OSS-Fuzz আর তার ছোট CI-সংস্করণ ClusterFuzzLite মোটামুটি এই ধাঁচেই কাজ করে বলে তাদের নথিতে দেখা যায়।

দুটি নিয়ম এতে সাহায্য করে। এক, ব্যর্থতা সবসময় input দিয়ে পুনরুৎপাদন করুন, seed দিয়ে নয়: schemathesis-এর curl লাইন, Hypothesis-এর “Failing test case”, libFuzzer-এর crash ফাইল। দুই, pull request-এর অনুসন্ধানী অংশে বাজেট ছোট রাখুন আর শুধু বদলানো কোডের harness চালান, যাতে feedback দ্রুত আসে। আর একটি সামাজিক নিয়ম: fuzzer-এর পাওয়া bug-কে “fuzzer-এর খেয়াল” বলে বন্ধ করা যাবে না; ছোট input দিয়ে পুনরুৎপাদন হলে সেটি অন্য যেকোনো bug-এর মতোই বাস্তব।

মূল উপলব্ধি: দৈব অনুসন্ধানের জন্য, নিশ্চয়তা regression-এর জন্য: পাওয়া প্রতিটি crash-input নির্ধারিত test-এ রূপ নেয়, আর নতুন খোঁজ চলে আলাদা বাজেটে।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন। প্রত্যাশিত ফলগুলো বাজারঘরের lab-কপিতে সত্যিই চালিয়ে মেলানো।

  1. Spec থেকে fuzzing-এর পরিকল্পনা: GET /api/products?q=&limit=&offset=. নিয়ম: q সর্বোচ্চ ১০০ অক্ষর (বাংলা, ইংরেজি নাম বা SKU-তে খোঁজে); limit ১ থেকে ১০০, default ৫০; offset ০ বা বেশি পূর্ণসংখ্যা। ভুল মানে 422, কখনো 5xx নয়। (ক) চারটি seed, (খ) ছয়টি dictionary-টুকরো, (গ) oracle, আর (ঘ) সীমা আর অদ্ভুত মান থেকে আটটি নির্দিষ্ট case, প্রত্যাশিত status-সহ।

    (ক) Seed: q=তেল, q=oil&limit=5, q=RICE-5KG, offset=10&limit=2. (খ) Dictionary: ০, -1, 100, 101, %00, একটি emoji, বাংলা অঙ্ক ১. (গ) Oracle: কোনো 5xx নয়; 200 হলে items-এর দৈর্ঘ্য ≤ limit আর total ≥ ০; 422 হলে body-তে কারণ।

    Queryকেনপ্রত্যাশিত
    limit=0নিচের সীমার ঠিক বাইরে422
    limit=101ওপরের সীমার ঠিক বাইরে422
    offset=-1ঋণাত্মক422
    offset=1030বিশাল, §৬-এর মতো?200, items খালি
    q = ১০১টি aদৈর্ঘ্যের সীমা422
    q = ১০০টি emojiসীমার ভেতরে, অদ্ভুত অক্ষর200, ০টি ফল
    limit=1.5ভগ্নাংশ422
    offset=১বাংলা অঙ্ক422

    সবচেয়ে আকর্ষণীয় সারি offset=1030: offset-এর নথিতে কোনো ওপরের সীমা নেই, ঠিক §৬-এর id-র মতো। তবু এখানে 500 আসে না, 200 আসে, কারণ app পণ্যের তালিকা Python-এ কাটে (hits[offset:offset+limit]), SQLite-এ পাঠায় না। একই রকম দেখতে দুটি ঘর, ভিন্ন আচরণ, কারণ সংখ্যাটি শেষে কোথায় যায় তা আলাদা। তবু নথিতে একটি যুক্তিসংগত সীমা চাওয়ার মতো প্রশ্ন এটি।

  2. ব্যর্থতা পড়ুন: একটি CI job-এর log থেকে (path ছাঁটা):
    E   IndexError: string index out of range
    E   Failing test case: test_never_crashes(
    E       raw='+৮8',
    E   )
    E   Explanation:
    E       These lines were always and only run by failing test cases:
    E           ~/bazarghar-qa/phone_form.py:10
        - 3268 passing, 2 failing, and 0 invalid test cases
    (ক) ঠিক কোন input-এ ব্যর্থ? (খ) দুটি আট কেন দুই রকম? (গ) “always and only” লাইনটি debug-এ কীভাবে সাহায্য করে? (ঘ) পরের তিনটি কাজ কী?

    (ক) তিন অক্ষর: +, বাংলা ৮, ASCII 8. বাংলা অঙ্ক ASCII হয়ে +88, + আর 88 বাদ, s খালি, s[0]-এ IndexError. (খ) Hypothesis ব্যর্থ input-কে নিজের হিসাবের “সরলতম” রূপে নামায়, মানুষের চোখের হিসাবে নয়; বাংলা আর ASCII অঙ্ক দুটিই alphabet-এ ছিল, আর তার shrinking এই মিশ্র রূপে থেমেছে। ব্যর্থতার জন্য দুটিই সমান, তাই আর সরল হয়নি। এই পর্বের chunk-মোছা minimiser-ও একই রূপে থেমেছিল। (গ) Explain অংশ বলছে লাইন 10 শুধু ব্যর্থ case-গুলোতেই চলেছে: অর্থাৎ 88-এর পরের শাখা, ঠিক bug-এর জায়গা। এটি coverage-এর তথ্য দিয়ে সন্দেহের লাইন চিহ্নিত করা। (ঘ) এক, "+88", "+৮৮", "+৮8" দিয়ে একটি স্থায়ী regression test, প্রত্যাশা None. দুই, fix: s[0]-এর বদলে s[:1] বা আগে দৈর্ঘ্য দেখা। তিন, এই input fuzzer-এর corpus বা example database-এ রাখা। লক্ষ করুন, ৩২৬৮টি পাসের পরে ব্যর্থতা: ছোট বাজেটে এই bug ধরা পড়ত না।

  3. এই fuzz test-এ ভুল খুঁজুন: AI-এর লেখা, একজন CI-তে বসাতে চান।
    import random, requests
    
    def test_fuzz_orders():
        for _ in range(1_000_000):
            body = {"qty": random.randint(-10**9, 10**9),
                    "phone": random.choice(["01712345678", "01812345678"])}
            try:
                requests.post("https://staging.bazarghar.example/api/orders", json=body)
            except Exception:
                pass

    অন্তত আটটি। (১) লক্ষ্য একটি বাইরের staging ঠিকানা: অনুমতি, scope আর সময়সূচি নেই; fuzzing শুধু নিজের app-এর কপিতে, 127.0.0.1-এ। (২) কোনো oracle নেই: response দেখাই হয় না, তাই 500 এলেও test পাস। (৩) except Exception: pass: connection-এর ব্যর্থতাসহ সব গিলে ফেলে। (৪) দশ লাখ request, সময়ের সীমা নেই; CI ঘণ্টার পর ঘণ্টা আটকে থাকবে। (৫) Seed নেই, আর ব্যর্থ input কোথাও লেখা হয় না: পুনরুৎপাদন অসম্ভব। (৬) Token নেই: বাজারঘরে /api/orders login চায়, তাই সব উত্তর 401, যা §৬-এর প্রথম run-এর মতো দরজাতেই আটকে থাকা। (৭) Body নথির সাথে মেলে না: অর্ডারে qty নেই, district, address, payment_method আবশ্যিক; প্রায় সব request গঠনেই 422, ভেতরের যুক্তিতে পৌঁছায় না। (৮) ফোনের ঘরে শুধু দুটি বৈধ নম্বর: যে ঘরে আসল ঝুঁকি, সেখানে কোনো অদ্ভুত input নেই, অথচ বিশাল ঋণাত্মক qty, যা প্রথম যাচাইতেই বাদ। ভালো রূপ: schemathesis বা Hypothesis-এর strategy, নিজের কপিতে, token-সহ, --max-time আর seed দিয়ে, 5xx-এর check আর ব্যর্থ input-সহ রিপোর্ট।

  4. এই bug report ঠিক করুন:
    শিরোনাম: random id-তে server crash করে
    ধাপ: schemathesis চালান
    প্রত্যাশিত: কাজ করবে
    আসল: 500 আসে, অনেকবার (143 বার)
    Severity: Blocker

    সমস্যা: “random” আর “crash” অস্পষ্ট (server বন্ধ হয় না, একটি request 500 পায়); ধাপে tool-এর পুরো run, যা সময় নেয় আর প্রতিবার একই case বানায় না; “কাজ করবে” কোনো প্রত্যাশিত ফল নয়; ১৪৩ সংখ্যাটি বিভ্রান্তিকর, কারণ মূল কারণ একটি; প্রভাবিত endpoint-এর তালিকা, log আর version নেই; Blocker-এর পক্ষে কোনো যুক্তি নেই। ভালো রূপ:

    শিরোনাম: id ≥ 2^63 হলে পণ্য/অর্ডার/কার্টের endpoint-এ 500
              (SQLite OverflowError), নথিতে 404/422
    পরিবেশ: bazarghar 1.0.0, নিজের কপি 127.0.0.1:8843, seed data
    ধাপ: curl http://127.0.0.1:8843/api/products/9223372036854775808
    প্রত্যাশিত: 422 (সীমার বাইরে) — নথির তালিকা 200/404/422
    আসল: 500 "Internal Server Error"; log: OverflowError: Python int
          too large to convert to SQLite INTEGER (services.py:97)
    সীমা: 9223372036854775807 → 404 (ঠিক); …808 থেকে 500
    প্রভাব: path-এ id নেওয়া সব endpoint + POST /api/cart/items-এর
          product_id; schemathesis 4.33.4-এ 10টি operation, একই কারণ
    Severity: মাঝারি (data ক্ষতি নেই; চুক্তি ভাঙে, error-এর হার বাড়ায়)

    এখানে minimal reproduction একটি curl, সীমার দুই পাশের মান, আর একটি মূল কারণের অধীনে সব প্রভাবিত জায়গা। Severity-র যুক্তি ভাবনার প্রশ্ন ০২-এ।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমFuzzer একটি crash পাওয়ার পরের কাজগুলো ক্রমে সাজান (▲▼ চেপে সরান)

  1. সংরক্ষিত input দিয়ে crash আবার ঘটানো
  2. একই signature রেখে input ছোট করা
  3. একই signature-এর সব crash এক bug-এ জড়ো করা
  4. মূল কারণ খুঁজে ঠিক করা
  5. ছোট input দিয়ে regression test লেখা আর corpus-এ যোগ
  6. Fuzzer আবার চালিয়ে দেখা crash আর আসে না

একটি coverage-guided fuzzer কোন input-কে corpus-এ রেখে দেয়?

  • শুধু যে input crash ঘটায়
  • যে input সবচেয়ে লম্বা
  • যে input কোডের এমন অংশ চালায় যা আগে কোনো input চালায়নি
  • প্রতিটি input, যাতে কিছু না হারায়

একটি JSON API-র ভেতরের ব্যবসার যুক্তিতে পৌঁছাতে চান, অথচ এলোমেলো byte পাঠালে প্রায় সব request প্রথম যাচাইতেই 400 বা 422 পায়। কোন ধরনের fuzzing সবচেয়ে মানানসই?

  • আরও বেশি এলোমেলো byte, আরও লম্বা সময়
  • Schema বা grammar থেকে generation-based fuzzing
  • শুধু একটি byte-এর bit উল্টানো
  • Fuzzing বাদ দিয়ে শুধু হাতে লেখা দুটি test

একটি API fuzzing run-এ app-এর log-এ ১৪৩টি 500, দশটি আলাদা endpoint-এ। প্রতিটির traceback-এর শেষ লাইন একই: একই function, একই লাইন, OverflowError. কয়টি bug report লেখা উচিত?

  • একটি, প্রভাবিত endpoint-এর তালিকাসহ
  • দশটি, প্রতিটি endpoint-এর জন্য একটি
  • ১৪৩টি, প্রতিটি 500-এর জন্য একটি
  • কোনোটিই নয়, কারণ কেউ এত বড় id পাঠায় না

একটি API-র coupon-এর হিসাবে >-এর জায়গায় >=-এর ভুল আছে, কিন্তু উত্তরের JSON-এর গঠন ঠিক। শুধু “5xx নেই” আর “schema মানে” check দিয়ে fuzzing চালালে কী হবে, আর কী করলে ধরা পড়বে?

  • ধরা পড়বে, কারণ fuzzer হাজারো input পাঠায়
  • ধরা পড়বে, যদি coverage-guided fuzzer ব্যবহার করা হয়
  • ধরা পড়বে না; সমাধান শুধু run-এর সময় বাড়ানো
  • ধরা পড়বে না; “১০০০ বা কম হলে ছাড় ০”-এর মতো invariant check যোগ করতে হবে

একটি crash-input ছোট করার সময় minimiser প্রতিটি ধাপে exception-এর ধরন আর লাইন (signature) মেলায়। কেন?

  • Minimiser দ্রুত চলে বলে
  • যাতে ছোট input অন্য কোনো bug-এ পিছলে না যায়
  • যাতে regression test-এর নাম ঠিক হয়
  • যাতে fuzzer-এর seed বদলে না যায়

CI-তে একটি API fuzzing job চলে --seed 60 --max-time 120 দিয়ে। দুই দিনে case-এর সংখ্যা আলাদা (১৬৭০৯ আর ১৬৯৪০), আর একদিন একটি ব্যর্থতা এসেছিল। সেটি পুনরুৎপাদনের সবচেয়ে নির্ভরযোগ্য উপায় কী?

  • একই seed দিয়ে পুরো job আবার চালানো
  • Max-time দ্বিগুণ করে আবার চালানো
  • Tool-এর দেওয়া ব্যর্থ request বা সংরক্ষিত input সরাসরি চালানো
  • Job-টিকে flaky চিহ্নিত করে উপেক্ষা করা

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Fuzzing স্বয়ংক্রিয়ভাবে অপ্রত্যাশিত input পাঠায়; oracle সাধারণত crash, hang, 5xx বা invariant ভাঙা। শুধু নিজের app-এ, নিজের কম্পিউটারে, সীমিত বাজেটে।
  2. Mutation নমুনা বদলায়, generation আর grammar গঠন থেকে বানায়; coverage-guided fuzzer নতুন কোড চালানো input রেখে ধাপে ধাপে গভীরে যায়। Input-এর গঠন জানালে অনুসন্ধান বহু গুণ দ্রুত।
  3. Crash পেলে: সংরক্ষিত input দিয়ে পুনরুৎপাদন, একই signature রেখে minimise, একই signature এক bug, তারপর ছোট input দিয়ে regression test আর corpus-এ যোগ।
  4. API-তে schemathesis: examples, coverage, fuzzing আর stateful phase; বাজারঘরে 263 id-তে SQLite-এর OverflowError থেকে 500, একটি লুকানো partition-এর সীমা। Log-এ 401 গুনে প্রমাণ করুন run সত্যিই login-এর পেছনে গেছে।
  5. Fuzzer ব্যবসার নিয়ম জানে না; invariant বা differential check যোগ করুন। CI-তে নির্ধারিত regression অংশ pull request আটকায়, অনুসন্ধানী অংশ চলে আলাদা সময়ের বাজেটে।

পরের পর্বে: পর্ব ৬১ (Snapshot আর approval testing — কখন সুবিধা, কখন ফাঁদ). এখানে যন্ত্র input বানাল; সেখানে যন্ত্র output মনে রাখবে: একটি অনুমোদিত রসিদ বা JSON-এর সাথে প্রতিটি নতুন output মিলিয়ে দেখা, আর কখন সেই সুবিধা ফাঁদ হয়ে যায়।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান