| FazBrowse GitHub Viewer | Trending | | Home |
| Tools: [Download Repo ZIP] [Original HTTPS Page] |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -197,10 +197,7 @@ using DeleteFnPtr = typename FunctionDeleter<T, function>::Pointer; | |||
| 197 | 197 | ||
| 198 | 198 | using BignumCtxPointer = DeleteFnPtr<BN_CTX, BN_CTX_free>; | |
| 199 | 199 | using BignumGenCallbackPointer = DeleteFnPtr<BN_GENCB, BN_GENCB_free>; | |
| 200 | - using DSAPointer = DeleteFnPtr<DSA, DSA_free>; | ||
| 201 | - using DSASigPointer = DeleteFnPtr<DSA_SIG, DSA_SIG_free>; | ||
| 202 | 200 | using ECDSASigPointer = DeleteFnPtr<ECDSA_SIG, ECDSA_SIG_free>; | |
| 203 | - using ECPointer = DeleteFnPtr<EC_KEY, EC_KEY_free>; | ||
| 204 | 201 | using ECGroupPointer = DeleteFnPtr<EC_GROUP, EC_GROUP_free>; | |
| 205 | 202 | using ECKeyPointer = DeleteFnPtr<EC_KEY, EC_KEY_free>; | |
| 206 | 203 | using ECPointPointer = DeleteFnPtr<EC_POINT, EC_POINT_free>; | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -16,6 +16,9 @@ | |||
| 16 | 16 | ||
| 17 | 17 | namespace node { | |
| 18 | 18 | ||
| 19 | + using ncrypto::BignumPointer; | ||
| 20 | + using ncrypto::Cipher; | ||
| 21 | + using ncrypto::CipherCtxPointer; | ||
| 19 | 22 | using v8::FunctionCallbackInfo; | |
| 20 | 23 | using v8::Just; | |
| 21 | 24 | using v8::JustVoid; | |
@@ -60,7 +63,7 @@ WebCryptoCipherStatus AES_Cipher(Environment* env, | |||
| 60 | 63 | ||
| 61 | 64 | if (!ctx.setKeyLength(key_data.GetSymmetricKeySize()) || | |
| 62 | 65 | !ctx.init( | |
| 63 | - ncrypto::Cipher(), | ||
| 66 | + Cipher(), | ||
| 64 | 67 | encrypt, | |
| 65 | 68 | reinterpret_cast<const unsigned char*>(key_data.GetSymmetricKey()), | |
| 66 | 69 | params.iv.data<unsigned char>())) { | |
@@ -464,7 +467,7 @@ Maybe<void> AESCipherTraits::AdditionalConfig( | |||
| 464 | 467 | } | |
| 465 | 468 | #undef V | |
| 466 | 469 | ||
| 467 | - params->cipher = ncrypto::Cipher::FromNid(cipher_nid); | ||
| 470 | + params->cipher = Cipher::FromNid(cipher_nid); | ||
| 468 | 471 | if (!params->cipher) { | |
| 469 | 472 | THROW_ERR_CRYPTO_UNKNOWN_CIPHER(env); | |
| 470 | 473 | return Nothing<void>(); | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -30,6 +30,9 @@ | |||
| 30 | 30 | #include <cstring> | |
| 31 | 31 | ||
| 32 | 32 | namespace node { | |
| 33 | + | ||
| 34 | + using ncrypto::BIOPointer; | ||
| 35 | + | ||
| 33 | 36 | namespace crypto { | |
| 34 | 37 | ||
| 35 | 38 | BIOPointer NodeBIO::New(Environment* env) { | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -43,12 +43,13 @@ class NodeBIO : public MemoryRetainer { | |||
| 43 | 43 | public: | |
| 44 | 44 | ~NodeBIO() override; | |
| 45 | 45 | ||
| 46 | - static BIOPointer New(Environment* env = nullptr); | ||
| 46 | + static ncrypto::BIOPointer New(Environment* env = nullptr); | ||
| 47 | 47 | ||
| 48 | 48 | // NewFixed takes a copy of `len` bytes from `data` and returns a BIO that, | |
| 49 | 49 | // when read from, returns those bytes followed by EOF. | |
| 50 | - static BIOPointer NewFixed(const char* data, size_t len, | ||
| 51 | - Environment* env = nullptr); | ||
| 50 | + static ncrypto::BIOPointer NewFixed(const char* data, | ||
| 51 | + size_t len, | ||
| 52 | + Environment* env = nullptr); | ||
| 52 | 53 | ||
| 53 | 54 | // Move read head to next buffer if needed | |
| 54 | 55 | void TryMoveReadHead(); | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -10,6 +10,13 @@ | |||
| 10 | 10 | ||
| 11 | 11 | namespace node { | |
| 12 | 12 | ||
| 13 | + using ncrypto::Cipher; | ||
| 14 | + using ncrypto::CipherCtxPointer; | ||
| 15 | + using ncrypto::EVPKeyCtxPointer; | ||
| 16 | + using ncrypto::EVPKeyPointer; | ||
| 17 | + using ncrypto::MarkPopErrorOnReturn; | ||
| 18 | + using ncrypto::SSLCtxPointer; | ||
| 19 | + using ncrypto::SSLPointer; | ||
| 13 | 20 | using v8::Array; | |
| 14 | 21 | using v8::ArrayBuffer; | |
| 15 | 22 | using v8::BackingStore; | |
@@ -42,10 +49,10 @@ void GetCipherInfo(const FunctionCallbackInfo<Value>& args) { | |||
| 42 | 49 | const auto cipher = ([&] { | |
| 43 | 50 | if (args[1]->IsString()) { | |
| 44 | 51 | Utf8Value name(env->isolate(), args[1]); | |
| 45 | - return ncrypto::Cipher::FromName(*name); | ||
| 52 | + return Cipher::FromName(*name); | ||
| 46 | 53 | } else { | |
| 47 | 54 | int nid = args[1].As<Int32>()->Value(); | |
| 48 | - return ncrypto::Cipher::FromNid(nid); | ||
| 55 | + return Cipher::FromNid(nid); | ||
| 49 | 56 | } | |
| 50 | 57 | })(); | |
| 51 | 58 | ||
@@ -334,7 +341,7 @@ void CipherBase::CommonInit(const char* cipher_type, | |||
| 334 | 341 | return THROW_ERR_CRYPTO_INVALID_KEYLEN(env()); | |
| 335 | 342 | } | |
| 336 | 343 | ||
| 337 | - if (!ctx_.init(ncrypto::Cipher(), encrypt, key, iv)) { | ||
| 344 | + if (!ctx_.init(Cipher(), encrypt, key, iv)) { | ||
| 338 | 345 | return ThrowCryptoError(env(), ERR_get_error(), | |
| 339 | 346 | "Failed to initialize cipher"); | |
| 340 | 347 | } | |
@@ -345,7 +352,7 @@ void CipherBase::Init(const char* cipher_type, | |||
| 345 | 352 | unsigned int auth_tag_len) { | |
| 346 | 353 | HandleScope scope(env()->isolate()); | |
| 347 | 354 | MarkPopErrorOnReturn mark_pop_error_on_return; | |
| 348 | - auto cipher = ncrypto::Cipher::FromName(cipher_type); | ||
| 355 | + auto cipher = Cipher::FromName(cipher_type); | ||
| 349 | 356 | if (!cipher) { | |
| 350 | 357 | return THROW_ERR_CRYPTO_UNKNOWN_CIPHER(env()); | |
| 351 | 358 | } | |
@@ -415,7 +422,7 @@ void CipherBase::InitIv(const char* cipher_type, | |||
| 415 | 422 | HandleScope scope(env()->isolate()); | |
| 416 | 423 | MarkPopErrorOnReturn mark_pop_error_on_return; | |
| 417 | 424 | ||
| 418 | - auto cipher = ncrypto::Cipher::FromName(cipher_type); | ||
| 425 | + auto cipher = Cipher::FromName(cipher_type); | ||
| 419 | 426 | if (!cipher) return THROW_ERR_CRYPTO_UNKNOWN_CIPHER(env()); | |
| 420 | 427 | ||
| 421 | 428 | const int expected_iv_len = cipher.getIvLength(); | |
@@ -628,8 +635,7 @@ void CipherBase::SetAuthTag(const FunctionCallbackInfo<Value>& args) { | |||
| 628 | 635 | } else { | |
| 629 | 636 | // At this point, the tag length is already known and must match the | |
| 630 | 637 | // length of the given authentication tag. | |
| 631 | - CHECK( | ||
| 632 | - ncrypto::Cipher::FromCtx(cipher->ctx_).isSupportedAuthenticatedMode()); | ||
| 638 | + CHECK(Cipher::FromCtx(cipher->ctx_).isSupportedAuthenticatedMode()); | ||
| 633 | 639 | CHECK_NE(cipher->auth_tag_len_, kNoAuthTagLength); | |
| 634 | 640 | is_valid = cipher->auth_tag_len_ == tag_len; | |
| 635 | 641 | } | |
@@ -854,7 +860,7 @@ bool CipherBase::Final(std::unique_ptr<BackingStore>* out) { | |||
| 854 | 860 | } | |
| 855 | 861 | ||
| 856 | 862 | if (kind_ == kDecipher && | |
| 857 | - ncrypto::Cipher::FromCtx(ctx_).isSupportedAuthenticatedMode()) { | ||
| 863 | + Cipher::FromCtx(ctx_).isSupportedAuthenticatedMode()) { | ||
| 858 | 864 | MaybePassAuthTagToOpenSSL(); | |
| 859 | 865 | } | |
| 860 | 866 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -85,7 +85,7 @@ class CipherBase : public BaseObject { | |||
| 85 | 85 | CipherBase(Environment* env, v8::Local<v8::Object> wrap, CipherKind kind); | |
| 86 | 86 | ||
| 87 | 87 | private: | |
| 88 | - CipherCtxPointer ctx_; | ||
| 88 | + ncrypto::CipherCtxPointer ctx_; | ||
| 89 | 89 | const CipherKind kind_; | |
| 90 | 90 | AuthTagState auth_tag_state_; | |
| 91 | 91 | unsigned int auth_tag_len_; | |
@@ -110,7 +110,7 @@ class PublicKeyCipher { | |||
| 110 | 110 | EVP_PKEY_cipher_init_t EVP_PKEY_cipher_init, | |
| 111 | 111 | EVP_PKEY_cipher_t EVP_PKEY_cipher> | |
| 112 | 112 | static bool Cipher(Environment* env, | |
| 113 | - const EVPKeyPointer& pkey, | ||
| 113 | + const ncrypto::EVPKeyPointer& pkey, | ||
| 114 | 114 | int padding, | |
| 115 | 115 | const EVP_MD* digest, | |
| 116 | 116 | const ArrayBufferOrViewContents<unsigned char>& oaep_label, | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -27,7 +27,13 @@ | |||
| 27 | 27 | ||
| 28 | 28 | namespace node { | |
| 29 | 29 | ||
| 30 | + using ncrypto::ClearErrorOnReturn; | ||
| 31 | + using ncrypto::EVPKeyPointer; | ||
| 32 | + using ncrypto::SSLPointer; | ||
| 33 | + using ncrypto::SSLSessionPointer; | ||
| 30 | 34 | using ncrypto::StackOfX509; | |
| 35 | + using ncrypto::X509Pointer; | ||
| 36 | + using ncrypto::X509View; | ||
| 31 | 37 | using v8::ArrayBuffer; | |
| 32 | 38 | using v8::BackingStore; | |
| 33 | 39 | using v8::Context; | |
@@ -135,7 +141,7 @@ MaybeLocal<Object> AddIssuerChainToObject(X509Pointer* cert, | |||
| 135 | 141 | for (;;) { | |
| 136 | 142 | int i; | |
| 137 | 143 | for (i = 0; i < sk_X509_num(peer_certs.get()); i++) { | |
| 138 | - ncrypto::X509View ca(sk_X509_value(peer_certs.get(), i)); | ||
| 144 | + X509View ca(sk_X509_value(peer_certs.get(), i)); | ||
| 139 | 145 | if (!cert->view().isIssuedBy(ca)) continue; | |
| 140 | 146 | ||
| 141 | 147 | Local<Value> ca_info; | |
@@ -243,7 +249,7 @@ MaybeLocal<Object> GetEphemeralKey(Environment* env, const SSLPointer& ssl) { | |||
| 243 | 249 | ||
| 244 | 250 | EscapableHandleScope scope(env->isolate()); | |
| 245 | 251 | Local<Object> info = Object::New(env->isolate()); | |
| 246 | - crypto::EVPKeyPointer key = ssl.getPeerTempKey(); | ||
| 252 | + EVPKeyPointer key = ssl.getPeerTempKey(); | ||
| 247 | 253 | if (!key) return scope.Escape(info); | |
| 248 | 254 | ||
| 249 | 255 | Local<Context> context = env->context(); | |
@@ -341,8 +347,8 @@ MaybeLocal<Value> GetPeerCert( | |||
| 341 | 347 | if (cert) { | |
| 342 | 348 | return X509Certificate::toObject(env, cert.view()); | |
| 343 | 349 | } | |
| 344 | - return X509Certificate::toObject( | ||
| 345 | - env, ncrypto::X509View(sk_X509_value(ssl_certs, 0))); | ||
| 350 | + return X509Certificate::toObject(env, | ||
| 351 | + X509View(sk_X509_value(ssl_certs, 0))); | ||
| 346 | 352 | } | |
| 347 | 353 | ||
| 348 | 354 | StackOfX509 peer_certs = CloneSSLCerts(std::move(cert), ssl_certs); | |
@@ -351,7 +357,7 @@ MaybeLocal<Value> GetPeerCert( | |||
| 351 | 357 | ||
| 352 | 358 | // First and main certificate. | |
| 353 | 359 | Local<Value> result; | |
| 354 | - ncrypto::X509View first_cert(sk_X509_value(peer_certs.get(), 0)); | ||
| 360 | + X509View first_cert(sk_X509_value(peer_certs.get(), 0)); | ||
| 355 | 361 | CHECK(first_cert); | |
| 356 | 362 | if (!X509Certificate::toObject(env, first_cert).ToLocal(&result)) return {}; | |
| 357 | 363 | CHECK(result->IsObject()); | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -22,35 +22,35 @@ | |||
| 22 | 22 | namespace node { | |
| 23 | 23 | namespace crypto { | |
| 24 | 24 | ||
| 25 | - SSLSessionPointer GetTLSSession(const unsigned char* buf, size_t length); | ||
| 25 | + ncrypto::SSLSessionPointer GetTLSSession(const unsigned char* buf, | ||
| 26 | + size_t length); | ||
| 26 | 27 | ||
| 27 | 28 | long VerifyPeerCertificate( // NOLINT(runtime/int) | |
| 28 | - const SSLPointer& ssl, | ||
| 29 | + const ncrypto::SSLPointer& ssl, | ||
| 29 | 30 | long def = X509_V_ERR_UNSPECIFIED); // NOLINT(runtime/int) | |
| 30 | 31 | ||
| 31 | - bool UseSNIContext(const SSLPointer& ssl, BaseObjectPtr<SecureContext> context); | ||
| 32 | + bool UseSNIContext(const ncrypto::SSLPointer& ssl, | ||
| 33 | + BaseObjectPtr<SecureContext> context); | ||
| 32 | 34 | ||
| 33 | 35 | bool SetGroups(SecureContext* sc, const char* groups); | |
| 34 | 36 | ||
| 35 | 37 | v8::MaybeLocal<v8::Value> GetValidationErrorReason(Environment* env, int err); | |
| 36 | 38 | ||
| 37 | 39 | v8::MaybeLocal<v8::Value> GetValidationErrorCode(Environment* env, int err); | |
| 38 | 40 | ||
| 39 | - v8::MaybeLocal<v8::Value> GetCert(Environment* env, const SSLPointer& ssl); | ||
| 41 | + v8::MaybeLocal<v8::Value> GetCert(Environment* env, | ||
| 42 | + const ncrypto::SSLPointer& ssl); | ||
| 40 | 43 | ||
| 41 | - v8::MaybeLocal<v8::Object> GetCipherInfo( | ||
| 42 | - Environment* env, | ||
| 43 | - const SSLPointer& ssl); | ||
| 44 | + v8::MaybeLocal<v8::Object> GetCipherInfo(Environment* env, | ||
| 45 | + const ncrypto::SSLPointer& ssl); | ||
| 44 | 46 | ||
| 45 | - v8::MaybeLocal<v8::Object> GetEphemeralKey( | ||
| 46 | - Environment* env, | ||
| 47 | - const SSLPointer& ssl); | ||
| 47 | + v8::MaybeLocal<v8::Object> GetEphemeralKey(Environment* env, | ||
| 48 | + const ncrypto::SSLPointer& ssl); | ||
| 48 | 49 | ||
| 49 | - v8::MaybeLocal<v8::Value> GetPeerCert( | ||
| 50 | - Environment* env, | ||
| 51 | - const SSLPointer& ssl, | ||
| 52 | - bool abbreviated = false, | ||
| 53 | - bool is_server = false); | ||
| 50 | + v8::MaybeLocal<v8::Value> GetPeerCert(Environment* env, | ||
| 51 | + const ncrypto::SSLPointer& ssl, | ||
| 52 | + bool abbreviated = false, | ||
| 53 | + bool is_server = false); | ||
| 54 | 54 | ||
| 55 | 55 | v8::MaybeLocal<v8::Object> ECPointToBuffer( | |
| 56 | 56 | Environment* env, | |
@@ -60,9 +60,9 @@ v8::MaybeLocal<v8::Object> ECPointToBuffer( | |||
| 60 | 60 | const char** error); | |
| 61 | 61 | ||
| 62 | 62 | v8::MaybeLocal<v8::Value> GetCurrentCipherName(Environment* env, | |
| 63 | - const SSLPointer& ssl); | ||
| 64 | - v8::MaybeLocal<v8::Value> GetCurrentCipherVersion(Environment* env, | ||
| 65 | - const SSLPointer& ssl); | ||
| 63 | + const ncrypto::SSLPointer& ssl); | ||
| 64 | + v8::MaybeLocal<v8::Value> GetCurrentCipherVersion( | ||
| 65 | + Environment* env, const ncrypto::SSLPointer& ssl); | ||
| 66 | 66 | ||
| 67 | 67 | } // namespace crypto | |
| 68 | 68 | } // namespace node | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -21,7 +21,17 @@ | |||
| 21 | 21 | ||
| 22 | 22 | namespace node { | |
| 23 | 23 | ||
| 24 | + using ncrypto::BignumPointer; | ||
| 25 | + using ncrypto::BIOPointer; | ||
| 26 | + using ncrypto::ClearErrorOnReturn; | ||
| 27 | + using ncrypto::CryptoErrorList; | ||
| 28 | + using ncrypto::DHPointer; | ||
| 29 | + using ncrypto::EnginePointer; | ||
| 30 | + using ncrypto::EVPKeyPointer; | ||
| 31 | + using ncrypto::MarkPopErrorOnReturn; | ||
| 32 | + using ncrypto::SSLPointer; | ||
| 24 | 33 | using ncrypto::StackOfX509; | |
| 34 | + using ncrypto::X509Pointer; | ||
| 25 | 35 | using v8::Array; | |
| 26 | 36 | using v8::ArrayBufferView; | |
| 27 | 37 | using v8::Boolean; | |
@@ -693,10 +703,10 @@ void SecureContext::SetEngineKey(const FunctionCallbackInfo<Value>& args) { | |||
| 693 | 703 | "experimental permission model is enabled"); | |
| 694 | 704 | } | |
| 695 | 705 | ||
| 696 | - ncrypto::CryptoErrorList errors; | ||
| 706 | + CryptoErrorList errors; | ||
| 697 | 707 | Utf8Value engine_id(env->isolate(), args[1]); | |
| 698 | - auto engine = ncrypto::EnginePointer::getEngineByName( | ||
| 699 | - engine_id.ToStringView(), &errors); | ||
| 708 | + auto engine = | ||
| 709 | + EnginePointer::getEngineByName(engine_id.ToStringView(), &errors); | ||
| 700 | 710 | if (!engine) { | |
| 701 | 711 | Local<Value> exception; | |
| 702 | 712 | if (errors.empty()) { | |
@@ -1205,10 +1215,10 @@ void SecureContext::SetClientCertEngine( | |||
| 1205 | 1215 | "experimental permission model is enabled"); | |
| 1206 | 1216 | } | |
| 1207 | 1217 | ||
| 1208 | - ncrypto::CryptoErrorList errors; | ||
| 1218 | + CryptoErrorList errors; | ||
| 1209 | 1219 | const Utf8Value engine_id(env->isolate(), args[0]); | |
| 1210 | - auto engine = ncrypto::EnginePointer::getEngineByName( | ||
| 1211 | - engine_id.ToStringView(), &errors); | ||
| 1220 | + auto engine = | ||
| 1221 | + EnginePointer::getEngineByName(engine_id.ToStringView(), &errors); | ||
| 1212 | 1222 | if (!engine) { | |
| 1213 | 1223 | Local<Value> exception; | |
| 1214 | 1224 | if (errors.empty()) { | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -23,7 +23,7 @@ X509_STORE* NewRootCertStore(); | |||
| 23 | 23 | ||
| 24 | 24 | X509_STORE* GetOrCreateRootCertStore(); | |
| 25 | 25 | ||
| 26 | - BIOPointer LoadBIO(Environment* env, v8::Local<v8::Value> v); | ||
| 26 | + ncrypto::BIOPointer LoadBIO(Environment* env, v8::Local<v8::Value> v); | ||
| 27 | 27 | ||
| 28 | 28 | class SecureContext final : public BaseObject { | |
| 29 | 29 | public: | |
@@ -41,27 +41,27 @@ class SecureContext final : public BaseObject { | |||
| 41 | 41 | static void RegisterExternalReferences(ExternalReferenceRegistry* registry); | |
| 42 | 42 | static SecureContext* Create(Environment* env); | |
| 43 | 43 | ||
| 44 | - const SSLCtxPointer& ctx() const { return ctx_; } | ||
| 44 | + const ncrypto::SSLCtxPointer& ctx() const { return ctx_; } | ||
| 45 | 45 | ||
| 46 | 46 | // Non-const ctx() that allows for non-default initialization of | |
| 47 | 47 | // the SecureContext. | |
| 48 | - SSLCtxPointer& ctx() { return ctx_; } | ||
| 48 | + ncrypto::SSLCtxPointer& ctx() { return ctx_; } | ||
| 49 | 49 | ||
| 50 | - SSLPointer CreateSSL(); | ||
| 50 | + ncrypto::SSLPointer CreateSSL(); | ||
| 51 | 51 | ||
| 52 | 52 | void SetGetSessionCallback(GetSessionCb cb); | |
| 53 | 53 | void SetKeylogCallback(KeylogCb cb); | |
| 54 | 54 | void SetNewSessionCallback(NewSessionCb cb); | |
| 55 | 55 | void SetSelectSNIContextCallback(SelectSNIContextCb cb); | |
| 56 | 56 | ||
| 57 | - inline const X509Pointer& issuer() const { return issuer_; } | ||
| 58 | - inline const X509Pointer& cert() const { return cert_; } | ||
| 57 | + inline const ncrypto::X509Pointer& issuer() const { return issuer_; } | ||
| 58 | + inline const ncrypto::X509Pointer& cert() const { return cert_; } | ||
| 59 | 59 | ||
| 60 | - v8::Maybe<void> AddCert(Environment* env, BIOPointer&& bio); | ||
| 61 | - v8::Maybe<void> SetCRL(Environment* env, const BIOPointer& bio); | ||
| 60 | + v8::Maybe<void> AddCert(Environment* env, ncrypto::BIOPointer&& bio); | ||
| 61 | + v8::Maybe<void> SetCRL(Environment* env, const ncrypto::BIOPointer& bio); | ||
| 62 | 62 | v8::Maybe<void> UseKey(Environment* env, const KeyObjectData& key); | |
| 63 | 63 | ||
| 64 | - void SetCACert(const BIOPointer& bio); | ||
| 64 | + void SetCACert(const ncrypto::BIOPointer& bio); | ||
| 65 | 65 | void SetRootCerts(); | |
| 66 | 66 | ||
| 67 | 67 | void SetX509StoreFlag(unsigned long flags); // NOLINT(runtime/int) | |
@@ -144,9 +144,9 @@ class SecureContext final : public BaseObject { | |||
| 144 | 144 | void Reset(); | |
| 145 | 145 | ||
| 146 | 146 | private: | |
| 147 | - SSLCtxPointer ctx_; | ||
| 148 | - X509Pointer cert_; | ||
| 149 | - X509Pointer issuer_; | ||
| 147 | + ncrypto::SSLCtxPointer ctx_; | ||
| 148 | + ncrypto::X509Pointer cert_; | ||
| 149 | + ncrypto::X509Pointer issuer_; | ||
| 150 | 150 | // Non-owning cache for SSL_CTX_get_cert_store(ctx_.get()) | |
| 151 | 151 | X509_STORE* own_cert_store_cache_ = nullptr; | |
| 152 | 152 | #ifndef OPENSSL_NO_ENGINE | |
@@ -160,9 +160,9 @@ class SecureContext final : public BaseObject { | |||
| 160 | 160 | }; | |
| 161 | 161 | ||
| 162 | 162 | int SSL_CTX_use_certificate_chain(SSL_CTX* ctx, | |
| 163 | - BIOPointer&& in, | ||
| 164 | - X509Pointer* cert, | ||
| 165 | - X509Pointer* issuer); | ||
| 163 | + ncrypto::BIOPointer&& in, | ||
| 164 | + ncrypto::X509Pointer* cert, | ||
| 165 | + ncrypto::X509Pointer* issuer); | ||
| 166 | 166 | ||
| 167 | 167 | } // namespace crypto | |
| 168 | 168 | } // namespace node | |
| Back | FazBrowse Home | New Git URL |
0 commit comments