1berry/nodejs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

crypto: simplify Certificate class bindings

Browse Source 
Replace Certificate C++ class with simple functions. Update
crypto.Certificate methods accordingly.

PR-URL: https://github.com/nodejs/node/pull/5382
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
This commit is contained in:
Alexander Makarenko 2016-02-23 15:43:32 +03:00 committed by Ben Noordhuis
parent c490b8ba54
commit a37401e061
3 changed files with 16 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lib/crypto.js
View File

@ -591,23 +591,21 @@ exports.Certificate = Certificate;
function Certificate() {
if (!(this instanceof Certificate))
return new Certificate();
this._handle = new binding.Certificate();
}
Certificate.prototype.verifySpkac = function(object) {
return this._handle.verifySpkac(object);
return binding.certVerifySpkac(object);
};
Certificate.prototype.exportPublicKey = function(object, encoding) {
return this._handle.exportPublicKey(toBuf(object, encoding));
return binding.certExportPublicKey(toBuf(object, encoding));
};
Certificate.prototype.exportChallenge = function(object, encoding) {
return this._handle.exportChallenge(toBuf(object, encoding));
return binding.certExportChallenge(toBuf(object, encoding));
};

51
src/node_crypto.cc
View File

@ -5484,29 +5484,7 @@ void GetCurves(const FunctionCallbackInfo<Value>& args) {
}
void Certificate::Initialize(Environment* env, Local<Object> target) {
HandleScope scope(env->isolate());
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
t->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(t, "verifySpkac", VerifySpkac);
env->SetProtoMethod(t, "exportPublicKey", ExportPublicKey);
env->SetProtoMethod(t, "exportChallenge", ExportChallenge);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Certificate"),
t->GetFunction());
}
void Certificate::New(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
new Certificate(env, args.This());
}
bool Certificate::VerifySpkac(const char* data, unsigned int len) {
bool VerifySpkac(const char* data, unsigned int len) {
bool i = 0;
EVP_PKEY* pkey = nullptr;
NETSCAPE_SPKI* spki = nullptr;
@ -5532,9 +5510,8 @@ bool Certificate::VerifySpkac(const char* data, unsigned int len) {
}
void Certificate::VerifySpkac(const FunctionCallbackInfo<Value>& args) {
Certificate* certificate = Unwrap<Certificate>(args.Holder());
Environment* env = certificate->env();
void VerifySpkac(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
bool i = false;
if (args.Length() < 1)
@ -5549,13 +5526,13 @@ void Certificate::VerifySpkac(const FunctionCallbackInfo<Value>& args) {
char* data = Buffer::Data(args[0]);
CHECK_NE(data, nullptr);
i = certificate->VerifySpkac(data, length);
i = VerifySpkac(data, length);
args.GetReturnValue().Set(i);
}
const char* Certificate::ExportPublicKey(const char* data, int len) {
const char* ExportPublicKey(const char* data, int len) {
char* buf = nullptr;
EVP_PKEY* pkey = nullptr;
NETSCAPE_SPKI* spki = nullptr;
@ -5596,11 +5573,9 @@ const char* Certificate::ExportPublicKey(const char* data, int len) {
}
void Certificate::ExportPublicKey(const FunctionCallbackInfo<Value>& args) {
void ExportPublicKey(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Certificate* certificate = Unwrap<Certificate>(args.Holder());
if (args.Length() < 1)
return env->ThrowTypeError("Missing argument");
@ -5613,7 +5588,7 @@ void Certificate::ExportPublicKey(const FunctionCallbackInfo<Value>& args) {
char* data = Buffer::Data(args[0]);
CHECK_NE(data, nullptr);
const char* pkey = certificate->ExportPublicKey(data, length);
const char* pkey = ExportPublicKey(data, length);
if (pkey == nullptr)
return args.GetReturnValue().SetEmptyString();
@ -5625,7 +5600,7 @@ void Certificate::ExportPublicKey(const FunctionCallbackInfo<Value>& args) {
}
const char* Certificate::ExportChallenge(const char* data, int len) {
const char* ExportChallenge(const char* data, int len) {
NETSCAPE_SPKI* sp = nullptr;
sp = NETSCAPE_SPKI_b64_decode(data, len);
@ -5641,11 +5616,9 @@ const char* Certificate::ExportChallenge(const char* data, int len) {
}
void Certificate::ExportChallenge(const FunctionCallbackInfo<Value>& args) {
void ExportChallenge(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Certificate* crt = Unwrap<Certificate>(args.Holder());
if (args.Length() < 1)
return env->ThrowTypeError("Missing argument");
@ -5658,7 +5631,7 @@ void Certificate::ExportChallenge(const FunctionCallbackInfo<Value>& args) {
char* data = Buffer::Data(args[0]);
CHECK_NE(data, nullptr);
const char* cert = crt->ExportChallenge(data, len);
const char* cert = ExportChallenge(data, len);
if (cert == nullptr)
return args.GetReturnValue().SetEmptyString();
@ -5797,8 +5770,10 @@ void InitCrypto(Local<Object> target,
Hash::Initialize(env, target);
Sign::Initialize(env, target);
Verify::Initialize(env, target);
Certificate::Initialize(env, target);
env->SetMethod(target, "certVerifySpkac", VerifySpkac);
env->SetMethod(target, "certExportPublicKey", ExportPublicKey);
env->SetMethod(target, "certExportChallenge", ExportChallenge);
#ifndef OPENSSL_NO_ENGINE
env->SetMethod(target, "setEngine", SetEngine);
#endif // !OPENSSL_NO_ENGINE

23
src/node_crypto.h
View File

@ -732,29 +732,6 @@ class ECDH : public BaseObject {
const EC_GROUP* group_;
};
class Certificate : public AsyncWrap {
public:
static void Initialize(Environment* env, v8::Local<v8::Object> target);
v8::Local<v8::Value> CertificateInit(const char* sign_type);
bool VerifySpkac(const char* data, unsigned int len);
const char* ExportPublicKey(const char* data, int len);
const char* ExportChallenge(const char* data, int len);
size_t self_size() const override { return sizeof(*this); }
protected:
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
static void VerifySpkac(const v8::FunctionCallbackInfo<v8::Value>& args);
static void ExportPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
static void ExportChallenge(const v8::FunctionCallbackInfo<v8::Value>& args);
Certificate(Environment* env, v8::Local<v8::Object> wrap)
: AsyncWrap(env, wrap, AsyncWrap::PROVIDER_CRYPTO) {
MakeWeak<Certificate>(this);
}
};
bool EntropySource(unsigned char* buffer, size_t length);
#ifndef OPENSSL_NO_ENGINE
void SetEngine(const v8::FunctionCallbackInfo<v8::Value>& args);