|
@ -636,7 +636,7 @@ static void HexEncode(unsigned char *md_value, |
|
|
char** md_hexdigest, |
|
|
char** md_hexdigest, |
|
|
int* md_hex_len) { |
|
|
int* md_hex_len) { |
|
|
*md_hex_len = (2*(md_len)); |
|
|
*md_hex_len = (2*(md_len)); |
|
|
*md_hexdigest = (char *) malloc(*md_hex_len + 1); |
|
|
*md_hexdigest = new char[*md_hex_len + 1]; |
|
|
for (int i = 0; i < md_len; i++) { |
|
|
for (int i = 0; i < md_len; i++) { |
|
|
sprintf((char *)(*md_hexdigest + (i*2)), "%02x", md_value[i]); |
|
|
sprintf((char *)(*md_hexdigest + (i*2)), "%02x", md_value[i]); |
|
|
} |
|
|
} |
|
@ -650,7 +650,7 @@ static void HexDecode(unsigned char *input, |
|
|
char** buf64, |
|
|
char** buf64, |
|
|
int* buf64_len) { |
|
|
int* buf64_len) { |
|
|
*buf64_len = (length/2); |
|
|
*buf64_len = (length/2); |
|
|
*buf64 = (char*) malloc(length/2 + 1); |
|
|
*buf64 = new char[length/2 + 1]; |
|
|
char *b = *buf64; |
|
|
char *b = *buf64; |
|
|
for(int i = 0; i < length-1; i+=2) { |
|
|
for(int i = 0; i < length-1; i+=2) { |
|
|
b[i/2] = (hex2i(input[i])<<4) | (hex2i(input[i+1])); |
|
|
b[i/2] = (hex2i(input[i])<<4) | (hex2i(input[i+1])); |
|
@ -671,7 +671,7 @@ void base64(unsigned char *input, int length, char** buf64, int* buf64_len) { |
|
|
BIO_get_mem_ptr(b64, &bptr); |
|
|
BIO_get_mem_ptr(b64, &bptr); |
|
|
|
|
|
|
|
|
*buf64_len = bptr->length; |
|
|
*buf64_len = bptr->length; |
|
|
*buf64 = (char *)malloc(*buf64_len+1); |
|
|
*buf64 = new char[*buf64_len+1]; |
|
|
memcpy(*buf64, bptr->data, bptr->length); |
|
|
memcpy(*buf64, bptr->data, bptr->length); |
|
|
char* b = *buf64; |
|
|
char* b = *buf64; |
|
|
b[bptr->length] = 0; |
|
|
b[bptr->length] = 0; |
|
@ -685,7 +685,7 @@ void *unbase64(unsigned char *input, |
|
|
char** buffer, |
|
|
char** buffer, |
|
|
int* buffer_len) { |
|
|
int* buffer_len) { |
|
|
BIO *b64, *bmem; |
|
|
BIO *b64, *bmem; |
|
|
*buffer = (char *)malloc(length); |
|
|
*buffer = new char[length]; |
|
|
memset(*buffer, 0, length); |
|
|
memset(*buffer, 0, length); |
|
|
|
|
|
|
|
|
b64 = BIO_new(BIO_f_base64()); |
|
|
b64 = BIO_new(BIO_f_base64()); |
|
@ -875,7 +875,7 @@ class Cipher : public ObjectWrap { |
|
|
int CipherUpdate(char* data, int len, unsigned char** out, int* out_len) { |
|
|
int 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=(unsigned char*)malloc(*out_len); |
|
|
*out= new unsigned char[*out_len]; |
|
|
|
|
|
|
|
|
EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len); |
|
|
EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len); |
|
|
return 1; |
|
|
return 1; |
|
@ -883,7 +883,7 @@ class Cipher : public ObjectWrap { |
|
|
|
|
|
|
|
|
int CipherFinal(unsigned char** out, int *out_len) { |
|
|
int CipherFinal(unsigned char** out, int *out_len) { |
|
|
if (!initialised_) return 0; |
|
|
if (!initialised_) return 0; |
|
|
*out = (unsigned char*) malloc(EVP_CIPHER_CTX_block_size(&ctx)); |
|
|
*out = new unsigned char[EVP_CIPHER_CTX_block_size(&ctx)]; |
|
|
EVP_CipherFinal(&ctx,*out,out_len); |
|
|
EVP_CipherFinal(&ctx,*out,out_len); |
|
|
EVP_CIPHER_CTX_cleanup(&ctx); |
|
|
EVP_CIPHER_CTX_cleanup(&ctx); |
|
|
initialised_ = false; |
|
|
initialised_ = false; |
|
@ -927,6 +927,8 @@ class Cipher : public ObjectWrap { |
|
|
|
|
|
|
|
|
bool r = cipher->CipherInit(*cipherType, key_buf, key_buf_len); |
|
|
bool r = cipher->CipherInit(*cipherType, key_buf, key_buf_len); |
|
|
|
|
|
|
|
|
|
|
|
delete [] key_buf; |
|
|
|
|
|
|
|
|
return args.This(); |
|
|
return args.This(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -967,6 +969,9 @@ class Cipher : public ObjectWrap { |
|
|
|
|
|
|
|
|
bool r = cipher->CipherInitIv(*cipherType, key_buf,key_len,iv_buf,iv_len); |
|
|
bool r = cipher->CipherInitIv(*cipherType, key_buf,key_len,iv_buf,iv_len); |
|
|
|
|
|
|
|
|
|
|
|
delete [] key_buf; |
|
|
|
|
|
delete [] iv_buf; |
|
|
|
|
|
|
|
|
return args.This(); |
|
|
return args.This(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -992,6 +997,8 @@ class Cipher : public ObjectWrap { |
|
|
int out_len=0; |
|
|
int out_len=0; |
|
|
int r = cipher->CipherUpdate(buf, len,&out,&out_len); |
|
|
int r = cipher->CipherUpdate(buf, len,&out,&out_len); |
|
|
|
|
|
|
|
|
|
|
|
delete [] buf; |
|
|
|
|
|
|
|
|
Local<Value> outString; |
|
|
Local<Value> outString; |
|
|
if (out_len==0) outString=String::New(""); |
|
|
if (out_len==0) outString=String::New(""); |
|
|
else { |
|
|
else { |
|
@ -1006,17 +1013,19 @@ class Cipher : public ObjectWrap { |
|
|
// Hex encoding
|
|
|
// Hex encoding
|
|
|
HexEncode(out, out_len, &out_hexdigest, &out_hex_len); |
|
|
HexEncode(out, out_len, &out_hexdigest, &out_hex_len); |
|
|
outString = Encode(out_hexdigest, out_hex_len, BINARY); |
|
|
outString = Encode(out_hexdigest, out_hex_len, BINARY); |
|
|
free(out_hexdigest); |
|
|
delete [] out_hexdigest; |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
// Base64 encoding
|
|
|
// Base64 encoding
|
|
|
// Check to see if we need to add in previous base64 overhang
|
|
|
// Check to see if we need to add in previous base64 overhang
|
|
|
if (cipher->incomplete_base64!=NULL){ |
|
|
if (cipher->incomplete_base64!=NULL){ |
|
|
unsigned char* complete_base64 = (unsigned char *)malloc(out_len+cipher->incomplete_base64_len+1); |
|
|
unsigned char* complete_base64 = new unsigned char[out_len+cipher->incomplete_base64_len+1]; |
|
|
memcpy(complete_base64, cipher->incomplete_base64, cipher->incomplete_base64_len); |
|
|
memcpy(complete_base64, cipher->incomplete_base64, cipher->incomplete_base64_len); |
|
|
memcpy(&complete_base64[cipher->incomplete_base64_len], out, out_len); |
|
|
memcpy(&complete_base64[cipher->incomplete_base64_len], out, out_len); |
|
|
free(out); |
|
|
delete [] out; |
|
|
free(cipher->incomplete_base64); |
|
|
|
|
|
|
|
|
delete [] cipher->incomplete_base64; |
|
|
cipher->incomplete_base64=NULL; |
|
|
cipher->incomplete_base64=NULL; |
|
|
|
|
|
|
|
|
out=complete_base64; |
|
|
out=complete_base64; |
|
|
out_len += cipher->incomplete_base64_len; |
|
|
out_len += cipher->incomplete_base64_len; |
|
|
} |
|
|
} |
|
@ -1024,7 +1033,7 @@ class Cipher : public ObjectWrap { |
|
|
// Check to see if we need to trim base64 stream
|
|
|
// Check to see if we need to trim base64 stream
|
|
|
if (out_len%3!=0){ |
|
|
if (out_len%3!=0){ |
|
|
cipher->incomplete_base64_len = out_len%3; |
|
|
cipher->incomplete_base64_len = out_len%3; |
|
|
cipher->incomplete_base64 = (char *)malloc(cipher->incomplete_base64_len+1); |
|
|
cipher->incomplete_base64 = new char[cipher->incomplete_base64_len+1]; |
|
|
memcpy(cipher->incomplete_base64, &out[out_len-cipher->incomplete_base64_len], cipher->incomplete_base64_len); |
|
|
memcpy(cipher->incomplete_base64, &out[out_len-cipher->incomplete_base64_len], cipher->incomplete_base64_len); |
|
|
out_len -= cipher->incomplete_base64_len; |
|
|
out_len -= cipher->incomplete_base64_len; |
|
|
out[out_len]=0; |
|
|
out[out_len]=0; |
|
@ -1032,7 +1041,7 @@ class Cipher : public ObjectWrap { |
|
|
|
|
|
|
|
|
base64(out, out_len, &out_hexdigest, &out_hex_len); |
|
|
base64(out, out_len, &out_hexdigest, &out_hex_len); |
|
|
outString = Encode(out_hexdigest, out_hex_len, BINARY); |
|
|
outString = Encode(out_hexdigest, out_hex_len, BINARY); |
|
|
free(out_hexdigest); |
|
|
delete [] out_hexdigest; |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
outString = Encode(out, out_len, BINARY); |
|
|
outString = Encode(out, out_len, BINARY); |
|
|
} else { |
|
|
} else { |
|
@ -1041,7 +1050,7 @@ class Cipher : public ObjectWrap { |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
if (out) free(out); |
|
|
if (out) delete [] out; |
|
|
return scope.Close(outString); |
|
|
return scope.Close(outString); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -1071,11 +1080,11 @@ class Cipher : public ObjectWrap { |
|
|
// Hex encoding
|
|
|
// Hex encoding
|
|
|
HexEncode(out_value, out_len, &out_hexdigest, &out_hex_len); |
|
|
HexEncode(out_value, out_len, &out_hexdigest, &out_hex_len); |
|
|
outString = Encode(out_hexdigest, out_hex_len, BINARY); |
|
|
outString = Encode(out_hexdigest, out_hex_len, BINARY); |
|
|
free(out_hexdigest); |
|
|
delete [] out_hexdigest; |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
base64(out_value, out_len, &out_hexdigest, &out_hex_len); |
|
|
base64(out_value, out_len, &out_hexdigest, &out_hex_len); |
|
|
outString = Encode(out_hexdigest, out_hex_len, BINARY); |
|
|
outString = Encode(out_hexdigest, out_hex_len, BINARY); |
|
|
free(out_hexdigest); |
|
|
delete [] out_hexdigest; |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
outString = Encode(out_value, out_len, BINARY); |
|
|
outString = Encode(out_value, out_len, BINARY); |
|
|
} else { |
|
|
} else { |
|
@ -1083,7 +1092,7 @@ class Cipher : public ObjectWrap { |
|
|
"can be binary, hex or base64\n"); |
|
|
"can be binary, hex or base64\n"); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
free(out_value); |
|
|
delete [] out_value; |
|
|
return scope.Close(outString); |
|
|
return scope.Close(outString); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -1194,7 +1203,7 @@ class Decipher : public ObjectWrap { |
|
|
int DecipherUpdate(char* data, int len, unsigned char** out, int* out_len) { |
|
|
int DecipherUpdate(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=(unsigned char*)malloc(*out_len); |
|
|
*out= new unsigned char[*out_len]; |
|
|
|
|
|
|
|
|
EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len); |
|
|
EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len); |
|
|
return 1; |
|
|
return 1; |
|
@ -1202,7 +1211,7 @@ class Decipher : public ObjectWrap { |
|
|
|
|
|
|
|
|
int DecipherFinal(unsigned char** out, int *out_len, bool tolerate_padding) { |
|
|
int DecipherFinal(unsigned char** out, int *out_len, bool tolerate_padding) { |
|
|
if (!initialised_) return 0; |
|
|
if (!initialised_) return 0; |
|
|
*out = (unsigned char*) malloc(EVP_CIPHER_CTX_block_size(&ctx)); |
|
|
*out = new unsigned char[EVP_CIPHER_CTX_block_size(&ctx)]; |
|
|
if (tolerate_padding) { |
|
|
if (tolerate_padding) { |
|
|
local_EVP_DecryptFinal_ex(&ctx,*out,out_len); |
|
|
local_EVP_DecryptFinal_ex(&ctx,*out,out_len); |
|
|
} else { |
|
|
} else { |
|
@ -1251,6 +1260,8 @@ class Decipher : public ObjectWrap { |
|
|
|
|
|
|
|
|
bool r = cipher->DecipherInit(*cipherType, key_buf,key_len); |
|
|
bool r = cipher->DecipherInit(*cipherType, key_buf,key_len); |
|
|
|
|
|
|
|
|
|
|
|
delete [] key_buf; |
|
|
|
|
|
|
|
|
return args.This(); |
|
|
return args.This(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -1292,6 +1303,9 @@ class Decipher : public ObjectWrap { |
|
|
|
|
|
|
|
|
bool r = cipher->DecipherInitIv(*cipherType, key_buf,key_len,iv_buf,iv_len); |
|
|
bool r = cipher->DecipherInitIv(*cipherType, key_buf,key_len,iv_buf,iv_len); |
|
|
|
|
|
|
|
|
|
|
|
delete [] key_buf; |
|
|
|
|
|
delete [] iv_buf; |
|
|
|
|
|
|
|
|
return args.This(); |
|
|
return args.This(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -1314,10 +1328,10 @@ class Decipher : public ObjectWrap { |
|
|
// Hex encoding
|
|
|
// Hex encoding
|
|
|
// Do we have a previous hex carry over?
|
|
|
// Do we have a previous hex carry over?
|
|
|
if (cipher->incomplete_hex_flag) { |
|
|
if (cipher->incomplete_hex_flag) { |
|
|
char* complete_hex = (char*)malloc(len+2); |
|
|
char* complete_hex = new char[len+2]; |
|
|
memcpy(complete_hex, &cipher->incomplete_hex, 1); |
|
|
memcpy(complete_hex, &cipher->incomplete_hex, 1); |
|
|
memcpy(complete_hex+1, buf, len); |
|
|
memcpy(complete_hex+1, buf, len); |
|
|
free(buf); |
|
|
delete [] buf; |
|
|
buf = complete_hex; |
|
|
buf = complete_hex; |
|
|
len += 1; |
|
|
len += 1; |
|
|
} |
|
|
} |
|
@ -1330,13 +1344,14 @@ class Decipher : public ObjectWrap { |
|
|
} |
|
|
} |
|
|
HexDecode((unsigned char*)buf, len, (char **)&ciphertext, &ciphertext_len); |
|
|
HexDecode((unsigned char*)buf, len, (char **)&ciphertext, &ciphertext_len); |
|
|
|
|
|
|
|
|
free(buf); |
|
|
|
|
|
|
|
|
delete [] buf; |
|
|
buf = ciphertext; |
|
|
buf = ciphertext; |
|
|
len = ciphertext_len; |
|
|
len = ciphertext_len; |
|
|
|
|
|
|
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
unbase64((unsigned char*)buf, len, (char **)&ciphertext, &ciphertext_len); |
|
|
unbase64((unsigned char*)buf, len, (char **)&ciphertext, &ciphertext_len); |
|
|
free(buf); |
|
|
delete [] buf; |
|
|
buf = ciphertext; |
|
|
buf = ciphertext; |
|
|
len = ciphertext_len; |
|
|
len = ciphertext_len; |
|
|
|
|
|
|
|
@ -1351,7 +1366,7 @@ class Decipher : public ObjectWrap { |
|
|
|
|
|
|
|
|
unsigned char *out=0; |
|
|
unsigned char *out=0; |
|
|
int out_len=0; |
|
|
int out_len=0; |
|
|
int r = cipher->DecipherUpdate(buf, len,&out,&out_len); |
|
|
int r = cipher->DecipherUpdate(buf, len, &out, &out_len); |
|
|
|
|
|
|
|
|
Local<Value> outString; |
|
|
Local<Value> outString; |
|
|
if (out_len==0) { |
|
|
if (out_len==0) { |
|
@ -1363,12 +1378,14 @@ class Decipher : public ObjectWrap { |
|
|
if (enc == UTF8) { |
|
|
if (enc == UTF8) { |
|
|
// See if we have any overhang from last utf8 partial ending
|
|
|
// See if we have any overhang from last utf8 partial ending
|
|
|
if (cipher->incomplete_utf8!=NULL) { |
|
|
if (cipher->incomplete_utf8!=NULL) { |
|
|
char* complete_out = (char *)malloc(cipher->incomplete_utf8_len + out_len); |
|
|
char* complete_out = new char[cipher->incomplete_utf8_len + out_len]; |
|
|
memcpy(complete_out, cipher->incomplete_utf8, cipher->incomplete_utf8_len); |
|
|
memcpy(complete_out, cipher->incomplete_utf8, cipher->incomplete_utf8_len); |
|
|
memcpy((char *)complete_out+cipher->incomplete_utf8_len, out, out_len); |
|
|
memcpy((char *)complete_out+cipher->incomplete_utf8_len, out, out_len); |
|
|
free(out); |
|
|
delete [] out; |
|
|
free(cipher->incomplete_utf8); |
|
|
|
|
|
cipher->incomplete_utf8=NULL; |
|
|
delete [] cipher->incomplete_utf8; |
|
|
|
|
|
cipher->incomplete_utf8 = NULL; |
|
|
|
|
|
|
|
|
out = (unsigned char*)complete_out; |
|
|
out = (unsigned char*)complete_out; |
|
|
out_len += cipher->incomplete_utf8_len; |
|
|
out_len += cipher->incomplete_utf8_len; |
|
|
} |
|
|
} |
|
@ -1376,7 +1393,7 @@ class Decipher : public ObjectWrap { |
|
|
int utf8_len = LengthWithoutIncompleteUtf8((char *)out, out_len); |
|
|
int utf8_len = LengthWithoutIncompleteUtf8((char *)out, out_len); |
|
|
if (utf8_len<out_len) { // We have an incomplete ut8 ending
|
|
|
if (utf8_len<out_len) { // We have an incomplete ut8 ending
|
|
|
cipher->incomplete_utf8_len = out_len-utf8_len; |
|
|
cipher->incomplete_utf8_len = out_len-utf8_len; |
|
|
cipher->incomplete_utf8 = (unsigned char *)malloc(cipher->incomplete_utf8_len+1); |
|
|
cipher->incomplete_utf8 = new unsigned char[cipher->incomplete_utf8_len+1]; |
|
|
memcpy(cipher->incomplete_utf8, &out[utf8_len], cipher->incomplete_utf8_len); |
|
|
memcpy(cipher->incomplete_utf8, &out[utf8_len], cipher->incomplete_utf8_len); |
|
|
} |
|
|
} |
|
|
outString = Encode(out, utf8_len, enc); |
|
|
outString = Encode(out, utf8_len, enc); |
|
@ -1385,8 +1402,9 @@ class Decipher : public ObjectWrap { |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (out) free(out); |
|
|
if (out) delete [] out; |
|
|
free(buf); |
|
|
|
|
|
|
|
|
delete [] buf; |
|
|
return scope.Close(outString); |
|
|
return scope.Close(outString); |
|
|
|
|
|
|
|
|
} |
|
|
} |
|
@ -1416,13 +1434,15 @@ class Decipher : public ObjectWrap { |
|
|
if (enc == UTF8) { |
|
|
if (enc == UTF8) { |
|
|
// See if we have any overhang from last utf8 partial ending
|
|
|
// See if we have any overhang from last utf8 partial ending
|
|
|
if (cipher->incomplete_utf8!=NULL) { |
|
|
if (cipher->incomplete_utf8!=NULL) { |
|
|
char* complete_out = (char *)malloc(cipher->incomplete_utf8_len + out_len); |
|
|
char* complete_out = new char[cipher->incomplete_utf8_len + out_len]; |
|
|
memcpy(complete_out, cipher->incomplete_utf8, cipher->incomplete_utf8_len); |
|
|
memcpy(complete_out, cipher->incomplete_utf8, cipher->incomplete_utf8_len); |
|
|
memcpy((char *)complete_out+cipher->incomplete_utf8_len, out_value, out_len); |
|
|
memcpy((char *)complete_out+cipher->incomplete_utf8_len, out_value, out_len); |
|
|
free(cipher->incomplete_utf8); |
|
|
|
|
|
|
|
|
delete [] cipher->incomplete_utf8; |
|
|
cipher->incomplete_utf8=NULL; |
|
|
cipher->incomplete_utf8=NULL; |
|
|
|
|
|
|
|
|
outString = Encode(complete_out, cipher->incomplete_utf8_len+out_len, enc); |
|
|
outString = Encode(complete_out, cipher->incomplete_utf8_len+out_len, enc); |
|
|
free(complete_out); |
|
|
delete [] complete_out; |
|
|
} else { |
|
|
} else { |
|
|
outString = Encode(out_value, out_len, enc); |
|
|
outString = Encode(out_value, out_len, enc); |
|
|
} |
|
|
} |
|
@ -1430,7 +1450,7 @@ class Decipher : public ObjectWrap { |
|
|
outString = Encode(out_value, out_len, enc); |
|
|
outString = Encode(out_value, out_len, enc); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
free(out_value); |
|
|
delete [] out_value; |
|
|
return scope.Close(outString); |
|
|
return scope.Close(outString); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -1459,13 +1479,15 @@ class Decipher : public ObjectWrap { |
|
|
if (enc == UTF8) { |
|
|
if (enc == UTF8) { |
|
|
// See if we have any overhang from last utf8 partial ending
|
|
|
// See if we have any overhang from last utf8 partial ending
|
|
|
if (cipher->incomplete_utf8!=NULL) { |
|
|
if (cipher->incomplete_utf8!=NULL) { |
|
|
char* complete_out = (char *)malloc(cipher->incomplete_utf8_len + out_len); |
|
|
char* complete_out = new char[cipher->incomplete_utf8_len + out_len]; |
|
|
memcpy(complete_out, cipher->incomplete_utf8, cipher->incomplete_utf8_len); |
|
|
memcpy(complete_out, cipher->incomplete_utf8, cipher->incomplete_utf8_len); |
|
|
memcpy((char *)complete_out+cipher->incomplete_utf8_len, out_value, out_len); |
|
|
memcpy((char *)complete_out+cipher->incomplete_utf8_len, out_value, out_len); |
|
|
free(cipher->incomplete_utf8); |
|
|
|
|
|
cipher->incomplete_utf8=NULL; |
|
|
delete [] cipher->incomplete_utf8; |
|
|
|
|
|
cipher->incomplete_utf8 = NULL; |
|
|
|
|
|
|
|
|
outString = Encode(complete_out, cipher->incomplete_utf8_len+out_len, enc); |
|
|
outString = Encode(complete_out, cipher->incomplete_utf8_len+out_len, enc); |
|
|
free(complete_out); |
|
|
delete [] complete_out; |
|
|
} else { |
|
|
} else { |
|
|
outString = Encode(out_value, out_len, enc); |
|
|
outString = Encode(out_value, out_len, enc); |
|
|
} |
|
|
} |
|
@ -1473,7 +1495,7 @@ class Decipher : public ObjectWrap { |
|
|
outString = Encode(out_value, out_len, enc); |
|
|
outString = Encode(out_value, out_len, enc); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
free(out_value); |
|
|
delete [] out_value; |
|
|
return scope.Close(outString); |
|
|
return scope.Close(outString); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -1534,7 +1556,7 @@ class Hmac : public ObjectWrap { |
|
|
|
|
|
|
|
|
int HmacDigest(unsigned char** md_value, unsigned int *md_len) { |
|
|
int HmacDigest(unsigned char** md_value, unsigned int *md_len) { |
|
|
if (!initialised_) return 0; |
|
|
if (!initialised_) return 0; |
|
|
*md_value = (unsigned char*) malloc(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); |
|
|
HMAC_CTX_cleanup(&ctx); |
|
|
HMAC_CTX_cleanup(&ctx); |
|
|
initialised_ = false; |
|
|
initialised_ = false; |
|
@ -1576,6 +1598,8 @@ class Hmac : public ObjectWrap { |
|
|
|
|
|
|
|
|
bool r = hmac->HmacInit(*hashType, buf, len); |
|
|
bool r = hmac->HmacInit(*hashType, buf, len); |
|
|
|
|
|
|
|
|
|
|
|
delete [] buf; |
|
|
|
|
|
|
|
|
return args.This(); |
|
|
return args.This(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -1598,6 +1622,8 @@ class Hmac : public ObjectWrap { |
|
|
|
|
|
|
|
|
int r = hmac->HmacUpdate(buf, len); |
|
|
int r = hmac->HmacUpdate(buf, len); |
|
|
|
|
|
|
|
|
|
|
|
delete [] buf; |
|
|
|
|
|
|
|
|
return args.This(); |
|
|
return args.This(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -1627,11 +1653,11 @@ class Hmac : public ObjectWrap { |
|
|
// Hex encoding
|
|
|
// Hex encoding
|
|
|
HexEncode(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
HexEncode(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
free(md_hexdigest); |
|
|
delete [] md_hexdigest; |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
base64(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
base64(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
free(md_hexdigest); |
|
|
delete [] md_hexdigest; |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
outString = Encode(md_value, md_len, BINARY); |
|
|
outString = Encode(md_value, md_len, BINARY); |
|
|
} else { |
|
|
} else { |
|
@ -1639,7 +1665,7 @@ class Hmac : public ObjectWrap { |
|
|
"can be binary, hex or base64\n"); |
|
|
"can be binary, hex or base64\n"); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
free(md_value); |
|
|
delete [] md_value; |
|
|
return scope.Close(outString); |
|
|
return scope.Close(outString); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -1692,7 +1718,7 @@ class Hash : public ObjectWrap { |
|
|
|
|
|
|
|
|
int HashDigest(unsigned char** md_value, unsigned int *md_len) { |
|
|
int HashDigest(unsigned char** md_value, unsigned int *md_len) { |
|
|
if (!initialised_) return 0; |
|
|
if (!initialised_) return 0; |
|
|
*md_value = (unsigned char*) malloc(EVP_MAX_MD_SIZE); |
|
|
*md_value = new unsigned char[EVP_MAX_MD_SIZE]; |
|
|
EVP_DigestFinal_ex(&mdctx, *md_value, md_len); |
|
|
EVP_DigestFinal_ex(&mdctx, *md_value, md_len); |
|
|
EVP_MD_CTX_cleanup(&mdctx); |
|
|
EVP_MD_CTX_cleanup(&mdctx); |
|
|
initialised_ = false; |
|
|
initialised_ = false; |
|
@ -1769,11 +1795,11 @@ class Hash : public ObjectWrap { |
|
|
// Hex encoding
|
|
|
// Hex encoding
|
|
|
HexEncode(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
HexEncode(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
free(md_hexdigest); |
|
|
delete [] md_hexdigest; |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
base64(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
base64(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
free(md_hexdigest); |
|
|
delete [] md_hexdigest; |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
outString = Encode(md_value, md_len, BINARY); |
|
|
outString = Encode(md_value, md_len, BINARY); |
|
|
} else { |
|
|
} else { |
|
@ -1781,7 +1807,7 @@ class Hash : public ObjectWrap { |
|
|
"can be binary, hex or base64\n"); |
|
|
"can be binary, hex or base64\n"); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
free(md_value); |
|
|
delete [] md_value; |
|
|
return scope.Close(outString); |
|
|
return scope.Close(outString); |
|
|
|
|
|
|
|
|
} |
|
|
} |
|
@ -1904,6 +1930,8 @@ class Sign : public ObjectWrap { |
|
|
|
|
|
|
|
|
int r = sign->SignUpdate(buf, len); |
|
|
int r = sign->SignUpdate(buf, len); |
|
|
|
|
|
|
|
|
|
|
|
delete [] buf; |
|
|
|
|
|
|
|
|
return args.This(); |
|
|
return args.This(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -1934,6 +1962,8 @@ class Sign : public ObjectWrap { |
|
|
|
|
|
|
|
|
int r = sign->SignFinal(&md_value, &md_len, buf, len); |
|
|
int r = sign->SignFinal(&md_value, &md_len, buf, len); |
|
|
|
|
|
|
|
|
|
|
|
delete [] buf; |
|
|
|
|
|
|
|
|
if (md_len == 0 || r == 0) { |
|
|
if (md_len == 0 || r == 0) { |
|
|
return scope.Close(String::New("")); |
|
|
return scope.Close(String::New("")); |
|
|
} |
|
|
} |
|
@ -1947,11 +1977,11 @@ class Sign : public ObjectWrap { |
|
|
// Hex encoding
|
|
|
// Hex encoding
|
|
|
HexEncode(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
HexEncode(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
free(md_hexdigest); |
|
|
delete [] md_hexdigest; |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
base64(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
base64(md_value, md_len, &md_hexdigest, &md_hex_len); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
outString = Encode(md_hexdigest, md_hex_len, BINARY); |
|
|
free(md_hexdigest); |
|
|
delete [] md_hexdigest; |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
outString = Encode(md_value, md_len, BINARY); |
|
|
outString = Encode(md_value, md_len, BINARY); |
|
|
} else { |
|
|
} else { |
|
@ -2092,6 +2122,8 @@ class Verify : public ObjectWrap { |
|
|
|
|
|
|
|
|
int r = verify->VerifyUpdate(buf, len); |
|
|
int r = verify->VerifyUpdate(buf, len); |
|
|
|
|
|
|
|
|
|
|
|
delete [] buf; |
|
|
|
|
|
|
|
|
return args.This(); |
|
|
return args.This(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
@ -2137,12 +2169,12 @@ class Verify : public ObjectWrap { |
|
|
// Hex encoding
|
|
|
// Hex encoding
|
|
|
HexDecode(hbuf, hlen, (char **)&dbuf, &dlen); |
|
|
HexDecode(hbuf, hlen, (char **)&dbuf, &dlen); |
|
|
r = verify->VerifyFinal(kbuf, klen, dbuf, dlen); |
|
|
r = verify->VerifyFinal(kbuf, klen, dbuf, dlen); |
|
|
free(dbuf); |
|
|
delete [] dbuf; |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
} else if (strcasecmp(*encoding, "base64") == 0) { |
|
|
// Base64 encoding
|
|
|
// Base64 encoding
|
|
|
unbase64(hbuf, hlen, (char **)&dbuf, &dlen); |
|
|
unbase64(hbuf, hlen, (char **)&dbuf, &dlen); |
|
|
r = verify->VerifyFinal(kbuf, klen, dbuf, dlen); |
|
|
r = verify->VerifyFinal(kbuf, klen, dbuf, dlen); |
|
|
free(dbuf); |
|
|
delete [] dbuf; |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
} else if (strcasecmp(*encoding, "binary") == 0) { |
|
|
r = verify->VerifyFinal(kbuf, klen, hbuf, hlen); |
|
|
r = verify->VerifyFinal(kbuf, klen, hbuf, hlen); |
|
|
} else { |
|
|
} else { |
|
@ -2151,6 +2183,9 @@ class Verify : public ObjectWrap { |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
delete [] kbuf; |
|
|
|
|
|
delete [] hbuf; |
|
|
|
|
|
|
|
|
return scope.Close(Integer::New(r)); |
|
|
return scope.Close(Integer::New(r)); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|