You are viewing a plain text version of this content. The canonical link for it is here.
Posted to rampart-dev@ws.apache.org by sh...@apache.org on 2009/09/01 14:26:23 UTC
svn commit: r810001 - in /webservices/rampart/trunk/c/src/omxmlsec: buffer.c
openssl/crypt.c
Author: shankar
Date: Tue Sep 1 12:26:23 2009
New Revision: 810001
URL: http://svn.apache.org/viewvc?rev=810001&view=rev
Log:
(1) removing unwanted memcpy to improve performance
(2) code formatting
Modified:
webservices/rampart/trunk/c/src/omxmlsec/buffer.c
webservices/rampart/trunk/c/src/omxmlsec/openssl/crypt.c
Modified: webservices/rampart/trunk/c/src/omxmlsec/buffer.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/buffer.c?rev=810001&r1=810000&r2=810001&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/buffer.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/buffer.c Tue Sep 1 12:26:23 2009
@@ -23,81 +23,50 @@
#include <oxs_axiom.h>
#include <oxs_error.h>
-
-
struct oxs_buffer
{
- unsigned char* data;
+ unsigned char* data; /* will be adjusted based on oxs_buffer_remove_head method */
+ unsigned char* original_data; /* to free the data */
unsigned int size;
unsigned int max_size;
oxs_AllocMode alloc_mode;
};
-
-/******************** end of function headers *****************/
-
AXIS2_EXTERN oxs_buffer_t *AXIS2_CALL
-oxs_buffer_create(const axutil_env_t *env)
+oxs_buffer_create(
+ const axutil_env_t *env)
{
oxs_buffer_t *buffer = NULL;
- axis2_status_t status = AXIS2_FAILURE;
-
- AXIS2_ENV_CHECK(env, NULL);
buffer = (oxs_buffer_t*)AXIS2_MALLOC(env->allocator, sizeof(oxs_buffer_t));
- if (!buffer)
+ if(!buffer)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[rampart]insufficient memory. oxs buffer creation failed");
return NULL;
}
buffer->data = NULL;
+ buffer->original_data = NULL;
buffer->size = 0;
buffer->max_size = 0;
- buffer->alloc_mode = oxs_alloc_mode_double;
-
- status = oxs_buffer_set_max_size(buffer, env, OXS_BUFFER_INITIAL_SIZE);
- if (status == AXIS2_FAILURE)
- {
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_DEFAULT,
- "oxs_buffer_set_max_size");
- AXIS2_FREE(env->allocator, buffer);
- return NULL;
- }
-
+ buffer->alloc_mode = oxs_alloc_mode_double; /* increase the size exponentially */
return buffer;
-
-}
-
-AXIS2_EXTERN oxs_buffer_t *AXIS2_CALL
-oxs_buffer_dup(oxs_buffer_t *buffer, const axutil_env_t *env)
-{
- oxs_buffer_t *buf = NULL;
- axis2_status_t status = AXIS2_FAILURE;
-
- AXIS2_ENV_CHECK(env, NULL);
- buf = oxs_buffer_create(env);
- status = oxs_buffer_populate(buf, env, oxs_buffer_get_data(buffer, env), oxs_buffer_get_size(buffer, env));
- return buf;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
oxs_buffer_free(
oxs_buffer_t *buffer,
- const axutil_env_t *env
-)
+ const axutil_env_t *env)
{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- if (buffer->data)
+ if(buffer->original_data)
{
- AXIS2_FREE(env->allocator, buffer->data);
- buffer->data = NULL;
+ AXIS2_FREE(env->allocator, buffer->original_data);
}
- AXIS2_FREE(env->allocator, buffer);
+ AXIS2_FREE(env->allocator, buffer);
buffer = NULL;
-
return AXIS2_SUCCESS;
}
@@ -105,71 +74,27 @@
oxs_buffer_remove_head(
oxs_buffer_t *buffer,
const axutil_env_t *env,
- int size
-)
+ int size)
{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- /*If the size to be removed is less than the buffer size*/
- if (size < buffer->size)
- {
- if (!buffer->data)
- {
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "oxs_buffer_remove_head failed. data is NULL");
- return AXIS2_FAILURE;
- }
- buffer->size -= size;
- memmove(buffer->data, buffer->data + size, buffer->size);
- }
- else
- {
- buffer->size = 0;
- }
-
- /*If the buffer size is less than the max_size.*/
- if (buffer->size < buffer->max_size)
+ if(!buffer->data)
{
- if (!buffer->data)
- {
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "oxs_buffer_remove_head failed");
- return AXIS2_FAILURE;
- }
- memset(buffer->data + buffer->size, 0, buffer->max_size - buffer->size);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[rampart]oxs_buffer_remove_head failed. data is NULL");
+ return AXIS2_FAILURE;
}
- return AXIS2_SUCCESS;
-}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_buffer_remove_tail(
- oxs_buffer_t *buffer,
- const axutil_env_t *env,
- int size
-)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- if (size < buffer->size)
+ /*If the size to be removed is less than the buffer size*/
+ if(size < buffer->size)
{
buffer->size -= size;
+ buffer->max_size -= size; /* since we are not freeing the head, effective max_size is less */
+ buffer->data += size;
}
else
{
buffer->size = 0;
+ buffer->data = NULL;
}
- if (buffer->size < buffer->max_size)
- {
- if (buffer->data)
- {
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "");
- return AXIS2_FAILURE;
- }
- memset(buffer->data + buffer->size, 0, buffer->max_size - buffer->size);
- }
-
return AXIS2_SUCCESS;
}
@@ -179,25 +104,18 @@
oxs_buffer_t *buffer,
const axutil_env_t *env,
unsigned char *data,
- int size
-)
+ int size)
{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- if (size > 0)
+ if((!data) || (size <= 0))
{
- oxs_buffer_set_max_size(buffer, env, size);
- if (!data)
- {
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "data is NULL");
- return AXIS2_FAILURE;
- }
-
- memcpy(buffer->data, data, size);
- buffer->size = size;
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[rampart]Cannot populate data to oxs buffer. data is not valid");
+ return AXIS2_FAILURE;
}
+ oxs_buffer_set_max_size(buffer, env, size);
+ memcpy(buffer->data, data, size);
+ buffer->size = size;
return AXIS2_SUCCESS;
}
@@ -206,54 +124,18 @@
oxs_buffer_t *buffer,
const axutil_env_t *env,
unsigned char *data,
- int size
-)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- if (size > 0)
- {
- oxs_buffer_set_max_size(buffer, env, buffer->size + size);
- if (!data)
- {
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "data is NULL");
- return AXIS2_FAILURE;
- }
-
- memcpy(buffer->data + buffer->size, data, size);
- buffer->size += size;
- }
-
- return AXIS2_SUCCESS;
-}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_buffer_prepend(
- oxs_buffer_t *buffer,
- const axutil_env_t *env,
- unsigned char *data,
- int size
-)
+ int size)
{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- if (size > 0)
+ if((!data) || (size <= 0))
{
- if (!data)
- {
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "Passed data is NULL");
- return AXIS2_FAILURE;
- }
-
- buffer->max_size = buffer->size + size;
-
- memmove(buffer->data + size, buffer->data, buffer->size);
- memcpy(buffer->data, data, size);
- buffer->size += size;
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[rampart]Cannot append data to oxs buffer. data is not valid");
+ return AXIS2_FAILURE;
}
+ oxs_buffer_set_max_size(buffer, env, buffer->size + size);
+ memcpy(buffer->data + buffer->size, data, size);
+ buffer->size += size;
return AXIS2_SUCCESS;
}
@@ -261,50 +143,46 @@
oxs_buffer_read_file(
oxs_buffer_t *buffer,
const axutil_env_t *env,
- const axis2_char_t *filename
-)
+ const axis2_char_t *filename)
{
unsigned char fbuffer[1024];
- FILE* f;
- int len;
- axis2_status_t status = AXIS2_FAILURE;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ FILE * f;
+ int len;
f = fopen(filename, "rb");
- if (f == NULL)
+ if(!f)
{
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[rampart]cannot open file %s. Populating oxs buffer from file failed.", filename);
return AXIS2_FAILURE;
}
- while (1)
+ while(1)
{
len = fread(fbuffer, 1, sizeof(fbuffer), f);
- if (len == 0)
+ if(len == 0)
{
break; /*Stop reading*/
}
- else if (len < 0)
+ else if(len < 0)
{
fclose(f);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[rampart]Cannot read file %s. Populating oxs buffer from file failed.", filename);
return AXIS2_FAILURE;
}
- status = oxs_buffer_append(buffer, env, fbuffer, len);
- if (status == AXIS2_FAILURE)
+
+ if(oxs_buffer_append(buffer, env, fbuffer, len) != AXIS2_SUCCESS)
{
fclose(f);
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[rampart]Cannot append data to oxs buffer. Populating buffer from %s failed.",
+ filename);
return AXIS2_FAILURE;
}
-
- /*Alright so far everything is fine. So let's close the output*/
- fclose(f);
- return AXIS2_SUCCESS;
}/*End of while*/
+ fclose(f);
return AXIS2_SUCCESS;
}
@@ -312,24 +190,17 @@
oxs_buffer_set_size(
oxs_buffer_t *buffer,
const axutil_env_t *env,
- int size
-)
+ int size)
{
- axis2_status_t status = AXIS2_FAILURE;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
/*First we need to make sure that the max size has a value greater or equal value*/
- status = oxs_buffer_set_max_size(buffer, env, size);
- if (status == AXIS2_FAILURE)
+ if(oxs_buffer_set_max_size(buffer, env, size) != AXIS2_SUCCESS)
{
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "oxs_buffer_set_max_size failed");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart] oxs_buffer_set_max_size failed");
return AXIS2_FAILURE;
}
+
/*Now set the size*/
buffer->size = size;
-
return AXIS2_SUCCESS;
}
@@ -337,110 +208,164 @@
oxs_buffer_set_max_size(
oxs_buffer_t *buffer,
const axutil_env_t *env,
- int size
-)
+ int size)
{
unsigned char* new_data;
unsigned int new_size = 0;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- if (size <= buffer->max_size)
+ if(size <= buffer->max_size)
{
return AXIS2_SUCCESS;
}
- switch (buffer->alloc_mode)
+ switch(buffer->alloc_mode)
{
- case oxs_alloc_mode_exact:
- new_size = size + 8;
- break;
- case oxs_alloc_mode_double:
- new_size = 2 * size + 32;
- break;
+ case oxs_alloc_mode_exact:
+ new_size = size + 8;
+ break;
+ case oxs_alloc_mode_double:
+ new_size = 2 * size + 32;
+ break;
}
- if (new_size < OXS_BUFFER_INITIAL_SIZE)
+ if(new_size < OXS_BUFFER_INITIAL_SIZE)
{
new_size = OXS_BUFFER_INITIAL_SIZE;
}
- /*If there are data already then use realloc instead of malloc*/
- if (buffer->data)
+ new_data = (unsigned char*)AXIS2_MALLOC(env->allocator, new_size);
+ if(!new_data)
{
-#if 0
- new_data = (unsigned char*)AXIS2_REALLOC(env->allocator, buffer_impl->data, new_size);
-#else
-
- /*Assign extra amnt of memory*/
- new_data = (unsigned char*)AXIS2_MALLOC(env->allocator, new_size + buffer->max_size);
-
- /*Copy to newdata*/
- new_data = memcpy(new_data, buffer->data, buffer->size);
- AXIS2_FREE(env->allocator, buffer->data);
- buffer->data = NULL;
-
-#endif
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[rampart]cannot increase the size of oxs buffer. Insufficient memory");
+ return AXIS2_FAILURE;
}
- else
+
+ if(buffer->data)
{
- new_data = (unsigned char*)AXIS2_MALLOC(env->allocator, new_size);
+ /* Copy existing data */
+ new_data = memcpy(new_data, buffer->data, buffer->size);
}
- if (new_data == NULL)
+ if(buffer->original_data)
{
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "");
- return AXIS2_FAILURE;
+ /* we don't need the original data now. buffer->data is part of buffer->original_data.
+ * Since we are going to change the pointer of buffer->data, we can free original_data
+ */
+ AXIS2_FREE(env->allocator, buffer->original_data);
}
buffer->data = new_data;
+ buffer->original_data = new_data;
buffer->max_size = new_size;
- if (buffer->size < buffer->max_size)
- {
- if (buffer->data == NULL)
- {
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
- "");
- return AXIS2_FAILURE;
- }
- memset(buffer->data + buffer->size, 0, buffer->max_size - buffer->size);
- }
-
return AXIS2_SUCCESS;
}
AXIS2_EXTERN unsigned char* AXIS2_CALL
oxs_buffer_get_data(
oxs_buffer_t *buffer,
- const axutil_env_t *env
-)
+ const axutil_env_t *env)
{
- AXIS2_ENV_CHECK(env, NULL);
-
return buffer->data;
}
AXIS2_EXTERN int AXIS2_CALL
oxs_buffer_get_size(
oxs_buffer_t *buffer,
- const axutil_env_t *env
-)
+ const axutil_env_t *env)
{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
return buffer->size;
}
AXIS2_EXTERN int AXIS2_CALL
oxs_buffer_get_max_size(
oxs_buffer_t *buffer,
- const axutil_env_t *env
-)
+ const axutil_env_t *env)
+{
+ return buffer->max_size;
+}
+
+#if 0 /* this seemed to be not used 1.3.0*/
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+oxs_buffer_prepend(
+ oxs_buffer_t *buffer,
+ const axutil_env_t *env,
+ unsigned char *data,
+ int size)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- return buffer->max_size;
+ if(size > 0)
+ {
+ if(!data)
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA, "Passed data is NULL");
+ return AXIS2_FAILURE;
+ }
+
+ buffer->max_size = buffer->size + size;
+
+ memmove(buffer->data + size, buffer->data, buffer->size);
+ memcpy(buffer->data, data, size);
+ buffer->size += size;
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN oxs_buffer_t *AXIS2_CALL
+oxs_buffer_dup(
+ oxs_buffer_t *buffer,
+ const axutil_env_t *env)
+{
+ oxs_buffer_t *buf = NULL;
+
+ buf = oxs_buffer_create(env);
+ if(!buf)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]duplicating oxs buffer failed");
+ return NULL;
+ }
+
+ if(oxs_buffer_populate(buf, env, oxs_buffer_get_data(buffer, env),
+ oxs_buffer_get_size(buffer, env)) != AXIS2_SUCCESS)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[rampart]populating buffer failed. Cannot duplicate given oxs buffer");
+ oxs_buffer_free(buf, env);
+ return NULL;
+ }
+
+ return buf;
}
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+oxs_buffer_remove_tail(
+ oxs_buffer_t *buffer,
+ const axutil_env_t *env,
+ int size)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(size < buffer->size)
+ {
+ buffer->size -= size;
+ }
+ else
+ {
+ buffer->size = 0;
+ }
+ if(buffer->size < buffer->max_size)
+ {
+ if(buffer->data)
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA, "");
+ return AXIS2_FAILURE;
+ }
+ memset(buffer->data + buffer->size, 0, buffer->max_size - buffer->size);
+ }
+
+ return AXIS2_SUCCESS;
+}
+#endif
Modified: webservices/rampart/trunk/c/src/omxmlsec/openssl/crypt.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/openssl/crypt.c?rev=810001&r1=810000&r2=810001&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/openssl/crypt.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/openssl/crypt.c Tue Sep 1 12:26:23 2009
@@ -27,47 +27,52 @@
#define BUFSIZE 64
AXIS2_EXTERN int AXIS2_CALL
-openssl_bc_crypt(const axutil_env_t *env,
- openssl_cipher_ctx_t *oc_ctx,
- oxs_buffer_t *input_buf,
- oxs_buffer_t *output_buf,
- int encrypt)
+openssl_bc_crypt(
+ const axutil_env_t *env,
+ openssl_cipher_ctx_t *oc_ctx,
+ oxs_buffer_t *input_buf,
+ oxs_buffer_t *output_buf,
+ int encrypt)
{
- EVP_CIPHER_CTX ctx ;
+ EVP_CIPHER_CTX ctx;
oxs_key_t *okey = NULL;
-
unsigned char iv[EVP_MAX_IV_LENGTH];
unsigned char key[EVP_MAX_KEY_LENGTH];
- int ret =0, iv_length =0, block_length =0;
+ int ret = 0, iv_length = 0, block_length = 0;
int last = 0;
axis2_status_t status = AXIS2_FAILURE;
- /********************************Initialize*****************************************************/
-
+ /* Initialize */
iv_length = EVP_CIPHER_iv_length(openssl_cipher_ctx_get_cipher(oc_ctx, env));
- /*Get the IV. If encrypt, we need to generate the IV else we need to get it from the input buffer*/
- if(encrypt){
+ /* Get the IV. If encrypt, need to generate the IV. Else need to get it from the input buffer*/
+ if(encrypt)
+ {
/*Generate IV*/
ret = RAND_bytes(iv, iv_length);
/*IV to the output*/
status = oxs_buffer_append(output_buf, env, iv, iv_length);
- }else{ /*Decrypt*/
+ }
+ else
+ {
+ /* Decrypt */
/*If data is less than the IV its an error*/
- if(oxs_buffer_get_size(input_buf, env) < iv_length){
+ if(oxs_buffer_get_size(input_buf, env) < iv_length)
+ {
return -1;
}
/*Copy IV from the inbuf to our buffer*/
memcpy(iv, oxs_buffer_get_data(input_buf, env), iv_length);
/*And remove from input*/
- status = oxs_buffer_remove_head (input_buf, env, iv_length);
+ status = oxs_buffer_remove_head(input_buf, env, iv_length);
}
/*Get key*/
okey = openssl_cipher_ctx_get_key(oc_ctx, env);
- memcpy(key, oxs_key_get_data(okey, env), oxs_key_get_size(okey, env));
+ memcpy(key, oxs_key_get_data(okey, env), oxs_key_get_size(okey, env));
/*Set the IV */
- ret = EVP_CipherInit(&ctx, (EVP_CIPHER *)openssl_cipher_ctx_get_cipher(oc_ctx, env), key, iv, encrypt);
+ ret = EVP_CipherInit(&ctx, (EVP_CIPHER *)openssl_cipher_ctx_get_cipher(oc_ctx, env), key, iv,
+ encrypt);
#ifndef OXS_OPENSSL_096
EVP_CIPHER_CTX_set_padding(&ctx, 0);
#endif
@@ -76,19 +81,24 @@
block_length = EVP_CIPHER_block_size((EVP_CIPHER *)openssl_cipher_ctx_get_cipher(oc_ctx, env));
/*********************************Update***********************************************************/
- for(;;){/*Loop untill all the data are encrypted*/
+ for(;;)
+ {/*Loop untill all the data are encrypted*/
unsigned char *out_buf = NULL;
- int in_size =0, out_size =0, fixed=0, out_length = 0;
+ int in_size = 0, out_size = 0, fixed = 0, out_length = 0;
- if (0 == oxs_buffer_get_size(input_buf, env)) {
+ if(0 == oxs_buffer_get_size(input_buf, env))
+ {
last = 1;
break; /*Quit loop if NO DATA!!! */
}
/*If the amnt of data available is greater than the buffer size, we limit it to buffer size */
- if(oxs_buffer_get_size(input_buf, env) > BUFSIZE){
+ if(oxs_buffer_get_size(input_buf, env) > BUFSIZE)
+ {
in_size = BUFSIZE;
- }else{
+ }
+ else
+ {
in_size = oxs_buffer_get_size(input_buf, env);
}
@@ -97,46 +107,58 @@
/*Set the output buffer size*/
status = oxs_buffer_set_max_size(output_buf, env, out_size + in_size + block_length);
- out_buf = oxs_buffer_get_data(output_buf, env) + out_size; /*position to write*/
+ out_buf = oxs_buffer_get_data(output_buf, env) + out_size; /*position to write*/
#ifndef OXS_OPENSSL_096
/*If decrypt, we copy the final data to the out_buf of size block_length*/
- if(!ctx.encrypt) {
- if(ctx.final_used) {
+ if(!ctx.encrypt)
+ {
+ if(ctx.final_used)
+ {
memcpy(out_buf, ctx.final, block_length);
out_buf += block_length;
fixed = 1;
- }else {
- fixed = 0;
+ }
+ else
+ {
+ fixed = 0;
+ }
}
- }
#endif
- /* encrypt or decrypt */
- ret = EVP_CipherUpdate(&ctx, out_buf, &out_length, oxs_buffer_get_data(input_buf, env), in_size);
+ /* encrypt or decrypt */
+ ret = EVP_CipherUpdate(&ctx, out_buf, &out_length, oxs_buffer_get_data(input_buf, env),
+ in_size);
#ifndef OXS_OPENSSL_096
/*If decrypt, we copy data from the out_buf to the ctx.final*/
- if(!ctx.encrypt) {
- if (block_length > 1 && !ctx.buf_len) {
+ if(!ctx.encrypt)
+ {
+ if(block_length > 1 && !ctx.buf_len)
+ {
out_length -= block_length;
ctx.final_used = 1;
memcpy(ctx.final, &out_buf[out_length], block_length);
- } else {
+ }
+ else
+ {
ctx.final_used = 0;
}
- if (fixed) {
+ if(fixed)
+ {
out_length += block_length;
}
}
#endif
/* set correct output buffer size */
status = oxs_buffer_set_size(output_buf, env, out_size + out_length);
- if(AXIS2_FAILURE == status){
+ if(AXIS2_FAILURE == status)
+ {
return -1;
}
/* remove the processed block from input */
status = oxs_buffer_remove_head(input_buf, env, in_size);
- if(AXIS2_FAILURE == status){
+ if(AXIS2_FAILURE == status)
+ {
return -1;
}
@@ -145,20 +167,23 @@
/********************************Finalize*****************************************************/
/* by now there should be no input */
- if(last == 1){
+ if(last == 1)
+ {
unsigned char pad[EVP_MAX_BLOCK_LENGTH];
unsigned char *out_buf = NULL;
- int out_size = 0, out_length = 0, out_length2 = 0;
+ int out_size = 0, out_length = 0, out_length2 = 0;
out_size = oxs_buffer_get_size(output_buf, env);
- status = oxs_buffer_set_max_size(output_buf, env, out_size + 2 * block_length);
- out_buf = oxs_buffer_get_data(output_buf, env) + out_size;/*position to write*/
+ status = oxs_buffer_set_max_size(output_buf, env, out_size + 2 * block_length);
+ out_buf = oxs_buffer_get_data(output_buf, env) + out_size;/*position to write*/
#ifndef OXS_OPENSSL_096
- if(encrypt){
+ if(encrypt)
+ {
int pad_length;
pad_length = block_length - ctx.buf_len;
/* generate random padding */
- if(pad_length > 1) {
+ if(pad_length > 1)
+ {
ret = RAND_bytes(pad, pad_length - 1);
}
pad[pad_length - 1] = pad_length;
@@ -170,13 +195,18 @@
/* finalize */
ret = EVP_CipherFinal(&ctx, out_buf, &out_length2);
#ifndef OXS_OPENSSL_096
- if(!encrypt){
- if(block_length > 1) {
+ if(!encrypt)
+ {
+ if(block_length > 1)
+ {
out_length2 = block_length - ctx.final[block_length - 1];
- if(out_length2 > 0) {
+ if(out_length2 > 0)
+ {
memcpy(out_buf, ctx.final, out_length2);
- } else if(out_length2 < 0) {
- return(-1);
+ }
+ else if(out_length2 < 0)
+ {
+ return (-1);
}
}
}
@@ -187,9 +217,10 @@
EVP_CIPHER_CTX_cleanup(&ctx);
/*return the length of the outputbuf*/
return out_size + out_length + out_length2;
- }else{
+ }
+ else
+ {
return -1;
}
-
}