themis_status_t themis_secure_message_ec_encrypter_proceed(themis_secure_message_ec_t* ctx, const uint8_t* message, const size_t message_length, uint8_t* wrapped_message, size_t* wrapped_message_length){
THEMIS_CHECK_PARAM(ctx!=NULL);
size_t encrypted_message_length=0;
THEMIS_CHECK(themis_secure_cell_encrypt_seal(ctx->shared_secret, ctx->shared_secret_length, NULL, 0, message, message_length, NULL, &encrypted_message_length)==THEMIS_BUFFER_TOO_SMALL && encrypted_message_length!=0);
if(wrapped_message==NULL || (*wrapped_message_length)<(sizeof(themis_secure_encrypted_message_hdr_t)+encrypted_message_length)){
(*wrapped_message_length)=(sizeof(themis_secure_encrypted_message_hdr_t)+encrypted_message_length);
return THEMIS_BUFFER_TOO_SMALL;
}
themis_secure_encrypted_message_hdr_t* hdr=(themis_secure_encrypted_message_hdr_t*)wrapped_message;
hdr->message_hdr.message_type=THEMIS_SECURE_MESSAGE_EC_ENCRYPTED;
hdr->message_hdr.message_length=(uint32_t)(sizeof(themis_secure_encrypted_message_hdr_t)+encrypted_message_length);
encrypted_message_length=(*wrapped_message_length)-sizeof(themis_secure_encrypted_message_hdr_t);
THEMIS_CHECK(themis_secure_cell_encrypt_seal(ctx->shared_secret, ctx->shared_secret_length, NULL,0, message, message_length, wrapped_message+sizeof(themis_secure_encrypted_message_hdr_t), &encrypted_message_length)==THEMIS_SUCCESS);
(*wrapped_message_length)=encrypted_message_length+sizeof(themis_secure_encrypted_message_hdr_t);
return THEMIS_SUCCESS;
}
v8::Handle<v8::Value> SecureCellSeal::encrypt(const v8::Arguments& args) {
v8::HandleScope scope;
SecureCellSeal* obj = node::ObjectWrap::Unwrap<SecureCellSeal>(args.This());
size_t length=0;
const uint8_t* context=NULL;
size_t context_length=0;
if(args.Length()==2) {
context = (const uint8_t*)(node::Buffer::Data(args[1]));
context_length = node::Buffer::Length(args[1]);
}
if(themis_secure_cell_encrypt_seal(&(obj->key_)[0], obj->key_.size(), context, context_length, (const uint8_t*)(node::Buffer::Data(args[0])), node::Buffer::Length(args[0]), NULL, &length)!=THEMIS_BUFFER_TOO_SMALL) {
ThrowException(v8::Exception::Error(v8::String::New("Secure Cell (seal) failed encrypting")));
return scope.Close(v8::Undefined());
}
uint8_t* data=new uint8_t[length];
if(themis_secure_cell_encrypt_seal(&(obj->key_)[0], obj->key_.size(), context, context_length, (const uint8_t*)(node::Buffer::Data(args[0])), node::Buffer::Length(args[0]), data, &length)!=THEMIS_SUCCESS) {
ThrowException(v8::Exception::Error(v8::String::New("Secure Cell (seal) failed encrypting")));
delete data;
return scope.Close(v8::Undefined());
}
node::Buffer *buffer = node::Buffer::New((const char*)(data), length);
delete data;
return scope.Close(buffer->handle_);
}
themis_status_t themis_secure_message_rsa_encrypter_proceed(themis_secure_message_rsa_encrypter_t* ctx, const uint8_t* message, const size_t message_length, uint8_t* wrapped_message, size_t* wrapped_message_length){
size_t symm_passwd_length=0;
size_t seal_message_length=0;
THEMIS_CHECK(soter_asym_cipher_encrypt(ctx->asym_cipher, (const uint8_t*)"123", 3, NULL, &symm_passwd_length)==THEMIS_BUFFER_TOO_SMALL);
THEMIS_CHECK(themis_secure_cell_encrypt_seal((const uint8_t*)"123", 3, NULL, 0, message, message_length, NULL, &seal_message_length)==THEMIS_BUFFER_TOO_SMALL);
if(wrapped_message==NULL || (*wrapped_message_length)<(sizeof(themis_secure_rsa_encrypted_message_hdr_t)+symm_passwd_length+seal_message_length)){
(*wrapped_message_length)=(sizeof(themis_secure_rsa_encrypted_message_hdr_t)+symm_passwd_length+seal_message_length);
return THEMIS_BUFFER_TOO_SMALL;
}
// symm_init_ctx_t symm_passwd_salt;
uint8_t symm_passwd[THEMIS_RSA_SYMM_PASSWD_LENGTH];
THEMIS_CHECK(soter_rand(symm_passwd, sizeof(symm_passwd))==THEMIS_SUCCESS);
uint8_t* encrypted_symm_pass=wrapped_message+sizeof(themis_secure_rsa_encrypted_message_hdr_t);
size_t encrypted_symm_pass_length=symm_passwd_length;
THEMIS_CHECK(soter_asym_cipher_encrypt(ctx->asym_cipher, symm_passwd, sizeof(symm_passwd), encrypted_symm_pass, &encrypted_symm_pass_length)==THEMIS_SUCCESS);
(((themis_secure_rsa_encrypted_message_hdr_t*)wrapped_message)->encrypted_passwd_length)=(uint32_t)encrypted_symm_pass_length;
uint8_t* encrypted_message=encrypted_symm_pass+encrypted_symm_pass_length;
size_t encrypted_message_length=seal_message_length;
THEMIS_CHECK(themis_secure_cell_encrypt_seal(symm_passwd, sizeof(symm_passwd), NULL, 0, message, message_length, encrypted_message, &encrypted_message_length)==THEMIS_SUCCESS);
(*wrapped_message_length)=sizeof(themis_secure_rsa_encrypted_message_hdr_t)+encrypted_symm_pass_length+encrypted_message_length;
((themis_secure_encrypted_message_hdr_t*)wrapped_message)->message_hdr.message_type=THEMIS_SECURE_MESSAGE_RSA_ENCRYPTED;
((themis_secure_encrypted_message_hdr_t*)wrapped_message)->message_hdr.message_length=(uint32_t)(*wrapped_message_length);
return THEMIS_SUCCESS;
}
void SecureCellSeal::encrypt(const Nan::FunctionCallbackInfo<v8::Value>& args)
{
themis_status_t status = THEMIS_FAIL;
SecureCellSeal* obj = Nan::ObjectWrap::Unwrap<SecureCellSeal>(args.This());
if (args.Length() < 1) {
ThrowParameterError("Secure Cell (Seal) failed to encrypt",
"not enough arguments, expected message");
args.GetReturnValue().SetUndefined();
return;
}
if (!args[0]->IsUint8Array()) {
ThrowParameterError("Secure Cell (Seal) failed to encrypt",
"message is not a byte buffer, use ByteBuffer or Uint8Array");
args.GetReturnValue().SetUndefined();
return;
}
if (node::Buffer::Length(args[0]) == 0) {
ThrowParameterError("Secure Cell (Seal) failed to encrypt", "message is empty");
args.GetReturnValue().SetUndefined();
return;
}
size_t length = 0;
const uint8_t* context = NULL;
size_t context_length = 0;
if (args.Length() == 2) {
if (!args[1]->IsUint8Array()) {
ThrowParameterError("Secure Cell (Seal) failed to encrypt",
"context is not a byte buffer, use ByteBuffer or Uint8Array");
args.GetReturnValue().SetUndefined();
return;
}
context = (const uint8_t*)(node::Buffer::Data(args[1]));
context_length = node::Buffer::Length(args[1]);
}
status = themis_secure_cell_encrypt_seal(&(obj->key_)[0],
obj->key_.size(),
context,
context_length,
(const uint8_t*)(node::Buffer::Data(args[0])),
node::Buffer::Length(args[0]),
NULL,
&length);
if (status != THEMIS_BUFFER_TOO_SMALL) {
ThrowError("Secure Cell (Seal) failed to encrypt", status);
args.GetReturnValue().SetUndefined();
return;
}
uint8_t* data = (uint8_t*)(malloc(length));
status = themis_secure_cell_encrypt_seal(&(obj->key_)[0],
obj->key_.size(),
context,
context_length,
(const uint8_t*)(node::Buffer::Data(args[0])),
node::Buffer::Length(args[0]),
data,
&length);
if (status != THEMIS_SUCCESS) {
ThrowError("Secure Cell (Seal) failed to encrypt", status);
free(data);
args.GetReturnValue().SetUndefined();
return;
}
args.GetReturnValue().Set(Nan::NewBuffer((char*)(data), length).ToLocalChecked());
}
