Head

GCC Code Coverage Report

Directory:	../		Exec	Total	Coverage
File:	/home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/crypto/crypto_keygen.h	Lines:	60	86	69.8 %
Date:	2020-11-21 04:10:54	Branches:	29	68	42.6 %


#ifndef SRC_CRYPTO_CRYPTO_KEYGEN_H_
#define SRC_CRYPTO_CRYPTO_KEYGEN_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "crypto/crypto_keys.h"
#include "crypto/crypto_util.h"
#include "allocated_buffer.h"
#include "async_wrap.h"
#include "base_object.h"
#include "env.h"
#include "memory_tracker.h"
#include "v8.h"

namespace node {
namespace crypto {
namespace Keygen {
void Initialize(Environment* env, v8::Local<v8::Object> target);
}  // namespace Keygen

enum class KeyGenJobStatus {
  OK,
  FAILED
};

// A Base CryptoJob for generating secret keys or key pairs.
// The KeyGenTraits is largely responsible for the details of
// the implementation, while KeyGenJob handles the common
// mechanisms.
template <typename KeyGenTraits>
class KeyGenJob final : public CryptoJob<KeyGenTraits> {
 public:
  using AdditionalParams = typename KeyGenTraits::AdditionalParameters;

  static void New(const v8::FunctionCallbackInfo<v8::Value>& args) {
    Environment* env = Environment::GetCurrent(args);
    CHECK(args.IsConstructCall());

    CryptoJobMode mode = GetCryptoJobMode(args[0]);

    unsigned int offset = 1;

    AdditionalParams params;
    if (KeyGenTraits::AdditionalConfig(mode, args, &offset, &params)
            .IsNothing()) {
      // The KeyGenTraits::AdditionalConfig is responsible for
      // calling an appropriate THROW_CRYPTO_* variant reporting
      // whatever error caused initialization to fail.
      return;
    }

    new KeyGenJob<KeyGenTraits>(env, args.This(), mode, std::move(params));
  }

  static void Initialize(
      Environment* env,
      v8::Local<v8::Object> target) {
    CryptoJob<KeyGenTraits>::Initialize(New, env, target);
  }

  KeyGenJob(
      Environment* env,
      v8::Local<v8::Object> object,
      CryptoJobMode mode,
      AdditionalParams&& params)
      : CryptoJob<KeyGenTraits>(
            env,
            object,
            KeyGenTraits::Provider,
            mode,
            std::move(params)) {}

  void DoThreadPoolWork() override {
    // Make sure the the CSPRNG is properly seeded so the results are secure
    CheckEntropy();

    AdditionalParams* params = CryptoJob<KeyGenTraits>::params();

    switch (KeyGenTraits::DoKeyGen(AsyncWrap::env(), params)) {
      case KeyGenJobStatus::OK:
        status_ = KeyGenJobStatus::OK;
        // Success!
        break;
      case KeyGenJobStatus::FAILED: {
        CryptoErrorVector* errors = CryptoJob<KeyGenTraits>::errors();
        errors->Capture();
        if (errors->empty())
          errors->push_back(std::string("Key generation job failed"));
      }
    }
  }

  v8::Maybe<bool> ToResult(
      v8::Local<v8::Value>* err,
      v8::Local<v8::Value>* result) override {
    Environment* env = AsyncWrap::env();
    CryptoErrorVector* errors = CryptoJob<KeyGenTraits>::errors();
    AdditionalParams* params = CryptoJob<KeyGenTraits>::params();
    if (status_ == KeyGenJobStatus::OK &&
        LIKELY(!KeyGenTraits::EncodeKey(env, params, result).IsNothing())) {
      *err = Undefined(env->isolate());
      return v8::Just(true);
    }

    if (errors->empty())
      errors->Capture();
    CHECK(!errors->empty());
    *result = Undefined(env->isolate());
    return v8::Just(errors->ToException(env).ToLocal(err));
  }

  SET_SELF_SIZE(KeyGenJob);

 private:
  KeyGenJobStatus status_ = KeyGenJobStatus::FAILED;
};

// A Base KeyGenTraits for Key Pair generation algorithms.
template <typename KeyPairAlgorithmTraits>
struct KeyPairGenTraits final {
  using AdditionalParameters =
      typename KeyPairAlgorithmTraits::AdditionalParameters;

  static const AsyncWrap::ProviderType Provider =
      AsyncWrap::PROVIDER_KEYPAIRGENREQUEST;
  static constexpr const char* JobName = KeyPairAlgorithmTraits::JobName;

  static v8::Maybe<bool> AdditionalConfig(
      CryptoJobMode mode,
      const v8::FunctionCallbackInfo<v8::Value>& args,
      unsigned int* offset,
      AdditionalParameters* params) {
    // Notice that offset is a pointer. Each of the AdditionalConfig,
    // GetPublicKeyEncodingFromJs, and GetPrivateKeyEncodingFromJs
    // functions will update the value of the offset as they successfully
    // process input parameters. This allows each job to have a variable
    // number of input parameters specific to each job type.
    if (KeyPairAlgorithmTraits::AdditionalConfig(mode, args, offset, params)
            .IsNothing()) {
      return v8::Just(false);
    }

    params->public_key_encoding = ManagedEVPPKey::GetPublicKeyEncodingFromJs(
        args,
        offset,
        kKeyContextGenerate);

    auto private_key_encoding =
        ManagedEVPPKey::GetPrivateKeyEncodingFromJs(
            args,
            offset,
            kKeyContextGenerate);

    if (!private_key_encoding.IsEmpty())
      params->private_key_encoding = private_key_encoding.Release();

    return v8::Just(true);
  }

  static KeyGenJobStatus DoKeyGen(
      Environment* env,
      AdditionalParameters* params) {
    EVPKeyCtxPointer ctx = KeyPairAlgorithmTraits::Setup(params);
    if (!ctx || EVP_PKEY_keygen_init(ctx.get()) <= 0)
      return KeyGenJobStatus::FAILED;

    // Generate the key
    EVP_PKEY* pkey = nullptr;
    if (!EVP_PKEY_keygen(ctx.get(), &pkey))
      return KeyGenJobStatus::FAILED;

    params->key = ManagedEVPPKey(EVPKeyPointer(pkey));
    return KeyGenJobStatus::OK;
  }

  static v8::Maybe<bool> EncodeKey(
      Environment* env,
      AdditionalParameters* params,
      v8::Local<v8::Value>* result) {
    v8::Local<v8::Value> keys[2];
    if (ManagedEVPPKey::ToEncodedPublicKey(
            env,
            std::move(params->key),
            params->public_key_encoding,
            &keys[0]).IsNothing() ||
        ManagedEVPPKey::ToEncodedPrivateKey(
            env,
            std::move(params->key),
            params->private_key_encoding,
            &keys[1]).IsNothing()) {
      return v8::Nothing<bool>();
    }
    *result = v8::Array::New(env->isolate(), keys, arraysize(keys));
    return v8::Just(true);
  }
};

struct SecretKeyGenConfig final : public MemoryRetainer {
  size_t length;  // Expressed a a number of bits
  char* out = nullptr;  // Placeholder for the generated key bytes

  void MemoryInfo(MemoryTracker* tracker) const override;
  SET_MEMORY_INFO_NAME(SecretKeyGenConfig)
  SET_SELF_SIZE(SecretKeyGenConfig)
};

struct SecretKeyGenTraits final {
  using AdditionalParameters = SecretKeyGenConfig;
  static const AsyncWrap::ProviderType Provider =
      AsyncWrap::PROVIDER_KEYGENREQUEST;
  static constexpr const char* JobName = "SecretKeyGenJob";

  static v8::Maybe<bool> AdditionalConfig(
      CryptoJobMode mode,
      const v8::FunctionCallbackInfo<v8::Value>& args,
      unsigned int* offset,
      SecretKeyGenConfig* params);

  static KeyGenJobStatus DoKeyGen(
      Environment* env,
      SecretKeyGenConfig* params);

  static v8::Maybe<bool> EncodeKey(
      Environment* env,
      SecretKeyGenConfig* params,
      v8::Local<v8::Value>* result);
};

template <typename AlgorithmParams>
struct KeyPairGenConfig final : public MemoryRetainer {
  PublicKeyEncodingConfig public_key_encoding;
  PrivateKeyEncodingConfig private_key_encoding;
  ManagedEVPPKey key;
  AlgorithmParams params;

  KeyPairGenConfig() = default;

  explicit KeyPairGenConfig(KeyPairGenConfig&& other) noexcept
      : public_key_encoding(other.public_key_encoding),
        private_key_encoding(
            std::forward<PrivateKeyEncodingConfig>(
                other.private_key_encoding)),
        key(std::move(other.key)),
        params(std::move(other.params)) {}

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

  void MemoryInfo(MemoryTracker* tracker) const override {
    tracker->TrackField("key", key);
    if (!private_key_encoding.passphrase_.IsEmpty()) {
      tracker->TrackFieldWithSize("private_key_encoding.passphrase",
                                  private_key_encoding.passphrase_->size());
    }
    tracker->TrackField("params", params);
  }

  SET_MEMORY_INFO_NAME(KeyPairGenConfig)
  SET_SELF_SIZE(KeyPairGenConfig)
};

struct NidKeyPairParams final : public MemoryRetainer {
  int id;
  SET_NO_MEMORY_INFO()
  SET_MEMORY_INFO_NAME(NidKeyPairParams)
  SET_SELF_SIZE(NidKeyPairParams)
};

using NidKeyPairGenConfig = KeyPairGenConfig<NidKeyPairParams>;

struct NidKeyPairGenTraits final {
  using AdditionalParameters = NidKeyPairGenConfig;
  static constexpr const char* JobName = "NidKeyPairGenJob";

  static EVPKeyCtxPointer Setup(NidKeyPairGenConfig* params);

  static v8::Maybe<bool> AdditionalConfig(
      CryptoJobMode mode,
      const v8::FunctionCallbackInfo<v8::Value>& args,
      unsigned int* offset,
      NidKeyPairGenConfig* params);
};

using NidKeyPairGenJob = KeyGenJob<KeyPairGenTraits<NidKeyPairGenTraits>>;
using SecretKeyGenJob = KeyGenJob<SecretKeyGenTraits>;
}  // namespace crypto
}  // namespace node

#endif  // !defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#endif  // SRC_CRYPTO_CRYPTO_KEYGEN_H_



Generated by: GCOVR (Version 3.4)

Line	Branch	Exec	Source
1			#ifndef SRC_CRYPTO_CRYPTO_KEYGEN_H_
2			#define SRC_CRYPTO_CRYPTO_KEYGEN_H_
3
4			#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5
6			#include "crypto/crypto_keys.h"
7			#include "crypto/crypto_util.h"
8			#include "allocated_buffer.h"
9			#include "async_wrap.h"
10			#include "base_object.h"
11			#include "env.h"
12			#include "memory_tracker.h"
13			#include "v8.h"
14
15			namespace node {
16			namespace crypto {
17			namespace Keygen {
18			void Initialize(Environment* env, v8::Local<v8::Object> target);
19			} // namespace Keygen
20
21			enum class KeyGenJobStatus {
22			OK,
23			FAILED
24			};
25
26			// A Base CryptoJob for generating secret keys or key pairs.
27			// The KeyGenTraits is largely responsible for the details of
28			// the implementation, while KeyGenJob handles the common
29			// mechanisms.
30			template <typename KeyGenTraits>
31		440	class KeyGenJob final : public CryptoJob<KeyGenTraits> {
32			public:
33			using AdditionalParams = typename KeyGenTraits::AdditionalParameters;
34
35		221	static void New(const v8::FunctionCallbackInfo<v8::Value>& args) {
36		221	Environment* env = Environment::GetCurrent(args);
37	✗✓✗✓	221	CHECK(args.IsConstructCall());
38
39		221	CryptoJobMode mode = GetCryptoJobMode(args[0]);
40
41		221	unsigned int offset = 1;
42
43		442	AdditionalParams params;
44	✗✓✗✓	442	if (KeyGenTraits::AdditionalConfig(mode, args, &offset, &params)
45			.IsNothing()) {
46			// The KeyGenTraits::AdditionalConfig is responsible for
47			// calling an appropriate THROW_CRYPTO_* variant reporting
48			// whatever error caused initialization to fail.
49			return;
50			}
51
52	✓✗✓✗	221	new KeyGenJob<KeyGenTraits>(env, args.This(), mode, std::move(params));
53			}
54
55		3924	static void Initialize(
56			Environment* env,
57			v8::Local<v8::Object> target) {
58		3924	CryptoJob<KeyGenTraits>::Initialize(New, env, target);
59		3924	}
60
61		221	KeyGenJob(
62			Environment* env,
63			v8::Local<v8::Object> object,
64			CryptoJobMode mode,
65			AdditionalParams&& params)
66			: CryptoJob<KeyGenTraits>(
67			env,
68			object,
69			KeyGenTraits::Provider,
70			mode,
71		221	std::move(params)) {}
72
73		218	void DoThreadPoolWork() override {
74			// Make sure the the CSPRNG is properly seeded so the results are secure
75		218	CheckEntropy();
76
77		218	AdditionalParams* params = CryptoJob<KeyGenTraits>::params();
78
79	✓✗✗✓ ✗✗	218	switch (KeyGenTraits::DoKeyGen(AsyncWrap::env(), params)) {
80			case KeyGenJobStatus::OK:
81		218	status_ = KeyGenJobStatus::OK;
82			// Success!
83		218	break;
84			case KeyGenJobStatus::FAILED: {
85			CryptoErrorVector* errors = CryptoJob<KeyGenTraits>::errors();
86			errors->Capture();
87			if (errors->empty())
88			errors->push_back(std::string("Key generation job failed"));
89			}
90			}
91		218	}
92
93		217	v8::Maybe<bool> ToResult(
94			v8::Local<v8::Value>* err,
95			v8::Local<v8::Value>* result) override {
96		217	Environment* env = AsyncWrap::env();
97		217	CryptoErrorVector* errors = CryptoJob<KeyGenTraits>::errors();
98		217	AdditionalParams* params = CryptoJob<KeyGenTraits>::params();
99	✓✗✓✗ ✓✗✓✗ ✓✗✓✗	651	if (status_ == KeyGenJobStatus::OK &&
100		651	LIKELY(!KeyGenTraits::EncodeKey(env, params, result).IsNothing())) {
101		434	*err = Undefined(env->isolate());
102		217	return v8::Just(true);
103			}
104
105			if (errors->empty())
106			errors->Capture();
107			CHECK(!errors->empty());
108			*result = Undefined(env->isolate());
109			return v8::Just(errors->ToException(env).ToLocal(err));
110			}
111
112			SET_SELF_SIZE(KeyGenJob);
113
114			private:
115			KeyGenJobStatus status_ = KeyGenJobStatus::FAILED;
116			};
117
118			// A Base KeyGenTraits for Key Pair generation algorithms.
119			template <typename KeyPairAlgorithmTraits>
120			struct KeyPairGenTraits final {
121			using AdditionalParameters =
122			typename KeyPairAlgorithmTraits::AdditionalParameters;
123
124			static const AsyncWrap::ProviderType Provider =
125			AsyncWrap::PROVIDER_KEYPAIRGENREQUEST;
126			static constexpr const char* JobName = KeyPairAlgorithmTraits::JobName;
127
128		139	static v8::Maybe<bool> AdditionalConfig(
129			CryptoJobMode mode,
130			const v8::FunctionCallbackInfo<v8::Value>& args,
131			unsigned int* offset,
132			AdditionalParameters* params) {
133			// Notice that offset is a pointer. Each of the AdditionalConfig,
134			// GetPublicKeyEncodingFromJs, and GetPrivateKeyEncodingFromJs
135			// functions will update the value of the offset as they successfully
136			// process input parameters. This allows each job to have a variable
137			// number of input parameters specific to each job type.
138	✓✓	278	if (KeyPairAlgorithmTraits::AdditionalConfig(mode, args, offset, params)
139			.IsNothing()) {
140		2	return v8::Just(false);
141			}
142
143		137	params->public_key_encoding = ManagedEVPPKey::GetPublicKeyEncodingFromJs(
144			args,
145			offset,
146			kKeyContextGenerate);
147
148			auto private_key_encoding =
149			ManagedEVPPKey::GetPrivateKeyEncodingFromJs(
150			args,
151			offset,
152		274	kKeyContextGenerate);
153
154	✓✓	137	if (!private_key_encoding.IsEmpty())
155		136	params->private_key_encoding = private_key_encoding.Release();
156
157		137	return v8::Just(true);
158			}
159
160		136	static KeyGenJobStatus DoKeyGen(
161			Environment* env,
162			AdditionalParameters* params) {
163		272	EVPKeyCtxPointer ctx = KeyPairAlgorithmTraits::Setup(params);
164	✓✗✗✓ ✗✓	136	if (!ctx \|\| EVP_PKEY_keygen_init(ctx.get()) <= 0)
165			return KeyGenJobStatus::FAILED;
166
167			// Generate the key
168		136	EVP_PKEY* pkey = nullptr;
169	✗✓	136	if (!EVP_PKEY_keygen(ctx.get(), &pkey))
170			return KeyGenJobStatus::FAILED;
171
172		136	params->key = ManagedEVPPKey(EVPKeyPointer(pkey));
173		136	return KeyGenJobStatus::OK;
174			}
175
176		135	static v8::Maybe<bool> EncodeKey(
177			Environment* env,
178			AdditionalParameters* params,
179			v8::Local<v8::Value>* result) {
180	✓✓	405	v8::Local<v8::Value> keys[2];
181	✓✗✗✓	540	if (ManagedEVPPKey::ToEncodedPublicKey(
182			env,
183		135	std::move(params->key),
184			params->public_key_encoding,
185	✓✗✗✓	405	&keys[0]).IsNothing() \|\|
186	✓✗	405	ManagedEVPPKey::ToEncodedPrivateKey(
187			env,
188		135	std::move(params->key),
189			params->private_key_encoding,
190			&keys[1]).IsNothing()) {
191			return v8::Nothing<bool>();
192			}
193		270	*result = v8::Array::New(env->isolate(), keys, arraysize(keys));
194		135	return v8::Just(true);
195			}
196			};
197
198		328	struct SecretKeyGenConfig final : public MemoryRetainer {
199			size_t length; // Expressed a a number of bits
200			char* out = nullptr; // Placeholder for the generated key bytes
201
202			void MemoryInfo(MemoryTracker* tracker) const override;
203			SET_MEMORY_INFO_NAME(SecretKeyGenConfig)
204			SET_SELF_SIZE(SecretKeyGenConfig)
205			};
206
207			struct SecretKeyGenTraits final {
208			using AdditionalParameters = SecretKeyGenConfig;
209			static const AsyncWrap::ProviderType Provider =
210			AsyncWrap::PROVIDER_KEYGENREQUEST;
211			static constexpr const char* JobName = "SecretKeyGenJob";
212
213			static v8::Maybe<bool> AdditionalConfig(
214			CryptoJobMode mode,
215			const v8::FunctionCallbackInfo<v8::Value>& args,
216			unsigned int* offset,
217			SecretKeyGenConfig* params);
218
219			static KeyGenJobStatus DoKeyGen(
220			Environment* env,
221			SecretKeyGenConfig* params);
222
223			static v8::Maybe<bool> EncodeKey(
224			Environment* env,
225			SecretKeyGenConfig* params,
226			v8::Local<v8::Value>* result);
227			};
228
229			template <typename AlgorithmParams>
230		277	struct KeyPairGenConfig final : public MemoryRetainer {
231			PublicKeyEncodingConfig public_key_encoding;
232			PrivateKeyEncodingConfig private_key_encoding;
233			ManagedEVPPKey key;
234			AlgorithmParams params;
235
236		139	KeyPairGenConfig() = default;
237
238		139	explicit KeyPairGenConfig(KeyPairGenConfig&& other) noexcept
239			: public_key_encoding(other.public_key_encoding),
240			private_key_encoding(
241			std::forward<PrivateKeyEncodingConfig>(
242			other.private_key_encoding)),
243		139	key(std::move(other.key)),
244		278	params(std::move(other.params)) {}
245
246			KeyPairGenConfig& operator=(KeyPairGenConfig&& other) noexcept {
247			if (&other == this) return *this;
248			this->~KeyPairGenConfig();
249			return *new (this) KeyPairGenConfig(std::move(other));
250			}
251
252			void MemoryInfo(MemoryTracker* tracker) const override {
253			tracker->TrackField("key", key);
254			if (!private_key_encoding.passphrase_.IsEmpty()) {
255			tracker->TrackFieldWithSize("private_key_encoding.passphrase",
256			private_key_encoding.passphrase_->size());
257			}
258			tracker->TrackField("params", params);
259			}
260
261			SET_MEMORY_INFO_NAME(KeyPairGenConfig)
262			SET_SELF_SIZE(KeyPairGenConfig)
263			};
264
265		40	struct NidKeyPairParams final : public MemoryRetainer {
266			int id;
267			SET_NO_MEMORY_INFO()
268			SET_MEMORY_INFO_NAME(NidKeyPairParams)
269			SET_SELF_SIZE(NidKeyPairParams)
270			};
271
272			using NidKeyPairGenConfig = KeyPairGenConfig<NidKeyPairParams>;
273
274			struct NidKeyPairGenTraits final {
275			using AdditionalParameters = NidKeyPairGenConfig;
276			static constexpr const char* JobName = "NidKeyPairGenJob";
277
278			static EVPKeyCtxPointer Setup(NidKeyPairGenConfig* params);
279
280			static v8::Maybe<bool> AdditionalConfig(
281			CryptoJobMode mode,
282			const v8::FunctionCallbackInfo<v8::Value>& args,
283			unsigned int* offset,
284			NidKeyPairGenConfig* params);
285			};
286
287			using NidKeyPairGenJob = KeyGenJob<KeyPairGenTraits<NidKeyPairGenTraits>>;
288			using SecretKeyGenJob = KeyGenJob<SecretKeyGenTraits>;
289			} // namespace crypto
290			} // namespace node
291
292			#endif // !defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
293			#endif // SRC_CRYPTO_CRYPTO_KEYGEN_H_
294