Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	crypto/crypto_ec.h	Lines:	0	10	0.0 %
Date:	2021-12-25 04:14:02	Branches:	0	0	- %


#ifndef SRC_CRYPTO_CRYPTO_EC_H_
#define SRC_CRYPTO_CRYPTO_EC_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "crypto/crypto_keys.h"
#include "crypto/crypto_keygen.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 "node_internals.h"
#include "v8.h"

namespace node {
namespace crypto {
int GetCurveFromName(const char* name);
int GetOKPCurveFromName(const char* name);

class ECDH final : public BaseObject {
 public:
  ~ECDH() override;

  static void Initialize(Environment* env, v8::Local<v8::Object> target);
  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);

  static ECPointPointer BufferToPoint(Environment* env,
                                      const EC_GROUP* group,
                                      v8::Local<v8::Value> buf);

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

  static void ConvertKey(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void GetCurves(const v8::FunctionCallbackInfo<v8::Value>& args);

 protected:
  ECDH(Environment* env, v8::Local<v8::Object> wrap, ECKeyPointer&& key);

  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void GenerateKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void ComputeSecret(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void GetPrivateKey(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void SetPrivateKey(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void GetPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void SetPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);

  bool IsKeyPairValid();
  bool IsKeyValidForCurve(const BignumPointer& private_key);

  ECKeyPointer key_;
  const EC_GROUP* group_;
};

struct ECDHBitsConfig final : public MemoryRetainer {
  int id_;
  std::shared_ptr<KeyObjectData> private_;
  std::shared_ptr<KeyObjectData> public_;

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

struct ECDHBitsTraits final {
  using AdditionalParameters = ECDHBitsConfig;
  static constexpr const char* JobName = "ECDHBitsJob";
  static constexpr AsyncWrap::ProviderType Provider =
      AsyncWrap::PROVIDER_DERIVEBITSREQUEST;

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

  static bool DeriveBits(
      Environment* env,
      const ECDHBitsConfig& params,
      ByteSource* out_);

  static v8::Maybe<bool> EncodeOutput(
      Environment* env,
      const ECDHBitsConfig& params,
      ByteSource* out,
      v8::Local<v8::Value>* result);
};

using ECDHBitsJob = DeriveBitsJob<ECDHBitsTraits>;

struct EcKeyPairParams final : public MemoryRetainer {
  int curve_nid;
  int param_encoding;
  SET_NO_MEMORY_INFO()
  SET_MEMORY_INFO_NAME(EcKeyPairParams)
  SET_SELF_SIZE(EcKeyPairParams)
};

using EcKeyPairGenConfig = KeyPairGenConfig<EcKeyPairParams>;

struct EcKeyGenTraits final {
  using AdditionalParameters = EcKeyPairGenConfig;
  static constexpr const char* JobName = "EcKeyPairGenJob";

  static EVPKeyCtxPointer Setup(EcKeyPairGenConfig* params);

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

using ECKeyPairGenJob = KeyGenJob<KeyPairGenTraits<EcKeyGenTraits>>;

// There is currently no additional information that the
// ECKeyExport needs to collect, but we need to provide
// the base struct anyway.
struct ECKeyExportConfig final : public MemoryRetainer {
  SET_NO_MEMORY_INFO()
  SET_MEMORY_INFO_NAME(ECKeyExportConfig)
  SET_SELF_SIZE(ECKeyExportConfig)
};

struct ECKeyExportTraits final {
  static constexpr const char* JobName = "ECKeyExportJob";
  using AdditionalParameters = ECKeyExportConfig;

  static v8::Maybe<bool> AdditionalConfig(
      const v8::FunctionCallbackInfo<v8::Value>& args,
      unsigned int offset,
      ECKeyExportConfig* config);

  static WebCryptoKeyExportStatus DoExport(
      std::shared_ptr<KeyObjectData> key_data,
      WebCryptoKeyFormat format,
      const ECKeyExportConfig& params,
      ByteSource* out);
};

using ECKeyExportJob = KeyExportJob<ECKeyExportTraits>;

v8::Maybe<bool> ExportJWKEcKey(
    Environment* env,
    std::shared_ptr<KeyObjectData> key,
    v8::Local<v8::Object> target);

v8::Maybe<bool> ExportJWKEdKey(
    Environment* env,
    std::shared_ptr<KeyObjectData> key,
    v8::Local<v8::Object> target);

std::shared_ptr<KeyObjectData> ImportJWKEcKey(
    Environment* env,
    v8::Local<v8::Object> jwk,
    const v8::FunctionCallbackInfo<v8::Value>& args,
    unsigned int offset);

v8::Maybe<bool> GetEcKeyDetail(
    Environment* env,
    std::shared_ptr<KeyObjectData> key,
    v8::Local<v8::Object> target);
}  // namespace crypto
}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#endif  // SRC_CRYPTO_CRYPTO_EC_H_


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#ifndef SRC_CRYPTO_CRYPTO_EC_H_
2			#define SRC_CRYPTO_CRYPTO_EC_H_
3
4			#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5
6			#include "crypto/crypto_keys.h"
7			#include "crypto/crypto_keygen.h"
8			#include "crypto/crypto_util.h"
9			#include "allocated_buffer.h"
10			#include "async_wrap.h"
11			#include "base_object.h"
12			#include "env.h"
13			#include "memory_tracker.h"
14			#include "node_internals.h"
15			#include "v8.h"
16
17			namespace node {
18			namespace crypto {
19			int GetCurveFromName(const char* name);
20			int GetOKPCurveFromName(const char* name);
21
22			class ECDH final : public BaseObject {
23			public:
24			~ECDH() override;
25
26			static void Initialize(Environment* env, v8::Local<v8::Object> target);
27			static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
28
29			static ECPointPointer BufferToPoint(Environment* env,
30			const EC_GROUP* group,
31			v8::Local<v8::Value> buf);
32
33			void MemoryInfo(MemoryTracker* tracker) const override;
34			SET_MEMORY_INFO_NAME(ECDH)
35			SET_SELF_SIZE(ECDH)
36
37			static void ConvertKey(const v8::FunctionCallbackInfo<v8::Value>& args);
38
39			static void GetCurves(const v8::FunctionCallbackInfo<v8::Value>& args);
40
41			protected:
42			ECDH(Environment* env, v8::Local<v8::Object> wrap, ECKeyPointer&& key);
43
44			static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
45			static void GenerateKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
46			static void ComputeSecret(const v8::FunctionCallbackInfo<v8::Value>& args);
47			static void GetPrivateKey(const v8::FunctionCallbackInfo<v8::Value>& args);
48			static void SetPrivateKey(const v8::FunctionCallbackInfo<v8::Value>& args);
49			static void GetPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
50			static void SetPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
51
52			bool IsKeyPairValid();
53			bool IsKeyValidForCurve(const BignumPointer& private_key);
54
55			ECKeyPointer key_;
56			const EC_GROUP* group_;
57			};
58
59			struct ECDHBitsConfig final : public MemoryRetainer {
60			int id_;
61			std::shared_ptr<KeyObjectData> private_;
62			std::shared_ptr<KeyObjectData> public_;
63
64			void MemoryInfo(MemoryTracker* tracker) const override;
65			SET_MEMORY_INFO_NAME(ECDHBitsConfig)
66			SET_SELF_SIZE(ECDHBitsConfig)
67			};
68
69			struct ECDHBitsTraits final {
70			using AdditionalParameters = ECDHBitsConfig;
71			static constexpr const char* JobName = "ECDHBitsJob";
72			static constexpr AsyncWrap::ProviderType Provider =
73			AsyncWrap::PROVIDER_DERIVEBITSREQUEST;
74
75			static v8::Maybe<bool> AdditionalConfig(
76			CryptoJobMode mode,
77			const v8::FunctionCallbackInfo<v8::Value>& args,
78			unsigned int offset,
79			ECDHBitsConfig* params);
80
81			static bool DeriveBits(
82			Environment* env,
83			const ECDHBitsConfig& params,
84			ByteSource* out_);
85
86			static v8::Maybe<bool> EncodeOutput(
87			Environment* env,
88			const ECDHBitsConfig& params,
89			ByteSource* out,
90			v8::Local<v8::Value>* result);
91			};
92
93			using ECDHBitsJob = DeriveBitsJob<ECDHBitsTraits>;
94
95			struct EcKeyPairParams final : public MemoryRetainer {
96			int curve_nid;
97			int param_encoding;
98			SET_NO_MEMORY_INFO()
99			SET_MEMORY_INFO_NAME(EcKeyPairParams)
100			SET_SELF_SIZE(EcKeyPairParams)
101			};
102
103			using EcKeyPairGenConfig = KeyPairGenConfig<EcKeyPairParams>;
104
105			struct EcKeyGenTraits final {
106			using AdditionalParameters = EcKeyPairGenConfig;
107			static constexpr const char* JobName = "EcKeyPairGenJob";
108
109			static EVPKeyCtxPointer Setup(EcKeyPairGenConfig* params);
110
111			static v8::Maybe<bool> AdditionalConfig(
112			CryptoJobMode mode,
113			const v8::FunctionCallbackInfo<v8::Value>& args,
114			unsigned int* offset,
115			EcKeyPairGenConfig* params);
116			};
117
118			using ECKeyPairGenJob = KeyGenJob<KeyPairGenTraits<EcKeyGenTraits>>;
119
120			// There is currently no additional information that the
121			// ECKeyExport needs to collect, but we need to provide
122			// the base struct anyway.
123			struct ECKeyExportConfig final : public MemoryRetainer {
124			SET_NO_MEMORY_INFO()
125			SET_MEMORY_INFO_NAME(ECKeyExportConfig)
126			SET_SELF_SIZE(ECKeyExportConfig)
127			};
128
129			struct ECKeyExportTraits final {
130			static constexpr const char* JobName = "ECKeyExportJob";
131			using AdditionalParameters = ECKeyExportConfig;
132
133			static v8::Maybe<bool> AdditionalConfig(
134			const v8::FunctionCallbackInfo<v8::Value>& args,
135			unsigned int offset,
136			ECKeyExportConfig* config);
137
138			static WebCryptoKeyExportStatus DoExport(
139			std::shared_ptr<KeyObjectData> key_data,
140			WebCryptoKeyFormat format,
141			const ECKeyExportConfig& params,
142			ByteSource* out);
143			};
144
145			using ECKeyExportJob = KeyExportJob<ECKeyExportTraits>;
146
147			v8::Maybe<bool> ExportJWKEcKey(
148			Environment* env,
149			std::shared_ptr<KeyObjectData> key,
150			v8::Local<v8::Object> target);
151
152			v8::Maybe<bool> ExportJWKEdKey(
153			Environment* env,
154			std::shared_ptr<KeyObjectData> key,
155			v8::Local<v8::Object> target);
156
157			std::shared_ptr<KeyObjectData> ImportJWKEcKey(
158			Environment* env,
159			v8::Local<v8::Object> jwk,
160			const v8::FunctionCallbackInfo<v8::Value>& args,
161			unsigned int offset);
162
163			v8::Maybe<bool> GetEcKeyDetail(
164			Environment* env,
165			std::shared_ptr<KeyObjectData> key,
166			v8::Local<v8::Object> target);
167			} // namespace crypto
168			} // namespace node
169
170			#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
171			#endif // SRC_CRYPTO_CRYPTO_EC_H_