Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	crypto/crypto_keygen.cc	Lines:	33	40	82.5 %
Date:	2022-12-07 04:23:16	Branches:	12	26	46.2 %


#include "crypto/crypto_keygen.h"
#include "async_wrap-inl.h"
#include "base_object-inl.h"
#include "debug_utils-inl.h"
#include "env-inl.h"
#include "memory_tracker-inl.h"
#include "threadpoolwork-inl.h"
#include "v8.h"

#include <cmath>

namespace node {

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

namespace crypto {
// NidKeyPairGenJob input arguments:
//   1. CryptoJobMode
//   2. NID
//   3. Public Format
//   4. Public Type
//   5. Private Format
//   6. Private Type
//   7. Cipher
//   8. Passphrase
Maybe<bool> NidKeyPairGenTraits::AdditionalConfig(
    CryptoJobMode mode,
    const FunctionCallbackInfo<Value>& args,
    unsigned int* offset,
    NidKeyPairGenConfig* params) {
  CHECK(args[*offset]->IsInt32());
  params->params.id = args[*offset].As<Int32>()->Value();

  *offset += 1;

  return Just(true);
}

EVPKeyCtxPointer NidKeyPairGenTraits::Setup(NidKeyPairGenConfig* params) {
  EVPKeyCtxPointer ctx =
      EVPKeyCtxPointer(EVP_PKEY_CTX_new_id(params->params.id, nullptr));
  if (!ctx || EVP_PKEY_keygen_init(ctx.get()) <= 0)
    return EVPKeyCtxPointer();

  return ctx;
}

void SecretKeyGenConfig::MemoryInfo(MemoryTracker* tracker) const {
  if (out) tracker->TrackFieldWithSize("out", length);
}

Maybe<bool> SecretKeyGenTraits::AdditionalConfig(
    CryptoJobMode mode,
    const FunctionCallbackInfo<Value>& args,
    unsigned int* offset,
    SecretKeyGenConfig* params) {
  Environment* env = Environment::GetCurrent(args);
  CHECK(args[*offset]->IsUint32());
  params->length = args[*offset].As<Uint32>()->Value() / CHAR_BIT;
  if (params->length > INT_MAX) {
    THROW_ERR_OUT_OF_RANGE(env,
                           "length must be less than or equal to %u bits",
                           static_cast<uint64_t>(INT_MAX) * CHAR_BIT);
    return Nothing<bool>();
  }
  *offset += 1;
  return Just(true);
}

KeyGenJobStatus SecretKeyGenTraits::DoKeyGen(
    Environment* env,
    SecretKeyGenConfig* params) {
  CHECK_LE(params->length, INT_MAX);
  ByteSource::Builder bytes(params->length);
  if (CSPRNG(bytes.data<unsigned char>(), params->length).is_err())
    return KeyGenJobStatus::FAILED;
  params->out = std::move(bytes).release();
  return KeyGenJobStatus::OK;
}

Maybe<bool> SecretKeyGenTraits::EncodeKey(Environment* env,
                                          SecretKeyGenConfig* params,
                                          Local<Value>* result) {
  std::shared_ptr<KeyObjectData> data =
      KeyObjectData::CreateSecret(std::move(params->out));
  return Just(KeyObjectHandle::Create(env, data).ToLocal(result));
}

namespace Keygen {
void Initialize(Environment* env, Local<Object> target) {
  NidKeyPairGenJob::Initialize(env, target);
  SecretKeyGenJob::Initialize(env, target);
}

void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
  NidKeyPairGenJob::RegisterExternalReferences(registry);
  SecretKeyGenJob::RegisterExternalReferences(registry);
}

}  // namespace Keygen
}  // namespace crypto
}  // namespace node


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#include "crypto/crypto_keygen.h"
2			#include "async_wrap-inl.h"
3			#include "base_object-inl.h"
4			#include "debug_utils-inl.h"
5			#include "env-inl.h"
6			#include "memory_tracker-inl.h"
7			#include "threadpoolwork-inl.h"
8			#include "v8.h"
9
10			#include <cmath>
11
12			namespace node {
13
14			using v8::FunctionCallbackInfo;
15			using v8::Int32;
16			using v8::Just;
17			using v8::Local;
18			using v8::Maybe;
19			using v8::Nothing;
20			using v8::Object;
21			using v8::Uint32;
22			using v8::Value;
23
24			namespace crypto {
25			// NidKeyPairGenJob input arguments:
26			// 1. CryptoJobMode
27			// 2. NID
28			// 3. Public Format
29			// 4. Public Type
30			// 5. Private Format
31			// 6. Private Type
32			// 7. Cipher
33			// 8. Passphrase
34		134	Maybe<bool> NidKeyPairGenTraits::AdditionalConfig(
35			CryptoJobMode mode,
36			const FunctionCallbackInfo<Value>& args,
37			unsigned int* offset,
38			NidKeyPairGenConfig* params) {
39	✓✗✗✓	268	CHECK(args[*offset]->IsInt32());
40	✓✗	402	params->params.id = args[*offset].As<Int32>()->Value();
41
42		134	*offset += 1;
43
44		134	return Just(true);
45			}
46
47		134	EVPKeyCtxPointer NidKeyPairGenTraits::Setup(NidKeyPairGenConfig* params) {
48			EVPKeyCtxPointer ctx =
49		268	EVPKeyCtxPointer(EVP_PKEY_CTX_new_id(params->params.id, nullptr));
50	✓✗✗✓ ✗✓	134	if (!ctx \|\| EVP_PKEY_keygen_init(ctx.get()) <= 0)
51			return EVPKeyCtxPointer();
52
53		134	return ctx;
54			}
55
56			void SecretKeyGenConfig::MemoryInfo(MemoryTracker* tracker) const {
57			if (out) tracker->TrackFieldWithSize("out", length);
58			}
59
60		1299	Maybe<bool> SecretKeyGenTraits::AdditionalConfig(
61			CryptoJobMode mode,
62			const FunctionCallbackInfo<Value>& args,
63			unsigned int* offset,
64			SecretKeyGenConfig* params) {
65		1299	Environment* env = Environment::GetCurrent(args);
66	✓✗✗✓	2598	CHECK(args[*offset]->IsUint32());
67	✓✗	3897	params->length = args[*offset].As<Uint32>()->Value() / CHAR_BIT;
68	✗✓	1299	if (params->length > INT_MAX) {
69			THROW_ERR_OUT_OF_RANGE(env,
70			"length must be less than or equal to %u bits",
71			static_cast<uint64_t>(INT_MAX) * CHAR_BIT);
72			return Nothing<bool>();
73			}
74		1299	*offset += 1;
75		1299	return Just(true);
76			}
77
78		1299	KeyGenJobStatus SecretKeyGenTraits::DoKeyGen(
79			Environment* env,
80			SecretKeyGenConfig* params) {
81	✗✓	1299	CHECK_LE(params->length, INT_MAX);
82		2598	ByteSource::Builder bytes(params->length);
83	✗✓	1299	if (CSPRNG(bytes.data<unsigned char>(), params->length).is_err())
84			return KeyGenJobStatus::FAILED;
85		1299	params->out = std::move(bytes).release();
86		1299	return KeyGenJobStatus::OK;
87			}
88
89		1299	Maybe<bool> SecretKeyGenTraits::EncodeKey(Environment* env,
90			SecretKeyGenConfig* params,
91			Local<Value>* result) {
92			std::shared_ptr<KeyObjectData> data =
93		1299	KeyObjectData::CreateSecret(std::move(params->out));
94		2598	return Just(KeyObjectHandle::Create(env, data).ToLocal(result));
95			}
96
97			namespace Keygen {
98		800	void Initialize(Environment* env, Local<Object> target) {
99		800	NidKeyPairGenJob::Initialize(env, target);
100		800	SecretKeyGenJob::Initialize(env, target);
101		800	}
102
103		5639	void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
104		5639	NidKeyPairGenJob::RegisterExternalReferences(registry);
105		5639	SecretKeyGenJob::RegisterExternalReferences(registry);
106		5639	}
107
108			} // namespace Keygen
109			} // namespace crypto
110			} // namespace node