idx int64 | project string | commit_id string | project_url string | commit_url string | commit_message string | target int64 | func string | func_hash float64 | file_name string | file_hash float64 | cwe list | cve string | cve_desc string | nvd_url string |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
507,034 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | bool LibuvStreamWrap::IsAlive() {
return HandleWrap::IsAlive(this);
} | 318,847,312,966,091,440,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,035 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | inline void StreamListener::OnStreamAfterShutdown(ShutdownWrap* w, int status) {
CHECK_NOT_NULL(previous_listener_);
previous_listener_->OnStreamAfterShutdown(w, status);
} | 43,411,992,387,914,590,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,036 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | std::string TLSWrap::diagnostic_name() const {
std::string name = "TLSWrap ";
if (is_server())
name += "server (";
else
name += "client (";
name += std::to_string(static_cast<int64_t>(get_async_id())) + ")";
return name;
} | 147,831,330,658,509,510,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,037 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void LibuvStreamWrap::AfterUvWrite(uv_write_t* req, int status) {
LibuvWriteWrap* req_wrap = static_cast<LibuvWriteWrap*>(
LibuvWriteWrap::from_req(req));
CHECK_NOT_NULL(req_wrap);
HandleScope scope(req_wrap->env()->isolate());
Context::Scope context_scope(req_wrap->env()->context());
req_wrap->Done(sta... | 322,063,293,997,335,760,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,038 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | JSStream::JSStream(Environment* env, Local<Object> obj)
: AsyncWrap(env, obj, AsyncWrap::PROVIDER_JSSTREAM),
StreamBase(env) {
MakeWeak();
} | 28,248,645,877,297,984,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,039 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | int TLSWrap::ReadStop() {
Debug(this, "ReadStop()");
if (stream_ != nullptr)
return stream_->ReadStop();
return 0;
} | 149,123,464,346,004,550,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,040 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | int LibuvStreamWrap::DoWrite(std::unique_ptr<WriteWrap>& req_wrap,
uv_buf_t* bufs,
size_t count,
uv_stream_t* send_handle) {
LibuvWriteWrap* w = static_cast<LibuvWriteWrap*>(req_wrap.get());
int r;
if (send_handle == nullptr) {... | 202,966,899,678,784,040,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,041 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Init(const char* syscall,
const char* data,
size_t len,
enum encoding encoding) {
syscall_ = syscall;
encoding_ = encoding;
if (data != nullptr) {
CHECK(!has_data_);
buffer_.AllocateSufficientStorage(len + 1);
buffer_.SetLengthAndZeroTerminate(le... | 83,346,302,851,335,290,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,042 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | ssize_t Http2Session::OnCallbackPadding(size_t frameLen,
size_t maxPayloadLen) {
if (frameLen == 0) return 0;
Debug(this, "using callback to determine padding");
Isolate* isolate = env()->isolate();
HandleScope handle_scope(isolate);
Local<Context> context = env()->cont... | 1,697,722,012,832,225,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,043 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | Http2Stream* Http2Stream::SubmitPushPromise(nghttp2_nv* nva,
size_t len,
int32_t* ret,
int options) {
CHECK(!this->IsDestroyed());
Http2Scope h2scope(this);
Debug(this, "sending push... | 143,228,415,619,557,700,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,044 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | int Http2Stream::DoShutdown(ShutdownWrap* req_wrap) {
if (IsDestroyed())
return UV_EPIPE;
{
Http2Scope h2scope(this);
flags_ |= NGHTTP2_STREAM_FLAG_SHUT;
CHECK_NE(nghttp2_session_resume_data(**session_, id_),
NGHTTP2_ERR_NOMEM);
Debug(this, "writable side shutdown");
}
return 1... | 248,533,825,046,400,500,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,045 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Http2Session::Http2Ping::Done(bool ack, const uint8_t* payload) {
session_->statistics_.ping_rtt = uv_hrtime() - startTime_;
double duration = session_->statistics_.ping_rtt / 1e6;
Local<Value> buf = Undefined(env()->isolate());
if (payload != nullptr) {
buf = Buffer::Copy(env()->isolate(),
... | 126,527,721,855,467,640,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,046 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | int Http2Session::OnFrameSent(nghttp2_session* handle,
const nghttp2_frame* frame,
void* user_data) {
Http2Session* session = static_cast<Http2Session*>(user_data);
session->statistics_.frame_sent += 1;
return 0;
} | 265,383,611,525,990,430,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,047 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | inline void Http2Stream::IncrementAvailableOutboundLength(size_t amount) {
available_outbound_length_ += amount;
session_->IncrementCurrentSessionMemory(amount);
} | 88,691,085,002,722,860,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,048 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | TLSWrap::TLSWrap(Environment* env,
Kind kind,
StreamBase* stream,
SecureContext* sc)
: AsyncWrap(env,
env->tls_wrap_constructor_function()
->NewInstance(env->context()).ToLocalChecked(),
AsyncWrap::PROVIDER_TLSWRA... | 241,547,876,761,034,700,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,049 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Reject(Local<Value> reject) override {
finished_ = true;
HandleScope scope(env()->isolate());
InternalCallbackScope callback_scope(this);
Local<Value> value =
object()->Get(env()->context(),
env()->promise_string()).ToLocalChecked();
Local<Promise::Resolver> reso... | 121,399,162,807,510,830,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,050 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | Http2Session::Http2Settings::Http2Settings(Environment* env,
Http2Session* session,
Local<Object> obj,
uint64_t start_time)
: AsyncWrap(env, obj, PROVIDER_HTTP2SETTINGS),
session_(s... | 9,631,228,192,982,425,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,051 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | FSReqWrap(Environment* env, Local<Object> req, bool use_bigint)
: FSReqBase(env, req, AsyncWrap::PROVIDER_FSREQWRAP, use_bigint) { } | 214,239,222,748,832,000,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,052 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Http2Session::Ping(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Http2Session* session;
ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
// A PING frame may have exactly 8 bytes of payload data. If not provided,
// then the current hrtime will be used as t... | 255,229,281,907,713,740,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,053 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | Http2Priority::Http2Priority(Environment* env,
Local<Value> parent,
Local<Value> weight,
Local<Value> exclusive) {
Local<Context> context = env->context();
int32_t parent_ = parent->Int32Value(context).ToChecked();
int32_t weig... | 323,361,177,948,808,400,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,054 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Http2Session::SetNextStreamID(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Http2Session* session;
ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
int32_t id = args[0]->Int32Value(env->context()).ToChecked();
if (nghttp2_session_set_next_stream_id(**sessio... | 299,098,631,861,408,600,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,055 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Http2Session::Http2Settings::Send() {
Http2Scope h2scope(session_);
CHECK_EQ(nghttp2_submit_settings(**session_, NGHTTP2_FLAG_NONE,
&entries_[0], count_), 0);
} | 279,471,014,557,196,100,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,056 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Http2Session::Destroy(const FunctionCallbackInfo<Value>& args) {
Http2Session* session;
ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
Debug(session, "destroying session");
Environment* env = Environment::GetCurrent(args);
Local<Context> context = env->context();
uint32_t code = args[0]->Uint32Valu... | 46,087,051,810,426,370,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,057 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Http2Stream::Info(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Local<Context> context = env->context();
Isolate* isolate = env->isolate();
Http2Stream* stream;
ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
Local<Array> headers = args[0].As<Array>();
... | 114,999,169,008,093,920,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,058 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void PushPath(std::string&& path) {
paths.emplace_back(std::move(path));
} | 147,601,518,055,771,690,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,059 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Http2Stream::EmitStatistics() {
if (!HasHttp2Observer(env()))
return;
Http2StreamPerformanceEntry* entry =
new Http2StreamPerformanceEntry(env(), id_, statistics_);
env()->SetImmediate([](Environment* env, void* data) {
// This takes ownership, the entry is destroyed at the end of this scope.
... | 92,794,021,370,336,580,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,060 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | Headers::Headers(Isolate* isolate,
Local<Context> context,
Local<Array> headers) {
Local<Value> header_string = headers->Get(context, 0).ToLocalChecked();
Local<Value> header_count = headers->Get(context, 1).ToLocalChecked();
count_ = header_count.As<Uint32>()->Value();
int hea... | 304,284,099,269,141,430,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,061 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void HttpErrorString(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
uint32_t val = args[0]->Uint32Value(env->context()).ToChecked();
args.GetReturnValue().Set(
String::NewFromOneByte(
env->isolate(),
reinterpret_cast<const uint8_t*>(nghttp2_s... | 60,560,000,562,413,010,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,062 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Http2Session::Settings(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Http2Session* session;
ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
Local<Object> obj;
if (!env->http2settings_constructor_template()
->NewInstance(env->context())
... | 23,478,955,988,678,227,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,063 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void Http2Stream::RefreshState(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Http2Stream* stream;
ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
Debug(stream, "refreshing state");
AliasedBuffer<double, Float64Array>& buffer =
env->http2_state()->stream_... | 15,854,100,290,096,547,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,064 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | inline StreamBase::StreamBase(Environment* env) : env_(env) {
PushStreamListener(&default_listener_);
} | 134,522,732,072,618,520,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,065 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | bool use_bigint() const { return use_bigint_; } | 15,333,212,652,346,650,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,066 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | Origins::Origins(Isolate* isolate,
Local<Context> context,
Local<String> origin_string,
size_t origin_count) : count_(origin_count) {
int origin_string_len = origin_string->Length();
if (count_ == 0) {
CHECK_EQ(origin_string_len, 0);
return;
}
// Alloc... | 106,262,526,168,174,880,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,067 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void TLSWrap::Start(const FunctionCallbackInfo<Value>& args) {
TLSWrap* wrap;
ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
CHECK(!wrap->started_);
wrap->started_ = true;
// Send ClientHello handshake
CHECK(wrap->is_client());
// Seems odd to read when when we want to send, but SSL_read() triggers a
... | 204,040,451,336,977,760,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,068 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void MemoryInfo(MemoryTracker* tracker) const override {
tracker->TrackField("current_read", current_read_);
} | 32,548,223,476,647,517,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,069 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | int TLSWrap::DoShutdown(ShutdownWrap* req_wrap) {
Debug(this, "DoShutdown()");
crypto::MarkPopErrorOnReturn mark_pop_error_on_return;
if (ssl_ && SSL_shutdown(ssl_.get()) == 0)
SSL_shutdown(ssl_.get());
shutdown_ = true;
EncOut();
return stream_->DoShutdown(req_wrap);
} | 299,610,435,491,428,100,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,070 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | static FSReqBase* from_req(uv_fs_t* req) {
return static_cast<FSReqBase*>(ReqWrap::from_req(req));
} | 46,720,835,070,841,340,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,071 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | static CloseReq* from_req(uv_fs_t* req) {
return static_cast<CloseReq*>(ReqWrap::from_req(req));
} | 278,354,277,579,224,900,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,072 | node | 7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | https://github.com/joyent/node | https://github.com/nodejs/node/commit/7f178663ebffc82c9f8a5a1b6bf2da0c263a30ed | src: use unique_ptr for WriteWrap
This commit attempts to avoid a use-after-free error by using unqiue_ptr
and passing a reference to it.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
PR-URL: https://github.com/nodejs-private/node-private/pull/238
Reviewed-By: Michael Dawson <... | 0 | void TLSWrap::EnableCertCb(const FunctionCallbackInfo<Value>& args) {
TLSWrap* wrap;
ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
wrap->WaitForCertCb(OnClientHelloParseEnd, wrap);
} | 40,574,930,659,908,120,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,073 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | StreamReq* StreamReq::FromObject(v8::Local<v8::Object> req_wrap_obj) {
return static_cast<StreamReq*>(
req_wrap_obj->GetAlignedPointerFromInternalField(
StreamReq::kStreamReqField));
} | 269,909,661,034,100,040,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,074 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | int StreamBase::UseUserBuffer(const FunctionCallbackInfo<Value>& args) {
CHECK(Buffer::HasInstance(args[0]));
uv_buf_t buf = uv_buf_init(Buffer::Data(args[0]), Buffer::Length(args[0]));
PushStreamListener(new CustomBufferJSListener(buf));
return 0;
} | 34,577,783,065,517,700,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,075 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | uv_buf_t CustomBufferJSListener::OnStreamAlloc(size_t suggested_size) {
return buffer_;
} | 254,111,821,728,255,130,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,076 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | const char* StreamResource::Error() const {
return nullptr;
} | 4,499,637,050,608,204,700,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,077 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamBase::JSMethod(const FunctionCallbackInfo<Value>& args) {
StreamBase* wrap = StreamBase::FromObject(args.Holder().As<Object>());
if (wrap == nullptr) return;
if (!wrap->IsAlive()) return args.GetReturnValue().Set(UV_EINVAL);
AsyncHooks::DefaultTriggerAsyncIdScope trigger_scope(wrap->GetAsyncWrap())... | 234,343,699,873,563,080,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,078 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamResource::ClearError() {
// No-op
} | 91,778,723,908,197,180,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,079 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamBase::SetWriteResult(const StreamWriteResult& res) {
env_->stream_base_state()[kBytesWritten] = res.bytes;
env_->stream_base_state()[kLastWriteWasAsync] = res.async;
} | 326,385,021,066,997,100,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,080 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | int StreamBase::ReadStartJS(const FunctionCallbackInfo<Value>& args) {
return ReadStart();
} | 180,109,657,528,466,030,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,081 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamBase::GetBytesRead(const FunctionCallbackInfo<Value>& args) {
StreamBase* wrap = StreamBase::FromObject(args.This().As<Object>());
if (wrap == nullptr) return args.GetReturnValue().Set(0);
// uint64_t -> double. 53bits is enough for all real cases.
args.GetReturnValue().Set(static_cast<double>(wrap-... | 151,622,075,473,399,230,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,082 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamListener::OnStreamAfterShutdown(ShutdownWrap* w, int status) {
CHECK_NOT_NULL(previous_listener_);
previous_listener_->OnStreamAfterShutdown(w, status);
} | 145,402,328,710,298,850,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,083 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamResource::PushStreamListener(StreamListener* listener) {
CHECK_NOT_NULL(listener);
CHECK_NULL(listener->stream_);
listener->previous_listener_ = listener_;
listener->stream_ = this;
listener_ = listener;
} | 90,215,306,102,137,740,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,084 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | StreamListener::~StreamListener() {
if (stream_ != nullptr)
stream_->RemoveStreamListener(this);
} | 258,160,682,253,863,700,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,085 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | StreamReq::StreamReq(
StreamBase* stream,
v8::Local<v8::Object> req_wrap_obj) : stream_(stream) {
AttachToObject(req_wrap_obj);
} | 105,744,626,473,348,000,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,086 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | uv_buf_t EmitToJSStreamListener::OnStreamAlloc(size_t suggested_size) {
CHECK_NOT_NULL(stream_);
Environment* env = static_cast<StreamBase*>(stream_)->stream_env();
return AllocatedBuffer::AllocateManaged(env, suggested_size).release();
} | 267,279,971,918,231,800,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,087 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | int StreamBase::WriteString(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(args[0]->IsObject());
CHECK(args[1]->IsString());
Local<Object> req_wrap_obj = args[0].As<Object>();
Local<String> string = args[1].As<String>();
Local<Object> send_handle_obj;
i... | 285,979,145,709,500,770,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,088 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void ReportWritesToJSStreamListener::OnStreamAfterShutdown(
ShutdownWrap* req_wrap, int status) {
OnStreamAfterReqFinished(req_wrap, status);
} | 85,133,796,156,639,350,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,089 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | StreamBase* StreamBase::FromObject(v8::Local<v8::Object> obj) {
if (obj->GetAlignedPointerFromInternalField(StreamBase::kSlot) == nullptr)
return nullptr;
return static_cast<StreamBase*>(
obj->GetAlignedPointerFromInternalField(
StreamBase::kStreamBaseField));
} | 42,165,245,216,375,074,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,090 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | ShutdownWrap* StreamBase::CreateShutdownWrap(
Local<Object> object) {
auto* wrap = new SimpleShutdownWrap<AsyncWrap>(this, object);
wrap->MakeWeak();
return wrap;
} | 200,034,100,942,019,000,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,091 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamResource::EmitWantsWrite(size_t suggested_size) {
DebugSealHandleScope seal_handle_scope;
listener_->OnStreamWantsWrite(suggested_size);
} | 67,347,722,684,978,430,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,092 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamReq::AttachToObject(v8::Local<v8::Object> req_wrap_obj) {
CHECK_EQ(req_wrap_obj->GetAlignedPointerFromInternalField(
StreamReq::kStreamReqField),
nullptr);
req_wrap_obj->SetAlignedPointerInInternalField(
StreamReq::kStreamReqField, this);
} | 299,788,975,409,531,420,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,093 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamBase::AttachToObject(v8::Local<v8::Object> obj) {
obj->SetAlignedPointerInInternalField(
StreamBase::kStreamBaseField, this);
} | 148,282,500,591,498,960,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,094 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | uv_buf_t StreamResource::EmitAlloc(size_t suggested_size) {
DebugSealHandleScope seal_handle_scope;
return listener_->OnStreamAlloc(suggested_size);
} | 202,422,562,034,176,140,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,095 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | ShutdownWrap* ShutdownWrap::FromObject(
const BaseObjectPtrImpl<T, kIsWeak>& base_obj) {
if (!base_obj) return nullptr;
return FromObject(base_obj->object());
} | 97,047,278,180,944,860,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,096 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamListener::PassReadErrorToPreviousListener(ssize_t nread) {
CHECK_NOT_NULL(previous_listener_);
previous_listener_->OnStreamRead(nread, uv_buf_init(nullptr, 0));
} | 108,162,911,727,777,930,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,097 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | int StreamBase::Writev(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(args[0]->IsObject());
CHECK(args[1]->IsArray());
Local<Object> req_wrap_obj = args[0].As<Object>();
Local<Array> chunks = args[1].As<Array>();
bool all_buffers = args[2]->IsTrue();
... | 339,771,026,919,251,850,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,098 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void WriteWrap::OnDone(int status) {
stream()->EmitAfterWrite(this, status);
Dispose();
} | 137,427,472,922,805,140,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,099 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | StreamBase::StreamBase(Environment* env) : env_(env) {
PushStreamListener(&default_listener_);
} | 58,684,284,737,146,690,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,100 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void EmitToJSStreamListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
CHECK_NOT_NULL(stream_);
StreamBase* stream = static_cast<StreamBase*>(stream_);
Environment* env = stream->stream_env();
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
AllocatedBuffer b... | 335,725,104,694,155,250,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,101 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | int StreamBase::Shutdown(const FunctionCallbackInfo<Value>& args) {
CHECK(args[0]->IsObject());
Local<Object> req_wrap_obj = args[0].As<Object>();
return Shutdown(req_wrap_obj);
} | 184,915,854,072,172,400,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,102 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | bool StreamBase::IsIPCPipe() {
return false;
} | 176,311,396,306,425,300,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,103 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | int StreamBase::Shutdown(v8::Local<v8::Object> req_wrap_obj) {
Environment* env = stream_env();
v8::HandleScope handle_scope(env->isolate());
if (req_wrap_obj.IsEmpty()) {
if (!env->shutdown_wrap_template()
->NewInstance(env->context())
.ToLocal(&req_wrap_obj)) {
return UV_EB... | 188,288,526,722,360,200,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,104 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamBase::AddMethod(Environment* env,
Local<Signature> signature,
enum PropertyAttribute attributes,
Local<FunctionTemplate> t,
JSMethodFunction* stream_method,
Local<String> str... | 268,311,735,852,658,130,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,105 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamResource::EmitRead(ssize_t nread, const uv_buf_t& buf) {
DebugSealHandleScope seal_handle_scope;
if (nread > 0)
bytes_read_ += static_cast<uint64_t>(nread);
listener_->OnStreamRead(nread, buf);
} | 17,702,019,209,678,800,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,106 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamBase::GetBytesWritten(const FunctionCallbackInfo<Value>& args) {
StreamBase* wrap = StreamBase::FromObject(args.This().As<Object>());
if (wrap == nullptr) return args.GetReturnValue().Set(0);
// uint64_t -> double. 53bits is enough for all real cases.
args.GetReturnValue().Set(static_cast<double>(wr... | 79,083,656,179,266,630,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,107 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | StreamResource::~StreamResource() {
while (listener_ != nullptr) {
StreamListener* listener = listener_;
listener->OnStreamDestroy();
// Remove the listener if it didn’t remove itself. This makes the logic
// in `OnStreamDestroy()` implementations easier, because they
// may call generic cleanup f... | 18,351,254,020,135,875,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,108 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamBase::GetExternal(const FunctionCallbackInfo<Value>& args) {
StreamBase* wrap = StreamBase::FromObject(args.This().As<Object>());
if (wrap == nullptr) return;
Local<External> ext = External::New(args.GetIsolate(), wrap);
args.GetReturnValue().Set(ext);
} | 134,081,385,449,892,060,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,109 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | WriteWrap* WriteWrap::FromObject(v8::Local<v8::Object> req_wrap_obj) {
return static_cast<WriteWrap*>(StreamReq::FromObject(req_wrap_obj));
} | 334,678,430,043,126,580,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,110 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamReq::ResetObject(v8::Local<v8::Object> obj) {
DCHECK_GT(obj->InternalFieldCount(), StreamReq::kStreamReqField);
obj->SetAlignedPointerInInternalField(StreamReq::kSlot, nullptr);
obj->SetAlignedPointerInInternalField(StreamReq::kStreamReqField, nullptr);
} | 226,450,319,703,287,200,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,111 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamResource::EmitAfterWrite(WriteWrap* w, int status) {
DebugSealHandleScope seal_handle_scope;
listener_->OnStreamAfterWrite(w, status);
} | 142,892,452,321,327,900,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,112 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamResource::EmitAfterShutdown(ShutdownWrap* w, int status) {
DebugSealHandleScope seal_handle_scope;
listener_->OnStreamAfterShutdown(w, status);
} | 39,203,124,063,481,965,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,113 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamBase::AddMethods(Environment* env, Local<FunctionTemplate> t) {
HandleScope scope(env->isolate());
enum PropertyAttribute attributes =
static_cast<PropertyAttribute>(ReadOnly | DontDelete | DontEnum);
Local<Signature> sig = Signature::New(env->isolate(), t);
AddMethod(env, sig, attributes, t,... | 202,625,706,738,371,460,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,114 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void ShutdownWrap::OnDone(int status) {
stream()->EmitAfterShutdown(this, status);
Dispose();
} | 226,657,710,536,725,160,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,115 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | int StreamBase::ReadStopJS(const FunctionCallbackInfo<Value>& args) {
return ReadStop();
} | 275,050,211,178,053,000,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,116 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamReq::Dispose() {
BaseObjectPtr<AsyncWrap> destroy_me{GetAsyncWrap()};
object()->SetAlignedPointerInInternalField(
StreamReq::kStreamReqField, nullptr);
destroy_me->Detach();
} | 314,642,519,140,661,700,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,117 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void WriteWrap::SetAllocatedStorage(AllocatedBuffer&& storage) {
CHECK_NULL(storage_.data());
storage_ = std::move(storage);
} | 265,961,516,362,543,820,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,118 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamReq::Done(int status, const char* error_str) {
AsyncWrap* async_wrap = GetAsyncWrap();
Environment* env = async_wrap->env();
if (error_str != nullptr) {
async_wrap->object()->Set(env->context(),
env->error_string(),
OneByteString(env->isol... | 200,143,126,565,213,370,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,119 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | int StreamResource::DoTryWrite(uv_buf_t** bufs, size_t* count) {
// No TryWrite by default
return 0;
} | 142,195,102,060,477,100,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,120 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | StreamWriteResult StreamBase::Write(
uv_buf_t* bufs,
size_t count,
uv_stream_t* send_handle,
v8::Local<v8::Object> req_wrap_obj) {
Environment* env = stream_env();
int err;
size_t total_bytes = 0;
for (size_t i = 0; i < count; ++i)
total_bytes += bufs[i].len;
bytes_written_ += total_bytes... | 69,224,095,910,162,280,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,121 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | int StreamBase::WriteBuffer(const FunctionCallbackInfo<Value>& args) {
CHECK(args[0]->IsObject());
Environment* env = Environment::GetCurrent(args);
if (!args[1]->IsUint8Array()) {
node::THROW_ERR_INVALID_ARG_TYPE(env, "Second argument must be a buffer");
return 0;
}
Local<Object> req_wrap_obj = ar... | 6,579,752,081,841,351,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,122 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | int StreamBase::GetFD() {
return -1;
} | 31,692,786,025,255,494,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,123 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void ReportWritesToJSStreamListener::OnStreamAfterReqFinished(
StreamReq* req_wrap, int status) {
StreamBase* stream = static_cast<StreamBase*>(stream_);
Environment* env = stream->stream_env();
AsyncWrap* async_wrap = req_wrap->GetAsyncWrap();
HandleScope handle_scope(env->isolate());
Context::Scope cont... | 336,627,275,061,613,250,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,124 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | MaybeLocal<Value> StreamBase::CallJSOnreadMethod(ssize_t nread,
Local<ArrayBuffer> ab,
size_t offset,
StreamBaseJSChecks checks) {
Environment* env = env_;
DCHECK_EQ(st... | 227,436,148,941,294,240,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,125 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamResource::RemoveStreamListener(StreamListener* listener) {
CHECK_NOT_NULL(listener);
StreamListener* previous;
StreamListener* current;
// Remove from the linked list.
for (current = listener_, previous = nullptr;
/* No loop condition because we want a crash if listener is not found */
... | 293,248,477,308,716,880,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,126 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void StreamBase::GetFD(const FunctionCallbackInfo<Value>& args) {
// Mimic implementation of StreamBase::GetFD() and UDPWrap::GetFD().
StreamBase* wrap = StreamBase::FromObject(args.This().As<Object>());
if (wrap == nullptr) return args.GetReturnValue().Set(UV_EINVAL);
if (!wrap->IsAlive()) return args.GetRetu... | 147,944,627,463,370,020,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,127 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | void CustomBufferJSListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
CHECK_NOT_NULL(stream_);
StreamBase* stream = static_cast<StreamBase*>(stream_);
Environment* env = stream->stream_env();
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
// To deal with ... | 65,320,018,919,168,710,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,128 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | ShutdownWrap* ShutdownWrap::FromObject(v8::Local<v8::Object> req_wrap_obj) {
return static_cast<ShutdownWrap*>(StreamReq::FromObject(req_wrap_obj));
} | 23,254,456,580,207,504,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,129 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | WriteWrap* StreamBase::CreateWriteWrap(
Local<Object> object) {
auto* wrap = new SimpleWriteWrap<AsyncWrap>(this, object);
wrap->MakeWeak();
return wrap;
} | 176,695,254,744,320,060,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,130 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | WriteWrap::WriteWrap(
StreamBase* stream,
v8::Local<v8::Object> req_wrap_obj)
: StreamReq(stream, req_wrap_obj) { } | 212,919,430,393,646,350,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,131 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | v8::Local<v8::Object> StreamReq::object() {
return GetAsyncWrap()->object();
} | 337,120,541,137,345,020,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,132 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | Local<Object> StreamBase::GetObject() {
return GetAsyncWrap()->object();
} | 17,398,268,010,663,277,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
507,133 | node | 4f8772f9b731118628256189b73cd202149bbd97 | https://github.com/joyent/node | https://github.com/nodejs/node/commit/4f8772f9b731118628256189b73cd202149bbd97 | src: retain pointers to WriteWrap/ShutdownWrap
Avoids potential use-after-free when wrap req's are synchronously
destroyed.
CVE-ID: CVE-2020-8265
Fixes: https://github.com/nodejs-private/node-private/issues/227
Refs: https://hackerone.com/bugs?subject=nodejs&report_id=988103
PR-URL: https://github.com/nodejs-private/... | 0 | ShutdownWrap::ShutdownWrap(
StreamBase* stream,
v8::Local<v8::Object> req_wrap_obj)
: StreamReq(stream, req_wrap_obj) { } | 129,163,593,805,252,830,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2020-8265 | Node.js versions before 10.23.1, 12.20.1, 14.15.4, 15.5.1 are vulnerable to a use-after-free bug in its TLS implementation. When writing to a TLS enabled socket, node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly allocated WriteWrap object as first argument. If the DoWrite method does not return an err... | https://nvd.nist.gov/vuln/detail/CVE-2020-8265 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.