Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	crypto/crypto_scrypt.cc	Lines:	59	70	84.3 %
Date:	2022-05-20 04:15:46	Branches:	28	52	53.8 %


#include "crypto/crypto_scrypt.h"
#include "async_wrap-inl.h"
#include "crypto/crypto_util.h"
#include "env-inl.h"
#include "memory_tracker-inl.h"
#include "node_buffer.h"
#include "threadpoolwork-inl.h"
#include "v8.h"

namespace node {

using v8::FunctionCallbackInfo;
using v8::Int32;
using v8::Just;
using v8::Maybe;
using v8::Nothing;
using v8::Uint32;
using v8::Value;

namespace crypto {
#ifndef OPENSSL_NO_SCRYPT

ScryptConfig::ScryptConfig(ScryptConfig&& other) noexcept
  : mode(other.mode),
    pass(std::move(other.pass)),
    salt(std::move(other.salt)),
    N(other.N),
    r(other.r),
    p(other.p),
    maxmem(other.maxmem),
    length(other.length) {}

ScryptConfig& ScryptConfig::operator=(ScryptConfig&& other) noexcept {
  if (&other == this) return *this;
  this->~ScryptConfig();
  return *new (this) ScryptConfig(std::move(other));
}

void ScryptConfig::MemoryInfo(MemoryTracker* tracker) const {
  if (mode == kCryptoJobAsync) {
    tracker->TrackFieldWithSize("pass", pass.size());
    tracker->TrackFieldWithSize("salt", salt.size());
  }
}

Maybe<bool> ScryptTraits::EncodeOutput(
    Environment* env,
    const ScryptConfig& params,
    ByteSource* out,
    v8::Local<v8::Value>* result) {
  *result = out->ToArrayBuffer(env);
  return Just(!result->IsEmpty());
}

Maybe<bool> ScryptTraits::AdditionalConfig(
    CryptoJobMode mode,
    const FunctionCallbackInfo<Value>& args,
    unsigned int offset,
    ScryptConfig* params) {
  Environment* env = Environment::GetCurrent(args);

  params->mode = mode;

  ArrayBufferOrViewContents<char> pass(args[offset]);
  ArrayBufferOrViewContents<char> salt(args[offset + 1]);

  if (UNLIKELY(!pass.CheckSizeInt32())) {
    THROW_ERR_OUT_OF_RANGE(env, "pass is too large");
    return Nothing<bool>();
  }

  if (UNLIKELY(!salt.CheckSizeInt32())) {
    THROW_ERR_OUT_OF_RANGE(env, "salt is too large");
    return Nothing<bool>();
  }

  params->pass = mode == kCryptoJobAsync
      ? pass.ToCopy()
      : pass.ToByteSource();

  params->salt = mode == kCryptoJobAsync
      ? salt.ToCopy()
      : salt.ToByteSource();

  CHECK(args[offset + 2]->IsUint32());  // N
  CHECK(args[offset + 3]->IsUint32());  // r
  CHECK(args[offset + 4]->IsUint32());  // p
  CHECK(args[offset + 5]->IsNumber());  // maxmem
  CHECK(args[offset + 6]->IsInt32());  // length

  params->N = args[offset + 2].As<Uint32>()->Value();
  params->r = args[offset + 3].As<Uint32>()->Value();
  params->p = args[offset + 4].As<Uint32>()->Value();
  params->maxmem = args[offset + 5]->IntegerValue(env->context()).ToChecked();

  if (EVP_PBE_scrypt(
          nullptr,
          0,
          nullptr,
          0,
          params->N,
          params->r,
          params->p,
          params->maxmem,
          nullptr,
          0) != 1) {
    THROW_ERR_CRYPTO_INVALID_SCRYPT_PARAMS(env);
    return Nothing<bool>();
  }

  params->length = args[offset + 6].As<Int32>()->Value();
  if (params->length < 0) {
    THROW_ERR_OUT_OF_RANGE(env, "length must be <= %d", INT_MAX);
    return Nothing<bool>();
  }

  return Just(true);
}

bool ScryptTraits::DeriveBits(
    Environment* env,
    const ScryptConfig& params,
    ByteSource* out) {
  char* data = MallocOpenSSL<char>(params.length);
  ByteSource buf = ByteSource::Allocated(data, params.length);
  unsigned char* ptr = reinterpret_cast<unsigned char*>(data);

  // Both the pass and salt may be zero-length at this point

  if (!EVP_PBE_scrypt(
          params.pass.get(),
          params.pass.size(),
          params.salt.data<unsigned char>(),
          params.salt.size(),
          params.N,
          params.r,
          params.p,
          params.maxmem,
          ptr,
          params.length)) {
    return false;
  }
  *out = std::move(buf);
  return true;
}

#endif  // !OPENSSL_NO_SCRYPT

}  // namespace crypto
}  // namespace node


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#include "crypto/crypto_scrypt.h"
2			#include "async_wrap-inl.h"
3			#include "crypto/crypto_util.h"
4			#include "env-inl.h"
5			#include "memory_tracker-inl.h"
6			#include "node_buffer.h"
7			#include "threadpoolwork-inl.h"
8			#include "v8.h"
9
10			namespace node {
11
12			using v8::FunctionCallbackInfo;
13			using v8::Int32;
14			using v8::Just;
15			using v8::Maybe;
16			using v8::Nothing;
17			using v8::Uint32;
18			using v8::Value;
19
20			namespace crypto {
21			#ifndef OPENSSL_NO_SCRYPT
22
23		31	ScryptConfig::ScryptConfig(ScryptConfig&& other) noexcept
24		31	: mode(other.mode),
25		31	pass(std::move(other.pass)),
26		31	salt(std::move(other.salt)),
27		31	N(other.N),
28		31	r(other.r),
29		31	p(other.p),
30		31	maxmem(other.maxmem),
31		31	length(other.length) {}
32
33			ScryptConfig& ScryptConfig::operator=(ScryptConfig&& other) noexcept {
34			if (&other == this) return *this;
35			this->~ScryptConfig();
36			return *new (this) ScryptConfig(std::move(other));
37			}
38
39		1	void ScryptConfig::MemoryInfo(MemoryTracker* tracker) const {
40	✓✗	1	if (mode == kCryptoJobAsync) {
41		1	tracker->TrackFieldWithSize("pass", pass.size());
42		1	tracker->TrackFieldWithSize("salt", salt.size());
43			}
44		1	}
45
46		31	Maybe<bool> ScryptTraits::EncodeOutput(
47			Environment* env,
48			const ScryptConfig& params,
49			ByteSource* out,
50			v8::Local<v8::Value>* result) {
51		62	*result = out->ToArrayBuffer(env);
52		31	return Just(!result->IsEmpty());
53			}
54
55		43	Maybe<bool> ScryptTraits::AdditionalConfig(
56			CryptoJobMode mode,
57			const FunctionCallbackInfo<Value>& args,
58			unsigned int offset,
59			ScryptConfig* params) {
60		43	Environment* env = Environment::GetCurrent(args);
61
62		43	params->mode = mode;
63
64	✓✗	129	ArrayBufferOrViewContents<char> pass(args[offset]);
65	✓✗	129	ArrayBufferOrViewContents<char> salt(args[offset + 1]);
66
67	✗✓	43	if (UNLIKELY(!pass.CheckSizeInt32())) {
68			THROW_ERR_OUT_OF_RANGE(env, "pass is too large");
69			return Nothing<bool>();
70			}
71
72	✗✓	43	if (UNLIKELY(!salt.CheckSizeInt32())) {
73			THROW_ERR_OUT_OF_RANGE(env, "salt is too large");
74			return Nothing<bool>();
75			}
76
77			params->pass = mode == kCryptoJobAsync
78	✓✓	86	? pass.ToCopy()
79		43	: pass.ToByteSource();
80
81			params->salt = mode == kCryptoJobAsync
82	✓✓	86	? salt.ToCopy()
83		43	: salt.ToByteSource();
84
85	✓✗✗✓	86	CHECK(args[offset + 2]->IsUint32()); // N
86	✓✗✗✓	86	CHECK(args[offset + 3]->IsUint32()); // r
87	✓✗✗✓	86	CHECK(args[offset + 4]->IsUint32()); // p
88	✓✗✗✓	86	CHECK(args[offset + 5]->IsNumber()); // maxmem
89	✓✗✗✓	86	CHECK(args[offset + 6]->IsInt32()); // length
90
91	✓✗	129	params->N = args[offset + 2].As<Uint32>()->Value();
92	✓✗	129	params->r = args[offset + 3].As<Uint32>()->Value();
93	✓✗	129	params->p = args[offset + 4].As<Uint32>()->Value();
94	✓✗	86	params->maxmem = args[offset + 5]->IntegerValue(env->context()).ToChecked();
95
96		215	if (EVP_PBE_scrypt(
97			nullptr,
98			0,
99			nullptr,
100			0,
101		43	params->N,
102		43	params->r,
103		43	params->p,
104			params->maxmem,
105			nullptr,
106	✓✓	43	0) != 1) {
107		12	THROW_ERR_CRYPTO_INVALID_SCRYPT_PARAMS(env);
108		12	return Nothing<bool>();
109			}
110
111	✓✗	93	params->length = args[offset + 6].As<Int32>()->Value();
112	✗✓	31	if (params->length < 0) {
113			THROW_ERR_OUT_OF_RANGE(env, "length must be <= %d", INT_MAX);
114			return Nothing<bool>();
115			}
116
117		31	return Just(true);
118			}
119
120		31	bool ScryptTraits::DeriveBits(
121			Environment* env,
122			const ScryptConfig& params,
123			ByteSource* out) {
124		31	char* data = MallocOpenSSL<char>(params.length);
125		62	ByteSource buf = ByteSource::Allocated(data, params.length);
126		31	unsigned char* ptr = reinterpret_cast<unsigned char*>(data);
127
128			// Both the pass and salt may be zero-length at this point
129
130	✗✓	31	if (!EVP_PBE_scrypt(
131			params.pass.get(),
132			params.pass.size(),
133			params.salt.data<unsigned char>(),
134			params.salt.size(),
135		31	params.N,
136		31	params.r,
137		31	params.p,
138		31	params.maxmem,
139			ptr,
140		31	params.length)) {
141			return false;
142			}
143		31	*out = std::move(buf);
144		31	return true;
145			}
146
147			#endif // !OPENSSL_NO_SCRYPT
148
149			} // namespace crypto
150			} // namespace node