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

crypto: split crypto classes

Browse Source
This commit is contained in:
Fedor Indutny 2013-03-12 01:59:46 +04:00
parent 66280de133
commit a15cc93ae3
2 changed files with 1581 additions and 1443 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

344
src/node_crypto.cc
View File

@ -2036,9 +2036,7 @@ Handle<Value> Connection::SetSNICallback(const Arguments& args) {
#endif #endif
class Cipher : public ObjectWrap { void Cipher::Initialize(v8::Handle<v8::Object> target) {
public:
static void Initialize (v8::Handle<v8::Object> target) {
HandleScope scope; HandleScope scope;
Local<FunctionTemplate> t = FunctionTemplate::New(New); Local<FunctionTemplate> t = FunctionTemplate::New(New);
@ -2055,7 +2053,7 @@ class Cipher : public ObjectWrap {
} }
bool CipherInit(char* cipherType, char* key_buf, int key_buf_len) { bool Cipher:: CipherInit(char* cipherType, char* key_buf, int key_buf_len) {
cipher = EVP_get_cipherbyname(cipherType); cipher = EVP_get_cipherbyname(cipherType);
if(!cipher) { if(!cipher) {
fprintf(stderr, "node-crypto : Unknown cipher %s\n", cipherType); fprintf(stderr, "node-crypto : Unknown cipher %s\n", cipherType);
@ -2081,7 +2079,7 @@ class Cipher : public ObjectWrap {
} }
bool CipherInitIv(char* cipherType, bool Cipher::CipherInitIv(char* cipherType,
char* key, char* key,
int key_len, int key_len,
char* iv, char* iv,
@ -2112,19 +2110,25 @@ class Cipher : public ObjectWrap {
return true; return true;
} }
int CipherUpdate(char* data, int len, unsigned char** out, int* out_len) {
int Cipher::CipherUpdate(char* data,
int len,
unsigned char** out,
int* out_len) {
if (!initialised_) return 0; if (!initialised_) return 0;
*out_len=len+EVP_CIPHER_CTX_block_size(&ctx); *out_len=len+EVP_CIPHER_CTX_block_size(&ctx);
*out= new unsigned char[*out_len]; *out= new unsigned char[*out_len];
return EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len); return EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len);
} }
int SetAutoPadding(bool auto_padding) {
int Cipher::SetAutoPadding(bool auto_padding) {
if (!initialised_) return 0; if (!initialised_) return 0;
return EVP_CIPHER_CTX_set_padding(&ctx, auto_padding ? 1 : 0); return EVP_CIPHER_CTX_set_padding(&ctx, auto_padding ? 1 : 0);
} }
int CipherFinal(unsigned char** out, int *out_len) {
int Cipher::CipherFinal(unsigned char** out, int *out_len) {
if (!initialised_) return 0; if (!initialised_) return 0;
*out = new unsigned char[EVP_CIPHER_CTX_block_size(&ctx)]; *out = new unsigned char[EVP_CIPHER_CTX_block_size(&ctx)];
int r = EVP_CipherFinal_ex(&ctx,*out, out_len); int r = EVP_CipherFinal_ex(&ctx,*out, out_len);
@ -2134,9 +2138,7 @@ class Cipher : public ObjectWrap {
} }
protected: Handle<Value> Cipher::New(const Arguments& args) {
static Handle<Value> New(const Arguments& args) {
HandleScope scope; HandleScope scope;
Cipher *cipher = new Cipher(); Cipher *cipher = new Cipher();
@ -2144,7 +2146,7 @@ class Cipher : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> CipherInit(const Arguments& args) { Handle<Value> Cipher::CipherInit(const Arguments& args) {
HandleScope scope; HandleScope scope;
Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This()); Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());
@ -2181,7 +2183,7 @@ class Cipher : public ObjectWrap {
} }
static Handle<Value> CipherInitIv(const Arguments& args) { Handle<Value> Cipher::CipherInitIv(const Arguments& args) {
Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This()); Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());
HandleScope scope; HandleScope scope;
@ -2232,7 +2234,8 @@ class Cipher : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> CipherUpdate(const Arguments& args) {
Handle<Value> Cipher::CipherUpdate(const Arguments& args) {
Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This()); Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());
HandleScope scope; HandleScope scope;
@ -2259,7 +2262,8 @@ class Cipher : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
static Handle<Value> SetAutoPadding(const Arguments& args) {
Handle<Value> Cipher::SetAutoPadding(const Arguments& args) {
HandleScope scope; HandleScope scope;
Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This()); Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());
@ -2268,7 +2272,8 @@ class Cipher : public ObjectWrap {
return Undefined(); return Undefined();
} }
static Handle<Value> CipherFinal(const Arguments& args) {
Handle<Value> Cipher::CipherFinal(const Arguments& args) {
Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This()); Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());
HandleScope scope; HandleScope scope;
@ -2291,31 +2296,8 @@ class Cipher : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
Cipher () : ObjectWrap ()
{
initialised_ = false;
}
~Cipher () { void Decipher::Initialize(v8::Handle<v8::Object> target) {
if (initialised_) {
EVP_CIPHER_CTX_cleanup(&ctx);
}
}
private:
EVP_CIPHER_CTX ctx; /* coverity[member_decl] */
const EVP_CIPHER *cipher; /* coverity[member_decl] */
bool initialised_;
};
class Decipher : public ObjectWrap {
public:
static void
Initialize (v8::Handle<v8::Object> target)
{
HandleScope scope; HandleScope scope;
Local<FunctionTemplate> t = FunctionTemplate::New(New); Local<FunctionTemplate> t = FunctionTemplate::New(New);
@ -2332,7 +2314,8 @@ class Decipher : public ObjectWrap {
target->Set(String::NewSymbol("Decipher"), t->GetFunction()); target->Set(String::NewSymbol("Decipher"), t->GetFunction());
} }
bool DecipherInit(char* cipherType, char* key_buf, int key_buf_len) {
bool Decipher::DecipherInit(char* cipherType, char* key_buf, int key_buf_len) {
cipher_ = EVP_get_cipherbyname(cipherType); cipher_ = EVP_get_cipherbyname(cipherType);
if(!cipher_) { if(!cipher_) {
@ -2365,7 +2348,7 @@ class Decipher : public ObjectWrap {
} }
bool DecipherInitIv(char* cipherType, bool Decipher::DecipherInitIv(char* cipherType,
char* key, char* key,
int key_len, int key_len,
char* iv, char* iv,
@ -2396,7 +2379,11 @@ class Decipher : public ObjectWrap {
return true; return true;
} }
int DecipherUpdate(char* data, int len, unsigned char** out, int* out_len) {
int Decipher::DecipherUpdate(char* data,
int len,
unsigned char** out,
int* out_len) {
if (!initialised_) { if (!initialised_) {
*out_len = 0; *out_len = 0;
*out = NULL; *out = NULL;
@ -2409,13 +2396,14 @@ class Decipher : public ObjectWrap {
return EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len); return EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len);
} }
int SetAutoPadding(bool auto_padding) {
int Decipher::SetAutoPadding(bool auto_padding) {
if (!initialised_) return 0; if (!initialised_) return 0;
return EVP_CIPHER_CTX_set_padding(&ctx, auto_padding ? 1 : 0); return EVP_CIPHER_CTX_set_padding(&ctx, auto_padding ? 1 : 0);
} }
// coverity[alloc_arg]
int DecipherFinal(unsigned char** out, int *out_len) { int Decipher::DecipherFinal(unsigned char** out, int *out_len) {
int r; int r;
if (!initialised_) { if (!initialised_) {
@ -2432,9 +2420,7 @@ class Decipher : public ObjectWrap {
} }
protected: Handle<Value> Decipher::New(const Arguments& args) {
static Handle<Value> New (const Arguments& args) {
HandleScope scope; HandleScope scope;
Decipher *cipher = new Decipher(); Decipher *cipher = new Decipher();
@ -2442,7 +2428,8 @@ class Decipher : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> DecipherInit(const Arguments& args) {
Handle<Value> Decipher::DecipherInit(const Arguments& args) {
Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This()); Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This());
HandleScope scope; HandleScope scope;
@ -2480,7 +2467,8 @@ class Decipher : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> DecipherInitIv(const Arguments& args) {
Handle<Value> Decipher::DecipherInitIv(const Arguments& args) {
Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This()); Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This());
HandleScope scope; HandleScope scope;
@ -2532,7 +2520,8 @@ class Decipher : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> DecipherUpdate(const Arguments& args) {
Handle<Value> Decipher::DecipherUpdate(const Arguments& args) {
HandleScope scope; HandleScope scope;
Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This()); Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This());
@ -2569,7 +2558,8 @@ class Decipher : public ObjectWrap {
} }
static Handle<Value> SetAutoPadding(const Arguments& args) {
Handle<Value> Decipher::SetAutoPadding(const Arguments& args) {
HandleScope scope; HandleScope scope;
Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This()); Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This());
@ -2578,7 +2568,8 @@ class Decipher : public ObjectWrap {
return Undefined(); return Undefined();
} }
static Handle<Value> DecipherFinal(const Arguments& args) {
Handle<Value> Decipher::DecipherFinal(const Arguments& args) {
HandleScope scope; HandleScope scope;
Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This()); Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This());
@ -2600,29 +2591,8 @@ class Decipher : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
Decipher () : ObjectWrap () {
initialised_ = false;
}
~Decipher () { void Hmac::Initialize(v8::Handle<v8::Object> target) {
if (initialised_) {
EVP_CIPHER_CTX_cleanup(&ctx);
}
}
private:
EVP_CIPHER_CTX ctx;
const EVP_CIPHER *cipher_;
bool initialised_;
};
class Hmac : public ObjectWrap {
public:
static void Initialize (v8::Handle<v8::Object> target) {
HandleScope scope; HandleScope scope;
Local<FunctionTemplate> t = FunctionTemplate::New(New); Local<FunctionTemplate> t = FunctionTemplate::New(New);
@ -2636,7 +2606,8 @@ class Hmac : public ObjectWrap {
target->Set(String::NewSymbol("Hmac"), t->GetFunction()); target->Set(String::NewSymbol("Hmac"), t->GetFunction());
} }
bool HmacInit(char* hashType, char* key, int key_len) {
bool Hmac::HmacInit(char* hashType, char* key, int key_len) {
md = EVP_get_digestbyname(hashType); md = EVP_get_digestbyname(hashType);
if(!md) { if(!md) {
fprintf(stderr, "node-crypto : Unknown message digest %s\n", hashType); fprintf(stderr, "node-crypto : Unknown message digest %s\n", hashType);
@ -2653,13 +2624,15 @@ class Hmac : public ObjectWrap {
} }
int HmacUpdate(char* data, int len) {
int Hmac::HmacUpdate(char* data, int len) {
if (!initialised_) return 0; if (!initialised_) return 0;
HMAC_Update(&ctx, (unsigned char*)data, len); HMAC_Update(&ctx, (unsigned char*)data, len);
return 1; return 1;
} }
int HmacDigest(unsigned char** md_value, unsigned int *md_len) {
int Hmac::HmacDigest(unsigned char** md_value, unsigned int *md_len) {
if (!initialised_) return 0; if (!initialised_) return 0;
*md_value = new unsigned char[EVP_MAX_MD_SIZE]; *md_value = new unsigned char[EVP_MAX_MD_SIZE];
HMAC_Final(&ctx, *md_value, md_len); HMAC_Final(&ctx, *md_value, md_len);
@ -2669,9 +2642,7 @@ class Hmac : public ObjectWrap {
} }
protected: Handle<Value> Hmac::New(const Arguments& args) {
static Handle<Value> New (const Arguments& args) {
HandleScope scope; HandleScope scope;
Hmac *hmac = new Hmac(); Hmac *hmac = new Hmac();
@ -2679,7 +2650,8 @@ class Hmac : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> HmacInit(const Arguments& args) {
Handle<Value> Hmac::HmacInit(const Arguments& args) {
Hmac *hmac = ObjectWrap::Unwrap<Hmac>(args.This()); Hmac *hmac = ObjectWrap::Unwrap<Hmac>(args.This());
HandleScope scope; HandleScope scope;
@ -2723,7 +2695,8 @@ class Hmac : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> HmacUpdate(const Arguments& args) {
Handle<Value> Hmac::HmacUpdate(const Arguments& args) {
Hmac *hmac = ObjectWrap::Unwrap<Hmac>(args.This()); Hmac *hmac = ObjectWrap::Unwrap<Hmac>(args.This());
HandleScope scope; HandleScope scope;
@ -2745,7 +2718,8 @@ class Hmac : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> HmacDigest(const Arguments& args) {
Handle<Value> Hmac::HmacDigest(const Arguments& args) {
Hmac *hmac = ObjectWrap::Unwrap<Hmac>(args.This()); Hmac *hmac = ObjectWrap::Unwrap<Hmac>(args.This());
HandleScope scope; HandleScope scope;
@ -2766,27 +2740,8 @@ class Hmac : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
Hmac () : ObjectWrap () {
initialised_ = false;
}
~Hmac () { void Hash::Initialize(v8::Handle<v8::Object> target) {
if (initialised_) {
HMAC_CTX_cleanup(&ctx);
}
}
private:
HMAC_CTX ctx; /* coverity[member_decl] */
const EVP_MD *md; /* coverity[member_decl] */
bool initialised_;
};
class Hash : public ObjectWrap {
public:
static void Initialize (v8::Handle<v8::Object> target) {
HandleScope scope; HandleScope scope;
Local<FunctionTemplate> t = FunctionTemplate::New(New); Local<FunctionTemplate> t = FunctionTemplate::New(New);
@ -2799,7 +2754,8 @@ class Hash : public ObjectWrap {
target->Set(String::NewSymbol("Hash"), t->GetFunction()); target->Set(String::NewSymbol("Hash"), t->GetFunction());
} }
bool HashInit (const char* hashType) {
bool Hash::HashInit(const char* hashType) {
md = EVP_get_digestbyname(hashType); md = EVP_get_digestbyname(hashType);
if(!md) return false; if(!md) return false;
EVP_MD_CTX_init(&mdctx); EVP_MD_CTX_init(&mdctx);
@ -2808,16 +2764,15 @@ class Hash : public ObjectWrap {
return true; return true;
} }
int HashUpdate(char* data, int len) {
int Hash::HashUpdate(char* data, int len) {
if (!initialised_) return 0; if (!initialised_) return 0;
EVP_DigestUpdate(&mdctx, data, len); EVP_DigestUpdate(&mdctx, data, len);
return 1; return 1;
} }
protected: Handle<Value> Hash::New(const Arguments& args) {
static Handle<Value> New (const Arguments& args) {
HandleScope scope; HandleScope scope;
if (args.Length() == 0 || !args[0]->IsString()) { if (args.Length() == 0 || !args[0]->IsString()) {
@ -2838,7 +2793,8 @@ class Hash : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> HashUpdate(const Arguments& args) {
Handle<Value> Hash::HashUpdate(const Arguments& args) {
HandleScope scope; HandleScope scope;
Hash *hash = ObjectWrap::Unwrap<Hash>(args.This()); Hash *hash = ObjectWrap::Unwrap<Hash>(args.This());
@ -2859,7 +2815,8 @@ class Hash : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> HashDigest(const Arguments& args) {
Handle<Value> Hash::HashDigest(const Arguments& args) {
HandleScope scope; HandleScope scope;
Hash *hash = ObjectWrap::Unwrap<Hash>(args.This()); Hash *hash = ObjectWrap::Unwrap<Hash>(args.This());
@ -2882,27 +2839,8 @@ class Hash : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
Hash () : ObjectWrap () {
initialised_ = false;
}
~Hash () { void Sign::Initialize(v8::Handle<v8::Object> target) {
if (initialised_) {
EVP_MD_CTX_cleanup(&mdctx);
}
}
private:
EVP_MD_CTX mdctx; /* coverity[member_decl] */
const EVP_MD *md; /* coverity[member_decl] */
bool initialised_;
};
class Sign : public ObjectWrap {
public:
static void
Initialize (v8::Handle<v8::Object> target) {
HandleScope scope; HandleScope scope;
Local<FunctionTemplate> t = FunctionTemplate::New(New); Local<FunctionTemplate> t = FunctionTemplate::New(New);
@ -2916,7 +2854,8 @@ class Sign : public ObjectWrap {
target->Set(String::NewSymbol("Sign"), t->GetFunction()); target->Set(String::NewSymbol("Sign"), t->GetFunction());
} }
bool SignInit (const char* signType) {
bool Sign::SignInit(const char* signType) {
md = EVP_get_digestbyname(signType); md = EVP_get_digestbyname(signType);
if(!md) { if(!md) {
printf("Unknown message digest %s\n", signType); printf("Unknown message digest %s\n", signType);
@ -2929,13 +2868,15 @@ class Sign : public ObjectWrap {
} }
int SignUpdate(char* data, int len) {
int Sign::SignUpdate(char* data, int len) {
if (!initialised_) return 0; if (!initialised_) return 0;
EVP_SignUpdate(&mdctx, data, len); EVP_SignUpdate(&mdctx, data, len);
return 1; return 1;
} }
int SignFinal(unsigned char** md_value,
int Sign::SignFinal(unsigned char** md_value,
unsigned int *md_len, unsigned int *md_len,
char* key_pem, char* key_pem,
int key_pemLen) { int key_pemLen) {
@ -2958,9 +2899,7 @@ class Sign : public ObjectWrap {
} }
protected: Handle<Value> Sign::New(const Arguments& args) {
static Handle<Value> New (const Arguments& args) {
HandleScope scope; HandleScope scope;
Sign *sign = new Sign(); Sign *sign = new Sign();
@ -2969,7 +2908,8 @@ class Sign : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> SignInit(const Arguments& args) {
Handle<Value> Sign::SignInit(const Arguments& args) {
HandleScope scope; HandleScope scope;
Sign *sign = ObjectWrap::Unwrap<Sign>(args.This()); Sign *sign = ObjectWrap::Unwrap<Sign>(args.This());
@ -2990,7 +2930,8 @@ class Sign : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> SignUpdate(const Arguments& args) {
Handle<Value> Sign::SignUpdate(const Arguments& args) {
Sign *sign = ObjectWrap::Unwrap<Sign>(args.This()); Sign *sign = ObjectWrap::Unwrap<Sign>(args.This());
HandleScope scope; HandleScope scope;
@ -3012,7 +2953,8 @@ class Sign : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> SignFinal(const Arguments& args) {
Handle<Value> Sign::SignFinal(const Arguments& args) {
Sign *sign = ObjectWrap::Unwrap<Sign>(args.This()); Sign *sign = ObjectWrap::Unwrap<Sign>(args.This());
HandleScope scope; HandleScope scope;
@ -3045,26 +2987,8 @@ class Sign : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
Sign () : ObjectWrap () {
initialised_ = false;
}
~Sign () { void Verify::Initialize(v8::Handle<v8::Object> target) {
if (initialised_) {
EVP_MD_CTX_cleanup(&mdctx);
}
}
private:
EVP_MD_CTX mdctx; /* coverity[member_decl] */
const EVP_MD *md; /* coverity[member_decl] */
bool initialised_;
};
class Verify : public ObjectWrap {
public:
static void Initialize (v8::Handle<v8::Object> target) {
HandleScope scope; HandleScope scope;
Local<FunctionTemplate> t = FunctionTemplate::New(New); Local<FunctionTemplate> t = FunctionTemplate::New(New);
@ -3079,7 +3003,7 @@ class Verify : public ObjectWrap {
} }
bool VerifyInit (const char* verifyType) { bool Verify::VerifyInit(const char* verifyType) {
md = EVP_get_digestbyname(verifyType); md = EVP_get_digestbyname(verifyType);
if(!md) { if(!md) {
fprintf(stderr, "node-crypto : Unknown message digest %s\n", verifyType); fprintf(stderr, "node-crypto : Unknown message digest %s\n", verifyType);
@ -3092,14 +3016,17 @@ class Verify : public ObjectWrap {
} }
int VerifyUpdate(char* data, int len) { int Verify::VerifyUpdate(char* data, int len) {
if (!initialised_) return 0; if (!initialised_) return 0;
EVP_VerifyUpdate(&mdctx, data, len); EVP_VerifyUpdate(&mdctx, data, len);
return 1; return 1;
} }
int VerifyFinal(char* key_pem, int key_pemLen, unsigned char* sig, int siglen) { int Verify::VerifyFinal(char* key_pem,
int key_pemLen,
unsigned char* sig,
int siglen) {
if (!initialised_) return 0; if (!initialised_) return 0;
EVP_PKEY* pkey = NULL; EVP_PKEY* pkey = NULL;
@ -3167,9 +3094,7 @@ class Verify : public ObjectWrap {
} }
protected: Handle<Value> Verify::New(const Arguments& args) {
static Handle<Value> New (const Arguments& args) {
HandleScope scope; HandleScope scope;
Verify *verify = new Verify(); Verify *verify = new Verify();
@ -3179,7 +3104,7 @@ class Verify : public ObjectWrap {
} }
static Handle<Value> VerifyInit(const Arguments& args) { Handle<Value> Verify::VerifyInit(const Arguments& args) {
Verify *verify = ObjectWrap::Unwrap<Verify>(args.This()); Verify *verify = ObjectWrap::Unwrap<Verify>(args.This());
HandleScope scope; HandleScope scope;
@ -3201,7 +3126,7 @@ class Verify : public ObjectWrap {
} }
static Handle<Value> VerifyUpdate(const Arguments& args) { Handle<Value> Verify::VerifyUpdate(const Arguments& args) {
HandleScope scope; HandleScope scope;
Verify *verify = ObjectWrap::Unwrap<Verify>(args.This()); Verify *verify = ObjectWrap::Unwrap<Verify>(args.This());
@ -3224,7 +3149,7 @@ class Verify : public ObjectWrap {
} }
static Handle<Value> VerifyFinal(const Arguments& args) { Handle<Value> Verify::VerifyFinal(const Arguments& args) {
HandleScope scope; HandleScope scope;
Verify *verify = ObjectWrap::Unwrap<Verify>(args.This()); Verify *verify = ObjectWrap::Unwrap<Verify>(args.This());
@ -3264,27 +3189,8 @@ class Verify : public ObjectWrap {
return Boolean::New(r && r != -1); return Boolean::New(r && r != -1);
} }
Verify () : ObjectWrap () {
initialised_ = false;
}
~Verify () { void DiffieHellman::Initialize(v8::Handle<v8::Object> target) {
if (initialised_) {
EVP_MD_CTX_cleanup(&mdctx);
}
}
private:
EVP_MD_CTX mdctx; /* coverity[member_decl] */
const EVP_MD *md; /* coverity[member_decl] */
bool initialised_;
};
class DiffieHellman : public ObjectWrap {
public:
static void Initialize(v8::Handle<v8::Object> target) {
HandleScope scope; HandleScope scope;
Local<FunctionTemplate> t = FunctionTemplate::New(New); Local<FunctionTemplate> t = FunctionTemplate::New(New);
@ -3315,7 +3221,8 @@ class DiffieHellman : public ObjectWrap {
target->Set(String::NewSymbol("DiffieHellmanGroup"), t2->GetFunction()); target->Set(String::NewSymbol("DiffieHellmanGroup"), t2->GetFunction());
} }
bool Init(int primeLength) {
bool DiffieHellman::Init(int primeLength) {
dh = DH_new(); dh = DH_new();
DH_generate_parameters_ex(dh, primeLength, DH_GENERATOR_2, 0); DH_generate_parameters_ex(dh, primeLength, DH_GENERATOR_2, 0);
bool result = VerifyContext(); bool result = VerifyContext();
@ -3324,7 +3231,8 @@ class DiffieHellman : public ObjectWrap {
return true; return true;
} }
bool Init(unsigned char* p, int p_len) {
bool DiffieHellman::Init(unsigned char* p, int p_len) {
dh = DH_new(); dh = DH_new();
dh->p = BN_bin2bn(p, p_len, 0); dh->p = BN_bin2bn(p, p_len, 0);
dh->g = BN_new(); dh->g = BN_new();
@ -3335,7 +3243,11 @@ class DiffieHellman : public ObjectWrap {
return true; return true;
} }
bool Init(unsigned char* p, int p_len, unsigned char* g, int g_len) {
bool DiffieHellman::Init(unsigned char* p,
int p_len,
unsigned char* g,
int g_len) {
dh = DH_new(); dh = DH_new();
dh->p = BN_bin2bn(p, p_len, 0); dh->p = BN_bin2bn(p, p_len, 0);
dh->g = BN_bin2bn(g, g_len, 0); dh->g = BN_bin2bn(g, g_len, 0);
@ -3343,8 +3255,8 @@ class DiffieHellman : public ObjectWrap {
return true; return true;
} }
protected:
static Handle<Value> DiffieHellmanGroup(const Arguments& args) { Handle<Value> DiffieHellman::DiffieHellmanGroup(const Arguments& args) {
HandleScope scope; HandleScope scope;
DiffieHellman* diffieHellman = new DiffieHellman(); DiffieHellman* diffieHellman = new DiffieHellman();
@ -3377,7 +3289,8 @@ class DiffieHellman : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> New(const Arguments& args) {
Handle<Value> DiffieHellman::New(const Arguments& args) {
HandleScope scope; HandleScope scope;
DiffieHellman* diffieHellman = new DiffieHellman(); DiffieHellman* diffieHellman = new DiffieHellman();
@ -3403,7 +3316,8 @@ class DiffieHellman : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> GenerateKeys(const Arguments& args) {
Handle<Value> DiffieHellman::GenerateKeys(const Arguments& args) {
DiffieHellman* diffieHellman = DiffieHellman* diffieHellman =
ObjectWrap::Unwrap<DiffieHellman>(args.This()); ObjectWrap::Unwrap<DiffieHellman>(args.This());
@ -3432,7 +3346,8 @@ class DiffieHellman : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
static Handle<Value> GetPrime(const Arguments& args) {
Handle<Value> DiffieHellman::GetPrime(const Arguments& args) {
DiffieHellman* diffieHellman = DiffieHellman* diffieHellman =
ObjectWrap::Unwrap<DiffieHellman>(args.This()); ObjectWrap::Unwrap<DiffieHellman>(args.This());
@ -3455,7 +3370,8 @@ class DiffieHellman : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
static Handle<Value> GetGenerator(const Arguments& args) {
Handle<Value> DiffieHellman::GetGenerator(const Arguments& args) {
DiffieHellman* diffieHellman = DiffieHellman* diffieHellman =
ObjectWrap::Unwrap<DiffieHellman>(args.This()); ObjectWrap::Unwrap<DiffieHellman>(args.This());
@ -3478,7 +3394,8 @@ class DiffieHellman : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
static Handle<Value> GetPublicKey(const Arguments& args) {
Handle<Value> DiffieHellman::GetPublicKey(const Arguments& args) {
DiffieHellman* diffieHellman = DiffieHellman* diffieHellman =
ObjectWrap::Unwrap<DiffieHellman>(args.This()); ObjectWrap::Unwrap<DiffieHellman>(args.This());
@ -3507,7 +3424,8 @@ class DiffieHellman : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
static Handle<Value> GetPrivateKey(const Arguments& args) {
Handle<Value> DiffieHellman::GetPrivateKey(const Arguments& args) {
DiffieHellman* diffieHellman = DiffieHellman* diffieHellman =
ObjectWrap::Unwrap<DiffieHellman>(args.This()); ObjectWrap::Unwrap<DiffieHellman>(args.This());
@ -3536,7 +3454,8 @@ class DiffieHellman : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
static Handle<Value> ComputeSecret(const Arguments& args) {
Handle<Value> DiffieHellman::ComputeSecret(const Arguments& args) {
HandleScope scope; HandleScope scope;
DiffieHellman* diffieHellman = DiffieHellman* diffieHellman =
@ -3609,7 +3528,8 @@ class DiffieHellman : public ObjectWrap {
return scope.Close(outString); return scope.Close(outString);
} }
static Handle<Value> SetPublicKey(const Arguments& args) {
Handle<Value> DiffieHellman::SetPublicKey(const Arguments& args) {
HandleScope scope; HandleScope scope;
DiffieHellman* diffieHellman = DiffieHellman* diffieHellman =
@ -3633,7 +3553,8 @@ class DiffieHellman : public ObjectWrap {
return args.This(); return args.This();
} }
static Handle<Value> SetPrivateKey(const Arguments& args) {
Handle<Value> DiffieHellman::SetPrivateKey(const Arguments& args) {
HandleScope scope; HandleScope scope;
DiffieHellman* diffieHellman = DiffieHellman* diffieHellman =
@ -3658,19 +3579,8 @@ class DiffieHellman : public ObjectWrap {
return args.This(); return args.This();
} }
DiffieHellman() : ObjectWrap() {
initialised_ = false;
dh = NULL;
}
~DiffieHellman() { bool DiffieHellman::VerifyContext() {
if (dh != NULL) {
DH_free(dh);
}
}
private:
bool VerifyContext() {
int codes; int codes;
if (!DH_check(dh, &codes)) return false; if (!DH_check(dh, &codes)) return false;
if (codes & DH_CHECK_P_NOT_SAFE_PRIME) return false; if (codes & DH_CHECK_P_NOT_SAFE_PRIME) return false;
@ -3680,10 +3590,6 @@ class DiffieHellman : public ObjectWrap {
return true; return true;
} }
bool initialised_;
DH* dh;
};
struct pbkdf2_req { struct pbkdf2_req {
uv_work_t work_req; uv_work_t work_req;

232
src/node_crypto.h
View File

@ -276,6 +276,238 @@ class Connection : ObjectWrap {
friend class SecureContext; friend class SecureContext;
}; };
class Cipher : public ObjectWrap {
public:
static void Initialize (v8::Handle<v8::Object> target);
bool CipherInit(char* cipherType, char* key_buf, int key_buf_len);
bool CipherInitIv(char* cipherType,
char* key,
int key_len,
char* iv,
int iv_len);
int CipherUpdate(char* data, int len, unsigned char** out, int* out_len);
int SetAutoPadding(bool auto_padding);
int CipherFinal(unsigned char** out, int *out_len);
protected:
static v8::Handle<v8::Value> New(const v8::Arguments& args);
static v8::Handle<v8::Value> CipherInit(const v8::Arguments& args);
static v8::Handle<v8::Value> CipherInitIv(const v8::Arguments& args);
static v8::Handle<v8::Value> CipherUpdate(const v8::Arguments& args);
static v8::Handle<v8::Value> SetAutoPadding(const v8::Arguments& args);
static v8::Handle<v8::Value> CipherFinal(const v8::Arguments& args);
Cipher() : ObjectWrap(), initialised_(false) {
}
~Cipher() {
if (initialised_) {
EVP_CIPHER_CTX_cleanup(&ctx);
}
}
private:
EVP_CIPHER_CTX ctx; /* coverity[member_decl] */
const EVP_CIPHER *cipher; /* coverity[member_decl] */
bool initialised_;
};
class Decipher : public ObjectWrap {
public:
static void Initialize(v8::Handle<v8::Object> target);
bool DecipherInit(char* cipherType, char* key_buf, int key_buf_len);
bool DecipherInitIv(char* cipherType,
char* key,
int key_len,
char* iv,
int iv_len);
int DecipherUpdate(char* data, int len, unsigned char** out, int* out_len);
int SetAutoPadding(bool auto_padding);
int DecipherFinal(unsigned char** out, int *out_len);
protected:
static v8::Handle<v8::Value> New(const v8::Arguments& args);
static v8::Handle<v8::Value> DecipherInit(const v8::Arguments& args);
static v8::Handle<v8::Value> DecipherInitIv(const v8::Arguments& args);
static v8::Handle<v8::Value> DecipherUpdate(const v8::Arguments& args);
static v8::Handle<v8::Value> SetAutoPadding(const v8::Arguments& args);
static v8::Handle<v8::Value> DecipherFinal(const v8::Arguments& args);
Decipher() : ObjectWrap(), initialised_(false) {
}
~Decipher() {
if (initialised_) {
EVP_CIPHER_CTX_cleanup(&ctx);
}
}
private:
EVP_CIPHER_CTX ctx;
const EVP_CIPHER *cipher_;
bool initialised_;
};
class Hmac : public ObjectWrap {
public:
static void Initialize (v8::Handle<v8::Object> target);
bool HmacInit(char* hashType, char* key, int key_len);
int HmacUpdate(char* data, int len);
int HmacDigest(unsigned char** md_value, unsigned int *md_len);
protected:
static v8::Handle<v8::Value> New(const v8::Arguments& args);
static v8::Handle<v8::Value> HmacInit(const v8::Arguments& args);
static v8::Handle<v8::Value> HmacUpdate(const v8::Arguments& args);
static v8::Handle<v8::Value> HmacDigest(const v8::Arguments& args);
Hmac() : ObjectWrap(), initialised_(false) {
}
~Hmac() {
if (initialised_) {
HMAC_CTX_cleanup(&ctx);
}
}
private:
HMAC_CTX ctx; /* coverity[member_decl] */
const EVP_MD *md; /* coverity[member_decl] */
bool initialised_;
};
class Hash : public ObjectWrap {
public:
static void Initialize (v8::Handle<v8::Object> target);
bool HashInit (const char* hashType);
int HashUpdate(char* data, int len);
protected:
static v8::Handle<v8::Value> New(const v8::Arguments& args);
static v8::Handle<v8::Value> HashUpdate(const v8::Arguments& args);
static v8::Handle<v8::Value> HashDigest(const v8::Arguments& args);
Hash() : ObjectWrap(), initialised_(false) {
}
~Hash() {
if (initialised_) {
EVP_MD_CTX_cleanup(&mdctx);
}
}
private:
EVP_MD_CTX mdctx; /* coverity[member_decl] */
const EVP_MD *md; /* coverity[member_decl] */
bool initialised_;
};
class Sign : public ObjectWrap {
public:
static void Initialize(v8::Handle<v8::Object> target);
bool SignInit (const char* signType);
int SignUpdate(char* data, int len);
int SignFinal(unsigned char** md_value,
unsigned int *md_len,
char* key_pem,
int key_pemLen);
protected:
static v8::Handle<v8::Value> New(const v8::Arguments& args);
static v8::Handle<v8::Value> SignInit(const v8::Arguments& args);
static v8::Handle<v8::Value> SignUpdate(const v8::Arguments& args);
static v8::Handle<v8::Value> SignFinal(const v8::Arguments& args);
Sign() : ObjectWrap(), initialised_(false) {
}
~Sign () {
if (initialised_) {
EVP_MD_CTX_cleanup(&mdctx);
}
}
private:
EVP_MD_CTX mdctx; /* coverity[member_decl] */
const EVP_MD *md; /* coverity[member_decl] */
bool initialised_;
};
class Verify : public ObjectWrap {
public:
static void Initialize (v8::Handle<v8::Object> target);
bool VerifyInit (const char* verifyType);
int VerifyUpdate(char* data, int len);
int VerifyFinal(char* key_pem,
int key_pemLen,
unsigned char* sig,
int siglen);
protected:
static v8::Handle<v8::Value> New (const v8::Arguments& args);
static v8::Handle<v8::Value> VerifyInit(const v8::Arguments& args);
static v8::Handle<v8::Value> VerifyUpdate(const v8::Arguments& args);
static v8::Handle<v8::Value> VerifyFinal(const v8::Arguments& args);
Verify() : ObjectWrap(), initialised_(false) {
}
~Verify() {
if (initialised_) {
EVP_MD_CTX_cleanup(&mdctx);
}
}
private:
EVP_MD_CTX mdctx; /* coverity[member_decl] */
const EVP_MD *md; /* coverity[member_decl] */
bool initialised_;
};
class DiffieHellman : public ObjectWrap {
public:
static void Initialize(v8::Handle<v8::Object> target);
bool Init(int primeLength);
bool Init(unsigned char* p, int p_len);
bool Init(unsigned char* p, int p_len, unsigned char* g, int g_len);
protected:
static v8::Handle<v8::Value> DiffieHellmanGroup(const v8::Arguments& args);
static v8::Handle<v8::Value> New(const v8::Arguments& args);
static v8::Handle<v8::Value> GenerateKeys(const v8::Arguments& args);
static v8::Handle<v8::Value> GetPrime(const v8::Arguments& args);
static v8::Handle<v8::Value> GetGenerator(const v8::Arguments& args);
static v8::Handle<v8::Value> GetPublicKey(const v8::Arguments& args);
static v8::Handle<v8::Value> GetPrivateKey(const v8::Arguments& args);
static v8::Handle<v8::Value> ComputeSecret(const v8::Arguments& args);
static v8::Handle<v8::Value> SetPublicKey(const v8::Arguments& args);
static v8::Handle<v8::Value> SetPrivateKey(const v8::Arguments& args);
DiffieHellman() : ObjectWrap(), initialised_(false), dh(NULL) {
}
~DiffieHellman() {
if (dh != NULL) {
DH_free(dh);
}
}
private:
bool VerifyContext();
bool initialised_;
DH* dh;
};
void InitCrypto(v8::Handle<v8::Object> target); void InitCrypto(v8::Handle<v8::Object> target);
} // namespace crypto } // namespace crypto