| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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 <oxs_constants.h> |
| #include <axutil_env.h> |
| #include <oxs_buffer.h> |
| #include <oxs_error.h> |
| #include <openssl_cipher_ctx.h> |
| #include <openssl_crypt.h> |
| #include <openssl_constants.h> |
| #include <oxs_axutil_utils.h> |
| |
| |
| |
| axutil_env_t *test_init() |
| { |
| axutil_allocator_t *allocator = axutil_allocator_init(NULL); |
| axutil_error_t *error = (axutil_error_t*)axis2_error_create(allocator); |
| axutil_env_t *env = axutil_env_create_with_error(allocator, error); |
| return env; |
| } |
| #if 0 |
| int decrypt(axutil_env_t *env, oxs_buffer_ptr in, unsigned char *key, unsigned char *iv) |
| { |
| openssl_evp_block_cipher_ctx_ptr bc_ctx = NULL; |
| oxs_buffer_ptr out = NULL; |
| oxs_buffer_ptr decoded_buf = NULL; |
| int ret; |
| |
| printf("--Decrypt started--------------------------------------------\n"); |
| |
| out = oxs_create_buffer(env, OXS_BUFFER_INITIAL_SIZE); |
| |
| bc_ctx = openssl_evp_block_cipher_ctx_create(env); |
| if (!bc_ctx) return(-1); |
| |
| /*Set the key*/ |
| bc_ctx->key = key; |
| bc_ctx->key_initialized = 1; |
| |
| /*Set the IV*/ |
| bc_ctx->iv = iv; |
| |
| ret = openssl_evp_block_cipher_ctx_init(env, bc_ctx, OPENSSL_DECRYPT, (unsigned char*)OPENSSL_EVP_aes_128_cbc); |
| if (ret < 0) |
| { |
| return -1; |
| } |
| |
| /*Now Decode */ |
| decoded_buf = oxs_base64_decode(env, in); |
| if (!decoded_buf) return -1; |
| |
| ret = openssl_block_cipher_crypt(env, bc_ctx, decoded_buf, out, OPENSSL_DECRYPT); |
| if (ret < 0) |
| { |
| return -1; |
| } |
| |
| printf("\nOut Size =\n %d ", out->size); |
| printf("\nOut Data =\n %s ", out->data); |
| |
| return (0); |
| } |
| #endif |
| int main() |
| { |
| FILE *outf; |
| /*FILE *outf2; |
| oxs_buffer_ptr encoded_buf = NULL; |
| oxs_buffer_ptr out = NULL; |
| */ |
| axutil_env_t *env = NULL; |
| oxs_buffer_ptr in = NULL; |
| axis2_char_t *plain_text = NULL; |
| unsigned char *out_main_buf = NULL , *out_main_buf2 = NULL; |
| |
| unsigned char key[EVP_MAX_KEY_LENGTH] = "012345670123456701234567"; |
| unsigned char iv[EVP_MAX_IV_LENGTH] = "01234567"; |
| |
| unsigned char *cipher_name = NULL; |
| |
| openssl_evp_block_cipher_ctx_ptr bc1_ctx = NULL; |
| openssl_evp_block_cipher_ctx_ptr bc2_ctx = NULL; |
| int ret, encrypted_len, decrypted_len; |
| |
| |
| env = test_init(); |
| printf("--Testing started Openssl Block Cipher--------------------------------------------\n"); |
| #if 0 |
| plain_text = "Upon successful completion, fread() returns the number of ...END" |
| "Upon successful completion, fread() returns the number of ...END"; |
| /*"This is an additional block :)";*/ |
| |
| #else |
| |
| plain_text = "PLAINTEXT"; |
| #endif |
| in = oxs_string_to_buffer(env, plain_text); |
| |
| cipher_name = (unsigned char*)OPENSSL_EVP_des_ede3_cbc; |
| |
| bc1_ctx = openssl_evp_block_cipher_ctx_create(env); |
| if (!bc1_ctx) return(-1); |
| /*Set the key*/ |
| bc1_ctx->key = key; /*axutil_strdup(key, env);*/ |
| bc1_ctx->key_initialized = 1; |
| /*Set the IV*/ |
| bc1_ctx->iv = axutil_strdup(env, iv); |
| ret = openssl_evp_block_cipher_ctx_init(env, bc1_ctx, |
| OPENSSL_ENCRYPT, cipher_name); |
| if (ret < 0) |
| { |
| printf("openssl_evp_block_cipher_ctx_init failed\n"); |
| return -1; |
| } |
| |
| ret = openssl_block_cipher_crypt(env, bc1_ctx, |
| in->data, strlen((char*)in->data), &out_main_buf, OPENSSL_ENCRYPT); |
| if (ret < 0) |
| { |
| printf("openssl_block_cipher_crypt OPENSSL_ENCRYPT failed\n"); |
| return -1; |
| } |
| encrypted_len = ret; |
| |
| printf("\nEncrypted data size =%d \n ", ret); |
| outf = fopen("outbuf", "wb"); |
| fwrite(out_main_buf, 1, ret, outf); |
| |
| /* out = oxs_create_buffer(env, ret);*/ |
| |
| /*********************Decrypt***********************/ |
| bc2_ctx = openssl_evp_block_cipher_ctx_create(env); |
| if (!bc2_ctx) return(-1); |
| /*Set the key*/ |
| bc2_ctx->key = key; /*axutil_strdup(key, env);*/ |
| bc2_ctx->key_initialized = 1; |
| /*Set the IV*/ |
| bc2_ctx->iv = axutil_strdup(env, iv); |
| ret = openssl_evp_block_cipher_ctx_init(env, bc2_ctx, |
| OPENSSL_DECRYPT, cipher_name); |
| if (ret < 0) |
| { |
| printf("openssl_evp_block_cipher_ctx_init failed\n"); |
| return -1; |
| } |
| |
| ret = openssl_block_cipher_crypt(env, bc2_ctx, |
| out_main_buf, encrypted_len, &out_main_buf, OPENSSL_DECRYPT); |
| |
| if (ret < 0) |
| { |
| printf("openssl_block_cipher_crypt OPENSSL_DECRYPT failed\n"); |
| return -1; |
| } |
| decrypted_len = ret; |
| |
| printf("\nDecrypted data[%d] %s\n ", ret, out_main_buf2); |
| |
| |
| #if 0 |
| /*Now Encode */ |
| encoded_buf = oxs_base64_encode(env, out); |
| |
| if (!encoded_buf) return -1; |
| |
| |
| printf("\nencrypted_encoded_buf Size =\n %d ", encoded_buf->size); |
| printf("\nencrypted_encoded_buf Data =\n %s ", encoded_buf->data); |
| |
| /*Now we need to decrypt*/ |
| /*===============================================================*/ |
| |
| ret = decrypt(env, encoded_buf, key, iv); |
| if (ret < 0) return -1; |
| #endif |
| return (0); |
| } |