lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8964 Commits
131 Branches
446 Tags
325 MiB
Tree: d66d840e3b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd66d840e3b'
${ noResults }
node/src/node_crypto.cc

3590 lines
101 KiB
Raw Normal View History

Update copyright headers
14 years ago
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include "node.h"
#include "node_buffer.h"
core: use proper #include directives
13 years ago
#include "node_crypto.h"
crypto: use better memory BIO implementation
12 years ago
#include "node_crypto_bio.h"
core: use proper #include directives
13 years ago
#include "node_crypto_groups.h"
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include "node_root_certs.h"
Initial openssl support for net2
15 years ago
crypto: Pass strings to binding layer directly
12 years ago
#include "string_bytes.h"
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include "v8.h"
Initial openssl support for net2
15 years ago
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include <errno.h>
#include <stdlib.h>
Revert &#34;Check for strings.h&#34; This reverts commit 032f651824869c429cc24fbd9f7a23e84ed34b1f.
15 years ago
#include <string.h>
src: more lint after cpplint tightening Commit 847c6d9 adds a &#39;project headers before system headers&#39; check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#if defined(_MSC_VER)
Upgrade to 0.9.8r. Build in Win32.
14 years ago
#define strcasecmp _stricmp
#endif
Compile for beta versions of OpenSSL 1.0.0
15 years ago
#if OPENSSL_VERSION_NUMBER >= 0x10000000L
src: more lint after cpplint tightening Commit 847c6d9 adds a &#39;project headers before system headers&#39; check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#define OPENSSL_CONST const
openssl 1.0.0 constification
15 years ago
#else
src: more lint after cpplint tightening Commit 847c6d9 adds a &#39;project headers before system headers&#39; check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#define OPENSSL_CONST
openssl 1.0.0 constification
15 years ago
#endif
src: wrap macros in `do {...} while (0)` Wrapped two macros in do {...} while (0) blocks and lined up backslashes. Uses up semicolon in contexts where a dangling semicolon is erroneous.
12 years ago
#define ASSERT_IS_STRING_OR_BUFFER(val) do { \
if (!Buffer::HasInstance(val) && !val->IsString()) { \
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Not a string or buffer"); \
src: wrap macros in `do {...} while (0)` Wrapped two macros in do {...} while (0) blocks and lined up backslashes. Uses up semicolon in contexts where a dangling semicolon is erroneous.
12 years ago
} \
} while (0)
crypto: Pass strings to binding layer directly
12 years ago
src: wrap macros in `do {...} while (0)` Wrapped two macros in do {...} while (0) blocks and lined up backslashes. Uses up semicolon in contexts where a dangling semicolon is erroneous.
12 years ago
#define ASSERT_IS_BUFFER(val) do { \
if (!Buffer::HasInstance(val)) { \
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Not a buffer"); \
src: wrap macros in `do {...} while (0)` Wrapped two macros in do {...} while (0) blocks and lined up backslashes. Uses up semicolon in contexts where a dangling semicolon is erroneous.
12 years ago
} \
} while (0)
Crypto update should only accept strings / buffers I have seen a lot of people trying to pass objects to crypto&#39;s update functions, assuming that it would somehow serialize the object before hashing. In reality, the object was converted to &#39;[object Object]&#39; which was then hashed, without any error message showing. This patch modifies the DecodeBytes function (used exclusively by crypto at this point) to complain when receiving anything but a string or buffer. Overall this should be a less-suprising, more robust behavior.
14 years ago
crypto: add support for RSA public key signing/verification
13 years ago
static const char PUBLIC_KEY_PFX[] = "-----BEGIN PUBLIC KEY-----";
static const int PUBLIC_KEY_PFX_LEN = sizeof(PUBLIC_KEY_PFX) - 1;
static const char PUBRSA_KEY_PFX[] = "-----BEGIN RSA PUBLIC KEY-----";
static const int PUBRSA_KEY_PFX_LEN = sizeof(PUBRSA_KEY_PFX) - 1;
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
static const int X509_NAME_FLAGS = ASN1_STRFLGS_ESC_CTRL
| ASN1_STRFLGS_ESC_MSB
| XN_FLAG_SEP_MULTILINE
| XN_FLAG_FN_SN;
Initial openssl support for net2
15 years ago
namespace node {
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
namespace crypto {
Initial openssl support for net2
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
using v8::Array;
using v8::Exception;
using v8::False;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
string_bytes: don&#39;t use named imports in header It imports the definition into every source file that includes string_bytes.h, as evidenced by the build suddenly breaking left and right because of missing Handle/Local/String/Value imports.
12 years ago
using v8::Handle;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
using v8::HandleScope;
using v8::Integer;
using v8::Local;
using v8::Null;
using v8::Object;
using v8::Persistent;
using v8::String;
using v8::ThrowException;
string_bytes: don&#39;t use named imports in header It imports the definition into every source file that includes string_bytes.h, as evidenced by the build suddenly breaking left and right because of missing Handle/Local/String/Value imports.
12 years ago
using v8::Value;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
Initial openssl support for net2
15 years ago
crypto: Clear error after DiffieHellman key errors Fixes #5499
12 years ago
// Forcibly clear OpenSSL's error stack on return. This stops stale errors
// from popping up later in the lifecycle of crypto operations where they
// would cause spurious failures. It's a rather blunt method, though.
// ERR_clear_error() isn't necessarily cheap either.
struct ClearErrorOnReturn {
~ClearErrorOnReturn() { ERR_clear_error(); }
};
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static Cached<String> subject_symbol;
static Cached<String> subjectaltname_symbol;
static Cached<String> modulus_symbol;
static Cached<String> exponent_symbol;
static Cached<String> issuer_symbol;
static Cached<String> valid_from_symbol;
static Cached<String> valid_to_symbol;
static Cached<String> fingerprint_symbol;
static Cached<String> name_symbol;
static Cached<String> version_symbol;
static Cached<String> ext_key_usage_symbol;
static Cached<String> onhandshakestart_sym;
static Cached<String> onhandshakedone_sym;
static Cached<String> onclienthello_sym;
static Cached<String> onnewsession_sym;
static Cached<String> sessionid_sym;
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
static Persistent<FunctionTemplate> secure_context_constructor;
static uv_rwlock_t* locks;
Initial openssl support for net2
15 years ago
crypto: use CRYPTO_THREADID_set_callback() Don&#39;t use CRYPTO_set_id_callback(), it&#39;s deprecated.
13 years ago
static void crypto_threadid_cb(CRYPTO_THREADID* tid) {
crypto: use uv_thread_self()
12 years ago
CRYPTO_THREADID_set_numeric(tid, uv_thread_self());
crypto: use the libuv rwlock API
13 years ago
}
crypto: make module thread-safe
13 years ago
static void crypto_lock_init(void) {
int i, n;
n = CRYPTO_num_locks();
crypto: use the libuv rwlock API
13 years ago
locks = new uv_rwlock_t[n];
crypto: make module thread-safe
13 years ago
for (i = 0; i < n; i++)
crypto: use the libuv rwlock API
13 years ago
if (uv_rwlock_init(locks + i))
crypto: make module thread-safe
13 years ago
abort();
}
static void crypto_lock_cb(int mode, int n, const char* file, int line) {
crypto: use the libuv rwlock API
13 years ago
assert((mode & CRYPTO_LOCK) || (mode & CRYPTO_UNLOCK));
assert((mode & CRYPTO_READ) || (mode & CRYPTO_WRITE));
crypto: make module thread-safe
13 years ago
if (mode & CRYPTO_LOCK) {
crypto: use the libuv rwlock API
13 years ago
if (mode & CRYPTO_READ)
uv_rwlock_rdlock(locks + n);
else
uv_rwlock_wrlock(locks + n);
crypto: make module thread-safe
13 years ago
} else {
crypto: use the libuv rwlock API
13 years ago
if (mode & CRYPTO_READ)
uv_rwlock_rdunlock(locks + n);
else
uv_rwlock_wrunlock(locks + n);
crypto: make module thread-safe
13 years ago
}
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void ThrowCryptoErrorHelper(unsigned long err, bool is_type_error) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: improve cipher/decipher error messages Throw the OpenSSL error string instead of the rather less informative error message &#34;fail&#34;.
12 years ago
char errmsg[128];
ERR_error_string_n(err, errmsg, sizeof(errmsg));
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (is_type_error)
ThrowTypeError(errmsg);
else
ThrowError(errmsg);
crypto: improve cipher/decipher error messages Throw the OpenSSL error string instead of the rather less informative error message &#34;fail&#34;.
12 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void ThrowCryptoError(unsigned long err) {
ThrowCryptoErrorHelper(err, false);
crypto: improve cipher/decipher error messages Throw the OpenSSL error string instead of the rather less informative error message &#34;fail&#34;.
12 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void ThrowCryptoTypeError(unsigned long err) {
ThrowCryptoErrorHelper(err, true);
crypto: improve cipher/decipher error messages Throw the OpenSSL error string instead of the rather less informative error message &#34;fail&#34;.
12 years ago
}
crypto: make module thread-safe
13 years ago
Initial openssl support for net2
15 years ago
void SecureContext::Initialize(Handle<Object> target) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
Local<FunctionTemplate> t = FunctionTemplate::New(SecureContext::New);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
secure_context_constructor.Reset(node_isolate, t);
Add support for TLS SNI Fixes #1411
14 years ago
Initial openssl support for net2
15 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "SecureContext"));
Initial openssl support for net2
15 years ago
NODE_SET_PROTOTYPE_METHOD(t, "init", SecureContext::Init);
NODE_SET_PROTOTYPE_METHOD(t, "setKey", SecureContext::SetKey);
NODE_SET_PROTOTYPE_METHOD(t, "setCert", SecureContext::SetCert);
NODE_SET_PROTOTYPE_METHOD(t, "addCACert", SecureContext::AddCACert);
TLS: CRL support Needs more tests.
14 years ago
NODE_SET_PROTOTYPE_METHOD(t, "addCRL", SecureContext::AddCRL);
Move root certs out of JavaScript
14 years ago
NODE_SET_PROTOTYPE_METHOD(t, "addRootCerts", SecureContext::AddRootCerts);
Initial openssl support for net2
15 years ago
NODE_SET_PROTOTYPE_METHOD(t, "setCiphers", SecureContext::SetCiphers);
TLS: Add secureOptions flag Also, secureOptions flag was added (and passed through) and allows the context to have all supported SSL_OP_* set via createCredentials. All SSL_OP_ flags (outside of ALL) have been added to constants.
14 years ago
NODE_SET_PROTOTYPE_METHOD(t, "setOptions", SecureContext::SetOptions);
tls: requestCert unusable with Firefox and Chrome Fixes #1516.
13 years ago
NODE_SET_PROTOTYPE_METHOD(t, "setSessionIdContext",
SecureContext::SetSessionIdContext);
tls: expose SSL_CTX_set_timeout via tls.createServer Add the `sessionTimeout` integral value to the list of options recognized by `tls.createServer`. This option will be useful for applications which need frequently establish short-lived TLS connections to the same endpoint. The TLS tickets RFC is an ideal option to reduce the socket setup overhead for such scenarios, but the default ticket timeout value (5 minutes) is too low to be useful.
12 years ago
NODE_SET_PROTOTYPE_METHOD(t, "setSessionTimeout",
SecureContext::SetSessionTimeout);
Initial openssl support for net2
15 years ago
NODE_SET_PROTOTYPE_METHOD(t, "close", SecureContext::Close);
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
NODE_SET_PROTOTYPE_METHOD(t, "loadPKCS12", SecureContext::LoadPKCS12);
tls: share tls tickets key between cluster workers fix #5871
12 years ago
NODE_SET_PROTOTYPE_METHOD(t, "getTicketKeys", SecureContext::GetTicketKeys);
NODE_SET_PROTOTYPE_METHOD(t, "setTicketKeys", SecureContext::SetTicketKeys);
Initial openssl support for net2
15 years ago
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "SecureContext"),
t->GetFunction());
Initial openssl support for net2
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::New(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
SecureContext *p = new SecureContext();
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
p->Wrap(args.This());
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::Init(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
Initial openssl support for net2
15 years ago
Revert &#34;Default to TLSv1&#34; This reverts commit 97970b05fe37c0a0313c5e0cb2f13be9e15199a3.
14 years ago
OPENSSL_CONST SSL_METHOD *method = SSLv23_method();
Initial openssl support for net2
15 years ago
style
14 years ago
if (args.Length() == 1 && args[0]->IsString()) {
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value sslmethod(args[0]);
style
14 years ago
if (strcmp(*sslmethod, "SSLv2_method") == 0) {
Option to disable SSL v2 Fixes #880
14 years ago
#ifndef OPENSSL_NO_SSL2
Initial openssl support for net2
15 years ago
method = SSLv2_method();
Option to disable SSL v2 Fixes #880
14 years ago
#else
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("SSLv2 methods disabled");
Option to disable SSL v2 Fixes #880
14 years ago
#endif
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv2_server_method") == 0) {
Option to disable SSL v2 Fixes #880
14 years ago
#ifndef OPENSSL_NO_SSL2
Initial openssl support for net2
15 years ago
method = SSLv2_server_method();
Option to disable SSL v2 Fixes #880
14 years ago
#else
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("SSLv2 methods disabled");
Option to disable SSL v2 Fixes #880
14 years ago
#endif
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv2_client_method") == 0) {
Option to disable SSL v2 Fixes #880
14 years ago
#ifndef OPENSSL_NO_SSL2
Initial openssl support for net2
15 years ago
method = SSLv2_client_method();
Option to disable SSL v2 Fixes #880
14 years ago
#else
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("SSLv2 methods disabled");
Option to disable SSL v2 Fixes #880
14 years ago
#endif
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv3_method") == 0) {
Initial openssl support for net2
15 years ago
method = SSLv3_method();
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv3_server_method") == 0) {
Initial openssl support for net2
15 years ago
method = SSLv3_server_method();
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv3_client_method") == 0) {
Initial openssl support for net2
15 years ago
method = SSLv3_client_method();
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv23_method") == 0) {
Initial openssl support for net2
15 years ago
method = SSLv23_method();
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv23_server_method") == 0) {
Initial openssl support for net2
15 years ago
method = SSLv23_server_method();
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv23_client_method") == 0) {
Initial openssl support for net2
15 years ago
method = SSLv23_client_method();
style
14 years ago
} else if (strcmp(*sslmethod, "TLSv1_method") == 0) {
Initial openssl support for net2
15 years ago
method = TLSv1_method();
style
14 years ago
} else if (strcmp(*sslmethod, "TLSv1_server_method") == 0) {
Initial openssl support for net2
15 years ago
method = TLSv1_server_method();
style
14 years ago
} else if (strcmp(*sslmethod, "TLSv1_client_method") == 0) {
Initial openssl support for net2
15 years ago
method = TLSv1_client_method();
style
14 years ago
} else {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("Unknown method");
style
14 years ago
}
Initial openssl support for net2
15 years ago
}
Fix style in node_crypto.cc
14 years ago
sc->ctx_ = SSL_CTX_new(method);
tls: async session storage
13 years ago
// SSL session cache configuration
SSL_CTX_set_session_cache_mode(sc->ctx_,
SSL_SESS_CACHE_SERVER |
SSL_SESS_CACHE_NO_INTERNAL |
SSL_SESS_CACHE_NO_AUTO_CLEAR);
SSL_CTX_sess_set_get_cb(sc->ctx_, GetSessionCallback);
SSL_CTX_sess_set_new_cb(sc->ctx_, NewSessionCallback);
Initial openssl support for net2
15 years ago
Don&#39;t load root certs for each SSL context
14 years ago
sc->ca_store_ = NULL;
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
tls: async session storage
13 years ago
SSL_SESSION* SecureContext::GetSessionCallback(SSL* s,
unsigned char* key,
int len,
int* copy) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
tls: async session storage
13 years ago
Connection* p = static_cast<Connection*>(SSL_get_app_data(s));
*copy = 0;
SSL_SESSION* sess = p->next_sess_;
p->next_sess_ = NULL;
return sess;
}
int SecureContext::NewSessionCallback(SSL* s, SSL_SESSION* sess) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
tls: async session storage
13 years ago
Connection* p = static_cast<Connection*>(SSL_get_app_data(s));
// Check if session is small enough to be stored
int size = i2d_SSL_SESSION(sess, NULL);
if (size > kMaxSessionSize) return 0;
// Serialize session
char* serialized = new char[size];
unsigned char* pserialized = reinterpret_cast<unsigned char*>(serialized);
memset(serialized, 0, size);
i2d_SSL_SESSION(sess, &pserialized);
Handle<Value> argv[2] = {
Buffer::New(reinterpret_cast<char*>(sess->session_id),
buffer: use smalloc as backing data store Memory allocations are now done through smalloc. The Buffer cc class has been removed completely, but for backwards compatibility have left the namespace as Buffer. The .parent attribute is only set if the Buffer is a slice of an allocation. Which is then set to the alloc object (not a Buffer). The .offset attribute is now a ReadOnly set to 0, for backwards compatibility. I&#39;d like to remove it in the future (pre v1.0). A few alterations have been made to how arguments are either coerced or thrown. All primitives will now be coerced to their respective values, and (most) all out of range index requests will throw. The indexes that are coerced were left for backwards compatibility. For example: Buffer slice operates more like Array slice, and coerces instead of throwing out of range indexes. This may change in the future. The reason for wanting to throw for out of range indexes is because giving js access to raw memory has high potential risk. To mitigate that it&#39;s easier to make sure the developer is always quickly alerted to the fact that their code is attempting to access beyond memory bounds. Because SlowBuffer will be deprecated, and simply returns a new Buffer instance, all tests on SlowBuffer have been removed. Heapdumps will now show usage under &#34;smalloc&#34; instead of &#34;Buffer&#34;. ParseArrayIndex was added to node_internals to support proper uint argument checking/coercion for external array data indexes. SlabAllocator had to be updated since handle_ no longer exists.
12 years ago
sess->session_id_length),
Buffer::Use(serialized, size)
tls: async session storage
13 years ago
};
if (onnewsession_sym.IsEmpty()) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
onnewsession_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onnewsession");
tls: async session storage
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
MakeCallback(p->handle(node_isolate),
onnewsession_sym,
ARRAY_SIZE(argv),
argv);
tls: async session storage
13 years ago
return 0;
}
Accept Buffers as well as strings for addCert, addKey
14 years ago
// Takes a string or buffer and loads it into a BIO.
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
// Caller responsible for BIO_free_all-ing the returned object.
src: lint c++ code
12 years ago
static BIO* LoadBIO(Handle<Value> v) {
crypto: use better memory BIO implementation
12 years ago
BIO *bio = BIO_new(NodeBIO::GetMethod());
Accept Buffers as well as strings for addCert, addKey
14 years ago
if (!bio) return NULL;
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
crypto: fix read of potentially uninitialized variable
13 years ago
int r = -1;
Initial openssl support for net2
15 years ago
Accept Buffers as well as strings for addCert, addKey
14 years ago
if (v->IsString()) {
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value s(v);
Accept Buffers as well as strings for addCert, addKey
14 years ago
r = BIO_write(bio, *s, s.length());
} else if (Buffer::HasInstance(v)) {
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
char* buffer_data = Buffer::Data(v);
crypto: Remove many unnecessary toObjects
12 years ago
size_t buffer_length = Buffer::Length(v);
Accept Buffers as well as strings for addCert, addKey
14 years ago
r = BIO_write(bio, buffer_data, buffer_length);
}
if (r <= 0) {
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bio);
Accept Buffers as well as strings for addCert, addKey
14 years ago
return NULL;
Initial openssl support for net2
15 years ago
}
Accept Buffers as well as strings for addCert, addKey
14 years ago
return bio;
}
Fix style in node_crypto.cc
14 years ago
Accept Buffers as well as strings for addCert, addKey
14 years ago
// Takes a string or buffer and loads it into an X509
// Caller responsible for X509_free-ing the returned object.
src: lint c++ code
12 years ago
static X509* LoadX509(Handle<Value> v) {
HandleScope scope(node_isolate);
Accept Buffers as well as strings for addCert, addKey
14 years ago
BIO *bio = LoadBIO(v);
if (!bio) return NULL;
X509 * x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
if (!x509) {
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bio);
Accept Buffers as well as strings for addCert, addKey
14 years ago
return NULL;
Fix style in node_crypto.cc
14 years ago
}
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bio);
Accept Buffers as well as strings for addCert, addKey
14 years ago
return x509;
}
Initial openssl support for net2
15 years ago
Accept Buffers as well as strings for addCert, addKey
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::SetKey(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Accept Buffers as well as strings for addCert, addKey
14 years ago
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
Accept Buffers as well as strings for addCert, addKey
14 years ago
tls, https: add passphrase option Fixes #1925.
13 years ago
unsigned int len = args.Length();
if (len != 1 && len != 2) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad parameter");
tls, https: add passphrase option Fixes #1925.
13 years ago
}
if (len == 2 && !args[1]->IsString()) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad parameter");
Accept Buffers as well as strings for addCert, addKey
14 years ago
}
BIO *bio = LoadBIO(args[0]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (!bio) return;
Accept Buffers as well as strings for addCert, addKey
14 years ago
Avoiding unnecessary ToString() calls String::Utf8Value and String::AsciiValue constructors take Handle&lt;Value&gt; So no need to convert to Handle&lt;String&gt;
13 years ago
String::Utf8Value passphrase(args[1]);
tls, https: add passphrase option Fixes #1925.
13 years ago
EVP_PKEY* key = PEM_read_bio_PrivateKey(bio, NULL, NULL,
len == 1 ? NULL : *passphrase);
Accept Buffers as well as strings for addCert, addKey
14 years ago
if (!key) {
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bio);
crypto: fix error reporting in SetKey()
13 years ago
unsigned long err = ERR_get_error();
if (!err) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("PEM_read_bio_PrivateKey");
crypto: fix error reporting in SetKey()
13 years ago
}
crypto: improve cipher/decipher error messages Throw the OpenSSL error string instead of the rather less informative error message &#34;fail&#34;.
12 years ago
return ThrowCryptoError(err);
Fix style in node_crypto.cc
14 years ago
}
Initial openssl support for net2
15 years ago
Accept Buffers as well as strings for addCert, addKey
14 years ago
SSL_CTX_use_PrivateKey(sc->ctx_, key);
Free (ref-counted) private key.
14 years ago
EVP_PKEY_free(key);
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bio);
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
TLS: handle cert chains
14 years ago
// Read a file that contains our certificate in "PEM" format,
// possibly followed by a sequence of CA certificates that should be
// sent to the peer in the Certificate message.
//
// Taken from OpenSSL - editted for style.
int SSL_CTX_use_certificate_chain(SSL_CTX *ctx, BIO *in) {
int ret = 0;
X509 *x = NULL;
x = PEM_read_bio_X509_AUX(in, NULL, NULL, NULL);
if (x == NULL) {
SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE, ERR_R_PEM_LIB);
goto end;
}
ret = SSL_CTX_use_certificate(ctx, x);
if (ERR_peek_error() != 0) {
// Key/certificate mismatch doesn't imply ret==0 ...
ret = 0;
}
if (ret) {
// If we could set up our certificate, now proceed to
// the CA certificates.
X509 *ca;
int r;
unsigned long err;
if (ctx->extra_certs != NULL) {
sk_X509_pop_free(ctx->extra_certs, X509_free);
ctx->extra_certs = NULL;
}
while ((ca = PEM_read_bio_X509(in, NULL, NULL, NULL))) {
r = SSL_CTX_add_extra_chain_cert(ctx, ca);
if (!r) {
X509_free(ca);
ret = 0;
goto end;
}
// Note that we must not free r if it was successfully
// added to the chain (while we must free the main
// certificate, since its reference count is increased
// by SSL_CTX_use_certificate).
}
// When the while loop ends, it's usually just EOF.
err = ERR_peek_last_error();
if (ERR_GET_LIB(err) == ERR_LIB_PEM &&
ERR_GET_REASON(err) == PEM_R_NO_START_LINE) {
ERR_clear_error();
} else {
// some real error
ret = 0;
}
}
src: lint c++ code
12 years ago
end:
TLS: handle cert chains
14 years ago
if (x != NULL) X509_free(x);
return ret;
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::SetCert(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
Initial openssl support for net2
15 years ago
Accept Buffers as well as strings for addCert, addKey
14 years ago
if (args.Length() != 1) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad parameter");
Initial openssl support for net2
15 years ago
}
Fix style in node_crypto.cc
14 years ago
TLS: handle cert chains
14 years ago
BIO* bio = LoadBIO(args[0]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (!bio) return;
Fix style in node_crypto.cc
14 years ago
TLS: handle cert chains
14 years ago
int rv = SSL_CTX_use_certificate_chain(sc->ctx_, bio);
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bio);
TLS: handle cert chains
14 years ago
if (!rv) {
unsigned long err = ERR_get_error();
if (!err) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("SSL_CTX_use_certificate_chain");
TLS: handle cert chains
14 years ago
}
crypto: improve cipher/decipher error messages Throw the OpenSSL error string instead of the rather less informative error message &#34;fail&#34;.
12 years ago
return ThrowCryptoError(err);
TLS: handle cert chains
14 years ago
}
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::AddCACert(const FunctionCallbackInfo<Value>& args) {
Don&#39;t load root certs for each SSL context
14 years ago
bool newCAStore = false;
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
Initial openssl support for net2
15 years ago
Accept Buffers as well as strings for addCert, addKey
14 years ago
if (args.Length() != 1) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad parameter");
Initial openssl support for net2
15 years ago
}
Don&#39;t load root certs for each SSL context
14 years ago
if (!sc->ca_store_) {
sc->ca_store_ = X509_STORE_new();
newCAStore = true;
}
Accept Buffers as well as strings for addCert, addKey
14 years ago
X509* x509 = LoadX509(args[0]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (!x509) return;
Initial openssl support for net2
15 years ago
Fix style in node_crypto.cc
14 years ago
X509_STORE_add_cert(sc->ca_store_, x509);
without this the server will not advertise support for client certs Closes GH-774.
14 years ago
SSL_CTX_add_client_CA(sc->ctx_, x509);
Initial openssl support for net2
15 years ago
X509_free(x509);
Don&#39;t load root certs for each SSL context
14 years ago
if (newCAStore) {
SSL_CTX_set_cert_store(sc->ctx_, sc->ca_store_);
}
Initial openssl support for net2
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::AddCRL(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
TLS: CRL support Needs more tests.
14 years ago
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
TLS: CRL support Needs more tests.
14 years ago
if (args.Length() != 1) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad parameter");
TLS: CRL support Needs more tests.
14 years ago
}
crypto: clear error on return in AddCRL
12 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence compiler warning.
TLS: CRL support Needs more tests.
14 years ago
BIO *bio = LoadBIO(args[0]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (!bio) return;
TLS: CRL support Needs more tests.
14 years ago
X509_CRL *x509 = PEM_read_bio_X509_CRL(bio, NULL, NULL, NULL);
if (x509 == NULL) {
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bio);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return;
TLS: CRL support Needs more tests.
14 years ago
}
X509_STORE_add_crl(sc->ca_store_, x509);
X509_STORE_set_flags(sc->ca_store_, X509_V_FLAG_CRL_CHECK |
X509_V_FLAG_CRL_CHECK_ALL);
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bio);
TLS: CRL support Needs more tests.
14 years ago
X509_CRL_free(x509);
}
Don&#39;t load root certs for each SSL context
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::AddRootCerts(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Move root certs out of JavaScript
14 years ago
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
Move root certs out of JavaScript
14 years ago
Don&#39;t load root certs for each SSL context
14 years ago
assert(sc->ca_store_ == NULL);
Move root certs out of JavaScript
14 years ago
Don&#39;t load root certs for each SSL context
14 years ago
if (!root_cert_store) {
root_cert_store = X509_STORE_new();
Move root certs out of JavaScript
14 years ago
Don&#39;t load root certs for each SSL context
14 years ago
for (int i = 0; root_certs[i]; i++) {
crypto: use better memory BIO implementation
12 years ago
BIO *bp = BIO_new(NodeBIO::GetMethod());
Move root certs out of JavaScript
14 years ago
Don&#39;t load root certs for each SSL context
14 years ago
if (!BIO_write(bp, root_certs[i], strlen(root_certs[i]))) {
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bp);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return;
Don&#39;t load root certs for each SSL context
14 years ago
}
Move root certs out of JavaScript
14 years ago
Don&#39;t load root certs for each SSL context
14 years ago
X509 *x509 = PEM_read_bio_X509(bp, NULL, NULL, NULL);
Move root certs out of JavaScript
14 years ago
Don&#39;t load root certs for each SSL context
14 years ago
if (x509 == NULL) {
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bp);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return;
Don&#39;t load root certs for each SSL context
14 years ago
}
X509_STORE_add_cert(root_cert_store, x509);
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bp);
Don&#39;t load root certs for each SSL context
14 years ago
X509_free(x509);
}
Move root certs out of JavaScript
14 years ago
}
Don&#39;t load root certs for each SSL context
14 years ago
sc->ca_store_ = root_cert_store;
SSL_CTX_set_cert_store(sc->ctx_, sc->ca_store_);
Move root certs out of JavaScript
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::SetCiphers(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
Initial openssl support for net2
15 years ago
Fix style in node_crypto.cc
14 years ago
if (args.Length() != 1 || !args[0]->IsString()) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad parameter");
Initial openssl support for net2
15 years ago
}
Fix style in node_crypto.cc
14 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value ciphers(args[0]);
Fix style in node_crypto.cc
14 years ago
SSL_CTX_set_cipher_list(sc->ctx_, *ciphers);
Initial openssl support for net2
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::SetOptions(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Revert &#34;crypto: add SecureContext.clearOptions() method&#34; API addition needs to go in master. Also openssl-0.9.8k doesn&#39;t have SSL_CTX_clear_options(). This reverts commit 6f8839d2ac362ced42235a34a023af5e2c656501.
13 years ago
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
Revert &#34;crypto: add SecureContext.clearOptions() method&#34; API addition needs to go in master. Also openssl-0.9.8k doesn&#39;t have SSL_CTX_clear_options(). This reverts commit 6f8839d2ac362ced42235a34a023af5e2c656501.
13 years ago
crypto: allow negative numbers in setOptions() OR&#39;ing together two large values, like `SSL_OP_ALL | SSL_OP_NO_TICKET`, produces a negative number. To wit: assert((0x80000000 | 0x4000) === -0x7fffc000); // true assert((0x80000000 | 0x4000) === 0x80004000); // false! It&#39;s easy to work around by doing a logical shift, like this: assert((0x80000000 | 0x4000) &gt;&gt;&gt; 0 === 0x80004000); // true But that&#39;s not very intuitive. Let&#39;s be more lenient in what we accept.
12 years ago
if (args.Length() != 1 || !args[0]->IntegerValue()) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad parameter");
TLS: Add secureOptions flag Also, secureOptions flag was added (and passed through) and allows the context to have all supported SSL_OP_* set via createCredentials. All SSL_OP_ flags (outside of ALL) have been added to constants.
14 years ago
}
crypto: allow negative numbers in setOptions() OR&#39;ing together two large values, like `SSL_OP_ALL | SSL_OP_NO_TICKET`, produces a negative number. To wit: assert((0x80000000 | 0x4000) === -0x7fffc000); // true assert((0x80000000 | 0x4000) === 0x80004000); // false! It&#39;s easy to work around by doing a logical shift, like this: assert((0x80000000 | 0x4000) &gt;&gt;&gt; 0 === 0x80004000); // true But that&#39;s not very intuitive. Let&#39;s be more lenient in what we accept.
12 years ago
SSL_CTX_set_options(sc->ctx_, args[0]->IntegerValue());
Revert &#34;crypto: add SecureContext.clearOptions() method&#34; API addition needs to go in master. Also openssl-0.9.8k doesn&#39;t have SSL_CTX_clear_options(). This reverts commit 6f8839d2ac362ced42235a34a023af5e2c656501.
13 years ago
}
Initial openssl support for net2
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::SetSessionIdContext(
const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
tls: requestCert unusable with Firefox and Chrome Fixes #1516.
13 years ago
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
tls: requestCert unusable with Firefox and Chrome Fixes #1516.
13 years ago
if (args.Length() != 1 || !args[0]->IsString()) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad parameter");
tls: requestCert unusable with Firefox and Chrome Fixes #1516.
13 years ago
}
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value sessionIdContext(args[0]);
const unsigned char* sid_ctx =
reinterpret_cast<const unsigned char*>(*sessionIdContext);
tls: requestCert unusable with Firefox and Chrome Fixes #1516.
13 years ago
unsigned int sid_ctx_len = sessionIdContext.length();
int r = SSL_CTX_set_session_id_context(sc->ctx_, sid_ctx, sid_ctx_len);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (r == 1) return;
BIO* bio;
BUF_MEM* mem;
Local<String> message;
bio = BIO_new(BIO_s_mem());
if (bio == NULL) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
message = FIXED_ONE_BYTE_STRING(node_isolate,
"SSL_CTX_set_session_id_context error");
src: lint c++ code
12 years ago
} else {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
ERR_print_errors(bio);
BIO_get_mem_ptr(bio, &mem);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
message = OneByteString(node_isolate, mem->data, mem->length);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
BIO_free_all(bio);
tls: requestCert unusable with Firefox and Chrome Fixes #1516.
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
ThrowException(Exception::TypeError(message));
tls: requestCert unusable with Firefox and Chrome Fixes #1516.
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::SetSessionTimeout(const FunctionCallbackInfo<Value>& args) {
src: add node_isolate to remaining scopes
12 years ago
HandleScope scope(node_isolate);
tls: expose SSL_CTX_set_timeout via tls.createServer Add the `sessionTimeout` integral value to the list of options recognized by `tls.createServer`. This option will be useful for applications which need frequently establish short-lived TLS connections to the same endpoint. The TLS tickets RFC is an ideal option to reduce the socket setup overhead for such scenarios, but the default ticket timeout value (5 minutes) is too low to be useful.
12 years ago
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
tls: expose SSL_CTX_set_timeout via tls.createServer Add the `sessionTimeout` integral value to the list of options recognized by `tls.createServer`. This option will be useful for applications which need frequently establish short-lived TLS connections to the same endpoint. The TLS tickets RFC is an ideal option to reduce the socket setup overhead for such scenarios, but the default ticket timeout value (5 minutes) is too low to be useful.
12 years ago
if (args.Length() != 1 || !args[0]->IsInt32()) {
return ThrowTypeError("Bad parameter");
}
int32_t sessionTimeout = args[0]->Int32Value();
SSL_CTX_set_timeout(sc->ctx_, sessionTimeout);
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::Close(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
Don&#39;t load root certs for each SSL context
14 years ago
sc->FreeCTXMem();
Initial openssl support for net2
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
src: lint c++ code
12 years ago
// Takes .pfx or .p12 and password in string or buffer format
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SecureContext::LoadPKCS12(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
BIO* in = NULL;
PKCS12* p12 = NULL;
EVP_PKEY* pkey = NULL;
X509* cert = NULL;
STACK_OF(X509)* extraCerts = NULL;
char* pass = NULL;
bool ret = false;
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.This());
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
if (args.Length() < 1) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad parameter");
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
}
in = LoadBIO(args[0]);
if (in == NULL) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("Unable to load BIO");
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
}
if (args.Length() >= 2) {
crypto: Binding only accepts buffers
12 years ago
ASSERT_IS_BUFFER(args[1]);
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
crypto: Remove many unnecessary toObjects
12 years ago
int passlen = Buffer::Length(args[1]);
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
if (passlen < 0) {
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(in);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad password");
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
}
pass = new char[passlen + 1];
int pass_written = DecodeWrite(pass, passlen, args[1], BINARY);
assert(pass_written == passlen);
pass[passlen] = '\0';
}
if (d2i_PKCS12_bio(in, &p12) &&
PKCS12_parse(p12, pass, &pkey, &cert, &extraCerts) &&
SSL_CTX_use_certificate(sc->ctx_, cert) &&
src: lint c++ code
12 years ago
SSL_CTX_use_PrivateKey(sc->ctx_, pkey)) {
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
// set extra certs
while (X509* x509 = sk_X509_pop(extraCerts)) {
if (!sc->ca_store_) {
sc->ca_store_ = X509_STORE_new();
SSL_CTX_set_cert_store(sc->ctx_, sc->ca_store_);
}
X509_STORE_add_cert(sc->ca_store_, x509);
SSL_CTX_add_client_CA(sc->ctx_, x509);
crypto: fix memory leak in LoadPKCS12 X509_STORE_add_cert increment reference of passed `x509` cert, `X509_free` must be called to avoid memory leak.
12 years ago
X509_free(x509);
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
}
EVP_PKEY_free(pkey);
X509_free(cert);
sk_X509_free(extraCerts);
ret = true;
}
PKCS12_free(p12);
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(in);
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
delete[] pass;
if (!ret) {
unsigned long err = ERR_get_error();
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
const char* str = ERR_reason_error_string(err);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError(str);
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
}
}
Don&#39;t load root certs for each SSL context
14 years ago
tls: share tls tickets key between cluster workers fix #5871
12 years ago
void SecureContext::GetTicketKeys(const FunctionCallbackInfo<Value>& args) {
#if !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_get_tlsext_ticket_keys)
HandleScope scope(node_isolate);
src: centralize class wrap/unwrap While almost all cases were handled by simple WRAP/UNWRAP macros, this extends those to cover all known occurrences.
12 years ago
SecureContext* wrap;
src: fix build break from generic macro name WRAP is too generic a macro name and causes the build to fail from conflicts. They have been prepended with NODE_.
12 years ago
NODE_UNWRAP(args.This(), SecureContext, wrap);
tls: share tls tickets key between cluster workers fix #5871
12 years ago
Local<Object> buff = Buffer::New(48);
if (SSL_CTX_get_tlsext_ticket_keys(wrap->ctx_,
Buffer::Data(buff),
Buffer::Length(buff)) != 1) {
return ThrowError("Failed to fetch tls ticket keys");
}
args.GetReturnValue().Set(buff);
#endif // !def(OPENSSL_NO_TLSEXT) && def(SSL_CTX_get_tlsext_ticket_keys)
}
void SecureContext::SetTicketKeys(const FunctionCallbackInfo<Value>& args) {
#if !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_get_tlsext_ticket_keys)
HandleScope scope(node_isolate);
if (args.Length() < 1 ||
!Buffer::HasInstance(args[0]) ||
Buffer::Length(args[0]) != 48) {
return ThrowTypeError("Bad argument");
}
src: centralize class wrap/unwrap While almost all cases were handled by simple WRAP/UNWRAP macros, this extends those to cover all known occurrences.
12 years ago
SecureContext* wrap;
src: fix build break from generic macro name WRAP is too generic a macro name and causes the build to fail from conflicts. They have been prepended with NODE_.
12 years ago
NODE_UNWRAP(args.This(), SecureContext, wrap);
tls: share tls tickets key between cluster workers fix #5871
12 years ago
if (SSL_CTX_set_tlsext_ticket_keys(wrap->ctx_,
Buffer::Data(args[0]),
Buffer::Length(args[0])) != 1) {
return ThrowError("Failed to fetch tls ticket keys");
}
args.GetReturnValue().Set(true);
#endif // !def(OPENSSL_NO_TLSEXT) && def(SSL_CTX_get_tlsext_ticket_keys)
}
tls_wrap: DRY ClientHelloParser Share ClientHelloParser code between `tls_wrap.cc` and `node_crypto.cc`. fix #5959
12 years ago
void Connection::OnClientHello(void* arg,
const ClientHelloParser::ClientHello& hello) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
tls_wrap: DRY ClientHelloParser Share ClientHelloParser code between `tls_wrap.cc` and `node_crypto.cc`. fix #5959
12 years ago
Connection* c = static_cast<Connection*>(arg);
tls: async session storage
13 years ago
tls_wrap: DRY ClientHelloParser Share ClientHelloParser code between `tls_wrap.cc` and `node_crypto.cc`. fix #5959
12 years ago
if (onclienthello_sym.IsEmpty())
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
onclienthello_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onclienthello");
tls_wrap: DRY ClientHelloParser Share ClientHelloParser code between `tls_wrap.cc` and `node_crypto.cc`. fix #5959
12 years ago
if (sessionid_sym.IsEmpty())
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
sessionid_sym = FIXED_ONE_BYTE_STRING(node_isolate, "sessionId");
tls: async session storage
13 years ago
tls_wrap: DRY ClientHelloParser Share ClientHelloParser code between `tls_wrap.cc` and `node_crypto.cc`. fix #5959
12 years ago
Local<Object> obj = Object::New();
obj->Set(sessionid_sym,
Buffer::New(reinterpret_cast<const char*>(hello.session_id()),
hello.session_size()));
tls: async session storage
13 years ago
tls_wrap: DRY ClientHelloParser Share ClientHelloParser code between `tls_wrap.cc` and `node_crypto.cc`. fix #5959
12 years ago
Handle<Value> argv[1] = { obj };
MakeCallback(c->handle(node_isolate),
onclienthello_sym,
ARRAY_SIZE(argv),
argv);
tls: async session storage
13 years ago
}
tls_wrap: DRY ClientHelloParser Share ClientHelloParser code between `tls_wrap.cc` and `node_crypto.cc`. fix #5959
12 years ago
void Connection::OnClientHelloParseEnd(void* arg) {
Connection* c = static_cast<Connection*>(arg);
tls: async session storage
13 years ago
// Write all accumulated data
tls_wrap: DRY ClientHelloParser Share ClientHelloParser code between `tls_wrap.cc` and `node_crypto.cc`. fix #5959
12 years ago
int r = BIO_write(c->bio_read_,
reinterpret_cast<char*>(c->hello_data_),
c->hello_offset_);
c->HandleBIOError(c->bio_read_, "BIO_write", r);
c->SetShutdownFlags();
tls: async session storage
13 years ago
}
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
#ifdef SSL_PRINT_DEBUG
# define DEBUG_PRINT(...) fprintf (stderr, __VA_ARGS__)
#else
# define DEBUG_PRINT(...)
#endif
Centralize error handling in SecureStream and add a start method, to kick off SSL handshaking, without writing a zero byte buffer
14 years ago
Remove unused parameter from crypto::Handle*Error
14 years ago
int Connection::HandleBIOError(BIO *bio, const char* func, int rv) {
tls: split bio errors from ssl errors
14 years ago
if (rv >= 0) return rv;
int retry = BIO_should_retry(bio);
src: lint c++ code
12 years ago
(void) retry; // unused if !defined(SSL_PRINT_DEBUG)
tls: split bio errors from ssl errors
14 years ago
if (BIO_should_write(bio)) {
src: lint c++ code
12 years ago
DEBUG_PRINT("[%p] BIO: %s want write. should retry %d\n",
ssl_,
func,
retry);
tls: split bio errors from ssl errors
14 years ago
return 0;
} else if (BIO_should_read(bio)) {
DEBUG_PRINT("[%p] BIO: %s want read. should retry %d\n", ssl_, func, retry);
return 0;
} else {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static char ssl_error_buf[512];
tls: split bio errors from ssl errors
14 years ago
ERR_error_string_n(rv, ssl_error_buf, sizeof(ssl_error_buf));
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<Value> exception =
Exception::Error(OneByteString(node_isolate, ssl_error_buf));
handle(node_isolate)->Set(
FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
tls: split bio errors from ssl errors
14 years ago
src: lint c++ code
12 years ago
DEBUG_PRINT("[%p] BIO: %s failed: (%d) %s\n",
ssl_,
func,
rv,
ssl_error_buf);
tls: split bio errors from ssl errors
14 years ago
return rv;
}
return 0;
}
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
int Connection::HandleSSLError(const char* func,
int rv,
ZeroStatus zs,
SyscallStatus ss) {
crypto: clear error stack Clear OpenSSL&#39;s error stack on return from Connection::HandleSSLError(). This stops stale errors from popping up later in the lifecycle of the SSL connection where they would cause spurious failures. This commit causes a 1-2% performance regression on `make bench-tls`. We&#39;ll address that in follow-up commits if possible but let&#39;s ensure correctness first. Fixes #4771.
12 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence unused variable warning.
crypto: fix ssl error handling Make HandleSSLError() correctly process a zero status code: sometimes it indicates an error and sometimes it doesn&#39;t.
12 years ago
if (rv > 0) return rv;
if ((rv == 0) && (zs == kZeroIsNotAnError)) return rv;
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
int err = SSL_get_error(ssl_, rv);
crypto: look up SSL errors with ERR_print_errors()
13 years ago
if (err == SSL_ERROR_NONE) {
return 0;
} else if (err == SSL_ERROR_WANT_WRITE) {
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
DEBUG_PRINT("[%p] SSL: %s want write\n", ssl_, func);
return 0;
Style changes.
14 years ago
} else if (err == SSL_ERROR_WANT_READ) {
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
DEBUG_PRINT("[%p] SSL: %s want read\n", ssl_, func);
return 0;
tls: handle SSL_ERROR_ZERO_RETURN see #5004
12 years ago
} else if (err == SSL_ERROR_ZERO_RETURN) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<Value> exception =
Exception::Error(FIXED_ONE_BYTE_STRING(node_isolate, "ZERO_RETURN"));
handle(node_isolate)->Set(
FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
tls: handle SSL_ERROR_ZERO_RETURN see #5004
12 years ago
return rv;
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
} else if ((err == SSL_ERROR_SYSCALL) && (ss == kIgnoreSyscall)) {
return 0;
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
} else {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: look up SSL errors with ERR_print_errors()
13 years ago
BUF_MEM* mem;
BIO *bio;
assert(err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Drain OpenSSL error queue? Addresses #1719
13 years ago
// XXX We need to drain the error queue for this thread or else OpenSSL
// has the possibility of blocking connections? This problem is not well
crypto: look up SSL errors with ERR_print_errors()
13 years ago
// understood. And we should be somehow propagating these errors up
Drain OpenSSL error queue? Addresses #1719
13 years ago
// into JavaScript. There is no test which demonstrates this problem.
// https://github.com/joyent/node/issues/1719
crypto: look up SSL errors with ERR_print_errors()
13 years ago
if ((bio = BIO_new(BIO_s_mem()))) {
ERR_print_errors(bio);
BIO_get_mem_ptr(bio, &mem);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<Value> exception =
Exception::Error(OneByteString(node_isolate, mem->data, mem->length));
handle(node_isolate)->Set(
FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bio);
Drain OpenSSL error queue? Addresses #1719
13 years ago
}
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
return rv;
Centralize error handling in SecureStream and add a start method, to kick off SSL handshaking, without writing a zero byte buffer
14 years ago
}
return 0;
}
Initial openssl support for net2
15 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
void Connection::ClearError() {
#ifndef NDEBUG
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
// We should clear the error in JS-land
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> error_key = FIXED_ONE_BYTE_STRING(node_isolate, "error");
Local<Value> error = handle(node_isolate)->Get(error_key);
assert(error->BooleanValue() == false);
src: lint c++ code
12 years ago
#endif // NDEBUG
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
}
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
void Connection::SetShutdownFlags() {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
int flags = SSL_get_shutdown(ssl_);
if (flags & SSL_SENT_SHUTDOWN) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> sent_shutdown_key =
FIXED_ONE_BYTE_STRING(node_isolate, "sentShutdown");
handle(node_isolate)->Set(sent_shutdown_key, True(node_isolate));
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
}
if (flags & SSL_RECEIVED_SHUTDOWN) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> received_shutdown_key =
FIXED_ONE_BYTE_STRING(node_isolate, "receivedShutdown");
handle(node_isolate)->Set(received_shutdown_key, True(node_isolate));
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
}
}
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
void Connection::Initialize(Handle<Object> target) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
Local<FunctionTemplate> t = FunctionTemplate::New(Connection::New);
Initial openssl support for net2
15 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Connection"));
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
NODE_SET_PROTOTYPE_METHOD(t, "encIn", Connection::EncIn);
NODE_SET_PROTOTYPE_METHOD(t, "clearOut", Connection::ClearOut);
NODE_SET_PROTOTYPE_METHOD(t, "clearIn", Connection::ClearIn);
NODE_SET_PROTOTYPE_METHOD(t, "encOut", Connection::EncOut);
NODE_SET_PROTOTYPE_METHOD(t, "clearPending", Connection::ClearPending);
NODE_SET_PROTOTYPE_METHOD(t, "encPending", Connection::EncPending);
src: lint c++ code
12 years ago
NODE_SET_PROTOTYPE_METHOD(t,
"getPeerCertificate",
Connection::GetPeerCertificate);
tls: add client-side session resumption support
14 years ago
NODE_SET_PROTOTYPE_METHOD(t, "getSession", Connection::GetSession);
NODE_SET_PROTOTYPE_METHOD(t, "setSession", Connection::SetSession);
tls: async session storage
13 years ago
NODE_SET_PROTOTYPE_METHOD(t, "loadSession", Connection::LoadSession);
tls: add client-side session resumption support
14 years ago
NODE_SET_PROTOTYPE_METHOD(t, "isSessionReused", Connection::IsSessionReused);
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
NODE_SET_PROTOTYPE_METHOD(t, "isInitFinished", Connection::IsInitFinished);
NODE_SET_PROTOTYPE_METHOD(t, "verifyError", Connection::VerifyError);
src: lint c++ code
12 years ago
NODE_SET_PROTOTYPE_METHOD(t,
"getCurrentCipher",
Connection::GetCurrentCipher);
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
NODE_SET_PROTOTYPE_METHOD(t, "start", Connection::Start);
NODE_SET_PROTOTYPE_METHOD(t, "shutdown", Connection::Shutdown);
src: lint c++ code
12 years ago
NODE_SET_PROTOTYPE_METHOD(t,
"receivedShutdown",
Connection::ReceivedShutdown);
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
NODE_SET_PROTOTYPE_METHOD(t, "close", Connection::Close);
OpenSSL NPN in node.js closes #926.
14 years ago
#ifdef OPENSSL_NPN_NEGOTIATED
src: lint c++ code
12 years ago
NODE_SET_PROTOTYPE_METHOD(t,
"getNegotiatedProtocol",
Connection::GetNegotiatedProto);
NODE_SET_PROTOTYPE_METHOD(t,
"setNPNProtocols",
Connection::SetNPNProtocols);
OpenSSL NPN in node.js closes #926.
14 years ago
#endif
Add support for TLS SNI Fixes #1411
14 years ago
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
NODE_SET_PROTOTYPE_METHOD(t, "getServername", Connection::GetServername);
NODE_SET_PROTOTYPE_METHOD(t, "setSNICallback", Connection::SetSNICallback);
#endif
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Connection"),
t->GetFunction());
Initial openssl support for net2
15 years ago
}
Remove assert in verify_peer; add comments
14 years ago
static int VerifyCallback(int preverify_ok, X509_STORE_CTX *ctx) {
// Quoting SSL_set_verify(3ssl):
//
// The VerifyCallback function is used to control the behaviour when
// the SSL_VERIFY_PEER flag is set. It must be supplied by the
// application and receives two arguments: preverify_ok indicates,
// whether the verification of the certificate in question was passed
// (preverify_ok=1) or not (preverify_ok=0). x509_ctx is a pointer to
// the complete context used for the certificate chain verification.
//
// The certificate chain is checked starting with the deepest nesting
// level (the root CA certificate) and worked upward to the peer's
// certificate. At each level signatures and issuer attributes are
// checked. Whenever a verification error is found, the error number is
// stored in x509_ctx and VerifyCallback is called with preverify_ok=0.
// By applying X509_CTX_store_* functions VerifyCallback can locate the
// certificate in question and perform additional steps (see EXAMPLES).
// If no error is found for a certificate, VerifyCallback is called
// with preverify_ok=1 before advancing to the next level.
//
// The return value of VerifyCallback controls the strategy of the
// further verification process. If VerifyCallback returns 0, the
// verification process is immediately stopped with "verification
// failed" state. If SSL_VERIFY_PEER is set, a verification failure
// alert is sent to the peer and the TLS/SSL handshake is terminated. If
// VerifyCallback returns 1, the verification process is continued. If
// VerifyCallback always returns 1, the TLS/SSL handshake will not be
// terminated with respect to verification failures and the connection
// will be established. The calling process can however retrieve the
// error code of the last verification error using
// SSL_get_verify_result(3) or by maintaining its own error storage
// managed by VerifyCallback.
//
// If no VerifyCallback is specified, the default callback will be
// used. Its return value is identical to preverify_ok, so that any
// verification failure will lead to a termination of the TLS/SSL
// handshake with an alert message, if SSL_VERIFY_PEER is set.
//
// Since we cannot perform I/O quickly enough in this callback, we ignore
// all preverify_ok errors and let the handshake continue. It is
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
// imparative that the user use Connection::VerifyError after the
Better verify info
14 years ago
// 'secure' callback has been made.
Remove assert in verify_peer; add comments
14 years ago
return 1;
}
OpenSSL NPN in node.js closes #926.
14 years ago
#ifdef OPENSSL_NPN_NEGOTIATED
int Connection::AdvertiseNextProtoCallback_(SSL *s,
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
const unsigned char** data,
OpenSSL NPN in node.js closes #926.
14 years ago
unsigned int *len,
void *arg) {
Connection *p = static_cast<Connection*>(SSL_get_app_data(s));
if (p->npnProtos_.IsEmpty()) {
// No initialization - no NPN protocols
*data = reinterpret_cast<const unsigned char*>("");
*len = 0;
} else {
src: remove non-isolate PersistentToLocal() There is no need for it and it&#39;s a tiny bit slower than the version of PersistentToLocal() that takes a v8::Isolate* as its first argument.
12 years ago
Local<Object> obj = PersistentToLocal(node_isolate, p->npnProtos_);
src: remove Buffer::Data(Persistent&lt;T&gt;&amp;) It hits a compiler bug in gcc &lt;= 4.4 similar to the issue that was recently addressed in commit 157d2bc: ../deps/v8/include/v8.h: In function ‘char* node::Buffer::Data(v8::Persistent&amp;) [with TypeName = v8::Object]’: ../src/node_crypto.cc:1123: instantiated from here ../deps/v8/include/v8.h:876: error: ‘class v8::Data’ is not a function, ../src/node_internals.h:356: error: conflict with ‘template char* node::Buffer::Data(v8::Persistent&amp;)’ ../src/node_internals.h:357: error: in call to ‘Data’ Remove the helper function, it was only used in a couple of places. Should fix the build on Ubuntu 10.04. Fixes #5844.
12 years ago
*data = reinterpret_cast<const unsigned char*>(Buffer::Data(obj));
*len = Buffer::Length(obj);
OpenSSL NPN in node.js closes #926.
14 years ago
}
return SSL_TLSEXT_ERR_OK;
}
int Connection::SelectNextProtoCallback_(SSL *s,
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
unsigned char** out, unsigned char* outlen,
OpenSSL NPN in node.js closes #926.
14 years ago
const unsigned char* in,
unsigned int inlen, void *arg) {
Connection *p = static_cast<Connection*> SSL_get_app_data(s);
// Release old protocol handler if present
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
p->selectedNPNProto_.Dispose();
OpenSSL NPN in node.js closes #926.
14 years ago
if (p->npnProtos_.IsEmpty()) {
// We should at least select one protocol
// If server is using NPN
*out = reinterpret_cast<unsigned char*>(const_cast<char*>("http/1.1"));
*outlen = 8;
// set status unsupported
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
p->selectedNPNProto_.Reset(node_isolate, False(node_isolate));
OpenSSL NPN in node.js closes #926.
14 years ago
return SSL_TLSEXT_ERR_OK;
}
src: remove non-isolate PersistentToLocal() There is no need for it and it&#39;s a tiny bit slower than the version of PersistentToLocal() that takes a v8::Isolate* as its first argument.
12 years ago
Local<Object> obj = PersistentToLocal(node_isolate, p->npnProtos_);
OpenSSL NPN in node.js closes #926.
14 years ago
const unsigned char* npnProtos =
src: remove Buffer::Data(Persistent&lt;T&gt;&amp;) It hits a compiler bug in gcc &lt;= 4.4 similar to the issue that was recently addressed in commit 157d2bc: ../deps/v8/include/v8.h: In function ‘char* node::Buffer::Data(v8::Persistent&amp;) [with TypeName = v8::Object]’: ../src/node_crypto.cc:1123: instantiated from here ../deps/v8/include/v8.h:876: error: ‘class v8::Data’ is not a function, ../src/node_internals.h:356: error: conflict with ‘template char* node::Buffer::Data(v8::Persistent&amp;)’ ../src/node_internals.h:357: error: in call to ‘Data’ Remove the helper function, it was only used in a couple of places. Should fix the build on Ubuntu 10.04. Fixes #5844.
12 years ago
reinterpret_cast<const unsigned char*>(Buffer::Data(obj));
OpenSSL NPN in node.js closes #926.
14 years ago
int status = SSL_select_next_proto(out, outlen, in, inlen, npnProtos,
src: remove Buffer::Data(Persistent&lt;T&gt;&amp;) It hits a compiler bug in gcc &lt;= 4.4 similar to the issue that was recently addressed in commit 157d2bc: ../deps/v8/include/v8.h: In function ‘char* node::Buffer::Data(v8::Persistent&amp;) [with TypeName = v8::Object]’: ../src/node_crypto.cc:1123: instantiated from here ../deps/v8/include/v8.h:876: error: ‘class v8::Data’ is not a function, ../src/node_internals.h:356: error: conflict with ‘template char* node::Buffer::Data(v8::Persistent&amp;)’ ../src/node_internals.h:357: error: in call to ‘Data’ Remove the helper function, it was only used in a couple of places. Should fix the build on Ubuntu 10.04. Fixes #5844.
12 years ago
Buffer::Length(obj));
OpenSSL NPN in node.js closes #926.
14 years ago
switch (status) {
case OPENSSL_NPN_UNSUPPORTED:
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
p->selectedNPNProto_.Reset(node_isolate, Null(node_isolate));
OpenSSL NPN in node.js closes #926.
14 years ago
break;
case OPENSSL_NPN_NEGOTIATED:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
{
Local<String> string = OneByteString(node_isolate, *out, *outlen);
p->selectedNPNProto_.Reset(node_isolate, string);
break;
}
OpenSSL NPN in node.js closes #926.
14 years ago
case OPENSSL_NPN_NO_OVERLAP:
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
p->selectedNPNProto_.Reset(node_isolate, False(node_isolate));
OpenSSL NPN in node.js closes #926.
14 years ago
break;
default:
break;
}
return SSL_TLSEXT_ERR_OK;
Fix line endings and trailing whitespace
13 years ago
}
OpenSSL NPN in node.js closes #926.
14 years ago
#endif
Add support for TLS SNI Fixes #1411
14 years ago
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
int Connection::SelectSNIContextCallback_(SSL *s, int *ad, void* arg) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Add support for TLS SNI Fixes #1411
14 years ago
Connection *p = static_cast<Connection*> SSL_get_app_data(s);
const char* servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
if (servername) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
p->servername_.Reset(node_isolate,
OneByteString(node_isolate, servername));
Add support for TLS SNI Fixes #1411
14 years ago
crypto, tls: make setSNICallback() compatible with domains
12 years ago
// Call the SNI callback and use its return value as context
if (!p->sniObject_.IsEmpty()) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
p->sniContext_.Dispose();
Add support for TLS SNI Fixes #1411
14 years ago
src: remove non-isolate PersistentToLocal() There is no need for it and it&#39;s a tiny bit slower than the version of PersistentToLocal() that takes a v8::Isolate* as its first argument.
12 years ago
Local<Value> arg = PersistentToLocal(node_isolate, p->servername_);
src: cast strong persistent handles to locals Avoids the overhead of creating a new Local every time we unwrap a Persistent handle.
12 years ago
Local<Value> ret = MakeCallback(p->sniObject_, "onselect", 1, &arg);
Add support for TLS SNI Fixes #1411
14 years ago
// If ret is SecureContext
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (HasInstance(secure_context_constructor, ret)) {
p->sniContext_.Reset(node_isolate, ret);
SecureContext* sc = ObjectWrap::Unwrap<SecureContext>(ret.As<Object>());
Add support for TLS SNI Fixes #1411
14 years ago
SSL_set_SSL_CTX(s, sc->ctx_);
} else {
return SSL_TLSEXT_ERR_NOACK;
}
}
}
return SSL_TLSEXT_ERR_OK;
}
#endif
Remove assert in verify_peer; add comments
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::New(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Fix style in node_crypto.cc
14 years ago
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
Connection *p = new Connection();
src: replace Holder() with This() Switch to always use args.This() to retrieve object instance.
12 years ago
p->Wrap(args.This());
Initial openssl support for net2
15 years ago
Fix style in node_crypto.cc
14 years ago
if (args.Length() < 1 || !args[0]->IsObject()) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("First argument must be a crypto module Credentials");
Initial openssl support for net2
15 years ago
}
Fix style in node_crypto.cc
14 years ago
Initial openssl support for net2
15 years ago
SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args[0]->ToObject());
Fix style in node_crypto.cc
14 years ago
bool is_server = args[1]->BooleanValue();
p->ssl_ = SSL_new(sc->ctx_);
crypto: use better memory BIO implementation
12 years ago
p->bio_read_ = BIO_new(NodeBIO::GetMethod());
p->bio_write_ = BIO_new(NodeBIO::GetMethod());
OpenSSL NPN in node.js closes #926.
14 years ago
SSL_set_app_data(p->ssl_, p);
Add support for TLS SNI Fixes #1411
14 years ago
tls: mitigate session renegotiation attacks The TLS protocol allows (and sometimes requires) clients to renegotiate the session. However, renegotiation requires a disproportional amount of server-side resources, particularly CPU time, which makes it a potential vector for denial-of-service attacks. To mitigate this issue, we keep track of and limit the number of renegotiation requests over time, emitting an error if the threshold is exceeded.
13 years ago
if (is_server) SSL_set_info_callback(p->ssl_, SSLInfoCallback);
Add support for TLS SNI Fixes #1411
14 years ago
#ifdef OPENSSL_NPN_NEGOTIATED
OpenSSL NPN in node.js closes #926.
14 years ago
if (is_server) {
// Server should advertise NPN protocols
SSL_CTX_set_next_protos_advertised_cb(sc->ctx_,
AdvertiseNextProtoCallback_,
NULL);
} else {
// Client should select protocol from advertised
// If server supports NPN
SSL_CTX_set_next_proto_select_cb(sc->ctx_,
SelectNextProtoCallback_,
NULL);
}
#endif
Add support for TLS SNI Fixes #1411
14 years ago
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
if (is_server) {
SSL_CTX_set_tlsext_servername_callback(sc->ctx_, SelectSNIContextCallback_);
} else {
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value servername(args[2]);
Add support for TLS SNI Fixes #1411
14 years ago
SSL_set_tlsext_host_name(p->ssl_, *servername);
}
#endif
Fix style in node_crypto.cc
14 years ago
SSL_set_bio(p->ssl_, p->bio_read_, p->bio_write_);
Use SSL_MODE_RELEASE_BUFFERS by default.
14 years ago
#ifdef SSL_MODE_RELEASE_BUFFERS
long mode = SSL_get_mode(p->ssl_);
SSL_set_mode(p->ssl_, mode | SSL_MODE_RELEASE_BUFFERS);
#endif
Server must not request cert.
14 years ago
int verify_mode;
if (is_server) {
bool request_cert = args[2]->BooleanValue();
if (!request_cert) {
// Note reject_unauthorized ignored.
verify_mode = SSL_VERIFY_NONE;
} else {
bool reject_unauthorized = args[3]->BooleanValue();
verify_mode = SSL_VERIFY_PEER;
if (reject_unauthorized) verify_mode |= SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
}
} else {
// Note request_cert and reject_unauthorized are ignored for clients.
verify_mode = SSL_VERIFY_NONE;
}
Remove should_verify from C++ - to handle in JS land
14 years ago
// Always allow a connection. We'll reject in javascript.
Server must not request cert.
14 years ago
SSL_set_verify(p->ssl_, verify_mode, VerifyCallback);
Fix style in node_crypto.cc
14 years ago
More clang fixes
14 years ago
if ((p->is_server_ = is_server)) {
Fix style in node_crypto.cc
14 years ago
SSL_set_accept_state(p->ssl_);
Initial openssl support for net2
15 years ago
} else {
Fix style in node_crypto.cc
14 years ago
SSL_set_connect_state(p->ssl_);
Initial openssl support for net2
15 years ago
}
}
crypto: fix compile-time error with openssl &lt;= 0.9.7e
13 years ago
void Connection::SSLInfoCallback(const SSL *ssl_, int where, int ret) {
// Be compatible with older versions of OpenSSL. SSL_get_app_data() wants
// a non-const SSL* in OpenSSL <= 0.9.7e.
SSL* ssl = const_cast<SSL*>(ssl_);
tls: mitigate session renegotiation attacks The TLS protocol allows (and sometimes requires) clients to renegotiate the session. However, renegotiation requires a disproportional amount of server-side resources, particularly CPU time, which makes it a potential vector for denial-of-service attacks. To mitigate this issue, we keep track of and limit the number of renegotiation requests over time, emitting an error if the threshold is exceeded.
13 years ago
if (where & SSL_CB_HANDSHAKE_START) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
tls: mitigate session renegotiation attacks The TLS protocol allows (and sometimes requires) clients to renegotiate the session. However, renegotiation requires a disproportional amount of server-side resources, particularly CPU time, which makes it a potential vector for denial-of-service attacks. To mitigate this issue, we keep track of and limit the number of renegotiation requests over time, emitting an error if the threshold is exceeded.
13 years ago
Connection* c = static_cast<Connection*>(SSL_get_app_data(ssl));
MakeCallback: Consistent symbol usage
13 years ago
if (onhandshakestart_sym.IsEmpty()) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
onhandshakestart_sym =
FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakestart");
MakeCallback: Consistent symbol usage
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
MakeCallback(c->handle(node_isolate), onhandshakestart_sym, 0, NULL);
tls: mitigate session renegotiation attacks The TLS protocol allows (and sometimes requires) clients to renegotiate the session. However, renegotiation requires a disproportional amount of server-side resources, particularly CPU time, which makes it a potential vector for denial-of-service attacks. To mitigate this issue, we keep track of and limit the number of renegotiation requests over time, emitting an error if the threshold is exceeded.
13 years ago
}
if (where & SSL_CB_HANDSHAKE_DONE) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
tls: mitigate session renegotiation attacks The TLS protocol allows (and sometimes requires) clients to renegotiate the session. However, renegotiation requires a disproportional amount of server-side resources, particularly CPU time, which makes it a potential vector for denial-of-service attacks. To mitigate this issue, we keep track of and limit the number of renegotiation requests over time, emitting an error if the threshold is exceeded.
13 years ago
Connection* c = static_cast<Connection*>(SSL_get_app_data(ssl));
MakeCallback: Consistent symbol usage
13 years ago
if (onhandshakedone_sym.IsEmpty()) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
onhandshakedone_sym =
FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakedone");
MakeCallback: Consistent symbol usage
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
MakeCallback(c->handle(node_isolate), onhandshakedone_sym, 0, NULL);
tls: mitigate session renegotiation attacks The TLS protocol allows (and sometimes requires) clients to renegotiate the session. However, renegotiation requires a disproportional amount of server-side resources, particularly CPU time, which makes it a potential vector for denial-of-service attacks. To mitigate this issue, we keep track of and limit the number of renegotiation requests over time, emitting an error if the threshold is exceeded.
13 years ago
}
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::EncIn(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Initial openssl support for net2
15 years ago
if (args.Length() < 3) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Takes 3 parameters");
Initial openssl support for net2
15 years ago
}
if (!Buffer::HasInstance(args[0])) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Second argument should be a buffer");
Initial openssl support for net2
15 years ago
}
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
char* buffer_data = Buffer::Data(args[0]);
crypto: Remove many unnecessary toObjects
12 years ago
size_t buffer_length = Buffer::Length(args[0]);
Initial openssl support for net2
15 years ago
size_t off = args[1]->Int32Value();
size_t len = args[2]->Int32Value();
fast buffers for crypto
15 years ago
if (off + len > buffer_length) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("off + len > buffer.length");
Initial openssl support for net2
15 years ago
}
tls: async session storage
13 years ago
int bytes_written;
char* data = buffer_data + off;
tls_wrap: DRY ClientHelloParser Share ClientHelloParser code between `tls_wrap.cc` and `node_crypto.cc`. fix #5959
12 years ago
if (ss->is_server_ && !ss->hello_parser_.IsEnded()) {
// Just accumulate data, everything will be pushed to BIO later
if (ss->hello_parser_.IsPaused()) {
bytes_written = 0;
} else {
// Copy incoming data to the internal buffer
// (which has a size of the biggest possible TLS frame)
size_t available = sizeof(ss->hello_data_) - ss->hello_offset_;
size_t copied = len < available ? len : available;
memcpy(ss->hello_data_ + ss->hello_offset_, data, copied);
ss->hello_offset_ += copied;
ss->hello_parser_.Parse(ss->hello_data_, ss->hello_offset_);
bytes_written = copied;
}
tls: async session storage
13 years ago
} else {
bytes_written = BIO_write(ss->bio_read_, data, len);
ss->HandleBIOError(ss->bio_read_, "BIO_write", bytes_written);
ss->SetShutdownFlags();
}
Initial openssl support for net2
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(bytes_written);
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::ClearOut(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Initial openssl support for net2
15 years ago
if (args.Length() < 3) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Takes 3 parameters");
Initial openssl support for net2
15 years ago
}
if (!Buffer::HasInstance(args[0])) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Second argument should be a buffer");
Initial openssl support for net2
15 years ago
}
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
char* buffer_data = Buffer::Data(args[0]);
crypto: Remove many unnecessary toObjects
12 years ago
size_t buffer_length = Buffer::Length(args[0]);
Initial openssl support for net2
15 years ago
size_t off = args[1]->Int32Value();
size_t len = args[2]->Int32Value();
fast buffers for crypto
15 years ago
if (off + len > buffer_length) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("off + len > buffer.length");
Initial openssl support for net2
15 years ago
}
Fix style in node_crypto.cc
14 years ago
if (!SSL_is_init_finished(ss->ssl_)) {
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
int rv;
Fix style in node_crypto.cc
14 years ago
if (ss->is_server_) {
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
rv = SSL_accept(ss->ssl_);
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
ss->HandleSSLError("SSL_accept:ClearOut",
rv,
kZeroIsAnError,
kSyscallError);
Initial openssl support for net2
15 years ago
} else {
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
rv = SSL_connect(ss->ssl_);
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
ss->HandleSSLError("SSL_connect:ClearOut",
rv,
kZeroIsAnError,
kSyscallError);
Initial openssl support for net2
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (rv < 0) {
return args.GetReturnValue().Set(rv);
}
Initial openssl support for net2
15 years ago
}
tls: split bio errors from ssl errors
14 years ago
int bytes_read = SSL_read(ss->ssl_, buffer_data + off, len);
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
ss->HandleSSLError("SSL_read:ClearOut",
bytes_read,
kZeroIsNotAnError,
kSyscallError);
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
ss->SetShutdownFlags();
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(bytes_read);
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::ClearPending(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Fix style in node_crypto.cc
14 years ago
int bytes_pending = BIO_pending(ss->bio_read_);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(bytes_pending);
Read all records to always empty the OpenSSL reading buffer.
15 years ago
}
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::EncPending(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Fix style in node_crypto.cc
14 years ago
int bytes_pending = BIO_pending(ss->bio_write_);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(bytes_pending);
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::EncOut(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Initial openssl support for net2
15 years ago
if (args.Length() < 3) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Takes 3 parameters");
Initial openssl support for net2
15 years ago
}
if (!Buffer::HasInstance(args[0])) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Second argument should be a buffer");
Initial openssl support for net2
15 years ago
}
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
char* buffer_data = Buffer::Data(args[0]);
crypto: Remove many unnecessary toObjects
12 years ago
size_t buffer_length = Buffer::Length(args[0]);
Initial openssl support for net2
15 years ago
size_t off = args[1]->Int32Value();
size_t len = args[2]->Int32Value();
fast buffers for crypto
15 years ago
if (off + len > buffer_length) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("off + len > buffer.length");
Initial openssl support for net2
15 years ago
}
tls: split bio errors from ssl errors
14 years ago
int bytes_read = BIO_read(ss->bio_write_, buffer_data + off, len);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Remove unused parameter from crypto::Handle*Error
14 years ago
ss->HandleBIOError(ss->bio_write_, "BIO_read:EncOut", bytes_read);
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
ss->SetShutdownFlags();
Initial openssl support for net2
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(bytes_read);
Initial openssl support for net2
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::ClearIn(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Initial openssl support for net2
15 years ago
if (args.Length() < 3) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Takes 3 parameters");
Initial openssl support for net2
15 years ago
}
if (!Buffer::HasInstance(args[0])) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Second argument should be a buffer");
Initial openssl support for net2
15 years ago
}
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
char* buffer_data = Buffer::Data(args[0]);
crypto: Remove many unnecessary toObjects
12 years ago
size_t buffer_length = Buffer::Length(args[0]);
Initial openssl support for net2
15 years ago
size_t off = args[1]->Int32Value();
size_t len = args[2]->Int32Value();
fast buffers for crypto
15 years ago
if (off + len > buffer_length) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("off + len > buffer.length");
Initial openssl support for net2
15 years ago
}
Fix style in node_crypto.cc
14 years ago
if (!SSL_is_init_finished(ss->ssl_)) {
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
int rv;
Fix style in node_crypto.cc
14 years ago
if (ss->is_server_) {
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
rv = SSL_accept(ss->ssl_);
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
ss->HandleSSLError("SSL_accept:ClearIn",
rv,
kZeroIsAnError,
kSyscallError);
Initial openssl support for net2
15 years ago
} else {
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
rv = SSL_connect(ss->ssl_);
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
ss->HandleSSLError("SSL_connect:ClearIn",
rv,
kZeroIsAnError,
kSyscallError);
Initial openssl support for net2
15 years ago
}
Style changes.
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (rv < 0) {
return args.GetReturnValue().Set(rv);
}
Initial openssl support for net2
15 years ago
}
Centralize error handling in SecureStream and add a start method, to kick off SSL handshaking, without writing a zero byte buffer
14 years ago
tls: split bio errors from ssl errors
14 years ago
int bytes_written = SSL_write(ss->ssl_, buffer_data + off, len);
Centralize error handling in SecureStream and add a start method, to kick off SSL handshaking, without writing a zero byte buffer
14 years ago
crypto: zero is not an error if writing 0 bytes fix #5128
12 years ago
ss->HandleSSLError("SSL_write:ClearIn",
bytes_written,
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
len == 0 ? kZeroIsNotAnError : kZeroIsAnError,
kSyscallError);
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
ss->SetShutdownFlags();
Initial openssl support for net2
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(bytes_written);
Initial openssl support for net2
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Initial openssl support for net2
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (ss->ssl_ == NULL) return;
Initial openssl support for net2
15 years ago
Local<Object> info = Object::New();
Fix style in node_crypto.cc
14 years ago
X509* peer_cert = SSL_get_peer_certificate(ss->ssl_);
Initial openssl support for net2
15 years ago
if (peer_cert != NULL) {
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
BIO* bio = BIO_new(BIO_s_mem());
BUF_MEM* mem;
if (X509_NAME_print_ex(bio, X509_get_subject_name(peer_cert), 0,
X509_NAME_FLAGS) > 0) {
BIO_get_mem_ptr(bio, &mem);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
info->Set(subject_symbol,
OneByteString(node_isolate, mem->data, mem->length));
Initial openssl support for net2
15 years ago
}
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
(void) BIO_reset(bio);
if (X509_NAME_print_ex(bio, X509_get_issuer_name(peer_cert), 0,
X509_NAME_FLAGS) > 0) {
BIO_get_mem_ptr(bio, &mem);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
info->Set(issuer_symbol,
OneByteString(node_isolate, mem->data, mem->length));
Initial openssl support for net2
15 years ago
}
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
(void) BIO_reset(bio);
crypto: use X509_get_ext_by_NID(NID_subject_alt_name)
14 years ago
int index = X509_get_ext_by_NID(peer_cert, NID_subject_alt_name, -1);
if (index >= 0) {
X509_EXTENSION* ext;
int rv;
ext = X509_get_ext(peer_cert, index);
assert(ext != NULL);
rv = X509V3_EXT_print(bio, ext, 0, 0);
assert(rv == 1);
BIO_get_mem_ptr(bio, &mem);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
info->Set(subjectaltname_symbol,
OneByteString(node_isolate, mem->data, mem->length));
crypto: use X509_get_ext_by_NID(NID_subject_alt_name)
14 years ago
crypto: Fix BIO&#39;s usage. Fixes #1612. Fixes #1296.
14 years ago
(void) BIO_reset(bio);
Added additional properties to getPeerCertificate, now includes subjectAltName, Exponent and Modulus (FOAF+SSL friendly). Patch written by Nathan, http://groups.google.com/group/nodejs/browse_thread/thread/1d42da4cb2e51536
14 years ago
}
EVP_PKEY *pkey = NULL;
RSA *rsa = NULL;
src: lint c++ code
12 years ago
if (NULL != (pkey = X509_get_pubkey(peer_cert)) &&
NULL != (rsa = EVP_PKEY_get1_RSA(pkey))) {
Added additional properties to getPeerCertificate, now includes subjectAltName, Exponent and Modulus (FOAF+SSL friendly). Patch written by Nathan, http://groups.google.com/group/nodejs/browse_thread/thread/1d42da4cb2e51536
14 years ago
BN_print(bio, rsa->n);
crypto: Fix BIO&#39;s usage. Fixes #1612. Fixes #1296.
14 years ago
BIO_get_mem_ptr(bio, &mem);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
info->Set(modulus_symbol,
OneByteString(node_isolate, mem->data, mem->length));
crypto: Fix BIO&#39;s usage. Fixes #1612. Fixes #1296.
14 years ago
(void) BIO_reset(bio);
Added additional properties to getPeerCertificate, now includes subjectAltName, Exponent and Modulus (FOAF+SSL friendly). Patch written by Nathan, http://groups.google.com/group/nodejs/browse_thread/thread/1d42da4cb2e51536
14 years ago
BN_print(bio, rsa->e);
crypto: Fix BIO&#39;s usage. Fixes #1612. Fixes #1296.
14 years ago
BIO_get_mem_ptr(bio, &mem);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
info->Set(exponent_symbol,
OneByteString(node_isolate, mem->data, mem->length));
crypto: Fix BIO&#39;s usage. Fixes #1612. Fixes #1296.
14 years ago
(void) BIO_reset(bio);
Added additional properties to getPeerCertificate, now includes subjectAltName, Exponent and Modulus (FOAF+SSL friendly). Patch written by Nathan, http://groups.google.com/group/nodejs/browse_thread/thread/1d42da4cb2e51536
14 years ago
}
crypto: fix leak in GetPeerCertificate
12 years ago
if (pkey != NULL) {
EVP_PKEY_free(pkey);
pkey = NULL;
}
if (rsa != NULL) {
RSA_free(rsa);
rsa = NULL;
}
Initial openssl support for net2
15 years ago
ASN1_TIME_print(bio, X509_get_notBefore(peer_cert));
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
BIO_get_mem_ptr(bio, &mem);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
info->Set(valid_from_symbol,
OneByteString(node_isolate, mem->data, mem->length));
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
(void) BIO_reset(bio);
Initial openssl support for net2
15 years ago
ASN1_TIME_print(bio, X509_get_notAfter(peer_cert));
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
BIO_get_mem_ptr(bio, &mem);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
info->Set(valid_to_symbol,
OneByteString(node_isolate, mem->data, mem->length));
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bio);
Initial openssl support for net2
15 years ago
Expose fingerproint from getPeerCertificate Expose the SHA1 digest of the certificate as the fingerprint attribute in the object returned by getPeerCertificate()
15 years ago
unsigned int md_size, i;
unsigned char md[EVP_MAX_MD_SIZE];
if (X509_digest(peer_cert, EVP_sha1(), md, &md_size)) {
const char hex[] = "0123456789ABCDEF";
char fingerprint[EVP_MAX_MD_SIZE * 3];
src: lint c++ code
12 years ago
for (i = 0; i < md_size; i++) {
Expose fingerproint from getPeerCertificate Expose the SHA1 digest of the certificate as the fingerprint attribute in the object returned by getPeerCertificate()
15 years ago
fingerprint[3*i] = hex[(md[i] & 0xf0) >> 4];
fingerprint[(3*i)+1] = hex[(md[i] & 0x0f)];
fingerprint[(3*i)+2] = ':';
}
if (md_size > 0) {
fingerprint[(3*(md_size-1))+2] = '\0';
src: lint c++ code
12 years ago
} else {
Expose fingerproint from getPeerCertificate Expose the SHA1 digest of the certificate as the fingerprint attribute in the object returned by getPeerCertificate()
15 years ago
fingerprint[0] = '\0';
}
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
info->Set(fingerprint_symbol, OneByteString(node_isolate, fingerprint));
Expose fingerproint from getPeerCertificate Expose the SHA1 digest of the certificate as the fingerprint attribute in the object returned by getPeerCertificate()
15 years ago
}
Fix style issues with ext_key_usage patch Closes GH-586.
14 years ago
STACK_OF(ASN1_OBJECT) *eku = (STACK_OF(ASN1_OBJECT) *)X509_get_ext_d2i(
peer_cert, NID_ext_key_usage, NULL, NULL);
Add ext_key_usage to getPeerCertificate
14 years ago
if (eku != NULL) {
Local<Array> ext_key_usage = Array::New();
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
char buf[256];
Fix style issues with ext_key_usage patch Closes GH-586.
14 years ago
Add ext_key_usage to getPeerCertificate
14 years ago
for (int i = 0; i < sk_ASN1_OBJECT_num(eku); i++) {
memset(buf, 0, sizeof(buf));
OBJ_obj2txt(buf, sizeof(buf) - 1, sk_ASN1_OBJECT_value(eku, i), 1);
src: don&#39;t obj-&gt;Set(Integer::New(...), val) Don&#39;t create an Integer when setting a numeric index on an object or an array, use the version of v8::Object::Set() that takes an uint32_t. Change the types of the variables from int to uint32_t and clean up some code consistency issues while we&#39;re here.
12 years ago
ext_key_usage->Set(i, OneByteString(node_isolate, buf));
Add ext_key_usage to getPeerCertificate
14 years ago
}
Fix style issues with ext_key_usage patch Closes GH-586.
14 years ago
Add ext_key_usage to getPeerCertificate
14 years ago
sk_ASN1_OBJECT_pop_free(eku, ASN1_OBJECT_free);
info->Set(ext_key_usage_symbol, ext_key_usage);
}
Expose fingerproint from getPeerCertificate Expose the SHA1 digest of the certificate as the fingerprint attribute in the object returned by getPeerCertificate()
15 years ago
Initial openssl support for net2
15 years ago
X509_free(peer_cert);
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(info);
Initial openssl support for net2
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::GetSession(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
tls: add client-side session resumption support
14 years ago
Connection *ss = Connection::Unwrap(args);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (ss->ssl_ == NULL) return;
tls: add client-side session resumption support
14 years ago
SSL_SESSION* sess = SSL_get_session(ss->ssl_);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (!sess) return;
tls: add client-side session resumption support
14 years ago
int slen = i2d_SSL_SESSION(sess, NULL);
assert(slen > 0);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
unsigned char* sbuf = new unsigned char[slen];
unsigned char* p = sbuf;
i2d_SSL_SESSION(sess, &p);
args.GetReturnValue().Set(Encode(sbuf, slen, BINARY));
delete[] sbuf;
tls: add client-side session resumption support
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::SetSession(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
tls: add client-side session resumption support
14 years ago
Connection *ss = Connection::Unwrap(args);
crypto: bring module into modern age Introduce &#39;buffer&#39; encoding, allow returning and giving buffers as arguments of &#39;crypto&#39; routines. Fix #3278
12 years ago
if (args.Length() < 1 ||
(!args[0]->IsString() && !Buffer::HasInstance(args[0]))) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad argument");
tls: add client-side session resumption support
14 years ago
}
crypto: Binding only accepts buffers
12 years ago
ASSERT_IS_BUFFER(args[0]);
crypto: Remove many unnecessary toObjects
12 years ago
ssize_t slen = Buffer::Length(args[0]);
tls: add client-side session resumption support
14 years ago
if (slen < 0) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError("Bad argument");
tls: add client-side session resumption support
14 years ago
}
char* sbuf = new char[slen];
ssize_t wlen = DecodeWrite(sbuf, slen, args[0], BINARY);
assert(wlen == slen);
tls: async session storage
13 years ago
const unsigned char* p = reinterpret_cast<const unsigned char*>(sbuf);
tls: add client-side session resumption support
14 years ago
SSL_SESSION* sess = d2i_SSL_SESSION(NULL, &p, wlen);
delete [] sbuf;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (!sess) return;
tls: add client-side session resumption support
14 years ago
int r = SSL_set_session(ss->ssl_, sess);
SSL_SESSION_free(sess);
if (!r) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("SSL_set_session error");
tls: add client-side session resumption support
14 years ago
}
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::LoadSession(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
tls: async session storage
13 years ago
Connection *ss = Connection::Unwrap(args);
if (args.Length() >= 1 && Buffer::HasInstance(args[0])) {
ssize_t slen = Buffer::Length(args[0].As<Object>());
char* sbuf = Buffer::Data(args[0].As<Object>());
const unsigned char* p = reinterpret_cast<unsigned char*>(sbuf);
SSL_SESSION* sess = d2i_SSL_SESSION(NULL, &p, slen);
// Setup next session and move hello to the BIO buffer
if (ss->next_sess_ != NULL) {
SSL_SESSION_free(ss->next_sess_);
}
ss->next_sess_ = sess;
}
tls_wrap: DRY ClientHelloParser Share ClientHelloParser code between `tls_wrap.cc` and `node_crypto.cc`. fix #5959
12 years ago
ss->hello_parser_.End();
tls: async session storage
13 years ago
}
tls: add client-side session resumption support
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::IsSessionReused(const FunctionCallbackInfo<Value>& args) {
HandleScope scope(node_isolate);
tls: add client-side session resumption support
14 years ago
Connection *ss = Connection::Unwrap(args);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
bool yes = ss->ssl_ && SSL_session_reused(ss->ssl_);
args.GetReturnValue().Set(yes);
tls: add client-side session resumption support
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::Start(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Centralize error handling in SecureStream and add a start method, to kick off SSL handshaking, without writing a zero byte buffer
14 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Centralize error handling in SecureStream and add a start method, to kick off SSL handshaking, without writing a zero byte buffer
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
int rv = 0;
Centralize error handling in SecureStream and add a start method, to kick off SSL handshaking, without writing a zero byte buffer
14 years ago
if (!SSL_is_init_finished(ss->ssl_)) {
if (ss->is_server_) {
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
rv = SSL_accept(ss->ssl_);
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
ss->HandleSSLError("SSL_accept:Start", rv, kZeroIsAnError, kSyscallError);
Centralize error handling in SecureStream and add a start method, to kick off SSL handshaking, without writing a zero byte buffer
14 years ago
} else {
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
rv = SSL_connect(ss->ssl_);
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
ss->HandleSSLError("SSL_connect:Start",
rv,
kZeroIsAnError,
kSyscallError);
Centralize error handling in SecureStream and add a start method, to kick off SSL handshaking, without writing a zero byte buffer
14 years ago
}
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(rv);
Centralize error handling in SecureStream and add a start method, to kick off SSL handshaking, without writing a zero byte buffer
14 years ago
}
Lint node_crypto.cc
15 years ago
Add receivedShutdown() binding
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::Shutdown(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Initial openssl support for net2
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (ss->ssl_ == NULL) {
return args.GetReturnValue().Set(false);
}
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
int rv = SSL_shutdown(ss->ssl_);
tls: ignore .shutdown() syscall error Quote from SSL_shutdown man page: The output of SSL_get_error(3) may be misleading, as an erroneous SSL_ERROR_SYSCALL may be flagged even though no error occurred. Also, handle all other errors to prevent assertion in `ClearError()`.
12 years ago
ss->HandleSSLError("SSL_shutdown", rv, kZeroIsNotAnError, kIgnoreSyscall);
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
ss->SetShutdownFlags();
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(rv);
Add receivedShutdown() binding
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::ReceivedShutdown(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
bool yes = ss->ssl_ && SSL_get_shutdown(ss->ssl_) == SSL_RECEIVED_SHUTDOWN;
args.GetReturnValue().Set(yes);
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::IsInitFinished(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
bool yes = ss->ssl_ && SSL_is_init_finished(ss->ssl_);
args.GetReturnValue().Set(yes);
Initial openssl support for net2
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::VerifyError(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Initial openssl support for net2
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (ss->ssl_ == NULL) {
return args.GetReturnValue().SetNull();
}
clients without certs are unauthed.
14 years ago
// XXX Do this check in JS land?
Fix style in node_crypto.cc
14 years ago
X509* peer_cert = SSL_get_peer_certificate(ss->ssl_);
clients without certs are unauthed.
14 years ago
if (peer_cert == NULL) {
// We requested a certificate and they did not send us one.
// Definitely an error.
// XXX is this the right error message?
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> error_message =
FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_ISSUER_CERT");
Local<Value> exception = Exception::Error(error_message);
return args.GetReturnValue().Set(exception);
clients without certs are unauthed.
14 years ago
}
Added default CAs, updated openssl verify behaviour, added crypto and https documentation
15 years ago
X509_free(peer_cert);
clients without certs are unauthed.
14 years ago
Fix style in node_crypto.cc
14 years ago
long x509_verify_error = SSL_get_verify_result(ss->ssl_);
Initial openssl support for net2
15 years ago
Better verify info
14 years ago
Local<String> s;
Initial openssl support for net2
15 years ago
Better verify info
14 years ago
switch (x509_verify_error) {
case X509_V_OK:
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
break;
Initial openssl support for net2
15 years ago
Better verify info
14 years ago
case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_ISSUER_CERT");
Better verify info
14 years ago
break;
case X509_V_ERR_UNABLE_TO_GET_CRL:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_CRL");
Better verify info
14 years ago
break;
case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate,
"UNABLE_TO_DECRYPT_CERT_SIGNATURE");
Better verify info
14 years ago
break;
case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate,
"UNABLE_TO_DECRYPT_CRL_SIGNATURE");
Better verify info
14 years ago
break;
case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate,
"UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY");
Better verify info
14 years ago
break;
case X509_V_ERR_CERT_SIGNATURE_FAILURE:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_SIGNATURE_FAILURE");
Better verify info
14 years ago
break;
case X509_V_ERR_CRL_SIGNATURE_FAILURE:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "CRL_SIGNATURE_FAILURE");
Better verify info
14 years ago
break;
case X509_V_ERR_CERT_NOT_YET_VALID:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_NOT_YET_VALID");
Better verify info
14 years ago
break;
case X509_V_ERR_CERT_HAS_EXPIRED:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_HAS_EXPIRED");
Better verify info
14 years ago
break;
case X509_V_ERR_CRL_NOT_YET_VALID:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "CRL_NOT_YET_VALID");
Better verify info
14 years ago
break;
case X509_V_ERR_CRL_HAS_EXPIRED:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "CRL_HAS_EXPIRED");
Better verify info
14 years ago
break;
case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CERT_NOT_BEFORE_FIELD");
Better verify info
14 years ago
break;
case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CERT_NOT_AFTER_FIELD");
Better verify info
14 years ago
break;
case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CRL_LAST_UPDATE_FIELD");
Better verify info
14 years ago
break;
case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CRL_NEXT_UPDATE_FIELD");
Better verify info
14 years ago
break;
case X509_V_ERR_OUT_OF_MEM:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "OUT_OF_MEM");
Better verify info
14 years ago
break;
case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "DEPTH_ZERO_SELF_SIGNED_CERT");
Better verify info
14 years ago
break;
case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "SELF_SIGNED_CERT_IN_CHAIN");
Better verify info
14 years ago
break;
case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate,
"UNABLE_TO_GET_ISSUER_CERT_LOCALLY");
Better verify info
14 years ago
break;
case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate,
"UNABLE_TO_VERIFY_LEAF_SIGNATURE");
Better verify info
14 years ago
break;
case X509_V_ERR_CERT_CHAIN_TOO_LONG:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_CHAIN_TOO_LONG");
Better verify info
14 years ago
break;
case X509_V_ERR_CERT_REVOKED:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_REVOKED");
Better verify info
14 years ago
break;
case X509_V_ERR_INVALID_CA:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "INVALID_CA");
Better verify info
14 years ago
break;
case X509_V_ERR_PATH_LENGTH_EXCEEDED:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "PATH_LENGTH_EXCEEDED");
Better verify info
14 years ago
break;
case X509_V_ERR_INVALID_PURPOSE:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "INVALID_PURPOSE");
Better verify info
14 years ago
break;
case X509_V_ERR_CERT_UNTRUSTED:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_UNTRUSTED");
Better verify info
14 years ago
break;
case X509_V_ERR_CERT_REJECTED:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_REJECTED");
Better verify info
14 years ago
break;
default:
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
s = OneByteString(node_isolate,
X509_verify_cert_error_string(x509_verify_error));
Better verify info
14 years ago
break;
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (s.IsEmpty())
args.GetReturnValue().SetNull();
else
args.GetReturnValue().Set(Exception::Error(s));
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::GetCurrentCipher(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
openssl 1.0.0 constification
15 years ago
OPENSSL_CONST SSL_CIPHER *c;
Initial openssl support for net2
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (ss->ssl_ == NULL) return;
Fix style in node_crypto.cc
14 years ago
c = SSL_get_current_cipher(ss->ssl_);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (c == NULL) return;
Initial openssl support for net2
15 years ago
Local<Object> info = Object::New();
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
const char* cipher_name = SSL_CIPHER_get_name(c);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
info->Set(name_symbol, OneByteString(node_isolate, cipher_name));
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
const char* cipher_version = SSL_CIPHER_get_version(c);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
info->Set(version_symbol, OneByteString(node_isolate, cipher_version));
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(info);
Initial openssl support for net2
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::Close(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Connection *ss = Connection::Unwrap(args);
Initial openssl support for net2
15 years ago
Fix style in node_crypto.cc
14 years ago
if (ss->ssl_ != NULL) {
SSL_free(ss->ssl_);
ss->ssl_ = NULL;
Initial openssl support for net2
15 years ago
}
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
OpenSSL NPN in node.js closes #926.
14 years ago
#ifdef OPENSSL_NPN_NEGOTIATED
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::GetNegotiatedProto(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
OpenSSL NPN in node.js closes #926.
14 years ago
Connection *ss = Connection::Unwrap(args);
if (ss->is_server_) {
crypto: Style. Prefer &#39;char*&#39; over &#39;char *&#39;
12 years ago
const unsigned char* npn_proto;
OpenSSL NPN in node.js closes #926.
14 years ago
unsigned int npn_proto_len;
SSL_get0_next_proto_negotiated(ss->ssl_, &npn_proto, &npn_proto_len);
if (!npn_proto) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return args.GetReturnValue().Set(false);
OpenSSL NPN in node.js closes #926.
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
OneByteString(node_isolate, npn_proto, npn_proto_len));
OpenSSL NPN in node.js closes #926.
14 years ago
} else {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(ss->selectedNPNProto_);
OpenSSL NPN in node.js closes #926.
14 years ago
}
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::SetNPNProtocols(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
OpenSSL NPN in node.js closes #926.
14 years ago
Connection *ss = Connection::Unwrap(args);
if (args.Length() < 1 || !Buffer::HasInstance(args[0])) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("Must give a Buffer as first argument");
OpenSSL NPN in node.js closes #926.
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
ss->npnProtos_.Reset(node_isolate, args[0].As<Object>());
}
OpenSSL NPN in node.js closes #926.
14 years ago
#endif
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
Add support for TLS SNI Fixes #1411
14 years ago
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::GetServername(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Add support for TLS SNI Fixes #1411
14 years ago
Connection *ss = Connection::Unwrap(args);
if (ss->is_server_ && !ss->servername_.IsEmpty()) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(ss->servername_);
Add support for TLS SNI Fixes #1411
14 years ago
} else {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(false);
Add support for TLS SNI Fixes #1411
14 years ago
}
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Connection::SetSNICallback(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Add support for TLS SNI Fixes #1411
14 years ago
Connection *ss = Connection::Unwrap(args);
if (args.Length() < 1 || !args[0]->IsFunction()) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowError("Must give a Function as first argument");
Add support for TLS SNI Fixes #1411
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
Local<Object> obj = Object::New();
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "onselect"), args[0]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
ss->sniObject_.Reset(node_isolate, obj);
Add support for TLS SNI Fixes #1411
14 years ago
}
#endif
Initial openssl support for net2
15 years ago
Lint node_crypto.cc
15 years ago
crypto: merge Cipher and Decipher
12 years ago
void CipherBase::Initialize(Handle<Object> target) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
Local<FunctionTemplate> t = FunctionTemplate::New(New);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
NODE_SET_PROTOTYPE_METHOD(t, "init", Init);
NODE_SET_PROTOTYPE_METHOD(t, "initiv", InitIv);
NODE_SET_PROTOTYPE_METHOD(t, "update", Update);
NODE_SET_PROTOTYPE_METHOD(t, "final", Final);
crypto: split crypto classes
12 years ago
NODE_SET_PROTOTYPE_METHOD(t, "setAutoPadding", SetAutoPadding);
Lint node_crypto.cc
15 years ago
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "CipherBase"),
t->GetFunction());
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void CipherBase::New(const FunctionCallbackInfo<Value>& args) {
assert(args.IsConstructCall() == true);
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: merge Cipher and Decipher
12 years ago
CipherBase* cipher = new CipherBase(args[0]->IsTrue() ? kCipher : kDecipher);
crypto: split crypto classes
12 years ago
cipher->Wrap(args.This());
}
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
void CipherBase::Init(const char* cipher_type,
const char* key_buf,
int key_buf_len) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Lint node_crypto.cc
15 years ago
crypto: merge Cipher and Decipher
12 years ago
assert(cipher_ == NULL);
cipher_ = EVP_get_cipherbyname(cipher_type);
if (cipher_ == NULL) {
return ThrowError("Unknown cipher");
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
unsigned char key[EVP_MAX_KEY_LENGTH];
unsigned char iv[EVP_MAX_IV_LENGTH];
Crypto: adding ability to turn off automatic PKCS padding
13 years ago
crypto: split crypto classes
12 years ago
int key_len = EVP_BytesToKey(cipher_,
EVP_md5(),
NULL,
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
reinterpret_cast<const unsigned char*>(key_buf),
crypto: split crypto classes
12 years ago
key_buf_len,
1,
key,
iv);
crypto: fix memory leak when decrypting empty strings Also fixes a dangling pointer delete[] in the error path.
13 years ago
crypto: merge Cipher and Decipher
12 years ago
EVP_CIPHER_CTX_init(&ctx_);
EVP_CipherInit_ex(&ctx_, cipher_, NULL, NULL, NULL, kind_ == kCipher);
if (!EVP_CIPHER_CTX_set_key_length(&ctx_, key_len)) {
EVP_CIPHER_CTX_cleanup(&ctx_);
return ThrowError("Invalid key length");
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
crypto: merge Cipher and Decipher
12 years ago
EVP_CipherInit_ex(&ctx_,
NULL,
NULL,
reinterpret_cast<unsigned char*>(key),
reinterpret_cast<unsigned char*>(iv),
kind_ == kCipher);
crypto: split crypto classes
12 years ago
initialised_ = true;
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void CipherBase::Init(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Lint node_crypto.cc
15 years ago
crypto: merge Cipher and Decipher
12 years ago
CipherBase* cipher = ObjectWrap::Unwrap<CipherBase>(args.This());
Lint node_crypto.cc
15 years ago
crypto: merge Cipher and Decipher
12 years ago
if (args.Length() < 2 ||
!(args[0]->IsString() && Buffer::HasInstance(args[1]))) {
return ThrowError("Must give cipher-type, key");
crypto: split crypto classes
12 years ago
}
Support for signature verification with RSA/DSA public keys Fixes #1166.
14 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value cipher_type(args[0]);
const char* key_buf = Buffer::Data(args[1]);
crypto: merge Cipher and Decipher
12 years ago
ssize_t key_buf_len = Buffer::Length(args[1]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
cipher->Init(*cipher_type, key_buf, key_buf_len);
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Support for signature verification with RSA/DSA public keys Fixes #1166.
14 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
void CipherBase::InitIv(const char* cipher_type,
const char* key,
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
int key_len,
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const char* iv,
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
int iv_len) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
cipher_ = EVP_get_cipherbyname(cipher_type);
if (cipher_ == NULL) {
return ThrowError("Unknown cipher");
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
/* OpenSSL versions up to 0.9.8l failed to return the correct
iv_length (0) for ECB ciphers */
if (EVP_CIPHER_iv_length(cipher_) != iv_len &&
!(EVP_CIPHER_mode(cipher_) == EVP_CIPH_ECB_MODE && iv_len == 0)) {
return ThrowError("Invalid IV length");
}
EVP_CIPHER_CTX_init(&ctx_);
EVP_CipherInit_ex(&ctx_, cipher_, NULL, NULL, NULL, kind_ == kCipher);
if (!EVP_CIPHER_CTX_set_key_length(&ctx_, key_len)) {
EVP_CIPHER_CTX_cleanup(&ctx_);
return ThrowError("Invalid key length");
}
EVP_CipherInit_ex(&ctx_,
NULL,
NULL,
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
reinterpret_cast<const unsigned char*>(key),
reinterpret_cast<const unsigned char*>(iv),
crypto: merge Cipher and Decipher
12 years ago
kind_ == kCipher);
initialised_ = true;
crypto: split crypto classes
12 years ago
}
Fix a bunch of memory leaks in node_crypto
15 years ago
Fix a few compiler warnings...
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void CipherBase::InitIv(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
CipherBase* cipher = ObjectWrap::Unwrap<CipherBase>(args.This());
Lint node_crypto.cc
15 years ago
crypto: merge Cipher and Decipher
12 years ago
if (args.Length() < 3 || !args[0]->IsString()) {
return ThrowError("Must give cipher-type, key, and iv as argument");
crypto: split crypto classes
12 years ago
}
Coverity fixes: src/node_crypto
15 years ago
crypto: merge Cipher and Decipher
12 years ago
ASSERT_IS_BUFFER(args[1]);
crypto: split crypto classes
12 years ago
ASSERT_IS_BUFFER(args[2]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value cipher_type(args[0]);
crypto: merge Cipher and Decipher
12 years ago
ssize_t key_len = Buffer::Length(args[1]);
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const char* key_buf = Buffer::Data(args[1]);
crypto: merge Cipher and Decipher
12 years ago
ssize_t iv_len = Buffer::Length(args[2]);
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const char* iv_buf = Buffer::Data(args[2]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
cipher->InitIv(*cipher_type, key_buf, key_len, iv_buf, iv_len);
crypto: merge Cipher and Decipher
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
bool CipherBase::Update(const char* data,
crypto: merge Cipher and Decipher
12 years ago
int len,
unsigned char** out,
int* out_len) {
if (!initialised_) return 0;
*out_len = len + EVP_CIPHER_CTX_block_size(&ctx_);
*out = new unsigned char[*out_len];
return EVP_CipherUpdate(&ctx_,
*out,
out_len,
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
reinterpret_cast<const unsigned char*>(data),
crypto: merge Cipher and Decipher
12 years ago
len);
crypto: split crypto classes
12 years ago
}
Crypto: adding ability to turn off automatic PKCS padding
13 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void CipherBase::Update(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
CipherBase* cipher = ObjectWrap::Unwrap<CipherBase>(args.This());
Lint node_crypto.cc
15 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
ASSERT_IS_STRING_OR_BUFFER(args[0]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
unsigned char* out = NULL;
bool r;
int out_len = 0;
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
// Only copy the data if we have to, because it's a string
if (args[0]->IsString()) {
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
Local<String> string = args[0].As<String>();
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
enum encoding encoding = ParseEncoding(args[1], BINARY);
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
if (!StringBytes::IsValidString(string, encoding))
return ThrowTypeError("Bad input string");
size_t buflen = StringBytes::StorageSize(string, encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
char* buf = new char[buflen];
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
size_t written = StringBytes::Write(buf, buflen, string, encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
r = cipher->Update(buf, written, &out, &out_len);
delete[] buf;
} else {
char* buf = Buffer::Data(args[0]);
size_t buflen = Buffer::Length(args[0]);
r = cipher->Update(buf, buflen, &out, &out_len);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
crypto: split crypto classes
12 years ago
if (!r) {
crypto: merge Cipher and Decipher
12 years ago
delete[] out;
crypto: split crypto classes
12 years ago
return ThrowCryptoTypeError(ERR_get_error());
Fix resource leaks in node_crypto.cc Fixes #1097.
14 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
buffer: use smalloc as backing data store Memory allocations are now done through smalloc. The Buffer cc class has been removed completely, but for backwards compatibility have left the namespace as Buffer. The .parent attribute is only set if the Buffer is a slice of an allocation. Which is then set to the alloc object (not a Buffer). The .offset attribute is now a ReadOnly set to 0, for backwards compatibility. I&#39;d like to remove it in the future (pre v1.0). A few alterations have been made to how arguments are either coerced or thrown. All primitives will now be coerced to their respective values, and (most) all out of range index requests will throw. The indexes that are coerced were left for backwards compatibility. For example: Buffer slice operates more like Array slice, and coerces instead of throwing out of range indexes. This may change in the future. The reason for wanting to throw for out of range indexes is because giving js access to raw memory has high potential risk. To mitigate that it&#39;s easier to make sure the developer is always quickly alerted to the fact that their code is attempting to access beyond memory bounds. Because SlowBuffer will be deprecated, and simply returns a new Buffer instance, all tests on SlowBuffer have been removed. Heapdumps will now show usage under &#34;smalloc&#34; instead of &#34;Buffer&#34;. ParseArrayIndex was added to node_internals to support proper uint argument checking/coercion for external array data indexes. SlabAllocator had to be updated since handle_ no longer exists.
12 years ago
Local<Object> buf = Buffer::New(reinterpret_cast<char*>(out), out_len);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
if (out) delete[] out;
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(buf);
crypto: merge Cipher and Decipher
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
bool CipherBase::SetAutoPadding(bool auto_padding) {
if (!initialised_) return false;
return EVP_CIPHER_CTX_set_padding(&ctx_, auto_padding);
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void CipherBase::SetAutoPadding(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: merge Cipher and Decipher
12 years ago
CipherBase* cipher = ObjectWrap::Unwrap<CipherBase>(args.This());
crypto: split crypto classes
12 years ago
cipher->SetAutoPadding(args.Length() < 1 || args[0]->BooleanValue());
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
bool CipherBase::Final(unsigned char** out, int *out_len) {
if (!initialised_) return false;
*out = new unsigned char[EVP_CIPHER_CTX_block_size(&ctx_)];
bool r = EVP_CipherFinal_ex(&ctx_, *out, out_len);
EVP_CIPHER_CTX_cleanup(&ctx_);
initialised_ = false;
return r;
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void CipherBase::Final(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
CipherBase* cipher = ObjectWrap::Unwrap<CipherBase>(args.This());
Lint node_crypto.cc
15 years ago
crypto: split crypto classes
12 years ago
unsigned char* out_value = NULL;
int out_len = -1;
Local<Value> outString;
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
bool r = cipher->Final(&out_value, &out_len);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: merge Cipher and Decipher
12 years ago
if (out_len <= 0 || !r) {
delete[] out_value;
crypto: split crypto classes
12 years ago
out_value = NULL;
crypto: merge Cipher and Decipher
12 years ago
out_len = 0;
if (!r) return ThrowCryptoTypeError(ERR_get_error());
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(
Buffer::New(reinterpret_cast<char*>(out_value), out_len));
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
void Hmac::Initialize(v8::Handle<v8::Object> target) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
Local<FunctionTemplate> t = FunctionTemplate::New(New);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
NODE_SET_PROTOTYPE_METHOD(t, "init", HmacInit);
NODE_SET_PROTOTYPE_METHOD(t, "update", HmacUpdate);
NODE_SET_PROTOTYPE_METHOD(t, "digest", HmacDigest);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Hmac"), t->GetFunction());
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Hmac::New(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: refactor crypto classes
12 years ago
Hmac* hmac = new Hmac();
hmac->Wrap(args.This());
crypto: split crypto classes
12 years ago
}
Fix a few compiler warnings...
14 years ago
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
void Hmac::HmacInit(const char* hash_type, const char* key, int key_len) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
assert(md_ == NULL);
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
md_ = EVP_get_digestbyname(hash_type);
crypto: refactor crypto classes
12 years ago
if (md_ == NULL) {
return ThrowError("Unknown message digest");
}
HMAC_CTX_init(&ctx_);
if (key_len == 0) {
HMAC_Init(&ctx_, "", 0, md_);
} else {
HMAC_Init(&ctx_, key, key_len, md_);
}
initialised_ = true;
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Fix a few compiler warnings...
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Hmac::HmacInit(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
fast buffers for crypto
15 years ago
crypto: refactor crypto classes
12 years ago
Hmac* hmac = ObjectWrap::Unwrap<Hmac>(args.This());
if (args.Length() < 2 || !args[0]->IsString()) {
return ThrowError("Must give hashtype string, key as arguments");
crypto: split crypto classes
12 years ago
}
Fix a bunch of memory leaks in node_crypto
15 years ago
crypto: split crypto classes
12 years ago
ASSERT_IS_BUFFER(args[1]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value hash_type(args[0]);
const char* buffer_data = Buffer::Data(args[1]);
crypto: refactor crypto classes
12 years ago
size_t buffer_length = Buffer::Length(args[1]);
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
hmac->HmacInit(*hash_type, buffer_data, buffer_length);
crypto: refactor crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
bool Hmac::HmacUpdate(const char* data, int len) {
crypto: refactor crypto classes
12 years ago
if (!initialised_) return false;
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
HMAC_Update(&ctx_, reinterpret_cast<const unsigned char*>(data), len);
crypto: refactor crypto classes
12 years ago
return true;
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Hmac::HmacUpdate(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
Hmac* hmac = ObjectWrap::Unwrap<Hmac>(args.This());
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
ASSERT_IS_STRING_OR_BUFFER(args[0]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
// Only copy the data if we have to, because it's a string
crypto: refactor crypto classes
12 years ago
bool r;
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
if (args[0]->IsString()) {
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
Local<String> string = args[0].As<String>();
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
enum encoding encoding = ParseEncoding(args[1], BINARY);
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
if (!StringBytes::IsValidString(string, encoding))
return ThrowTypeError("Bad input string");
size_t buflen = StringBytes::StorageSize(string, encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
char* buf = new char[buflen];
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
size_t written = StringBytes::Write(buf, buflen, string, encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
r = hmac->HmacUpdate(buf, written);
delete[] buf;
} else {
char* buf = Buffer::Data(args[0]);
size_t buflen = Buffer::Length(args[0]);
r = hmac->HmacUpdate(buf, buflen);
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
if (!r) {
crypto: refactor crypto classes
12 years ago
return ThrowTypeError("HmacUpdate fail");
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
bool Hmac::HmacDigest(unsigned char** md_value, unsigned int* md_len) {
if (!initialised_) return false;
*md_value = new unsigned char[EVP_MAX_MD_SIZE];
HMAC_Final(&ctx_, *md_value, md_len);
HMAC_CTX_cleanup(&ctx_);
initialised_ = false;
return true;
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Hmac::HmacDigest(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
Hmac* hmac = ObjectWrap::Unwrap<Hmac>(args.This());
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
enum encoding encoding = BUFFER;
if (args.Length() >= 1) {
encoding = ParseEncoding(args[0]->ToString(), BUFFER);
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
unsigned char* md_value = NULL;
unsigned int md_len = 0;
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
bool r = hmac->HmacDigest(&md_value, &md_len);
if (!r) {
crypto: split crypto classes
12 years ago
md_value = NULL;
md_len = 0;
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
Local<Value> rc = StringBytes::Encode(
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
reinterpret_cast<const char*>(md_value), md_len, encoding);
delete[] md_value;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(rc);
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
void Hash::Initialize(v8::Handle<v8::Object> target) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
Local<FunctionTemplate> t = FunctionTemplate::New(New);
Fix memory leak in hash.update()
15 years ago
crypto: split crypto classes
12 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
NODE_SET_PROTOTYPE_METHOD(t, "update", HashUpdate);
NODE_SET_PROTOTYPE_METHOD(t, "digest", HashDigest);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Hash"), t->GetFunction());
crypto: split crypto classes
12 years ago
}
Fix memory leak in hash.update()
15 years ago
Fix a few compiler warnings...
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Hash::New(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
if (args.Length() == 0 || !args[0]->IsString()) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Must give hashtype string as argument");
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value hash_type(args[0]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
Hash* hash = new Hash();
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
if (!hash->HashInit(*hash_type)) {
crypto: split crypto classes
12 years ago
delete hash;
crypto: refactor crypto classes
12 years ago
return ThrowError("Digest method not supported");
Fix resource leaks in node_crypto.cc Fixes #1097.
14 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
hash->Wrap(args.This());
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
bool Hash::HashInit(const char* hash_type) {
crypto: refactor crypto classes
12 years ago
assert(md_ == NULL);
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
md_ = EVP_get_digestbyname(hash_type);
crypto: refactor crypto classes
12 years ago
if (md_ == NULL) return false;
EVP_MD_CTX_init(&mdctx_);
EVP_DigestInit_ex(&mdctx_, md_, NULL);
initialised_ = true;
return true;
}
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
bool Hash::HashUpdate(const char* data, int len) {
crypto: refactor crypto classes
12 years ago
if (!initialised_) return false;
EVP_DigestUpdate(&mdctx_, data, len);
return true;
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Hash::HashUpdate(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: split crypto classes
12 years ago
crypto: refactor crypto classes
12 years ago
Hash* hash = ObjectWrap::Unwrap<Hash>(args.This());
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
ASSERT_IS_STRING_OR_BUFFER(args[0]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
// Only copy the data if we have to, because it's a string
crypto: refactor crypto classes
12 years ago
bool r;
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
if (args[0]->IsString()) {
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
Local<String> string = args[0].As<String>();
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
enum encoding encoding = ParseEncoding(args[1], BINARY);
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
if (!StringBytes::IsValidString(string, encoding))
return ThrowTypeError("Bad input string");
size_t buflen = StringBytes::StorageSize(string, encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
char* buf = new char[buflen];
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
size_t written = StringBytes::Write(buf, buflen, string, encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
r = hash->HashUpdate(buf, written);
delete[] buf;
} else {
char* buf = Buffer::Data(args[0]);
size_t buflen = Buffer::Length(args[0]);
r = hash->HashUpdate(buf, buflen);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
crypto: split crypto classes
12 years ago
if (!r) {
crypto: refactor crypto classes
12 years ago
return ThrowTypeError("HashUpdate fail");
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
crypto: split crypto classes
12 years ago
}
Lint node_crypto.cc
15 years ago
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Hash::HashDigest(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: split crypto classes
12 years ago
crypto: refactor crypto classes
12 years ago
Hash* hash = ObjectWrap::Unwrap<Hash>(args.This());
crypto: split crypto classes
12 years ago
if (!hash->initialised_) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Not initialized");
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
enum encoding encoding = BUFFER;
if (args.Length() >= 1) {
encoding = ParseEncoding(args[0]->ToString(), BUFFER);
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
unsigned char md_value[EVP_MAX_MD_SIZE];
unsigned int md_len;
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
EVP_DigestFinal_ex(&hash->mdctx_, md_value, &md_len);
EVP_MD_CTX_cleanup(&hash->mdctx_);
crypto: split crypto classes
12 years ago
hash->initialised_ = false;
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
Local<Value> rc = StringBytes::Encode(
reinterpret_cast<const char*>(md_value), md_len, encoding);
args.GetReturnValue().Set(rc);
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
void Sign::Initialize(v8::Handle<v8::Object> target) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: split crypto classes
12 years ago
Local<FunctionTemplate> t = FunctionTemplate::New(New);
t->InstanceTemplate()->SetInternalFieldCount(1);
NODE_SET_PROTOTYPE_METHOD(t, "init", SignInit);
NODE_SET_PROTOTYPE_METHOD(t, "update", SignUpdate);
NODE_SET_PROTOTYPE_METHOD(t, "sign", SignFinal);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Sign"), t->GetFunction());
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Sign::New(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: refactor crypto classes
12 years ago
Sign* sign = new Sign();
sign->Wrap(args.This());
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Sign::SignInit(const char* sign_type) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
assert(md_ == NULL);
md_ = EVP_get_digestbyname(sign_type);
if (!md_) {
return ThrowError("Uknown message digest");
}
EVP_MD_CTX_init(&mdctx_);
EVP_SignInit_ex(&mdctx_, md_, NULL);
initialised_ = true;
crypto: split crypto classes
12 years ago
}
fast buffers for crypto
15 years ago
Fix a bunch of memory leaks in node_crypto
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Sign::SignInit(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: split crypto classes
12 years ago
crypto: refactor crypto classes
12 years ago
Sign* sign = ObjectWrap::Unwrap<Sign>(args.This());
Fix a few compiler warnings...
14 years ago
crypto: split crypto classes
12 years ago
if (args.Length() == 0 || !args[0]->IsString()) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Must give signtype string as argument");
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value sign_type(args[0]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
sign->SignInit(*sign_type);
crypto: refactor crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
bool Sign::SignUpdate(const char* data, int len) {
crypto: refactor crypto classes
12 years ago
if (!initialised_) return false;
EVP_SignUpdate(&mdctx_, data, len);
return true;
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Sign::SignUpdate(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
Sign* sign = ObjectWrap::Unwrap<Sign>(args.This());
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
ASSERT_IS_STRING_OR_BUFFER(args[0]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
// Only copy the data if we have to, because it's a string
int r;
if (args[0]->IsString()) {
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
Local<String> string = args[0].As<String>();
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
enum encoding encoding = ParseEncoding(args[1], BINARY);
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
if (!StringBytes::IsValidString(string, encoding))
return ThrowTypeError("Bad input string");
size_t buflen = StringBytes::StorageSize(string, encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
char* buf = new char[buflen];
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
size_t written = StringBytes::Write(buf, buflen, string, encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
r = sign->SignUpdate(buf, written);
delete[] buf;
} else {
char* buf = Buffer::Data(args[0]);
size_t buflen = Buffer::Length(args[0]);
r = sign->SignUpdate(buf, buflen);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
crypto: split crypto classes
12 years ago
if (!r) {
crypto: refactor crypto classes
12 years ago
return ThrowTypeError("SignUpdate fail");
Fix resource leaks in node_crypto.cc Fixes #1097.
14 years ago
}
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
bool Sign::SignFinal(unsigned char** md_value,
unsigned int *md_len,
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const char* key_pem,
crypto: refactor crypto classes
12 years ago
int key_pem_len) {
if (!initialised_) return false;
BIO* bp = NULL;
EVP_PKEY* pkey = NULL;
bp = BIO_new(BIO_s_mem());
if (!BIO_write(bp, key_pem, key_pem_len)) return false;
pkey = PEM_read_bio_PrivateKey(bp, NULL, NULL, NULL);
if (pkey == NULL) return 0;
EVP_SignFinal(&mdctx_, *md_value, md_len, pkey);
EVP_MD_CTX_cleanup(&mdctx_);
initialised_ = false;
EVP_PKEY_free(pkey);
crypto: replace BIO_free with BIO_free_all From OpenSSL&#39;s documentation: &#34;If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.&#34; and &#34;BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain&#34;
12 years ago
BIO_free_all(bp);
crypto: refactor crypto classes
12 years ago
return true;
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Sign::SignFinal(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
Sign* sign = ObjectWrap::Unwrap<Sign>(args.This());
crypto: split crypto classes
12 years ago
unsigned char* md_value;
unsigned int md_len;
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
enum encoding encoding = BUFFER;
if (args.Length() >= 2) {
encoding = ParseEncoding(args[1]->ToString(), BUFFER);
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
ASSERT_IS_BUFFER(args[0]);
ssize_t len = Buffer::Length(args[0]);
crypto: refactor crypto classes
12 years ago
char* buf = Buffer::Data(args[0]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: lint c++ code
12 years ago
md_len = 8192; // Maximum key size is 8192 bits
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c lib/http.js src/node_crypto.cc src/node_os.cc src/node_version.h test/simple/helper-debugger-repl.js
12 years ago
md_value = new unsigned char[md_len];
Fix a few compiler warnings...
14 years ago
crypto: refactor crypto classes
12 years ago
bool r = sign->SignFinal(&md_value, &md_len, buf, len);
if (!r) {
delete[] md_value;
crypto: split crypto classes
12 years ago
md_value = NULL;
crypto: refactor crypto classes
12 years ago
md_len = 0;
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
Local<Value> rc = StringBytes::Encode(
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
reinterpret_cast<const char*>(md_value), md_len, encoding);
delete[] md_value;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(rc);
crypto: split crypto classes
12 years ago
}
void Verify::Initialize(v8::Handle<v8::Object> target) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Lint node_crypto.cc
15 years ago
crypto: split crypto classes
12 years ago
Local<FunctionTemplate> t = FunctionTemplate::New(New);
t->InstanceTemplate()->SetInternalFieldCount(1);
NODE_SET_PROTOTYPE_METHOD(t, "init", VerifyInit);
NODE_SET_PROTOTYPE_METHOD(t, "update", VerifyUpdate);
NODE_SET_PROTOTYPE_METHOD(t, "verify", VerifyFinal);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Verify"), t->GetFunction());
crypto: split crypto classes
12 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Verify::New(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: refactor crypto classes
12 years ago
Verify* verify = new Verify();
verify->Wrap(args.This());
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Verify::VerifyInit(const char* verify_type) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
assert(md_ == NULL);
md_ = EVP_get_digestbyname(verify_type);
if (md_ == NULL) {
return ThrowError("Unknown message digest");
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
EVP_MD_CTX_init(&mdctx_);
EVP_VerifyInit_ex(&mdctx_, md_, NULL);
initialised_ = true;
crypto: split crypto classes
12 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Verify::VerifyInit(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
Verify* verify = ObjectWrap::Unwrap<Verify>(args.This());
crypto: split crypto classes
12 years ago
if (args.Length() == 0 || !args[0]->IsString()) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Must give verifytype string as argument");
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value verify_type(args[0]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
verify->VerifyInit(*verify_type);
crypto: refactor crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
bool Verify::VerifyUpdate(const char* data, int len) {
crypto: refactor crypto classes
12 years ago
if (!initialised_) return false;
EVP_VerifyUpdate(&mdctx_, data, len);
return true;
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Verify::VerifyUpdate(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
Verify* verify = ObjectWrap::Unwrap<Verify>(args.This());
Fix a few compiler warnings...
14 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
ASSERT_IS_STRING_OR_BUFFER(args[0]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
// Only copy the data if we have to, because it's a string
crypto: refactor crypto classes
12 years ago
bool r;
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
if (args[0]->IsString()) {
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
Local<String> string = args[0].As<String>();
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
enum encoding encoding = ParseEncoding(args[1], BINARY);
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
if (!StringBytes::IsValidString(string, encoding))
return ThrowTypeError("Bad input string");
size_t buflen = StringBytes::StorageSize(string, encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
char* buf = new char[buflen];
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/src/version.c deps/uv/src/win/fs.c src/node.cc src/node_crypto.cc src/node_os.cc src/node_version.h
12 years ago
size_t written = StringBytes::Write(buf, buflen, string, encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
r = verify->VerifyUpdate(buf, written);
delete[] buf;
} else {
char* buf = Buffer::Data(args[0]);
size_t buflen = Buffer::Length(args[0]);
r = verify->VerifyUpdate(buf, buflen);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
Lint node_crypto.cc
15 years ago
crypto: split crypto classes
12 years ago
if (!r) {
crypto: refactor crypto classes
12 years ago
return ThrowTypeError("VerifyUpdate fail");
crypto: split crypto classes
12 years ago
}
}
Fix a few compiler warnings...
14 years ago
fast buffers for crypto
15 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
bool Verify::VerifyFinal(const char* key_pem,
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
int key_pem_len,
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const char* sig,
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
int siglen) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Fix a bunch of memory leaks in node_crypto
15 years ago
crypto: refactor crypto classes
12 years ago
if (!initialised_) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
ThrowError("Verify not initalised");
return false;
crypto: refactor crypto classes
12 years ago
}
crypto: split crypto classes
12 years ago
crypto: refactor crypto classes
12 years ago
EVP_PKEY* pkey = NULL;
BIO* bp = NULL;
X509* x509 = NULL;
bool fatal = true;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
int r = 0;
Fix a few compiler warnings...
14 years ago
crypto: refactor crypto classes
12 years ago
bp = BIO_new(BIO_s_mem());
if (bp == NULL)
goto exit;
if (!BIO_write(bp, key_pem, key_pem_len))
goto exit;
// Check if this is a PKCS#8 or RSA public key before trying as X.509.
// Split this out into a separate function once we have more than one
// consumer of public keys.
if (strncmp(key_pem, PUBLIC_KEY_PFX, PUBLIC_KEY_PFX_LEN) == 0) {
pkey = PEM_read_bio_PUBKEY(bp, NULL, NULL, NULL);
if (pkey == NULL)
goto exit;
} else if (strncmp(key_pem, PUBRSA_KEY_PFX, PUBRSA_KEY_PFX_LEN) == 0) {
RSA* rsa = PEM_read_bio_RSAPublicKey(bp, NULL, NULL, NULL);
if (rsa) {
pkey = EVP_PKEY_new();
if (pkey) EVP_PKEY_set1_RSA(pkey, rsa);
RSA_free(rsa);
}
if (pkey == NULL)
goto exit;
} else {
// X.509 fallback
x509 = PEM_read_bio_X509(bp, NULL, NULL, NULL);
if (x509 == NULL)
goto exit;
pkey = X509_get_pubkey(x509);
if (pkey == NULL)
goto exit;
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
crypto: refactor crypto classes
12 years ago
fatal = false;
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
r = EVP_VerifyFinal(&mdctx_,
reinterpret_cast<const unsigned char*>(sig),
siglen,
pkey);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: lint c++ code
12 years ago
exit:
crypto: refactor crypto classes
12 years ago
if (pkey != NULL)
EVP_PKEY_free(pkey);
if (bp != NULL)
BIO_free_all(bp);
if (x509 != NULL)
X509_free(x509);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
EVP_MD_CTX_cleanup(&mdctx_);
initialised_ = false;
if (fatal) {
unsigned long err = ERR_get_error();
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
ThrowCryptoError(err);
return false;
crypto: split crypto classes
12 years ago
}
Lint node_crypto.cc
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return r == 1;
crypto: refactor crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Verify::VerifyFinal(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
Verify* verify = ObjectWrap::Unwrap<Verify>(args.This());
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: refactor crypto classes
12 years ago
ASSERT_IS_BUFFER(args[0]);
char* kbuf = Buffer::Data(args[0]);
ssize_t klen = Buffer::Length(args[0]);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
ASSERT_IS_STRING_OR_BUFFER(args[1]);
// BINARY works for both buffers and binary strings.
enum encoding encoding = BINARY;
if (args.Length() >= 3) {
encoding = ParseEncoding(args[2]->ToString(), BINARY);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
crypto: refactor crypto classes
12 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
ssize_t hlen = StringBytes::Size(args[1], encoding);
Lint node_crypto.cc
15 years ago
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
// only copy if we need to, because it's a string.
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
char* hbuf;
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
if (args[1]->IsString()) {
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
hbuf = new char[hlen];
ssize_t hwritten = StringBytes::Write(hbuf, hlen, args[1], encoding);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
assert(hwritten == hlen);
} else {
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
hbuf = Buffer::Data(args[1]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
bool rc = verify->VerifyFinal(kbuf, klen, hbuf, hlen);
Merge remote-tracking branch &#39;ry/v0.10&#39; into master Conflicts: AUTHORS ChangeLog deps/uv/ChangeLog deps/uv/config-unix.mk deps/uv/src/unix/stream.c deps/uv/src/version.c deps/uv/uv.gyp src/node.cc src/node_buffer.cc src/node_crypto.cc src/node_version.h src/stream_wrap.cc src/stream_wrap.h
12 years ago
if (args[1]->IsString()) {
delete[] hbuf;
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(rc);
crypto: split crypto classes
12 years ago
}
Lint node_crypto.cc
15 years ago
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
void DiffieHellman::Initialize(v8::Handle<v8::Object> target) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
Local<FunctionTemplate> t = FunctionTemplate::New(New);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
Fix a bunch of memory leaks in node_crypto
15 years ago
crypto: split crypto classes
12 years ago
NODE_SET_PROTOTYPE_METHOD(t, "generateKeys", GenerateKeys);
NODE_SET_PROTOTYPE_METHOD(t, "computeSecret", ComputeSecret);
NODE_SET_PROTOTYPE_METHOD(t, "getPrime", GetPrime);
NODE_SET_PROTOTYPE_METHOD(t, "getGenerator", GetGenerator);
NODE_SET_PROTOTYPE_METHOD(t, "getPublicKey", GetPublicKey);
NODE_SET_PROTOTYPE_METHOD(t, "getPrivateKey", GetPrivateKey);
NODE_SET_PROTOTYPE_METHOD(t, "setPublicKey", SetPublicKey);
NODE_SET_PROTOTYPE_METHOD(t, "setPrivateKey", SetPrivateKey);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "DiffieHellman"),
t->GetFunction());
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
Local<FunctionTemplate> t2 = FunctionTemplate::New(DiffieHellmanGroup);
t2->InstanceTemplate()->SetInternalFieldCount(1);
NODE_SET_PROTOTYPE_METHOD(t2, "generateKeys", GenerateKeys);
NODE_SET_PROTOTYPE_METHOD(t2, "computeSecret", ComputeSecret);
NODE_SET_PROTOTYPE_METHOD(t2, "getPrime", GetPrime);
NODE_SET_PROTOTYPE_METHOD(t2, "getGenerator", GetGenerator);
NODE_SET_PROTOTYPE_METHOD(t2, "getPublicKey", GetPublicKey);
NODE_SET_PROTOTYPE_METHOD(t2, "getPrivateKey", GetPrivateKey);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "DiffieHellmanGroup"),
t2->GetFunction());
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: split crypto classes
12 years ago
bool DiffieHellman::Init(int primeLength) {
dh = DH_new();
DH_generate_parameters_ex(dh, primeLength, DH_GENERATOR_2, 0);
bool result = VerifyContext();
if (!result) return false;
initialised_ = true;
return true;
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
bool DiffieHellman::Init(const char* p, int p_len) {
crypto: split crypto classes
12 years ago
dh = DH_new();
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
dh->p = BN_bin2bn(reinterpret_cast<const unsigned char*>(p), p_len, 0);
crypto: split crypto classes
12 years ago
dh->g = BN_new();
if (!BN_set_word(dh->g, 2)) return false;
bool result = VerifyContext();
if (!result) return false;
initialised_ = true;
return true;
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
bool DiffieHellman::Init(const char* p, int p_len, const char* g, int g_len) {
crypto: split crypto classes
12 years ago
dh = DH_new();
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
dh->p = BN_bin2bn(reinterpret_cast<const unsigned char*>(p), p_len, 0);
dh->g = BN_bin2bn(reinterpret_cast<const unsigned char*>(g), g_len, 0);
crypto: split crypto classes
12 years ago
initialised_ = true;
return true;
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DiffieHellman::DiffieHellmanGroup(
const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
crypto: split crypto classes
12 years ago
DiffieHellman* diffieHellman = new DiffieHellman();
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
crypto: split crypto classes
12 years ago
if (args.Length() != 1 || !args[0]->IsString()) {
crypto: refactor crypto classes
12 years ago
return ThrowError("No group name given");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
const String::Utf8Value group_name(args[0]);
crypto: simplify DH modp group name matcher * Use ARRAY_SIZE() rather than scanning until we hit a NULL entry. * Fix `-fsigned-char -Wnarrowing` compiler warnings. Harmless but numerous and annoying. * Static-ify the modp_group and mod_groups arrays. * Const-ify the modp_groups array.
12 years ago
for (unsigned int i = 0; i < ARRAY_SIZE(modp_groups); ++i) {
const modp_group* it = modp_groups + i;
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: simplify DH modp group name matcher * Use ARRAY_SIZE() rather than scanning until we hit a NULL entry. * Fix `-fsigned-char -Wnarrowing` compiler warnings. Harmless but numerous and annoying. * Static-ify the modp_group and mod_groups arrays. * Const-ify the modp_groups array.
12 years ago
if (strcasecmp(*group_name, it->name) != 0)
continue;
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: refactor crypto classes
12 years ago
diffieHellman->Init(it->prime,
it->prime_size,
it->gen,
it->gen_size);
crypto: simplify DH modp group name matcher * Use ARRAY_SIZE() rather than scanning until we hit a NULL entry. * Fix `-fsigned-char -Wnarrowing` compiler warnings. Harmless but numerous and annoying. * Static-ify the modp_group and mod_groups arrays. * Const-ify the modp_groups array.
12 years ago
diffieHellman->Wrap(args.This());
return;
crypto: split crypto classes
12 years ago
}
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
crypto: simplify DH modp group name matcher * Use ARRAY_SIZE() rather than scanning until we hit a NULL entry. * Fix `-fsigned-char -Wnarrowing` compiler warnings. Harmless but numerous and annoying. * Static-ify the modp_group and mod_groups arrays. * Const-ify the modp_groups array.
12 years ago
ThrowError("Unknown group");
crypto: split crypto classes
12 years ago
}
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DiffieHellman::New(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
crypto: split crypto classes
12 years ago
DiffieHellman* diffieHellman = new DiffieHellman();
bool initialized = false;
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
crypto: split crypto classes
12 years ago
if (args.Length() > 0) {
if (args[0]->IsInt32()) {
initialized = diffieHellman->Init(args[0]->Int32Value());
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
} else {
src: const-ify variables in src/node_crypto* No functional changes, just some code tightening. Clean up some style inconsistencies while we are here.
12 years ago
initialized = diffieHellman->Init(Buffer::Data(args[0]),
Buffer::Length(args[0]));
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
}
crypto: split crypto classes
12 years ago
}
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
crypto: split crypto classes
12 years ago
if (!initialized) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Initialization failed");
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
}
crypto: split crypto classes
12 years ago
diffieHellman->Wrap(args.This());
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DiffieHellman::GenerateKeys(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: refactor crypto classes
12 years ago
DiffieHellman* diffieHellman =
ObjectWrap::Unwrap<DiffieHellman>(args.This());
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Not initialized");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
crypto: split crypto classes
12 years ago
if (!DH_generate_key(diffieHellman->dh)) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Key generation failed");
crypto: split crypto classes
12 years ago
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
int dataSize = BN_num_bytes(diffieHellman->dh->pub_key);
char* data = new char[dataSize];
BN_bn2bin(diffieHellman->dh->pub_key,
crypto: refactor crypto classes
12 years ago
reinterpret_cast<unsigned char*>(data));
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(Encode(data, dataSize, BUFFER));
crypto: split crypto classes
12 years ago
delete[] data;
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DiffieHellman::GetPrime(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: refactor crypto classes
12 years ago
DiffieHellman* diffieHellman =
ObjectWrap::Unwrap<DiffieHellman>(args.This());
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Not initialized");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
crypto: split crypto classes
12 years ago
int dataSize = BN_num_bytes(diffieHellman->dh->p);
char* data = new char[dataSize];
BN_bn2bin(diffieHellman->dh->p, reinterpret_cast<unsigned char*>(data));
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(Encode(data, dataSize, BUFFER));
crypto: split crypto classes
12 years ago
delete[] data;
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DiffieHellman::GetGenerator(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: split crypto classes
12 years ago
crypto: refactor crypto classes
12 years ago
DiffieHellman* diffieHellman =
ObjectWrap::Unwrap<DiffieHellman>(args.This());
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Not initialized");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
crypto: split crypto classes
12 years ago
int dataSize = BN_num_bytes(diffieHellman->dh->g);
char* data = new char[dataSize];
BN_bn2bin(diffieHellman->dh->g, reinterpret_cast<unsigned char*>(data));
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(Encode(data, dataSize, BUFFER));
crypto: split crypto classes
12 years ago
delete[] data;
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DiffieHellman::GetPublicKey(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: refactor crypto classes
12 years ago
DiffieHellman* diffieHellman =
ObjectWrap::Unwrap<DiffieHellman>(args.This());
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Not initialized");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
crypto: split crypto classes
12 years ago
if (diffieHellman->dh->pub_key == NULL) {
crypto: refactor crypto classes
12 years ago
return ThrowError("No public key - did you forget to generate one?");
crypto: split crypto classes
12 years ago
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
int dataSize = BN_num_bytes(diffieHellman->dh->pub_key);
char* data = new char[dataSize];
BN_bn2bin(diffieHellman->dh->pub_key,
crypto: refactor crypto classes
12 years ago
reinterpret_cast<unsigned char*>(data));
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(Encode(data, dataSize, BUFFER));
crypto: split crypto classes
12 years ago
delete[] data;
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DiffieHellman::GetPrivateKey(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: refactor crypto classes
12 years ago
DiffieHellman* diffieHellman =
ObjectWrap::Unwrap<DiffieHellman>(args.This());
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Not initialized");
crypto: split crypto classes
12 years ago
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
if (diffieHellman->dh->priv_key == NULL) {
crypto: refactor crypto classes
12 years ago
return ThrowError("No private key - did you forget to generate one?");
crypto: split crypto classes
12 years ago
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
int dataSize = BN_num_bytes(diffieHellman->dh->priv_key);
char* data = new char[dataSize];
BN_bn2bin(diffieHellman->dh->priv_key,
crypto: refactor crypto classes
12 years ago
reinterpret_cast<unsigned char*>(data));
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(Encode(data, dataSize, BUFFER));
crypto: split crypto classes
12 years ago
delete[] data;
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DiffieHellman::ComputeSecret(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
DiffieHellman* diffieHellman =
crypto: refactor crypto classes
12 years ago
ObjectWrap::Unwrap<DiffieHellman>(args.This());
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Not initialized");
crypto: split crypto classes
12 years ago
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
Merge remote-tracking branch ry/v0.10 into master Conflicts: AUTHORS ChangeLog src/node_crypto.cc src/node_version.h
12 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence compiler warning.
crypto: refactor crypto classes
12 years ago
BIGNUM* key = NULL;
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
if (args.Length() == 0) {
crypto: refactor crypto classes
12 years ago
return ThrowError("First argument must be other party's public key");
crypto: split crypto classes
12 years ago
} else {
ASSERT_IS_BUFFER(args[0]);
key = BN_bin2bn(
crypto: refactor crypto classes
12 years ago
reinterpret_cast<unsigned char*>(Buffer::Data(args[0])),
Buffer::Length(args[0]),
0);
crypto: split crypto classes
12 years ago
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
int dataSize = DH_size(diffieHellman->dh);
char* data = new char[dataSize];
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
int size = DH_compute_key(reinterpret_cast<unsigned char*>(data),
crypto: refactor crypto classes
12 years ago
key,
diffieHellman->dh);
crypto: add padding to diffie-hellman key DH_size returns number of bytes in a prime number, DH_compute_key returns number of bytes in a remainder of exponent, which may have less bytes than a prime number. Therefore add 0-padding to the allocated buffer. Fixes #3372
13 years ago
crypto: split crypto classes
12 years ago
if (size == -1) {
int checkResult;
int checked;
crypto: fix DH use-after-free and memory leak Fix a use-after-free bug and a memory leak in the error path of DiffieHellman::ComputeSecret(). * the BIGNUM key was used after being freed with BN_free(). * the output buffer was not freed
12 years ago
crypto: split crypto classes
12 years ago
checked = DH_check_pub_key(diffieHellman->dh, key, &checkResult);
BN_free(key);
delete[] data;
crypto: fix DH use-after-free and memory leak Fix a use-after-free bug and a memory leak in the error path of DiffieHellman::ComputeSecret(). * the BIGNUM key was used after being freed with BN_free(). * the output buffer was not freed
12 years ago
crypto: split crypto classes
12 years ago
if (!checked) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Invalid key");
crypto: split crypto classes
12 years ago
} else if (checkResult) {
if (checkResult & DH_CHECK_PUBKEY_TOO_SMALL) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Supplied key is too small");
crypto: split crypto classes
12 years ago
} else if (checkResult & DH_CHECK_PUBKEY_TOO_LARGE) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Supplied key is too large");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
} else {
crypto: refactor crypto classes
12 years ago
return ThrowError("Invalid key");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
crypto: split crypto classes
12 years ago
} else {
crypto: refactor crypto classes
12 years ago
return ThrowError("Invalid key");
crypto: fix DH 1 byte buffer underflow Passing a bad key to DiffieHellman::ComputeSecret() made it zero the byte before the heap allocated buffer due to an erroneous size calculation.
12 years ago
}
crypto: split crypto classes
12 years ago
}
crypto: fix DH 1 byte buffer underflow Passing a bad key to DiffieHellman::ComputeSecret() made it zero the byte before the heap allocated buffer due to an erroneous size calculation.
12 years ago
crypto: split crypto classes
12 years ago
BN_free(key);
assert(size >= 0);
crypto: fix DH 1 byte buffer underflow Passing a bad key to DiffieHellman::ComputeSecret() made it zero the byte before the heap allocated buffer due to an erroneous size calculation.
12 years ago
crypto: split crypto classes
12 years ago
// DH_size returns number of bytes in a prime number
// DH_compute_key returns number of bytes in a remainder of exponent, which
// may have less bytes than a prime number. Therefore add 0-padding to the
// allocated buffer.
if (size != dataSize) {
assert(dataSize > size);
Merge branch &#39;v0.10&#39; Conflicts: ChangeLog deps/uv/src/version.c src/node.h src/node_crypto.cc src/node_crypto_bio.cc src/node_crypto_bio.h src/node_object_wrap.h src/node_version.h
12 years ago
memmove(data + dataSize - size, data, size);
memset(data, 0, dataSize - size);
crypto: split crypto classes
12 years ago
}
crypto: fix DH 1 byte buffer underflow Passing a bad key to DiffieHellman::ComputeSecret() made it zero the byte before the heap allocated buffer due to an erroneous size calculation.
12 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(Encode(data, dataSize, BUFFER));
crypto: split crypto classes
12 years ago
delete[] data;
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DiffieHellman::SetPublicKey(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
DiffieHellman* diffieHellman =
crypto: refactor crypto classes
12 years ago
ObjectWrap::Unwrap<DiffieHellman>(args.This());
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Not initialized");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
crypto: split crypto classes
12 years ago
if (args.Length() == 0) {
crypto: refactor crypto classes
12 years ago
return ThrowError("First argument must be public key");
crypto: split crypto classes
12 years ago
} else {
ASSERT_IS_BUFFER(args[0]);
crypto: refactor crypto classes
12 years ago
diffieHellman->dh->pub_key = BN_bin2bn(
crypto: split crypto classes
12 years ago
reinterpret_cast<unsigned char*>(Buffer::Data(args[0])),
Buffer::Length(args[0]), 0);
}
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DiffieHellman::SetPrivateKey(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
DiffieHellman* diffieHellman =
crypto: refactor crypto classes
12 years ago
ObjectWrap::Unwrap<DiffieHellman>(args.This());
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
crypto: refactor crypto classes
12 years ago
return ThrowError("Not initialized");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
crypto: split crypto classes
12 years ago
if (args.Length() == 0) {
crypto: refactor crypto classes
12 years ago
return ThrowError("First argument must be private key");
crypto: split crypto classes
12 years ago
} else {
ASSERT_IS_BUFFER(args[0]);
crypto: refactor crypto classes
12 years ago
diffieHellman->dh->priv_key = BN_bin2bn(
crypto: split crypto classes
12 years ago
reinterpret_cast<unsigned char*>(Buffer::Data(args[0])),
crypto: refactor crypto classes
12 years ago
Buffer::Length(args[0]),
0);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
crypto: split crypto classes
12 years ago
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
bool DiffieHellman::VerifyContext() {
int codes;
if (!DH_check(dh, &codes)) return false;
if (codes & DH_CHECK_P_NOT_SAFE_PRIME) return false;
if (codes & DH_CHECK_P_NOT_PRIME) return false;
if (codes & DH_UNABLE_TO_CHECK_GENERATOR) return false;
if (codes & DH_NOT_SUITABLE_GENERATOR) return false;
return true;
}
Revert &#34;Disable compression with OpenSSL.&#34; This reverts commit 362785f704b5754f6025bc4bcbe5835688d3002c.
14 years ago
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
crypto: PBKDF2 function from OpenSSL
14 years ago
struct pbkdf2_req {
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
uv_work_t work_req;
crypto: PBKDF2 function from OpenSSL
14 years ago
int err;
char* pass;
size_t passlen;
char* salt;
size_t saltlen;
size_t iter;
char* key;
size_t keylen;
crypto: make pbkdf2() compatible with domains
12 years ago
Persistent<Object> obj;
crypto: PBKDF2 function from OpenSSL
14 years ago
};
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
void EIO_PBKDF2(pbkdf2_req* req) {
req->err = PKCS5_PBKDF2_HMAC_SHA1(
req->pass,
req->passlen,
(unsigned char*)req->salt,
req->saltlen,
req->iter,
req->keylen,
(unsigned char*)req->key);
memset(req->pass, 0, req->passlen);
memset(req->salt, 0, req->saltlen);
crypto: PBKDF2 function from OpenSSL
14 years ago
}
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
void EIO_PBKDF2(uv_work_t* work_req) {
pbkdf2_req* req = container_of(work_req, pbkdf2_req, work_req);
EIO_PBKDF2(req);
}
Use new uv_fs_ apis This will cause master to be unstable for a while as we replace existing eio calls with uv_fs calls.
14 years ago
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
void EIO_PBKDF2After(pbkdf2_req* req, Local<Value> argv[2]) {
if (req->err) {
src: remove unnecessary calls to Local&lt;T&gt;::New()
12 years ago
argv[0] = Undefined(node_isolate);
crypto: Binding only accepts buffers
12 years ago
argv[1] = Encode(req->key, req->keylen, BUFFER);
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
memset(req->key, 0, req->keylen);
crypto: PBKDF2 function from OpenSSL
14 years ago
} else {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
argv[0] = Exception::Error(
FIXED_ONE_BYTE_STRING(node_isolate, "PBKDF2 error"));
src: remove unnecessary calls to Local&lt;T&gt;::New()
12 years ago
argv[1] = Undefined(node_isolate);
crypto: PBKDF2 function from OpenSSL
14 years ago
}
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
delete[] req->pass;
delete[] req->salt;
delete[] req->key;
delete req;
}
crypto: PBKDF2 function from OpenSSL
14 years ago
deps: upgrade libuv to e079a99
12 years ago
void EIO_PBKDF2After(uv_work_t* work_req, int status) {
assert(status == 0);
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
pbkdf2_req* req = container_of(work_req, pbkdf2_req, work_req);
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
src: use PersistentToLocal() in a few more places Update a few more `Local&lt;T&gt;::New(isolate, persistent)` call sites to `PersistentToLocal(isolate, persistent)` - the latter has a fast path for non-weak persistent references.
12 years ago
// Create a new Local that's associated with the current HandleScope.
// PersistentToLocal() returns a handle that gets zeroed when we call
// Dispose() so don't use that.
src: fix persistent handle lifecycle issue Commit 636ca7c adds an optimization that casts strong Persistent&lt;T&gt; handles directly to Local&lt;T&gt; handles to avoid the overhead of creating new HandleScope-rooted Local&lt;T&gt; handles all the time. One gotcha that I missed is that it&#39;s no longer legal to reference the Local&lt;T&gt; after calling Persistent&lt;T&gt;::Dispose(). This commit addresses that.
12 years ago
Local<Object> obj = Local<Object>::New(node_isolate, req->obj);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
req->obj.Dispose();
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
Local<Value> argv[2];
EIO_PBKDF2After(req, argv);
Merge remote-tracking branch &#39;origin/v0.8&#39; Conflicts: deps/uv/include/uv.h src/node_crypto.cc
12 years ago
MakeCallback(obj, "ondone", ARRAY_SIZE(argv), argv);
crypto: PBKDF2 function from OpenSSL
14 years ago
}
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void PBKDF2(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: PBKDF2 function from OpenSSL
14 years ago
crypto: fix memory leaks in PBKDF2 error path
13 years ago
const char* type_error = NULL;
char* pass = NULL;
char* salt = NULL;
ssize_t passlen = -1;
ssize_t saltlen = -1;
ssize_t keylen = -1;
ssize_t pass_written = -1;
ssize_t salt_written = -1;
ssize_t iter = -1;
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
pbkdf2_req* req = NULL;
crypto: fix memory leaks in PBKDF2 error path
13 years ago
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
if (args.Length() != 4 && args.Length() != 5) {
crypto: fix memory leaks in PBKDF2 error path
13 years ago
type_error = "Bad parameter";
goto err;
}
crypto: PBKDF2 function from OpenSSL
14 years ago
crypto: Binding only accepts buffers
12 years ago
ASSERT_IS_BUFFER(args[0]);
crypto: Remove many unnecessary toObjects
12 years ago
passlen = Buffer::Length(args[0]);
crypto: fix memory leaks in PBKDF2 error path
13 years ago
if (passlen < 0) {
type_error = "Bad password";
goto err;
}
pass = new char[passlen];
pass_written = DecodeWrite(pass, passlen, args[0], BINARY);
crypto: PBKDF2 function from OpenSSL
14 years ago
assert(pass_written == passlen);
crypto: Binding only accepts buffers
12 years ago
ASSERT_IS_BUFFER(args[1]);
crypto: Remove many unnecessary toObjects
12 years ago
saltlen = Buffer::Length(args[1]);
crypto: fix memory leaks in PBKDF2 error path
13 years ago
if (saltlen < 0) {
type_error = "Bad salt";
goto err;
}
salt = new char[saltlen];
salt_written = DecodeWrite(salt, saltlen, args[1], BINARY);
crypto: PBKDF2 function from OpenSSL
14 years ago
assert(salt_written == saltlen);
crypto: fix memory leaks in PBKDF2 error path
13 years ago
if (!args[2]->IsNumber()) {
type_error = "Iterations not a number";
goto err;
}
crypto: PBKDF2 function from OpenSSL
14 years ago
crypto: fix memory leaks in PBKDF2 error path
13 years ago
iter = args[2]->Int32Value();
if (iter < 0) {
type_error = "Bad iterations";
goto err;
}
crypto: PBKDF2 function from OpenSSL
14 years ago
crypto: fix memory leaks in PBKDF2 error path
13 years ago
if (!args[3]->IsNumber()) {
type_error = "Key length not a number";
goto err;
}
crypto: PBKDF2 function from OpenSSL
14 years ago
crypto: fix memory leaks in PBKDF2 error path
13 years ago
keylen = args[3]->Int32Value();
if (keylen < 0) {
type_error = "Bad key length";
goto err;
}
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
req = new pbkdf2_req;
req->err = 0;
req->pass = pass;
req->passlen = passlen;
req->salt = salt;
req->saltlen = saltlen;
req->iter = iter;
req->key = new char[keylen];
req->keylen = keylen;
if (args[4]->IsFunction()) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
Local<Object> obj = Object::New();
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ondone"), args[4]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
req->obj.Reset(node_isolate, obj);
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
uv_queue_work(uv_default_loop(),
&req->work_req,
EIO_PBKDF2,
EIO_PBKDF2After);
} else {
Local<Value> argv[2];
EIO_PBKDF2(req);
EIO_PBKDF2After(req, argv);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (argv[0]->IsObject())
ThrowException(argv[0]);
else
args.GetReturnValue().Set(argv[1]);
crypto: fix memory leaks in PBKDF2 error path
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return;
crypto: PBKDF2 function from OpenSSL
14 years ago
src: lint c++ code
12 years ago
err:
crypto: fix memory leaks in PBKDF2 error path
13 years ago
delete[] salt;
delete[] pass;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return ThrowTypeError(type_error);
crypto: PBKDF2 function from OpenSSL
14 years ago
}
Revert &#34;Disable compression with OpenSSL.&#34; This reverts commit 362785f704b5754f6025bc4bcbe5835688d3002c.
14 years ago
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
struct RandomBytesRequest {
~RandomBytesRequest();
crypto: make randomBytes() compatible with domains Don&#39;t execute the callback in the context of the global object. MakeCallback() tries to apply the active domain to the callback. If the user polluted the global object with a &#39;domain&#39; property, as in the code example below, MakeCallback() will try to apply that. Example: domain = {}; // missing var keyword is intentional crypto.randomBytes(8, cb); // TypeError: undefined is not a function Fixes #3956.
12 years ago
Persistent<Object> obj_;
src: lint c++ code
12 years ago
unsigned long error_; // openssl error code or zero
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
uv_work_t work_req_;
size_t size_;
char* data_;
};
RandomBytesRequest::~RandomBytesRequest() {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
obj_.Dispose();
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
}
crypto: fix -Wtautological-compare warning
12 years ago
template <bool pseudoRandom>
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
void RandomBytesWork(uv_work_t* work_req) {
crypto: fix -Wtautological-compare warning
12 years ago
RandomBytesRequest* req = container_of(work_req,
RandomBytesRequest,
work_req_);
int r;
if (pseudoRandom == true) {
r = RAND_pseudo_bytes(reinterpret_cast<unsigned char*>(req->data_),
req->size_);
} else {
r = RAND_bytes(reinterpret_cast<unsigned char*>(req->data_), req->size_);
}
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
crypto: fix -Wtautological-compare warning
12 years ago
// RAND_bytes() returns 0 on error. RAND_pseudo_bytes() returns 0 when the
// result is not cryptographically strong - but that's not an error.
if (r == 0 && pseudoRandom == false) {
req->error_ = ERR_get_error();
} else if (r == -1) {
req->error_ = static_cast<unsigned long>(-1);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
}
}
crypto: root JS objects in HandleScope with Local&lt;&gt;
13 years ago
// don't call this function without a valid HandleScope
void RandomBytesCheck(RandomBytesRequest* req, Local<Value> argv[2]) {
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
if (req->error_) {
char errmsg[256] = "Operation not supported";
if (req->error_ != (unsigned long) -1)
ERR_error_string_n(req->error_, errmsg, sizeof errmsg);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
argv[0] = Exception::Error(OneByteString(node_isolate, errmsg));
src: remove unnecessary calls to Local&lt;T&gt;::New()
12 years ago
argv[1] = Null(node_isolate);
src: lint c++ code
12 years ago
} else {
src: remove unnecessary calls to Local&lt;T&gt;::New()
12 years ago
argv[0] = Null(node_isolate);
buffer: use smalloc as backing data store Memory allocations are now done through smalloc. The Buffer cc class has been removed completely, but for backwards compatibility have left the namespace as Buffer. The .parent attribute is only set if the Buffer is a slice of an allocation. Which is then set to the alloc object (not a Buffer). The .offset attribute is now a ReadOnly set to 0, for backwards compatibility. I&#39;d like to remove it in the future (pre v1.0). A few alterations have been made to how arguments are either coerced or thrown. All primitives will now be coerced to their respective values, and (most) all out of range index requests will throw. The indexes that are coerced were left for backwards compatibility. For example: Buffer slice operates more like Array slice, and coerces instead of throwing out of range indexes. This may change in the future. The reason for wanting to throw for out of range indexes is because giving js access to raw memory has high potential risk. To mitigate that it&#39;s easier to make sure the developer is always quickly alerted to the fact that their code is attempting to access beyond memory bounds. Because SlowBuffer will be deprecated, and simply returns a new Buffer instance, all tests on SlowBuffer have been removed. Heapdumps will now show usage under &#34;smalloc&#34; instead of &#34;Buffer&#34;. ParseArrayIndex was added to node_internals to support proper uint argument checking/coercion for external array data indexes. SlabAllocator had to be updated since handle_ no longer exists.
12 years ago
argv[1] = Buffer::Use(req->data_, req->size_);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
}
}
deps: upgrade libuv to e079a99
12 years ago
void RandomBytesAfter(uv_work_t* work_req, int status) {
assert(status == 0);
crypto: fix -Wtautological-compare warning
12 years ago
RandomBytesRequest* req = container_of(work_req,
RandomBytesRequest,
work_req_);
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: root JS objects in HandleScope with Local&lt;&gt;
13 years ago
Local<Value> argv[2];
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
RandomBytesCheck(req, argv);
crypto: make randomBytes() compatible with domains Don&#39;t execute the callback in the context of the global object. MakeCallback() tries to apply the active domain to the callback. If the user polluted the global object with a &#39;domain&#39; property, as in the code example below, MakeCallback() will try to apply that. Example: domain = {}; // missing var keyword is intentional crypto.randomBytes(8, cb); // TypeError: undefined is not a function Fixes #3956.
12 years ago
MakeCallback(req->obj_, "ondone", ARRAY_SIZE(argv), argv);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
delete req;
}
crypto: fix -Wtautological-compare warning
12 years ago
template <bool pseudoRandom>
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void RandomBytes(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
// maybe allow a buffer to write to? cuts down on object creation
// when generating random data in a loop
if (!args[0]->IsUint32()) {
crypto: check randomBytes() size argument Throw a TypeError if size &gt; 0x3fffffff. Avoids the following V8 fatal error: FATAL ERROR: v8::Object::SetIndexedPropertiesToExternalArrayData() length exceeds max acceptable value Fixes #5126.
12 years ago
return ThrowTypeError("Argument #1 must be number > 0");
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
}
crypto: check randomBytes() size argument Throw a TypeError if size &gt; 0x3fffffff. Avoids the following V8 fatal error: FATAL ERROR: v8::Object::SetIndexedPropertiesToExternalArrayData() length exceeds max acceptable value Fixes #5126.
12 years ago
const uint32_t size = args[0]->Uint32Value();
if (size > Buffer::kMaxLength) {
return ThrowTypeError("size > Buffer::kMaxLength");
}
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
RandomBytesRequest* req = new RandomBytesRequest();
req->error_ = 0;
req->data_ = new char[size];
req->size_ = size;
if (args[1]->IsFunction()) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
Local<Object> obj = Object::New();
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ondone"), args[1]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
req->obj_.Reset(node_isolate, obj);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
uv_queue_work(uv_default_loop(),
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
&req->work_req_,
crypto: fix -Wtautological-compare warning
12 years ago
RandomBytesWork<pseudoRandom>,
RandomBytesAfter);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(obj);
src: lint c++ code
12 years ago
} else {
crypto: root JS objects in HandleScope with Local&lt;&gt;
13 years ago
Local<Value> argv[2];
crypto: fix -Wtautological-compare warning
12 years ago
RandomBytesWork<pseudoRandom>(&req->work_req_);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
RandomBytesCheck(req, argv);
delete req;
if (!argv[0]->IsNull())
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
ThrowException(argv[0]);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
else
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(argv[1]);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
}
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void GetSSLCiphers(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: add crypto.getCiphers() Returns a list of, unsurprisingly, the available ciphers.
12 years ago
SSL_CTX* ctx = SSL_CTX_new(TLSv1_server_method());
if (ctx == NULL) {
return ThrowError("SSL_CTX_new() failed.");
}
SSL* ssl = SSL_new(ctx);
if (ssl == NULL) {
SSL_CTX_free(ctx);
return ThrowError("SSL_new() failed.");
}
Local<Array> arr = Array::New();
STACK_OF(SSL_CIPHER)* ciphers = SSL_get_ciphers(ssl);
for (int i = 0; i < sk_SSL_CIPHER_num(ciphers); ++i) {
SSL_CIPHER* cipher = sk_SSL_CIPHER_value(ciphers, i);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
arr->Set(i, OneByteString(node_isolate, SSL_CIPHER_get_name(cipher)));
crypto: add crypto.getCiphers() Returns a list of, unsurprisingly, the available ciphers.
12 years ago
}
SSL_free(ssl);
SSL_CTX_free(ctx);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(arr);
crypto: add crypto.getCiphers() Returns a list of, unsurprisingly, the available ciphers.
12 years ago
}
crypto: make getCiphers() return non-SSL ciphers Commit f53441a added crypto.getCiphers() as a function that returns the names of SSL ciphers. Commit 14a6c4e then added crypto.getHashes(), which returns the names of digest algorithms, but that creates a subtle inconsistency: the return values of crypto.getHashes() are valid arguments to crypto.createHash() but that is not true for crypto.getCiphers() - the returned values are only valid for SSL/TLS functions. Rectify that by adding tls.getCiphers() and making crypto.getCiphers() return proper cipher names.
12 years ago
template <class TypeName>
static void array_push_back(const TypeName* md,
const char* from,
const char* to,
void* arg) {
crypto: add crypto.getHashes()
12 years ago
Local<Array>& arr = *static_cast<Local<Array>*>(arg);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
arr->Set(arr->Length(), OneByteString(node_isolate, from));
crypto: add crypto.getHashes()
12 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void GetCiphers(const FunctionCallbackInfo<Value>& args) {
src: add node_isolate to remaining scopes
12 years ago
HandleScope scope(node_isolate);
crypto: make getCiphers() return non-SSL ciphers Commit f53441a added crypto.getCiphers() as a function that returns the names of SSL ciphers. Commit 14a6c4e then added crypto.getHashes(), which returns the names of digest algorithms, but that creates a subtle inconsistency: the return values of crypto.getHashes() are valid arguments to crypto.createHash() but that is not true for crypto.getCiphers() - the returned values are only valid for SSL/TLS functions. Rectify that by adding tls.getCiphers() and making crypto.getCiphers() return proper cipher names.
12 years ago
Local<Array> arr = Array::New();
EVP_CIPHER_do_all_sorted(array_push_back<EVP_CIPHER>, &arr);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(arr);
crypto: make getCiphers() return non-SSL ciphers Commit f53441a added crypto.getCiphers() as a function that returns the names of SSL ciphers. Commit 14a6c4e then added crypto.getHashes(), which returns the names of digest algorithms, but that creates a subtle inconsistency: the return values of crypto.getHashes() are valid arguments to crypto.createHash() but that is not true for crypto.getCiphers() - the returned values are only valid for SSL/TLS functions. Rectify that by adding tls.getCiphers() and making crypto.getCiphers() return proper cipher names.
12 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void GetHashes(const FunctionCallbackInfo<Value>& args) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
crypto: add crypto.getHashes()
12 years ago
Local<Array> arr = Array::New();
crypto: make getCiphers() return non-SSL ciphers Commit f53441a added crypto.getCiphers() as a function that returns the names of SSL ciphers. Commit 14a6c4e then added crypto.getHashes(), which returns the names of digest algorithms, but that creates a subtle inconsistency: the return values of crypto.getHashes() are valid arguments to crypto.createHash() but that is not true for crypto.getCiphers() - the returned values are only valid for SSL/TLS functions. Rectify that by adding tls.getCiphers() and making crypto.getCiphers() return proper cipher names.
12 years ago
EVP_MD_do_all_sorted(array_push_back<EVP_MD>, &arr);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(arr);
crypto: add crypto.getHashes()
12 years ago
}
Initial openssl support for net2
15 years ago
void InitCrypto(Handle<Object> target) {
src: pass Isolate to all applicable api Update the api to pass node_isolate to all supported methods. Much thanks to Ben Noordhuis and his work in 51f6e6a.
12 years ago
HandleScope scope(node_isolate);
Initial openssl support for net2
15 years ago
SSL_library_init();
Additional OpenSSL tests
15 years ago
OpenSSL_add_all_algorithms();
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
OpenSSL_add_all_digests();
Initial openssl support for net2
15 years ago
SSL_load_error_strings();
ERR_load_crypto_strings();
crypto: make module thread-safe
13 years ago
crypto_lock_init();
CRYPTO_set_locking_callback(crypto_lock_cb);
crypto: use CRYPTO_THREADID_set_callback() Don&#39;t use CRYPTO_set_id_callback(), it&#39;s deprecated.
13 years ago
CRYPTO_THREADID_set_callback(crypto_threadid_cb);
crypto: make module thread-safe
13 years ago
Disable compression with OpenSSL. This improves memory and speed. Users may apply compression in &#34;userland&#34; above the CryptoStream layer if they desire.
14 years ago
// Turn off compression. Saves memory - do it in userland.
crypto: check for SSL_COMP_get_compression_methods() Function was named SSL_COMP_get_compression_method() (singular) in OpenSSL 0.9.7 and older. Fixes #1242.
14 years ago
#if !defined(OPENSSL_NO_COMP)
#if OPENSSL_VERSION_NUMBER < 0x00908000L
src: lint c++ code
12 years ago
STACK_OF(SSL_COMP)* comp_methods = SSL_COMP_get_compression_method();
crypto: check for SSL_COMP_get_compression_methods() Function was named SSL_COMP_get_compression_method() (singular) in OpenSSL 0.9.7 and older. Fixes #1242.
14 years ago
#else
src: lint c++ code
12 years ago
STACK_OF(SSL_COMP)* comp_methods = SSL_COMP_get_compression_methods();
crypto: check for SSL_COMP_get_compression_methods() Function was named SSL_COMP_get_compression_method() (singular) in OpenSSL 0.9.7 and older. Fixes #1242.
14 years ago
#endif
Disable compression with OpenSSL. This improves memory and speed. Users may apply compression in &#34;userland&#34; above the CryptoStream layer if they desire.
14 years ago
sk_SSL_COMP_zero(comp_methods);
assert(sk_SSL_COMP_num(comp_methods) == 0);
Disabling SSL compression is dependent on OpenSSL version 0.9.8 Fixes #1087.
14 years ago
#endif
Disable compression with OpenSSL. This improves memory and speed. Users may apply compression in &#34;userland&#34; above the CryptoStream layer if they desire.
14 years ago
Initial openssl support for net2
15 years ago
SecureContext::Initialize(target);
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
Connection::Initialize(target);
crypto: merge Cipher and Decipher
12 years ago
CipherBase::Initialize(target);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
DiffieHellman::Initialize(target);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Hmac::Initialize(target);
Hash::Initialize(target);
Sign::Initialize(target);
Verify::Initialize(target);
Initial openssl support for net2
15 years ago
crypto: PBKDF2 function from OpenSSL
14 years ago
NODE_SET_METHOD(target, "PBKDF2", PBKDF2);
crypto: fix -Wtautological-compare warning
12 years ago
NODE_SET_METHOD(target, "randomBytes", RandomBytes<false>);
NODE_SET_METHOD(target, "pseudoRandomBytes", RandomBytes<true>);
crypto: make getCiphers() return non-SSL ciphers Commit f53441a added crypto.getCiphers() as a function that returns the names of SSL ciphers. Commit 14a6c4e then added crypto.getHashes(), which returns the names of digest algorithms, but that creates a subtle inconsistency: the return values of crypto.getHashes() are valid arguments to crypto.createHash() but that is not true for crypto.getCiphers() - the returned values are only valid for SSL/TLS functions. Rectify that by adding tls.getCiphers() and making crypto.getCiphers() return proper cipher names.
12 years ago
NODE_SET_METHOD(target, "getSSLCiphers", GetSSLCiphers);
crypto: add crypto.getCiphers() Returns a list of, unsurprisingly, the available ciphers.
12 years ago
NODE_SET_METHOD(target, "getCiphers", GetCiphers);
crypto: add crypto.getHashes()
12 years ago
NODE_SET_METHOD(target, "getHashes", GetHashes);
crypto: PBKDF2 function from OpenSSL
14 years ago
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
subject_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "subject");
issuer_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "issuer");
valid_from_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "valid_from");
valid_to_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "valid_to");
subjectaltname_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "subjectaltname");
modulus_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "modulus");
exponent_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "exponent");
fingerprint_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "fingerprint");
name_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "name");
version_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "version");
ext_key_usage_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "ext_key_usage");
Initial openssl support for net2
15 years ago
}
Rename node::SecureStream to node::crypto::Connection node::SecureStream is definitely not a &#34;stream&#34; in the Node sense. Renaming it to avoid ambiguity. (Adding namespace to not confuse with some other Connection object.)
14 years ago
} // namespace crypto
Initial openssl support for net2
15 years ago
} // namespace node
Remove stray NODE_MODULE() semi-colons.
13 years ago
NODE_MODULE(node_crypto, node::crypto::InitCrypto)