| /* |
| * Copyright 2003-2004 The Apache Software Foundation. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <stdio.h> |
| #include <axis2_util.h> |
| #include <openssl_cipher_ctx.h> |
| #include <openssl_constants.h> |
| #include <openssl_cipher_property.h> |
| #include <oxs_error.h> |
| #include <openssl/evp.h> |
| #include <openssl/rand.h> |
| #include <openssl_util.h> |
| |
| |
| typedef struct openssl_cipher_ctx_impl |
| { |
| openssl_cipher_ctx_t ctx; |
| |
| const EVP_CIPHER* cipher; |
| axis2_char_t *key; |
| axis2_char_t *iv; |
| axis2_char_t *pad; |
| } |
| openssl_cipher_ctx_impl_t; |
| |
| /** Interface to implementation conversion macro */ |
| #define AXIS2_INTF_TO_IMPL(openssl_cipher_ctx) ((openssl_cipher_ctx_impl_t *)openssl_cipher_ctx) |
| |
| /******************* function headers ******************************/ |
| /* private functions */ |
| static void |
| openssl_cipher_ctx_init_ops( |
| openssl_cipher_ctx_t *ctx); |
| |
| /*public functions*/ |
| |
| axis2_status_t AXIS2_CALL |
| openssl_cipher_ctx_free(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env |
| ); |
| |
| const EVP_CIPHER* AXIS2_CALL |
| openssl_cipher_ctx_get_cipher(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env |
| ); |
| |
| axis2_char_t *AXIS2_CALL |
| openssl_cipher_ctx_get_key(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env |
| ); |
| |
| axis2_char_t *AXIS2_CALL |
| openssl_cipher_ctx_get_iv(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env |
| ); |
| |
| axis2_char_t *AXIS2_CALL |
| openssl_cipher_ctx_get_pad(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env |
| ); |
| |
| axis2_status_t AXIS2_CALL |
| openssl_cipher_ctx_set_cipher(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env, |
| const EVP_CIPHER* |
| ); |
| |
| axis2_status_t AXIS2_CALL |
| openssl_cipher_ctx_set_key(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env, |
| axis2_char_t *key |
| ); |
| |
| axis2_status_t AXIS2_CALL |
| openssl_cipher_ctx_set_iv(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env, |
| axis2_char_t *iv |
| ); |
| |
| axis2_status_t AXIS2_CALL |
| openssl_cipher_ctx_set_pad(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env, |
| axis2_char_t *pad |
| ); |
| |
| |
| |
| /******************* end of function headers ******************************/ |
| AXIS2_EXTERN openssl_cipher_ctx_t *AXIS2_CALL |
| openssl_cipher_ctx_create(const axis2_env_t *env) |
| { |
| openssl_cipher_ctx_impl_t *ctx_impl = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| ctx_impl = AXIS2_MALLOC(env->allocator, sizeof(openssl_cipher_ctx_impl_t)); |
| if (!ctx_impl) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| |
| ctx_impl->cipher = NULL; |
| ctx_impl->key = NULL; |
| ctx_impl->iv = NULL; |
| ctx_impl->pad = NULL; |
| |
| |
| |
| ctx_impl->ctx.ops = AXIS2_MALLOC(env->allocator, sizeof(openssl_cipher_ctx_ops_t)); |
| if (!ctx_impl->ctx.ops) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| openssl_cipher_ctx_free(&(ctx_impl->ctx), env); |
| return NULL; |
| } |
| |
| openssl_cipher_ctx_init_ops(&(ctx_impl->ctx)); |
| |
| return &(ctx_impl->ctx); |
| } |
| |
| /* private functions */ |
| static void |
| openssl_cipher_ctx_init_ops( |
| openssl_cipher_ctx_t *ctx) |
| { |
| ctx->ops->free = openssl_cipher_ctx_free ; |
| ctx->ops->get_cipher = openssl_cipher_ctx_get_cipher ; |
| ctx->ops->get_key = openssl_cipher_ctx_get_key ; |
| ctx->ops->get_iv = openssl_cipher_ctx_get_iv ; |
| ctx->ops->get_pad = openssl_cipher_ctx_get_pad ; |
| ctx->ops->set_cipher = openssl_cipher_ctx_set_cipher ; |
| ctx->ops->set_key_value = openssl_cipher_ctx_set_key ; |
| ctx->ops->set_iv = openssl_cipher_ctx_set_iv ; |
| ctx->ops->set_pad = openssl_cipher_ctx_set_pad ; |
| } |
| |
| /* public functions*/ |
| axis2_status_t AXIS2_CALL |
| openssl_cipher_ctx_free(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env |
| ) |
| { |
| openssl_cipher_ctx_impl_t * ctx_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| ctx_impl = AXIS2_INTF_TO_IMPL(ctx); |
| /*TODO Check how to free the EVP_CIPHER. Might be a problem if we try to free it here.*/ |
| if (ctx_impl->key) |
| { |
| AXIS2_FREE(env->allocator, ctx_impl->key); |
| ctx_impl->key = NULL; |
| } |
| |
| if (ctx_impl->iv) |
| { |
| AXIS2_FREE(env->allocator, ctx_impl->iv); |
| ctx_impl->iv = NULL; |
| } |
| |
| if (ctx_impl->pad) |
| { |
| AXIS2_FREE(env->allocator, ctx_impl->pad); |
| ctx_impl->pad = NULL; |
| } |
| |
| AXIS2_FREE(env->allocator, ctx_impl); |
| ctx_impl = NULL; |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| const EVP_CIPHER* AXIS2_CALL |
| openssl_cipher_ctx_get_cipher(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env) |
| { |
| openssl_cipher_ctx_impl_t * ctx_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| ctx_impl = AXIS2_INTF_TO_IMPL(ctx); |
| |
| return ctx_impl->cipher ; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| openssl_cipher_ctx_get_key(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env |
| ) |
| { |
| openssl_cipher_ctx_impl_t * ctx_impl = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| ctx_impl = AXIS2_INTF_TO_IMPL(ctx); |
| |
| return ctx_impl->key ; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| openssl_cipher_ctx_get_iv(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env |
| ) |
| { |
| openssl_cipher_ctx_impl_t * ctx_impl = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| ctx_impl = AXIS2_INTF_TO_IMPL(ctx); |
| |
| return ctx_impl->iv ; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| openssl_cipher_ctx_get_pad(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env |
| ) |
| { |
| openssl_cipher_ctx_impl_t * ctx_impl = NULL; |
| AXIS2_ENV_CHECK(env, NULL); |
| ctx_impl = AXIS2_INTF_TO_IMPL(ctx); |
| |
| return ctx_impl->pad; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| openssl_cipher_ctx_set_cipher(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env, |
| const EVP_CIPHER *cipher |
| ) |
| { |
| openssl_cipher_ctx_impl_t * ctx_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| |
| ctx_impl = AXIS2_INTF_TO_IMPL(ctx); |
| /*if (ctx_impl->cipher){ |
| AXIS2_FREE(env->allocator, ctx_impl->cipher); |
| ctx_impl->cipher = NULL; |
| } |
| */ |
| ctx_impl->cipher = cipher; |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| openssl_cipher_ctx_set_key(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env, |
| axis2_char_t *key |
| ) |
| { |
| openssl_cipher_ctx_impl_t * ctx_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, key, AXIS2_FAILURE); |
| |
| ctx_impl = AXIS2_INTF_TO_IMPL(ctx); |
| if (ctx_impl->key) |
| { |
| AXIS2_FREE(env->allocator, ctx_impl->key); |
| ctx_impl->key = NULL; |
| } |
| ctx_impl->key = AXIS2_STRDUP(key, env); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| openssl_cipher_ctx_set_iv(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env, |
| axis2_char_t *iv |
| ) |
| { |
| openssl_cipher_ctx_impl_t * ctx_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, iv, AXIS2_FAILURE); |
| |
| ctx_impl = AXIS2_INTF_TO_IMPL(ctx); |
| if (ctx_impl->iv) |
| { |
| AXIS2_FREE(env->allocator, ctx_impl->iv); |
| ctx_impl->iv = NULL; |
| } |
| ctx_impl->iv = AXIS2_STRDUP(iv, env); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| |
| axis2_status_t AXIS2_CALL |
| openssl_cipher_ctx_set_pad(openssl_cipher_ctx_t *ctx, |
| const axis2_env_t *env, |
| axis2_char_t *pad |
| ) |
| { |
| openssl_cipher_ctx_impl_t * ctx_impl = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, pad, AXIS2_FAILURE); |
| |
| ctx_impl = AXIS2_INTF_TO_IMPL(ctx); |
| if (ctx_impl->pad) |
| { |
| AXIS2_FREE(env->allocator, ctx_impl->pad); |
| ctx_impl->pad = NULL; |
| } |
| ctx_impl->pad = AXIS2_STRDUP(pad, env); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |