diff --git a/src/crypto/crypto_cipher.cc b/src/crypto/crypto_cipher.cc
index 8cc2b1786c9..c7ff4b2c0bc 100644
--- a/src/crypto/crypto_cipher.cc
+++ b/src/crypto/crypto_cipher.cc
@@ -820,10 +820,15 @@ CipherBase::UpdateResult CipherBase::Update(
                            len);
 
   CHECK_LE(static_cast<size_t>(buf_len), (*out)->ByteLength());
-  if (buf_len == 0)
+  if (buf_len == 0) {
     *out = ArrayBuffer::NewBackingStore(env()->isolate(), 0);
-  else
-    *out = BackingStore::Reallocate(env()->isolate(), std::move(*out), buf_len);
+  } else {
+    std::unique_ptr<BackingStore> old_out = std::move(*out);
+    *out = ArrayBuffer::NewBackingStore(env()->isolate(), buf_len);
+    memcpy(static_cast<char*>((*out)->Data()),
+           static_cast<char*>(old_out->Data()),
+           buf_len);
+  }
 
   // When in CCM mode, EVP_CipherUpdate will fail if the authentication tag is
   // invalid. In that case, remember the error and throw in final().
@@ -912,8 +917,11 @@ bool CipherBase::Final(std::unique_ptr<BackingStore>* out) {
 
     CHECK_LE(static_cast<size_t>(out_len), (*out)->ByteLength());
     if (out_len > 0) {
-      *out =
-        BackingStore::Reallocate(env()->isolate(), std::move(*out), out_len);
+      std::unique_ptr<BackingStore> old_out = std::move(*out);
+      *out = ArrayBuffer::NewBackingStore(env()->isolate(), out_len);
+      memcpy(static_cast<char*>((*out)->Data()),
+             static_cast<char*>(old_out->Data()),
+             out_len);
     } else {
       *out = ArrayBuffer::NewBackingStore(env()->isolate(), 0);
     }
@@ -1015,10 +1023,15 @@ bool PublicKeyCipher::Cipher(
   }
 
   CHECK_LE(out_len, (*out)->ByteLength());
-  if (out_len > 0)
-    *out = BackingStore::Reallocate(env->isolate(), std::move(*out), out_len);
-  else
+  if (out_len > 0) {
+    std::unique_ptr<BackingStore> old_out = std::move(*out);
+    *out = ArrayBuffer::NewBackingStore(env->isolate(), out_len);
+    memcpy(static_cast<char*>((*out)->Data()),
+           static_cast<char*>(old_out->Data()),
+           out_len);
+  } else {
     *out = ArrayBuffer::NewBackingStore(env->isolate(), 0);
+  }
 
   return true;
 }
diff --git a/src/crypto/crypto_sig.cc b/src/crypto/crypto_sig.cc
index 5b1acf2677d..157cf35da68 100644
--- a/src/crypto/crypto_sig.cc
+++ b/src/crypto/crypto_sig.cc
@@ -99,10 +99,15 @@ std::unique_ptr<BackingStore> Node_SignFinal(Environment* env,
       EVP_PKEY_sign(pkctx.get(), static_cast<unsigned char*>(sig->Data()),
                     &sig_len, m, m_len)) {
     CHECK_LE(sig_len, sig->ByteLength());
-    if (sig_len == 0)
+    if (sig_len == 0) {
       sig = ArrayBuffer::NewBackingStore(env->isolate(), 0);
-    else
-      sig = BackingStore::Reallocate(env->isolate(), std::move(sig), sig_len);
+    } else {
+      std::unique_ptr<BackingStore> old_sig = std::move(sig);
+      sig = ArrayBuffer::NewBackingStore(env->isolate(), sig_len);
+      memcpy(static_cast<char*>(sig->Data()),
+             static_cast<char*>(old_sig->Data()),
+             sig_len);
+    }
     return sig;
   }
 
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index 300060f9d24..82e98193ba0 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -324,8 +324,13 @@ MaybeLocal<Object> New(Isolate* isolate,
     CHECK(actual <= length);
 
     if (LIKELY(actual > 0)) {
-      if (actual < length)
-        store = BackingStore::Reallocate(isolate, std::move(store), actual);
+      if (actual < length) {
+        std::unique_ptr<BackingStore> old_store = std::move(store);
+        store = ArrayBuffer::NewBackingStore(isolate, actual);
+        memcpy(static_cast<char*>(store->Data()),
+               static_cast<char*>(old_store->Data()),
+               actual);
+      }
       Local<ArrayBuffer> buf = ArrayBuffer::New(isolate, std::move(store));
       Local<Object> obj;
       if (UNLIKELY(!New(isolate, buf, 0, actual).ToLocal(&obj)))
diff --git a/src/node_http2.cc b/src/node_http2.cc
index 0d0faaaa752..313bd21fdd4 100644
--- a/src/node_http2.cc
+++ b/src/node_http2.cc
@@ -2025,7 +2025,11 @@ void Http2Session::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
 
   if (LIKELY(stream_buf_offset_ == 0)) {
     // Shrink to the actual amount of used data.
-    bs = BackingStore::Reallocate(env()->isolate(), std::move(bs), nread);
+    std::unique_ptr<BackingStore> old_bs = std::move(bs);
+    bs = ArrayBuffer::NewBackingStore(env()->isolate(), nread);
+    memcpy(static_cast<char*>(bs->Data()),
+           static_cast<char*>(old_bs->Data()),
+           nread);
   } else {
     // This is a very unlikely case, and should only happen if the ReadStart()
     // call in OnStreamAfterWrite() immediately provides data. If that does
diff --git a/src/stream_base.cc b/src/stream_base.cc
index 74001d5b6ce..4962641cc0e 100644
--- a/src/stream_base.cc
+++ b/src/stream_base.cc
@@ -679,9 +679,14 @@ void EmitToJSStreamListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
   }
 
   CHECK_LE(static_cast<size_t>(nread), bs->ByteLength());
-  bs = BackingStore::Reallocate(isolate, std::move(bs), nread);
-
-  stream->CallJSOnreadMethod(nread, ArrayBuffer::New(isolate, std::move(bs)));
+  std::unique_ptr<BackingStore> new_bs =
+      ArrayBuffer::NewBackingStore(isolate, nread);
+  memcpy(static_cast<char*>(new_bs->Data()),
+         static_cast<char*>(bs->Data()),
+         nread);
+
+  stream->CallJSOnreadMethod(nread,
+                             ArrayBuffer::New(isolate, std::move(new_bs)));
 }
 
 
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index d4249d7aac5..dcf29d9be78 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -766,7 +766,11 @@ void UDPWrap::OnRecv(ssize_t nread,
     bs = ArrayBuffer::NewBackingStore(isolate, 0);
   } else {
     CHECK_LE(static_cast<size_t>(nread), bs->ByteLength());
-    bs = BackingStore::Reallocate(isolate, std::move(bs), nread);
+    std::unique_ptr<BackingStore> old_bs = std::move(bs);
+    bs = ArrayBuffer::NewBackingStore(isolate, nread);
+    memcpy(static_cast<char*>(bs->Data()),
+           static_cast<char*>(old_bs->Data()),
+           nread);
   }
 
   Local<Object> address;