Where Online Learning is simpler!

The C and C++ Include Header Files

cat -n /usr/include/nodejs/src/crypto/crypto_ec.h

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