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.
11601 Commits
131 Branches
446 Tags
325 MiB
Tree: ff39ecb914
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ff39ecb914'
${ noResults }
node/src/node_crypto.cc

5185 lines
149 KiB
Raw Normal View History

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"
stream_base: introduce StreamBase StreamBase is an improved way to write C++ streams. The class itself is for separting `StreamWrap` (with the methods like `.writeAsciiString`, `.writeBuffer`, `.writev`, etc) from the `HandleWrap` class, making possible to write abstract C++ streams that are not bound to any uv socket. The following methods are important part of the abstraction (which mimics libuv's stream API): * Events: * `OnAlloc(size_t size, uv_buf_t*)` * `OnRead(ssize_t nread, const uv_buf_t*, uv_handle_type pending)` * `OnAfterWrite(WriteWrap*)` * Wrappers: * `DoShutdown(ShutdownWrap*)` * `DoTryWrite(uv_buf_t** bufs, size_t* count)` * `DoWrite(WriteWrap*, uv_buf_t*, size_t count, uv_stream_t* handle)` * `Error()` * `ClearError()` The implementation should provide all of these methods, thus providing the access to the underlying resource (be it uv handle, TLS socket, or anything else). A C++ stream may consume the input of another stream by replacing the event callbacks and proxying the writes. This kind of API is actually used now for the TLSWrap implementation, making it possible to wrap TLS stream into another TLS stream. Thus legacy API calls are no longer required in `_tls_wrap.js`. PR-URL: https://github.com/iojs/io.js/pull/840 Reviewed-By: Trevor Norris <trev.norris@gmail.com> Reviewed-By: Chris Dickinson <christopher.s.dickinson@gmail.com>
10 years ago
#include "tls_wrap.h" // TLSWrap
Initial openssl support for net2
15 years ago
base-object: add BaseObject BaseObject is a class that just handles the Persistent handle attached to the class instance. This also removed WeakObject. Reordering the inheritance chain helps prevent unneeded calls on instances that don't call MakeCallback.
11 years ago
#include "async-wrap.h"
#include "async-wrap-inl.h"
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now "remember" the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
#include "env.h"
#include "env-inl.h"
crypto: Pass strings to binding layer directly
12 years ago
#include "string_bytes.h"
src: use function to get internal pointer Remove the NODE_{WRAP,UNWRAP} macros and instead use template functions.
11 years ago
#include "util.h"
#include "util-inl.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: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
#define THROW_AND_RETURN_IF_NOT_STRING_OR_BUFFER(val) \
do { \
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
if (!Buffer::HasInstance(val) && !val->IsString()) { \
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
#define THROW_AND_RETURN_IF_NOT_BUFFER(val) \
do { \
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
if (!Buffer::HasInstance(val)) { \
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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;
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
static const char CERTIFICATE_PFX[] = "-----BEGIN CERTIFICATE-----";
static const int CERTIFICATE_PFX_LEN = sizeof(CERTIFICATE_PFX) - 1;
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
static const int X509_NAME_FLAGS = ASN1_STRFLGS_ESC_CTRL
tls: fix encoding in certificate-related functions Strings are treated as UTF8 instead of one-byte strings when names are processed and when OpenSSL&#39;s ..._print functions are used. This commit fixes simple/test-tls-peer-certificate-encoding test. fix #8366
10 years ago
| ASN1_STRFLGS_UTF8_CONVERT
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
| 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;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
using v8::Boolean;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
using v8::Context;
src: make accessors immune to context confusion It&#39;s possible for an accessor or named interceptor to get called with a different execution context than the one it lives in, see the test case for an example using the debug API. This commit fortifies against that by passing the environment as a data property instead of looking it up through the current context. Fixes: https://github.com/iojs/io.js/issues/1190 (again) PR-URL: https://github.com/iojs/io.js/pull/1238 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
using v8::DEFAULT;
using v8::DontDelete;
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
using v8::EscapableHandleScope;
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::Exception;
crypto: export externals to internal structs Export External getters for a internal structs: SSL, SSL_CTX.
10 years ago
using v8::External;
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::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;
tls: show human-readable error messages Before this commit, verification exceptions had err.message set to the OpenSSL error code (e.g. &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;). This commit moves the error code to err.code and replaces err.message with a human-readable error. Example: // before { message: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39; } // after { code: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;, message: &#39;unable to verify the first certificate&#39; } UNABLE_TO_VERIFY_LEAF_SIGNATURE is a good example of why you want this: the error code suggests that it&#39;s the last certificate that fails to validate while it&#39;s actually the first certificate in the chain. Going by the number of mailing list posts and StackOverflow questions, it&#39;s a source of confusion to many people.
11 years ago
using v8::Isolate;
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::Local;
using v8::Null;
using v8::Object;
using v8::Persistent;
crypto: allow custom generator for DiffieHellman
11 years ago
using v8::PropertyAttribute;
using v8::PropertyCallbackInfo;
src: make accessors immune to context confusion It&#39;s possible for an accessor or named interceptor to get called with a different execution context than the one it lives in, see the test case for an example using the debug API. This commit fortifies against that by passing the environment as a data property instead of looking it up through the current context. Fixes: https://github.com/iojs/io.js/issues/1190 (again) PR-URL: https://github.com/iojs/io.js/pull/1238 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
using v8::ReadOnly;
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::String;
crypto: don&#39;t mix new[] and free() RandomBytes() allocated memory with new[] which was then handed off to Buffer::Use() which eventually releases it again with free(). Mixing the two is technically a violation of the spec and besides, it&#39;s generally frowned upon.
12 years ago
using v8::V8;
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(); }
};
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 uv_rwlock_t* locks;
src: make root_certs const Make the root_certs global fully const. As a side effect, that moves it from the .data section to the .rodata section. Makes it a little easier to reason about the remaining globals.
10 years ago
const char* const root_certs[] = {
crypto: update root certificates Update the list of root certificates in src/node_root_certs.h with tools/mk-ca-bundle.pl and update src/node_crypto.cc to make use of the new format. Fixes #6013.
11 years ago
#include "node_root_certs.h" // NOLINT(build/include_order)
};
crypto: make root_cert_store variable extern Before this commit it was declared static (in a header file!), meaning it got duplicated in every file that includes it. A few duplicated pointers is not the end of the world but it introduces a lot of potential for confusion because root_cert_store in file A is not the root_cert_store in file B. Moral of the story: don&#39;t declare static variables in header files.
11 years ago
X509_STORE* root_cert_store;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// Just to generate static methods
stream_base: introduce StreamBase StreamBase is an improved way to write C++ streams. The class itself is for separting `StreamWrap` (with the methods like `.writeAsciiString`, `.writeBuffer`, `.writev`, etc) from the `HandleWrap` class, making possible to write abstract C++ streams that are not bound to any uv socket. The following methods are important part of the abstraction (which mimics libuv&#39;s stream API): * Events: * `OnAlloc(size_t size, uv_buf_t*)` * `OnRead(ssize_t nread, const uv_buf_t*, uv_handle_type pending)` * `OnAfterWrite(WriteWrap*)` * Wrappers: * `DoShutdown(ShutdownWrap*)` * `DoTryWrite(uv_buf_t** bufs, size_t* count)` * `DoWrite(WriteWrap*, uv_buf_t*, size_t count, uv_stream_t* handle)` * `Error()` * `ClearError()` The implementation should provide all of these methods, thus providing the access to the underlying resource (be it uv handle, TLS socket, or anything else). A C++ stream may consume the input of another stream by replacing the event callbacks and proxying the writes. This kind of API is actually used now for the TLSWrap implementation, making it possible to wrap TLS stream into another TLS stream. Thus legacy API calls are no longer required in `_tls_wrap.js`. PR-URL: https://github.com/iojs/io.js/pull/840 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
template class SSLWrap<TLSWrap>;
template void SSLWrap<TLSWrap>::AddMethods(Environment* env,
Handle<FunctionTemplate> t);
template void SSLWrap<TLSWrap>::InitNPN(SecureContext* sc);
template SSL_SESSION* SSLWrap<TLSWrap>::GetSessionCallback(
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL* s,
unsigned char* key,
int len,
int* copy);
stream_base: introduce StreamBase StreamBase is an improved way to write C++ streams. The class itself is for separting `StreamWrap` (with the methods like `.writeAsciiString`, `.writeBuffer`, `.writev`, etc) from the `HandleWrap` class, making possible to write abstract C++ streams that are not bound to any uv socket. The following methods are important part of the abstraction (which mimics libuv&#39;s stream API): * Events: * `OnAlloc(size_t size, uv_buf_t*)` * `OnRead(ssize_t nread, const uv_buf_t*, uv_handle_type pending)` * `OnAfterWrite(WriteWrap*)` * Wrappers: * `DoShutdown(ShutdownWrap*)` * `DoTryWrite(uv_buf_t** bufs, size_t* count)` * `DoWrite(WriteWrap*, uv_buf_t*, size_t count, uv_stream_t* handle)` * `Error()` * `ClearError()` The implementation should provide all of these methods, thus providing the access to the underlying resource (be it uv handle, TLS socket, or anything else). A C++ stream may consume the input of another stream by replacing the event callbacks and proxying the writes. This kind of API is actually used now for the TLSWrap implementation, making it possible to wrap TLS stream into another TLS stream. Thus legacy API calls are no longer required in `_tls_wrap.js`. PR-URL: https://github.com/iojs/io.js/pull/840 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
template int SSLWrap<TLSWrap>::NewSessionCallback(SSL* s,
SSL_SESSION* sess);
template void SSLWrap<TLSWrap>::OnClientHello(
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void* arg,
const ClientHelloParser::ClientHello& hello);
crypto: unbreak build with no-NPN shared openssl Unbreak the build when linking against a shared version of OpenSSL that doesn&#39;t support NPN (Next Protocol Negotiation.) Fixes the following build error: ../src/node_crypto.cc:140: error: no member function &#39;AdvertiseNextProtoCallback&#39; declared in &#39;node::crypto::SSLWrap&lt;node::TLSCallbacks&gt;&#39; ../src/node_crypto.cc:147: error: no member function &#39;SelectNextProtoCallback&#39; declared in &#39;node::crypto::SSLWrap&lt;node::TLSCallbacks&gt;&#39;
11 years ago
#ifdef OPENSSL_NPN_NEGOTIATED
stream_base: introduce StreamBase StreamBase is an improved way to write C++ streams. The class itself is for separting `StreamWrap` (with the methods like `.writeAsciiString`, `.writeBuffer`, `.writev`, etc) from the `HandleWrap` class, making possible to write abstract C++ streams that are not bound to any uv socket. The following methods are important part of the abstraction (which mimics libuv&#39;s stream API): * Events: * `OnAlloc(size_t size, uv_buf_t*)` * `OnRead(ssize_t nread, const uv_buf_t*, uv_handle_type pending)` * `OnAfterWrite(WriteWrap*)` * Wrappers: * `DoShutdown(ShutdownWrap*)` * `DoTryWrite(uv_buf_t** bufs, size_t* count)` * `DoWrite(WriteWrap*, uv_buf_t*, size_t count, uv_stream_t* handle)` * `Error()` * `ClearError()` The implementation should provide all of these methods, thus providing the access to the underlying resource (be it uv handle, TLS socket, or anything else). A C++ stream may consume the input of another stream by replacing the event callbacks and proxying the writes. This kind of API is actually used now for the TLSWrap implementation, making it possible to wrap TLS stream into another TLS stream. Thus legacy API calls are no longer required in `_tls_wrap.js`. PR-URL: https://github.com/iojs/io.js/pull/840 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
template int SSLWrap<TLSWrap>::AdvertiseNextProtoCallback(
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL* s,
const unsigned char** data,
unsigned int* len,
void* arg);
stream_base: introduce StreamBase StreamBase is an improved way to write C++ streams. The class itself is for separting `StreamWrap` (with the methods like `.writeAsciiString`, `.writeBuffer`, `.writev`, etc) from the `HandleWrap` class, making possible to write abstract C++ streams that are not bound to any uv socket. The following methods are important part of the abstraction (which mimics libuv&#39;s stream API): * Events: * `OnAlloc(size_t size, uv_buf_t*)` * `OnRead(ssize_t nread, const uv_buf_t*, uv_handle_type pending)` * `OnAfterWrite(WriteWrap*)` * Wrappers: * `DoShutdown(ShutdownWrap*)` * `DoTryWrite(uv_buf_t** bufs, size_t* count)` * `DoWrite(WriteWrap*, uv_buf_t*, size_t count, uv_stream_t* handle)` * `Error()` * `ClearError()` The implementation should provide all of these methods, thus providing the access to the underlying resource (be it uv handle, TLS socket, or anything else). A C++ stream may consume the input of another stream by replacing the event callbacks and proxying the writes. This kind of API is actually used now for the TLSWrap implementation, making it possible to wrap TLS stream into another TLS stream. Thus legacy API calls are no longer required in `_tls_wrap.js`. PR-URL: https://github.com/iojs/io.js/pull/840 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
template int SSLWrap<TLSWrap>::SelectNextProtoCallback(
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL* s,
unsigned char** out,
unsigned char* outlen,
const unsigned char* in,
unsigned int inlen,
void* arg);
crypto: unbreak build with no-NPN shared openssl Unbreak the build when linking against a shared version of OpenSSL that doesn&#39;t support NPN (Next Protocol Negotiation.) Fixes the following build error: ../src/node_crypto.cc:140: error: no member function &#39;AdvertiseNextProtoCallback&#39; declared in &#39;node::crypto::SSLWrap&lt;node::TLSCallbacks&gt;&#39; ../src/node_crypto.cc:147: error: no member function &#39;SelectNextProtoCallback&#39; declared in &#39;node::crypto::SSLWrap&lt;node::TLSCallbacks&gt;&#39;
11 years ago
#endif
stream_base: introduce StreamBase StreamBase is an improved way to write C++ streams. The class itself is for separting `StreamWrap` (with the methods like `.writeAsciiString`, `.writeBuffer`, `.writev`, etc) from the `HandleWrap` class, making possible to write abstract C++ streams that are not bound to any uv socket. The following methods are important part of the abstraction (which mimics libuv&#39;s stream API): * Events: * `OnAlloc(size_t size, uv_buf_t*)` * `OnRead(ssize_t nread, const uv_buf_t*, uv_handle_type pending)` * `OnAfterWrite(WriteWrap*)` * Wrappers: * `DoShutdown(ShutdownWrap*)` * `DoTryWrite(uv_buf_t** bufs, size_t* count)` * `DoWrite(WriteWrap*, uv_buf_t*, size_t count, uv_stream_t* handle)` * `Error()` * `ClearError()` The implementation should provide all of these methods, thus providing the access to the underlying resource (be it uv handle, TLS socket, or anything else). A C++ stream may consume the input of another stream by replacing the event callbacks and proxying the writes. This kind of API is actually used now for the TLSWrap implementation, making it possible to wrap TLS stream into another TLS stream. Thus legacy API calls are no longer required in `_tls_wrap.js`. PR-URL: https://github.com/iojs/io.js/pull/840 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
template int SSLWrap<TLSWrap>::TLSExtStatusCallback(SSL* s, void* arg);
tls: destroy SSL once it is out of use Do not keep SSL structure in memory once socket is closed. This should lower the memory usage in many cases. Fix: https://github.com/iojs/io.js/issues/1522 PR-URL: https://github.com/iojs/io.js/pull/1529 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
template void SSLWrap<TLSWrap>::DestroySSL();
tls: use `SSL_set_cert_cb` for async SNI/OCSP Do not enable ClientHello parser for async SNI/OCSP. Use new OpenSSL-1.0.2&#39;s API `SSL_set_cert_cb` to pause the handshake process and load the cert/OCSP response asynchronously. Hopefuly this will make whole async SNI/OCSP process much faster and will eventually let us remove the ClientHello parser itself (which is currently used only for async session, see #1462 for the discussion of removing it). NOTE: Ported our code to `SSL_CTX_add1_chain_cert` to use `SSL_CTX_get0_chain_certs` in `CertCbDone`. Test provided for this feature. Fix: https://github.com/iojs/io.js/issues/1423 PR-URL: https://github.com/iojs/io.js/pull/1464 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
template int SSLWrap<TLSWrap>::SSLCertCallback(SSL* s, void* arg);
template void SSLWrap<TLSWrap>::WaitForCertCb(CertCb cb, void* arg);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
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) {
src: remove cpplint error using NOLINT directive PR-URL: https://github.com/iojs/io.js/pull/202 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
static_assert(sizeof(uv_thread_t) <= sizeof(void*), // NOLINT(runtime/sizeof)
crypto: store thread id as pointer-sized value uv_thread_t is a HANDLE (void pointer) on Windows, which means that on 64-bit windows it cannot be stored with CRYPTO_THREADID_set_numeric without potential data loss. PR-URL: https://github.com/iojs/io.js/pull/124 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
"uv_thread_t does not fit in a pointer");
CRYPTO_THREADID_set_pointer(tid, reinterpret_cast<void*>(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) {
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK((mode & CRYPTO_LOCK) || (mode & CRYPTO_UNLOCK));
CHECK((mode & CRYPTO_READ) || (mode & CRYPTO_WRITE));
crypto: use the libuv rwlock API
13 years ago
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
}
}
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
static int CryptoPemCallback(char *buf, int size, int rwflag, void *u) {
if (u) {
size_t buflen = static_cast<size_t>(size);
size_t len = strlen(static_cast<const char*>(u));
len = len > buflen ? buflen : len;
memcpy(buf, u, len);
return len;
}
return 0;
}
crypto: improve error messages 1) ThrowCryptoTypeErrors was not actually used for type-related errors. Removed it. 2) For AEAD modes, OpenSSL does not set any internal error information if Final does not complete suc- cessfully. Therefore, &#34;TypeError:error:00000000:l ib(0):func(0):reason(0)&#34; would be the error mess- age. Use a default message for these cases. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
void ThrowCryptoError(Environment* env,
unsigned long err,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
const char* default_message = nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(env->isolate());
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (err != 0 || default_message == nullptr) {
crypto: improve error messages 1) ThrowCryptoTypeErrors was not actually used for type-related errors. Removed it. 2) For AEAD modes, OpenSSL does not set any internal error information if Final does not complete suc- cessfully. Therefore, &#34;TypeError:error:00000000:l ib(0):func(0):reason(0)&#34; would be the error mess- age. Use a default message for these cases. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
char errmsg[128] = { 0 };
ERR_error_string_n(err, errmsg, sizeof(errmsg));
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowError(errmsg);
crypto: improve error messages 1) ThrowCryptoTypeErrors was not actually used for type-related errors. Removed it. 2) For AEAD modes, OpenSSL does not set any internal error information if Final does not complete suc- cessfully. Therefore, &#34;TypeError:error:00000000:l ib(0):func(0):reason(0)&#34; would be the error mess- age. Use a default message for these cases. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
} else {
env->ThrowError(default_message);
}
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
src: ensure that openssl&#39;s PRNG is fully seeded Ensure that OpenSSL has enough entropy (at least 256 bits) for its PRNG. The entropy pool starts out empty and needs to fill up before the PRNG can be used securely. OpenSSL normally fills the pool automatically but not when someone starts generating random numbers before the pool is full: in that case OpenSSL keeps lowering the entropy estimate to thwart attackers trying to guess the initial state of the PRNG. When that happens, we wait until enough entropy is available, something that normally should never take longer than a few milliseconds. Fixes #7338.
11 years ago
// Ensure that OpenSSL has enough entropy (at least 256 bits) for its PRNG.
// The entropy pool starts out empty and needs to fill up before the PRNG
// can be used securely. Once the pool is filled, it never dries up again;
// its contents is stirred and reused when necessary.
//
// OpenSSL normally fills the pool automatically but not when someone starts
// generating random numbers before the pool is full: in that case OpenSSL
// keeps lowering the entropy estimate to thwart attackers trying to guess
// the initial state of the PRNG.
//
// When that happens, we will have to wait until enough entropy is available.
// That should normally never take longer than a few milliseconds.
//
// OpenSSL draws from /dev/random and /dev/urandom. While /dev/random may
// block pending "true" randomness, /dev/urandom is a CSPRNG that doesn't
// block under normal circumstances.
//
// The only time when /dev/urandom may conceivably block is right after boot,
// when the whole system is still low on entropy. That's not something we can
// do anything about.
inline void CheckEntropy() {
for (;;) {
int status = RAND_status();
Merge remote-tracking branch &#39;origin/v0.10&#39; Conflicts: src/node.cc src/node_crypto.cc src/node_crypto.h
11 years ago
CHECK_GE(status, 0); // Cannot fail.
src: ensure that openssl&#39;s PRNG is fully seeded Ensure that OpenSSL has enough entropy (at least 256 bits) for its PRNG. The entropy pool starts out empty and needs to fill up before the PRNG can be used securely. OpenSSL normally fills the pool automatically but not when someone starts generating random numbers before the pool is full: in that case OpenSSL keeps lowering the entropy estimate to thwart attackers trying to guess the initial state of the PRNG. When that happens, we wait until enough entropy is available, something that normally should never take longer than a few milliseconds. Fixes #7338.
11 years ago
if (status != 0)
break;
crypto: fix lint
11 years ago
// Give up, RAND_poll() not supported.
if (RAND_poll() == 0)
src: ensure that openssl&#39;s PRNG is fully seeded Ensure that OpenSSL has enough entropy (at least 256 bits) for its PRNG. The entropy pool starts out empty and needs to fill up before the PRNG can be used securely. OpenSSL normally fills the pool automatically but not when someone starts generating random numbers before the pool is full: in that case OpenSSL keeps lowering the entropy estimate to thwart attackers trying to guess the initial state of the PRNG. When that happens, we wait until enough entropy is available, something that normally should never take longer than a few milliseconds. Fixes #7338.
11 years ago
break;
}
}
src: seed V8&#39;s random number generator at startup The default entropy source is /dev/urandom on UNIX platforms, which is okay but we can do better by seeding it from OpenSSL&#39;s entropy pool. On Windows we can certainly do better; on that platform, V8 seeds the random number generator using only the current system time. Fixes #6250.
11 years ago
bool EntropySource(unsigned char* buffer, size_t length) {
src: ensure that openssl&#39;s PRNG is fully seeded Ensure that OpenSSL has enough entropy (at least 256 bits) for its PRNG. The entropy pool starts out empty and needs to fill up before the PRNG can be used securely. OpenSSL normally fills the pool automatically but not when someone starts generating random numbers before the pool is full: in that case OpenSSL keeps lowering the entropy estimate to thwart attackers trying to guess the initial state of the PRNG. When that happens, we wait until enough entropy is available, something that normally should never take longer than a few milliseconds. Fixes #7338.
11 years ago
// Ensure that OpenSSL's PRNG is properly seeded.
CheckEntropy();
src: seed V8&#39;s random number generator at startup The default entropy source is /dev/urandom on UNIX platforms, which is okay but we can do better by seeding it from OpenSSL&#39;s entropy pool. On Windows we can certainly do better; on that platform, V8 seeds the random number generator using only the current system time. Fixes #6250.
11 years ago
// RAND_bytes() can return 0 to indicate that the entropy data is not truly
// random. That's okay, it's still better than V8's stock source of entropy,
// which is /dev/urandom on UNIX platforms and the current time on Windows.
return RAND_bytes(buffer, length) != -1;
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void SecureContext::Initialize(Environment* env, Handle<Object> target) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t = env->NewFunctionTemplate(SecureContext::New);
Initial openssl support for net2
15 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext"));
Initial openssl support for net2
15 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "init", SecureContext::Init);
env->SetProtoMethod(t, "setKey", SecureContext::SetKey);
env->SetProtoMethod(t, "setCert", SecureContext::SetCert);
env->SetProtoMethod(t, "addCACert", SecureContext::AddCACert);
env->SetProtoMethod(t, "addCRL", SecureContext::AddCRL);
env->SetProtoMethod(t, "addRootCerts", SecureContext::AddRootCerts);
env->SetProtoMethod(t, "setCiphers", SecureContext::SetCiphers);
env->SetProtoMethod(t, "setECDHCurve", SecureContext::SetECDHCurve);
env->SetProtoMethod(t, "setDHParam", SecureContext::SetDHParam);
env->SetProtoMethod(t, "setOptions", SecureContext::SetOptions);
env->SetProtoMethod(t, "setSessionIdContext",
SecureContext::SetSessionIdContext);
env->SetProtoMethod(t, "setSessionTimeout",
SecureContext::SetSessionTimeout);
env->SetProtoMethod(t, "close", SecureContext::Close);
env->SetProtoMethod(t, "loadPKCS12", SecureContext::LoadPKCS12);
env->SetProtoMethod(t, "getTicketKeys", SecureContext::GetTicketKeys);
env->SetProtoMethod(t, "setTicketKeys", SecureContext::SetTicketKeys);
tls: zero SSL_CTX freelist for a singleUse socket When connecting to server with `keepAlive` turned off - make sure that the read/write buffers won&#39;t be kept in a single use SSL_CTX instance after the socket will be destroyed. Fix: https://github.com/iojs/io.js/issues/1522 PR-URL: https://github.com/iojs/io.js/pull/1529 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
env->SetProtoMethod(t, "setFreeListLength", SecureContext::SetFreeListLength);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "getCertificate", SecureContext::GetCertificate<true>);
env->SetProtoMethod(t, "getIssuer", SecureContext::GetCertificate<false>);
Initial openssl support for net2
15 years ago
src: make accessors immune to context confusion It&#39;s possible for an accessor or named interceptor to get called with a different execution context than the one it lives in, see the test case for an example using the debug API. This commit fortifies against that by passing the environment as a data property instead of looking it up through the current context. Fixes: https://github.com/iojs/io.js/issues/1190 (again) PR-URL: https://github.com/iojs/io.js/pull/1238 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
t->PrototypeTemplate()->SetAccessor(
FIXED_ONE_BYTE_STRING(env->isolate(), "_external"),
CtxGetter,
nullptr,
env->as_external(),
DEFAULT,
static_cast<PropertyAttribute>(ReadOnly | DontDelete));
crypto: export externals to internal structs Export External getters for a internal structs: SSL, SSL_CTX.
10 years ago
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext"),
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->GetFunction());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
env->set_secure_context_constructor_template(t);
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
src: remove ObjectWrap dependency from core Drop the ObjectWrap dependency in favor of an internal WeakObject class. Let&#39;s us stop worrying about API and ABI compatibility when making changes to the way node.js deals with weakly persistent handles internally.
11 years ago
new SecureContext(env, 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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = sc->env();
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: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value sslmethod(env->isolate(), args[0]);
style
14 years ago
build,src: remove sslv3 support SSLv3 is susceptible to downgrade attacks. Provide secure defaults, disable v3 protocol support entirely. PR-URL: https://github.com/iojs/io.js/pull/315 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
// Note that SSLv2 and SSLv3 are disallowed but SSLv2_method and friends
// are still accepted. They are OpenSSL's way of saying that all known
// protocols are supported unless explicitly disabled (which we do below
// for SSLv2 and SSLv3.)
style
14 years ago
if (strcmp(*sslmethod, "SSLv2_method") == 0) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("SSLv2 methods disabled");
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv2_server_method") == 0) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("SSLv2 methods disabled");
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv2_client_method") == 0) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("SSLv2 methods disabled");
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv3_method") == 0) {
crypto: disable SSLv3 if shared OpenSSL lacks it Some distributions disable SSLv3 due to POODLE. In such a case, disable the specific SSLv3 methods and throw an exception, much like the code already does for SSLv2. The SSLv23* code is retained because this is OpenSSL&#39;s terminology for &#34;no version in particular&#34;. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; PR-URL: https://github.com/iojs/io.js/pull/101
10 years ago
return env->ThrowError("SSLv3 methods disabled");
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv3_server_method") == 0) {
crypto: disable SSLv3 if shared OpenSSL lacks it Some distributions disable SSLv3 due to POODLE. In such a case, disable the specific SSLv3 methods and throw an exception, much like the code already does for SSLv2. The SSLv23* code is retained because this is OpenSSL&#39;s terminology for &#34;no version in particular&#34;. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; PR-URL: https://github.com/iojs/io.js/pull/101
10 years ago
return env->ThrowError("SSLv3 methods disabled");
style
14 years ago
} else if (strcmp(*sslmethod, "SSLv3_client_method") == 0) {
crypto: disable SSLv3 if shared OpenSSL lacks it Some distributions disable SSLv3 due to POODLE. In such a case, disable the specific SSLv3 methods and throw an exception, much like the code already does for SSLv2. The SSLv23* code is retained because this is OpenSSL&#39;s terminology for &#34;no version in particular&#34;. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; PR-URL: https://github.com/iojs/io.js/pull/101
10 years ago
return env->ThrowError("SSLv3 methods disabled");
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();
crypto: add TLS 1.1 and 1.2 to secureProtocol list
12 years ago
} else if (strcmp(*sslmethod, "TLSv1_1_method") == 0) {
method = TLSv1_1_method();
} else if (strcmp(*sslmethod, "TLSv1_1_server_method") == 0) {
method = TLSv1_1_server_method();
} else if (strcmp(*sslmethod, "TLSv1_1_client_method") == 0) {
method = TLSv1_1_client_method();
} else if (strcmp(*sslmethod, "TLSv1_2_method") == 0) {
method = TLSv1_2_method();
} else if (strcmp(*sslmethod, "TLSv1_2_server_method") == 0) {
method = TLSv1_2_server_method();
} else if (strcmp(*sslmethod, "TLSv1_2_client_method") == 0) {
method = TLSv1_2_client_method();
style
14 years ago
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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
build,src: remove sslv2 support SSLv2 has been deprecated and known broken for nearly twenty years now. I made SSLv2 support opt-in well over a year ago in commit 39aa894 and now this commit removes it entirely. PR-URL: https://github.com/iojs/io.js/pull/290 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Rod Vagg &lt;rod@vagg.org&gt;
10 years ago
// Disable SSLv2 in the case when method == SSLv23_method() and the
// cipher list contains SSLv2 ciphers (not the default, should be rare.)
// The bundled OpenSSL doesn't have SSLv2 support but the system OpenSSL may.
build,src: remove sslv3 support SSLv3 is susceptible to downgrade attacks. Provide secure defaults, disable v3 protocol support entirely. PR-URL: https://github.com/iojs/io.js/pull/315 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
// SSLv3 is disabled because it's susceptible to downgrade attacks (POODLE.)
build,src: remove sslv2 support SSLv2 has been deprecated and known broken for nearly twenty years now. I made SSLv2 support opt-in well over a year ago in commit 39aa894 and now this commit removes it entirely. PR-URL: https://github.com/iojs/io.js/pull/290 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Rod Vagg &lt;rod@vagg.org&gt;
10 years ago
SSL_CTX_set_options(sc->ctx_, SSL_OP_NO_SSLv2);
build,src: remove sslv3 support SSLv3 is susceptible to downgrade attacks. Provide secure defaults, disable v3 protocol support entirely. PR-URL: https://github.com/iojs/io.js/pull/315 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
SSL_CTX_set_options(sc->ctx_, SSL_OP_NO_SSLv3);
build,src: remove sslv2 support SSLv2 has been deprecated and known broken for nearly twenty years now. I made SSLv2 support opt-in well over a year ago in commit 39aa894 and now this commit removes it entirely. PR-URL: https://github.com/iojs/io.js/pull/290 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Rod Vagg &lt;rod@vagg.org&gt;
10 years ago
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);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL_CTX_sess_set_get_cb(sc->ctx_, SSLWrap<Connection>::GetSessionCallback);
SSL_CTX_sess_set_new_cb(sc->ctx_, SSLWrap<Connection>::NewSessionCallback);
Initial openssl support for net2
15 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
sc->ca_store_ = nullptr;
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
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: remove `node_isolate` from source fix #6899
11 years ago
static BIO* LoadBIO(Environment* env, Handle<Value> v) {
crypto: remove NodeBIO::GetMethod() Remove NodeBIO::GetMethod() and replace calls to BIO_new() with calls to the new NodeBIO::New() function. This commit basically reshuffles some code in order to make it explicit that the NodeBIO BIO_METHOD is const.
11 years ago
BIO* bio = NodeBIO::New();
cpplint: disallow if one-liners
11 years ago
if (!bio)
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
Accept Buffers as well as strings for addCert, addKey
14 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(env->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: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value s(env->isolate(), 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);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
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: remove `node_isolate` from source fix #6899
11 years ago
static X509* LoadX509(Environment* env, Handle<Value> v) {
HandleScope scope(env->isolate());
Accept Buffers as well as strings for addCert, addKey
14 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
BIO *bio = LoadBIO(env, v);
cpplint: disallow if one-liners
11 years ago
if (!bio)
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
Accept Buffers as well as strings for addCert, addKey
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
X509 * x509 = PEM_read_bio_X509(bio, nullptr, CryptoPemCallback, nullptr);
Accept Buffers as well as strings for addCert, addKey
14 years ago
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);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Accept Buffers as well as strings for addCert, addKey
14 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
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) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Bad parameter");
tls, https: add passphrase option Fixes #1925.
13 years ago
}
if (len == 2 && !args[1]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Bad parameter");
Accept Buffers as well as strings for addCert, addKey
14 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
BIO *bio = LoadBIO(env, args[0]);
cpplint: disallow if one-liners
11 years ago
if (!bio)
return;
Accept Buffers as well as strings for addCert, addKey
14 years ago
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value passphrase(env->isolate(), args[1]);
tls, https: add passphrase option Fixes #1925.
13 years ago
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
EVP_PKEY* key = PEM_read_bio_PrivateKey(bio,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
CryptoPemCallback,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
len == 1 ? nullptr : *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) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("PEM_read_bio_PrivateKey");
crypto: fix error reporting in SetKey()
13 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
return ThrowCryptoError(env, err);
Fix style in node_crypto.cc
14 years ago
}
Initial openssl support for net2
15 years ago
crypto: throw if the key doesn&#39;t match cert fix joyent/node#8770 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; PR-URL: https://github.com/node-forward/node/pull/66
10 years ago
int rv = 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);
crypto: throw if the key doesn&#39;t match cert fix joyent/node#8770 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; PR-URL: https://github.com/node-forward/node/pull/66
10 years ago
if (!rv) {
unsigned long err = ERR_get_error();
if (!err)
return env->ThrowError("SSL_CTX_use_PrivateKey");
return ThrowCryptoError(env, err);
}
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
int SSL_CTX_get_issuer(SSL_CTX* ctx, X509* cert, X509** issuer) {
int ret;
X509_STORE* store = SSL_CTX_get_cert_store(ctx);
X509_STORE_CTX store_ctx;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
ret = X509_STORE_CTX_init(&store_ctx, store, nullptr, nullptr);
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
if (!ret)
goto end;
ret = X509_STORE_CTX_get1_issuer(issuer, &store_ctx, cert);
X509_STORE_CTX_cleanup(&store_ctx);
src: lint after OCSP commits
11 years ago
end:
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
return ret;
}
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.
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
int SSL_CTX_use_certificate_chain(SSL_CTX* ctx,
BIO* in,
tls: support OCSP on client and server
11 years ago
X509** cert,
X509** issuer) {
TLS: handle cert chains
14 years ago
int ret = 0;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
X509* x = nullptr;
TLS: handle cert chains
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
x = PEM_read_bio_X509_AUX(in, nullptr, CryptoPemCallback, nullptr);
TLS: handle cert chains
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (x == nullptr) {
TLS: handle cert chains
14 years ago
SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE, ERR_R_PEM_LIB);
goto end;
}
ret = SSL_CTX_use_certificate(ctx, x);
if (ret) {
// If we could set up our certificate, now proceed to
// the CA certificates.
X509 *ca;
int r;
unsigned long err;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (ctx->extra_certs != nullptr) {
TLS: handle cert chains
14 years ago
sk_X509_pop_free(ctx->extra_certs, X509_free);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
ctx->extra_certs = nullptr;
TLS: handle cert chains
14 years ago
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
while ((ca = PEM_read_bio_X509(in, nullptr, CryptoPemCallback, nullptr))) {
tls: use `SSL_set_cert_cb` for async SNI/OCSP Do not enable ClientHello parser for async SNI/OCSP. Use new OpenSSL-1.0.2&#39;s API `SSL_set_cert_cb` to pause the handshake process and load the cert/OCSP response asynchronously. Hopefuly this will make whole async SNI/OCSP process much faster and will eventually let us remove the ClientHello parser itself (which is currently used only for async session, see #1462 for the discussion of removing it). NOTE: Ported our code to `SSL_CTX_add1_chain_cert` to use `SSL_CTX_get0_chain_certs` in `CertCbDone`. Test provided for this feature. Fix: https://github.com/iojs/io.js/issues/1423 PR-URL: https://github.com/iojs/io.js/pull/1464 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
// NOTE: Increments reference count on `ca`
r = SSL_CTX_add1_chain_cert(ctx, ca);
TLS: handle cert chains
14 years ago
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).
tls: support OCSP on client and server
11 years ago
// Find issuer
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (*issuer != nullptr || X509_check_issued(ca, x) != X509_V_OK)
tls: support OCSP on client and server
11 years ago
continue;
*issuer = ca;
TLS: handle cert chains
14 years ago
}
// 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;
}
}
tls: support OCSP on client and server
11 years ago
// Try getting issuer from a cert store
if (ret) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (*issuer == nullptr) {
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
ret = SSL_CTX_get_issuer(ctx, x, issuer);
tls: support OCSP on client and server
11 years ago
ret = ret < 0 ? 0 : 1;
// NOTE: get_cert_store doesn't increment reference count,
// no need to free `store`
} else {
// Increment issuer reference count
CRYPTO_add(&(*issuer)->references, 1, CRYPTO_LOCK_X509);
}
}
src: lint c++ code
12 years ago
end:
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (x != nullptr)
tls: support OCSP on client and server
11 years ago
*cert = x;
TLS: handle cert chains
14 years ago
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Initial openssl support for net2
15 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
Initial openssl support for net2
15 years ago
Accept Buffers as well as strings for addCert, addKey
14 years ago
if (args.Length() != 1) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Bad parameter");
Initial openssl support for net2
15 years ago
}
Fix style in node_crypto.cc
14 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
BIO* bio = LoadBIO(env, args[0]);
cpplint: disallow if one-liners
11 years ago
if (!bio)
return;
Fix style in node_crypto.cc
14 years ago
tls: support OCSP on client and server
11 years ago
int rv = SSL_CTX_use_certificate_chain(sc->ctx_,
bio,
&sc->cert_,
&sc->issuer_);
TLS: handle cert chains
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);
TLS: handle cert chains
14 years ago
if (!rv) {
unsigned long err = ERR_get_error();
if (!err) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("SSL_CTX_use_certificate_chain");
TLS: handle cert chains
14 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
return ThrowCryptoError(env, 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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Initial openssl support for net2
15 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
crypto: clear error on return in TLS methods Methods like `X509_STORE_add_cert` may push errors onto OpenSSL&#39;s error stack. Ensure that they won&#39;t pop up in a different places like `tls_wrap.cc`. Fix: https://github.com/iojs/io.js/issues/712 PR-URL: https://github.com/iojs/io.js/pull/719 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence compiler warning.
Initial openssl support for net2
15 years ago
Accept Buffers as well as strings for addCert, addKey
14 years ago
if (args.Length() != 1) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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;
}
src: remove `node_isolate` from source fix #6899
11 years ago
X509* x509 = LoadX509(env, args[0]);
cpplint: disallow if one-liners
11 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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
TLS: CRL support Needs more tests.
14 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
TLS: CRL support Needs more tests.
14 years ago
if (args.Length() != 1) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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.
src: remove `node_isolate` from source fix #6899
11 years ago
BIO *bio = LoadBIO(env, args[0]);
cpplint: disallow if one-liners
11 years ago
if (!bio)
return;
TLS: CRL support Needs more tests.
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
X509_CRL *x509 =
PEM_read_bio_X509_CRL(bio, nullptr, CryptoPemCallback, nullptr);
TLS: CRL support Needs more tests.
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (x509 == nullptr) {
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
crypto: clear error on return in TLS methods Methods like `X509_STORE_add_cert` may push errors onto OpenSSL&#39;s error stack. Ensure that they won&#39;t pop up in a different places like `tls_wrap.cc`. Fix: https://github.com/iojs/io.js/issues/712 PR-URL: https://github.com/iojs/io.js/pull/719 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence compiler warning.
Move root certs out of JavaScript
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_EQ(sc->ca_store_, nullptr);
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
src: clean up root_certs iteration Drop the trailing nullptr and use ARRAY_SIZE.
10 years ago
for (size_t i = 0; i < ARRAY_SIZE(root_certs); i++) {
crypto: remove NodeBIO::GetMethod() Remove NodeBIO::GetMethod() and replace calls to BIO_new() with calls to the new NodeBIO::New() function. This commit basically reshuffles some code in order to make it explicit that the NodeBIO BIO_METHOD is const.
11 years ago
BIO* bp = NodeBIO::New();
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
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
X509 *x509 = PEM_read_bio_X509(bp, nullptr, CryptoPemCallback, nullptr);
Move root certs out of JavaScript
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (x509 == nullptr) {
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
crypto: clear error on return in TLS methods Methods like `X509_STORE_add_cert` may push errors onto OpenSSL&#39;s error stack. Ensure that they won&#39;t pop up in a different places like `tls_wrap.cc`. Fix: https://github.com/iojs/io.js/issues/712 PR-URL: https://github.com/iojs/io.js/pull/719 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence compiler warning.
Initial openssl support for net2
15 years ago
Fix style in node_crypto.cc
14 years ago
if (args.Length() != 1 || !args[0]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return sc->env()->ThrowTypeError("Bad parameter");
Initial openssl support for net2
15 years ago
}
Fix style in node_crypto.cc
14 years ago
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value ciphers(args.GetIsolate(), 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
tls: add ECDH ciphers support Switch test fixtures to 1024 bit keys.
11 years ago
void SecureContext::SetECDHCurve(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = sc->env();
tls: add ECDH ciphers support Switch test fixtures to 1024 bit keys.
11 years ago
if (args.Length() != 1 || !args[0]->IsString())
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("First argument should be a string");
tls: add ECDH ciphers support Switch test fixtures to 1024 bit keys.
11 years ago
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value curve(env->isolate(), args[0]);
tls: add ECDH ciphers support Switch test fixtures to 1024 bit keys.
11 years ago
int nid = OBJ_sn2nid(*curve);
if (nid == NID_undef)
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("First argument should be a valid curve name");
tls: add ECDH ciphers support Switch test fixtures to 1024 bit keys.
11 years ago
EC_KEY* ecdh = EC_KEY_new_by_curve_name(nid);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (ecdh == nullptr)
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("First argument should be a valid curve name");
tls: add ECDH ciphers support Switch test fixtures to 1024 bit keys.
11 years ago
SSL_CTX_set_options(sc->ctx_, SSL_OP_SINGLE_ECDH_USE);
SSL_CTX_set_tmp_ecdh(sc->ctx_, ecdh);
EC_KEY_free(ecdh);
}
tls, crypto: add DHE support In case of an invalid DH parameter file, it is sliently discarded. To use auto DH parameter in a server and DHE key length check in a client, we need to wait for the next release of OpenSSL-1.0.2. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
void SecureContext::SetDHParam(const FunctionCallbackInfo<Value>& args) {
SecureContext* sc = Unwrap<SecureContext>(args.This());
Environment* env = sc->env();
crypto: clear error on return in TLS methods Methods like `X509_STORE_add_cert` may push errors onto OpenSSL&#39;s error stack. Ensure that they won&#39;t pop up in a different places like `tls_wrap.cc`. Fix: https://github.com/iojs/io.js/issues/712 PR-URL: https://github.com/iojs/io.js/pull/719 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence compiler warning.
tls, crypto: add DHE support In case of an invalid DH parameter file, it is sliently discarded. To use auto DH parameter in a server and DHE key length check in a client, we need to wait for the next release of OpenSSL-1.0.2. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
// Auto DH is not supported in openssl 1.0.1, so dhparam needs
// to be specifed explicitly
if (args.Length() != 1)
return env->ThrowTypeError("Bad parameter");
// Invalid dhparam is silently discarded and DHE is no longer used.
BIO* bio = LoadBIO(env, args[0]);
if (!bio)
return;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
DH* dh = PEM_read_bio_DHparams(bio, nullptr, nullptr, nullptr);
tls, crypto: add DHE support In case of an invalid DH parameter file, it is sliently discarded. To use auto DH parameter in a server and DHE key length check in a client, we need to wait for the next release of OpenSSL-1.0.2. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
BIO_free_all(bio);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (dh == nullptr)
tls, crypto: add DHE support In case of an invalid DH parameter file, it is sliently discarded. To use auto DH parameter in a server and DHE key length check in a client, we need to wait for the next release of OpenSSL-1.0.2. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
return;
tls: make server not use DHE in less than 1024bits DHE key lengths less than 1024bits is already weaken as pointed out in https://weakdh.org/ . 1024bits will not be safe in near future. We will extend this up to 2048bits somedays later. PR-URL: https://github.com/nodejs/io.js/pull/1739 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
const int keylen = BN_num_bits(dh->p);
if (keylen < 1024)
return env->ThrowError("DH parameter is less than 1024 bits");
else if (keylen < 2048)
fprintf(stderr, "WARNING: DH parameter is less than 2048 bits\n");
tls, crypto: add DHE support In case of an invalid DH parameter file, it is sliently discarded. To use auto DH parameter in a server and DHE key length check in a client, we need to wait for the next release of OpenSSL-1.0.2. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
SSL_CTX_set_options(sc->ctx_, SSL_OP_SINGLE_DH_USE);
int r = SSL_CTX_set_tmp_dh(sc->ctx_, dh);
DH_free(dh);
if (!r)
return env->ThrowTypeError("Error setting temp DH parameter");
}
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
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()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return sc->env()->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: fix a couple of VC++ warnings Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
SSL_CTX_set_options(sc->ctx_, static_cast<long>(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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
tls: requestCert unusable with Firefox and Chrome Fixes #1516.
13 years ago
if (args.Length() != 1 || !args[0]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return sc->env()->ThrowTypeError("Bad parameter");
tls: requestCert unusable with Firefox and Chrome Fixes #1516.
13 years ago
}
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value sessionIdContext(args.GetIsolate(), args[0]);
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 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);
cpplint: disallow if one-liners
11 years ago
if (r == 1)
return;
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* bio;
BUF_MEM* mem;
Local<String> message;
bio = BIO_new(BIO_s_mem());
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (bio == nullptr) {
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
message = FIXED_ONE_BYTE_STRING(args.GetIsolate(),
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
"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);
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
message = OneByteString(args.GetIsolate(), 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
}
src: update to v8 3.24 APIs
11 years ago
args.GetIsolate()->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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
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()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return sc->env()->ThrowTypeError("Bad parameter");
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
}
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
BIO* in = nullptr;
PKCS12* p12 = nullptr;
EVP_PKEY* pkey = nullptr;
X509* cert = nullptr;
STACK_OF(X509)* extraCerts = nullptr;
char* pass = nullptr;
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
bool ret = false;
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* sc = Unwrap<SecureContext>(args.Holder());
crypto: clear error on return in TLS methods Methods like `X509_STORE_add_cert` may push errors onto OpenSSL&#39;s error stack. Ensure that they won&#39;t pop up in a different places like `tls_wrap.cc`. Fix: https://github.com/iojs/io.js/issues/712 PR-URL: https://github.com/iojs/io.js/pull/719 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence compiler warning.
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
if (args.Length() < 1) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Bad parameter");
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
in = LoadBIO(env, args[0]);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (in == nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Unable to load BIO");
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
}
if (args.Length() >= 2) {
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[1]);
src: don&#39;t call DecodeWrite() on Buffers Don&#39;t call DecodeWrite() with a Buffer as its argument because it in turn calls StringBytes::Write() and that method expects a Local&lt;String&gt;. &#34;Why then does that function take a Local&lt;Value&gt;?&#34; I hear you ask. Good question but I don&#39;t have the answer. I added a CHECK for good measure and what do you know, all of a sudden a large number of crypto tests started failing. Calling DecodeWrite(BINARY) on a buffer is nonsensical anyway: if you want the contents of the buffer, just copy out the data, there is no need to decode it - and that&#39;s exactly what this commit does. Fixes a great many instances of the following run-time error in debug builds: FATAL ERROR: v8::String::Cast() Could not convert to string
11 years ago
size_t passlen = Buffer::Length(args[1]);
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
pass = new char[passlen + 1];
src: don&#39;t call DecodeWrite() on Buffers Don&#39;t call DecodeWrite() with a Buffer as its argument because it in turn calls StringBytes::Write() and that method expects a Local&lt;String&gt;. &#34;Why then does that function take a Local&lt;Value&gt;?&#34; I hear you ask. Good question but I don&#39;t have the answer. I added a CHECK for good measure and what do you know, all of a sudden a large number of crypto tests started failing. Calling DecodeWrite(BINARY) on a buffer is nonsensical anyway: if you want the contents of the buffer, just copy out the data, there is no need to decode it - and that&#39;s exactly what this commit does. Fixes a great many instances of the following run-time error in debug builds: FATAL ERROR: v8::String::Cast() Could not convert to string
11 years ago
memcpy(pass, Buffer::Data(args[1]), passlen);
crypto: add PKCS12/PFX support Fixes #2845.
13 years ago
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);
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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)
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* wrap = Unwrap<SecureContext>(args.Holder());
tls: share tls tickets key between cluster workers fix #5871
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Object> buff = Buffer::New(wrap->env(), 48);
tls: share tls tickets key between cluster workers fix #5871
12 years ago
if (SSL_CTX_get_tlsext_ticket_keys(wrap->ctx_,
Buffer::Data(buff),
Buffer::Length(buff)) != 1) {
src: remove `node_isolate` from source fix #6899
11 years ago
return wrap->env()->ThrowError("Failed to fetch tls ticket keys");
tls: share tls tickets key between cluster workers fix #5871
12 years ago
}
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)
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
SecureContext* wrap = Unwrap<SecureContext>(args.Holder());
tls: share tls tickets key between cluster workers fix #5871
12 years ago
if (args.Length() < 1 ||
!Buffer::HasInstance(args[0]) ||
Buffer::Length(args[0]) != 48) {
src: remove `node_isolate` from source fix #6899
11 years ago
return wrap->env()->ThrowTypeError("Bad argument");
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) {
src: remove `node_isolate` from source fix #6899
11 years ago
return wrap->env()->ThrowError("Failed to fetch tls ticket keys");
tls: share tls tickets key between cluster workers fix #5871
12 years ago
}
args.GetReturnValue().Set(true);
#endif // !def(OPENSSL_NO_TLSEXT) && def(SSL_CTX_get_tlsext_ticket_keys)
}
tls: zero SSL_CTX freelist for a singleUse socket When connecting to server with `keepAlive` turned off - make sure that the read/write buffers won&#39;t be kept in a single use SSL_CTX instance after the socket will be destroyed. Fix: https://github.com/iojs/io.js/issues/1522 PR-URL: https://github.com/iojs/io.js/pull/1529 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
void SecureContext::SetFreeListLength(const FunctionCallbackInfo<Value>& args) {
SecureContext* wrap = Unwrap<SecureContext>(args.Holder());
wrap->ctx_->freelist_max_len = args[0]->Int32Value();
}
crypto: export externals to internal structs Export External getters for a internal structs: SSL, SSL_CTX.
10 years ago
void SecureContext::CtxGetter(Local<String> property,
const PropertyCallbackInfo<Value>& info) {
HandleScope scope(info.GetIsolate());
SSL_CTX* ctx = Unwrap<SecureContext>(info.Holder())->ctx_;
Local<External> ext = External::New(info.GetIsolate(), ctx);
info.GetReturnValue().Set(ext);
}
tls: support OCSP on client and server
11 years ago
template <bool primary>
void SecureContext::GetCertificate(const FunctionCallbackInfo<Value>& args) {
SecureContext* wrap = Unwrap<SecureContext>(args.Holder());
Environment* env = wrap->env();
X509* cert;
if (primary)
cert = wrap->cert_;
else
cert = wrap->issuer_;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (cert == nullptr)
tls: support OCSP on client and server
11 years ago
return args.GetReturnValue().Set(Null(env->isolate()));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
int size = i2d_X509(cert, nullptr);
tls: support OCSP on client and server
11 years ago
Local<Object> buff = Buffer::New(env, size);
unsigned char* serialized = reinterpret_cast<unsigned char*>(
Buffer::Data(buff));
i2d_X509(cert, &serialized);
args.GetReturnValue().Set(buff);
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
src: remove `node_isolate` from source fix #6899
11 years ago
void SSLWrap<Base>::AddMethods(Environment* env, Handle<FunctionTemplate> t) {
HandleScope scope(env->isolate());
tls: async session storage
13 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "getPeerCertificate", GetPeerCertificate);
env->SetProtoMethod(t, "getSession", GetSession);
env->SetProtoMethod(t, "setSession", SetSession);
env->SetProtoMethod(t, "loadSession", LoadSession);
env->SetProtoMethod(t, "isSessionReused", IsSessionReused);
env->SetProtoMethod(t, "isInitFinished", IsInitFinished);
env->SetProtoMethod(t, "verifyError", VerifyError);
env->SetProtoMethod(t, "getCurrentCipher", GetCurrentCipher);
env->SetProtoMethod(t, "endParser", EndParser);
tls: use `SSL_set_cert_cb` for async SNI/OCSP Do not enable ClientHello parser for async SNI/OCSP. Use new OpenSSL-1.0.2&#39;s API `SSL_set_cert_cb` to pause the handshake process and load the cert/OCSP response asynchronously. Hopefuly this will make whole async SNI/OCSP process much faster and will eventually let us remove the ClientHello parser itself (which is currently used only for async session, see #1462 for the discussion of removing it). NOTE: Ported our code to `SSL_CTX_add1_chain_cert` to use `SSL_CTX_get0_chain_certs` in `CertCbDone`. Test provided for this feature. Fix: https://github.com/iojs/io.js/issues/1423 PR-URL: https://github.com/iojs/io.js/pull/1464 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
env->SetProtoMethod(t, "certCbDone", CertCbDone);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "renegotiate", Renegotiate);
stream_base: introduce StreamBase StreamBase is an improved way to write C++ streams. The class itself is for separting `StreamWrap` (with the methods like `.writeAsciiString`, `.writeBuffer`, `.writev`, etc) from the `HandleWrap` class, making possible to write abstract C++ streams that are not bound to any uv socket. The following methods are important part of the abstraction (which mimics libuv&#39;s stream API): * Events: * `OnAlloc(size_t size, uv_buf_t*)` * `OnRead(ssize_t nread, const uv_buf_t*, uv_handle_type pending)` * `OnAfterWrite(WriteWrap*)` * Wrappers: * `DoShutdown(ShutdownWrap*)` * `DoTryWrite(uv_buf_t** bufs, size_t* count)` * `DoWrite(WriteWrap*, uv_buf_t*, size_t count, uv_stream_t* handle)` * `Error()` * `ClearError()` The implementation should provide all of these methods, thus providing the access to the underlying resource (be it uv handle, TLS socket, or anything else). A C++ stream may consume the input of another stream by replacing the event callbacks and proxying the writes. This kind of API is actually used now for the TLSWrap implementation, making it possible to wrap TLS stream into another TLS stream. Thus legacy API calls are no longer required in `_tls_wrap.js`. PR-URL: https://github.com/iojs/io.js/pull/840 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
env->SetProtoMethod(t, "shutdownSSL", Shutdown);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "getTLSTicket", GetTLSTicket);
env->SetProtoMethod(t, "newSessionDone", NewSessionDone);
env->SetProtoMethod(t, "setOCSPResponse", SetOCSPResponse);
env->SetProtoMethod(t, "requestOCSP", RequestOCSP);
tls: async session storage
13 years ago
lib: introduce `.setMaxSendFragment(size)` fix #6889
11 years ago
#ifdef SSL_set_max_send_fragment
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "setMaxSendFragment", SetMaxSendFragment);
lib: introduce `.setMaxSendFragment(size)` fix #6889
11 years ago
#endif // SSL_set_max_send_fragment
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#ifdef OPENSSL_NPN_NEGOTIATED
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "getNegotiatedProtocol", GetNegotiatedProto);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#endif // OPENSSL_NPN_NEGOTIATED
crypto: export externals to internal structs Export External getters for a internal structs: SSL, SSL_CTX.
10 years ago
src, test: fixup after v8 update Because of behavior change of some V8 APIs (they mostly became more strict), following modules needed to be fixed: * crypto: duplicate prototype methods are not allowed anymore * contextify: some TryCatch trickery, the binding was using it incorrectly * util: maximum call stack error is now crashing in a different place Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
#ifdef OPENSSL_NPN_NEGOTIATED
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "setNPNProtocols", SetNPNProtocols);
src, test: fixup after v8 update Because of behavior change of some V8 APIs (they mostly became more strict), following modules needed to be fixed: * crypto: duplicate prototype methods are not allowed anymore * contextify: some TryCatch trickery, the binding was using it incorrectly * util: maximum call stack error is now crashing in a different place Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
#endif
src: make accessors immune to context confusion It&#39;s possible for an accessor or named interceptor to get called with a different execution context than the one it lives in, see the test case for an example using the debug API. This commit fortifies against that by passing the environment as a data property instead of looking it up through the current context. Fixes: https://github.com/iojs/io.js/issues/1190 (again) PR-URL: https://github.com/iojs/io.js/pull/1238 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
t->PrototypeTemplate()->SetAccessor(
FIXED_ONE_BYTE_STRING(env->isolate(), "_external"),
SSLGetter,
nullptr,
env->as_external(),
DEFAULT,
static_cast<PropertyAttribute>(ReadOnly | DontDelete));
tls: async session storage
13 years ago
}
Merge branch &#39;v0.10&#39; Conflicts: src/node_crypto.cc src/node_crypto.h
11 years ago
template <class Base>
crypto: never store pointer to conn in SSL_CTX SSL_CTX is shared between multiple connections and is not a right place to store per-connection data. fix #8348 Reviewed-By: Trevor Norris
10 years ago
void SSLWrap<Base>::InitNPN(SecureContext* sc) {
Merge branch &#39;v0.10&#39; Conflicts: src/node_crypto.cc src/node_crypto.h
11 years ago
#ifdef OPENSSL_NPN_NEGOTIATED
crypto: never store pointer to conn in SSL_CTX SSL_CTX is shared between multiple connections and is not a right place to store per-connection data. fix #8348 Reviewed-By: Trevor Norris
10 years ago
// Server should advertise NPN protocols
SSL_CTX_set_next_protos_advertised_cb(sc->ctx_,
AdvertiseNextProtoCallback,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr);
crypto: never store pointer to conn in SSL_CTX SSL_CTX is shared between multiple connections and is not a right place to store per-connection data. fix #8348 Reviewed-By: Trevor Norris
10 years ago
// Client should select protocol from list of advertised
// If server supports NPN
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
SSL_CTX_set_next_proto_select_cb(sc->ctx_, SelectNextProtoCallback, nullptr);
Merge branch &#39;v0.10&#39; Conflicts: src/node_crypto.cc src/node_crypto.h
11 years ago
#endif // OPENSSL_NPN_NEGOTIATED
tls: support OCSP on client and server
11 years ago
#ifdef NODE__HAVE_TLSEXT_STATUS_CB
// OCSP stapling
SSL_CTX_set_tlsext_status_cb(sc->ctx_, TLSExtStatusCallback);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
SSL_CTX_set_tlsext_status_arg(sc->ctx_, nullptr);
tls: support OCSP on client and server
11 years ago
#endif // NODE__HAVE_TLSEXT_STATUS_CB
tls: async session storage
13 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
SSL_SESSION* SSLWrap<Base>::GetSessionCallback(SSL* s,
unsigned char* key,
int len,
int* copy) {
Base* w = static_cast<Base*>(SSL_get_app_data(s));
tls: async session storage
13 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
*copy = 0;
SSL_SESSION* sess = w->next_sess_;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
w->next_sess_ = nullptr;
tls: async session storage
13 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
return sess;
}
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, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
int SSLWrap<Base>::NewSessionCallback(SSL* s, SSL_SESSION* sess) {
Base* w = static_cast<Base*>(SSL_get_app_data(s));
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
Environment* env = w->ssl_env();
crypto: fix up implicit HandleScope abuse Don&#39;t depend on any HandleScope objects that may or may not have been created in src/stream_wrap.cc, create them explicitly.
11 years ago
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
tls: split bio errors from ssl errors
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (!w->session_callbacks_)
tls: split bio errors from ssl errors
14 years ago
return 0;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// Check if session is small enough to be stored
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
int size = i2d_SSL_SESSION(sess, nullptr);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (size > SecureContext::kMaxSessionSize)
tls: split bio errors from ssl errors
14 years ago
return 0;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// Serialize session
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Object> buff = Buffer::New(env, size);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
unsigned char* serialized = reinterpret_cast<unsigned char*>(
Buffer::Data(buff));
memset(serialized, 0, size);
i2d_SSL_SESSION(sess, &serialized);
tls: split bio errors from ssl errors
14 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Object> session = Buffer::New(env,
reinterpret_cast<char*>(sess->session_id),
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
sess->session_id_length);
Local<Value> argv[] = { session, buff };
tls: introduce asynchronous `newSession` fix #7105
11 years ago
w->new_session_wait_ = true;
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
w->MakeCallback(env->onnewsession_string(), ARRAY_SIZE(argv), argv);
tls: split bio errors from ssl errors
14 years ago
return 0;
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
void SSLWrap<Base>::OnClientHello(void* arg,
const ClientHelloParser::ClientHello& hello) {
Base* w = static_cast<Base*>(arg);
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
Environment* env = w->ssl_env();
crypto: fix up implicit HandleScope abuse Don&#39;t depend on any HandleScope objects that may or may not have been created in src/stream_wrap.cc, create them explicitly.
11 years ago
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
src: update to v8 3.24 APIs
11 years ago
Local<Object> hello_obj = Object::New(env->isolate());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
Local<Object> buff = Buffer::New(
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
env,
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
reinterpret_cast<const char*>(hello.session_id()),
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
hello.session_size());
hello_obj->Set(env->session_id_string(), buff);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (hello.servername() == nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
hello_obj->Set(env->servername_string(), String::Empty(env->isolate()));
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> servername = OneByteString(env->isolate(),
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
hello.servername(),
hello.servername_size());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
hello_obj->Set(env->servername_string(), servername);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
src: update to v8 3.24 APIs
11 years ago
hello_obj->Set(env->tls_ticket_string(),
Boolean::New(env->isolate(), hello.has_ticket()));
tls: support OCSP on client and server
11 years ago
hello_obj->Set(env->ocsp_request_string(),
Boolean::New(env->isolate(), hello.ocsp_request()));
crypto: look up SSL errors with ERR_print_errors()
13 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
Local<Value> argv[] = { hello_obj };
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
w->MakeCallback(env->onclienthello_string(), ARRAY_SIZE(argv), argv);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
crypto: escape DNS altname Vulnerability credit goes to: Calvin Liang conradjliang@hotmail.com Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; PR-URL: ...private
10 years ago
static bool SafeX509ExtPrint(BIO* out, X509_EXTENSION* ext) {
const X509V3_EXT_METHOD* method = X509V3_EXT_get(ext);
crypto: fix to check ext method for shared lib In the case of using openssl with shared library, reinterpret_cast&lt;X509V3_EXT_I2V&gt;(i2v_GENERAL_NAMES)) refers plt pointer so that SafeX509ExtPrint returns false. Fix it to check it with method of NID_subject_alt_name This patch originally was created by Fedor Indutny and Ben Noordhuis Fixes: https://github.com/iojs/io.js/issues/617 PR-URL: https://github.com/iojs/io.js/pull/800 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
if (method != X509V3_EXT_get_nid(NID_subject_alt_name))
crypto: escape DNS altname Vulnerability credit goes to: Calvin Liang conradjliang@hotmail.com Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; PR-URL: ...private
10 years ago
return false;
const unsigned char* p = ext->value->data;
GENERAL_NAMES* names = reinterpret_cast<GENERAL_NAMES*>(ASN1_item_d2i(
NULL,
&p,
ext->value->length,
ASN1_ITEM_ptr(method->it)));
if (names == NULL)
return false;
for (int i = 0; i < sk_GENERAL_NAME_num(names); i++) {
GENERAL_NAME* gen = sk_GENERAL_NAME_value(names, i);
crypto: separate altname extensions with &#34;, &#34; In newly introduced `SafeX509ExtPrint` I forgot to insert separators between extensions, which lead to the &#34;DNS:...DNS:...&#34; thing for npm. Fix: iojs/io.js#105 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; PR-URL: https://github.com/iojs/io.js/pull/113.patch
10 years ago
if (i != 0)
BIO_write(out, ", ", 2);
crypto: escape DNS altname Vulnerability credit goes to: Calvin Liang conradjliang@hotmail.com Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; PR-URL: ...private
10 years ago
if (gen->type == GEN_DNS) {
ASN1_IA5STRING* name = gen->d.dNSName;
BIO_write(out, "DNS:", 4);
BIO_write(out, name->data, name->length);
} else {
STACK_OF(CONF_VALUE)* nval = i2v_GENERAL_NAME(
const_cast<X509V3_EXT_METHOD*>(method), gen, NULL);
if (nval == NULL)
return false;
X509V3_EXT_val_prn(out, nval, 0, 0);
}
}
crypto: fix leak in SafeX509ExtPrint `ASN1_item_d2i`&#39;s return value must be freed by the owner. Fix: https://github.com/iojs/io.js/issues/1075 PR-URL: https://github.com/iojs/io.js/pull/1087 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
crypto: escape DNS altname Vulnerability credit goes to: Calvin Liang conradjliang@hotmail.com Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; PR-URL: ...private
10 years ago
return true;
}
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
static Local<Object> X509ToObject(Environment* env, X509* cert) {
EscapableHandleScope scope(env->isolate());
tls: handle SSL_ERROR_ZERO_RETURN see #5004
12 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
Local<Object> info = Object::New(env->isolate());
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
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
BIO* bio = BIO_new(BIO_s_mem());
BUF_MEM* mem;
if (X509_NAME_print_ex(bio,
X509_get_subject_name(cert),
0,
X509_NAME_FLAGS) > 0) {
BIO_get_mem_ptr(bio, &mem);
info->Set(env->subject_string(),
tls: fix encoding in certificate-related functions Strings are treated as UTF8 instead of one-byte strings when names are processed and when OpenSSL&#39;s ..._print functions are used. This commit fixes simple/test-tls-peer-certificate-encoding test. fix #8366
10 years ago
String::NewFromUtf8(env->isolate(), mem->data,
String::kNormalString, mem->length));
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
}
(void) BIO_reset(bio);
crypto: clear error in GetPeerCertificate fix #6945
11 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
X509_NAME* issuer_name = X509_get_issuer_name(cert);
if (X509_NAME_print_ex(bio, issuer_name, 0, X509_NAME_FLAGS) > 0) {
BIO_get_mem_ptr(bio, &mem);
info->Set(env->issuer_string(),
tls: fix encoding in certificate-related functions Strings are treated as UTF8 instead of one-byte strings when names are processed and when OpenSSL&#39;s ..._print functions are used. This commit fixes simple/test-tls-peer-certificate-encoding test. fix #8366
10 years ago
String::NewFromUtf8(env->isolate(), mem->data,
String::kNormalString, mem->length));
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
}
(void) BIO_reset(bio);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
int nids[] = { NID_subject_alt_name, NID_info_access };
Local<String> keys[] = { env->subjectaltname_string(),
env->infoaccess_string() };
CHECK_EQ(ARRAY_SIZE(nids), ARRAY_SIZE(keys));
for (unsigned int i = 0; i < ARRAY_SIZE(nids); i++) {
int index = X509_get_ext_by_NID(cert, nids[i], -1);
if (index < 0)
continue;
Drain OpenSSL error queue? Addresses #1719
13 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
X509_EXTENSION* ext;
int rv;
tls: support OCSP on client and server
11 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
ext = X509_get_ext(cert, index);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_NE(ext, nullptr);
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: escape DNS altname Vulnerability credit goes to: Calvin Liang conradjliang@hotmail.com Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; PR-URL: ...private
10 years ago
if (!SafeX509ExtPrint(bio, ext)) {
rv = X509V3_EXT_print(bio, ext, 0, 0);
CHECK_EQ(rv, 1);
}
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
BIO_get_mem_ptr(bio, &mem);
info->Set(keys[i],
tls: fix encoding in certificate-related functions Strings are treated as UTF8 instead of one-byte strings when names are processed and when OpenSSL&#39;s ..._print functions are used. This commit fixes simple/test-tls-peer-certificate-encoding test. fix #8366
10 years ago
String::NewFromUtf8(env->isolate(), mem->data,
String::kNormalString, mem->length));
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
(void) BIO_reset(bio);
}
Initial openssl support for net2
15 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
EVP_PKEY* pkey = X509_get_pubkey(cert);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
RSA* rsa = nullptr;
if (pkey != nullptr)
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
rsa = EVP_PKEY_get1_RSA(pkey);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (rsa != nullptr) {
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
BN_print(bio, rsa->n);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
BIO_get_mem_ptr(bio, &mem);
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
info->Set(env->modulus_string(),
tls: fix encoding in certificate-related functions Strings are treated as UTF8 instead of one-byte strings when names are processed and when OpenSSL&#39;s ..._print functions are used. This commit fixes simple/test-tls-peer-certificate-encoding test. fix #8366
10 years ago
String::NewFromUtf8(env->isolate(), mem->data,
String::kNormalString, mem->length));
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
(void) BIO_reset(bio);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
BN_print(bio, rsa->e);
BIO_get_mem_ptr(bio, &mem);
info->Set(env->exponent_string(),
tls: fix encoding in certificate-related functions Strings are treated as UTF8 instead of one-byte strings when names are processed and when OpenSSL&#39;s ..._print functions are used. This commit fixes simple/test-tls-peer-certificate-encoding test. fix #8366
10 years ago
String::NewFromUtf8(env->isolate(), mem->data,
String::kNormalString, mem->length));
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
(void) BIO_reset(bio);
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey != nullptr) {
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
EVP_PKEY_free(pkey);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
pkey = nullptr;
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (rsa != nullptr) {
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
RSA_free(rsa);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
rsa = nullptr;
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
}
ASN1_TIME_print(bio, X509_get_notBefore(cert));
BIO_get_mem_ptr(bio, &mem);
info->Set(env->valid_from_string(),
tls: fix encoding in certificate-related functions Strings are treated as UTF8 instead of one-byte strings when names are processed and when OpenSSL&#39;s ..._print functions are used. This commit fixes simple/test-tls-peer-certificate-encoding test. fix #8366
10 years ago
String::NewFromUtf8(env->isolate(), mem->data,
String::kNormalString, mem->length));
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
(void) BIO_reset(bio);
ASN1_TIME_print(bio, X509_get_notAfter(cert));
BIO_get_mem_ptr(bio, &mem);
info->Set(env->valid_to_string(),
tls: fix encoding in certificate-related functions Strings are treated as UTF8 instead of one-byte strings when names are processed and when OpenSSL&#39;s ..._print functions are used. This commit fixes simple/test-tls-peer-certificate-encoding test. fix #8366
10 years ago
String::NewFromUtf8(env->isolate(), mem->data,
String::kNormalString, mem->length));
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
BIO_free_all(bio);
unsigned int md_size, i;
unsigned char md[EVP_MAX_MD_SIZE];
if (X509_digest(cert, EVP_sha1(), md, &md_size)) {
const char hex[] = "0123456789ABCDEF";
char fingerprint[EVP_MAX_MD_SIZE * 3];
// TODO(indutny): Unify it with buffer's code
for (i = 0; i < md_size; i++) {
fingerprint[3*i] = hex[(md[i] & 0xf0) >> 4];
fingerprint[(3*i)+1] = hex[(md[i] & 0x0f)];
fingerprint[(3*i)+2] = ':';
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
if (md_size > 0) {
fingerprint[(3*(md_size-1))+2] = '\0';
} else {
fingerprint[0] = '\0';
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
info->Set(env->fingerprint_string(),
OneByteString(env->isolate(), fingerprint));
}
STACK_OF(ASN1_OBJECT)* eku = static_cast<STACK_OF(ASN1_OBJECT)*>(
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
X509_get_ext_d2i(cert, NID_ext_key_usage, nullptr, nullptr));
if (eku != nullptr) {
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
Local<Array> ext_key_usage = Array::New(env->isolate());
char buf[256];
int j = 0;
for (int i = 0; i < sk_ASN1_OBJECT_num(eku); i++) {
if (OBJ_obj2txt(buf, sizeof(buf), sk_ASN1_OBJECT_value(eku, i), 1) >= 0)
ext_key_usage->Set(j++, OneByteString(env->isolate(), buf));
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
sk_ASN1_OBJECT_pop_free(eku, ASN1_OBJECT_free);
info->Set(env->ext_key_usage_string(), ext_key_usage);
}
if (ASN1_INTEGER* serial_number = X509_get_serialNumber(cert)) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (BIGNUM* bn = ASN1_INTEGER_to_BN(serial_number, nullptr)) {
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
if (char* buf = BN_bn2hex(bn)) {
info->Set(env->serial_number_string(),
OneByteString(env->isolate(), buf));
OPENSSL_free(buf);
}
BN_free(bn);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
}
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
// Raw DER certificate
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
int size = i2d_X509(cert, nullptr);
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
Local<Object> buff = Buffer::New(env, size);
unsigned char* serialized = reinterpret_cast<unsigned char*>(
Buffer::Data(buff));
i2d_X509(cert, &serialized);
info->Set(env->raw_string(), buff);
TLS: Set ssl.receivedShutdown after each read Closes GH-613.
14 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
return scope.Escape(info);
}
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
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
// TODO(indutny): Split it into multiple smaller functions
template <class Base>
void SSLWrap<Base>::GetPeerCertificate(
const FunctionCallbackInfo<Value>& args) {
Base* w = Unwrap<Base>(args.Holder());
Environment* env = w->ssl_env();
OpenSSL NPN in node.js closes #926.
14 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence unused variable warning.
Add support for TLS SNI Fixes #1411
14 years ago
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
Local<Object> result;
Local<Object> info;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
crypto: work around OpenSSL oddness OpenSSL behaves oddly: on client `cert_chain` contains the `peer_certificate`, but on server it doesn&#39;t. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
// NOTE: This is because of the odd OpenSSL behavior. On client `cert_chain`
// contains the `peer_certificate`, but on server it doesn't
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
X509* cert = w->is_server() ? SSL_get_peer_certificate(w->ssl_) : nullptr;
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
STACK_OF(X509)* ssl_certs = SSL_get_peer_cert_chain(w->ssl_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
STACK_OF(X509)* peer_certs = nullptr;
if (cert == nullptr && ssl_certs == nullptr)
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
goto done;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (cert == nullptr && sk_X509_num(ssl_certs) == 0)
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
goto done;
// Short result requested
if (args.Length() < 1 || !args[0]->IsTrue()) {
crypto: work around OpenSSL oddness OpenSSL behaves oddly: on client `cert_chain` contains the `peer_certificate`, but on server it doesn&#39;t. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
result = X509ToObject(env,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
cert == nullptr ? sk_X509_value(ssl_certs, 0) : cert);
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
goto done;
}
// Clone `ssl_certs`, because we are going to destruct it
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
peer_certs = sk_X509_new(nullptr);
if (cert != nullptr)
crypto: work around OpenSSL oddness OpenSSL behaves oddly: on client `cert_chain` contains the `peer_certificate`, but on server it doesn&#39;t. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
sk_X509_push(peer_certs, cert);
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
for (int i = 0; i < sk_X509_num(ssl_certs); i++) {
cert = X509_dup(sk_X509_value(ssl_certs, i));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (cert == nullptr)
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
goto done;
if (!sk_X509_push(peer_certs, cert))
goto done;
}
// First and main certificate
cert = sk_X509_value(peer_certs, 0);
result = X509ToObject(env, cert);
info = result;
// Put issuer inside the object
cert = sk_X509_delete(peer_certs, 0);
while (sk_X509_num(peer_certs) > 0) {
int i;
for (i = 0; i < sk_X509_num(peer_certs); i++) {
X509* ca = sk_X509_value(peer_certs, i);
if (X509_check_issued(ca, cert) != X509_V_OK)
continue;
Local<Object> ca_info = X509ToObject(env, ca);
info->Set(env->issuercert_string(), ca_info);
info = ca_info;
// NOTE: Intentionally freeing cert that is not used anymore
X509_free(cert);
// Delete cert and continue aggregating issuers
cert = sk_X509_delete(peer_certs, i);
break;
tls: add serialNumber to getPeerCertificate() Add a &#39;serialNumber&#39; property to the object that is returned by tls.CryptoStream#getPeerCertificate(). Contains the certificate&#39;s serial number encoded as a hex string. The format is identical to `openssl x509 -serial -in path/to/certificate`. Fixes #6583.
11 years ago
}
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
// Issuer not found, break out of the loop
if (i == sk_X509_num(peer_certs))
break;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
// Last certificate should be self-signed
while (X509_check_issued(cert, cert) != X509_V_OK) {
X509* ca;
if (SSL_CTX_get_issuer(w->ssl_->ctx, cert, &ca) <= 0)
break;
Local<Object> ca_info = X509ToObject(env, ca);
info->Set(env->issuercert_string(), ca_info);
info = ca_info;
// NOTE: Intentionally freeing cert that is not used anymore
X509_free(cert);
// Delete cert and continue aggregating issuers
cert = ca;
}
// Self-issued certificate
if (X509_check_issued(cert, cert) == X509_V_OK)
info->Set(env->issuercert_string(), info);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_NE(cert, nullptr);
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
src: lint after OCSP commits
11 years ago
done:
crypto: fix X509 cert memory leak in GetPeerCert `SSL_get_peer_certificate` returns referenced X509 object, we should decrement the reference count once it is not needed. Fix joyent/node#8674 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; PR-URL: https://github.com/node-forward/node/pull/56
10 years ago
if (cert != nullptr)
X509_free(cert);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (peer_certs != nullptr)
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
sk_X509_pop_free(peer_certs, X509_free);
if (result.IsEmpty())
result = Object::New(env->isolate());
args.GetReturnValue().Set(result);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
template <class Base>
void SSLWrap<Base>::GetSession(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL_SESSION* sess = SSL_get_session(w->ssl_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (sess == nullptr)
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
return;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
int slen = i2d_SSL_SESSION(sess, nullptr);
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_GT(slen, 0);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
src: redo unaligned access workaround Introduce two-byte overloads of node::Encode() and StringBytes::Encode() that ensure that the input is suitably aligned. Revisits commit 535fec8 from yesterday.
10 years ago
char* sbuf = new char[slen];
unsigned char* p = reinterpret_cast<unsigned char*>(sbuf);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
i2d_SSL_SESSION(sess, &p);
src: remove `node_isolate` from source fix #6899
11 years ago
args.GetReturnValue().Set(Encode(env->isolate(), sbuf, slen, BUFFER));
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
delete[] sbuf;
}
template <class Base>
void SSLWrap<Base>::SetSession(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (args.Length() < 1 ||
(!args[0]->IsString() && !Buffer::HasInstance(args[0]))) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Bad argument");
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
src: don&#39;t call DecodeWrite() on Buffers Don&#39;t call DecodeWrite() with a Buffer as its argument because it in turn calls StringBytes::Write() and that method expects a Local&lt;String&gt;. &#34;Why then does that function take a Local&lt;Value&gt;?&#34; I hear you ask. Good question but I don&#39;t have the answer. I added a CHECK for good measure and what do you know, all of a sudden a large number of crypto tests started failing. Calling DecodeWrite(BINARY) on a buffer is nonsensical anyway: if you want the contents of the buffer, just copy out the data, there is no need to decode it - and that&#39;s exactly what this commit does. Fixes a great many instances of the following run-time error in debug builds: FATAL ERROR: v8::String::Cast() Could not convert to string
11 years ago
size_t slen = Buffer::Length(args[0]);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
char* sbuf = new char[slen];
src: don&#39;t call DecodeWrite() on Buffers Don&#39;t call DecodeWrite() with a Buffer as its argument because it in turn calls StringBytes::Write() and that method expects a Local&lt;String&gt;. &#34;Why then does that function take a Local&lt;Value&gt;?&#34; I hear you ask. Good question but I don&#39;t have the answer. I added a CHECK for good measure and what do you know, all of a sudden a large number of crypto tests started failing. Calling DecodeWrite(BINARY) on a buffer is nonsensical anyway: if you want the contents of the buffer, just copy out the data, there is no need to decode it - and that&#39;s exactly what this commit does. Fixes a great many instances of the following run-time error in debug builds: FATAL ERROR: v8::String::Cast() Could not convert to string
11 years ago
memcpy(sbuf, Buffer::Data(args[0]), slen);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
const unsigned char* p = reinterpret_cast<const unsigned char*>(sbuf);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
SSL_SESSION* sess = d2i_SSL_SESSION(nullptr, &p, slen);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
delete[] sbuf;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (sess == nullptr)
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
return;
int r = SSL_set_session(w->ssl_, sess);
SSL_SESSION_free(sess);
if (!r)
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("SSL_set_session error");
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
template <class Base>
void SSLWrap<Base>::LoadSession(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
Environment* env = w->ssl_env();
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (args.Length() >= 1 && Buffer::HasInstance(args[0])) {
ssize_t slen = Buffer::Length(args[0]);
char* sbuf = Buffer::Data(args[0]);
const unsigned char* p = reinterpret_cast<unsigned char*>(sbuf);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
SSL_SESSION* sess = d2i_SSL_SESSION(nullptr, &p, slen);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// Setup next session and move hello to the BIO buffer
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (w->next_sess_ != nullptr)
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL_SESSION_free(w->next_sess_);
w->next_sess_ = sess;
src: update to v8 3.24 APIs
11 years ago
Local<Object> info = Object::New(env->isolate());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#ifndef OPENSSL_NO_TLSEXT
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (sess->tlsext_hostname == nullptr) {
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
info->Set(env->servername_string(), False(args.GetIsolate()));
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
} else {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
info->Set(env->servername_string(),
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
OneByteString(args.GetIsolate(), sess->tlsext_hostname));
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
Add support for TLS SNI Fixes #1411
14 years ago
#endif
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
args.GetReturnValue().Set(info);
}
}
Add support for TLS SNI Fixes #1411
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
void SSLWrap<Base>::IsSessionReused(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
bool yes = SSL_session_reused(w->ssl_);
args.GetReturnValue().Set(yes);
Initial openssl support for net2
15 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
void SSLWrap<Base>::EndParser(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
w->hello_parser_.End();
}
tls: socket.renegotiate(options, callback) This utility function allows renegotiaion of secure connection after establishing it. fix #2496
12 years ago
template <class Base>
void SSLWrap<Base>::Renegotiate(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
tls: socket.renegotiate(options, callback) This utility function allows renegotiaion of secure connection after establishing it. fix #2496
12 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence unused variable warning.
bool yes = SSL_renegotiate(w->ssl_) == 1;
args.GetReturnValue().Set(yes);
}
Merge branch &#39;v0.10&#39; Conflicts: lib/tls.js src/node_crypto.cc src/node_crypto.h
11 years ago
template <class Base>
void SSLWrap<Base>::Shutdown(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
Merge branch &#39;v0.10&#39; Conflicts: lib/tls.js src/node_crypto.cc src/node_crypto.h
11 years ago
int rv = SSL_shutdown(w->ssl_);
args.GetReturnValue().Set(rv);
Read all records to always empty the OpenSSL reading buffer.
15 years ago
}
Lint node_crypto.cc
15 years ago
tls: more session configuration options, methods Introduce `ticketKeys` server option, `session` client option, `getSession()` and `getTLSTicket()` methods. fix #7032
11 years ago
template <class Base>
void SSLWrap<Base>::GetTLSTicket(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
tls: more session configuration options, methods Introduce `ticketKeys` server option, `session` client option, `getSession()` and `getTLSTicket()` methods. fix #7032
11 years ago
Environment* env = w->ssl_env();
SSL_SESSION* sess = SSL_get_session(w->ssl_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (sess == nullptr || sess->tlsext_tick == nullptr)
tls: more session configuration options, methods Introduce `ticketKeys` server option, `session` client option, `getSession()` and `getTLSTicket()` methods. fix #7032
11 years ago
return;
Local<Object> buf = Buffer::New(env,
reinterpret_cast<char*>(sess->tlsext_tick),
sess->tlsext_ticklen);
args.GetReturnValue().Set(buf);
}
tls: introduce asynchronous `newSession` fix #7105
11 years ago
template <class Base>
void SSLWrap<Base>::NewSessionDone(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
tls: introduce asynchronous `newSession` fix #7105
11 years ago
w->new_session_wait_ = false;
w->NewSessionDoneCb();
}
tls: support OCSP on client and server
11 years ago
template <class Base>
void SSLWrap<Base>::SetOCSPResponse(
const v8::FunctionCallbackInfo<v8::Value>& args) {
#ifdef NODE__HAVE_TLSEXT_STATUS_CB
HandleScope scope(args.GetIsolate());
Base* w = Unwrap<Base>(args.Holder());
if (args.Length() < 1 || !Buffer::HasInstance(args[0]))
return w->env()->ThrowTypeError("Must give a Buffer as first argument");
w->ocsp_response_.Reset(args.GetIsolate(), args[0].As<Object>());
#endif // NODE__HAVE_TLSEXT_STATUS_CB
}
template <class Base>
void SSLWrap<Base>::RequestOCSP(
const v8::FunctionCallbackInfo<v8::Value>& args) {
#ifdef NODE__HAVE_TLSEXT_STATUS_CB
HandleScope scope(args.GetIsolate());
Base* w = Unwrap<Base>(args.Holder());
SSL_set_tlsext_status_type(w->ssl_, TLSEXT_STATUSTYPE_ocsp);
#endif // NODE__HAVE_TLSEXT_STATUS_CB
}
lib: introduce `.setMaxSendFragment(size)` fix #6889
11 years ago
#ifdef SSL_set_max_send_fragment
template <class Base>
void SSLWrap<Base>::SetMaxSendFragment(
const v8::FunctionCallbackInfo<v8::Value>& args) {
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(args.GetIsolate());
lib: introduce `.setMaxSendFragment(size)` fix #6889
11 years ago
CHECK(args.Length() >= 1 && args[0]->IsNumber());
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
lib: introduce `.setMaxSendFragment(size)` fix #6889
11 years ago
int rv = SSL_set_max_send_fragment(w->ssl_, args[0]->Int32Value());
args.GetReturnValue().Set(rv);
}
#endif // SSL_set_max_send_fragment
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
void SSLWrap<Base>::IsInitFinished(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
bool yes = SSL_is_init_finished(w->ssl_);
args.GetReturnValue().Set(yes);
}
template <class Base>
void SSLWrap<Base>::VerifyError(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
tls: show human-readable error messages Before this commit, verification exceptions had err.message set to the OpenSSL error code (e.g. &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;). This commit moves the error code to err.code and replaces err.message with a human-readable error. Example: // before { message: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39; } // after { code: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;, message: &#39;unable to verify the first certificate&#39; } UNABLE_TO_VERIFY_LEAF_SIGNATURE is a good example of why you want this: the error code suggests that it&#39;s the last certificate that fails to validate while it&#39;s actually the first certificate in the chain. Going by the number of mailing list posts and StackOverflow questions, it&#39;s a source of confusion to many people.
11 years ago
// XXX(bnoordhuis) The UNABLE_TO_GET_ISSUER_CERT error when there is no
// peer certificate is questionable but it's compatible with what was
// here before.
long x509_verify_error = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT;
if (X509* peer_cert = SSL_get_peer_certificate(w->ssl_)) {
X509_free(peer_cert);
x509_verify_error = SSL_get_verify_result(w->ssl_);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
tls: show human-readable error messages Before this commit, verification exceptions had err.message set to the OpenSSL error code (e.g. &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;). This commit moves the error code to err.code and replaces err.message with a human-readable error. Example: // before { message: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39; } // after { code: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;, message: &#39;unable to verify the first certificate&#39; } UNABLE_TO_VERIFY_LEAF_SIGNATURE is a good example of why you want this: the error code suggests that it&#39;s the last certificate that fails to validate while it&#39;s actually the first certificate in the chain. Going by the number of mailing list posts and StackOverflow questions, it&#39;s a source of confusion to many people.
11 years ago
if (x509_verify_error == X509_V_OK)
return args.GetReturnValue().SetNull();
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
tls: show human-readable error messages Before this commit, verification exceptions had err.message set to the OpenSSL error code (e.g. &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;). This commit moves the error code to err.code and replaces err.message with a human-readable error. Example: // before { message: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39; } // after { code: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;, message: &#39;unable to verify the first certificate&#39; } UNABLE_TO_VERIFY_LEAF_SIGNATURE is a good example of why you want this: the error code suggests that it&#39;s the last certificate that fails to validate while it&#39;s actually the first certificate in the chain. Going by the number of mailing list posts and StackOverflow questions, it&#39;s a source of confusion to many people.
11 years ago
// XXX(bnoordhuis) X509_verify_cert_error_string() is not actually thread-safe
// in the presence of invalid error codes. Probably academical but something
// to keep in mind if/when node ever grows multi-isolate capabilities.
const char* reason = X509_verify_cert_error_string(x509_verify_error);
const char* code = reason;
#define CASE_X509_ERR(CODE) case X509_V_ERR_##CODE: code = #CODE; break;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
switch (x509_verify_error) {
CASE_X509_ERR(UNABLE_TO_GET_ISSUER_CERT)
CASE_X509_ERR(UNABLE_TO_GET_CRL)
CASE_X509_ERR(UNABLE_TO_DECRYPT_CERT_SIGNATURE)
CASE_X509_ERR(UNABLE_TO_DECRYPT_CRL_SIGNATURE)
CASE_X509_ERR(UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY)
CASE_X509_ERR(CERT_SIGNATURE_FAILURE)
CASE_X509_ERR(CRL_SIGNATURE_FAILURE)
CASE_X509_ERR(CERT_NOT_YET_VALID)
CASE_X509_ERR(CERT_HAS_EXPIRED)
CASE_X509_ERR(CRL_NOT_YET_VALID)
CASE_X509_ERR(CRL_HAS_EXPIRED)
CASE_X509_ERR(ERROR_IN_CERT_NOT_BEFORE_FIELD)
CASE_X509_ERR(ERROR_IN_CERT_NOT_AFTER_FIELD)
CASE_X509_ERR(ERROR_IN_CRL_LAST_UPDATE_FIELD)
CASE_X509_ERR(ERROR_IN_CRL_NEXT_UPDATE_FIELD)
CASE_X509_ERR(OUT_OF_MEM)
CASE_X509_ERR(DEPTH_ZERO_SELF_SIGNED_CERT)
CASE_X509_ERR(SELF_SIGNED_CERT_IN_CHAIN)
CASE_X509_ERR(UNABLE_TO_GET_ISSUER_CERT_LOCALLY)
CASE_X509_ERR(UNABLE_TO_VERIFY_LEAF_SIGNATURE)
CASE_X509_ERR(CERT_CHAIN_TOO_LONG)
CASE_X509_ERR(CERT_REVOKED)
CASE_X509_ERR(INVALID_CA)
CASE_X509_ERR(PATH_LENGTH_EXCEEDED)
CASE_X509_ERR(INVALID_PURPOSE)
CASE_X509_ERR(CERT_UNTRUSTED)
CASE_X509_ERR(CERT_REJECTED)
}
tls: show human-readable error messages Before this commit, verification exceptions had err.message set to the OpenSSL error code (e.g. &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;). This commit moves the error code to err.code and replaces err.message with a human-readable error. Example: // before { message: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39; } // after { code: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;, message: &#39;unable to verify the first certificate&#39; } UNABLE_TO_VERIFY_LEAF_SIGNATURE is a good example of why you want this: the error code suggests that it&#39;s the last certificate that fails to validate while it&#39;s actually the first certificate in the chain. Going by the number of mailing list posts and StackOverflow questions, it&#39;s a source of confusion to many people.
11 years ago
#undef CASE_X509_ERR
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
tls: show human-readable error messages Before this commit, verification exceptions had err.message set to the OpenSSL error code (e.g. &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;). This commit moves the error code to err.code and replaces err.message with a human-readable error. Example: // before { message: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39; } // after { code: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;, message: &#39;unable to verify the first certificate&#39; } UNABLE_TO_VERIFY_LEAF_SIGNATURE is a good example of why you want this: the error code suggests that it&#39;s the last certificate that fails to validate while it&#39;s actually the first certificate in the chain. Going by the number of mailing list posts and StackOverflow questions, it&#39;s a source of confusion to many people.
11 years ago
Isolate* isolate = args.GetIsolate();
Local<String> reason_string = OneByteString(isolate, reason);
Local<Value> exception_value = Exception::Error(reason_string);
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
Local<Object> exception_object = exception_value->ToObject(isolate);
tls: show human-readable error messages Before this commit, verification exceptions had err.message set to the OpenSSL error code (e.g. &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;). This commit moves the error code to err.code and replaces err.message with a human-readable error. Example: // before { message: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39; } // after { code: &#39;UNABLE_TO_VERIFY_LEAF_SIGNATURE&#39;, message: &#39;unable to verify the first certificate&#39; } UNABLE_TO_VERIFY_LEAF_SIGNATURE is a good example of why you want this: the error code suggests that it&#39;s the last certificate that fails to validate while it&#39;s actually the first certificate in the chain. Going by the number of mailing list posts and StackOverflow questions, it&#39;s a source of confusion to many people.
11 years ago
exception_object->Set(FIXED_ONE_BYTE_STRING(isolate, "code"),
OneByteString(isolate, code));
args.GetReturnValue().Set(exception_object);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
OpenSSL NPN in node.js closes #926.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
void SSLWrap<Base>::GetCurrentCipher(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
Environment* env = w->ssl_env();
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
OPENSSL_CONST SSL_CIPHER* c = SSL_get_current_cipher(w->ssl_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (c == nullptr)
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
return;
src: update to v8 3.24 APIs
11 years ago
Local<Object> info = Object::New(env->isolate());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
const char* cipher_name = SSL_CIPHER_get_name(c);
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
info->Set(env->name_string(), OneByteString(args.GetIsolate(), cipher_name));
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
const char* cipher_version = SSL_CIPHER_get_version(c);
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
info->Set(env->version_string(),
OneByteString(args.GetIsolate(), cipher_version));
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
args.GetReturnValue().Set(info);
}
#ifdef OPENSSL_NPN_NEGOTIATED
template <class Base>
int SSLWrap<Base>::AdvertiseNextProtoCallback(SSL* s,
const unsigned char** data,
unsigned int* len,
void* arg) {
crypto: never store pointer to conn in SSL_CTX SSL_CTX is shared between multiple connections and is not a right place to store per-connection data. fix #8348 Reviewed-By: Trevor Norris
10 years ago
Base* w = static_cast<Base*>(SSL_get_app_data(s));
crypto: fix up implicit HandleScope abuse Don&#39;t depend on any HandleScope objects that may or may not have been created in src/stream_wrap.cc, create them explicitly.
11 years ago
Environment* env = w->env();
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (w->npn_protos_.IsEmpty()) {
OpenSSL NPN in node.js closes #926.
14 years ago
// No initialization - no NPN protocols
*data = reinterpret_cast<const unsigned char*>("");
*len = 0;
} else {
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
Local<Object> obj = PersistentToLocal(env->isolate(), w->npn_protos_);
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;
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
int SSLWrap<Base>::SelectNextProtoCallback(SSL* s,
unsigned char** out,
unsigned char* outlen,
const unsigned char* in,
unsigned int inlen,
void* arg) {
crypto: never store pointer to conn in SSL_CTX SSL_CTX is shared between multiple connections and is not a right place to store per-connection data. fix #8348 Reviewed-By: Trevor Norris
10 years ago
Base* w = static_cast<Base*>(SSL_get_app_data(s));
crypto: fix up implicit HandleScope abuse Don&#39;t depend on any HandleScope objects that may or may not have been created in src/stream_wrap.cc, create them explicitly.
11 years ago
Environment* env = w->env();
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
OpenSSL NPN in node.js closes #926.
14 years ago
// Release old protocol handler if present
src: update to v8 3.24 APIs
11 years ago
w->selected_npn_proto_.Reset();
OpenSSL NPN in node.js closes #926.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (w->npn_protos_.IsEmpty()) {
OpenSSL NPN in node.js closes #926.
14 years ago
// 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;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// set status: unsupported
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
w->selected_npn_proto_.Reset(env->isolate(), False(env->isolate()));
OpenSSL NPN in node.js closes #926.
14 years ago
return SSL_TLSEXT_ERR_OK;
}
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
Local<Object> obj = PersistentToLocal(env->isolate(), w->npn_protos_);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
const unsigned char* npn_protos =
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));
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
size_t len = Buffer::Length(obj);
OpenSSL NPN in node.js closes #926.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int status = SSL_select_next_proto(out, outlen, in, inlen, npn_protos, len);
Handle<Value> result;
OpenSSL NPN in node.js closes #926.
14 years ago
switch (status) {
case OPENSSL_NPN_UNSUPPORTED:
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
result = Null(env->isolate());
OpenSSL NPN in node.js closes #926.
14 years ago
break;
case OPENSSL_NPN_NEGOTIATED:
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
result = OneByteString(env->isolate(), *out, *outlen);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
break;
OpenSSL NPN in node.js closes #926.
14 years ago
case OPENSSL_NPN_NO_OVERLAP:
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
result = False(env->isolate());
OpenSSL NPN in node.js closes #926.
14 years ago
break;
default:
break;
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (!result.IsEmpty())
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
w->selected_npn_proto_.Reset(env->isolate(), result);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
OpenSSL NPN in node.js closes #926.
14 years ago
return SSL_TLSEXT_ERR_OK;
Fix line endings and trailing whitespace
13 years ago
}
OpenSSL NPN in node.js closes #926.
14 years ago
Add support for TLS SNI Fixes #1411
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
void SSLWrap<Base>::GetNegotiatedProto(
const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
Add support for TLS SNI Fixes #1411
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (w->is_client()) {
if (w->selected_npn_proto_.IsEmpty() == false) {
args.GetReturnValue().Set(w->selected_npn_proto_);
}
return;
}
Add support for TLS SNI Fixes #1411
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
const unsigned char* npn_proto;
unsigned int npn_proto_len;
Add support for TLS SNI Fixes #1411
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL_get0_next_proto_negotiated(w->ssl_, &npn_proto, &npn_proto_len);
Add support for TLS SNI Fixes #1411
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (!npn_proto)
return args.GetReturnValue().Set(false);
Add support for TLS SNI Fixes #1411
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
args.GetReturnValue().Set(
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
OneByteString(args.GetIsolate(), npn_proto, npn_proto_len));
Add support for TLS SNI Fixes #1411
14 years ago
}
Remove assert in verify_peer; add comments
14 years ago
Fix style in node_crypto.cc
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
template <class Base>
void SSLWrap<Base>::SetNPNProtocols(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Base* w = Unwrap<Base>(args.Holder());
Fix style in node_crypto.cc
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (args.Length() < 1 || !Buffer::HasInstance(args[0]))
src: remove `node_isolate` from source fix #6899
11 years ago
return w->env()->ThrowTypeError("Must give a Buffer as first argument");
Fix style in node_crypto.cc
14 years ago
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
w->npn_protos_.Reset(args.GetIsolate(), args[0].As<Object>());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
#endif // OPENSSL_NPN_NEGOTIATED
Fix style in node_crypto.cc
14 years ago
OpenSSL NPN in node.js closes #926.
14 years ago
tls: support OCSP on client and server
11 years ago
#ifdef NODE__HAVE_TLSEXT_STATUS_CB
template <class Base>
int SSLWrap<Base>::TLSExtStatusCallback(SSL* s, void* arg) {
crypto: never store pointer to conn in SSL_CTX SSL_CTX is shared between multiple connections and is not a right place to store per-connection data. fix #8348 Reviewed-By: Trevor Norris
10 years ago
Base* w = static_cast<Base*>(SSL_get_app_data(s));
tls: support OCSP on client and server
11 years ago
Environment* env = w->env();
HandleScope handle_scope(env->isolate());
if (w->is_client()) {
// Incoming response
const unsigned char* resp;
int len = SSL_get_tlsext_status_ocsp_resp(s, &resp);
Local<Value> arg;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (resp == nullptr) {
tls: support OCSP on client and server
11 years ago
arg = Null(env->isolate());
} else {
arg = Buffer::New(
env,
reinterpret_cast<char*>(const_cast<unsigned char*>(resp)),
len);
}
w->MakeCallback(env->onocspresponse_string(), 1, &arg);
// Somehow, client is expecting different return value here
return 1;
} else {
// Outgoing response
if (w->ocsp_response_.IsEmpty())
return SSL_TLSEXT_ERR_NOACK;
Local<Object> obj = PersistentToLocal(env->isolate(), w->ocsp_response_);
char* resp = Buffer::Data(obj);
size_t len = Buffer::Length(obj);
// OpenSSL takes control of the pointer after accepting it
char* data = reinterpret_cast<char*>(malloc(len));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_NE(data, nullptr);
tls: support OCSP on client and server
11 years ago
memcpy(data, resp, len);
if (!SSL_set_tlsext_status_ocsp_resp(s, data, len))
free(data);
w->ocsp_response_.Reset();
return SSL_TLSEXT_ERR_OK;
}
}
#endif // NODE__HAVE_TLSEXT_STATUS_CB
tls: use `SSL_set_cert_cb` for async SNI/OCSP Do not enable ClientHello parser for async SNI/OCSP. Use new OpenSSL-1.0.2&#39;s API `SSL_set_cert_cb` to pause the handshake process and load the cert/OCSP response asynchronously. Hopefuly this will make whole async SNI/OCSP process much faster and will eventually let us remove the ClientHello parser itself (which is currently used only for async session, see #1462 for the discussion of removing it). NOTE: Ported our code to `SSL_CTX_add1_chain_cert` to use `SSL_CTX_get0_chain_certs` in `CertCbDone`. Test provided for this feature. Fix: https://github.com/iojs/io.js/issues/1423 PR-URL: https://github.com/iojs/io.js/pull/1464 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
template <class Base>
void SSLWrap<Base>::WaitForCertCb(CertCb cb, void* arg) {
cert_cb_ = cb;
cert_cb_arg_ = arg;
}
template <class Base>
int SSLWrap<Base>::SSLCertCallback(SSL* s, void* arg) {
Base* w = static_cast<Base*>(SSL_get_app_data(s));
if (!w->is_server())
return 1;
if (!w->is_waiting_cert_cb())
return 1;
if (w->cert_cb_running_)
return -1;
Environment* env = w->env();
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
w->cert_cb_running_ = true;
Local<Object> info = Object::New(env->isolate());
SSL_SESSION* sess = SSL_get_session(s);
if (sess != nullptr) {
if (sess->tlsext_hostname == nullptr) {
info->Set(env->servername_string(), String::Empty(env->isolate()));
} else {
Local<String> servername = OneByteString(env->isolate(),
sess->tlsext_hostname,
strlen(sess->tlsext_hostname));
info->Set(env->servername_string(), servername);
}
info->Set(env->tls_ticket_string(),
Boolean::New(env->isolate(), sess->tlsext_ticklen != 0));
}
bool ocsp = s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp;
info->Set(env->ocsp_request_string(), Boolean::New(env->isolate(), ocsp));
Local<Value> argv[] = { info };
w->MakeCallback(env->oncertcb_string(), ARRAY_SIZE(argv), argv);
if (!w->cert_cb_running_)
return 1;
// Performing async action, wait...
return -1;
}
template <class Base>
void SSLWrap<Base>::CertCbDone(const FunctionCallbackInfo<Value>& args) {
Base* w = Unwrap<Base>(args.Holder());
Environment* env = w->env();
CHECK(w->is_waiting_cert_cb() && w->cert_cb_running_);
Local<Object> object = w->object();
Local<Value> ctx = object->Get(env->sni_context_string());
Local<FunctionTemplate> cons = env->secure_context_constructor_template();
// Not an object, probably undefined or null
if (!ctx->IsObject())
goto fire_cb;
if (cons->HasInstance(ctx)) {
SecureContext* sc = Unwrap<SecureContext>(ctx.As<Object>());
w->sni_context_.Reset();
w->sni_context_.Reset(env->isolate(), ctx);
int rv;
// NOTE: reference count is not increased by this API methods
X509* x509 = SSL_CTX_get0_certificate(sc->ctx_);
EVP_PKEY* pkey = SSL_CTX_get0_privatekey(sc->ctx_);
STACK_OF(X509)* chain;
rv = SSL_CTX_get0_chain_certs(sc->ctx_, &chain);
if (rv)
rv = SSL_use_certificate(w->ssl_, x509);
if (rv)
rv = SSL_use_PrivateKey(w->ssl_, pkey);
if (rv && chain != nullptr)
rv = SSL_set1_chain(w->ssl_, chain);
if (!rv) {
unsigned long err = ERR_get_error();
if (!err)
return env->ThrowError("CertCbDone");
return ThrowCryptoError(env, err);
}
} else {
// Failure: incorrect SNI context object
Local<Value> err = Exception::TypeError(env->sni_context_err_string());
w->MakeCallback(env->onerror_string(), 1, &err);
return;
}
fire_cb:
CertCb cb;
void* arg;
cb = w->cert_cb_;
arg = w->cert_cb_arg_;
w->cert_cb_running_ = false;
w->cert_cb_ = nullptr;
w->cert_cb_arg_ = nullptr;
cb(arg);
}
crypto: export externals to internal structs Export External getters for a internal structs: SSL, SSL_CTX.
10 years ago
template <class Base>
void SSLWrap<Base>::SSLGetter(Local<String> property,
const PropertyCallbackInfo<Value>& info) {
HandleScope scope(info.GetIsolate());
SSL* ssl = Unwrap<Base>(info.Holder())->ssl_;
Local<External> ext = External::New(info.GetIsolate(), ssl);
info.GetReturnValue().Set(ext);
}
tls: destroy SSL once it is out of use Do not keep SSL structure in memory once socket is closed. This should lower the memory usage in many cases. Fix: https://github.com/iojs/io.js/issues/1522 PR-URL: https://github.com/iojs/io.js/pull/1529 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
template <class Base>
void SSLWrap<Base>::DestroySSL() {
if (ssl_ == nullptr)
return;
SSL_free(ssl_);
crypto: track external memory for SSL structures Ensure that GC kicks in at the right times and the RSS does not blow up. Fix: https://github.com/iojs/io.js/issues/1522 PR-URL: https://github.com/iojs/io.js/pull/1529 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
env_->isolate()->AdjustAmountOfExternalAllocatedMemory(-kExternalSize);
tls: destroy SSL once it is out of use Do not keep SSL structure in memory once socket is closed. This should lower the memory usage in many cases. Fix: https://github.com/iojs/io.js/issues/1522 PR-URL: https://github.com/iojs/io.js/pull/1529 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
ssl_ = nullptr;
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::OnClientHelloParseEnd(void* arg) {
Connection* conn = static_cast<Connection*>(arg);
Add support for TLS SNI Fixes #1411
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// Write all accumulated data
int r = BIO_write(conn->bio_read_,
reinterpret_cast<char*>(conn->hello_data_),
conn->hello_offset_);
conn->HandleBIOError(conn->bio_read_, "BIO_write", r);
conn->SetShutdownFlags();
}
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
OpenSSL NPN in node.js closes #926.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#ifdef SSL_PRINT_DEBUG
# define DEBUG_PRINT(...) fprintf (stderr, __VA_ARGS__)
#else
# define DEBUG_PRINT(...)
Add support for TLS SNI Fixes #1411
14 years ago
#endif
Use SSL_MODE_RELEASE_BUFFERS by default.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int Connection::HandleBIOError(BIO *bio, const char* func, int rv) {
cpplint: disallow if one-liners
11 years ago
if (rv >= 0)
return rv;
Server must not request cert.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int retry = BIO_should_retry(bio);
(void) retry; // unused if !defined(SSL_PRINT_DEBUG)
Server must not request cert.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (BIO_should_write(bio)) {
DEBUG_PRINT("[%p] BIO: %s want write. should retry %d\n",
ssl_,
func,
retry);
return 0;
Server must not request cert.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
} else if (BIO_should_read(bio)) {
DEBUG_PRINT("[%p] BIO: %s want read. should retry %d\n", ssl_, func, retry);
return 0;
Fix style in node_crypto.cc
14 years ago
Initial openssl support for net2
15 years ago
} else {
crypto: make error buffer non-static Doesn&#39;t matter now but it will if/when we have support for multiple threads.
11 years ago
char ssl_error_buf[512];
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
ERR_error_string_n(rv, ssl_error_buf, sizeof(ssl_error_buf));
Initial openssl support for net2
15 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(ssl_env()->isolate());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
Local<Value> exception =
src: remove `node_isolate` from source fix #6899
11 years ago
Exception::Error(OneByteString(ssl_env()->isolate(), ssl_error_buf));
object()->Set(ssl_env()->error_string(), exception);
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
DEBUG_PRINT("[%p] BIO: %s failed: (%d) %s\n",
ssl_,
func,
rv,
ssl_error_buf);
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
return rv;
Initial openssl support for net2
15 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
return 0;
}
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
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int Connection::HandleSSLError(const char* func,
int rv,
ZeroStatus zs,
SyscallStatus ss) {
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence unused variable warning.
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (rv > 0)
return rv;
if (rv == 0 && zs == kZeroIsNotAnError)
return rv;
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int err = SSL_get_error(ssl_, rv);
Lint node_crypto.cc
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (err == SSL_ERROR_NONE) {
return 0;
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
} else if (err == SSL_ERROR_WANT_WRITE) {
DEBUG_PRINT("[%p] SSL: %s want write\n", ssl_, func);
return 0;
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
} else if (err == SSL_ERROR_WANT_READ) {
DEBUG_PRINT("[%p] SSL: %s want read\n", ssl_, func);
return 0;
Initial openssl support for net2
15 years ago
tls: use `SSL_set_cert_cb` for async SNI/OCSP Do not enable ClientHello parser for async SNI/OCSP. Use new OpenSSL-1.0.2&#39;s API `SSL_set_cert_cb` to pause the handshake process and load the cert/OCSP response asynchronously. Hopefuly this will make whole async SNI/OCSP process much faster and will eventually let us remove the ClientHello parser itself (which is currently used only for async session, see #1462 for the discussion of removing it). NOTE: Ported our code to `SSL_CTX_add1_chain_cert` to use `SSL_CTX_get0_chain_certs` in `CertCbDone`. Test provided for this feature. Fix: https://github.com/iojs/io.js/issues/1423 PR-URL: https://github.com/iojs/io.js/pull/1464 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
} else if (err == SSL_ERROR_WANT_X509_LOOKUP) {
DEBUG_PRINT("[%p] SSL: %s want x509 lookup\n", ssl_, func);
return 0;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
} else if (err == SSL_ERROR_ZERO_RETURN) {
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(ssl_env()->isolate());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
Local<Value> exception =
src: remove `node_isolate` from source fix #6899
11 years ago
Exception::Error(ssl_env()->zero_return_string());
object()->Set(ssl_env()->error_string(), exception);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
return rv;
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
} else if (err == SSL_ERROR_SYSCALL && ss == kIgnoreSyscall) {
return 0;
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(ssl_env()->isolate());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
BUF_MEM* mem;
BIO *bio;
Initial openssl support for net2
15 years ago
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK(err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL);
TLS: better error reporting at binding layer Closes GH-612.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 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
// understood. And we should be somehow propagating these errors up
// into JavaScript. There is no test which demonstrates this problem.
// https://github.com/joyent/node/issues/1719
bio = BIO_new(BIO_s_mem());
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (bio != nullptr) {
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
ERR_print_errors(bio);
BIO_get_mem_ptr(bio, &mem);
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> exception = Exception::Error(
OneByteString(ssl_env()->isolate(),
mem->data,
mem->length));
object()->Set(ssl_env()->error_string(), exception);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
BIO_free_all(bio);
Initial openssl support for net2
15 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
return rv;
Initial openssl support for net2
15 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
return 0;
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::ClearError() {
#ifndef NDEBUG
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(ssl_env()->isolate());
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// We should clear the error in JS-land
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> error_key = ssl_env()->error_string();
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
Local<Value> error = object()->Get(error_key);
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_EQ(error->BooleanValue(), false);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#endif // NDEBUG
Initial openssl support for net2
15 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::SetShutdownFlags() {
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(ssl_env()->isolate());
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int flags = SSL_get_shutdown(ssl_);
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (flags & SSL_SENT_SHUTDOWN) {
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> sent_shutdown_key = ssl_env()->sent_shutdown_string();
object()->Set(sent_shutdown_key, True(ssl_env()->isolate()));
Initial openssl support for net2
15 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (flags & SSL_RECEIVED_SHUTDOWN) {
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> received_shutdown_key = ssl_env()->received_shutdown_string();
object()->Set(received_shutdown_key, True(ssl_env()->isolate()));
Initial openssl support for net2
15 years ago
}
}
tls: introduce asynchronous `newSession` fix #7105
11 years ago
void Connection::NewSessionDoneCb() {
HandleScope scope(env()->isolate());
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
MakeCallback(env()->onnewsessiondone_string(), 0, nullptr);
tls: introduce asynchronous `newSession` fix #7105
11 years ago
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void Connection::Initialize(Environment* env, Handle<Object> target) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t = env->NewFunctionTemplate(Connection::New);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Connection"));
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "encIn", Connection::EncIn);
env->SetProtoMethod(t, "clearOut", Connection::ClearOut);
env->SetProtoMethod(t, "clearIn", Connection::ClearIn);
env->SetProtoMethod(t, "encOut", Connection::EncOut);
env->SetProtoMethod(t, "clearPending", Connection::ClearPending);
env->SetProtoMethod(t, "encPending", Connection::EncPending);
env->SetProtoMethod(t, "start", Connection::Start);
env->SetProtoMethod(t, "close", Connection::Close);
crypto: use X509_get_ext_by_NID(NID_subject_alt_name)
14 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
SSLWrap<Connection>::AddMethods(env, t);
crypto: use X509_get_ext_by_NID(NID_subject_alt_name)
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "getServername", Connection::GetServername);
env->SetProtoMethod(t, "setSNICallback", Connection::SetSNICallback);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#endif
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: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Connection"),
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
t->GetFunction());
}
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
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
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
// imparative that the user use Connection::VerifyError after the
// 'secure' callback has been made.
return 1;
}
crypto: fix leak in GetPeerCertificate
12 years ago
tls: x509 certificate subject parsing fail Fixes #1568.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
int Connection::SelectSNIContextCallback_(SSL *s, int *ad, void* arg) {
Connection* conn = static_cast<Connection*>(SSL_get_app_data(s));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Environment* env = conn->env();
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
HandleScope scope(env->isolate());
Expose fingerproint from getPeerCertificate Expose the SHA1 digest of the certificate as the fingerprint attribute in the object returned by getPeerCertificate()
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
const char* servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
Expose fingerproint from getPeerCertificate Expose the SHA1 digest of the certificate as the fingerprint attribute in the object returned by getPeerCertificate()
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (servername) {
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
conn->servername_.Reset(env->isolate(),
OneByteString(env->isolate(), servername));
Expose fingerproint from getPeerCertificate Expose the SHA1 digest of the certificate as the fingerprint attribute in the object returned by getPeerCertificate()
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// Call the SNI callback and use its return value as context
if (!conn->sniObject_.IsEmpty()) {
tls: use `SSL_set_cert_cb` for async SNI/OCSP Do not enable ClientHello parser for async SNI/OCSP. Use new OpenSSL-1.0.2&#39;s API `SSL_set_cert_cb` to pause the handshake process and load the cert/OCSP response asynchronously. Hopefuly this will make whole async SNI/OCSP process much faster and will eventually let us remove the ClientHello parser itself (which is currently used only for async session, see #1462 for the discussion of removing it). NOTE: Ported our code to `SSL_CTX_add1_chain_cert` to use `SSL_CTX_get0_chain_certs` in `CertCbDone`. Test provided for this feature. Fix: https://github.com/iojs/io.js/issues/1423 PR-URL: https://github.com/iojs/io.js/pull/1464 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
conn->sni_context_.Reset();
Fix style issues with ext_key_usage patch Closes GH-586.
14 years ago
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
Local<Value> arg = PersistentToLocal(env->isolate(), conn->servername_);
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
Local<Value> ret = conn->MakeCallback(env->onselect_string(), 1, &arg);
Fix style issues with ext_key_usage patch Closes GH-586.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// If ret is SecureContext
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<FunctionTemplate> secure_context_constructor_template =
env->secure_context_constructor_template();
if (secure_context_constructor_template->HasInstance(ret)) {
tls: use `SSL_set_cert_cb` for async SNI/OCSP Do not enable ClientHello parser for async SNI/OCSP. Use new OpenSSL-1.0.2&#39;s API `SSL_set_cert_cb` to pause the handshake process and load the cert/OCSP response asynchronously. Hopefuly this will make whole async SNI/OCSP process much faster and will eventually let us remove the ClientHello parser itself (which is currently used only for async session, see #1462 for the discussion of removing it). NOTE: Ported our code to `SSL_CTX_add1_chain_cert` to use `SSL_CTX_get0_chain_certs` in `CertCbDone`. Test provided for this feature. Fix: https://github.com/iojs/io.js/issues/1423 PR-URL: https://github.com/iojs/io.js/pull/1464 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
conn->sni_context_.Reset(env->isolate(), ret);
src: shorten Object{Wrap,Unwrap} Going back to the original names of Wrap/Unwrap now that most all the class members that duplicate the name and functionality have been removed.
11 years ago
SecureContext* sc = Unwrap<SecureContext>(ret.As<Object>());
crypto: never store pointer to conn in SSL_CTX SSL_CTX is shared between multiple connections and is not a right place to store per-connection data. fix #8348 Reviewed-By: Trevor Norris
10 years ago
InitNPN(sc);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL_set_SSL_CTX(s, sc->ctx_);
} else {
return SSL_TLSEXT_ERR_NOACK;
Add ext_key_usage to getPeerCertificate
14 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
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
return SSL_TLSEXT_ERR_OK;
Initial openssl support for net2
15 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#endif
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::New(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (args.Length() < 1 || !args[0]->IsObject()) {
crypto: move `createCredentials` to tls Move `createCredentials` to `tls` module and rename it to `createSecureContext`. Make it use default values from `tls` module: `DEFAULT_CIPHERS` and `DEFAULT_ECDH_CURVE`. fix #7249
11 years ago
env->ThrowError("First argument must be a tls module SecureContext");
src: remove `node_isolate` from source fix #6899
11 years ago
return;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
tls: add client-side session resumption support
14 years ago
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
SecureContext* sc = Unwrap<SecureContext>(args[0]->ToObject(env->isolate()));
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
bool is_server = args[1]->BooleanValue();
tls: add client-side session resumption support
14 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
SSLWrap<Connection>::Kind kind =
is_server ? SSLWrap<Connection>::kServer : SSLWrap<Connection>::kClient;
src: remove ObjectWrap dependency from core Drop the ObjectWrap dependency in favor of an internal WeakObject class. Let&#39;s us stop worrying about API and ABI compatibility when making changes to the way node.js deals with weakly persistent handles internally.
11 years ago
Connection* conn = new Connection(env, args.This(), sc, kind);
crypto: remove NodeBIO::GetMethod() Remove NodeBIO::GetMethod() and replace calls to BIO_new() with calls to the new NodeBIO::New() function. This commit basically reshuffles some code in order to make it explicit that the NodeBIO BIO_METHOD is const.
11 years ago
conn->bio_read_ = NodeBIO::New();
conn->bio_write_ = NodeBIO::New();
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL_set_app_data(conn->ssl_, conn);
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
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (is_server)
SSL_set_info_callback(conn->ssl_, SSLInfoCallback);
tls: add client-side session resumption support
14 years ago
crypto: never store pointer to conn in SSL_CTX SSL_CTX is shared between multiple connections and is not a right place to store per-connection data. fix #8348 Reviewed-By: Trevor Norris
10 years ago
InitNPN(sc);
tls: add client-side session resumption support
14 years ago
tls: use `SSL_set_cert_cb` for async SNI/OCSP Do not enable ClientHello parser for async SNI/OCSP. Use new OpenSSL-1.0.2&#39;s API `SSL_set_cert_cb` to pause the handshake process and load the cert/OCSP response asynchronously. Hopefuly this will make whole async SNI/OCSP process much faster and will eventually let us remove the ClientHello parser itself (which is currently used only for async session, see #1462 for the discussion of removing it). NOTE: Ported our code to `SSL_CTX_add1_chain_cert` to use `SSL_CTX_get0_chain_certs` in `CertCbDone`. Test provided for this feature. Fix: https://github.com/iojs/io.js/issues/1423 PR-URL: https://github.com/iojs/io.js/pull/1464 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
SSL_set_cert_cb(conn->ssl_, SSLWrap<Connection>::SSLCertCallback, conn);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
if (is_server) {
SSL_CTX_set_tlsext_servername_callback(sc->ctx_, SelectSNIContextCallback_);
tls: do not default to &#39;localhost&#39; servername
11 years ago
} else if (args[2]->IsString()) {
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value servername(env->isolate(), args[2]);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL_set_tlsext_host_name(conn->ssl_, *servername);
tls: add client-side session resumption support
14 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#endif
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL_set_bio(conn->ssl_, conn->bio_read_, conn->bio_write_);
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
#ifdef SSL_MODE_RELEASE_BUFFERS
long mode = SSL_get_mode(conn->ssl_);
SSL_set_mode(conn->ssl_, mode | SSL_MODE_RELEASE_BUFFERS);
#endif
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 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;
cpplint: disallow if one-liners
11 years ago
if (reject_unauthorized)
verify_mode |= SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
} else {
// Note request_cert and reject_unauthorized are ignored for clients.
verify_mode = SSL_VERIFY_NONE;
}
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// Always allow a connection. We'll reject in javascript.
SSL_set_verify(conn->ssl_, verify_mode, VerifyCallback);
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (is_server) {
SSL_set_accept_state(conn->ssl_);
} else {
SSL_set_connect_state(conn->ssl_);
}
}
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::SSLInfoCallback(const SSL *ssl_, int where, int ret) {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
if (!(where & (SSL_CB_HANDSHAKE_START | SSL_CB_HANDSHAKE_DONE)))
return;
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
// 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_);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Connection* conn = static_cast<Connection*>(SSL_get_app_data(ssl));
Environment* env = conn->env();
HandleScope handle_scope(env->isolate());
src: fix Context::Scope usage env-&gt;context() may or may not create a new Local. It currently does not but don&#39;t depend on that behavior, create a HandleScope first.
11 years ago
Context::Scope context_scope(env->context());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (where & SSL_CB_HANDSHAKE_START) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
conn->MakeCallback(env->onhandshakestart_string(), 0, nullptr);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (where & SSL_CB_HANDSHAKE_DONE) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
conn->MakeCallback(env->onhandshakedone_string(), 0, nullptr);
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
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::EncIn(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Connection* conn = Unwrap<Connection>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = conn->env();
tls: async session storage
13 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (args.Length() < 3) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Takes 3 parameters");
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
if (!Buffer::HasInstance(args[0])) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Second argument should be a buffer");
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
char* buffer_data = Buffer::Data(args[0]);
size_t buffer_length = Buffer::Length(args[0]);
size_t off = args[1]->Int32Value();
size_t len = args[2]->Int32Value();
Lint node_crypto.cc
15 years ago
Merge remote-tracking branch &#39;upstream/v0.10&#39; Conflicts: deps/v8/src/preparser.cc deps/v8/src/win32-math.h doc/api/http.markdown src/node_buffer.h src/node_crypto.cc src/node_file.cc src/node_http_parser.cc
11 years ago
if (!Buffer::IsWithinBounds(off, len, buffer_length))
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("off + len > buffer.length");
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int bytes_written;
char* data = buffer_data + off;
tls: async session storage
13 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (conn->is_server() && !conn->hello_parser_.IsEnded()) {
// Just accumulate data, everything will be pushed to BIO later
if (conn->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(conn->hello_data_) - conn->hello_offset_;
size_t copied = len < available ? len : available;
memcpy(conn->hello_data_ + conn->hello_offset_, data, copied);
conn->hello_offset_ += copied;
tls: async session storage
13 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
conn->hello_parser_.Parse(conn->hello_data_, conn->hello_offset_);
bytes_written = copied;
tls: async session storage
13 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
} else {
bytes_written = BIO_write(conn->bio_read_, data, len);
conn->HandleBIOError(conn->bio_read_, "BIO_write", bytes_written);
conn->SetShutdownFlags();
tls: async session storage
13 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
args.GetReturnValue().Set(bytes_written);
tls: async session storage
13 years ago
}
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::ClearOut(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Connection* conn = Unwrap<Connection>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = conn->env();
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (args.Length() < 3) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Takes 3 parameters");
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
if (!Buffer::HasInstance(args[0])) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Second argument should be a buffer");
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
tls: add client-side session resumption support
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
char* buffer_data = Buffer::Data(args[0]);
size_t buffer_length = Buffer::Length(args[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
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
size_t off = args[1]->Int32Value();
size_t len = args[2]->Int32Value();
Support for signature verification with RSA/DSA public keys Fixes #1166.
14 years ago
Merge remote-tracking branch &#39;upstream/v0.10&#39; Conflicts: deps/v8/src/preparser.cc deps/v8/src/win32-math.h doc/api/http.markdown src/node_buffer.h src/node_crypto.cc src/node_file.cc src/node_http_parser.cc
11 years ago
if (!Buffer::IsWithinBounds(off, len, buffer_length))
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("off + len > buffer.length");
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: use consistent variable names Code cleanup: don&#39;t call a Connection object `p` in some places, `c` in other places and `ss` in yet other places. Let&#39;s just call it `conn`. This also fixes about a million style errors in one fell swoop.
12 years ago
if (!SSL_is_init_finished(conn->ssl_)) {
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int rv;
if (conn->is_server()) {
crypto: use consistent variable names Code cleanup: don&#39;t call a Connection object `p` in some places, `c` in other places and `ss` in yet other places. Let&#39;s just call it `conn`. This also fixes about a million style errors in one fell swoop.
12 years ago
rv = SSL_accept(conn->ssl_);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
conn->HandleSSLError("SSL_accept:ClearOut",
crypto: use consistent variable names Code cleanup: don&#39;t call a Connection object `p` in some places, `c` in other places and `ss` in yet other places. Let&#39;s just call it `conn`. This also fixes about a million style errors in one fell swoop.
12 years ago
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 {
crypto: use consistent variable names Code cleanup: don&#39;t call a Connection object `p` in some places, `c` in other places and `ss` in yet other places. Let&#39;s just call it `conn`. This also fixes about a million style errors in one fell swoop.
12 years ago
rv = SSL_connect(conn->ssl_);
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
conn->HandleSSLError("SSL_connect:ClearOut",
crypto: use consistent variable names Code cleanup: don&#39;t call a Connection object `p` in some places, `c` in other places and `ss` in yet other places. Let&#39;s just call it `conn`. This also fixes about a million style errors in one fell swoop.
12 years ago
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
}
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (rv < 0) {
return args.GetReturnValue().Set(rv);
}
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
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int bytes_read = SSL_read(conn->ssl_, buffer_data + off, len);
conn->HandleSSLError("SSL_read:ClearOut",
bytes_read,
kZeroIsNotAnError,
kSyscallError);
crypto: use consistent variable names Code cleanup: don&#39;t call a Connection object `p` in some places, `c` in other places and `ss` in yet other places. Let&#39;s just call it `conn`. This also fixes about a million style errors in one fell swoop.
12 years ago
conn->SetShutdownFlags();
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
args.GetReturnValue().Set(bytes_read);
Add receivedShutdown() binding
14 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::ClearPending(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Connection* conn = Unwrap<Connection>(args.Holder());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int bytes_pending = BIO_pending(conn->bio_read_);
args.GetReturnValue().Set(bytes_pending);
Initial openssl support for net2
15 years ago
}
Lint node_crypto.cc
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::EncPending(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Connection* conn = Unwrap<Connection>(args.Holder());
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int bytes_pending = BIO_pending(conn->bio_write_);
args.GetReturnValue().Set(bytes_pending);
Initial openssl support for net2
15 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::EncOut(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Connection* conn = Unwrap<Connection>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = conn->env();
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (args.Length() < 3) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Takes 3 parameters");
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
}
clients without certs are unauthed.
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (!Buffer::HasInstance(args[0])) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Second argument should be a buffer");
clients without certs are unauthed.
14 years ago
}
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
char* buffer_data = Buffer::Data(args[0]);
size_t buffer_length = Buffer::Length(args[0]);
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
size_t off = args[1]->Int32Value();
size_t len = args[2]->Int32Value();
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Merge remote-tracking branch &#39;upstream/v0.10&#39; Conflicts: deps/v8/src/preparser.cc deps/v8/src/win32-math.h doc/api/http.markdown src/node_buffer.h src/node_crypto.cc src/node_file.cc src/node_http_parser.cc
11 years ago
if (!Buffer::IsWithinBounds(off, len, buffer_length))
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("off + len > buffer.length");
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int bytes_read = BIO_read(conn->bio_write_, buffer_data + off, len);
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
conn->HandleBIOError(conn->bio_write_, "BIO_read:EncOut", bytes_read);
conn->SetShutdownFlags();
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
args.GetReturnValue().Set(bytes_read);
}
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::ClearIn(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Connection* conn = Unwrap<Connection>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = conn->env();
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (args.Length() < 3) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Takes 3 parameters");
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (!Buffer::HasInstance(args[0])) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Second argument should be a buffer");
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
}
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
char* buffer_data = Buffer::Data(args[0]);
size_t buffer_length = Buffer::Length(args[0]);
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
size_t off = args[1]->Int32Value();
size_t len = args[2]->Int32Value();
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
Merge remote-tracking branch &#39;upstream/v0.10&#39; Conflicts: deps/v8/src/preparser.cc deps/v8/src/win32-math.h doc/api/http.markdown src/node_buffer.h src/node_crypto.cc src/node_file.cc src/node_http_parser.cc
11 years ago
if (!Buffer::IsWithinBounds(off, len, buffer_length))
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("off + len > buffer.length");
Better verify info
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (!SSL_is_init_finished(conn->ssl_)) {
int rv;
if (conn->is_server()) {
rv = SSL_accept(conn->ssl_);
conn->HandleSSLError("SSL_accept:ClearIn",
rv,
kZeroIsAnError,
kSyscallError);
} else {
rv = SSL_connect(conn->ssl_);
conn->HandleSSLError("SSL_connect:ClearIn",
rv,
kZeroIsAnError,
kSyscallError);
}
Lint node_crypto.cc
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (rv < 0) {
return args.GetReturnValue().Set(rv);
}
}
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int bytes_written = SSL_write(conn->ssl_, buffer_data + off, len);
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
conn->HandleSSLError("SSL_write:ClearIn",
bytes_written,
len == 0 ? kZeroIsNotAnError : kZeroIsAnError,
kSyscallError);
conn->SetShutdownFlags();
crypto: use consistent variable names Code cleanup: don&#39;t call a Connection object `p` in some places, `c` in other places and `ss` in yet other places. Let&#39;s just call it `conn`. This also fixes about a million style errors in one fell swoop.
12 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
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
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::Start(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Connection* conn = Unwrap<Connection>(args.Holder());
Initial openssl support for net2
15 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
int rv = 0;
if (!SSL_is_init_finished(conn->ssl_)) {
if (conn->is_server()) {
rv = SSL_accept(conn->ssl_);
conn->HandleSSLError("SSL_accept:Start",
rv,
kZeroIsAnError,
kSyscallError);
} else {
rv = SSL_connect(conn->ssl_);
conn->HandleSSLError("SSL_connect:Start",
rv,
kZeroIsAnError,
kSyscallError);
}
Initial openssl support for net2
15 years ago
}
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
args.GetReturnValue().Set(rv);
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
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
void Connection::Close(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Connection* conn = Unwrap<Connection>(args.Holder());
OpenSSL NPN in node.js closes #926.
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (conn->ssl_ != nullptr) {
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
SSL_free(conn->ssl_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
conn->ssl_ = nullptr;
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
}
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
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Connection* conn = Unwrap<Connection>(args.Holder());
Add support for TLS SNI Fixes #1411
14 years ago
tls, crypto: deduplicate code Commit 03e008d introduced src/tls_wrap.cc and src/tls_wrap.h but said files copied on the order of 1 kLoC from src/node_crypto.cc and src/node_crypto.h. This commit undoes some of the duplication. Fixes #6024.
12 years ago
if (conn->is_server() && !conn->servername_.IsEmpty()) {
crypto: use consistent variable names Code cleanup: don&#39;t call a Connection object `p` in some places, `c` in other places and `ss` in yet other places. Let&#39;s just call it `conn`. This also fixes about a million style errors in one fell swoop.
12 years ago
args.GetReturnValue().Set(conn->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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Connection* conn = Unwrap<Connection>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = conn->env();
Add support for TLS SNI Fixes #1411
14 years ago
if (args.Length() < 1 || !args[0]->IsFunction()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Must give a Function as first argument");
Add support for TLS SNI Fixes #1411
14 years ago
}
src: update to v8 3.24 APIs
11 years ago
Local<Object> obj = Object::New(env->isolate());
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
obj->Set(FIXED_ONE_BYTE_STRING(args.GetIsolate(), "onselect"), args[0]);
conn->sniObject_.Reset(args.GetIsolate(), 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
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void CipherBase::Initialize(Environment* env, Handle<Object> target) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t = env->NewFunctionTemplate(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
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "init", Init);
env->SetProtoMethod(t, "initiv", InitIv);
env->SetProtoMethod(t, "update", Update);
env->SetProtoMethod(t, "final", Final);
env->SetProtoMethod(t, "setAutoPadding", SetAutoPadding);
env->SetProtoMethod(t, "getAuthTag", GetAuthTag);
env->SetProtoMethod(t, "setAuthTag", SetAuthTag);
env->SetProtoMethod(t, "setAAD", SetAAD);
Lint node_crypto.cc
15 years ago
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "CipherBase"),
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->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) {
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_EQ(args.IsConstructCall(), true);
src: remove ObjectWrap dependency from core Drop the ObjectWrap dependency in favor of an internal WeakObject class. Let&#39;s us stop worrying about API and ABI compatibility when making changes to the way node.js deals with weakly persistent handles internally.
11 years ago
CipherKind kind = args[0]->IsTrue() ? kCipher : kDecipher;
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
new CipherBase(env, args.This(), kind);
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
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: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(env()->isolate());
Lint node_crypto.cc
15 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_EQ(cipher_, nullptr);
crypto: merge Cipher and Decipher
12 years ago
cipher_ = EVP_get_cipherbyname(cipher_type);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (cipher_ == nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->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(),
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
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_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
const bool encrypt = (kind_ == kCipher);
EVP_CipherInit_ex(&ctx_, cipher_, nullptr, nullptr, nullptr, encrypt);
crypto: merge Cipher and Decipher
12 years ago
if (!EVP_CIPHER_CTX_set_key_length(&ctx_, key_len)) {
EVP_CIPHER_CTX_cleanup(&ctx_);
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->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_,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
nullptr,
crypto: merge Cipher and Decipher
12 years ago
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
CipherBase* cipher = Unwrap<CipherBase>(args.Holder());
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]))) {
src: remove `node_isolate` from source fix #6899
11 years ago
return cipher->env()->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: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value cipher_type(args.GetIsolate(), args[0]);
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 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: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(env()->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);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (cipher_ == nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->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)) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->ThrowError("Invalid IV length");
crypto: merge Cipher and Decipher
12 years ago
}
EVP_CIPHER_CTX_init(&ctx_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
const bool encrypt = (kind_ == kCipher);
EVP_CipherInit_ex(&ctx_, cipher_, nullptr, nullptr, nullptr, encrypt);
crypto: merge Cipher and Decipher
12 years ago
if (!EVP_CIPHER_CTX_set_key_length(&ctx_, key_len)) {
EVP_CIPHER_CTX_cleanup(&ctx_);
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->ThrowError("Invalid key length");
crypto: merge Cipher and Decipher
12 years ago
}
EVP_CipherInit_ex(&ctx_,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
nullptr,
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
CipherBase* cipher = Unwrap<CipherBase>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = cipher->env();
Lint node_crypto.cc
15 years ago
crypto: merge Cipher and Decipher
12 years ago
if (args.Length() < 3 || !args[0]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[1]);
THROW_AND_RETURN_IF_NOT_BUFFER(args[2]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value cipher_type(env->isolate(), 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
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
bool CipherBase::IsAuthenticatedMode() const {
// check if this cipher operates in an AEAD mode that we support.
if (!cipher_)
return false;
int mode = EVP_CIPHER_mode(cipher_);
return mode == EVP_CIPH_GCM_MODE;
}
bool CipherBase::GetAuthTag(char** out, unsigned int* out_len) const {
// only callable after Final and if encrypting.
if (initialised_ || kind_ != kCipher || !auth_tag_)
return false;
*out_len = auth_tag_len_;
*out = new char[auth_tag_len_];
memcpy(*out, auth_tag_, auth_tag_len_);
return true;
}
void CipherBase::GetAuthTag(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
CipherBase* cipher = Unwrap<CipherBase>(args.Holder());
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
char* out = nullptr;
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
unsigned int out_len = 0;
if (cipher->GetAuthTag(&out, &out_len)) {
Local<Object> buf = Buffer::Use(env, out, out_len);
args.GetReturnValue().Set(buf);
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowError("Attempting to get auth tag in unsupported state");
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
}
}
bool CipherBase::SetAuthTag(const char* data, unsigned int len) {
if (!initialised_ || !IsAuthenticatedMode() || kind_ != kDecipher)
return false;
delete[] auth_tag_;
auth_tag_len_ = len;
auth_tag_ = new char[len];
memcpy(auth_tag_, data, len);
return true;
}
void CipherBase::SetAuthTag(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
Local<Object> buf = args[0].As<Object>();
if (!buf->IsObject() || !Buffer::HasInstance(buf))
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Argument must be a Buffer");
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
CipherBase* cipher = Unwrap<CipherBase>(args.Holder());
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
if (!cipher->SetAuthTag(Buffer::Data(buf), Buffer::Length(buf)))
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowError("Attempting to set auth tag in unsupported state");
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
}
crypto: allow setting add&#39;l authenticated data
11 years ago
bool CipherBase::SetAAD(const char* data, unsigned int len) {
if (!initialised_ || !IsAuthenticatedMode())
return false;
int outlen;
if (!EVP_CipherUpdate(&ctx_,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
crypto: allow setting add&#39;l authenticated data
11 years ago
&outlen,
reinterpret_cast<const unsigned char*>(data),
len)) {
return false;
}
return true;
}
void CipherBase::SetAAD(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: allow setting add&#39;l authenticated data
11 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
crypto: allow setting add&#39;l authenticated data
11 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
CipherBase* cipher = Unwrap<CipherBase>(args.Holder());
crypto: allow setting add&#39;l authenticated data
11 years ago
if (!cipher->SetAAD(Buffer::Data(args[0]), Buffer::Length(args[0])))
env->ThrowError("Attempting to set AAD in unsupported state");
}
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) {
cpplint: disallow if one-liners
11 years ago
if (!initialised_)
return 0;
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
// on first update:
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (kind_ == kDecipher && IsAuthenticatedMode() && auth_tag_ != nullptr) {
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
EVP_CIPHER_CTX_ctrl(&ctx_,
EVP_CTRL_GCM_SET_TAG,
auth_tag_len_,
reinterpret_cast<unsigned char*>(auth_tag_));
delete[] auth_tag_;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
auth_tag_ = nullptr;
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
}
crypto: merge Cipher and Decipher
12 years ago
*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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
CipherBase* cipher = Unwrap<CipherBase>(args.Holder());
Lint node_crypto.cc
15 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_STRING_OR_BUFFER(args[0]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
unsigned char* out = nullptr;
crypto: merge Cipher and Decipher
12 years ago
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()) {
crypto: use on-stack storage in HashUpdate Boosts speed up to 10% on primitive `createHash().update().digest()` benchmark. PR-URL: https://github.com/iojs/io.js/pull/664 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
StringBytes::InlineDecoder decoder;
if (!decoder.Decode(env, args[0].As<String>(), args[1], BINARY))
return;
r = cipher->Update(decoder.out(), decoder.size(), &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
} 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: improve error messages 1) ThrowCryptoTypeErrors was not actually used for type-related errors. Removed it. 2) For AEAD modes, OpenSSL does not set any internal error information if Final does not complete suc- cessfully. Therefore, &#34;TypeError:error:00000000:l ib(0):func(0):reason(0)&#34; would be the error mess- age. Use a default message for these cases. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
return ThrowCryptoError(env,
ERR_get_error(),
"Trying to add data in unsupported state");
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
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Object> buf = Buffer::New(env, reinterpret_cast<char*>(out), out_len);
cpplint: disallow if one-liners
11 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) {
cpplint: disallow if one-liners
11 years ago
if (!initialised_)
return false;
crypto: merge Cipher and Decipher
12 years ago
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
CipherBase* cipher = Unwrap<CipherBase>(args.Holder());
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) {
cpplint: disallow if one-liners
11 years ago
if (!initialised_)
return false;
crypto: merge Cipher and Decipher
12 years ago
*out = new unsigned char[EVP_CIPHER_CTX_block_size(&ctx_)];
crypto: fix CipherFinal return value check
11 years ago
int r = EVP_CipherFinal_ex(&ctx_, *out, out_len);
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
if (r && kind_ == kCipher) {
delete[] auth_tag_;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
auth_tag_ = nullptr;
crypto: support GCM authenticated encryption mode. This adds two new member functions getAuthTag and setAuthTag that are useful for AES-GCM encryption modes. Use getAuthTag after Cipheriv.final, transmit the tag along with the data and use Decipheriv.setAuthTag to have the encrypted data verified.
11 years ago
if (IsAuthenticatedMode()) {
auth_tag_len_ = EVP_GCM_TLS_TAG_LEN; // use default tag length
auth_tag_ = new char[auth_tag_len_];
memset(auth_tag_, 0, auth_tag_len_);
EVP_CIPHER_CTX_ctrl(&ctx_,
EVP_CTRL_GCM_GET_TAG,
auth_tag_len_,
reinterpret_cast<unsigned char*>(auth_tag_));
}
}
crypto: merge Cipher and Decipher
12 years ago
EVP_CIPHER_CTX_cleanup(&ctx_);
initialised_ = false;
crypto: fix CipherFinal return value check
11 years ago
return r == 1;
crypto: merge Cipher and Decipher
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 CipherBase::Final(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
CipherBase* cipher = Unwrap<CipherBase>(args.Holder());
Lint node_crypto.cc
15 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
unsigned char* out_value = nullptr;
crypto: split crypto classes
12 years ago
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;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
out_value = nullptr;
crypto: merge Cipher and Decipher
12 years ago
out_len = 0;
crypto: improve error messages 1) ThrowCryptoTypeErrors was not actually used for type-related errors. Removed it. 2) For AEAD modes, OpenSSL does not set any internal error information if Final does not complete suc- cessfully. Therefore, &#34;TypeError:error:00000000:l ib(0):func(0):reason(0)&#34; would be the error mess- age. Use a default message for these cases. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
if (!r) {
const char* msg = cipher->IsAuthenticatedMode() ?
"Unsupported state or unable to authenticate data" :
"Unsupported state";
return ThrowCryptoError(env,
ERR_get_error(),
msg);
}
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(
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Buffer::New(env, reinterpret_cast<char*>(out_value), out_len));
crypto: fix memory leak in CipherBase::Final fix #7497 Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
delete[] out_value;
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void Hmac::Initialize(Environment* env, v8::Handle<v8::Object> target) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t = env->NewFunctionTemplate(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
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "init", HmacInit);
env->SetProtoMethod(t, "update", HmacUpdate);
env->SetProtoMethod(t, "digest", HmacDigest);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
new Hmac(env, 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: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(env()->isolate());
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_EQ(md_, nullptr);
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);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (md_ == nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->ThrowError("Unknown message digest");
crypto: refactor crypto classes
12 years ago
}
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Hmac* hmac = Unwrap<Hmac>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = hmac->env();
crypto: refactor crypto classes
12 years ago
if (args.Length() < 2 || !args[0]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[1]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value hash_type(env->isolate(), args[0]);
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* 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) {
cpplint: disallow if one-liners
11 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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Hmac* hmac = Unwrap<Hmac>(args.Holder());
crypto: refactor crypto classes
12 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_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()) {
crypto: use on-stack storage in HashUpdate Boosts speed up to 10% on primitive `createHash().update().digest()` benchmark. PR-URL: https://github.com/iojs/io.js/pull/664 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
StringBytes::InlineDecoder decoder;
if (!decoder.Decode(env, args[0].As<String>(), args[1], BINARY))
return;
r = hmac->HmacUpdate(decoder.out(), decoder.size());
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
} 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) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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) {
cpplint: disallow if one-liners
11 years ago
if (!initialised_)
return false;
crypto: refactor crypto classes
12 years ago
*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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Hmac* hmac = Unwrap<Hmac>(args.Holder());
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
enum encoding encoding = BUFFER;
if (args.Length() >= 1) {
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
encoding = ParseEncoding(env->isolate(),
args[0]->ToString(env->isolate()),
BUFFER);
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
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
unsigned char* md_value = nullptr;
crypto: split crypto classes
12 years ago
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) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
md_value = nullptr;
crypto: split crypto classes
12 years ago
md_len = 0;
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> rc = StringBytes::Encode(env->isolate(),
reinterpret_cast<const char*>(md_value),
md_len,
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
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
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void Hash::Initialize(Environment* env, v8::Handle<v8::Object> target) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t = env->NewFunctionTemplate(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
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "update", HashUpdate);
env->SetProtoMethod(t, "digest", HashDigest);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
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()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Must give hashtype string as argument");
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value hash_type(env->isolate(), args[0]);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
Hash* hash = new Hash(env, args.This());
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)) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Digest method not supported");
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
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) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_EQ(md_, nullptr);
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);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (md_ == nullptr)
cpplint: disallow if one-liners
11 years ago
return false;
crypto: refactor crypto classes
12 years ago
EVP_MD_CTX_init(&mdctx_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
EVP_DigestInit_ex(&mdctx_, md_, nullptr);
crypto: refactor crypto classes
12 years ago
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) {
cpplint: disallow if one-liners
11 years ago
if (!initialised_)
return false;
crypto: refactor crypto classes
12 years ago
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: split crypto classes
12 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Hash* hash = Unwrap<Hash>(args.Holder());
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_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()) {
crypto: use on-stack storage in HashUpdate Boosts speed up to 10% on primitive `createHash().update().digest()` benchmark. PR-URL: https://github.com/iojs/io.js/pull/664 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
StringBytes::InlineDecoder decoder;
if (!decoder.Decode(env, args[0].As<String>(), args[1], BINARY))
return;
r = hash->HashUpdate(decoder.out(), decoder.size());
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
} 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) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: split crypto classes
12 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Hash* hash = Unwrap<Hash>(args.Holder());
crypto: split crypto classes
12 years ago
if (!hash->initialised_) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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) {
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
encoding = ParseEncoding(env->isolate(),
args[0]->ToString(env->isolate()),
BUFFER);
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
}
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
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> rc = StringBytes::Encode(env->isolate(),
reinterpret_cast<const char*>(md_value),
md_len,
encoding);
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: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
void SignBase::CheckThrow(SignBase::Error error) {
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(env()->isolate());
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
switch (error) {
case kSignUnknownDigest:
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->ThrowError("Unknown message digest");
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
case kSignNotInitialised:
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->ThrowError("Not initialised");
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
case kSignInit:
case kSignUpdate:
case kSignPrivateKey:
case kSignPublicKey:
{
unsigned long err = ERR_get_error();
if (err)
src: remove `node_isolate` from source fix #6899
11 years ago
return ThrowCryptoError(env(), err);
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
switch (error) {
case kSignInit:
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->ThrowError("EVP_SignInit_ex failed");
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
case kSignUpdate:
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->ThrowError("EVP_SignUpdate failed");
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
case kSignPrivateKey:
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->ThrowError("PEM_read_bio_PrivateKey failed");
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
case kSignPublicKey:
src: remove `node_isolate` from source fix #6899
11 years ago
return env()->ThrowError("PEM_read_bio_PUBKEY failed");
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
default:
abort();
}
}
case kSignOk:
return;
}
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void Sign::Initialize(Environment* env, v8::Handle<v8::Object> target) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
crypto: split crypto classes
12 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "init", SignInit);
env->SetProtoMethod(t, "update", SignUpdate);
env->SetProtoMethod(t, "sign", SignFinal);
crypto: split crypto classes
12 years ago
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
new Sign(env, 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
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
SignBase::Error Sign::SignInit(const char* sign_type) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_EQ(md_, nullptr);
crypto: refactor crypto classes
12 years ago
md_ = EVP_get_digestbyname(sign_type);
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
if (!md_)
return kSignUnknownDigest;
crypto: refactor crypto classes
12 years ago
EVP_MD_CTX_init(&mdctx_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (!EVP_SignInit_ex(&mdctx_, md_, nullptr))
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
return kSignInit;
crypto: refactor crypto classes
12 years ago
initialised_ = true;
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
return kSignOk;
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Sign* sign = Unwrap<Sign>(args.Holder());
Fix a few compiler warnings...
14 years ago
crypto: split crypto classes
12 years ago
if (args.Length() == 0 || !args[0]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return sign->env()->ThrowError("Must give signtype string as argument");
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value sign_type(args.GetIsolate(), args[0]);
src: remove `node_isolate` from source fix #6899
11 years ago
sign->CheckThrow(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
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
SignBase::Error Sign::SignUpdate(const char* data, int len) {
cpplint: disallow if one-liners
11 years ago
if (!initialised_)
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
return kSignNotInitialised;
if (!EVP_SignUpdate(&mdctx_, data, len))
return kSignUpdate;
return kSignOk;
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Sign* sign = Unwrap<Sign>(args.Holder());
crypto: refactor crypto classes
12 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_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: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
Error err;
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()) {
crypto: use on-stack storage in HashUpdate Boosts speed up to 10% on primitive `createHash().update().digest()` benchmark. PR-URL: https://github.com/iojs/io.js/pull/664 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
StringBytes::InlineDecoder decoder;
if (!decoder.Decode(env, args[0].As<String>(), args[1], BINARY))
return;
err = sign->SignUpdate(decoder.out(), decoder.size());
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
} else {
char* buf = Buffer::Data(args[0]);
size_t buflen = Buffer::Length(args[0]);
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
err = sign->SignUpdate(buf, buflen);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
sign->CheckThrow(err);
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
SignBase::Error Sign::SignFinal(const char* key_pem,
int key_pem_len,
const char* passphrase,
unsigned char** sig,
unsigned int *sig_len) {
if (!initialised_)
return kSignNotInitialised;
crypto: refactor crypto classes
12 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
BIO* bp = nullptr;
EVP_PKEY* pkey = nullptr;
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
bool fatal = true;
crypto: use less memory for storing keys Use `BIO_new_mem_buf` where possible to reduce memory usage and initialization costs.
10 years ago
bp = BIO_new_mem_buf(const_cast<char*>(key_pem), key_pem_len);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (bp == nullptr)
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
goto exit;
pkey = PEM_read_bio_PrivateKey(bp,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
CryptoPemCallback,
const_cast<char*>(passphrase));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey == nullptr)
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
goto exit;
if (EVP_SignFinal(&mdctx_, *sig, sig_len, pkey))
fatal = false;
crypto: refactor crypto classes
12 years ago
initialised_ = false;
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
exit:
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey != nullptr)
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
EVP_PKEY_free(pkey);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (bp != nullptr)
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
BIO_free_all(bp);
EVP_MD_CTX_cleanup(&mdctx_);
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
if (fatal)
return kSignPrivateKey;
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
return kSignOk;
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 Sign::SignFinal(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Sign* sign = Unwrap<Sign>(args.Holder());
crypto: refactor crypto classes
12 years ago
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
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
unsigned int len = args.Length();
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;
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
if (len >= 2 && args[1]->IsString()) {
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
encoding = ParseEncoding(env->isolate(),
args[1]->ToString(env->isolate()),
BUFFER);
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
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value passphrase(env->isolate(), args[2]);
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
src: accept passphrase when crypto signing with private key Previous behaviour was to drop to an openssl prompt (&#34;Enter PEM pass phrase:&#34;) when supplying a private key with a passphrase. This change adds a fourth, optional, paramter that will be used as the passphrase. To include this parameter in a backwards compatible way it was necessary to expose the previously undocumented (and unexposed) feature of being able to explitly setting the output encoding.
11 years ago
size_t buf_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: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
Error err = sign->SignFinal(
buf,
buf_len,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
len >= 3 && !args[2]->IsNull() ? *passphrase : nullptr,
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
&md_value,
&md_len);
if (err != kSignOk) {
crypto: refactor crypto classes
12 years ago
delete[] md_value;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
md_value = nullptr;
crypto: refactor crypto classes
12 years ago
md_len = 0;
src: remove `node_isolate` from source fix #6899
11 years ago
return sign->CheckThrow(err);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> rc = StringBytes::Encode(env->isolate(),
reinterpret_cast<const char*>(md_value),
md_len,
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
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
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void Verify::Initialize(Environment* env, v8::Handle<v8::Object> target) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
crypto: split crypto classes
12 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "init", VerifyInit);
env->SetProtoMethod(t, "update", VerifyUpdate);
env->SetProtoMethod(t, "verify", VerifyFinal);
crypto: split crypto classes
12 years ago
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
new Verify(env, 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
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
SignBase::Error Verify::VerifyInit(const char* verify_type) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_EQ(md_, nullptr);
crypto: refactor crypto classes
12 years ago
md_ = EVP_get_digestbyname(verify_type);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (md_ == nullptr)
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
return kSignUnknownDigest;
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_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (!EVP_VerifyInit_ex(&mdctx_, md_, nullptr))
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
return kSignInit;
crypto: refactor crypto classes
12 years ago
initialised_ = true;
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
return kSignOk;
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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Verify* verify = Unwrap<Verify>(args.Holder());
crypto: refactor crypto classes
12 years ago
crypto: split crypto classes
12 years ago
if (args.Length() == 0 || !args[0]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return verify->env()->ThrowError("Must give verifytype string as argument");
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value verify_type(args.GetIsolate(), args[0]);
src: remove `node_isolate` from source fix #6899
11 years ago
verify->CheckThrow(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
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
SignBase::Error Verify::VerifyUpdate(const char* data, int len) {
cpplint: disallow if one-liners
11 years ago
if (!initialised_)
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
return kSignNotInitialised;
if (!EVP_VerifyUpdate(&mdctx_, data, len))
return kSignUpdate;
return kSignOk;
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Verify* verify = Unwrap<Verify>(args.Holder());
Fix a few compiler warnings...
14 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_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: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
Error err;
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()) {
crypto: use on-stack storage in HashUpdate Boosts speed up to 10% on primitive `createHash().update().digest()` benchmark. PR-URL: https://github.com/iojs/io.js/pull/664 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
StringBytes::InlineDecoder decoder;
if (!decoder.Decode(env, args[0].As<String>(), args[1], BINARY))
return;
err = verify->VerifyUpdate(decoder.out(), decoder.size());
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
} else {
char* buf = Buffer::Data(args[0]);
size_t buflen = Buffer::Length(args[0]);
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
err = 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
src: remove `node_isolate` from source fix #6899
11 years ago
verify->CheckThrow(err);
crypto: split crypto classes
12 years ago
}
Fix a few compiler warnings...
14 years ago
fast buffers for crypto
15 years ago
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
SignBase::Error Verify::VerifyFinal(const char* key_pem,
int key_pem_len,
const char* sig,
int siglen,
bool* verify_result) {
if (!initialised_)
return kSignNotInitialised;
crypto: split crypto classes
12 years ago
Merge remote-tracking branch &#39;upstream/v0.10&#39; Conflicts: ChangeLog deps/uv/ChangeLog deps/uv/include/uv-darwin.h deps/uv/src/unix/fsevents.c deps/uv/src/unix/process.c deps/uv/src/version.c doc/api/addons.markdown doc/api/cluster.markdown doc/api/http.markdown lib/http.js lib/tls.js src/node_crypto.cc src/node_http_parser.cc src/node_version.h src/pipe_wrap.cc src/v8abbr.h src/v8ustack.d test/simple/test-http-pipeline-flood.js
11 years ago
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence compiler warning.
Fix a bunch of memory leaks in node_crypto
15 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
EVP_PKEY* pkey = nullptr;
BIO* bp = nullptr;
X509* x509 = nullptr;
crypto: refactor crypto classes
12 years ago
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: use less memory for storing keys Use `BIO_new_mem_buf` where possible to reduce memory usage and initialization costs.
10 years ago
bp = BIO_new_mem_buf(const_cast<char*>(key_pem), key_pem_len);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (bp == nullptr)
crypto: refactor crypto classes
12 years ago
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) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
pkey = PEM_read_bio_PUBKEY(bp, nullptr, CryptoPemCallback, nullptr);
if (pkey == nullptr)
crypto: refactor crypto classes
12 years ago
goto exit;
} else if (strncmp(key_pem, PUBRSA_KEY_PFX, PUBRSA_KEY_PFX_LEN) == 0) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
RSA* rsa =
PEM_read_bio_RSAPublicKey(bp, nullptr, CryptoPemCallback, nullptr);
crypto: refactor crypto classes
12 years ago
if (rsa) {
pkey = EVP_PKEY_new();
cpplint: disallow if one-liners
11 years ago
if (pkey)
EVP_PKEY_set1_RSA(pkey, rsa);
crypto: refactor crypto classes
12 years ago
RSA_free(rsa);
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey == nullptr)
crypto: refactor crypto classes
12 years ago
goto exit;
} else {
// X.509 fallback
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
x509 = PEM_read_bio_X509(bp, nullptr, CryptoPemCallback, nullptr);
if (x509 == nullptr)
crypto: refactor crypto classes
12 years ago
goto exit;
pkey = X509_get_pubkey(x509);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey == nullptr)
crypto: refactor crypto classes
12 years ago
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:
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey != nullptr)
crypto: refactor crypto classes
12 years ago
EVP_PKEY_free(pkey);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (bp != nullptr)
crypto: refactor crypto classes
12 years ago
BIO_free_all(bp);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (x509 != nullptr)
crypto: refactor crypto classes
12 years ago
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;
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
if (fatal)
return kSignPublicKey;
Lint node_crypto.cc
15 years ago
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
*verify_result = r == 1;
return kSignOk;
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Verify* verify = Unwrap<Verify>(args.Holder());
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
crypto: refactor crypto classes
12 years ago
char* kbuf = Buffer::Data(args[0]);
ssize_t klen = Buffer::Length(args[0]);
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_STRING_OR_BUFFER(args[1]);
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
// BINARY works for both buffers and binary strings.
enum encoding encoding = BINARY;
if (args.Length() >= 3) {
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
encoding = ParseEncoding(env->isolate(),
args[2]->ToString(env->isolate()),
BINARY);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
}
crypto: refactor crypto classes
12 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
ssize_t hlen = StringBytes::Size(env->isolate(), 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];
src: remove `node_isolate` from source fix #6899
11 years ago
ssize_t hwritten = StringBytes::Write(env->isolate(),
hbuf,
hlen,
args[1],
encoding);
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_EQ(hwritten, 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
} 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
}
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
bool verify_result;
Error err = verify->VerifyFinal(kbuf, klen, hbuf, hlen, &verify_result);
if (args[1]->IsString())
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
delete[] hbuf;
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
if (err != kSignOk)
src: remove `node_isolate` from source fix #6899
11 years ago
return verify->CheckThrow(err);
crypto: throw only in direct C++ methods Do not throw in internal C++ methods, that clobbers logic and may lead to the situations, where both exception was thrown and the value was returned (via `args.GetReturnValue().Set()`). That doesn&#39;t play nicely with v8. fix #6912
11 years ago
args.GetReturnValue().Set(verify_result);
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: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
template <PublicKeyCipher::Operation operation,
PublicKeyCipher::EVP_PKEY_cipher_init_t EVP_PKEY_cipher_init,
PublicKeyCipher::EVP_PKEY_cipher_t EVP_PKEY_cipher>
bool PublicKeyCipher::Cipher(const char* key_pem,
int key_pem_len,
const char* passphrase,
crypto: allow padding in RSA methods Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt;
11 years ago
int padding,
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
const unsigned char* data,
int len,
unsigned char** out,
size_t* out_len) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
EVP_PKEY* pkey = nullptr;
EVP_PKEY_CTX* ctx = nullptr;
BIO* bp = nullptr;
X509* x509 = nullptr;
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
bool fatal = true;
crypto: use less memory for storing keys Use `BIO_new_mem_buf` where possible to reduce memory usage and initialization costs.
10 years ago
bp = BIO_new_mem_buf(const_cast<char*>(key_pem), key_pem_len);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (bp == nullptr)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
goto exit;
// Check if this is a PKCS#8 or RSA public key before trying as X.509 and
// private key.
crypto: implement privateEncrypt/publicDecrypt PR-URL: https://github.com/iojs/io.js/pull/625 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Fix iojs/io.js#477
10 years ago
if (operation == kPublic &&
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
strncmp(key_pem, PUBLIC_KEY_PFX, PUBLIC_KEY_PFX_LEN) == 0) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
pkey = PEM_read_bio_PUBKEY(bp, nullptr, nullptr, nullptr);
if (pkey == nullptr)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
goto exit;
crypto: implement privateEncrypt/publicDecrypt PR-URL: https://github.com/iojs/io.js/pull/625 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Fix iojs/io.js#477
10 years ago
} else if (operation == kPublic &&
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
strncmp(key_pem, PUBRSA_KEY_PFX, PUBRSA_KEY_PFX_LEN) == 0) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
RSA* rsa = PEM_read_bio_RSAPublicKey(bp, nullptr, nullptr, nullptr);
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
if (rsa) {
pkey = EVP_PKEY_new();
if (pkey)
EVP_PKEY_set1_RSA(pkey, rsa);
RSA_free(rsa);
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey == nullptr)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
goto exit;
crypto: implement privateEncrypt/publicDecrypt PR-URL: https://github.com/iojs/io.js/pull/625 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Fix iojs/io.js#477
10 years ago
} else if (operation == kPublic &&
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
strncmp(key_pem, CERTIFICATE_PFX, CERTIFICATE_PFX_LEN) == 0) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
x509 = PEM_read_bio_X509(bp, nullptr, CryptoPemCallback, nullptr);
if (x509 == nullptr)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
goto exit;
pkey = X509_get_pubkey(x509);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey == nullptr)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
goto exit;
} else {
pkey = PEM_read_bio_PrivateKey(bp,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
CryptoPemCallback,
const_cast<char*>(passphrase));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey == nullptr)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
goto exit;
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
ctx = EVP_PKEY_CTX_new(pkey, nullptr);
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
if (!ctx)
goto exit;
if (EVP_PKEY_cipher_init(ctx) <= 0)
goto exit;
crypto: allow padding in RSA methods Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt;
11 years ago
if (EVP_PKEY_CTX_set_rsa_padding(ctx, padding) <= 0)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
goto exit;
crypto: allow padding in RSA methods Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt;
11 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (EVP_PKEY_cipher(ctx, nullptr, out_len, data, len) <= 0)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
goto exit;
*out = new unsigned char[*out_len];
if (EVP_PKEY_cipher(ctx, *out, out_len, data, len) <= 0)
goto exit;
fatal = false;
exit:
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey != nullptr)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
EVP_PKEY_free(pkey);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (bp != nullptr)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
BIO_free_all(bp);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (ctx != nullptr)
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
EVP_PKEY_CTX_free(ctx);
return !fatal;
}
template <PublicKeyCipher::Operation operation,
PublicKeyCipher::EVP_PKEY_cipher_init_t EVP_PKEY_cipher_init,
PublicKeyCipher::EVP_PKEY_cipher_t EVP_PKEY_cipher>
void PublicKeyCipher::Cipher(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
char* kbuf = Buffer::Data(args[0]);
ssize_t klen = Buffer::Length(args[0]);
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[1]);
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
char* buf = Buffer::Data(args[1]);
ssize_t len = Buffer::Length(args[1]);
crypto: allow padding in RSA methods Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt;
11 years ago
int padding = args[2]->Uint32Value();
String::Utf8Value passphrase(args[3]);
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
unsigned char* out_value = nullptr;
crypto: unsigned value can&#39;t be negative Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
size_t out_len = 0;
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
bool r = Cipher<operation, EVP_PKEY_cipher_init, EVP_PKEY_cipher>(
kbuf,
klen,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
args.Length() >= 3 && !args[2]->IsNull() ? *passphrase : nullptr,
crypto: allow padding in RSA methods Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt;
11 years ago
padding,
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
reinterpret_cast<const unsigned char*>(buf),
len,
&out_value,
&out_len);
crypto: unsigned value can&#39;t be negative Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
if (out_len == 0 || !r) {
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
delete[] out_value;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
out_value = nullptr;
crypto: add RSA encryption Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
out_len = 0;
if (!r) {
return ThrowCryptoError(env,
ERR_get_error());
}
}
args.GetReturnValue().Set(
Buffer::New(env, reinterpret_cast<char*>(out_value), out_len));
delete[] out_value;
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void DiffieHellman::Initialize(Environment* env, Handle<Object> target) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: turn two global vars into local vars Bring us a little closer to multi-isolate readiness by removing two global variables. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; PR-URL: https://github.com/node-forward/node/pull/58
10 years ago
const PropertyAttribute attributes =
crypto: allow custom generator for DiffieHellman
11 years ago
static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
crypto: split crypto classes
12 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
Fix a bunch of memory leaks in node_crypto
15 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "generateKeys", GenerateKeys);
env->SetProtoMethod(t, "computeSecret", ComputeSecret);
env->SetProtoMethod(t, "getPrime", GetPrime);
env->SetProtoMethod(t, "getGenerator", GetGenerator);
env->SetProtoMethod(t, "getPublicKey", GetPublicKey);
env->SetProtoMethod(t, "getPrivateKey", GetPrivateKey);
env->SetProtoMethod(t, "setPublicKey", SetPublicKey);
env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: allow custom generator for DiffieHellman
11 years ago
t->InstanceTemplate()->SetAccessor(env->verify_error_string(),
DiffieHellman::VerifyErrorGetter,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
src: make accessors immune to context confusion It&#39;s possible for an accessor or named interceptor to get called with a different execution context than the one it lives in, see the test case for an example using the debug API. This commit fortifies against that by passing the environment as a data property instead of looking it up through the current context. Fixes: https://github.com/iojs/io.js/issues/1190 (again) PR-URL: https://github.com/iojs/io.js/pull/1238 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->as_external(),
DEFAULT,
crypto: allow custom generator for DiffieHellman
11 years ago
attributes);
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellman"),
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->GetFunction());
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t2 = env->NewFunctionTemplate(DiffieHellmanGroup);
crypto: split crypto classes
12 years ago
t2->InstanceTemplate()->SetInternalFieldCount(1);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t2, "generateKeys", GenerateKeys);
env->SetProtoMethod(t2, "computeSecret", ComputeSecret);
env->SetProtoMethod(t2, "getPrime", GetPrime);
env->SetProtoMethod(t2, "getGenerator", GetGenerator);
env->SetProtoMethod(t2, "getPublicKey", GetPublicKey);
env->SetProtoMethod(t2, "getPrivateKey", GetPrivateKey);
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: allow custom generator for DiffieHellman
11 years ago
t2->InstanceTemplate()->SetAccessor(env->verify_error_string(),
DiffieHellman::VerifyErrorGetter,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
src: make accessors immune to context confusion It&#39;s possible for an accessor or named interceptor to get called with a different execution context than the one it lives in, see the test case for an example using the debug API. This commit fortifies against that by passing the environment as a data property instead of looking it up through the current context. Fixes: https://github.com/iojs/io.js/issues/1190 (again) PR-URL: https://github.com/iojs/io.js/pull/1238 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->as_external(),
DEFAULT,
crypto: allow custom generator for DiffieHellman
11 years ago
attributes);
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellmanGroup"),
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
t2->GetFunction());
crypto: split crypto classes
12 years ago
}
Moved Credentials into crypto module. Added node_crypto into crypto module
15 years ago
crypto: allow custom generator for DiffieHellman
11 years ago
bool DiffieHellman::Init(int primeLength, int g) {
crypto: split crypto classes
12 years ago
dh = DH_new();
crypto: allow custom generator for DiffieHellman
11 years ago
DH_generate_parameters_ex(dh, primeLength, g, 0);
crypto: split crypto classes
12 years ago
bool result = VerifyContext();
cpplint: disallow if one-liners
11 years ago
if (!result)
return false;
crypto: split crypto classes
12 years ago
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
crypto: allow custom generator for DiffieHellman
11 years ago
bool DiffieHellman::Init(const char* p, int p_len, int g) {
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();
crypto: allow custom generator for DiffieHellman
11 years ago
if (!BN_set_word(dh->g, g))
cpplint: disallow if one-liners
11 years ago
return false;
crypto: split crypto classes
12 years ago
bool result = VerifyContext();
cpplint: disallow if one-liners
11 years ago
if (!result)
return false;
crypto: split crypto classes
12 years ago
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: allow custom generator for DiffieHellman
11 years ago
bool result = VerifyContext();
if (!result)
return false;
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
DiffieHellman* diffieHellman = new DiffieHellman(env, args.This());
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()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("No group name given");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
crypto: allow custom generator for DiffieHellman
11 years ago
bool initialized = false;
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value group_name(env->isolate(), 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: allow custom generator for DiffieHellman
11 years ago
initialized = diffieHellman->Init(it->prime,
it->prime_size,
it->gen,
it->gen_size);
if (!initialized)
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowError("Initialization failed");
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
return;
crypto: split crypto classes
12 years ago
}
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
env->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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
src: remove ObjectWrap dependency from core Drop the ObjectWrap dependency in favor of an internal WeakObject class. Let&#39;s us stop worrying about API and ABI compatibility when making changes to the way node.js deals with weakly persistent handles internally.
11 years ago
DiffieHellman* diffieHellman =
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
new DiffieHellman(env, args.This());
crypto: split crypto classes
12 years ago
bool initialized = false;
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
crypto: allow custom generator for DiffieHellman
11 years ago
if (args.Length() == 2) {
crypto: split crypto classes
12 years ago
if (args[0]->IsInt32()) {
crypto: allow custom generator for DiffieHellman
11 years ago
if (args[1]->IsInt32()) {
initialized = diffieHellman->Init(args[0]->Int32Value(),
args[1]->Int32Value());
}
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
} else {
crypto: allow custom generator for DiffieHellman
11 years ago
if (args[1]->IsInt32()) {
initialized = diffieHellman->Init(Buffer::Data(args[0]),
Buffer::Length(args[0]),
args[1]->Int32Value());
} else {
initialized = diffieHellman->Init(Buffer::Data(args[0]),
Buffer::Length(args[0]),
Buffer::Data(args[1]),
Buffer::Length(args[1]));
}
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) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Initialization failed");
crypto: add function getDiffieHellman() Returns a well known, predefined RFC group.
13 years ago
}
crypto: split crypto classes
12 years ago
}
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
DiffieHellman* diffieHellman = Unwrap<DiffieHellman>(args.Holder());
crypto: refactor crypto classes
12 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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)) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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
src: remove `node_isolate` from source fix #6899
11 years ago
args.GetReturnValue().Set(Encode(env->isolate(), 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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
DiffieHellman* diffieHellman = Unwrap<DiffieHellman>(args.Holder());
crypto: refactor crypto classes
12 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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
src: remove `node_isolate` from source fix #6899
11 years ago
args.GetReturnValue().Set(Encode(env->isolate(), 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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: split crypto classes
12 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
DiffieHellman* diffieHellman = Unwrap<DiffieHellman>(args.Holder());
crypto: refactor crypto classes
12 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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
src: remove `node_isolate` from source fix #6899
11 years ago
args.GetReturnValue().Set(Encode(env->isolate(), 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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
DiffieHellman* diffieHellman = Unwrap<DiffieHellman>(args.Holder());
crypto: refactor crypto classes
12 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Not initialized");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (diffieHellman->dh->pub_key == nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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
src: remove `node_isolate` from source fix #6899
11 years ago
args.GetReturnValue().Set(Encode(env->isolate(), 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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
DiffieHellman* diffieHellman = Unwrap<DiffieHellman>(args.Holder());
crypto: refactor crypto classes
12 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Not initialized");
crypto: split crypto classes
12 years ago
}
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (diffieHellman->dh->priv_key == nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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
src: remove `node_isolate` from source fix #6899
11 years ago
args.GetReturnValue().Set(Encode(env->isolate(), 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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
DiffieHellman* diffieHellman = Unwrap<DiffieHellman>(args.Holder());
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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.
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
BIGNUM* key = nullptr;
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
if (args.Length() == 0) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("First argument must be other party's public key");
crypto: split crypto classes
12 years ago
} else {
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
crypto: split crypto classes
12 years ago
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) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Invalid key");
crypto: split crypto classes
12 years ago
} else if (checkResult) {
if (checkResult & DH_CHECK_PUBKEY_TOO_SMALL) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Supplied key is too small");
crypto: split crypto classes
12 years ago
} else if (checkResult & DH_CHECK_PUBKEY_TOO_LARGE) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Supplied key is too large");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Invalid key");
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
}
crypto: split crypto classes
12 years ago
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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);
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_GE(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) {
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK(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
src: remove `node_isolate` from source fix #6899
11 years ago
args.GetReturnValue().Set(Encode(env->isolate(), 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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
DiffieHellman* diffieHellman = Unwrap<DiffieHellman>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = diffieHellman->env();
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("First argument must be public key");
crypto: split crypto classes
12 years ago
} else {
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_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) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
DiffieHellman* diffieHellman = Unwrap<DiffieHellman>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = diffieHellman->env();
Add Diffie-Hellman support to crypto module Fixes #573
14 years ago
crypto: split crypto classes
12 years ago
if (!diffieHellman->initialised_) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("First argument must be private key");
crypto: split crypto classes
12 years ago
} else {
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_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
crypto: allow custom generator for DiffieHellman
11 years ago
void DiffieHellman::VerifyErrorGetter(Local<String> property,
const PropertyCallbackInfo<Value>& args) {
HandleScope scope(args.GetIsolate());
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
DiffieHellman* diffieHellman = Unwrap<DiffieHellman>(args.Holder());
crypto: allow custom generator for DiffieHellman
11 years ago
if (!diffieHellman->initialised_)
src: remove `node_isolate` from source fix #6899
11 years ago
return diffieHellman->env()->ThrowError("Not initialized");
crypto: allow custom generator for DiffieHellman
11 years ago
args.GetReturnValue().Set(diffieHellman->verifyError_);
}
crypto: split crypto classes
12 years ago
bool DiffieHellman::VerifyContext() {
int codes;
cpplint: disallow if one-liners
11 years ago
if (!DH_check(dh, &codes))
return false;
crypto: allow custom generator for DiffieHellman
11 years ago
verifyError_ = codes;
crypto: split crypto classes
12 years ago
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: introduce ECDH
10 years ago
void ECDH::Initialize(Environment* env, Handle<Object> target) {
HandleScope scope(env->isolate());
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
crypto: introduce ECDH
10 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "generateKeys", GenerateKeys);
env->SetProtoMethod(t, "computeSecret", ComputeSecret);
env->SetProtoMethod(t, "getPublicKey", GetPublicKey);
env->SetProtoMethod(t, "getPrivateKey", GetPrivateKey);
env->SetProtoMethod(t, "setPublicKey", SetPublicKey);
env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey);
crypto: introduce ECDH
10 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "ECDH"),
t->GetFunction());
}
void ECDH::New(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: introduce ECDH
10 years ago
// TODO(indutny): Support raw curves?
CHECK(args[0]->IsString());
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value curve(env->isolate(), args[0]);
crypto: introduce ECDH
10 years ago
int nid = OBJ_sn2nid(*curve);
if (nid == NID_undef)
return env->ThrowTypeError("First argument should be a valid curve name");
EC_KEY* key = EC_KEY_new_by_curve_name(nid);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (key == nullptr)
crypto: introduce ECDH
10 years ago
return env->ThrowError("Failed to create EC_KEY using curve name");
new ECDH(env, args.This(), key);
}
void ECDH::GenerateKeys(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: introduce ECDH
10 years ago
ECDH* ecdh = Unwrap<ECDH>(args.Holder());
if (!EC_KEY_generate_key(ecdh->key_))
return env->ThrowError("Failed to generate EC_KEY");
ecdh->generated_ = true;
}
EC_POINT* ECDH::BufferToPoint(char* data, size_t len) {
EC_POINT* pub;
int r;
pub = EC_POINT_new(group_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pub == nullptr) {
crypto: introduce ECDH
10 years ago
env()->ThrowError("Failed to allocate EC_POINT for a public key");
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
crypto: introduce ECDH
10 years ago
}
r = EC_POINT_oct2point(
group_,
pub,
reinterpret_cast<unsigned char*>(data),
len,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr);
crypto: introduce ECDH
10 years ago
if (!r) {
env()->ThrowError("Failed to translate Buffer to a EC_POINT");
goto fatal;
}
return pub;
fatal:
EC_POINT_free(pub);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
crypto: introduce ECDH
10 years ago
}
void ECDH::ComputeSecret(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: introduce ECDH
10 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
crypto: introduce ECDH
10 years ago
ECDH* ecdh = Unwrap<ECDH>(args.Holder());
EC_POINT* pub = ecdh->BufferToPoint(Buffer::Data(args[0]),
Buffer::Length(args[0]));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pub == nullptr)
crypto: introduce ECDH
10 years ago
return;
// NOTE: field_size is in bits
int field_size = EC_GROUP_get_degree(ecdh->group_);
size_t out_len = (field_size + 7) / 8;
char* out = static_cast<char*>(malloc(out_len));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_NE(out, nullptr);
crypto: introduce ECDH
10 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
int r = ECDH_compute_key(out, out_len, pub, ecdh->key_, nullptr);
crypto: introduce ECDH
10 years ago
EC_POINT_free(pub);
if (!r) {
free(out);
return env->ThrowError("Failed to compute ECDH key");
}
args.GetReturnValue().Set(Buffer::Use(env, out, out_len));
}
void ECDH::GetPublicKey(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: introduce ECDH
10 years ago
// Conversion form
CHECK_EQ(args.Length(), 1);
ECDH* ecdh = Unwrap<ECDH>(args.Holder());
if (!ecdh->generated_)
return env->ThrowError("You should generate ECDH keys first");
const EC_POINT* pub = EC_KEY_get0_public_key(ecdh->key_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pub == nullptr)
crypto: introduce ECDH
10 years ago
return env->ThrowError("Failed to get ECDH public key");
int size;
point_conversion_form_t form =
static_cast<point_conversion_form_t>(args[0]->Uint32Value());
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
size = EC_POINT_point2oct(ecdh->group_, pub, form, nullptr, 0, nullptr);
crypto: introduce ECDH
10 years ago
if (size == 0)
return env->ThrowError("Failed to get public key length");
unsigned char* out = static_cast<unsigned char*>(malloc(size));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_NE(out, nullptr);
crypto: introduce ECDH
10 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
int r = EC_POINT_point2oct(ecdh->group_, pub, form, out, size, nullptr);
crypto: introduce ECDH
10 years ago
if (r != size) {
free(out);
return env->ThrowError("Failed to get public key");
}
args.GetReturnValue().Set(Buffer::Use(env,
reinterpret_cast<char*>(out),
size));
}
void ECDH::GetPrivateKey(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: introduce ECDH
10 years ago
ECDH* ecdh = Unwrap<ECDH>(args.Holder());
if (!ecdh->generated_)
return env->ThrowError("You should generate ECDH keys first");
const BIGNUM* b = EC_KEY_get0_private_key(ecdh->key_);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (b == nullptr)
crypto: introduce ECDH
10 years ago
return env->ThrowError("Failed to get ECDH private key");
int size = BN_num_bytes(b);
unsigned char* out = static_cast<unsigned char*>(malloc(size));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_NE(out, nullptr);
crypto: introduce ECDH
10 years ago
if (size != BN_bn2bin(b, out)) {
free(out);
return env->ThrowError("Failed to convert ECDH private key to Buffer");
}
args.GetReturnValue().Set(Buffer::Use(env,
reinterpret_cast<char*>(out),
size));
}
void ECDH::SetPrivateKey(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: introduce ECDH
10 years ago
ECDH* ecdh = Unwrap<ECDH>(args.Holder());
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
crypto: introduce ECDH
10 years ago
BIGNUM* priv = BN_bin2bn(
reinterpret_cast<unsigned char*>(Buffer::Data(args[0].As<Object>())),
Buffer::Length(args[0].As<Object>()),
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr);
if (priv == nullptr)
crypto: introduce ECDH
10 years ago
return env->ThrowError("Failed to convert Buffer to BN");
if (!EC_KEY_set_private_key(ecdh->key_, priv))
return env->ThrowError("Failed to convert BN to a private key");
}
void ECDH::SetPublicKey(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: introduce ECDH
10 years ago
ECDH* ecdh = Unwrap<ECDH>(args.Holder());
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
crypto: introduce ECDH
10 years ago
EC_POINT* pub = ecdh->BufferToPoint(Buffer::Data(args[0].As<Object>()),
Buffer::Length(args[0].As<Object>()));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pub == nullptr)
crypto: introduce ECDH
10 years ago
return;
int r = EC_KEY_set_public_key(ecdh->key_, pub);
EC_POINT_free(pub);
if (!r)
return env->ThrowError("Failed to convert BN to a private key");
}
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
class PBKDF2Request : public AsyncWrap {
public:
PBKDF2Request(Environment* env,
Local<Object> object,
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
const EVP_MD* digest,
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
ssize_t passlen,
char* pass,
ssize_t saltlen,
char* salt,
ssize_t iter,
ssize_t keylen)
async_wrap: add provider types/pass to constructor These will be used to allow users to filter for which types of calls they wish their callbacks to run. Signed-off-by: Timothy J Fontaine &lt;tjfontaine@gmail.com&gt;
11 years ago
: AsyncWrap(env, object, AsyncWrap::PROVIDER_CRYPTO),
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
digest_(digest),
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
error_(0),
passlen_(passlen),
pass_(pass),
saltlen_(saltlen),
salt_(salt),
keylen_(keylen),
key_(static_cast<char*>(malloc(keylen))),
iter_(iter) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (key() == nullptr)
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
FatalError("node::PBKDF2Request()", "Out of Memory");
}
src: mark more destructors with override keyword The previous commits fixed oversights in destructors that should have been marked virtual but weren&#39;t. This commit marks destructors from derived classes with the override keyword.
10 years ago
~PBKDF2Request() override {
src: update to v8 3.24 APIs
11 years ago
persistent().Reset();
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
}
uv_work_t* work_req() {
return &work_req_;
}
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
inline const EVP_MD* digest() const {
return digest_;
}
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
inline ssize_t passlen() const {
return passlen_;
}
inline char* pass() const {
return pass_;
}
inline ssize_t saltlen() const {
return saltlen_;
}
inline char* salt() const {
return salt_;
}
inline ssize_t keylen() const {
return keylen_;
}
inline char* key() const {
return key_;
}
inline ssize_t iter() const {
return iter_;
}
inline void release() {
free(pass_);
passlen_ = 0;
free(salt_);
saltlen_ = 0;
free(key_);
keylen_ = 0;
}
inline int error() const {
return error_;
}
inline void set_error(int err) {
error_ = err;
}
uv_work_t work_req_;
private:
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
const EVP_MD* digest_;
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
int error_;
ssize_t passlen_;
char* pass_;
ssize_t saltlen_;
char* salt_;
ssize_t keylen_;
char* key_;
ssize_t iter_;
crypto: PBKDF2 function from OpenSSL
14 years ago
};
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
void EIO_PBKDF2(PBKDF2Request* req) {
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
req->set_error(PKCS5_PBKDF2_HMAC(
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
req->pass(),
req->passlen(),
reinterpret_cast<unsigned char*>(req->salt()),
req->saltlen(),
req->iter(),
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
req->digest(),
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
req->keylen(),
reinterpret_cast<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) {
src: replace CONTAINER_OF with type-safe function Replace the CONTAINER_OF macro with a template function that is as type-safe as a reinterpret_cast&lt;&gt; of an arbitrary pointer can be made. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
PBKDF2Request* req = ContainerOf(&PBKDF2Request::work_req_, work_req);
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
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
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
void EIO_PBKDF2After(PBKDF2Request* req, Local<Value> argv[2]) {
if (req->error()) {
src: remove `node_isolate` from source fix #6899
11 years ago
argv[0] = Undefined(req->env()->isolate());
argv[1] = Encode(req->env()->isolate(), req->key(), req->keylen(), BUFFER);
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
memset(req->key(), 0, req->keylen());
crypto: PBKDF2 function from OpenSSL
14 years ago
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
argv[0] = Exception::Error(req->env()->pbkdf2_error_string());
argv[1] = Undefined(req->env()->isolate());
crypto: PBKDF2 function from OpenSSL
14 years ago
}
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
}
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) {
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_EQ(status, 0);
src: replace CONTAINER_OF with type-safe function Replace the CONTAINER_OF macro with a template function that is as type-safe as a reinterpret_cast&lt;&gt; of an arbitrary pointer can be made. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
PBKDF2Request* req = ContainerOf(&PBKDF2Request::work_req_, work_req);
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
Environment* env = req->env();
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
HandleScope handle_scope(env->isolate());
src: fix Context::Scope usage env-&gt;context() may or may not create a new Local. It currently does not but don&#39;t depend on that behavior, create a HandleScope first.
11 years ago
Context::Scope context_scope(env->context());
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
Local<Value> argv[2];
EIO_PBKDF2After(req, argv);
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
req->MakeCallback(env->ondone_string(), ARRAY_SIZE(argv), argv);
req->release();
delete req;
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: PBKDF2 function from OpenSSL
14 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
const EVP_MD* digest = nullptr;
const char* type_error = nullptr;
char* pass = nullptr;
char* salt = nullptr;
crypto: fix memory leaks in PBKDF2 error path
13 years ago
ssize_t passlen = -1;
ssize_t saltlen = -1;
ssize_t keylen = -1;
ssize_t iter = -1;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
PBKDF2Request* req = nullptr;
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
Local<Object> obj;
crypto: fix memory leaks in PBKDF2 error path
13 years ago
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
if (args.Length() != 5 && args.Length() != 6) {
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
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_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;
}
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[1]);
crypto: avoid memory leak Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
pass = static_cast<char*>(malloc(passlen));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pass == nullptr) {
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
FatalError("node::PBKDF2()", "Out of Memory");
}
src: don&#39;t call DecodeWrite() on Buffers Don&#39;t call DecodeWrite() with a Buffer as its argument because it in turn calls StringBytes::Write() and that method expects a Local&lt;String&gt;. &#34;Why then does that function take a Local&lt;Value&gt;?&#34; I hear you ask. Good question but I don&#39;t have the answer. I added a CHECK for good measure and what do you know, all of a sudden a large number of crypto tests started failing. Calling DecodeWrite(BINARY) on a buffer is nonsensical anyway: if you want the contents of the buffer, just copy out the data, there is no need to decode it - and that&#39;s exactly what this commit does. Fixes a great many instances of the following run-time error in debug builds: FATAL ERROR: v8::String::Cast() Could not convert to string
11 years ago
memcpy(pass, Buffer::Data(args[0]), passlen);
crypto: PBKDF2 function from OpenSSL
14 years ago
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;
}
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
salt = static_cast<char*>(malloc(saltlen));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (salt == nullptr) {
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
FatalError("node::PBKDF2()", "Out of Memory");
}
src: don&#39;t call DecodeWrite() on Buffers Don&#39;t call DecodeWrite() with a Buffer as its argument because it in turn calls StringBytes::Write() and that method expects a Local&lt;String&gt;. &#34;Why then does that function take a Local&lt;Value&gt;?&#34; I hear you ask. Good question but I don&#39;t have the answer. I added a CHECK for good measure and what do you know, all of a sudden a large number of crypto tests started failing. Calling DecodeWrite(BINARY) on a buffer is nonsensical anyway: if you want the contents of the buffer, just copy out the data, there is no need to decode it - and that&#39;s exactly what this commit does. Fixes a great many instances of the following run-time error in debug builds: FATAL ERROR: v8::String::Cast() Could not convert to string
11 years ago
memcpy(salt, Buffer::Data(args[1]), saltlen);
crypto: PBKDF2 function from OpenSSL
14 years ago
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: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
if (args[4]->IsString()) {
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value digest_name(env->isolate(), args[4]);
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
digest = EVP_get_digestbyname(*digest_name);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (digest == nullptr) {
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
type_error = "Bad digest name";
goto err;
}
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (digest == nullptr) {
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
digest = EVP_sha1();
}
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
src: update to v8 3.24 APIs
11 years ago
obj = Object::New(env->isolate());
crypto: support custom pbkdf2 digest methods Make the HMAC digest method configurable. Update crypto.pbkdf2() and crypto.pbkdf2Sync() to take an extra, optional digest argument. Before this commit, SHA-1 (admittedly the most common method) was used exclusively. Fixes #6553.
11 years ago
req = new PBKDF2Request(env,
obj,
digest,
passlen,
pass,
saltlen,
salt,
iter,
keylen);
if (args[5]->IsFunction()) {
obj->Set(env->ondone_string(), args[5]);
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
// XXX(trevnorris): This will need to go with the rest of domains.
if (env->in_domain())
obj->Set(env->domain_string(), env->domain_array()->Get(0));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
uv_queue_work(env->event_loop(),
crypto: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
req->work_req(),
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
EIO_PBKDF2,
EIO_PBKDF2After);
} else {
core: implement runtime flag to trace sync io Use the --trace-sync-io flag to print a stack trace whenever a sync method is used after the first tick, excluding during the process exit event. (e.g. fs.readFileSync()) It does not track if the warning has occurred at a specific location in the past and so will print the warning every time. Reason for not printing during the first tick of the appication is so all necessary resources can be required. Also by excluding synchronous calls during exit is necessary in case any data needs to be logged out by the application before it shuts down. Fixes: https://github.com/nodejs/io.js/issues/1674 PR-URL: https://github.com/nodejs/io.js/pull/1707 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Jeremiah Senkpiel &lt;fishrock123@rocketmail.com&gt; Reviewed-By: Petka Antonov &lt;petka_antonov@hotmail.com&gt;
10 years ago
env->PrintSyncTrace();
crypto: add sync interface to crypto.pbkdf2() Fixes #3766.
13 years ago
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())
src: update to v8 3.24 APIs
11 years ago
env->isolate()->ThrowException(argv[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
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: convert pbkdf2_req to a class pbkdf2_req has been renamed to PBKDF2Request and converted to a class. It now uses AsyncWrap::MakeCallback. Also includes, using env()-&gt;ondone_string() instead of &#34;ondone&#34; and using malloc instead of new char[].
11 years ago
free(salt);
free(pass);
src: remove `node_isolate` from source fix #6899
11 years ago
return env->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
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
// Only instantiate within a valid HandleScope.
class RandomBytesRequest : public AsyncWrap {
public:
RandomBytesRequest(Environment* env, Local<Object> object, size_t size)
async_wrap: add provider types/pass to constructor These will be used to allow users to filter for which types of calls they wish their callbacks to run. Signed-off-by: Timothy J Fontaine &lt;tjfontaine@gmail.com&gt;
11 years ago
: AsyncWrap(env, object, AsyncWrap::PROVIDER_CRYPTO),
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
error_(0),
size_(size),
data_(static_cast<char*>(malloc(size))) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (data() == nullptr)
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
FatalError("node::RandomBytesRequest()", "Out of Memory");
}
src: mark more destructors with override keyword The previous commits fixed oversights in destructors that should have been marked virtual but weren&#39;t. This commit marks destructors from derived classes with the override keyword.
10 years ago
~RandomBytesRequest() override {
src: update to v8 3.24 APIs
11 years ago
persistent().Reset();
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
}
uv_work_t* work_req() {
return &work_req_;
}
inline size_t size() const {
return size_;
}
inline char* data() const {
return data_;
}
inline void release() {
free(data_);
size_ = 0;
}
inline void return_memory(char** d, size_t* len) {
*d = data_;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
data_ = nullptr;
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
*len = size_;
size_ = 0;
}
inline unsigned long error() const {
return error_;
}
inline void set_error(unsigned long err) {
error_ = err;
}
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
uv_work_t work_req_;
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
private:
unsigned long error_;
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
size_t size_;
char* data_;
};
void RandomBytesWork(uv_work_t* work_req) {
src: replace CONTAINER_OF with type-safe function Replace the CONTAINER_OF macro with a template function that is as type-safe as a reinterpret_cast&lt;&gt; of an arbitrary pointer can be made. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
RandomBytesRequest* req =
ContainerOf(&RandomBytesRequest::work_req_, work_req);
crypto: fix -Wtautological-compare warning
12 years ago
src: ensure that openssl&#39;s PRNG is fully seeded Ensure that OpenSSL has enough entropy (at least 256 bits) for its PRNG. The entropy pool starts out empty and needs to fill up before the PRNG can be used securely. OpenSSL normally fills the pool automatically but not when someone starts generating random numbers before the pool is full: in that case OpenSSL keeps lowering the entropy estimate to thwart attackers trying to guess the initial state of the PRNG. When that happens, we wait until enough entropy is available, something that normally should never take longer than a few milliseconds. Fixes #7338.
11 years ago
// Ensure that OpenSSL's PRNG is properly seeded.
CheckEntropy();
lib,src: make pseudoRandomBytes alias randomBytes Previously pseudoRandomBytes worked similarly to randomBytes but in the event of insufficient entropy would silently return non-secure values. As of f68a116, the entropy pool blocks if there is insufficient entropy instead of giving an error so there is now no longer a case where pseudoRandomBytes would act differently than randomBytes. Docs are updated to remove pseudoRandomBytes and to clarify that randomBytes now does block instead of erring when entropy is low. PR-URL: https://github.com/iojs/io.js/pull/557 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
const int r = RAND_bytes(reinterpret_cast<unsigned char*>(req->data()),
req->size());
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
lib,src: make pseudoRandomBytes alias randomBytes Previously pseudoRandomBytes worked similarly to randomBytes but in the event of insufficient entropy would silently return non-secure values. As of f68a116, the entropy pool blocks if there is insufficient entropy instead of giving an error so there is now no longer a case where pseudoRandomBytes would act differently than randomBytes. Docs are updated to remove pseudoRandomBytes and to clarify that randomBytes now does block instead of erring when entropy is low. PR-URL: https://github.com/iojs/io.js/pull/557 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
// RAND_bytes() returns 0 on error.
if (r == 0) {
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
req->set_error(ERR_get_error());
crypto: fix -Wtautological-compare warning
12 years ago
} else if (r == -1) {
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
req->set_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: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
if (req->error()) {
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
char errmsg[256] = "Operation not supported";
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
if (req->error() != static_cast<unsigned long>(-1))
ERR_error_string_n(req->error(), errmsg, sizeof errmsg);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
argv[0] = Exception::Error(OneByteString(req->env()->isolate(), errmsg));
argv[1] = Null(req->env()->isolate());
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
req->release();
src: lint c++ code
12 years ago
} else {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
char* data = nullptr;
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
size_t size;
req->return_memory(&data, &size);
src: remove `node_isolate` from source fix #6899
11 years ago
argv[0] = Null(req->env()->isolate());
src: fix deprecation warnings The previous commit enables deprecation warnings, this commit fixes the handful of offending sites where the isolate was not explicitly being passed around. PR-URL: https://github.com/iojs/io.js/pull/1565 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
argv[1] = Buffer::Use(req->env()->isolate(), data, 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) {
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_EQ(status, 0);
src: replace CONTAINER_OF with type-safe function Replace the CONTAINER_OF macro with a template function that is as type-safe as a reinterpret_cast&lt;&gt; of an arbitrary pointer can be made. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
RandomBytesRequest* req =
ContainerOf(&RandomBytesRequest::work_req_, work_req);
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
Environment* env = req->env();
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
HandleScope handle_scope(env->isolate());
src: fix Environment::GetCurrent() usage Create a HandleScope before calling the Environment::GetCurrent() that takes a v8::Isolate* as an argument because it creates a handle with the call to v8::Isolate::CurrentContext().
11 years ago
Context::Scope context_scope(env->context());
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: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
req->MakeCallback(env->ondone_string(), ARRAY_SIZE(argv), argv);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
delete req;
}
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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
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: clarify RandomBytes() error msg Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
return env->ThrowTypeError("size must be a 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) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("size > Buffer::kMaxLength");
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
}
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
src: update to v8 3.24 APIs
11 years ago
Local<Object> obj = Object::New(env->isolate());
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
RandomBytesRequest* req = new RandomBytesRequest(env, obj, size);
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
if (args[1]->IsFunction()) {
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
obj->Set(FIXED_ONE_BYTE_STRING(args.GetIsolate(), "ondone"), args[1]);
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
// XXX(trevnorris): This will need to go with the rest of domains.
if (env->in_domain())
obj->Set(env->domain_string(), env->domain_array()->Get(0));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
uv_queue_work(env->event_loop(),
crypto: convert RandomBytesRequest to a class Since RandomBytesRequest makes a call to MakeCallback, needed it to be a class so AsyncWrap could handle any async listeners. Also added a simple test for an issue had during implementation where the memory was being released and returned.
11 years ago
req->work_req(),
lib,src: make pseudoRandomBytes alias randomBytes Previously pseudoRandomBytes worked similarly to randomBytes but in the event of insufficient entropy would silently return non-secure values. As of f68a116, the entropy pool blocks if there is insufficient entropy instead of giving an error so there is now no longer a case where pseudoRandomBytes would act differently than randomBytes. Docs are updated to remove pseudoRandomBytes and to clarify that randomBytes now does block instead of erring when entropy is low. PR-URL: https://github.com/iojs/io.js/pull/557 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
RandomBytesWork,
crypto: fix -Wtautological-compare warning
12 years ago
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 {
core: implement runtime flag to trace sync io Use the --trace-sync-io flag to print a stack trace whenever a sync method is used after the first tick, excluding during the process exit event. (e.g. fs.readFileSync()) It does not track if the warning has occurred at a specific location in the past and so will print the warning every time. Reason for not printing during the first tick of the appication is so all necessary resources can be required. Also by excluding synchronous calls during exit is necessary in case any data needs to be logged out by the application before it shuts down. Fixes: https://github.com/nodejs/io.js/issues/1674 PR-URL: https://github.com/nodejs/io.js/pull/1707 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Jeremiah Senkpiel &lt;fishrock123@rocketmail.com&gt; Reviewed-By: Petka Antonov &lt;petka_antonov@hotmail.com&gt;
10 years ago
env->PrintSyncTrace();
crypto: root JS objects in HandleScope with Local&lt;&gt;
13 years ago
Local<Value> argv[2];
lib,src: make pseudoRandomBytes alias randomBytes Previously pseudoRandomBytes worked similarly to randomBytes but in the event of insufficient entropy would silently return non-secure values. As of f68a116, the entropy pool blocks if there is insufficient entropy instead of giving an error so there is now no longer a case where pseudoRandomBytes would act differently than randomBytes. Docs are updated to remove pseudoRandomBytes and to clarify that randomBytes now does block instead of erring when entropy is low. PR-URL: https://github.com/iojs/io.js/pull/557 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
RandomBytesWork(req->work_req());
crypto: implement randomBytes() and pseudoRandomBytes()
13 years ago
RandomBytesCheck(req, argv);
delete req;
if (!argv[0]->IsNull())
src: update to v8 3.24 APIs
11 years ago
env->isolate()->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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: add crypto.getCiphers() Returns a list of, unsurprisingly, the available ciphers.
12 years ago
SSL_CTX* ctx = SSL_CTX_new(TLSv1_server_method());
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (ctx == nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("SSL_CTX_new() failed.");
crypto: add crypto.getCiphers() Returns a list of, unsurprisingly, the available ciphers.
12 years ago
}
SSL* ssl = SSL_new(ctx);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (ssl == nullptr) {
crypto: add crypto.getCiphers() Returns a list of, unsurprisingly, the available ciphers.
12 years ago
SSL_CTX_free(ctx);
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("SSL_new() failed.");
crypto: add crypto.getCiphers() Returns a list of, unsurprisingly, the available ciphers.
12 years ago
}
src: update to v8 3.24 APIs
11 years ago
Local<Array> arr = Array::New(env->isolate());
crypto: add crypto.getCiphers() Returns a list of, unsurprisingly, the available ciphers.
12 years ago
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);
crypto: remove most of the `node_isolate` uses All C++ code should be using `args.GetIsolate()` or `env-&gt;isolate()`. Using static `node_isolate` var limits possible future functionality (like multi-isolate support).
11 years ago
arr->Set(i, OneByteString(args.GetIsolate(), 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
}
src: remove `node_isolate` from source fix #6899
11 years ago
class CipherPushContext {
public:
src: update to v8 3.24 APIs
11 years ago
explicit CipherPushContext(Environment* env)
: arr(Array::New(env->isolate())),
env_(env) {
src: remove `node_isolate` from source fix #6899
11 years ago
}
inline Environment* env() const { return env_; }
Local<Array> arr;
private:
Environment* env_;
};
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) {
src: remove `node_isolate` from source fix #6899
11 years ago
CipherPushContext* ctx = static_cast<CipherPushContext*>(arg);
ctx->arr->Set(ctx->arr->Length(), OneByteString(ctx->env()->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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
src: remove `node_isolate` from source fix #6899
11 years ago
CipherPushContext ctx(env);
EVP_CIPHER_do_all_sorted(array_push_back<EVP_CIPHER>, &ctx);
args.GetReturnValue().Set(ctx.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: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
src: remove `node_isolate` from source fix #6899
11 years ago
CipherPushContext ctx(env);
EVP_MD_do_all_sorted(array_push_back<EVP_MD>, &ctx);
args.GetReturnValue().Set(ctx.arr);
crypto: add crypto.getHashes()
12 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
void Certificate::Initialize(Environment* env, Handle<Object> target) {
HandleScope scope(env->isolate());
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
t->InstanceTemplate()->SetInternalFieldCount(1);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetProtoMethod(t, "verifySpkac", VerifySpkac);
env->SetProtoMethod(t, "exportPublicKey", ExportPublicKey);
env->SetProtoMethod(t, "exportChallenge", ExportChallenge);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Certificate"),
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
t->GetFunction());
}
void Certificate::New(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
new Certificate(env, args.This());
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
}
bool Certificate::VerifySpkac(const char* data, unsigned int len) {
bool i = 0;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
EVP_PKEY* pkey = nullptr;
NETSCAPE_SPKI* spki = nullptr;
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
spki = NETSCAPE_SPKI_b64_decode(data, len);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (spki == nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
goto exit;
pkey = X509_PUBKEY_get(spki->spkac->pubkey);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey == nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
goto exit;
i = NETSCAPE_SPKI_verify(spki, pkey) > 0;
exit:
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey != nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
EVP_PKEY_free(pkey);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (spki != nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
NETSCAPE_SPKI_free(spki);
return i;
}
void Certificate::VerifySpkac(const FunctionCallbackInfo<Value>& args) {
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Certificate* certificate = Unwrap<Certificate>(args.Holder());
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = certificate->env();
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
bool i = false;
if (args.Length() < 1)
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Missing argument");
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
size_t length = Buffer::Length(args[0]);
if (length == 0)
return args.GetReturnValue().Set(i);
char* data = Buffer::Data(args[0]);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_NE(data, nullptr);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
crypto: fix a couple of VC++ warnings Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
i = certificate->VerifySpkac(data, length);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
args.GetReturnValue().Set(i);
}
const char* Certificate::ExportPublicKey(const char* data, int len) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
char* buf = nullptr;
EVP_PKEY* pkey = nullptr;
NETSCAPE_SPKI* spki = nullptr;
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
BIO* bio = BIO_new(BIO_s_mem());
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (bio == nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
goto exit;
spki = NETSCAPE_SPKI_b64_decode(data, len);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (spki == nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
goto exit;
pkey = NETSCAPE_SPKI_get_pubkey(spki);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey == nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
goto exit;
if (PEM_write_bio_PUBKEY(bio, pkey) <= 0)
goto exit;
BIO_write(bio, "\0", 1);
BUF_MEM* ptr;
BIO_get_mem_ptr(bio, &ptr);
buf = new char[ptr->length];
memcpy(buf, ptr->data, ptr->length);
exit:
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey != nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
EVP_PKEY_free(pkey);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (spki != nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
NETSCAPE_SPKI_free(spki);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (bio != nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
BIO_free_all(bio);
return buf;
}
void Certificate::ExportPublicKey(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Certificate* certificate = Unwrap<Certificate>(args.Holder());
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
if (args.Length() < 1)
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Missing argument");
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
size_t length = Buffer::Length(args[0]);
if (length == 0)
return args.GetReturnValue().SetEmptyString();
char* data = Buffer::Data(args[0]);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_NE(data, nullptr);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
const char* pkey = certificate->ExportPublicKey(data, length);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (pkey == nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
return args.GetReturnValue().SetEmptyString();
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> out = Encode(env->isolate(), pkey, strlen(pkey), BUFFER);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
delete[] pkey;
args.GetReturnValue().Set(out);
}
const char* Certificate::ExportChallenge(const char* data, int len) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
NETSCAPE_SPKI* sp = nullptr;
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
sp = NETSCAPE_SPKI_b64_decode(data, len);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (sp == nullptr)
return nullptr;
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
const char* buf = nullptr;
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
buf = reinterpret_cast<const char*>(ASN1_STRING_data(sp->spkac->challenge));
return buf;
}
void Certificate::ExportChallenge(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
node: add signature to SET_PROTOTYPE_METHOD This prevents segfaults when a native method is reassigned to a different object (which corrupts args.This()). When unwrapping, clients should use args.Holder() instead of args.This(). Closes #6690. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Certificate* crt = Unwrap<Certificate>(args.Holder());
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
if (args.Length() < 1)
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("Missing argument");
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
src: rename ASSERT macros in node_crypto.cc Rename the misnomers ASSERT_IS_STRING_OR_BUFFER and ASSERT_IS_BUFFER. Said macros don&#39;t assert, they throw a TypeError and return. PR-URL: https://github.com/iojs/io.js/pull/529 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
THROW_AND_RETURN_IF_NOT_BUFFER(args[0]);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
size_t len = Buffer::Length(args[0]);
if (len == 0)
return args.GetReturnValue().SetEmptyString();
char* data = Buffer::Data(args[0]);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_NE(data, nullptr);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
const char* cert = crt->ExportChallenge(data, len);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (cert == nullptr)
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
return args.GetReturnValue().SetEmptyString();
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> outString = Encode(env->isolate(), cert, strlen(cert), BUFFER);
crypto: add SPKAC support Implements new class &#39;Certificate&#39; within crypto object for working with SPKAC&#39;s (signed public key &amp; challenge) natively.
11 years ago
delete[] cert;
args.GetReturnValue().Set(outString);
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void InitCryptoOnce() {
Initial openssl support for net2
15 years ago
SSL_library_init();
Additional OpenSSL tests
15 years ago
OpenSSL_add_all_algorithms();
Initial openssl support for net2
15 years ago
SSL_load_error_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
crypto: comment change on disabling compression This is a comment change, where it originally says disabling TLS Compression protects against BEAST attack. But in fact, it is the CRIME attack(Compression Ratio Info-leak Made Easy) that makes use of TLS Compression and not BEAST. BEAST(Browser Exploit Against SSL/TLS) is an entirely another variant making use of the chosen boundary attack against CBC mode in encryption. Just making sure, that the exact reason for disabling TLS compression must be made clear and not be misleading with some other attack.
11 years ago
// Turn off compression. Saves memory and protects against CRIME attacks.
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);
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_EQ(sk_SSL_COMP_num(comp_methods), 0);
Disabling SSL compression is dependent on OpenSSL version 0.9.8 Fixes #1087.
14 years ago
#endif
crypto: introduce .setEngine(engine, [flags])
11 years ago
#ifndef OPENSSL_NO_ENGINE
ERR_load_ENGINE_strings();
ENGINE_load_builtin_engines();
#endif // !OPENSSL_NO_ENGINE
}
#ifndef OPENSSL_NO_ENGINE
void SetEngine(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
crypto: introduce .setEngine(engine, [flags])
11 years ago
CHECK(args.Length() >= 2 && args[0]->IsString());
unsigned int flags = args[1]->Uint32Value();
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence compiler warning.
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const node::Utf8Value engine_id(env->isolate(), args[0]);
crypto: introduce .setEngine(engine, [flags])
11 years ago
ENGINE* engine = ENGINE_by_id(*engine_id);
// Engine not found, try loading dynamically
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (engine == nullptr) {
crypto: introduce .setEngine(engine, [flags])
11 years ago
engine = ENGINE_by_id("dynamic");
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (engine != nullptr) {
crypto: introduce .setEngine(engine, [flags])
11 years ago
if (!ENGINE_ctrl_cmd_string(engine, "SO_PATH", *engine_id, 0) ||
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
!ENGINE_ctrl_cmd_string(engine, "LOAD", nullptr, 0)) {
crypto: introduce .setEngine(engine, [flags])
11 years ago
ENGINE_free(engine);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
engine = nullptr;
crypto: introduce .setEngine(engine, [flags])
11 years ago
}
}
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (engine == nullptr) {
crypto: introduce .setEngine(engine, [flags])
11 years ago
int err = ERR_get_error();
if (err == 0) {
char tmp[1024];
snprintf(tmp, sizeof(tmp), "Engine \"%s\" was not found", *engine_id);
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError(tmp);
crypto: introduce .setEngine(engine, [flags])
11 years ago
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
return ThrowCryptoError(env, err);
crypto: introduce .setEngine(engine, [flags])
11 years ago
}
}
int r = ENGINE_set_default(engine, flags);
ENGINE_free(engine);
if (r == 0)
src: remove `node_isolate` from source fix #6899
11 years ago
return ThrowCryptoError(env, ERR_get_error());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
crypto: introduce .setEngine(engine, [flags])
11 years ago
#endif // !OPENSSL_NO_ENGINE
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 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
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
// FIXME(bnoordhuis) Handle global init correctly.
void InitCrypto(Handle<Object> target,
Handle<Value> unused,
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
Handle<Context> context,
void* priv) {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
static uv_once_t init_once = UV_ONCE_INIT;
uv_once(&init_once, InitCryptoOnce);
Environment* env = Environment::GetCurrent(context);
SecureContext::Initialize(env, target);
Connection::Initialize(env, target);
CipherBase::Initialize(env, target);
DiffieHellman::Initialize(env, target);
crypto: introduce ECDH
10 years ago
ECDH::Initialize(env, target);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Hmac::Initialize(env, target);
Hash::Initialize(env, target);
Sign::Initialize(env, target);
Verify::Initialize(env, target);
src: remove `node_isolate` from source fix #6899
11 years ago
Certificate::Initialize(env, target);
Initial openssl support for net2
15 years ago
crypto: introduce .setEngine(engine, [flags])
11 years ago
#ifndef OPENSSL_NO_ENGINE
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(target, "setEngine", SetEngine);
crypto: introduce .setEngine(engine, [flags])
11 years ago
#endif // !OPENSSL_NO_ENGINE
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(target, "PBKDF2", PBKDF2);
lib,src: make pseudoRandomBytes alias randomBytes Previously pseudoRandomBytes worked similarly to randomBytes but in the event of insufficient entropy would silently return non-secure values. As of f68a116, the entropy pool blocks if there is insufficient entropy instead of giving an error so there is now no longer a case where pseudoRandomBytes would act differently than randomBytes. Docs are updated to remove pseudoRandomBytes and to clarify that randomBytes now does block instead of erring when entropy is low. PR-URL: https://github.com/iojs/io.js/pull/557 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(target, "randomBytes", RandomBytes);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(target, "getSSLCiphers", GetSSLCiphers);
env->SetMethod(target, "getCiphers", GetCiphers);
env->SetMethod(target, "getHashes", GetHashes);
env->SetMethod(target, "publicEncrypt",
crypto: implement privateEncrypt/publicDecrypt PR-URL: https://github.com/iojs/io.js/pull/625 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Fix iojs/io.js#477
10 years ago
PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
EVP_PKEY_encrypt_init,
EVP_PKEY_encrypt>);
env->SetMethod(target, "privateDecrypt",
crypto: implement privateEncrypt/publicDecrypt PR-URL: https://github.com/iojs/io.js/pull/625 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Fix iojs/io.js#477
10 years ago
PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
EVP_PKEY_decrypt_init,
EVP_PKEY_decrypt>);
crypto: implement privateEncrypt/publicDecrypt PR-URL: https://github.com/iojs/io.js/pull/625 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Fix iojs/io.js#477
10 years ago
env->SetMethod(target, "privateEncrypt",
PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
EVP_PKEY_sign_init,
EVP_PKEY_sign>);
env->SetMethod(target, "publicDecrypt",
PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
EVP_PKEY_verify_recover_init,
EVP_PKEY_verify_recover>);
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
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
NODE_MODULE_CONTEXT_AWARE_BUILTIN(crypto, node::crypto::InitCrypto)