Where Online Learning is simpler!

The C and C++ Include Header Files

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

     1	#ifndef SRC_CRYPTO_CRYPTO_SIG_H_
     2	#define SRC_CRYPTO_CRYPTO_SIG_H_
     3	
     4	#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
     5	
     6	#include "base_object.h"
     7	#include "crypto/crypto_keys.h"
     8	#include "crypto/crypto_util.h"
     9	#include "env.h"
    10	#include "memory_tracker.h"
    11	
    12	namespace node {
    13	namespace crypto {
    14	static const unsigned int kNoDsaSignature = static_cast<unsigned int>(-1);
    15	
    16	enum DSASigEnc {
    17	  kSigEncDER,
    18	  kSigEncP1363
    19	};
    20	
    21	class SignBase : public BaseObject {
    22	 public:
    23	  enum Error {
    24	    kSignOk,
    25	    kSignUnknownDigest,
    26	    kSignInit,
    27	    kSignNotInitialised,
    28	    kSignUpdate,
    29	    kSignPrivateKey,
    30	    kSignPublicKey,
    31	    kSignMalformedSignature
    32	  };
    33	
    34	  SignBase(Environment* env, v8::Local<v8::Object> wrap);
    35	
    36	  Error Init(const char* sign_type);
    37	  Error Update(const char* data, size_t len);
    38	
    39	  // TODO(joyeecheung): track the memory used by OpenSSL types
    40	  void MemoryInfo(MemoryTracker* tracker) const override;
    41	  SET_MEMORY_INFO_NAME(SignBase)
    42	  SET_SELF_SIZE(SignBase)
    43	
    44	 protected:
    45	  ncrypto::EVPMDCtxPointer mdctx_;
    46	};
    47	
    48	class Sign : public SignBase {
    49	 public:
    50	  static void Initialize(Environment* env, v8::Local<v8::Object> target);
    51	  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
    52	
    53	  struct SignResult {
    54	    Error error;
    55	    std::unique_ptr<v8::BackingStore> signature;
    56	
    57	    explicit SignResult(
    58	        Error err,
    59	        std::unique_ptr<v8::BackingStore>&& sig = nullptr)
    60	      : error(err), signature(std::move(sig)) {}
    61	  };
    62	
    63	  SignResult SignFinal(const ncrypto::EVPKeyPointer& pkey,
    64	                       int padding,
    65	                       const v8::Maybe<int>& saltlen,
    66	                       DSASigEnc dsa_sig_enc);
    67	
    68	  static void SignSync(const v8::FunctionCallbackInfo<v8::Value>& args);
    69	
    70	 protected:
    71	  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
    72	  static void SignInit(const v8::FunctionCallbackInfo<v8::Value>& args);
    73	  static void SignUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
    74	  static void SignFinal(const v8::FunctionCallbackInfo<v8::Value>& args);
    75	
    76	  Sign(Environment* env, v8::Local<v8::Object> wrap);
    77	};
    78	
    79	class Verify : public SignBase {
    80	 public:
    81	  static void Initialize(Environment* env, v8::Local<v8::Object> target);
    82	  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
    83	
    84	  Error VerifyFinal(const ncrypto::EVPKeyPointer& key,
    85	                    const ByteSource& sig,
    86	                    int padding,
    87	                    const v8::Maybe<int>& saltlen,
    88	                    bool* verify_result);
    89	
    90	  static void VerifySync(const v8::FunctionCallbackInfo<v8::Value>& args);
    91	
    92	 protected:
    93	  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
    94	  static void VerifyInit(const v8::FunctionCallbackInfo<v8::Value>& args);
    95	  static void VerifyUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
    96	  static void VerifyFinal(const v8::FunctionCallbackInfo<v8::Value>& args);
    97	
    98	  Verify(Environment* env, v8::Local<v8::Object> wrap);
    99	};
   100	
   101	struct SignConfiguration final : public MemoryRetainer {
   102	  enum Mode {
   103	    kSign,
   104	    kVerify
   105	  };
   106	  enum Flags {
   107	    kHasNone = 0,
   108	    kHasSaltLength = 1,
   109	    kHasPadding = 2
   110	  };
   111	
   112	  CryptoJobMode job_mode;
   113	  Mode mode;
   114	  KeyObjectData key;
   115	  ByteSource data;
   116	  ByteSource signature;
   117	  const EVP_MD* digest = nullptr;
   118	  int flags = SignConfiguration::kHasNone;
   119	  int padding = 0;
   120	  int salt_length = 0;
   121	  DSASigEnc dsa_encoding = kSigEncDER;
   122	
   123	  SignConfiguration() = default;
   124	
   125	  explicit SignConfiguration(SignConfiguration&& other) noexcept;
   126	
   127	  SignConfiguration& operator=(SignConfiguration&& other) noexcept;
   128	
   129	  void MemoryInfo(MemoryTracker* tracker) const override;
   130	  SET_MEMORY_INFO_NAME(SignConfiguration)
   131	  SET_SELF_SIZE(SignConfiguration)
   132	};
   133	
   134	struct SignTraits final {
   135	  using AdditionalParameters = SignConfiguration;
   136	  static constexpr const char* JobName = "SignJob";
   137	
   138	// TODO(@jasnell): Sign request vs. Verify request
   139	
   140	  static constexpr AsyncWrap::ProviderType Provider =
   141	      AsyncWrap::PROVIDER_SIGNREQUEST;
   142	
   143	  static v8::Maybe<void> AdditionalConfig(
   144	      CryptoJobMode mode,
   145	      const v8::FunctionCallbackInfo<v8::Value>& args,
   146	      unsigned int offset,
   147	      SignConfiguration* params);
   148	
   149	  static bool DeriveBits(Environment* env,
   150	                         const SignConfiguration& params,
   151	                         ByteSource* out,
   152	                         CryptoJobMode mode);
   153	
   154	  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
   155	                                                const SignConfiguration& params,
   156	                                                ByteSource* out);
   157	};
   158	
   159	using SignJob = DeriveBitsJob<SignTraits>;
   160	
   161	}  // namespace crypto
   162	}  // namespace node
   163	
   164	#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
   165	#endif  // SRC_CRYPTO_CRYPTO_SIG_H_